Início rápido: concluir os pré-requisitos para implantar o Azure Operator 5G Core Preview no Serviço de Kubernetes do Nexus do Azure

Esse artigo descreve como provisionar um cluster Nexus Serviço de Kubernetes do Azure (NAKS) criando:

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

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

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

Pré-requisitos

Antes de provisionar um cluster NAKS:

• Configure redes externas entre os dispositivos CE (borda do cliente) e PE (borda do provedor) (ou borda de telecomunicações) que permitem a conectividade com a borda do provedor. Configurar o acesso a serviços externos como firewalls e serviços hospedados no Azure (inquilino e não plataforma) está fora do âmbito desse artigo.
• Configure um jumpbox para conectar domínios de roteamento. A configuração de um jumpbox não está incluída no escopo deste artigo.
• Configure elementos de rede em PEs/borda de telecomunicações que não são controlados pela malha de rede do Nexus, como a configuração de circuitos do ExpressRoute para conectividade de cargas de trabalho de locatário com o Azure (opcional para configurações híbridas) ou conectividade por meio da rede principal do operador.
• Revise o calendário de lançamentos do Nexus Kubernetes para identificar as versões disponíveis e os planos de suporte.
• Revise a Visão geral do cluster Nexus Kubernetes.
• Revise a Visão geral do Network Fabric.
• Revise o Guia prático dos domínios de isolamento do Azure.
• Revise a visão geral do armazenamento.

Configurar redes e protocolos internos

Conclua essas tarefas para configurar sua rede interna.

Crie o domínio de isolamento (L3ISD)

Utilize os seguintes comandos 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 ver o novo domínio de isolamento L3ISD, insira 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, é necessário desabilitar o ISD. Re habilite o ISD após fazer as alterações.

Desabilite o domínio de isolamento

Use os seguintes comandos para desabilitar 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 desabilitado, você pode adicionar, modificar ou remover a rede interna. Quando terminar de fazer as alterações, habilite novamente o ISD conforme descrito no Habilitar domínio de isolamento.

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

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

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 as interfaces de Função de Plano do Usuário (N3, N6) e Função de Gerenciamento de Acesso e Mobilidade (N2)

Quando você estiver criando redes internas da UPF (Função de Plano de Usuário), haverá suporte para o IPv4/IPv6 de pilha dupla. Você não precisa configurar o ASN do lado da malha do BGP (Border Gateway Protocol), porque o ASN está incluído na criação de recursos da 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 ver a lista de redes internas criadas, insira 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 ver os detalhes de uma rede interna específica, insira 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 ativar 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 do BGP e da BFD (Detecção de Encaminhamento Bidirecional) para redes internas, use as configurações padrão. Confira a documentação do Nexus para ver as descrições de parâmetros.

Crie redes L3

Antes de implementar o cluster do NAKS, crie recursos de rede L3 de NC (nuvem de rede) que são mapeados para recursos de NF (malha de rede). 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 de VLAN no nível da VF (Função Virtual) da NIC (placa de adaptador de rede), em vez do nível do aplicativo (portas de acesso da perspectiva do aplicativo) e/ou se os endereços IP forem alocados pelo Nexus (por meio da funcionalidade IPAM, Gerenciamento de Endereços IP).

Uma rede L3 é usada para a interface CNI padrão. As outras interfaces que exigem múltiplas VLANs por interface única precisam 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 ver a rede L3 criada, insira 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 com tronco

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

Você precisa criar uma rede com tronco para a Função AMF (Mobilidade de Acesso e Gerenciamento) (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 ver o recurso de rede com tronco criado, insira 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 do Serviços de Nuvem e os domínios permitidos

Um proxy da 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 CSN para um cluster NAKS para acessar os serviços do Azure e para integração do Arc.

Pontos de extremidade de Redes de Serviços de Nuvem baseados no Gerenciador de Funções de Rede

Adicione os seguintes pontos de saída ao suporte de implantação baseado em NFM (Gerenciador de Funções de Rede) (RP, Provedor de Recursos de HybridNetwork, acessibilidade de RP de CustomLocation, 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 de redes de Serviços de Nuvem Python

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

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

Pontos de extremidade opcionais de redes de Serviços de Nuvem

Use o destino a seguir para executar contêineres que têm seus terminais armazenados em registros de contêineres 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

Crie redes de Serviços de 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 o CSN, verifique os 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 Nexus Azure Kubernetes

Os provedores de recursos relacionados ao Nexus precisam 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 fornecedor de recursos Network Cloud cria o seu próprio grupo de recurso gerenciado e implanta-o num recurso de cluster Azure Arc Kubernetes. Após essa implantação, esse recurso de cluster está vinculado ao recurso de cluster NAKS.

Utilize os seguintes comandos 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 do Nexus criados, insira o seguinte comando:

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

Para verificar os detalhes de um cluster criado, insira 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 por meio do AOSM ou do NFM.

Acesse o cluster Nexus Azure Kubernetes Services

Existem várias maneiras de acessar o servidor API do cluster Tenant NAKS:

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

• Usando a CLI do Azure e a opção de proxy do k8s conectado, conforme descrito no link para acessar os clusters diretamente. O grupo do Entra ID/do AAD da entidade de serviço ou do usuário (usado com a CLI do Azure) precisa ser fornecido durante o provisionamento do cluster do NAKS. Além disso, você precisa ter uma função personalizada atribuída ao grupo de recursos gerenciado criado pelo RP de nuvem de rede. 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 do grupo de recursos gerenciados

Serviços de borda do Azure

O Azure Operator 5G Core é uma carga de trabalho de telecomunicações que permite oferecer serviços aos usuários finais consumidores e empresariais. As cargas de trabalho do Azure Operator 5G Core são executadas em uma camada da NFVI (Infraestrutura de Virtualização de Funções de Rede) e podem depender de outros serviços da NFVI.

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

• Nexus do Operador do Azure – O Nexus do Operador do Azure é uma plataforma de nuvem híbrida de última geração e de nível de operadora para operadores de telecomunicações. O Azure Operator Nexus foi criado especificamente para cargas de trabalho com uso intensivo de rede e aplicativos críticos dos operadores.

• Qualquer outro hardware e serviço do qual o Nexus do Operador do Azure possa depender.

• Azure Arc – Fornece uma plataforma unificada de gerenciamento e governança para aplicativos e serviços do Azure Operator 5G Core em ambientes locais e do Azure.

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

• Entra ID – Fornece gerenciamento de identidades e acesso para usuários e administradores do Azure Operator 5G Core em ambientes locais e do Azure.

• Azure Key Vault – Fornece um repositório seguro e centralizado para gerenciar chaves de criptografia e segredos do Azure Operator 5G Core em ambientes locais e do Azure.

Conteúdo relacionado

• Saiba mais sobre a Ordem de implantação.
• Implantar versão prévia do Azure Operator 5G Core.
• Implantar uma função de rede.