Implementación de CanIPull en un clúster de Azure Kubernetes Service (AKS)

CanIPull es una herramienta de diagnóstico para Azure Kubernetes Service (AKS). Impleméntelo mediante Azure Copilot o el manifiesto completo de Kubernetes en este artículo. CanIPull lee la configuración de identidad del clúster de un nodo seleccionado, comprueba la resolución dns de un servidor de autenticación de Azure Container Registry (ACR) y valida el intercambio inicial de tokens de ACR.

En este artículo se muestra cómo ejecutar CanIPull mediante Azure Copilot o un manifiesto de Kubernetes. CanIPull v0.1.0 se ejecuta en un nodo de Linux AMD64 a la vez. Repita la comprobación en otros nodos admitidos para comparar su conectividad o configuración.

Importante

CanIPull no es una prueba de extracción de imágenes de un extremo a otro. Un resultado correcto no confirma el acceso a un repositorio, un manifiesto de imagen o una capa de imagen porque CanIPull no selecciona ni extrae una imagen.

Prerequisites

Antes de comenzar, necesita lo siguiente:

  • Un clúster de AKS existente con al menos un nodo AMD64 Linux.
  • Una instancia de ACR existente que desea probar.

Para implementar CanIPull con Azure Copilot, también necesita acceso a Azure Copilot en el portal de Azure.

Para implementar CanIPull manualmente, también necesita lo siguiente:

  • CLI de Azure instalado.
  • Una sesión de CLI de Azure autenticada con permisos para obtener credenciales de usuario para el clúster de AKS y leer la instancia de ACR.
  • kubectl configurado para conectarse al clúster de AKS.
  • Permisos de Kubernetes para enumerar nodos en el ámbito del clúster; crear, obtener, enumerar, supervisar y eliminar pods en el espacio de nombres default; y obtener registros de pods en el espacio de nombres default.

Implementación de CanIPull con Azure Copilot

Azure Copilot puede seleccionar el clúster de AKS, el nodo AMD64 Linux y el servidor de autenticación de ACR y, a continuación, implementar CanIPull automáticamente. El diagnóstico comprueba la resolución DNS y el intercambio de tokens de ACR desde el nodo seleccionado. No selecciona ni accede a un repositorio ni a una imagen.

  1. En el portal de Azure, abra Copilot.
  2. Introduzca una de las siguientes instrucciones:
  • 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. Seleccione el clúster de AKS y el nodo AMD64 Linux donde desea que se ejecute CanIPull.
  2. Seleccione la instancia de ACR cuyo servidor de autenticación desea usar para las comprobaciones de intercambio de tokens y DNS.
  3. Revise las selecciones y confirme la implementación.
  4. Una vez completado el despliegue, siga las indicaciones para abrir el panel Ejecutar un comando.
  5. Revise los registros de CanIPull para los resultados de intercambio de tokens de DNS, identidad de clúster y ACR.

Para obtener más información sobre esta experiencia, consulte Uso de CanIPull con Azure Copilot.

Implementación manual de CanIPull

Para implementar CanIPull manualmente, conéctese al clúster, seleccione un nodo Linux AMD64, obtenga el servidor de inicio de sesión completo de ACR, guarde el manifiesto completo del pod proporcionado en esta sección como canipull.yaml y ejecute kubectl apply --filename canipull.yaml. El pod de un solo uso le permite elegir el nodo de destino e inspeccionar los registros de diagnóstico directamente con kubectl.

Importante

El manifiesto monta /etc/kubernetes/azure.json desde el nodo seleccionado. Este archivo contiene la configuración de identidad de clúster confidencial. Implementa el pod solo si eres un administrador de clúster de confianza. No aumente la verbosidad de CanIPull porque los niveles más altos pueden imprimir tokens de acceso. Elimine el pod tan pronto como finalice la prueba.

Conexión al clúster y selección de un nodo

  1. Establezca variables para el clúster de AKS y la instancia de ACR.

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

  2. Obtenga las credenciales del clúster.

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

  3. Obtenga el servidor de inicio de sesión de ACR. CanIPull espera el servidor de inicio de sesión con el nombre completo, como myregistry.azurecr.io, en lugar del nombre del recurso ACR.

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

echo $ACR_LOGIN_SERVER

  4. Enumere los nodos de Linux AMD64 y elija el nodo donde desea ejecutar la comprobación de diagnóstico. CanIPull v0.1.0 solo admite nodos AMD64.

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

Creación e implementación del manifiesto CanIPull completo

  1. Copie el manifiesto completo en un archivo denominado canipull.yaml. Reemplace <target-linux-node> y <acr-login-server> por el nombre del nodo y el servidor de inicio de sesión de ACR de la sección anterior. El manifiesto vincula CanIPull al nodo seleccionado, desactiva el montaje de tokens de cuentas de servicio y la escalada de privilegios, y monta la configuración necesaria del nodo como de solo lectura.

    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. Cree el pod.

    kubectl apply --filename canipull.yaml

  3. Espere a que finalice el pod.

    kubectl get pod canipull --watch

    Presione Ctrl+C cuando el estado del pod cambie a Completed o Error.

Revisar los resultados de CanIPull

Vea la salida de diagnóstico.

kubectl logs canipull

Una prueba correcta incluye los siguientes resultados:

  • El servidor de autenticación ACR se resuelve a través de DNS.
  • CanIPull lee la configuración de Azure del nodo.
  • La identidad del kubelet del clúster o la entidad de servicio pueden autenticarse.
  • ACR acepta el intercambio de tokens inicial.

Estos resultados solo confirman que el nodo seleccionado puede resolver el servidor de autenticación de ACR y que la identidad del clúster puede completar el intercambio inicial de tokens. CanIPull no extrae una imagen ni valida el acceso a un repositorio, un manifiesto de imagen o una capa de imagen.

El mensaje de éxito final de la herramienta usa una redacción más amplia que el ámbito de la prueba y se parece a la siguiente salida:

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

Para comprobar una extracción de imágenes de un extremo a otro, implemente una carga de trabajo que haga referencia a una imagen en el repositorio de destino.

Si se produce un error en la prueba, revise la línea de registro marcada como FAILED. Entre las causas comunes se incluyen las siguientes:

  • El servidor de autenticación ACR no se resuelve desde el nodo seleccionado.
  • El nodo seleccionado no contiene /etc/kubernetes/azure.json.
  • Las credenciales de identidad del clúster no son válidas.
  • ACR rechaza el intercambio de tokens para la identidad del kubelet o la entidad de servicio.

Si se produce un error en el intercambio de tokens porque la identidad no está autorizada para acceder a ACR, consulte Autenticación con ACR desde AKS.

Limpieza de recursos

Elimine el pod CanIPull y quite su acceso a la configuración del nodo.

kubectl delete pod canipull

Contenido relacionado

  • Se actualizó por última vez el