Guia de início rápido: conclua os pré-requisitos para implantar o Azure Operator 5G Core Preview no Nexus Azure Kubernetes Service

Este artigo descreve como provisionar um cluster Nexus Azure Kubernetes Service (NAKS) criando:

• Recursos de malha de rede (conectividade)
• Recursos de nuvem de rede (computação)

Os comandos usados neste artigo referem-se aos seguintes grupos de recursos:

• Grupos de recursos de infraestrutura (gerenciados):
  • Malha - recursos de rede da plataforma
  • Undercloud - recursos de computação da plataforma
  • Grupo de recursos gerenciados usado para hospedar recursos do Kubernetes do Azure-ARC
• Grupos de recursos de locatário:
  • Malha - recursos de rede do locatário (como redes)
  • Computação - recursos de computação do locatário (como VMs e clusters do Nexus Azure Kubernetes Services (AKS))

Pré-requisitos

Antes de provisionar um cluster NAKS:

• Configure redes externas entre os dispositivos Customer Edge (CE) e Provider Edge (PE) (ou Telco Edge) que permitam a conectividade com a borda do provedor. Configurar o acesso a serviços externos, como firewalls e serviços hospedados no Azure (locatário e não plataforma) está fora do escopo deste artigo.
• Configure uma jumpbox para conectar domínios de roteamento. A configuração de uma jumpbox está fora do escopo deste artigo.
• Configure elementos de rede em PEs/Telco Edge que não são controlados pelo Nexus Network Fabric, como a configuração de Circuitos de Rota Expressa para cargas de trabalho de locatário, conectividade com o Azure (opcional para configurações híbridas) ou conectividade por meio da rede principal da operadora.
• Revise o calendário de lançamentos do Nexus Kubernetes para identificar versões disponíveis e planos de suporte.
• Analise a visão geral do cluster Nexus Kubernetes.
• Analise a visão geral da malha de rede.
• Consulte o Guia de instruções dos domínios de isolamento do Azure.
• Analise a visão geral do armazenamento.

Configurar redes e protocolos internos

Conclua estas tarefas para configurar a sua rede interna.

Criar o domínio de isolamento (L3ISD)

Use os seguintes comandos da CLI do Azure para criar o domínio de isolamento (ISD):

export subscriptionId="<SUBSCRIPTION-ID>" 
export rgManagedFabric="<RG-MANAGED-FABRIC>" 
export nnfId="<NETWORK-FABRIC-ID>" 
export rgFabric="<RG-FABRIC>" 
export l3Isd="<ISD-NAME>" 
export region="<REGION>" 
 
az networkfabric l3domain create –resource-name $l3Isd \ 
--resource-group $rgFabric \ 
--location $region \ 
--nf-id "/subscriptions/$subscriptionId/resourceGroups/$rgManagedFabric/providers/Microsoft.ManagedNetworkFabric/networkFabrics/$nnfId" \ 
--redistribute-connected-subnets "True" \ 
--redistribute-static-routes "True" \ 
--subscription "$subscriptionId"

Para exibir o novo domínio de isolamento L3ISD, digite o seguinte comando:

export subscriptionId="<SUBSCRIPTION-ID>" 
export rgFabric="<RG-FABRIC>" 
export l3Isd="<ISD-NAME>" 
 
az networkfabric l3domain show --resource-name $l3Isd -g $rgFabric --subscription $subscriptionId

Criar a rede interna

Antes de criar ou modificar a rede interna, você deve desativar o ISD. Reative o ISD depois de fazer as alterações.

Desativar o domínio de isolamento

Use os seguintes comandos para desativar o ISD:

export subscriptionId="<SUBSCRIPTION-ID>" 
export rgFabric="<RG-FABRIC>" 
export l3Isd="<ISD-NAME>" 
  
# Disable ISD to create internal networks, wait for 5 minutes and check the status is Disabled 
 
az networkfabric l3domain update-admin-state –resource-name "$l3Isd" \ 
--resource-group "$rgFabric" \ 
--subscription "$subscriptionId" \ 
--state Disable 
 
# Check the status of the ISD 
 
az networkfabric l3domain show –resource-name "$l3Isd" \ 
--resource-group "$rgFabric" \ 
--subscription "$subscriptionId"

Com o ISD desativado, você pode adicionar, modificar ou remover a rede interna. Quando terminar de fazer alterações, reative o ISD conforme descrito em Habilitar domínio de isolamento.

