5G and Azure for Operators

Azure for Operators brings cloud capabilities to telecommunications networks, enabling 5G deployments, network function virtualization, and edge computing at scale. This post explores how Azure supports modern telecom infrastructure.

Azure for Operators Overview

Azure Private 5G Core

# Private 5G Core deployment configuration
apiVersion: mobile.azure.com/v1
kind: MobileNetwork
metadata:
  name: enterprise-5g-network
  location: eastus
spec:
  mobileCountryCode: "001"
  mobileNetworkCode: "01"
  simPolicy:
    defaultSlice:
      sliceConfiguration:
        name: default-slice
        sst: 1
        sd: "0x010203"
---
apiVersion: mobile.azure.com/v1
kind: PacketCoreControlPlane
metadata:
  name: packet-core-cp
spec:
  mobileNetwork: enterprise-5g-network
  platform:
    type: AKS-HCI
  coreNetworkTechnology: 5GC
  sku: G0
  sites:
    - name: factory-site-1
      accessNetwork:
        attachedDataNetworks:
          - name: internet
            dnsAddresses:
              - 8.8.8.8
              - 8.8.4.4
            userPlaneDataInterface:
              name: N6
              ipv4Address: 10.1.1.1
              ipv4Gateway: 10.1.1.254

Network Function Virtualization

// Managing virtualized network functions
public class NetworkFunctionManager
{
    private readonly ArmClient _armClient;

    public async Task DeployVirtualNetworkFunctionAsync(
        string resourceGroup,
        string nfName,
        NetworkFunctionConfig config)
    {
        var vnf = new NetworkFunctionData(config.Location)
        {
            NetworkFunctionContainerConfigurations = new List<NetworkFunctionContainerConfiguration>
            {
                new NetworkFunctionContainerConfiguration
                {
                    Name = "vnf-container",
                    Properties = new ContainerNetworkFunctionConfigurationProperties
                    {
                        CustomNetworkInterfaceConfigurations = config.NetworkInterfaces
                    }
                }
            },
            Sku = new SkuInfo(config.SkuName),
            VendorName = config.VendorName,
            VendorProvisioningState = "Provisioning"
        };

        var subscription = await _armClient.GetDefaultSubscriptionAsync();
        var resourceGroupResource = subscription.GetResourceGroup(resourceGroup);

        // Deploy the VNF
        await resourceGroupResource.GetNetworkFunctions()
            .CreateOrUpdateAsync(WaitUntil.Completed, nfName, vnf);
    }

    public async Task ScaleNetworkFunctionAsync(
        string resourceGroup,
        string nfName,
        int targetInstances)
    {
        // Scale the VNF instances
        var vnf = await GetNetworkFunctionAsync(resourceGroup, nfName);

        vnf.Data.SkuName = targetInstances switch
        {
            <= 2 => "Small",
            <= 5 => "Medium",
            _ => "Large"
        };

        await vnf.UpdateAsync(WaitUntil.Completed, vnf.Data);
    }
}

public class NetworkFunctionConfig
{
    public string Location { get; set; }
    public string SkuName { get; set; }
    public string VendorName { get; set; }
    public List<CustomNetworkInterfaceConfiguration> NetworkInterfaces { get; set; }
}

Azure Operator Nexus

# Deploy Operator Nexus cluster
az networkcloud cluster create \
    --name "operator-nexus-cluster" \
    --resource-group "OperatorInfra" \
    --location "eastus" \
    --extended-location name="/subscriptions/.../customLocations/nexus-location" type="CustomLocation" \
    --analytics-workspace-id "/subscriptions/.../workspaces/nexus-analytics" \
    --cluster-type "SingleRack" \
    --network-rack-id "/subscriptions/.../networkRacks/rack-1"

# Create bare metal machine
az networkcloud baremetalmachine create \
    --name "compute-node-01" \
    --resource-group "OperatorInfra" \
    --extended-location name="/subscriptions/.../customLocations/nexus-location" type="CustomLocation" \
    --machine-details bmcConnectionString="ipmi://192.168.1.100" \
    --rack-id "/subscriptions/.../racks/rack-1" \
    --rack-slot 1

# Deploy workload cluster for network functions
az networkcloud kubernetescluster create \
    --name "vnf-workload-cluster" \
    --resource-group "OperatorInfra" \
    --extended-location name="/subscriptions/.../customLocations/nexus-location" type="CustomLocation" \
    --kubernetes-version "1.25.0" \
    --control-plane-node-count 3 \
    --worker-node-count 5

SIM Management

# Managing SIMs for private 5G network
from azure.mgmt.mobilenetwork import MobileNetworkManagementClient
from azure.identity import DefaultAzureCredential

class SIMManager:
    def __init__(self, subscription_id):
        self.client = MobileNetworkManagementClient(
            credential=DefaultAzureCredential(),
            subscription_id=subscription_id
        )

    def provision_sim(self, resource_group, sim_group_name, sim_config):
        """Provision a new SIM"""
        sim = {
            "properties": {
                "internationalMobileSubscriberIdentity": sim_config['imsi'],
                "authenticationKey": sim_config['ki'],
                "operatorKeyCode": sim_config['opc'],
                "staticIpConfiguration": sim_config.get('static_ip'),
                "deviceType": sim_config.get('device_type', 'IoT')
            }
        }

        return self.client.sims.begin_create_or_update(
            resource_group,
            sim_group_name,
            sim_config['name'],
            sim
        ).result()

    def bulk_provision_sims(self, resource_group, sim_group_name, sim_list):
        """Bulk provision multiple SIMs"""
        sims = []
        for sim_config in sim_list:
            sims.append({
                "name": sim_config['name'],
                "properties": {
                    "internationalMobileSubscriberIdentity": sim_config['imsi'],
                    "authenticationKey": sim_config['ki'],
                    "operatorKeyCode": sim_config['opc']
                }
            })

        return self.client.sims.begin_bulk_upload(
            resource_group,
            sim_group_name,
            {"sims": sims}
        ).result()

    def assign_sim_policy(self, resource_group, sim_group_name, sim_name, policy_id):
        """Assign a SIM policy to a SIM"""
        sim = self.client.sims.get(resource_group, sim_group_name, sim_name)
        sim.properties.sim_policy = {"id": policy_id}

        return self.client.sims.begin_create_or_update(
            resource_group,
            sim_group_name,
            sim_name,
            sim
        ).result()

Monitoring 5G Network

// KQL queries for 5G network monitoring
// UE (User Equipment) connection metrics
PacketCoreMetrics
| where TimeGenerated > ago(1h)
| where MetricName == "ConnectedUEs"
| summarize AvgConnected = avg(MetricValue), MaxConnected = max(MetricValue) by bin(TimeGenerated, 5m)
| render timechart

// Data plane throughput
PacketCoreMetrics
| where TimeGenerated > ago(1h)
| where MetricName in ("UplinkThroughput", "DownlinkThroughput")
| summarize TotalThroughput = sum(MetricValue) by MetricName, bin(TimeGenerated, 5m)
| render timechart

// Session establishment success rate
PacketCoreMetrics
| where TimeGenerated > ago(24h)
| where MetricName in ("SessionEstablishmentAttempts", "SessionEstablishmentSuccess")
| summarize Total = sum(MetricValue) by MetricName, bin(TimeGenerated, 1h)
| evaluate pivot(MetricName, sum(Total))
| extend SuccessRate = SessionEstablishmentSuccess * 100.0 / SessionEstablishmentAttempts
| project TimeGenerated, SuccessRate
| render timechart

Use Cases

1. Enterprise private 5G - Dedicated networks for factories and campuses
2. Mobile Edge Computing - Low-latency applications at the edge
3. Network slicing - Dedicated network resources per use case
4. IoT connectivity - Massive IoT device support
5. CBRS/Private LTE - Spectrum-efficient private networks

Azure for Operators enables telecommunications providers and enterprises to build next-generation network infrastructure.