# SLICES-RI Post5G blueprint handson

Damien Saucez

► To cite this version:

Damien Saucez. SLICES-RI Post5G blueprint handson. Latincom 2025 - IEEE Latin-American Conference on Communications, Nov 2025, Antigua, Guatemala. . hal-05477480

HAL Id: hal-05477480

https://inria.hal.science/hal-05477480v1

Submitted on 26 Jan 2026

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons CC BY 4.0 - Attribution - International License
## README.md

<figure><img src="image_2.png" /></figure>

link off

Damien Saucez authored 2 months ago

README.md 21.33 KiB

<figure><img src="image_3.png" /></figure>

slices RI

<figure><img src="image_4.png" /></figure>

* Introduction

* Get access to SLICES-RI

* Prepare your experimental environment

* Create a virtual machine in SLICES

* Deploy a virtual 5G Network

* Analyze logs, PCAP captures, and publish results

* Advanced Traffic Tests

* Remove all the docker containers

## Introduction

This hands-on tutorial introduces the fundamentals of the SLICES-RI Post-5G Blueprint.
Throughout the session, you will:

1. Get access to SLICES-RI;

2. Install and configure the SLICES Command Line Interface (CLI);

3. Create a virtual machine hosted within the SLICES-RI infrastructure;

4. Deploy a complete 5G network using the virtual machine, with a simulated RAN implemented through OpenAirInterface;

5. Explore the protocols and components involved in 5G communication;

6. Publish your experimental results to the SLICES Measurement Repository Service (MRS).
This tutorial is designed as a foundation for running experiments on SLICES or for learning and teaching 5G through hands-on practice. To ensure a clear understanding of each component, we demonstrate all steps explicitly rather than relying on the automation wrappers provided by SLICES.