Criar a rede interna padrão da Interface de Rede de Contêiner do Azure

Use os seguintes comandos para criar a rede interna CNI (Interface de Rede de Contêiner) do Azure padrão:

export subscriptionId="<SUBSCRIPTION-ID>" 
export intnwDefCni="<DEFAULT-CNI-NAME>" 
export l3Isd="<ISD-NAME>" 
export rgFabric="<RG-FABRIC>" 
export vlan=<VLAN-ID> 
export peerAsn=<PEER-ASN> 
export ipv4ListenRangePrefix="<DEFAULT-CNI-IPV4-PREFIX>/<PREFIX-LEN>" 
export mtu=9000 
 
az networkfabric internalnetwork create –resource-name "$intnwDefCni" \ 
--resource-group "$rgFabric" \ 
--subscription "$subscriptionId" \ 
--l3domain "$l3Isd" \ 
--vlan-id $vlan \ 
--mtu $mtu \ 
--connected-ipv4-subnets "[{prefix:$ipv4ListenRangePrefix}]" \ 
--bgp-configuration
{peerASN:$peerAsn,allowAS:0,defaultRouteOriginate:True,ipv4ListenRangePrefixes:['$ipv4ListenRangePrefix']}" 

Criar redes internas para interfaces User Plane Function (N3, N6) e Access and Mobility Management Function (N2)

Ao criar redes internas UPF (User Plane Function), há suporte para IPv4/IPv6 de pilha dupla. Não é necessário configurar o ASN (Número de Sistema Autônomo) do lado da malha do protocolo BGP (Border Gateway Protocol) porque o ASN está incluído na criação de recursos de malha de rede. Use os comandos a seguir para criar essas redes internas.

export subscriptionId="<SUBSCRIPTION-ID>" 
export intnwName="<INTNW-NAME>" 
export l3Isd="<ISD-NAME>" // N2, N3, N6  
export rgFabric="<RG-FABRIC>" 
export vlan=<VLAN-ID> 
export peerAsn=<PEER-ASN> 
export ipv4ListenRangePrefix="<IPV4-PREFIX>/<PREFIX-LEN>" 
export ipv6ListenRangePrefix="<IPV6-PREFIX>/<PREFIX-LEN>" 
export mtu=9000 
 
az networkfabric internalnetwork create –resource-name "$intnwName" \ 
--resource-group "$rgFabric" \ 
--subscription "$subscriptionId" \ 
--l3domain "$l3Isd" \ 
--vlan-id $vlan \ 
--mtu $mtu \ 
--connected-ipv4-subnets "[{prefix:$ipv4ListenRangePrefix}]" \ 
--connected-ipv6-subnets "[{prefix:'$ipv6ListenRangePrefix'}]" \ //optional
--bgp-configuration 
"{peerASN:$peerAsn,allowAS:0,defaultRouteOriginate:True,ipv4ListenRangePrefixes:[$ipv4ListenRangePrefix],ipv6ListenRangePrefixes:['$ipv6ListenRangePrefix']}"

Para exibir a lista de redes internas criadas, digite os seguintes comandos:

export subscriptionId="<SUBSCRIPTION-ID>" 
export rgFabric="<RG-FABRIC>" 
export l3Isd="<ISD-NAME>" 
 
az networkfabric internalnetwork list -o table --subscription $subscriptionId -g $rgFabric --l3domain $l3Isd

Para exibir os detalhes de uma rede interna específica, digite os seguintes comandos:

export subscriptionId="<SUBSCRIPTION-ID>" 
export rgFabric="<RG-FABRIC>" 
export l3Isd="<ISD-NAME>" 
export intnwName="<INTNW-NAME>" 
 
az networkfabric internalnetwork show --resource-name $intnwName -g $rgFabric --l3domain $l3Isd

Habilitar domínio de isolamento

Use os seguintes comandos para habilitar o ISD:

export subscriptionId="<SUBSCRIPTION-ID>" 
export rgFabric="<RG-FABRIC>" 
export l3Isd="<ISD-NAME>" 
  
# Enable ISD, wait for 5 minutes and check the status is Enabled 
 
az networkfabric l3domain update-admin-state –resource-name "$l3Isd" \ 
--resource-group "$rgFabric" \ 
--subscription "$subscriptionId" \ 
--state Enable 
 
# Check the status of the ISD 
 
