5G Cloud Native

With such a lot of focus around Standalone 5G deployment recently, we thought we’d focus this month on some of the terminology that’s often used for deploying 5G on a cloud infrastructure.

5G Cloud Native – Microservices and Containers

5G was designed from the outset to be cloud-native, in other words to be built around best-principles of cloud computing; this is absolutely essential in delivering the key services and applications enabled by 5G such as Network Slicing and MEC (Multi-Access Edge Computing).

Many mobile service providers around the world are moving towards the deployment of full Standalone 5G networks with a cloud-native core based around microservices within a containerized environment, but what are the implications of this approach?  Yes, there are gains in terms of flexibility, agility and scalability but there is also increased complexity that needs to be carefully managed.

Whilst there are other elements that encompass the whole cloud-native paradigm, microservices and containers essentially make up the foundation of this approach, so let’s take a look in more detail at the relationship between them and how they underpin 5G core networks.

Microservices

Before considering the key advantages of Microservices it is pertinent to consider how it differs from the monolithic approach. In terms of application development, a monolithic architecture is a single, unified, self-contained program that typically runs as a single logical executable file.  This approach has its benefits, but it is often seen as unsuitable for modern development which requires a greater degree of agility and may be deployed on distributed systems such as in a cloud environment.

Conversely, a microservices architecture is a distributed system that consists of smaller, modularized services each with a defined role that can scale with demand. We can effectively take the larger monolithic architecture and break it down into smaller components as can be seen in Figure 1.

If we take a closer look at the microservices architecture, we can see that the functional components of an application can be broken down into smaller microservices which are self-contained and termed ‘loosely coupled’ since they can be managed independently and changes to one service don’t affect another.

If one service is down, for example, is being updated, this does not impact the whole system. Another benefit to this is that it allows for different development teams to work on their own services independently without affecting other services.

As you can see in Figure 2, each service also has access to its own database – again, this ensures that services are loosely coupled and that a change to one service database does not affect the others. Each service can also use the type of database that is best suited to its needs. In this scenario the services communicate with each other via an API (Application Programming Interface) using HTTP (Hypertext Transfer Protocol) or some other form of messaging service (e.g., message broker or service mesh) and this is the model that the 5G SBA (Service-based Architecture) is based around.

Advantages and Disadvantages of Microservices

There are several advantages to microservices which are outlined in Figure 3, but it is important to consider that by their very nature microservices are more complex both in terms of design and deployment but also in terms of management and orchestration – and indeed this is where containers and container orchestration come into play.

Containers

Containers can be thought of as a method of packaging application code together with any dependencies (for example, runtime environments and libraries). One of the great benefits of containers is that applications can be built once and deployed anywhere – in other words, containers are portable across multiple deployment environments without the need for any reconfiguration.

Containers v Virtual machines

Containers are a virtualization solution that reduce the overhead of the operating system by running containers as isolated processes on the host OS, rather than within individual guest operating systems. So, in other words rather than requiring the full operating system, it simply accesses the resources it needs from the OS Kernel and these resources can be shared by multiple containers.

With containers, instead of virtualizing the underlying computer like a VM (Virtual Machine), just the OS itself is virtualized. The application sits in a container which is abstracted from the operating system and includes all the runtime dependencies required by the application. This configuration is much more resource efficient since a container shares the OS kernel among multiple containers rather than requiring the full OS environment, making them much more lightweight in comparison to virtual machines. Containers are much smaller in terms of file size and take seconds to start.

Containers also allow for greater portability since application code can be configured in one environment and deployed elsewhere without the need for reconfiguration. This eliminates many of the traditional headaches that developers typically face when migrating from one system to another.

The 5G core network functions are deployed as microservices within a containerized environment and typically managed using orchestration software such as Kubernetes deployed within a cloud environment (Public, Private or Hybrid). 

Figure 5 clarifies the difference between the use of virtualization and containers. With virtualization, applications and services are typically deployed using virtual machines which sit within guest operating systems which are abstracted from the hardware via a hypervisor – it should be noted that running multiple apps each within their own guest OS incurs considerable resource overhead.

In containerization, the application sits in a container which is abstracted from the operating system and includes all the runtime dependencies required by the application. This configuration is much more resource efficient, since a container shares the OS kernel among multiple containers rather than requiring the full OS environment making them much more lightweight. 

When comparing the two methods as shown in Figure 6, we can see that containers confer many advantages over virtual machines. The lightweight mature of containers makes it an ideal approach when deploying microservices applications on the cloud.

It is important to note however that what we gain in efficiency we lose in simplicity – containerized environments are typically more complex to manage and require the use of orchestration software.

Summary

So in summary, 5G core networks are built around a microservices architecture – the network functions within 5G are deployed as microservices within containerised network functions (though this may vary from vendor to vendor). This enables a much more flexible and standards-based approach which can be deployed using COTS (Commercial Off The Shelf) hardware. For more information on 5G and Cloud Computing, take a look at our 5G and Cloud Computing course.