---
# System prepended metadata

title: Basic Understanding of free5gmano and free5gc concepts.

---

# Basic Understanding of free5gmano and free5gc concepts.

The important parts of a 5G connection are:
1. UE (user equipment).
2. RAN (Radio Access Network).
3. 5G Core Network. 

For our research purpose at this stage we are using UERANSIM to simulate UE and RAN part.

Now,The core 5g network is made up of various network functions (in case of free5gc it is amf, ausf, udm, udr, upf, smf, pcf, mongodb, nrf, nssf).Each performing a specific task. Like AUSF here is for authentication and so on. These network functions are primarily written in go language (for free5gc and free5gmano).    

There are two ways of deployment:
1. Direct Deployment of core functions (free5gc idea):
        
    In the case of direct deployment, there are two ways to deploy:
        
    1.1. Deploy the core network on ubuntu directly (i.e. build the functions (go language) individually on ubuntu and run the functions individually).
    
    1.2. Deploy the core network functions on docker containers (using base image as golang:1.14.1) using docker compose command.
    
2. Deployment over 

    2.1 Docker Containers orchestrated by Kubernetes.
    
    2.2 OpenStack Cluster orchestrated by Kubernetes.
        
    The second (2.1 and 2.2) method over here follows the free5gmano deployment. It also supports network slicing concepts. The docker containers and openstack cluster are just plugins where the functions gets deployed.
    

Lets discuss them in detail:

### 1.1 Deploy core network over ubuntu directly.
 <<Deployed by @VinayPandhriwal>>
 
1. In this type of deployment each individual functions are built directly over ubuntu where go is installed (need to install if not present). 
2. The functions are written in go language and here they have to be built and deployed manually.
3. All the functions need to be deployed in orderly manner NRF > UDR > UDM > AUSF > NSSF > AMF > PCF > UPF > SMF > N3IWF.
4. Or they can be deployed via preexisting script ( which again follows the above order to run).
5. In this case the network management and orchestration needs to be done manually or using N3WiF function (where three interfaces are created for AMF, SMF and base connections).
6. Each function is running as individual application over your machine.
7. Here the ip address of AMF is the address of the server where it has been deployed. 
8. Firewall of the server especially needs to be taken into consideration for incoming and outgoing connections.

![](https://i.imgur.com/X71qxD3.png)


Deployment procedure can be found at link below:
https://hackmd.io/@Qm1GsHxWRcKE6Mgvmw7Yvg/r1P4-0tac

### 1.2 Deploy the core network functions over docker containers and using docker-compose.
<<Deployed by @Jeff>>

A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another.
A Docker container image is a lightweight, standalone, executable package of software that includes everything needed to run an application: code, runtime, system tools, system libraries and settings.

1. In this case we have our base image (ubuntu)(here vagrant-image is nothing but a VM running Ubuntu) on top which we install docker daemon (Pre installed in vagrant-image). 
2. Now, on that docker daemon we use a docker-compose command. The docker-compose command uses the docker-compose.yaml file to deploy different services (general term) (in our case functions). Now each service section in docker-compose file contains the information required to build and run the service(here functions). The link to docker compose file is attached below:
https://github.com/free5gc/free5gc-compose/blob/master/docker-compose.yaml

<<In https://github.com/free5gc/free5gc-compose you can see one folder for base and other folders for individual functions>>

<<In each functions folder.. there is a docker file which refrences to the base image folder present in the repo (uses base image)>>

<<The base image folder also consists of Docker file>>
    
<<The base image uses go as primary image and bascially configures go for deployment of functions>>

<<https://github.com/free5gc/free5gc-compose/blob/master/base/Dockerfile>>

    
3. Once initiated the docker-compose command, the control is now passed to each service (here function) where individual every function is configured as per data present in docker-compose.yaml and each function's Dockerfile.
4. With the help of dockerfile each function creates a container for itself each having their own base images.
5. In this case the network is managed by Network subsection present in docker-compose file.
6. Here the network is built for those docker containers and not for the Virtual Image (vagrant-image).
    
![](https://i.imgur.com/u3lfmns.png)

Deployment procedure can be found at : 
    https://hackmd.io/dv-nO3VjSYOry51_VJEsnQ
    
### 2.1 and 2.2 The free5gmano type deployment.
   <<Deployed by @VinayPandhariwal>> 
    
This is the type of deployment where instead of deploying it on ubuntu or just using docker containers, here we. introduce a powerful platform called Kubernetes. 
    
Kubernetes, also known as K8s, is an open-source system for automating deployment, scaling, and management of containerized applications.

Kubernetes here will take care for all the network management, deployment, redeployment, scaling, monitoring for us.

Since kubernetes comes with abilities to scale and manage network it becomes an important tool in case of Network Slicing.
    
Network Slicing:

So in 5g, the 3gpp community plans to use same interface as present in 5G core but in a more specialized and channelized way.
    
In Network Slicing we create multiple virtual interfaces based on the same hardware resources in backend to accomplish and meet the needs of specialized fields. 
    like: For communication purpose, for autonomous vehicles, for surgeries etc.
    
Now the requirement of each of them need not be the same. lets say for case of URLLC(ultra low latency) (vehicles) here we need to have more compute power so as to simulate zero latency. that requirement is not needed for the communication band.
    
So here we have multiple network slices where each of them will be serving different purposes. These individual slices will have the option scale as per the traffic and need.

Now a slice is made up of multiple containers, each container being used for different functions and a separate network being made for each slice. 
    
Multiple slices when deployed will make a network slicing system.
    
If only one slice is deployed it is equivalent to the 5G core kind of deployment as mentioned above in 1.1 and 1.2
    
The connection and process is discussed in below link.

![](https://i.imgur.com/jza7G7g.png)

The process can be viewed at:
    https://hackmd.io/@Qm1GsHxWRcKE6Mgvmw7Yvg/SJuVn3bCc