az networkfabric l3domain show –resource-name "$l3Isd" \ 
--resource-group "$rgFabric" \ 
--subscription "$subscriptionId"

Configurações de roteamento recomendadas

Para configurar o roteamento BGP e BFD (Bidirectional Forwarding Detection) para redes internas, use as configurações padrão. Consulte a documentação do Nexus para obter descrições de parâmetros.

Criar redes L3

Antes de implantar o cluster NAKS, você deve criar recursos de rede L3 na nuvem de rede (NC) mapeados para recursos de malha de rede (NF). Você deve criar recursos NC de rede L3 para a interface CNI padrão, incluindo o prefixo ISD/VLAN/IP de uma rede interna correspondente. Anexe esses recursos diretamente às VMs para executar a marcação VLAN no nível da função virtual (VF) da placa de interface de rede (NIC) em vez do nível do aplicativo (portas de acesso da perspetiva do aplicativo) e/ou se os endereços IP forem alocados pelo Nexus (usando a funcionalidade de gerenciamento de endereços IP (ipam)).

Uma rede L3 é usada para a interface CNI padrão. Outras interfaces que exigem várias VLANs por interface única devem ser interfaces de tronco.

Use os seguintes comandos para criar a rede L3:

Export subscriptionId="<SUBSCRIPTION-ID>" 
export rgManagedUndercloudCluster="<RG-MANAGED-UNDERCLOUD-CLUSTER>" 
export undercloudCustLocationName="<UNDERCLOUD-CUST-LOCATION-NAME>" 
export rgFabric="<RG-FABRIC>" 
export rgCompute="<RG-COMPUTE>" 
export l3Name="<L3-NET-NAME>" 
export l3Isd="<ISD-NAME>" 
export region="<REGION>" 
export vlan=<VLAN-ID> 
export ipAllocationType="IPV4" // DualStack, IPV4, IPV6 
export ipv4ConnectedPrefix="<DEFAULT-CNI-IPV4-PREFIX>/<PREFIX-LEN>" // if IPV4 or DualStack 
export ipv6ConnectedPrefix="<DEFAULT-CNI-IPV6-PREFIX>/<PREFIX-LEN>" // if IPV6 or DualStack 
 
 az networkcloud l3network create –l3-network-name $l3Name \ 
--l3-isolation-domain-id 
"/subscriptions/$subscriptionId/resourceGroups/$rgFabric/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/$l3Isd" \ 
--vlan $vlan \ 
--ip-allocation-type $ipAllocationType \ 
--ipv4-connected-prefix $ipv4ConnectedPrefix \ 
--extended-location name="/subscriptions/$subscriptionId/resourceGroups/$rgManagedUndercloudCluster/providers/Microsoft.ExtendedLocation/customLocations/$undercloudCustLocationName" type="CustomLocation" \ 
--resource-group $rgCompute \ 
--location $region \ 
--subscription $subscriptionId \ 
--interface-name "vlan-$vlan"

Para visualizar a rede L3 criada, digite os seguintes comandos:

export subscriptionId="<SUBSCRIPTION-ID>" 
export rgCompute="<RG-COMPUTE>" 
export l3Name="<L3-NET-NAME>" 
 
az networkcloud l3network show -n $l3Name -g $rgCompute --subscription $subscriptionId

Redes troncalizadas

Um trunkednetwork recurso de nuvem de rede é necessário se uma única porta/interface conectada a uma máquina virtual deve transportar várias VLANs (redes locais virtuais). A marcação é executada na camada de aplicativo em vez da NIC. Uma interface de tronco pode transportar VLANs que fazem parte de ISDs diferentes.

Você deve criar uma rede troncalizada para a Função de Mobilidade de Acesso e Gerenciamento (AMF) (N2) e UPF (N3, N6).

Use os seguintes comandos para criar uma rede troncalizada:

export subscriptionId="<SUBSCRIPTION-ID>" 
export rgManagedUndercloudCluster="<RG-MANAGED-UNDERCLOUD-CLUSTER>" 
export undercloudCustLocationName="<UNDERCLOUD-CUST-LOCATION-NAME>" 
export rgFabric="<RG-FABRIC>" 
export rgCompute="<RG-COMPUTE>" 
export trunkName="<TRUNK-NAME>" 
export l3IsdUlb="<ISD-ULB-NAME>" 
export vlanUlb=<VLAN-ULB-ID> 
export region="<REGION>" 
 
az networkcloud trunkednetwork create --name $trunkName \ 
--isolation-domain-ids
 "/subscriptions/$subscriptionId/resourceGroups/$rgFabric/providers/Microsoft.ManagedNetworkFabric/l3IsolationDomains/$l3IsdUlb" \ 
--vlans $vlanUlb \ 
--extended-location name="/subscriptions/$subscriptionId/resourceGroups/$rgManagedUndercloudCluster/providers/Microsoft.ExtendedLocation/customLocations/$undercloudCustLocationName" type="CustomLocation" \ 
--resource-group $rgCompute \ 
--location $region \ 
--interface-name "trunk-ulb" \ 
--subscription $subscriptionId

Para exibir o recurso de rede troncalizado criado, digite o seguinte comando:

export subscriptionId="<SUBSCRIPTION-ID>" 
export rgCompute="<RG-COMPUTE>" 
export trunkName="<TRUNK-NAME>" 
 
az networkcloud trunkednetwork show -n $trunkName -g $rgCompute --subscription $subscriptionId

Configurar o proxy da Rede de Serviços de Nuvem e os domínios permitidos

Um proxy de Rede de Serviços de Nuvem (proxy CSN) é usado para acessar o Azure e destinos da Internet. Você deve adicionar explicitamente esses domínios a uma lista de permissões na configuração da CSN para um cluster NAKS acessar os serviços do Azure e para a integração do Arc.

Pontos finais de redes de serviços de nuvem baseados no Network Function Manager

Adicione os seguintes pontos de saída para suporte à implantação baseada no Network Function Manager (NFM) (HybridNetwork Resource Provider (RP), CustomLocation RP reachability, ACR, Arc):

• .azurecr.io / porta 80
• .azurecr.io / porta 443
• .mecdevice.azure.com / porta 443
• eastus-prod.mecdevice.azure.com / porta 443
• .microsoftmetrics.com / porta 443
• crprivatemobilenetwork.azurecr.io / porta 443
• .guestconfiguration.azure.com / porta 443
• .kubernetesconfiguration.azure.com / porta 443
• eastus.obo.arc.azure.com / porta 8084
• .windows.net / porta 80
• .windows.net / porta 443
• .k8connecthelm.azureedge.net / porta 80
• .k8connecthelm.azureedge.net / porta 443
• .k8sconnectcsp.azureedge.net / porta 80
• .k8sconnectcsp.azureedge.net / porta 443
• .arc.azure.net / porta 80
• .arc.azure.net / porta 443

Pontos de extremidade Python Cloud Services Networks

Para a instalação de pacotes python (parte da lista de comandos pod-node_config do fed-kube_addons usada para NAKS), adicione os seguintes endpoints:

• pypi.org / porta 443
• files.pythonhosted.org / porta 443

Pontos finais opcionais de redes de serviços em nuvem

Use o seguinte destino para executar contêineres que tenham seus pontos de extremidade armazenados em registros de contêiner públicos ou para instalar mais pacotes para as máquinas virtuais auxiliares:

• .ghcr.io / porta 80
• .ghcr.io / porta 443
• .k8s.gcr.io / porta 80
• .k8s.gcr.io / porta 443
• .k8s.io / porta 80
• .k8s.io / porta 443
• .docker.io / porta 80
• .docker.io / porta 443
• .docker.com / porta 80
• .docker.com / porta 443
• .pkg.dev / porta 80
• .pkg.dev / porta 443
• .ubuntu.com / porta 80
• .ubuntu.com / porta 443

Criar redes de serviços na nuvem

Você deve criar uma instância CSN separada para cada cluster NAKS ao implantar o Azure Operator 5G Core Preview na plataforma Nexus.

export subscriptionId="<SUBSCRIPTION-ID>" 
export rgManagedUndercloudCluster="<RG-MANAGED-UNDERCLOUD-CLUSTER>" 
export undercloudCustLocationName="<UNDERCLOUD-CUST-LOCATION-NAME>" 
export rgCompute="<RG-COMPUTE>" 
export csnName="<CSN-NAME>" 
export region="<REGION>" 
 
az networkcloud cloudservicesnetwork create --cloud-services-network-name $csnName \ 
--extended-location name="/subscriptions/$subscriptionId/resourceGroups/$rgManagedUndercloudCluster/providers/Microsoft.ExtendedLocation/customLocations/$undercloudCustLocationName" type="CustomLocation" \06- \ 
--resource-group $rgCompute \ 
--location $region \ 
--enable-default-egress-endpoints True \ 
--subscription $subscriptionId \ 
--additional-egress-endpoints '[ 
    { 
      "category": "common", 
      "endpoints": [ 
        { 
          "domainName": ".io", 
          "port": 80 
        } 
      ] 
    }, 
    { 
      "category": "common", 
      "endpoints": [ 
        { 
          "domainName": ".io", 
          "port": 443 
        } 
      ] 
    } 
  ]'    07-

Depois de criar a CSN, verifique se está egress-endpoints usando os seguintes comandos na linha de comando:

export subscriptionId="<SUBSCRIPTION-ID>" 
export rgCompute="<RG-COMPUTE>" 
export csnName="<CSN-NAME>" 
 
az networkcloud cloudservicesnetwork show -n $csnName -g $rgCompute --subscription $subscriptionId

Criar um cluster de serviços do Nexus Azure Kubernetes

Os provedores de recursos relacionados ao Nexus devem implantar grupos de recursos autogerenciados usados para implantar os recursos necessários criados pelos clientes. Quando os clusters Nexus AKS são provisionados, eles devem ser habilitados para Arc. O provedor de recursos Network Cloud cria seu próprio grupo de recursos gerenciados e o implanta em um recurso de cluster do Azure Arc Kubernetes. Após essa implantação, esse recurso de cluster é vinculado ao recurso de cluster NAKS.

Use os seguintes comandos da CLI do Azure para criar o cluster NAKS:

export subscriptionId="<SUBSCRIPTION-ID>" 
export rgManagedUndercloudCluster="<RG-MANAGED-UNDERCLOUD-CLUSTER>" 
export undercloudCustLocationName="<UNDERCLOUD-CUST-LOCATION-NAME>" 
export rgCompute="<RG-COMPUTE>" 
export rgNcManaged="<RG-NETWORK-CLOUD-MANAGED>" 
export csnName="<CSN-NAME>" 
export defCniL3Net="<L3-NET-FOR-DEF-CNI>" 
export trunkName="<TRUNK-NAME>" 
export naksName="<NAKS-NAME>" 
export k8sVer="<K8S-VER>" 
export region="<REGION>" 
export regionRgNcManaged="<REGION-RG-NETWORK-CLOUD-MANAGED>" 
export sshPubKeys="<SSH-PUB-KEYS>"  
export adminUser="<ADMIN-USER>" // e.g. "azureuser" 
export controlVmSku="<CONTROL-NODE-SKU>" 
export controlVmCount="<CONTROL-NODE-COUNT>" 
export workerVmSku="<WORKER-NODE-SKU>" 
export workerVmCount="<WORKER-NODE-COUNT>" 
export nodePoolName="<NODE-POOL-NAME>" 
export lbIpv4Pool="<LOADBALANCER-IPV4-POOL>" 
export hugePages2MCount=<HUGEPAGES-2M-COUNT> 
export aadAdminGroupObjectId="<AAD-GROUP-TO-ACCESS-NAKS>" 
export maxSurge=1 // number of nodes added to the cluster during upgrade e.g. 1 or percentage "10%"   
 
 
az networkcloud kubernetescluster create --name $naksName \ 
--resource-group $rgCompute \ 
--location $region \ 
--kubernetes-version $k8sVer \ 
--extended-location name="/subscriptions/$subscriptionId/resourceGroups/$rgManagedUndercloudCluster/providers/Microsoft.ExtendedLocation/customLocations/$undercloudCustLocationName" type="CustomLocation" \ 
--admin-username $adminUser \ 
--ssh-key-values "$sshPubKeys" \ 
--initial-agent-pool-configurations "[{count:$workerVmCount,mode:'System',name:'$nodePoolName',vmSkuName:'$workerVmSku',agentOptions:{hugepagesCount:$hugePages2MCount,hugepagesSize:2M},upgradeSettings:{maxSurge:$maxSurge},adminUsername:'$adminUser',ssh-key-values:['$sshPubKeys']}]" \ 
--control-plane-node-configuration count=$workerVmCount vmSkuName=$controlVmSku adminUsername=$adminUser ssh-key-values=['$sshPubKeys'] \ 
--network-configuration cloud-services-network-id="/subscriptions/$subscriptionId/resourceGroups/$rgCompute/providers/Microsoft.NetworkCloud/cloudServicesNetworks/$csnName" cni-network-id="/subscriptions/$subscriptionId/resourceGroups/$rgCompute/providers/Microsoft.NetworkCloud/l3Networks/$defCniL3Net" pod-cidrs=["10.244.0.0/16"] service-cidrs=["10.96.0.0/16"] dns-service-ip="10.96.0.10" attached-network-configuration.trunked-networks="[{networkId:'/subscriptions/$subscriptionId/resourceGroups/$rgCompute/providers/Microsoft.NetworkCloud/trunkedNetworks/$trunkName',pluginType:'SRIOV'}]" bgp-service-load-balancer-configuration.fabric-peering-enabled="True" bgp-service-load-balancer-configuration.ip-address-pools="[{addresses:['$lbIpv4Pool'],autoAssign:'True',name:'pool1',onlyUseHostIps:'True'}]" \ 
--managed-resource-group-configuration "{location:$regionRgNcManaged,name:$rgNcManaged}" \ 
--aad-configuration admin-group-object-ids=[$aadAdminGroupObjectId] \ 
--subscription $subscriptionId

