Skip to main content

Configuration

This chapter explains how to configure the O-RAN/5G testbed using the provided YAML files, the API and how to run the testbed.

The checked-out repository has the following structure, which will be explained in detail in this section.

📁 repository
├── 📄 README.md
├── 📄 run_all.sh
├── 📄 run_api_endpoint.sh
├── 📁 docs
├── 📁 scripts
│   ├── 📁 config
│   │   ├── 📄 build_configuration.yml
│   │   ├── 📄 demo_configuration.yml
│   │   └── 📄 sample_traffic.yml
│   ├── 📁 src
│   │   ├── 📄 main.py
│   │   ├── 📁 api
│   │   ├── 📁 controller
│   │   ├── 📁 model
│   │   └── 📁 view
│   └── 📁 tests
├── 📁 patches
│   └── 📁 templates
│   └── 📁 patched

Central Configuration using a yml file​

All components of the O-RAN/5G testbed can be centrally configured using the YAML files located at:
scripts/config/.

The major configuration file is build_configuration.yml, which allows you to define the setup for all major components, including the Near-Real-Time RIC, 5G Core, gNodeB, and User Equipment (UE).

The following shows a sample build configuration file. The sections and fields are explained in detail below.

environment:
  core_implementation: "open5gs"
  gnb_implementation: "srs"
  ric_implementation: "oran_sc_ric"
  log_level: "INFO"
  log_dir: "logs"
  build_dir: "./repositories"
  docker_registry: "132.231.14.130:8080"
  tag_appendix: latest
  push_local_images: false


near_rt_ric:
  network:
    subnet: 10.0.2.0/24
    dbaas_ip: 10.0.2.12
    e2term_ip: 10.0.2.10
    e2mgr_ip: 10.0.2.11
    submgr_ip: 10.0.2.13
    appmgr_ip: 10.0.2.14
    rtmgr_sim_ip: 10.0.2.15
    xapp_runner_ip: 10.0.2.20
  vendors:
    - implementation: "oran_sc_ric" # Must correspond to RICImplementation(Enum) in model/ric_config.py
      repository: "https://github.com/srsran/oran-sc-ric.git"
      commit: "e44a7ce239b3c908e842163f1d57cbb4ba43fd0a"
      build_type: "docker"
      release: 'k'
    - implementation: "flexric"
      repository: "https://gitlab.eurecom.fr/mosaic5g/flexric.git"
      commit: "1f04cc558ebc8da9de6a620762bc02f5db4ecb4a"
      build_type: "docker"


5gc:
  network:
    5gc_ip: 10.53.1.2
    mongo_db_ip: 10.53.1.5
    subnet: 10.53.1.0/24
  vendors:
    - implementation: "open5gs" # must correspond to CoreImplementation(Enum) in model/core_config.py
      repository: "https://github.com/open5gs/open5gs.git"
      commit: "2b6369e9d997eb8eb158e3803e3ae4f4d207cd4d"
      build_type: "docker"
    - implementation: "open5gs_srs"
      repository: "https://github.com/srsran/srsRAN_Project.git"
      commit: "11c9bbabb69873752500d676f55e0034f6caa5c5"
      build_type: "docker"


ue:
  network:
    ip_range: 10.45.0.0/24
    gateway: 10.45.0.1
  ues:
    - ue1:
        implementation: "srs_4g"
        repository: "https://github.com/srsran/srsRAN_4G.git"
        commit: "1fab3df863f66fdb6c3b34f1b39e745dbcb12d5e"
        build_type: "docker"
        ue_type: "srsUE"
        ip_addr: 10.45.1.2
        srate: 11.52e6
        usim:
          mode: soft
          algo: milenage
          opc: 63bfa50ee6523365ff14c1f45f88737d
          key: 00112233445566778899aabbccddeeff
          imsi: 001010123456789
          imei: 353490069873319
        gateway:
          netns: ue1
          ip_devname: tun_srsue
          ip_netmask: 255.255.255.0
    - ue2:
        implementation: "srs_4g"
        repository: "https://github.com/srsran/srsRAN_4G.git"
        commit: "ec29b0c1ff79cebcbe66caa6d6b90778261c42b8"
        build_type: "docker"
        ue_type: "srsUE"
        ip_addr: 10.45.1.3
        srate: 11.52e6
        usim:
          mode: soft
          algo: milenage
          opc: 63bfa50ee6523365ff14c1f45f88737d
          key: 00112233445566778899aabbccddef00
          imsi: 001010123456790
          imei: 353490069873319
        gateway:
          netns: ue2
          ip_devname: tun_srsue
          ip_netmask: 255.255.255.0
    - ue3:
        implementation: "srs_4g"
        repository: "https://github.com/srsran/srsRAN_4G.git"
        commit: "ec29b0c1ff79cebcbe66caa6d6b90778261c42b8"
        build_type: "docker"
        ue_type: "srsUE"
        ip_addr: 10.45.1.4
        srate: 11.52e6
        usim:
          mode: soft
          algo: milenage
          opc: 63bfa50ee6523365ff14c1f45f88737d
          key: 00112233445566778899aabbccddef01
          imsi: 001010123456791
          imei: 353490069873319
        gateway:
          netns: ue3
          ip_devname: tun_srsue
          ip_netmask: 255.255.255.0

