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

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

Antes de começar

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 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 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.

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.

Se você não tiver usado anteriormente ACI, registre o provedor de serviço com sua assinatura. Você pode verificar o status do registro de provedor ACI usando o comando az provider list, conforme mostrado no exemplo a seguir:

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 é exibido como NotRegistered, registre o provedor usando az provider register conforme mostrado no exemplo a seguir:

az provider register --namespace Microsoft.ContainerInstance

Iniciar o Azure Cloud Shell

O Azure Cloud Shell é um shell interativo grátis que pode ser usado para executar as etapas neste artigo. Ele tem ferramentas do Azure instaladas e configuradas para usar com sua conta.

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.

Se preferir instalar e usar a CLI localmente, 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.

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 com o comando az group create. O exemplo a seguir cria um grupo de recursos chamado myResourceGroup na localização westus.

az group create --name myResourceGroup --location westus

Criar uma rede virtual

Crie 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

Agora, crie uma sub-rede adicional 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 uma entidade de serviço ou usar identidade gerenciada

Para permitir a interação de um cluster do AKS com outros recursos do Azure, uma identidade do cluster é usada. A identidade do cluster pode ser criada automaticamente pelo portal ou pela CLI do Azure, ou você pode criar previamente uma e atribuir permissões adicionais. Por padrão, essa identidade de cluster é uma identidade gerenciada. Para obter mais informações, confira Usar identidades gerenciadas. Você também pode usar uma entidade de serviço como sua identidade de cluster. As etapas a seguir mostram como criar e atribuir manualmente a entidade de serviço ao cluster.

Use o comando az ad sp create-for-rbac para criar uma entidade de serviço. O parâmetro --skip-assignment limita a atribuição de outras permissões.

az ad sp create-for-rbac --skip-assignment

A saída deverá ser semelhante ao seguinte exemplo:

{
  "appId": "bef76eb3-d743-4a97-9534-03e9388811fc",
  "displayName": "azure-cli-2018-11-21-18-42-00",
  "name": "http://azure-cli-2018-11-21-18-42-00",
  "password": "1d257915-8714-4ce7-a7fb-0e5a5411df7f",
  "tenant": "72f988bf-86f1-41af-91ab-2d7cd011db48"
}

Anote a appId e a senha. Esses valores serão usados nas próximas etapas.

Atribuir permissões para a rede virtual

Para permitir que o cluster use e gerencie a rede virtual, é necessário conceder à entidade de serviço do AKS os direitos corretos para usar os recursos de rede.

Primeiro, obtenha a ID do recurso de rede virtual usando az network vnet show:

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

Para conceder o acesso correto para que o cluster do AKS use a rede virtual, crie uma atribuição de função usando o comando az role assignment create. Substitua <appId> e <vnetId> pelos valores coletados nas duas etapas anteriores.

az role assignment create --assignee <appId> --scope <vnetId> --role Contributor

Criar um cluster do AKS

Implante um cluster do AKS dentro da sub-rede do AKS criada na etapa anterior. Obtenha a ID dessa sub-rede usando az network vnet subnet show:

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

Use o comando az aks create para criar um cluster do AKS. O exemplo a seguir cria um cluster chamado myAKSCluster com um nó. Substitua <subnetId> pela ID obtida na etapa anterior e, em seguida, <appId> e <password> pelos valores coletados na seção anterior.

az aks create \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --node-count 1 \
    --network-plugin azure \
    --service-cidr 10.0.0.0/16 \
    --dns-service-ip 10.0.0.10 \
    --docker-bridge-address 172.17.0.1/16 \
    --vnet-subnet-id <subnetId> \
    --service-principal <appId> \
    --client-secret <password>

Após alguns minutos, o comando é concluído e retorna informações formatadas em JSON sobre o cluster.

Habilitar complemento de nós virtuais

Para habilitar nós virtuais, agora use 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

Para configurar o kubectl para se conectar ao cluster do Kubernetes, use 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 para 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. Para agendar o contêiner no nó, define-se 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

Use o comando kubectl get pods com o argumento -o wide para gerar uma lista dos pods e do nó agendado. Observe que o pod aci-helloworld foi agendado no nó virtual-node-aci-linux.

kubectl get pods -o wide
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 de entidade de serviço integrada do Azure AD. 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. 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 uma sessão de terminal a ele:

kubectl run -it --rm testvk --image=mcr.microsoft.com/aks/fundamental/base-ubuntu:v0.0.11

Instale curl no pod usando apt-get:

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

Agora, acesse o endereço de seu pod usando curl; 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

Se você não quiser mais usar nós virtuais, é possível desabilitá-los usando o comando az aks disable-addons.

Se necessário, acesse https://shell.azure.com para abrir o Azure Cloud Shell no navegador.

Primeiro, exclua o pod aci-helloworld em execução no nó virtual:

kubectl delete -f virtual-node.yaml

O exemplo de comando a seguir desabilita os nós virtuais do Linux:

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

Agora, remova os recursos de rede virtual e o grupo de recursos:

# 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

# 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 0

Próximas etapas

Neste artigo, agendamos um pod no nó virtual e atribuímos a um endereço IP privado interno. 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: