Implementar o CanIPull num cluster do Azure Kubernetes Service (AKS)

CanIPull é uma ferramenta de diagnóstico para Azure Kubernetes Service (AKS). Implemente-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 DNS de um servidor de autenticação do Azure Container Registry (ACR) e valida a troca inicial do token do ACR.

Este artigo mostra-lhe como executar o CanIPull usando Azure Copilot ou um manifesto Kubernetes. O CanIPull v0.1.0 é executado num nó Linux AMD64 de cada vez. Repita a verificação noutros nós suportados para comparar a sua conectividade ou configuração.

Importante

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

Pré-requisitos

Antes de começar, você precisa:

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

Para implementar o CanIPull com Azure Copilot, também precisa de acesso a Azure Copilot no portal Azure.

Para implementar o CanIPull manualmente, também precisa de:

  • CLI do Azure instalado.
  • Uma sessão CLI do Azure autenticada com permissões para obter credenciais de utilizador para o cluster AKS e ler a instância ACR.
  • kubectl configurado para estabelecer ligação ao seu cluster AKS.
  • Permissões do Kubernetes para listar nós ao nível do cluster; criar, obter, listar, monitorizar e apagar pods no espaço de nomes default; e obter os registos dos pods no espaço de nomes default.

Implemente o CanIPull com Azure Copilot

O Azure Copilot pode selecionar o cluster AKS, o nó AMD64 Linux e o servidor de autenticação ACR e, em seguida, implementar o CanIPull por si. O diagnóstico verifica a resolução de DNS e a troca de token do ACR no nó selecionado. Não seleciona nem acede a um repositório ou imagem.

  1. No portal do Azure, abra Copilot.
  2. Introduza um dos seguintes prompts:
  • 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 AKS e o nó Linux AMD64 onde pretende que o CanIPull seja executado.
  2. Selecione a instância do ACR cujo servidor de autenticação pretende utilizar nas verificações de DNS e de troca de tokens.
  3. Revê as escolhas e depois confirma a implementação.
  4. Quando a implementação estiver concluída, siga as instruções para abrir o painel do comando Executar.
  5. Consulte os registos CanIPull para DNS, identidade de cluster e resultados de troca de tokens ACR.

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

Instalar o CanIPull manualmente

Para implementar o CanIPull manualmente, ligue-se ao cluster, selecione um nó AMD64 para Linux, obtenha o servidor de login ACR totalmente qualificado, guarde o manifesto pod completo fornecido nesta secção como canipull.yaml, e execute kubectl apply --filename canipull.yaml. O one-shot pod permite-lhe escolher o nó-alvo e inspecionar diretamente os registos de diagnóstico com kubectl.

Importante

O manifesto é montado /etc/kubernetes/azure.json a partir do nó selecionado. Este ficheiro contém configurações sensíveis de identidade de cluster. Implemente o pod apenas se for um administrador de clusters de confiança. Não aumente a verbosidade do CanIPull porque níveis superiores podem imprimir tokens de acesso. Apaga o pod assim que terminares o teste.

Estabeleça ligação ao agrupamento e selecione um nó

  1. Defina variáveis para o cluster AKS e a instância 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 início de sessão do ACR. O CanIPull espera o servidor de login totalmente qualificado, como myregistry.azurecr.io, em vez do nome do recurso ACR.

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

echo $ACR_LOGIN_SERVER

  4. Liste os nós AMD64 do Linux e escolha o nó onde pretende executar a verificação de diagnóstico. CanIPull v0.1.0 é compatível apenas com nós AMD64.

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

Criar e implementar o manifesto completo do CanIPull

  1. Copie o manifesto completo para um ficheiro chamado canipull.yaml. Substitua <target-linux-node> e <acr-login-server> pelo nome do nó e pelo servidor de início de sessão do ACR da secção anterior. O manifesto fixa o CanIPull no nó selecionado, desativa a montagem do token da conta de serviço e a escalação de privilégios, e monta a configuração do nó necessária como apenas 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. Cria o pod.

    kubectl apply --filename canipull.yaml

  3. Aguarde que o pod termine.

    kubectl get pod canipull --watch

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

Rever os resultados do CanIPull

Ver o resultado do diagnóstico.

kubectl logs canipull

Um teste bem-sucedido inclui os seguintes resultados:

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

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

A mensagem final de sucesso da ferramenta utiliza uma redação mais ampla do que o âmbito do teste e assemelha-se ao seguinte resultado:

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

Para verificar uma consulta de imagem de ponta a ponta, implemente uma carga de trabalho que faça referência a uma imagem no repositório alvo.

Se o teste falhar, consulte a linha de registo assinalada com FAILED. As causas comuns incluem:

  • O servidor de autenticação ACR não pode ser resolvido 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.
  • A ACR rejeita a troca de tokens pela identidade kubelet ou principal de serviço.

Se a troca de tokens falhar porque a identidade não está autorizada a aceder ao ACR, veja Autenticar com ACR a partir do AKS.

Limpeza de recursos

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

kubectl delete pod canipull

Conteúdo relacionado

  • Última atualização a