gnb:
  network:
    e2: 10.0.2.3
    ru_sdr: 10.45.1.1
    cu_cp: 10.53.1.3
  vendors:
    - implementation: "srs"
      repository: "https://github.com/srsran/srsRAN_Project.git"
      commit: "11c9bbabb69873752500d676f55e0034f6caa5c5"
      build_type: "docker"
      srate: 11.52e6
      tx_gain: 75
      rx_gain: 75

zmq_proxy:
  ip_addr: 10.45.1.200
  rx_ports:
    gnb: 2001
    ue1: 2100
    ue2: 2200
    ue3: 2300
  tx_ports:
    gnb: 2000
    ue1: 2101
    ue2: 2201
    ue3: 2301
  path_losses_db:
    ue1: 10
    ue2: 20
    ue3: 30
  slow_down_ratio: 4

This configuration file defines all available component implementations (e.g., 5G Core, Near-RT RIC) that can be used within the testbed. For each implementation, the associated Git repository and exact commit hash are specified, ensuring full reproducibility and straightforward version switching. Implementations are selected in the environment section, where the desired variant for each component can be chosen from the predefined list. This enables flexible experimentation with different software stacks without requiring any changes to the underlying codebase.

The environment-section includes the following fields:

  • core_implementation: Selects the 5G Core implementation to use (e.g., open5gs, open5gs_srs).
  • gnb_implementation: Selects the gNB implementation (e.g., srs).
  • ric_implementation: Selects the Near-RT RIC implementation (e.g., oran_sc_ric, flexric).
  • log_level: Sets the logging verbosity level (e.g., INFO, DEBUG).
  • log_dir: Directory where logs will be stored, relative to the root directory.
  • build_dir: Directory where components will be built, relative to the root directory.
  • docker_registry: (Optional) Custom Docker registry for pushing built images.
  • tag_appendix: (Optional) Appendix to append to Docker image tags (e.g., "latest", "v1.0").
  • push_local_images: Boolean flag to determine whether to push locally built Docker images to the specified registry.

The near_rt_ric contains the following fields:

  • network: Defines the network settings for the Near-RT RIC, including subnet and specific IP addresses for different RIC components (e.g., DBaaS, E2 Term, E2 Manager, Sub Manager, App Manager, RTMGR Simulator, xApp Runner).
  • vendors: A list of available Near-RT RIC implementations, each with its own configuration:

    • repository: Git repository URL for the RIC implementation.

    • commit: Specific commit hash to check out.

    • build_type: Specifies whether to use a native or Docker-based build.

      ⚠ī¸ Currently, only Docker-based builds are supported.

    • release: Specifies the ORAN-SC RIC release.

      ℹī¸ Our testbed supports O-RAN releases i to m. You can switch between releases by changing this field to the desired release letter (e.g., 'i', 'j', 'k', 'l', 'm').

    • implementation: Specifies the Near-Real-Time RIC implementation.

      Supported implementations include: oran_sc_ric, flexric. You can select the desired implementation by setting this field to the corresponding name (e.g., "oran_sc_ric" or "flexric"). A specific release can only be set for the ORAN-SC RIC implementation, as the FlexRIC implementation does not currently support multiple releases.

The 5g core network can be configured within the 5gc section:

  • network: Defines the network settings for the 5G Core, including the core IP address, MongoDB IP address, and subnet.
  • vendors: A list of available 5G Core implementations, each with its own configuration:
    • repository: Git repository URL for the 5G Core implementation.
    • commit: Specific commit hash to check out.
    • build_type: Specifies whether to use a native or Docker-based build.

      ⚠ī¸ Currently, only Docker-based builds are supported.

    • implementation: Specifies the 5G Core implementation.

      Supported implementations include: open5gs, open5gs_srs. You can select the desired implementation by setting this field to the corresponding name (e.g., "open5gs" or "open5gs_srs").

To setup a next generation node B the gnb section can be used:

  • network: Defines the network settings for the gNB, including IP addresses for the E2 interface, RU software-defined radio interface, and CU-CP interface.
  • vendors: A list of available gNB implementations, each with its own configuration:
    • repository: Git repository URL for the gNB implementation.
    • commit: Specific commit hash to check out.
    • build_type: Specifies whether to use a native or Docker-based build.

      ℹī¸ We currently support the SRSRAN project with the ZeroMQ interface build locally or using docker

    • srate: Sample rate in Hz, determining the baseband processing rate. Must match the UE sample rate for proper operation.
    • tx_gain: Transmit gain applied to the gNB radio output.
    • rx_gain: Receive gain applied to the gNB radio input.
    • implementation: Specifies the gNB implementation.

      Supported implementations include: srs. You can select the desired implementation by setting this field to the corresponding name (e.g., "srs").

Overview of Configuration Sections​

  • near RT RIC

    Configuration settings for the Near-Real-Time RIC implementation:

    near_rt_ric:
      build_type: "docker"
      implementation: "oran-sc-ric"
      release: 'i'
      network:
        subnet: 10.0.2.0/24
        dbaas_ip: 10.0.2.12
        e2term_ip: 10.0.2.10
        e2mgr_ip: 10.0.2.11
        submgr_ip: 10.0.2.13
        appmgr_ip: 10.0.2.14
        rtmgr_sim_ip: 10.0.2.15
        xapp_runner_ip: 10.0.2.20

  • 5G Core

    Specifies the configuration settings for the 5G Core (5GC).

    ⚠ī¸ Note: Currently, only the srsRAN_Project implementation is supported.

    5gc:
      build_type: "docker"
      implementation: "srs"
      ip_addr: 10.53.1.2
      subnet: 10.53.1.0/24

  • gNB:

    Specifies the configuration settings for the gNodeB (gNB).

    ⚠ī¸ Note: Currently, only the srsRAN_Project implementation is supported.

    gnb:
      type: "srs"
      build_type: "docker"
      ip_addr:
        e2: 10.0.2.3
        ru_sdr: 172.28.0.2
        cu_cp: 10.53.1.3
      srate: 11.52e6
      tx_gain: 75
      rx_gain: 75
    • type: Specifies the gNB implementation type (e.g., srs).
    • build_type: Determines whether to use a native or Docker-based build (docker).
    • ip_addr: IP addresses for the gNB interfaces:
      • e2: IP for the E2 interface connecting to the Near-RT RIC
      • ru_sdr: IP for the Radio Unit (RU) software-defined radio interface
      • cu_cp: IP for the CU-CP interface of the gNB
    • srate: Sample rate in Hz, determining the baseband processing rate.
    • tx_gain: Transmit gain applied to the gNB radio output.
    • rx_gain: Receive gain applied to the gNB radio input.

  • UE:

    Specifies the configuration settings for the User Equipment (UE).

    ℹī¸ī¸ Multiple UEs are supported, but each UE must have a unique name.

   - ue:
     implementation: "srs"
     name: "ue1"
     build_type: "docker"
     ue_type: "srsUE"
     ip_addr: 172.28.0.3
     srate: 11.52e6
     usim:
       mode: soft
       algo: milenage
       opc: 63BFA50EE6523365FF14C1F45F88737D
       k: 00112233445566778899aabbccddeeff
       imsi: 001010123456780
       imei: 353490069873319
     gateway:
       netns: ue1
       ip_devname: tun_srsue
       ip_netmask: 255.255.255.0
  • implementation: Specifies which UE software stack is used. Currently, srs is supported
    • name: Unique identifier for the UE instance. This is required when defining multiple UEs to avoid conflicts as this name is attached.
    • build_type: Determines the build method: docker (recommended) or native.

      ⚠ī¸ Native builds are only supported on Linux systems and may require additional dependencies.

    • srate (sample rate): Defines the baseband processing rate. Must match the gNB sample rate to ensure proper signal processing and synchronization.
    • usim: Sim card parameters for authentication and identification
    • gateway: Defines the UE's network interface and namespace
      • netns: Linux network namespace for isolating UE traffic.
      • ip_devname: Virtual interface device name (e.g., tun_srsue).
      • ip_netmask: Subnet mask for UE IP configuration.

Additional Notes​

  • Each UE must have a unique name and ip_addr to avoid conflicts.
  • You can define multiple UEs in the YAML, but currently only the first UE may be fully set up; multi-UE deployment support is planned.
  • Dockerized UEs simplify dependency management and allow multiple instances to run concurrently in isolated namespaces.
  • Ensure that the UE srate matches the gNB sample rate for proper RF and baseband operation.

Interactive Configuration​

An alternative way to set up the demo is via an interactive console, which guides you step by step through the configuration process.
In this mode, only the standard IP settings shown below are applied:

docker_interconnection_overview