Distribuire CanIPull in un cluster Servizio Azure Kubernetes (AKS)

CanIPull è uno strumento di diagnostica per Servizio Azure Kubernetes (AKS). Distribuirlo usando Azure Copilot o il manifest Kubernetes completo in questo articolo. CanIPull legge la configurazione dell'identità del cluster da un nodo selezionato, controlla la risoluzione DNS per un server di autenticazione di Registro Azure Container (ACR) e convalida lo scambio iniziale di token di Registro Azure Container.

Questo articolo illustra come eseguire CanIPull usando Azure Copilot o un manifesto Kubernetes. CanIPull v0.1.0 viene eseguito in un nodo AMD64 Linux alla volta. Ripetere il controllo su altri nodi supportati per confrontare la connettività o la configurazione.

Importante

CanIPull non è un test end-to-end di scaricamento delle immagini. Un risultato riuscito non conferma l'accesso a un repository, a un manifesto dell'immagine o a un livello immagine perché CanIPull non seleziona o esegue il pull di un'immagine.

Prerequisiti

Prima di iniziare, è necessario disporre di quanto segue:

Un cluster AKS esistente con almeno un nodo Linux AMD64.
Un'istanza ACR di Azure Container Registry esistente che si desidera testare.

Per distribuire CanIPull con Azure Copilot, è anche necessario accedere a Azure Copilot nel portale di Azure.

Per distribuire CanIPull manualmente, è anche necessario:

interfaccia della riga di comando di Azure installato.
Una sessione autenticata di interfaccia della riga di comando di Azure con autorizzazioni per ottenere le credenziali utente per il cluster AKS e accedere in lettura all'istanza di Azure Container Registry (ACR).
kubectl configurato per connettersi al cluster AKS.
Autorizzazioni di Kubernetes per elencare i nodi a livello di cluster; creare, recuperare, elencare, monitorare ed eliminare i pod nel namespace default; e recuperare i log dei pod nel namespace default.

Distribuire CanIPull con Azure Copilot

Azure Copilot può selezionare il cluster AKS, il nodo Linux AMD64 e il server di autenticazione ACR, quindi distribuire CanIPull per l'utente. La diagnostica verifica la risoluzione DNS e lo scambio di token Registro Azure Container dal nodo selezionato. Non seleziona o accede a un repository o a un'immagine.

Nel portale di Azure aprire Copilot.
Immettere una delle richieste seguenti:

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.

Selezionare il cluster AKS e il nodo Linux AMD64 in cui si desidera eseguire CanIPull.
Selezionare l'istanza di ACR di cui si desidera utilizzare il server di autenticazione per i controlli DNS e dello scambio di token.
Esaminare le selezioni e quindi confermare la distribuzione.
Al termine della distribuzione, seguire il prompt per aprire il riquadro Esegui comando .
Esamina i log di CanIPull per DNS, l'identità del cluster e i risultati dello scambio di token ACR.

Per altre informazioni su questa esperienza, vedere Usare CanIPull con Azure Copilot.

Distribuire CanIPull manualmente

Per distribuire CanIPull manualmente, connettersi al cluster, selezionare un nodo Linux AMD64, ottenere il nome completo del server di accesso Registro Azure Container, salvare il manifesto completo del pod fornito in questa sezione come canipull.yaml ed eseguire kubectl apply --filename canipull.yaml. Il pod one-shot consente di scegliere il nodo di destinazione ed esaminare i log di diagnostica direttamente con kubectl.

Importante

Il manifest monta /etc/kubernetes/azure.json dal nodo selezionato. Questo file contiene una configurazione sensibile dell'identità del cluster. Distribuisci il pod solo se sei un amministratore del cluster autorizzato. Non aumentare il livello di dettaglio di CanIPull perché i livelli superiori possono visualizzare i token di accesso. Elimina il pod non appena hai finito il test.

Connettersi al cluster e selezionare un nodo

Impostare le variabili per il cluster AKS e l'istanza ACR.

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

Ottenere le credenziali del cluster.

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

Ottenere il server di accesso Registro Azure Container. CanIPull richiede il server di accesso completo, ad esempio myregistry.azurecr.io, anziché il nome della risorsa Registro Azure Container.
```
ACR_LOGIN_SERVER=$(az acr show \
  --name $ACR_NAME \
  --query loginServer \
  --output tsv)

echo $ACR_LOGIN_SERVER
```
Elencare i nodi LINUX AMD64 e scegliere il nodo in cui si vuole eseguire il controllo di diagnostica. CanIPull v0.1.0 supporta solo nodi AMD64.
```
kubectl get nodes \
  --selector kubernetes.io/os=linux,kubernetes.io/arch=amd64 \
  --output wide
```

Creare e distribuire il manifesto CanIPull completo

Copiare il manifesto completo in un file denominato canipull.yaml. Sostituire <target-linux-node> e <acr-login-server> con il nome del nodo e il server di accesso ACR della sezione precedente. Il manifesto vincola CanIPull al nodo selezionato, disabilita il montaggio del token dell'account di servizio e l'escalation dei privilegi, e monta la configurazione del nodo necessaria in sola lettura.

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

Creare il pod.
```
kubectl apply --filename canipull.yaml
```
Attendere il completamento del pod.
```
kubectl get pod canipull --watch
```
Premere CTRL+C quando lo stato del pod cambia in Completed o Error.

Esaminare i risultati di CanIPull

Visualizzare l'output della diagnostica.

kubectl logs canipull

Un test riuscito include i risultati seguenti:

Il server di autenticazione ACR viene risolto tramite DNS.
CanIPull legge la configurazione Azure dal nodo.
L'identità kubelet o l'entità servizio del cluster può eseguire l'autenticazione.
Azure Container Registry accetta lo scambio iniziale del token.

Questi risultati confermano solo che il nodo selezionato è in grado di risolvere il server di autenticazione ACR e che l'identità del cluster può completare lo scambio iniziale del token. CanIPull non scarica un'immagine né verifica l'accesso a un repository, al manifest dell'immagine o a un layer dell'immagine.

Il messaggio di esito positivo finale dello strumento usa una formulazione più ampia rispetto all'ambito del test e assomiglia all'output seguente:

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

Per verificare un pull dell'immagine end-to-end, distribuire un carico di lavoro che faccia riferimento a un'immagine nel repository di destinazione.

Se il test non riesce, esaminare la riga del log contrassegnata come FAILED. Le cause più comuni includono:

Il server di autenticazione Registro Azure Container non viene risolto dal nodo selezionato.
Il nodo selezionato non contiene /etc/kubernetes/azure.json.
Le credenziali di identità del cluster non sono valide.
Registro Azure Container rifiuta lo scambio di token per l'identità kubelet o l'entità servizio.

Se lo scambio del token non riesce perché l'identità non è autorizzata ad accedere ad ACR, vedi Autenticarsi con ACR da AKS.

Pulire le risorse

Eliminare il pod CanIPull e rimuovere l'accesso alla configurazione del nodo.

kubectl delete pod canipull

Commenti e suggerimenti

Questa pagina è stata utile?

Ultimo aggiornamento: 2026-09-02