Implantar o CanIPull em um cluster AKS (Serviço de Kubernetes do Azure)

O CanIPull é uma ferramenta de diagnóstico para AKS (Serviço de Kubernetes do Azure). Implante-o usando Azure Copilot ou o manifesto completo do Kubernetes neste artigo. O CanIPull lê a configuração de identidade do cluster a partir de um nó selecionado, verifica a resolução de DNS para um servidor de autenticação do Registro de Contêiner do Azure (ACR) e valida a troca inicial de tokens do ACR.

Este artigo mostra como executar o CanIPull usando Azure Copilot ou um manifesto do Kubernetes. O CanIPull v0.1.0 é executado em apenas um nó Linux AMD64 por vez. Repita a verificação em outros nós com suporte para comparar sua conectividade ou configuração.

Importante

O CanIPull não é um teste de extração de imagem de ponta a ponta. Um resultado bem-sucedido não confirma o acesso ao repositório, ao manifesto da imagem ou à camada da imagem, porque o CanIPull não seleciona nem extrai uma imagem.

Pré-requisitos

Antes de começar, você precisa de:

  • Um cluster do AKS existente com pelo menos um nó Linux AMD64.
  • Uma instância do ACR existente que você deseja testar.

Para implantar o CanIPull com Azure Copilot, você também precisa ter acesso a Azure Copilot no portal Azure.

Para implantar o CanIPull manualmente, você também precisa:

  • CLI do Azure instalado.
  • Uma sessão de CLI do Azure autenticada com permissões para obter credenciais de usuário para o cluster do AKS e ler a instância do ACR.
  • kubectl configurado para se conectar ao cluster do AKS.
  • Permissões do Kubernetes para listar nós em escopo de cluster; criar, recuperar, listar, monitorar e excluir pods no namespace default; e recuperar logs dos pods no namespace default.

Implantar o CanIPull com Azure Copilot

O Azure Copilot pode selecionar o cluster do AKS, o nó Linux AMD64 e o servidor de autenticação do ACR e, em seguida, implantar o CanIPull para você. O diagnóstico verifica a resolução de DNS e a troca de token do ACR a partir do nó selecionado. Ele não seleciona nem acessa um repositório ou imagem.

  1. No portal do Azure, abra Copilot.
  2. Insira um dos seguintes comandos:
  • Help me deploy CanIPull to my AKS cluster.
  • Can an AMD64 Linux node in my AKS cluster resolve and authenticate to a specific Azure Container Registry?
  • Help me test ACR token exchange from an AMD64 Linux node in my AKS cluster.
  1. Selecione o cluster do AKS e o nó Linux AMD64 no qual você deseja que o CanIPull seja executado.
  2. Selecione a instância do ACR cujo servidor de autenticação você deseja usar para as verificações de troca de token e DNS.
  3. Examine as seleções e confirme a implantação.
  4. Após a conclusão da implantação, siga o prompt para abrir o painel Executar comando .
  5. Examine os logs do CanIPull para obter resultados de DNS, identidade de cluster e troca de token do ACR.

Para obter mais informações sobre essa experiência, consulte Usar CanIPull com Azure Copilot.

Implantar o CanIPull manualmente

Para implantar o CanIPull manualmente, conecte-se ao cluster, selecione um nó Linux AMD64, obtenha o servidor de logon do ACR totalmente qualificado e salve o manifesto completo do pod fornecido nesta seção como canipull.yaml e execute kubectl apply --filename canipull.yaml. O pod de uso único permite que você escolha o nó de destino e inspecione os logs de diagnóstico diretamente com kubectl.

Importante

O manifesto monta /etc/kubernetes/azure.json a partir do nó selecionado. Esse arquivo contém uma configuração de identidade de cluster confidencial. Implante o pod somente se você for um administrador de cluster confiável. Não aumente a verbosidade do CanIPull porque níveis mais altos podem imprimir os tokens de acesso. Exclua o pod assim que concluir o teste.

Conectar ao cluster e selecionar um nó

  1. Defina variáveis para o cluster do AKS e a instância do ACR.

    RESOURCE_GROUP=<resource-group>
