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

Artigo
11/22/2024

Os nós virtuais habilitam a comunicação de rede entre pods que são executados em clusters de Instâncias de Contêiner do Azure (ACI) e do Serviço Kubernetes do Azure (AKS). Para fornecer essa comunicação, uma sub-rede de rede virtual é criada e permissões delegadas são atribuídas. Os nós virtuais só funcionam com clusters AKS criados usando redes avançadas (Azure CNI). Os clusters AKS são criados com rede básica (kubenet) por padrão.

Este artigo mostra como criar uma rede virtual e sub-redes e, em seguida, implantar um cluster AKS que usa rede avançada usando o portal do Azure.

Nota

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

Antes de começar

Você precisa do provedor de serviços ACI registrado em sua assinatura.

Verifique o status do registro do provedor ACI usando o az provider list comando.

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 az provider register comando.
```
az provider register --namespace Microsoft.ContainerInstance
```

Criar um cluster do AKS

Navegue até a home page do portal do Azure.
Selecione Criar contêineres de recursos>.
No recurso Serviço 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, em seguida, selecione ou crie um grupo de recursos do Azure, como myResourceGroup.
- Detalhes do cluster: insira um nome de cluster do Kubernetes, como myAKSCluster. Selecione uma região e uma versão do Kubernetes para o cluster AKS.
Selecione Next: Node pools e marque *Enable virtual nodes.
Selecione Rever + criar.
Após a conclusão da validação, selecione Criar.

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

Esse processo configura o cluster para rede avançada e os nós virtuais para usar sua própria sub-rede de rede virtual do Azure. A sub-rede tem permissões delegadas para conectar recursos do Azure entre o cluster 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.

Ligar ao cluster

O Azure Cloud Shell é um shell interativo gratuito que você pode usar para executar as etapas neste artigo. Tem as ferramentas comuns do Azure pré-instaladas e configuradas para utilização com a sua conta. Para gerir um cluster de Kubernetes, utilize kubectl, o cliente de linha de comandos do Kubernetes. O cliente kubectl está pré-instalado no Azure Cloud Shell.

Configure kubectl para se conectar ao cluster do Kubernetes usando o az aks get-credentials comando. O exemplo seguinte obtém credenciais para o nome do cluster myAKSCluster no grupo de recursos denominado 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ó de VM criado e o nó Linux virtual 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 nomeado virtual-node.yaml e copie no seguinte YAML:

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, que permite que o pod seja agendado no nó virtual. O pod recebe um endereço IP interno da sub-rede de rede virtual do Azure delegada para uso com nós virtuais.

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

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

kubectl get pods -o wide

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

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

Nota

Se você 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, 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

Para testar o pod em execução no nó virtual, navegue até o aplicativo de demonstração com um web client. O pod recebe um endereço IP interno, para que você possa testar facilmente a conectividade de outro pod no cluster AKS.

Crie um pod de teste e anexe uma sessão de terminal a ele usando o comando a seguir kubectl run .
```
kubectl run -it --rm virtual-node-test --image=mcr.microsoft.com/dotnet/runtime-deps:6.0
```
Instale curl no pod usando o seguinte apt-get comando.
```
apt-get update && apt-get install -y curl
```
Acesse o endereço do seu pod usando o seguinte curl comando e forneça seu endereço IP interno.
```
curl -L http://10.241.0.4
```
A saída de exemplo condensado 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 seu pod de teste com exito , que também exclui o pod.
```
exit
```

Próximos passos

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, consulte Criar 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 obter mais informações sobre soluções de dimensionamento, consulte os seguintes artigos:

Partilhar via