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

Artigo
08/02/2024

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

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

Antes de começar

Importante

Antes de usar nós virtuais com AKS, examine as limitações dos nós virtuais do 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 da ACI registrado em sua assinatura. Verifique o status do registro do provedor da ACI usando o comando az provider list.
```
az provider list --query "[?contains(namespace,'Microsoft.ContainerInstance')]" -o table
```
O provedor Microsoft.ContainerInstance deve relatar como registrado, conforme mostrado na saída de exemplo a seguir:
```
Namespace                    RegistrationState    RegistrationPolicy
---------------------------  -------------------  --------------------
Microsoft.ContainerInstance  Registered           RegistrationRequired
```
Se o provedor for exibido como NotRegistered, registre o provedor usando az provider register.
```
az provider register --namespace Microsoft.ContainerInstance
```
Se estiver usando a CLI do Azure, este artigo requer a CLI do Azure versão 2.0.49 ou posterior. Execute az --version para encontrar a versão. Se você precisa instalar ou atualizar, consulte Instalar a CLI do Azure. Você também pode usar o Azure Cloud Shell.

Iniciar o Azure Cloud Shell

O Azure Cloud Shell é um shell gratuito e interativo que poderá ser usado para executar as etapas deste artigo. Ele tem ferramentas do Azure pré-instaladas e configuradas.

Para abrir o Cloud Shell, selecione Experimentar no canto superior direito de um bloco de código. Você também pode iniciar o Cloud Shell em uma guia separada do navegador indo até https://shell.azure.com/bash. Selecione Copiar para copiar os blocos de código, cole o código no Cloud Shell e depois pressione 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 implantados e gerenciados.

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

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 do cluster do AKS.

Criar uma rede virtual usando o comando az network vnet create. O exemplo a seguir cria uma rede virtual nomeada myVnet com um prefixo de endereço de 10.0.0.0/8 e uma sub-rede nomeada myAKSSubnet. O prefixo de endereço dessa sub-rede é por 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
```
Crie uma sub-rede extra para os nós virtuais usando o comando az network vnet subnet create. O exemplo a seguir cria uma sub-rede nomeada myVirtualNodeSubnet com o 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 do AKS com a identidade gerenciada

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

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

Crie um cluster AKS usando o comando az aks create e substitua <subnetId> pela ID obtida 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> \
    --generate-ssh-keys
```
Após alguns minutos, o comando é concluído e retorna informações formatadas em JSON sobre o cluster.

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

Habilitar complemento de nós virtuais

Observação

Se tiver um cluster do Serviço de Kubernetes do Azure existente criado que use a CNI do Azure para a Rede Avançada, você poderá habilitar nós virtuais como um complemento usando a CLI.

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

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

Conectar-se ao cluster

Configure o kubectl para se conectar ao cluster do Kubernetes usando o comando az aks get-credentials. Esta etapa baixa credenciais e configura a CLI de Kubernetes para usá-las.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```
Para verificar a conexão com o cluster, use o comando kubectl get, o que retornará uma lista dos nós de cluster.
```
kubectl get nodes
```
O resultado do 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

Crie um arquivo chamado virtual-node.yaml e copie no YAML a seguir. O YAML agenda o contêiner no nó definindo um nodeSelector e toleration.

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

Execute o aplicativo com o comando kubectl apply.
```
kubectl apply -f virtual-node.yaml
```
Obtenha uma lista de pods e o nó agendado usando o comando kubectl get pods com o argumento -o wide.
```
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 é atribuído a um endereço IP interno da sub-rede da rede virtual do Azure delegada para uso com nós virtuais.

Observação

Se 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 integrada da entidade de serviço do Microsoft Entra. Se você não usar um segredo, pods agendados em nós virtuais falham ao iniciar e relatam o erro HTTP response status code 400 error code "InaccessibleImage".

Testar o pod de nó virtual

Teste o pod em execução no nó virtual navegando até o aplicativo de demonstração com um cliente Web. Como o pod é atribuído a um endereço IP interno, é possível testar rapidamente essa conectividade por outro pod no cluster do AKS.
Crie um pod de teste e anexe uma sessão de terminal a ele usando o seguinte comando kubectl run -it.
```
kubectl run -it --rm testvk --image=mcr.microsoft.com/dotnet/runtime-deps:6.0
```

Instale curl no pod usando apt-get.

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

Acesse o endereço de seu pod usando curl, como, por exemplo http://10.241.0.4. Forneça seu próprio endereço IP interno exibido no comando kubectl get pods anterior.
```
curl -L http://10.241.0.4
```
O aplicativo de demonstração é exibido, conforme mostrado na saída de exemplo condensada a seguir:
```
<html>
<head>
  <title>Welcome to Azure Container Instances!</title>
</head>
[...]
```
Feche a sessão de terminal do pod de teste com exit. Quando a sessão for encerrada, o pod será excluído.

Remover nós virtuais

Exclua o pod aci-helloworld em execução no nó virtual usando o comando kubectl delete.
```
kubectl delete -f virtual-node.yaml
```

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

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

Remova os recursos de rede virtual e o grupo de recursos usando os comandos a seguir.

# 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óximas etapas

Neste artigo, você agendou um pod no nó virtual e atribuiu um endereço IP interno privado. Ao invés disso, você pode criar uma implantação de serviço e direcionar o tráfego para o pod por meio de um balanceador de carga ou controlador de entrada. Para obter mais informações, veja Criação de um controlador de entrada básico no AKS.

Nós virtuais geralmente são um componente de uma solução de dimensionamento no AKS. Para saber mais sobre essas soluções de dimensionamento, consulte os artigos a seguir:

Compartilhar via