Criar e configurar um cluster do AKS (Serviços de Kubernetes do Azure) para usar nós virtuais no portal 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 o cluster do Serviço de Kubernetes do Azure (AKS). Para fornecer essa comunicação, uma sub-rede de rede virtual é criada e permissões delegadas são atribuídas. 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 e, assim, implantar um cluster do AKS que usa rede avançada através do portal do Azure.

Observação

Para obter uma visão geral da disponibilidade e das limitações da região do nó virtual, confira Usar nós virtuais no AKS.

Antes de começar

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

A saída de exemplo a seguir mostra que o provedor Microsoft.ContainerInstance está Registrado:

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

Se o provedor for NotRegistered, registre-o usando o comando az provider register.
```
az provider register --namespace Microsoft.ContainerInstance
```

Criar um cluster AKS

Navegue até a home page do portal do Azure.
Select Criar um recurso>Contêineres.
No recurso Serviço de Kubernetes do Azure (AKS), selecione Criar.
Na página Noções básicas, configure as seguintes opções:
- Detalhes do projeto: selecione uma assinatura do Azure e selecione ou crie um grupo de recursos do Azure, por exemplo, myResourceGroup.
- Detalhes do cluster: Insira um nome do cluster do Kubernetes, como myAKSCluster. Selecione uma região e uma versão do Kubernetes para o cluster do AKS.
Selecione Avançar: pools de nós e marque *Habilitar nós virtuais.
Selecione Examinar + criar.
Após concluir a validação, selecione Criar.

Por padrão, esse processo cria uma identidade de cluster gerenciada, que é usada para comunicação de cluster e integração com outros serviços do Azure. Para obter mais informações, confira Usar identidades gerenciadas. Você também pode usar uma entidade de serviço como sua identidade de cluster.

Esse processo configura o cluster para a rede avançada e os nós virtuais usarem sua própria sub-rede de rede virtual do Azure. A sub-rede tem permissões delegadas para se conectar a recursos do Azure entre o cluster do AKS. Se você ainda não tiver uma sub-rede delegada, o portal do Azure criará e configurará uma rede virtual e uma sub-rede do Azure com os nós virtuais.

Conectar-se ao cluster

O Azure Cloud Shell é um shell gratuito e interativo que poderá ser usado para executar as etapas deste artigo. Ele tem ferramentas do Azure instaladas e configuradas para usar com sua conta. Para gerenciar um cluster Kubernetes, use kubectl, o cliente de linha de comando Kubernetes. O cliente kubectl está pré-instalado no Azure Cloud Shell.

Configure o kubectl para se conectar ao cluster do Kubernetes usando o comando az aks get-credentials. O exemplo a seguir obtém as credenciais para o nome do cluster myAKSCluster no grupo de recursos chamado myResourceGroup:
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```

Verifique a conexão com o cluster usando o kubectl get nodes.

kubectl get nodes

A saída de exemplo a seguir mostra o único nó da VM criado e o nó virtual do Linux chamado 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

No Azure Cloud Shell, crie um arquivo chamado virtual-node.yaml e copie no YAML a seguir:

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

O YAML define um nodeSelector e tolerância, o que permite que o pod seja agendado no nó virtual. 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.

Execute o aplicativo com o comando kubectl apply.
```
kubectl apply -f virtual-node.yaml
```

Exiba os pods agendados no nó usando o comando kubectl get pods com o argumento -o wide.

kubectl get pods -o wide

A saída de exemplo a seguir mostra o pod virtual-node-helloworld agendado no nó virtual-node-linux.

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

Observação

Se usar imagens armazenadas no Registro de Contêiner do Azure, configure e use um segredo do Kubernetes. Uma limitação 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, 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

Para testar o pod em execução no nó virtual, navegue até o aplicativo de demonstração com um cliente Web. O pod recebe um endereço IP interno, para que você possa testar facilmente a conectividade de 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.
```
kubectl run -it --rm virtual-node-test --image=mcr.microsoft.com/dotnet/runtime-deps:6.0
```
Instale curl no pod usando o comando apt-get a seguir.
```
apt-get update && apt-get install -y curl
```
Acesse o endereço do pod usando o comando curl a seguir e forneça seu endereço IP interno.
```
curl -L http://10.241.0.4
```
A saída de exemplo condensada a seguir mostra o aplicativo de demonstração.
```
<html>
<head>
  <title>Welcome to Azure Container Instances!</title>
</head>
[...]
```
Feche a sessão do terminal para o pod de teste com exit, que também exclui o pod.
```
exit
```

Próximas etapas

Neste artigo, você agendou um pod no nó virtual e atribuiu um endereço IP interno privado. Se desejar, você pode, em vez disso, 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, veja Criação de um controlador de entrada básico no AKS.

Os nós virtuais 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