CLUSTER_NAME=<aks-cluster-name>
ACR_NAME=<acr-name>

  2. Obtenha as credenciais do cluster.

    az aks get-credentials \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME

  3. Obtenha o servidor de logon do ACR. O CanIPull espera o servidor de login totalmente qualificado, como myregistry.azurecr.io, em vez do nome do recurso do ACR.

    ACR_LOGIN_SERVER=$(az acr show \
  --name $ACR_NAME \
  --query loginServer \
  --output tsv)

echo $ACR_LOGIN_SERVER

  4. Liste os nós AMD64 Linux e escolha o nó em que você deseja executar a verificação de diagnóstico. O CanIPull v0.1.0 suporta apenas nodos AMD64.

    kubectl get nodes \
  --selector kubernetes.io/os=linux,kubernetes.io/arch=amd64 \
  --output wide

Criar e implantar o manifesto CanIPull completo

  1. Copie o manifesto completo em um arquivo chamado canipull.yaml. Substitua <target-linux-node> e <acr-login-server> pelo nome do nó e pelo servidor de logon do ACR da seção anterior. O manifesto fixa o CanIPull ao nó selecionado, desabilita a montagem de tokens de conta de serviço e a escalada de privilégios, e monta a configuração de nó necessária como somente leitura.

    apiVersion: v1
kind: Pod
metadata:
  name: canipull
  namespace: default
  labels:
    app: canipull
spec:
  automountServiceAccountToken: false
  nodeName: <target-linux-node>
  restartPolicy: Never
  containers:
    - name: canipull
      image: mcr.microsoft.com/aks/canipull:v0.1.0
      imagePullPolicy: IfNotPresent
      args:
        - <acr-login-server>
      securityContext:
        allowPrivilegeEscalation: false
        capabilities:
          drop:
            - ALL
        readOnlyRootFilesystem: true
      volumeMounts:
        - name: azure-config
          mountPath: /etc/kubernetes/azure.json
          readOnly: true
  volumes:
    - name: azure-config
      hostPath:
        path: /etc/kubernetes/azure.json
        type: File

  2. Crie o pod.

    kubectl apply --filename canipull.yaml

  3. Aguarde a conclusão do pod.

    kubectl get pod canipull --watch

    Pressione Ctrl+C quando o estado do pod mudar para Completed ou Error.

Revise os resultados do CanIPull

Exiba a saída de diagnóstico.

kubectl logs canipull

Um teste bem-sucedido inclui os seguintes resultados:

  • O servidor de autenticação do ACR é resolvido por meio do DNS.
  • O CanIPull lê a configuração do Azure do nó.
  • A identidade do kubelet do cluster ou a entidade de serviço pode se autenticar.
  • O ACR aceita a troca de tokens inicial.

Esses resultados confirmam apenas que o nó selecionado pode resolver o servidor de autenticação do ACR e que a identidade do cluster pode concluir a troca inicial de tokens. O CanIPull não puxa uma imagem nem valida o acesso a um repositório, manifesto de imagem ou camada de imagem.

A mensagem de sucesso final da ferramenta usa uma redação mais ampla do que o escopo do teste e se assemelha à seguinte saída:

Your cluster can pull images from <acr-login-server>!

Para verificar um pull de imagem de ponta a ponta, implante uma carga de trabalho que faça referência a uma imagem no repositório de destino.

Se o teste falhar, examine a linha de log marcada FAILED. As causas mais comuns incluem:

  • Não é possível resolver o servidor de autenticação do ACR a partir do nó selecionado.
  • O nó selecionado não contém /etc/kubernetes/azure.json.
  • As credenciais de identidade do cluster não são válidas.
  • O ACR rejeita a troca de token para a identidade do kubelet ou a entidade de serviço.

Se a troca de tokens falhar porque a identidade não está autorizada a acessar o ACR, consulte Authenticate with ACR from AKS.

Limpar os recursos

Exclua o pod CanIPull e remova seu acesso à configuração do nó.

kubectl delete pod canipull

Conteúdo relacionado

  • Última atualização em