For more advanced 5G scenarios involving **hardware radios**, refer to the [SLICES Post-5G Blueprint documentation](#).

**Reading time:** ~ 30mins

**Tutorial replication time:** ~ 1h30

## Get access to SLICES-RI

SLICES-RI is an open platform; however, you must first **register and activate your account** to gain access.

Visit [https://doc.slices-ri.eu/SupportingServices/getanaccount.html](https://doc.slices-ri.eu/SupportingServices/getanaccount.html) and follow the provided instructions to create your SLICES-RI account.

## Prepare your experimental environment

SLICES experimental activities are organized into *projects*, which are further divided into *experiments*.

A **project** acts as a namespace that groups experimental activities related to a specific topic. Projects can be shared among multiple users, and you can participate in as many projects as you wish.

An **experiment** isolates a specific experimental activity within a project. You can create as many experiments as needed inside your projects.

For this tutorial, we have created the `post5g-beta` project. Follow the [post5g-beta project registration link](https://docs.google.comforms/d/1v1Nqyj376rGvq677wP8xv7gQ) to join the project.

After registering for the project, you will gain access to all its services and storage, and you will be able to create your own experiments.

To interact with SLICES, you can use the [SLICES CLI](https://github.com/slices-ri/slices-ri-cli), a command-line tool implemented in Python that must be installed on your machine. The CLI is linked to your account, allowing you to manage all your resources and data directly.

We have also developed a tool to facilitate interaction with the [MRS](https://mrs.slices-ri.eu/).

To avoid affecting your system or user environment, it is recommended to install these tools within a Python virtual environment.

**NOTE:** On Ubuntu 22.04 and later, you can install the required dependencies for creating Python virtual environments with:
```bash
sudo apt install -y python3 python3-pip python3-venv
```

Let's create a Python virtual environment in the `slices-venv` directory:

```
python3 -m venv slices-venv
```

Activate the virtual environment with:

```
source slices-venv/bin/activate
```

**NOTE:** To exit a Python virtual environment, use the `deactivate` command.

Once the virtual environment is active, you can safely install the required tools.
pip install slices-cli --extra-index-url=https://doc.slices-ri.eu/pypi/
pip install git+https://gitlab.inria.fr/slices-ri/publish_results.git

To connect the CLI to your account, run the following command:

slices auth login

Follow the URL provided; it will redirect you to the SLICES-RI portal, where you can authorize
the CLI to access your account.

Create a virtual machine in SLICES

SLICES offers a variety of resources, including virtual machines. Virtual machines are
associated with *experiments*, which in turn are contained within *projects*.

Since we previously registered for the `post5g-beta` project, we need to instruct the SLICES CLI to use this project:

slices project use post5g-beta

Next, we can create an experiment named `experiment-tutorial`:

slices experiment create experiment-tutorial --duration 3h

**WARNING:** Experiments belong to projects, which act as namespaces. This means you cannot have two experiments with the same name within the same project at the same time.

With a project and an experiment set up, we can now create a virtual machine through the [Basic Infrastructure service](https://cloud.gentoo.org/).

For this tutorial, we will use the Gent 1 VM infrastructure site in Belgium, called `be-gent1-bi-vm1`. To make this transparent, set the following environment variables to reference the site and experiment:

export SLICES_BI_SITE_ID=be-gent1-bi-vm1
export SLICES_EXPERIMENT=experiment-tutorial

To access the virtual machine from your computer, you need to register your SSH public key with SLICES. If your key is located at `~/.ssh/id_ed25519.pub`, run:

slices pubkey register ~/.ssh/id_ed25519.pub

Note: If you don't have an SSH key pair yet, generate one using `ssh-keygen` and adapt the path to the key you just created.

Now, create a virtual machine named `vm1` using the `medium` flavor, which is sufficient for this tutorial and runs Ubuntu 24.04.1. The VM will automatically expire after 3 hours:

slices bi create vm1 --duration 3h --image "Ubuntu 24.04.1" --flavor medium

**WARNING:** Virtual machines belong to an experiment, so you cannot have two VMs with the same name in a single experiment. Change the VM name if a conflict occurs.

After deployment, check the status of all resources in your experiment with:
slices bi list-resources

Wait until the VM status shows `up`. Once it is `up`, your VM is ready for use.

Resources in experiment exp_expauth.ilabt.imec.be_01k8e16g5eem2r8pcc9ma2zhe

<table><thead><tr><td>ID</td><td>Name</td><td>Status</td><td>Created At</td></tr></thead><tbody><tr><td>r_be-gent1-bi-vm1_01k8e1d1rkes7v6sdfdksn65eb</td><td>vm1</td><td>up</td><td>2025-10-25T00:00:00Z</td></tr></tbody></table>

To connect to your VM from your computer, run:

slices bi ssh vm1

NOTE: To copy files between your machine and the VM, use `slices bi scp`.

You are now in a shell on your VM. For this tutorial, we will deploy the 5G core, RAN, and UEs using Docker, and use tools like **tshark** and **iperf**, as well as IP forwarding. To simplify setup, we provide a script that installs and configures all required dependencies: `utils/install_dependencies.sh`. In the VM run the following:

git clone https://gitlab.inria.fr/slices-ri/latincom-2025.git
cd latincom-2025
./utils/install_dependencies.sh

## Deploy a virtual 5G Network

We will deploy the 5G network as illustrated in the figure above. In this tutorial, we use OpenAirInterface to implement the 5G functions and Docker Compose to deploy them.

Examine the following files to understand how the functions are deployed (e.g., images) and interconnected (e.g., IP addresses):

* [cn/docker-depose.yml](#)

* [cn/docker-depose-ran.yml](#)

For the 5G core configuration (e.g., PLNM, slices, DNN...), see [cn/conf/config.yml](#).

The gNB configuration, including its connection to the core and radio parameters, is defined in [cn/conf/gnb.sa.bandn78.fr1.106PRB.rfsim.conf](#).

The UE configurations are stored in:

* [cn/conf/ue1.conf](#)

* [cn/conf/ue2.conf](#)

Finally, you can verify that the UEs are registered in the core network by checking the AuthenticationSubscription table in [cn/database/oai_db.sql](#).
Hardware Requirements:

1. A SLICES-RI virtual machine or bare metal server with minimum 8vCPU and 16GB of RAM and 4GB of storage. Most of the CPU and RAM is consumed by OAI gNB and NR-UE RFSimulator. Core network requires minimum 2vCPU and 4GB RAM.

2. Make sure your machine CPU supports `avx2`. You can check via `lscpu | grep avx2`.

3. Operating System: Ubuntu 20.04, 22.04, or 24.04.

**IMPORTANT** The steps in this section must be executed on the virtual machine.

We can now deploy the 5G core, RAN, and UEs using docker.

First, navigate to the directory containing all deployment and configuration files:

```
cd ~/latincom-2025/cn
```

**NOTE:** It is recommended to use `tmux` to manage multiple terminals within the VM.

In this tutorial, our goal is to capture the control traffic exchanged between the 5G functions.

In this network configuration:

* The **AMF** subscribes to **SMF registration events** via the **NRF** for SMF selection.

* The **SMF** registers with the **NRF**.

* The **SMF** subscribes to **UPF registration events** via the **NRF** for UPF discovery.

* The **UPF** registers with the **NRF**.

* **PFCP heartbeats** are exchanged between the SMF and UPF.

We will use `tshark` to capture all this control traffic.

Docker will create a network interface named `oaiworkshop`, on which the control-plane traffic will be captured. To create this network, run the following command, which uses `docker Compose` to deploy only the database service:

```
docker compose -f docker-compose.yml up -d mysql
```

Next, open a **second terminal** in your VM and start capturing traffic with `tshark`:

```
sudo tshark -i oaiworkshop -f "sctp or port 80 or port 8080 or port 8805 or port 8880"
```

This command will record all control traffic to `~/latincom-2025/results/traffic.pcap` on the VM.

**Return to the first terminal** (from which you deployed the database) and, ensuring you are still in the `~/latincom-2025/cn` directory, start the 5G core network:

```
docker compose -f docker-compose.yml up -d
```

Wait for the core network to fully start. To monitor its status, open a **third terminal** in your VM, navigate to the same directory, and run:

```
watch docker compose -f docker-compose.yml ps -a
```

When all components display a status of `Up` and `healthy`, the 5G core network is successfully running.

```
Every 2,0s: docker compose -f docker-compose.yml ps -a
```
<table><thead><tr><th>Name</th><th>Command</th><th>State</th></tr></thead><tbody><tr><td>mysql</td><td>docker-entrypoint.sh mysqld</td><td>Up (healthy)</td></tr><tr><td>oai-amf</td><td>/openair-amf/bin/oai_amf - ...</td><td>Up (healthy)</td></tr><tr><td>oai-ausf</td><td>/openair-ausf/bin/oai_ausf ...</td><td>Up (healthy)</td></tr><tr><td>oai-ext-dn</td><td>/bin/bash -c ip route add ...</td><td>Up (healthy)</td></tr><tr><td>oai-nrf</td><td>/openair-nrf/bin/oai_nrf - ...</td><td>Up (healthy)</td></tr><tr><td>oai-smf</td><td>/openair-smf/bin/oai_smf - ...</td><td>Up (healthy)</td></tr><tr><td>oai-udm</td><td>/openair-udm/bin/oai_udm - ...</td><td>Up (healthy)</td></tr><tr><td>oai-udr</td><td>/openair-udr/bin/oai_udr - ...</td><td>Up (healthy)</td></tr><tr><td>oai-upf</td><td>/openair-upf/bin/oai_upf - ...</td><td>Up (healthy)</td></tr></tbody></table>

Open a **fourth terminal** in your VM and display the AMF logs with:

```
docker logs oai-amf -f
```

Then, open a **fifth terminal** and display the SMF logs with:

```
docker logs oai-smf -f
```

Return to the **first terminal** (ensure you are in the `~/latincom-2025/cn` directory) and start the gNB by running:

```
docker compose -f docker-compose-ran.yml up -d oai-gnb
```

Monitor the **third terminal** until the gNB status becomes `healthy`. Meanwhile, observe the `oai-amf` logs in the **fourth terminal**—you should see output similar to the following:

<table><thead><tr><th>Index</th><th>Status</th><th>Global Id</th></tr></thead><tbody><tr><td>1</td><td>Connected</td><td>0xE000</td></tr></tbody></table>

Once the gNB is up and properly connected to the 5G core network, return to the **first terminal** (ensure you are in the `~/latincom-2025/cn` directory) and start the first UE:

```
docker compose -f docker-compose-ran.yml up -d oai-nr-ue
```

Monitor the logs of both `oai-amf` and `oai-smf`. If the connection is successfully established, the UE has obtained an IP address. This IP address, along with other PDU session details, is also logged on the SMF console (N1 interface).

In the AMF logs, you should observe output similar to the following:

<table><thead><tr><th>Index</th><th>5GMM State</th><th>IMSI</th><th>GUTI</th></tr></thead><tbody><tr><td>1</td><td>5GMM-REGISTERED</td><td>001010000000101</td><td>0010101004100000001</td></tr></tbody></table>

We can now verify that the UE is properly connected. The UE runs inside the `oai-nr-ue` container. To check whether it has received an IP address over its radio link, run the following command. The interface `oaitun_ue1` should appear with a valid IP address:
```
docker exec oai-nr-ue ip addr show dev oaitun_ue1
```

If an IP address has been assigned and a PDU session established, we can proceed to test traffic forwarding.

Access the UE container and try to ping external and internal endpoints:

```
docker exec -it oai-nr-ue bash
## ping towards the Internet
ping -I oaitun_ue1 8.8.8.8 -c4
## ping towards the UPF
ping -I oaitun_ue1 10.0.0.1 -c4
## ping towards the oai-traffic-generator
ping -I oaitun_ue1 192.168.70.135 -c4
```

(Optional) You can connect a second UE and monitor the `oai-amf` and `oai-smf` logs by opening a new terminal in the VM (ensure you are in the `~/latincom-2025/cn` directory) and running:

```
docker compose -f docker-compose-ran.yml up -d oai-nr-ue2
```

## Analyze logs, PCAP captures, and publish results

We can now stop the traffic capture and save all logs. In the **second terminal**, stop `tshark` by pressing `Ctrl+C`.

Next, we will collect logs from all 5G core components and the gNB:

```
for fct in oai-amf oai-ausf oai-ext-dn oai-nrf oai-smf oai-udm oai-udr oai-
do
docker logs $fct > ~/latincom-2025/results/$fct.stdout.log 2>~/latincom-
done
```

You can now retrieve all the results on your local machine using `scp` from your host:

```
mkdir -p results
slices bi scp -r vm1:latincom-2025/results/* results/
```

You can analyze the logs and open the `results/traffic.pcap` file with **Wireshark** to inspect the control-plane traffic.

You should observe the following message sequence twice, since two UEs were connected and each performed four pings.

These messages originate from the AMF capture:

1. NGSetupRequest, NGSetupResponse

2. InitialUEMessage, Registration Request, Registration Request

3. DownlinkNASTransport, Identity Request

4. UplinkNASTransport, Identity Response

5. DownlinkNASTransport, Authentication Request

6. UplinkNASTransport, Authentication Response

7. DownlinkNASTransport, Security Mode Command

8. UplinkNASTransport, Security Mode Complete, Registration Request

9. UERadioCapabilityInfoIndication

10. UplinkNASTransport, Registration Complete
11. PDU Session Establishment Request

12. PDUSessionResourceSetupRequest, DL NAS Transport, PDU Session Establishment Accept

13. PDUSessionResourceSetupResponse

14. UplinkNASTransport, UL NAS Transport, PDU Session Release Request (Regular deactivation)

15. PDUSessionResourceReleaseCommand, DL NAS Transport, PDU Session Release Command (Regular deactivation)

16. PDUSessionResourceReleaseResponse

17. UplinkNASTransport, UL NAS Transport, PDU Session Release Complete, Deregistration Request (UE originating)

18. SHUTDOWN

19. SHUTDOWN ACK

20. SHUTDOWN COMPLETE

For a detailed explanation of the 5G control-plane protocols, visit:
[https://www.sharetechnote.com/html/5G/5G_NGAP.html](https://www.sharetechnote.com/html/5G/5G_NGAP.html)

Finally, you can publish your dataset to the **Measurement Repository Service (MRS)**, an open registry for experimental data and metadata:

```bash
export ID_TOKEN=$(slices auth id-token "https://mrs-portal.slices-staging.com")
export DMI_TOKEN=$(slices auth get-for-audience "https://mrs-portal.slices-staging.com")
publish-dataset --data-location results
```

Follow the on-screen instructions. Once the upload is complete, your metadata and dataset will be available on the MRS dashboard.

We uploaded an example of dataset from this tutorial with the identifier [latincom-2025](https://github.com/latincom-labs/latincom-2025) and internal identifier [654](https://github.com/latincom-labs/latincom-2025/blob/main/README.md#downlink-direction)

## Advanced Traffic Tests

Now that we have verified that the UE, gNB and CN behave as expected, we can do some advanced traffic tests.

We are using `iperf3` to measure the bandwidth between the UE and the traffic-generator in the Core Network.

From a terminal in your VM, start the `iperf3` server on `oai-ex-dn` container (in the core network) to test UPLINK direction.

```bash
docker exec -it oai-ext-dn iperf3 -s
```

`iperf3` is not installed per default in the OAI NR UE, so we need to install it. From another terminal in your VM:

```bash
docker exec -it oai-nr-ue bash
apt update
apt install -y iperf3
```

Then, run `iperf3` client from the UE

```bash
iperf3 -B 10.0.0.2 -c 192.168.70.135
```

If we also want to test `DOWNLINK` direction, we can instruct `iperf3` to do so using `-R`:

```bash
iperf3 -B 10.0.0.2 -c 192.168.70.135 -R
```
## Remove all the docker containers

From a terminal in your VM, make sure you are always in `~/latincom-2025/cn` folder and run the following

```
docker compose -f docker-compose-ran.yml down -t2 -v
```

```
docker compose -f docker-compose.yml down -t2 -v
```