Para verificar a lista de clusters Nexus criados, digite o seguinte comando:

export subscriptionId="<SUBSCRIPTION-ID>" 
 
az networkcloud kubernetescluster list -o table --subscription $subscriptionId

Para verificar os detalhes de um cluster criado, digite o seguinte comando:

export subscriptionId="<SUBSCRIPTION-ID>" 
export rgCompute="<RG-COMPUTE>" 
export naksName="<NAKS-NAME>" 
 
az networkcloud kubernetescluster show -n $naksName -g $rgCompute --subscription $subscriptionId

Depois que o cluster for criado, você poderá habilitar a extensão NFM e definir um local personalizado para que o cluster possa ser implantado via AOSM ou NFM.

Acessar o cluster do Nexus Azure Kubernetes Services

Há várias maneiras de acessar o servidor de API do cluster NAKS do locatário:

• Diretamente do endereço IP/porta (de uma jumpbox que tem conectividade com o servidor da API NAKS do locatário)

• Usando a CLI do Azure e a opção de proxy connectedk8s, conforme descrito no link para acessar clusters diretamente. O grupo EntraID/AAD da Entidade de Serviço ou do usuário (usado com a CLI do Azure) deve ser fornecido durante o provisionamento do cluster NAKS. Além disso, você deve ter uma função personalizada atribuída ao grupo de recursos gerenciados criado pelo Network Cloud RP. Uma das seguintes ações deve ser habilitada nessa função:

  • Microsoft.Kubernetes/connectedClusters/listClusterUserCredential/action
  • Um usuário ou provedor de serviços como contribuidor para o grupo de recursos gerenciados

Serviços de Borda do Azure

O Azure Operator 5G Core é uma carga de trabalho de telecomunicações que lhe permite oferecer serviços a consumidores e utilizadores finais empresariais. As cargas de trabalho do Azure Operator 5G Core são executadas em uma camada NFVI (Network Functions Virtualization Infrastructure) e podem depender de outros serviços NFVI.

Funções NFVI de borda (em execução no Azure Operator Nexus)

• Azure Operator Nexus - O Azure Operator Nexus é uma plataforma de nuvem híbrida de próxima geração de nível de operadora para operadoras de telecomunicações. O Azure Operator Nexus foi criado especificamente para cargas de trabalho intensivas de rede e aplicativos de missão crítica dos operadores.

• Qualquer outro hardware e serviços do Azure Operator Nexus pode depender.

• Azure Arc - Fornece uma plataforma unificada de gestão e governação para aplicações e serviços 5G Core do Azure Operator em ambientes Azure e locais.

• Azure Monitor - Fornece uma solução abrangente para monitorar o desempenho e a integridade dos aplicativos e serviços do Azure Operator 5G Core em ambientes do Azure e locais.

• EntraID - Fornece gerenciamento de identidade e acesso para usuários e administradores do Azure Operator 5G Core em ambientes do Azure e locais.

• Azure Key Vault - Fornece um armazenamento seguro e centralizado para gerenciar chaves de criptografia e segredos para o Azure Operator 5G Core em ambientes do Azure e locais.

Conteúdos relacionados

• Saiba mais sobre a ordem de implantação.
• Implante o Azure Operator 5G Core Preview.
• Implante uma função de rede.