Criar e configurar um cluster dos Serviços Kubernetes do Azure (AKS) para usar nós virtuais usando a CLI do Azure

  • Artigo

Os nós virtuais permitem a comunicação de rede entre pods executados em Instâncias de Contêiner do Azure (ACI) e clusters AKS. Para fornecer essa comunicação, crie uma sub-rede de rede virtual e atribua permissões delegadas. Os nós virtuais só funcionam com clusters AKS criados usando redes avançadas (Azure CNI). Por padrão, os clusters AKS são criados com rede básica (kubenet). Este artigo mostra como criar uma rede virtual e sub-redes e, em seguida, implantar um cluster AKS que usa rede avançada.

Este artigo mostra como usar a CLI do Azure para criar e configurar recursos de rede virtual e um cluster AKS habilitado com nós virtuais.

Antes de começar

Importante

Antes de usar nós virtuais com AKS, revise as limitações dos nós virtuais AKS e as limitações de rede virtual do ACI. Essas limitações afetam o local, a configuração de rede e outros detalhes de configuração do cluster AKS e dos nós virtuais.

  • Você precisa do provedor de serviços ACI registrado com sua assinatura. Você pode verificar o status do registro do provedor ACI usando o az provider list comando.

    az provider list --query "[?contains(namespace,'Microsoft.ContainerInstance')]" -o table

    O provedor Microsoft.ContainerInstance deve relatar como Registered, conforme mostrado na saída de exemplo a seguir:

    Namespace                    RegistrationState    RegistrationPolicy
---------------------------  -------------------  --------------------
Microsoft.ContainerInstance  Registered           RegistrationRequired

    Se o provedor mostrar como NotRegistered, registre o provedor usando o az provider register.

    az provider register --namespace Microsoft.ContainerInstance

  • Se estiver usando a CLI do Azure, este artigo exigirá a CLI do Azure versão 2.0.49 ou posterior. Executar az --version para localizar a versão. Se precisar de instalar ou atualizar, veja Install Azure CLI (Instalar o Azure CLI). Você também pode usar o Azure Cloud Shell.

Iniciar o Azure Cloud Shell

O Azure Cloud Shell é um shell interativo gratuito que você pode usar para executar as etapas neste artigo. Tem ferramentas comuns do Azure pré-instaladas e configuradas.

Para abrir o Cloud Shell, selecione Experimente no canto superior direito de um bloco de código. Também pode iniciar o Cloud Shell num separador do browser separado ao aceder a https://shell.azure.com/bash. Selecione Copiar para copiar os blocos de código, cole-o no Cloud Shell e prima Enter para executá-lo.

Criar um grupo de recursos

Um grupo de recursos do Azure é um grupo lógico, no qual os recursos do Azure são implementados e geridos.

  • Crie um grupo de recursos usando o az group create comando.

    az group create --name myResourceGroup --location eastus

Criar uma rede virtual

Importante

O nó virtual requer uma rede virtual personalizada e uma sub-rede associada. Ele não pode ser associado à mesma rede virtual que o cluster AKS.

  1. Crie uma rede virtual usando o az network vnet create comando. O exemplo a seguir cria uma rede virtual chamada myVnet com um prefixo de endereço de 10.0.0.0/8 e uma sub-rede chamada myAKSSubnet. O prefixo de endereço dessa sub-rede tem como padrão 10.240.0.0/16.

    az network vnet create \
    --resource-group myResourceGroup \
    --name myVnet \
    --address-prefixes 10.0.0.0/8 \
    --subnet-name myAKSSubnet \
    --subnet-prefix 10.240.0.0/16

  2. Crie uma sub-rede extra para os nós virtuais usando o az network vnet subnet create comando. O exemplo a seguir cria uma sub-rede chamada myVirtualNodeSubnet com um prefixo de endereço de 10.241.0.0/16.

    az network vnet subnet create \
    --resource-group myResourceGroup \
    --vnet-name myVnet \
    --name myVirtualNodeSubnet \
    --address-prefixes 10.241.0.0/16

Criar um cluster AKS com identidade gerenciada

  1. Obtenha o ID da sub-rede usando o az network vnet subnet show comando.

    az network vnet subnet show --resource-group myResourceGroup --vnet-name myVnet --name myAKSSubnet --query id -o tsv

  2. Crie um cluster AKS usando o az aks create comando e substitua <subnetId> pelo ID obtido na etapa anterior. O exemplo a seguir cria um cluster chamado myAKSCluster com cinco nós.

    az aks create \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --node-count 5 \
    --network-plugin azure \
    --vnet-subnet-id <subnetId>

    Ao fim de vários minutos, o comando é concluído e devolve informações sobre o cluster no formato JSON.

Para obter mais informações sobre identidades gerenciadas, consulte Usar identidades gerenciadas.

Ativar o addon de nós virtuais

  • Habilite nós virtuais usando o az aks enable-addons comando. O exemplo a seguir usa a sub-rede chamada myVirtualNodeSubnet criada em uma etapa anterior.

    az aks enable-addons \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --addons virtual-node \
    --subnet-name myVirtualNodeSubnet

Ligar ao cluster

  1. Configure kubectl para se conectar ao cluster do Kubernetes usando o az aks get-credentials comando. Este passo transfere credenciais e configura a CLI do Kubernetes para as utilizar.

    az aks get-credentials --resource-group myResourceGroup --name myAKSCluster

  2. Verifique a conexão com o cluster usando o kubectl get comando, que retorna uma lista dos nós do cluster.

    kubectl get nodes

    A saída de exemplo a seguir mostra o único nó de VM criado e o nó virtual para Linux, virtual-node-aci-linux:

    NAME                          STATUS    ROLES     AGE       VERSION
virtual-node-aci-linux        Ready     agent     28m       v1.11.2
aks-agentpool-14693408-0      Ready     agent     32m       v1.11.2

Implantar um aplicativo de exemplo

  1. Crie um arquivo nomeado virtual-node.yaml e copie no seguinte YAML. O YAML agenda o contêiner no nó definindo um nodeSelector e tolerância.

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: aci-helloworld
spec:
  replicas: 1
  selector:
    matchLabels:
      app: aci-helloworld
  template:
    metadata:
      labels:
        app: aci-helloworld
    spec:
      containers:
      - name: aci-helloworld
        image: mcr.microsoft.com/azuredocs/aci-helloworld
        ports:
        - containerPort: 80
      nodeSelector:
        kubernetes.io/role: agent
        beta.kubernetes.io/os: linux
        type: virtual-kubelet
      tolerations:
      - key: virtual-kubelet.io/provider
        operator: Exists
      - key: azure.com/aci
        effect: NoSchedule

  2. Execute o aplicativo usando o kubectl apply comando.

    kubectl apply -f virtual-node.yaml

  3. Obtenha uma lista de pods e o nó agendado usando o comando com o kubectl get pods-o wide argumento.

    kubectl get pods -o wide

    O pod é agendado no nó virtual virtual-node-aci-linux, conforme mostrado na saída de exemplo a seguir:

    NAME                            READY     STATUS    RESTARTS   AGE       IP           NODE
aci-helloworld-9b55975f-bnmfl   1/1       Running   0          4m        10.241.0.4   virtual-node-aci-linux

    O pod recebe um endereço IP interno da sub-rede de rede virtual do Azure delegada para uso com nós virtuais.

Nota

Se você usar imagens armazenadas no Registro de Contêiner do Azure, configure e use um segredo do Kubernetes. Uma limitação atual dos nós virtuais é que você não pode usar a autenticação de entidade de serviço integrada do Microsoft Entra. Se você não usar um segredo, os pods agendados em nós virtuais não serão iniciados e relatarão o erro HTTP response status code 400 error code "InaccessibleImage".

Teste o pod do nó virtual

  1. Teste o pod em execução no nó virtual navegando até o aplicativo de demonstração com um web client. Como o pod recebe um endereço IP interno, você pode testar rapidamente essa conectividade de outro pod no cluster AKS.

  2. Crie um pod de teste e anexe uma sessão de terminal a ele usando o comando a seguir kubectl run -it .

    kubectl run -it --rm testvk --image=mcr.microsoft.com/dotnet/runtime-deps:6.0

  3. Instale curl no pod usando apt-get.

    apt-get update && apt-get install -y curl

  4. Acesse o endereço do seu pod usando curl, como http://10.241.0.4. Forneça seu próprio endereço IP interno mostrado no comando anterior kubectl get pods .

    curl -L http://10.241.0.4

    O aplicativo de demonstração é exibido, como mostrado na seguinte saída de exemplo condensado:

    <html>
<head>
  <title>Welcome to Azure Container Instances!</title>
</head>
[...]

  5. Feche a sessão do terminal para o seu pod de teste com exito . Quando a sessão termina, o pod é excluído.

Remover nós virtuais

  1. Exclua o aci-helloworld pod em execução no nó virtual usando o kubectl delete comando.

    kubectl delete -f virtual-node.yaml

  2. Desative os nós virtuais usando o az aks disable-addons comando.

    az aks disable-addons --resource-group myResourceGroup --name myAKSCluster --addons virtual-node

  3. Remova os recursos de rede virtual e o grupo de recursos usando os seguintes comandos.

    # Change the name of your resource group, cluster and network resources as needed
RES_GROUP=myResourceGroup
AKS_CLUSTER=myAKScluster
AKS_VNET=myVnet
AKS_SUBNET=myVirtualNodeSubnet

# Get AKS node resource group
NODE_RES_GROUP=$(az aks show --resource-group $RES_GROUP --name $AKS_CLUSTER --query nodeResourceGroup --output tsv)

# Get network profile ID
NETWORK_PROFILE_ID=$(az network profile list --resource-group $NODE_RES_GROUP --query "[0].id" --output tsv)

# Delete the network profile
az network profile delete --id $NETWORK_PROFILE_ID -y

# Grab the service association link ID
SAL_ID=$(az network vnet subnet show --resource-group $RES_GROUP --vnet-name $AKS_VNET --name $AKS_SUBNET --query id --output tsv)/providers/Microsoft.ContainerInstance/serviceAssociationLinks/default

# Delete the service association link for the subnet
az resource delete --ids $SAL_ID --api-version 2021-10-01

# Delete the subnet delegation to Azure Container Instances
az network vnet subnet update --resource-group $RES_GROUP --vnet-name $AKS_VNET --name $AKS_SUBNET --remove delegations

Próximos passos

Neste artigo, você agendou um pod no nó virtual e atribuiu um endereço IP interno privado. Em vez disso, você pode criar uma implantação de serviço e rotear o tráfego para seu pod por meio de um balanceador de carga ou controlador de entrada. Para obter mais informações, consulte Criar um controlador de entrada básico no AKS.

Os nós virtuais geralmente são um componente de uma solução de dimensionamento no AKS. Para obter mais informações sobre soluções de dimensionamento, consulte os seguintes artigos: