---
# System prepended metadata

title: <center>  FlexRIC </center>
tags: [Mini Projek]

---

# <center>  FlexRIC </center>

## Pengenalan singkat FlexRIC
<div style="text-align: justify;">

Repositori ini berisi emulator E2 Node Agent yang sesuai dengan O-RAN Alliance, nearRT-RIC, dan xApps yang ditulis dalam C/C++ dan Python. Repositori ini mengimplementasikan berbagai model layanan (standar O-RAN E2SM-KPM v2.01/v2.03/v3.00 dan E2SM-RC v1.03, serta NG/GTP, PDCP, RLC, MAC, SC, dan TC yang disesuaikan).

Tergantung pada model layanan, berbagai skema pengodean telah dikembangkan (ASN.1, flatbuffer, plain). Data indikasi yang diterima dalam xApp menggunakan basis data sqlite3 sebagai mekanisme persistensi untuk mengaktifkan aplikasi pemrosesan offline (misalnya, ML/AI).Selain itu, repositori ini mendukung E2AP v1.01/v2.03/v3.01 untuk semua SM.  
    
Jika Anda ingin mengetahui lebih lanjut tentang FlexRIC dan arsitektur aslinya, Anda dapat menemukan informasi lebih rinci di: Robert Schmidt, Mikel Irazabal, dan Navid Nikaein. 2021. FlexRIC: SDK untuk SD-RAN generasi berikutnya. Dalam Prosiding Konferensi Internasional ke-17 tentang Eksperimen dan Teknologi Jaringan yang Muncul (CoNEXT'21). Association for Computing Machinery, New York, NY, AS, 411–425. 
DOI: https://doi.org/10.1145/3485983.3494870. Salinan pdf tersedia di https://bit.ly/3uOXuCV
    

Berikut adalah daftar fitur yang tersedia dalam versi ini dibagi per komponen dan per model layanan:
    
| Komponen   | OAI-5g | SRS-5g | E2 agent emulators | nearRT-RIC | xApp C/C++ SDK | xApp Python SDK | O-RAN standardized |
|------------|--------|--------|---------------------|-------------|----------------|------------------|---------------------|
| E2SM-KPM   | Y      | Y      | Y                   | Y           | Y              | N                | Y                   |
| E2SM-RC    | Y      | Y      | Y                   | Y           | Y              | N                | Y                   |
| MAC        | Y      | N      | Y                   | Y           | Y              | Y                | N                   |
| RLC        | Y      | N      | Y                   | Y           | Y              | Y                | N                   |
| PDCP       | Y      | N      | Y                   | Y           | Y              | Y                | N                   |
| GTP        | Y      | N      | Y                   | Y           | Y              | Y                | N                   |
| SLICE      | N      | N      | Y                   | Y           | Y              | Y                | N                   |
| TC         | N      | N      | Y                   | Y           | Y              | N                | N                   |
</div>

# 1. Installation
    
## 1.1 Prasyarat
    
### 1.1.1. Kompiler GCC
<div style="text-align: justify;">    
    Pastikan Anda telah menginstal gcc-13 (gcc-10 dan 12 juga kompatibel). Ikuti langkah-langkah berikut:

```
sudo apt update -y
sudo apt upgrade -y
sudo apt install -y build-essential
sudo apt install -y gcc-13 g++-13 cpp-13
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-13 100 --slave /usr/bin/g++ g++ /usr/bin/g++-13 --slave /usr/bin/gcov gcov /usr/bin/gcov-13
sudo update-alternatives --config gcc # chose gcc-13

```
Catatan: gcc-11 tidak didukung di FlexRIC   
</div>

### 1.1.2 (opt.) Wireshark
    
 <div style="text-align: justify;">

Menurut spesifikasi O-RAN.WG3.E2GAP-v02.00, tidak ada port SCTP yang ditetapkan untuk protokol E2AP. Dalam implementasi kami, kami menggunakan nomor port 36421. Harap tambahkan konfigurasi berikut di Wireshark:

![WhatsApp Image 2025-07-04 at 16.41.29_67c126be](https://hackmd.io/_uploads/BJ5CWmrrgl.jpg)
</div> 

### 1.1.3 (opt.) Flatbuffer encoding  
<div style="text-align: justify;"> 
Kami juga menyediakan skema penyandian/dekode flatbuffers sebagai alternatif untuk ASN.1. Jika Anda ingin menggunakannya, ikuti petunjuk di https://github.com/dvidelabs/flatcc dan berikan jalur untuk lib dan sertakan saat memilihnya di `ccmake ..` dari direktori build
    
</div> 
    
## 1.2 Unduh dependensi yang diperlukan

### 1.2.1 Mandatory dependencies
    
```
sudo apt install libsctp-dev cmake-curses-gui libpcre2-dev
```
  
### 1.2.2 (opt.) Multi-language xApp requirements
<div style="text-align: justify;"> 
SWIG (setidaknya v.4.1).
Kami menggunakan SWIG sebagai generator antarmuka untuk mengaktifkan fitur multibahasa (misalnya, C/C++ dan Python) untuk xApps. Harap periksa versi SWIG Anda (misalnya, `swig-version`) dan instal dari awal jika perlu seperti yang dijelaskan di sini: https://swig.org/svn.html atau melalui kode di bawah ini:
    
```
git clone https://github.com/swig/swig.git
cd swig
git checkout release-4.1 
./autogen.sh
./configure --prefix=/usr/
make -j8
sudo make install
```
- Python dependency
```
sudo apt-get install python3.10-dev
```  
</div>
    
# 2. FlexRIC installation
    
## 2.1 Clone the FlexRIC repository
    
```
git clone https://gitlab.eurecom.fr/mosaic5g/flexric
cd flexric/
```
  
## 2.2 Build FlexRIC
    
```
mkdir build && cd build && cmake .. && make -j8
```

Jika Anda telah menginstal pustaka opsional dari bagian 1.2.2 (opsional) Persyaratan xApp multibahasa, jalankan perintah berikut:
```
mkdir build && cd build && cmake -DXAPP_MULTILANGUAGE=ON .. && make -j8
```
    

Versi yang tersedia saat ini:
    
| Versi E2SM-KPM | E2AP v1.01 | E2AP v2.03       | E2AP v3.01 |
|----------------|------------|------------------|------------|
| v2.01          | Y          | Y (default)      | Y          |
| v2.03          | Y          | Y (default)      | Y          |
| v3.00          | Y          | Y (default)      | Y          |

Jika Anda ingin mengubah versi default, silakan jalankan perintah ini:
    
```
mkdir build && cd build && cmake -DE2AP_VERSION=E2AP_VX -DKPM_VERSION=KPM_VY .. && make -j8
```
where X=1,2,3, and Y=2_01,2_03,3_00.
    

Jika Anda ingin membuat profil FlexRIC, atau hanya membutuhkan nearRT-RIC yang cepat, Anda harus membangun FlexRIC dalam mode rilis untuk mengaktifkan pengoptimalan kompiler:
    
```
mkdir build && cd build && cmake -DCMAKE_BUILD_TYPE=Release .. && make -j8
```
    
## 2.3 Installation of Service Models (SMs)
  
<div style="text-align: justify;">
Model layanan tersebut digunakan bersama oleh xApps dan RAN. Oleh karena itu, model layanan tersebut harus diinstal di tempat yang dapat diakses oleh RAN. Cara termudah adalah menginstalnya secara global, dengan mengetik:
    
```
sudo make install
```
    
Jalur instalasi default adalah `/usr/local/`. Oleh karena itu, pustaka model layanan ada di `/usr/local/lib/flexric` sementara berkas konfigurasi ada di `/usr/local/etc/flexric`.
Jika Anda ingin mengubah jalur instalasi default, silakan kompilasi sebagai berikut:    

- Catatan: Perintah `sudo make install` menginstal pustaka bersama yang mewakili Model Layanan. Setiap kali versi E2AP dan/atau E2SM-KPM dimodifikasi, perintah tersebut harus dijalankan lagi.

Periksa apakah semuanya berjalan dengan baik dengan menjalankan pengujian unit:

```
ctest -j8 --output-on-failure
```
    
</div>
    
 # 3. Service Models  
## 3.1 O-RAN

<div style="text-align: justify;">

Untuk pemahaman lebih dalam, kami sarankan pengguna FlexRIC membiasakan diri dengan spesifikasi O-RAN WG3 yang tersedia di halaman [spesifikasi O-RAN](https://orandownloadsweb.azurewebsites.net/specifications)
    
Spesifikasi berikut direkomendasikan:
    
- `O-RAN.WG3.E2GAP-v02.00` - Arsitektur nearRT-RIC & Aspek dan Prinsip Umum E2: penting untuk pemahaman umum tentang E2
- `O-RAN.WG3.E2AP-version` - Deskripsi protokol E2AP
- `O-RAN.WG3.E2SM-KPM-version` - Deskripsi Model Layanan E2SM-KPM
- `O-RAN.WG3.E2SM-RC-v01.03` - Deskripsi Model Layanan E2SM-RC
    
</div> 
    
### 3.1.1 E2SM-KPM
  
<div style="text-align: justify;">
Seperti disebutkan di bagian 2.2 Build FlexRIC, kami mendukung E2SM-KPM v2.01/v2.03/v3.00 yang semuanya menggunakan pengodean ASN.1.
</div>   
    
### 3.1.2 E2SM-RC

<div style="text-align: justify;">
Kami mendukung E2SM-RC v1.03 yang menggunakan pengkodean ASN.1. </div>
    
## 3.2 Custom Service Models 
    
<div style="text-align: justify;">
Selain itu, kami mendukung model layanan kustom, seperti MAC, RLC, PDCP, GTP, SLICE, dan TC (kontrol lalu lintas). Semua menggunakan pengodean biasa, yaitu, tanpa ASN.1, tetapi menulis data biner ke dalam pesan jaringan.
    Namun, perlu diketahui bahwa tidak semuanya didukung dengan OAI RAN, dan ditulis dalam bahasa C/Python. Untuk informasi lebih lanjut, silakan lihat tabel dalam pengantar FlexRIC.

</div>
    
# 4. Deployment
    
## 4.1 Bare-metal testbed 
    
<div style="text-align: justify;">
Secara opsional, jalankan Wireshark dan tangkap lalu lintas E2AP.

Mulai nearRT-RIC
Pastikan untuk mengatur alamat IP nearRT-RIC yang diinginkan `NEAR_RIC_IP` di `/usr/local/etc/flexric/flexric.conf.`
    
```
./build/examples/ric/nearRT-RIC
```
    
Selain itu, jika FlexRIC diinstal di jalur `<new-path>` khusus, harap tentukan jalur file konfigurasi dan model layanan sebagai berikut:
    
```
./build/examples/ric/nearRT-RIC -c <new-path>/etc/flexric/flexric.conf -p <new-path>/lib/flexric/
```
    
Hal yang sama berlaku untuk emulator agen E2.

- Start E2 agent emulators
    -- gNB-mono
  `./build/examples/emulator/agent/emu_agent_gnb`
    
    -- jika pemisahan CU/DU digunakan, mulai gNB sebagai berikut
`./build/examples/emulator/agent/emu_agent_gnb_cu`
`./build/examples/emulator/agent/emu_agent_gnb_du
`
    -- eNB
   ` ./build/examples/emulator/agent/emu_agent_enb`
    
Pastikan Anda melihat pesan Permintaan dan Respons Penyiapan E2 di Wireshark.

Dalam pesan Permintaan Penyiapan E2, simpul E2 mengirimkan daftar model layanan yang didukung ("kemampuannya"), seperti Fungsi RAN yang didukung E2SM-KPM dan E2SM-RC.

Karena bagian ini dikhususkan untuk pengujian dengan emulator agen E2, semua pesan INDIKASI RIC berisi data acak, karena tidak ada UE yang terhubung.

Variabel lingkungan `XAPP_DURATION` menimpa durasi xApp default selama 20 detik. Jika nilai negatif digunakan, durasi xApp dianggap tak terbatas.  

- Mulai C xApps yang berbeda

-- mulai monitor E2SM-KPM xApp - ambil pengukuran tingkat UE berdasarkan kondisi S-NSSAI `(1, 0xffffff)`; `O-RAN.WG3.E2SM-KPM-version` bagian 7.4.5 - LAPORAN Gaya Layanan 4 ("Berdasarkan kondisi umum, tingkat UE")  
```
XAPP_DURATION=20 ./build/examples/xApp/c/monitor/xapp_kpm_moni # not supported by emu_agent_enb
```
 
-- start the E2SM-RC monitor xApp - based on ORAN.WG3.E2SM-RC-v01.03 specification, aperiodic subscriptions to:
    
    REPORT Service Style 1 ("Message Copy") - section 7.4.2


* RRC Message (RRC Reconfiguration, Measurement Report, Security Mode Complete, RRC Setup Complete)
* UE ID (when RRC Setup Complete and/or F1 UE Context Setup Request detected)
* REPORT Service Style 4 ("UE Information") - section 7.4.5
* UE RRC State Change (RRC connected, RRC inactive, RRC idle)
    
```
XAPP_DURATION=20 ./build/examples/xApp/c/monitor/xapp_rc_moni # not supported by eNB as per spec
```
 
* mulai kontrol E2SM-RC xApp - fungsi kontrol RAN "QoS flow mapping configuration" (misalnya membuat DRB baru); `ORAN.WG3.E2SM-RC-v01.03` bagian 7.6.2 - Gaya Layanan KONTROL 1 ("Radio Bearer Control")
    
```
XAPP_DURATION=20 ./build/examples/xApp/c/kpm_rc/xapp_kpm_rc # not supported by emu_agent_enb
```
  
* mulai monitor (MAC + RLC + PDCP + GTP) xApp
```
XAPP_DURATION=20 ./build/examples/xApp/c/monitor/xapp_gtp_mac_rlc_pdcp_moni
```  
    
* start the MAC control xApp
```
./build/examples/xApp/c/ctrl/xapp_mac_ctrl # not supported by emu_agent_enb and emu_agent_gnb_cu
```

* mulai slicing xApp
    
```
./build/examples/xApp/c/slice/xapp_slice_moni_ctrl
```
  
* mulai TC xApps
```
./build/examples/xApp/c/tc/xapp_tc_all
./build/examples/xApp/c/tc/xapp_tc_codel
./build/examples/xApp/c/tc/xapp_tc_ecn
./build/examples/xApp/c/tc/xapp_tc_osi_codel
./build/examples/xApp/c/tc/xapp_tc_partition 36422 # second argument must be the xApp port
```
    
* jika opsi `XAPP_MULTILANGUAGE` diaktifkan, jalankan python xApps:
    
```
# (MAC + RLC + PDCP + GTP) monitor xApp
XAPP_DURATION=20 python3 build/examples/xApp/python3/xapp_mac_rlc_pdcp_gtp_moni.py
# slicing xApp
python3 build/examples/xApp/python3/xapp_slice_moni_ctrl.py
cd build/examples/xApp/python3 && ./watch_slice_stats # to observe real-time stats for network slices
```  
  
Beberapa xApps dapat dijalankan secara paralel.
    
Pada titik ini, FlexRIC berfungsi dengan benar di komputer Anda dan Anda telah menguji kapabilitas multi-agen, multi-xApp, dan multi-bahasa.
Latensi yang Anda amati di monitor xApp adalah latensi dari Agen E2 ke nearRT-RIC dan xApp. Di komputer modern, latensi harus kurang dari 200 mikrodetik atau 50x lebih cepat dari latensi nearRT-RIC minimum yang ditetapkan O-RAN, yaitu rentang (10 ms - 1 detik).
Oleh karena itu, FlexRIC sangat cocok untuk kasus penggunaan dengan persyaratan latensi sangat rendah.
Selain itu, semua data yang diterima di xApp juga ditulis ke `/tmp/xapp_db` jika pemrosesan data offline diinginkan (misalnya, aplikasi Pembelajaran Mesin/Kecerdasan Buatan). Anda menelusuri data menggunakan misalnya, sqlitebrowser.
Silakan periksa folder contoh untuk kasus penggunaan xApp yang berfungsi lainnya.
    
</div>
    
## 4.2 (opt.) Docker testbed
    
<div style="text-align: justify;">
FlexRIC didukung pada distribusi berikut: Ubuntu, Red Hat, dan Rocky Linux. Anda dapat membuat gambar sebagai berikut:
    
```
# Ubuntu
docker buildx build --no-cache --target oai-flexric --tag oai-flexric:dev --file docker/Dockerfile.flexric.ubuntu .
# Red Hat
docker buildx build --no-cache --target oai-flexric --tag oai-flexric:dev --file docker/Dockerfile.flexric.rhel .
# Rocky Linux
docker buildx build --no-cache --target oai-flexric --tag oai-flexric:dev --file docker/Dockerfile.flexric.rocky .
```
Untuk mereproduksi pengujian bare-metal di lingkungan docker, ikuti langkah-langkah berikut:
    
```
cd docker
docker compose up -d
```
</div>   
    
# 5. integrasi dengan RAN and example of deployment
    
## 5.1 integrasi dengan OpenAirInterface 5G RAN
Ikuti petunjuk https://gitlab.eurecom.fr/oai/openairinterface5g/-/blob/develop/openair2/E2AP/README.md.
    
## 5.2 integrasi dengan srsRAN 5G RAN
Ikuti petunjuk https://docs.srsran.com/projects/project/en/latest/tutorials/source/near-rt-ric/source/index.html.
    
## 5.3 Integrasi dengan Keysight RICtest
    
<div style="text-align: justify;">
OAI nearRT-RIC dengan xApp `flexric/examples/xApp/c/keysight/xapp_keysight_kpm_rc.c` berhasil diuji dengan [emulator RAN RICtest Keysight](https://www.keysight.com/us/en/product/P8828S/rictest-ran-intelligent-controller-test-solutions.html), seperti yang ditunjukkan pada O-RAN PlugFest Fall 2023.
    
Silakan temukan informasi lebih lanjut di tautan berikut (hanya tersedia untuk anggota Aliansi O-RAN):
    
*[recorded PlugFest session](https://oranalliance.atlassian.net/wiki/download/attachments/2907668584/O-RAN_PFFall2023_venue05.mp4). FlexRIC is shown after 3 hours 33 minutes (3:33:00).

*[accompanying presentation](https://oranalliance.atlassian.net/wiki/download/attachments/2907668584/O-RAN_PFFall2023_venue05.pdf); the mentioned xApp is shown starting at slide 190.
</div>
    
## 5.4  Integration with ns-O-RAN simulator
    
<div style="text-align: justify;">
Dikembangkan oleh WIoT di Universitas Northeastern, ns-O-RAN adalah platform simulasi sumber terbuka pertama yang menggabungkan tumpukan protokol 4G/5G fungsional dalam ns-3 dengan antarmuka E2 yang sesuai dengan O-RAN.


Menyadari peran penting simulator ns-O-RAN, tim Orange Innovation Egypt berhasil mengintegrasikan OAI nearRT-RIC dengan simulator ini, yang menghasilkan terciptanya kerangka pengujian xApp baru yang diberi nama ns-O-RAN-flexric. Ringkasan penyempurnaan yang dilakukan pada setiap repositori diilustrasikan dalam diagram di bawah ini:
    

# II. XAPP BACKGROUND
    
## A. Tinjauan Umum O-RAN
    
Arsitektur O-RAN, yang diilustrasikan pada Gambar 1, terstruktur di sekitar komponen-komponen utama dan antarmuka terbuka yang membagi fungsionalitas stasiun basis menjadi tiga bagian utama: unit radio (RU), unit terdistribusi (DU), dan unit pusat (CU). Unit Radio Terbuka (O-RU) memainkan peran penting dalam menangani sinyal frekuensi radio di dekat antena, sementara Unit Terdistribusi Terbuka (O-DU) memproses sinyal-sinyal ini sebelum mentransmisikannya ke jaringan. Dalam segmen Unit Pusat Terbuka (O-CU), Unit Pusat-Bidang Kontrol (O-CU-CP) O-RAN mengelola fungsi dan protokol kontrol, sementara Unit Pusat-Bidang Pengguna (O-CU-UP) O-RAN berfokus pada operasi yang berpusat pada pengguna dan optimalisasi transmisi data. Kecerdasan dalam arsitektur ORAN diwujudkan oleh Near-Real-time (RT)
    
![WhatsApp Image 2025-07-10 at 08.42.35_b1097f8f](https://hackmd.io/_uploads/Skh4N6nBxg.jpg)

RAN Intelligent Controller (RIC) dan Non-RT RIC. NearRT RIC mengoptimalkan komponen jaringan dengan waktu respons yang cepat, menghosting xApps berbasis layanan mikro, untuk meningkatkan efisiensi spektrum. Di sisi lain, Non-RT RIC mengorkestrasikan fungsi RAN secara cerdas secara non-real-time, mendukung manajemen sumber daya radio, optimalisasi prosedur, dan panduan kebijakan. RIC ini beroperasi secara terpusat dalam kerangka kerja Service Management and Orchestration (SMO), yang memungkinkan kontrol non-real-time elemen dan sumber daya RAN melalui aplikasi khusus yang disebut rApps. Antarmuka Y1 memainkan peran penting dalam menyediakan akses ke data analisis RAN untuk proses internal maupun eksternal. Antarmuka ini penting untuk berbagi informasi mendalam yang dapat meningkatkan kinerja dan pengambilan keputusan jaringan.
    
## B. Literature Review
    
Konsep xApps dalam arsitektur O-RAN,
yang dikembangkan sejak pembentukan Aliansi O-RAN pada 2018, menjawab kebutuhan akan kemampuan pemrograman dan fleksibilitas dalam lingkungan jaringan akses radio (RAN). Berkembang menjadi komponen integral, xApps memungkinkan orkestrasi cerdas dan pengambilan keputusan dinamis secara mendekati waktu nyata, mendorong solusi RAN yang terbuka dan cerdas melalui kolaborasi dan upaya standardisasi yang berkelanjutan. Seiring xApps menjadi elemen utama kerangka kerja O-RAN, xApps mengantarkan era baru fleksibilitas dan kecerdasan dalam lingkungan RAN. Tinjauan pustaka ini mengkaji penelitian dan kemajuan yang ada dalam mengamankan xApps untuk memastikan perannya dalam mengorkestrasi dan mengoptimalkan fungsi RAN tetap tangguh dan andal.
    
Penerapan xApps dalam arsitektur O-RAN menimbulkan tantangan keamanan yang unik karena arsitekturnya yang modular dan berbasis cloud. Para peneliti menekankan pentingnya langkah-langkah keamanan yang kuat untuk mengatasi potensi kerentanan dan serangan, terutama dalam sifat dinamis dan terdistribusi penerapan xApps. Mekanisme autentikasi sangat penting untuk memastikan bahwa hanya xApps resmi yang berinteraksi dengan Near-RT RIC dan komponen O-RAN lainnya. Studi mengusulkan berbagai protokol autentikasi yang disesuaikan dengan lingkungan xApps, dengan fokus pada verifikasi identitas yang aman. Integritas dan kerahasiaan data dalam xApps, yang bertanggung jawab atas kontrol fungsi RAN, dijaga melalui teknik enkripsi dan mekanisme verifikasi integritas. Tantangan keamanan yang terkait dengan antarmuka arah utara dan selatan ditangani dengan protokol komunikasic aman yang diusulkan, mekanisme kontrol akses, dan sistem deteksi intrusi. Kerangka kerja perpesanan internal dalam xApps, yang menangani mitigasi konflik dan manajemen siklus hidup aplikasi, diamankan melalui praktik-praktik seperti pengkodean aman, enkripsi pesan, dan mekanisme audit, yang meningkatkan keamanan xApps secara keseluruhan. 
    
## C. xApps Architecture
    
Arsitektur xApps dalam kerangka kerja O-RAN melibatkan desain modular dan fleksibel yang memungkinkanaplika si ini berjalan pada RIC near-RT seperti yang ditunjukkan pada gambar 2. xApp adalah aplikasi perangkat lunak yang diperluas, yang secara khusus dirancang untuk berjalan pada RIC. Aplikasi ini, yang terdiri dari satu atau lebih layanan mikro, secara jelas menentukan data yang digunakan dan disediakannya pada tahap onboarding. Yang terpenting, xApp tetap independen dari RIC Near-RT dan dapat disediakan oleh pihak ketiga. Antarmuka E2 menyediakan tautan langsung antara xApp dan fungsionalitas RAN.
    
![WhatsApp Image 2025-07-10 at 11.48.09_3ac234fe](https://hackmd.io/_uploads/BJgQ8T2Heg.jpg)

## D. Catagories of xApps

xApps sangat penting dalam meningkatkan dan mengelola berbagai aspek jaringan komunikasi nirkabel. Aplikasi ini menyediakan cara yang sederhana dan efektif untuk mengelola sumber daya radio, mobilitas, kualitas layanan, dan keamanan. Kemampuan xApps untuk terhubung silang sangat penting untuk memastikan integrasi dan interoperabilitas yang lancar di berbagai domain teknologi. Hal ini menjadikannya sebagai komponen penting dari jaringan komunikasi nirkabel.
    
1) Radio Resource Management (RRM): Kategori RRM dari xApps berfokus pada pengoptimalan spektrum dan sumber daya radio. Ini mencakup alokasi pita frekuensi secara dinamis, optimalisasi tingkat daya, dan pengelolaan interferensi untuk meningkatkan kinerja jaringan secara keseluruhan. xApps dalam kategori ini mengalokasikan pita frekuensi secara dinamis berdasarkan permintaan jaringan saat ini, tingkat interferensi, dan faktor-faktor lainnya. Hal ini memastikan bahwa setiap sel beroperasi pada frekuensi yang meminimalkan interferensi dan memaksimalkan throughput. xApps mengoptimalkan penjadwalan transmisi dalam jaringan. Ini melibatkan pengalokasian slot waktu dan sumber daya spektrum ke berbagai pengguna atau perangkat, dengan mempertimbangkan faktor-faktor seperti prioritas data, kebutuhan pengguna, dan kondisi jaringan untuk meningkatkan efisiensi spektral secara keseluruhan.
    
2) Mobility management: xApps manajemen mobilitas memastikan perpindahan yang lancar saat perangkat melintasi jaringan. Ini termasuk mengawasi proses perpindahan antar sel atau stasiun pangkalan yang berbeda, meminimalkan putus panggilan, dan menjaga konektivitas tanpa gangguan bagi pengguna seluler. xApps iniMemantau pergerakan perangkat dalam jaringan, menyediakan informasi lokasi secara real-time. Data ini penting untuk berbagai layanan berbasis lokasi dan untuk mengoptimalkan sumber daya jaringan berdasarkan kepadatan pengguna dan pola pergerakan. Tujuan utama Mobility Management xApps adalah menyediakan konektivitas berkelanjutan bagi perangkat seluler. Aplikasi ini memfasilitasi transisi yang lancar antar berbagai teknologi akses radio, memastikan pengguna menikmati konektivitas yang lancar, bahkan selama perpindahan perangkat.
    
3) quality of service (QoS): xApps berbasis QoS mengontrol dan mengelola lalu lintas jaringan untuk memaksimalkan efisiensi sumber daya. Mereka memprioritaskan berbagai jenis lalu lintas berdasarkan berbagai kriteria seperti persyaratan aplikasi, preferensi pengguna, dan perjanjian tingkat layanan. xApps ini mendeteksi kemacetan jaringan dan menerapkan metode mitigasi untuk mencegah penurunan layanan. Strategi tersebut meliputi perubahan alokasi sumber daya, pengalihan lalu lintas, dan penerapan perangkat penghindaran kemacetan. Mereka juga mengoptimalkan latensi, jitter, dan kehilangan paket untuk memenuhi persyaratan aplikasi waktu nyata seperti panggilan suara dan streaming video, sehingga meningkatkan kualitas layanan secara keseluruhan di seluruh jaringan.
    
4) Security: xApps yang berfokus pada keamanan mengelola autentikasi pengguna, memastikan bahwa hanya perangkat dan pengguna yang berwenang yang memiliki akses ke jaringan. Merinci pembentukan mekanisme autentikasi, yang dapat berkisar dari kombinasi nama pengguna/sandi sederhana hingga pendekatan yang lebih canggih seperti verifikasi biometrik. xApps keamanan ini juga menyediakan teknik enkripsi untuk melindungi saluran komunikasi dalam arsitektur RAN. Langkah ini krusial untuk melindungi informasi sensitif dan mencegah akses atau intersepsi transmisi data yang tidak sah. Lebih lanjut, xApps keamanan meningkatkan keamanan keseluruhan arsitektur RAN dengan menerapkan berbagai langkah keamanan. Ini termasuk kontrol akses, deteksi intrusi, dan mekanisme respons. Bersama-sama, langkah-langkah ini memperkuat jaringan terhadap potensi ancaman dan kerentanan keamanan.
    
![WhatsApp Image 2025-07-10 at 11.53.49_1ff091bf](https://hackmd.io/_uploads/B1yuwanrll.jpg)
    
![WhatsApp Image 2025-07-10 at 11.55.26_4ca4fc14](https://hackmd.io/_uploads/HJ8Cwa2rxe.jpg)


