Eseguire l'autenticazione con Registro Azure Container (ACR) dal servizio Servizio Azure Kubernetes (AKS)

• Se si usa interfaccia della riga di comando di Azure, questo articolo richiede che sia in esecuzione interfaccia della riga di comando di Azure versione 2.7.0 o successiva. per trovare la versione, eseguire il az --version comando . Se è necessario installare o aggiornare, vedere Installare interfaccia della riga di comando di Azure.

• Se si usa Azure PowerShell, questo articolo richiede di eseguire Azure PowerShell versione 5.9.0 o successiva. Per trovare la versione, eseguire il comando Get-InstalledModule -Name Az. Se è necessario installare o aggiornare, vedere Installare Azure PowerShell.
• Esempi e sintassi per l'uso di Terraform per la configurazione di Registro Azure Container sono disponibili nelle informazioni di riferimento su Terraform.

• Terraform installato (>= 1.6).
• Interfaccia della riga di comando di Azure installata e connessa alla sottoscrizione.
• Autorizzazioni per assegnare ruoli (proprietario o amministratore accesso utenti).

In questo articolo viene configurato un cluster Servizio Azure Kubernetes (AKS) per eseguire il pull sicuro delle immagini da un Registro Azure Container (ACR). In interfaccia della riga di comando di Azure, usa --attach-acr. In Terraform, assegnare il ruolo AcrPull all'identità gestita kubelet del servizio Azure Kubernetes.

Questo articolo segue lo stesso schema del flusso di lavoro di interfaccia della riga di comando di Azure quando si utilizza Terraform per il provisioning dell'infrastruttura. Per verificare di aver eseguito l'accesso alla sottoscrizione corretta, usare i comandi di interfaccia della riga di comando di Azure seguenti:

az login
az account show

Se non si dispone già un servizio Registro Azure Container, crearne uno usando il comando az acr create.

Il nome del Registro di sistema deve essere univoco a livello globale all'interno di Azure e contenere 5-50 caratteri alfanumerici, esclusi i caratteri trattini (-). Questo nome fa parte del nome DNS completamente qualificato del registro.

export RANDOM_STRING=$(printf '%05d%05d' "$RANDOM" "$RANDOM")
export MYACR="mycontainerregistry$RANDOM_STRING"
export ACR_RESOURCE_GROUP="myContainerRegistryResourceGroup"
export LOCATION="westcentralus"

az group create \
  --name $ACR_RESOURCE_GROUP \
  --location $LOCATION

az acr create \
  --name $MYACR \
  --resource-group $ACR_RESOURCE_GROUP \
  --sku basic

La RANDOM_STRING variabile archivia una stringa casuale a 10 cifre. Il MYACR valore è concatenato con il RANDOM_STRING valore per creare un nome univoco.

Se non si dispone già un servizio Registro Azure Container, crearne uno usando il cmdlet New-AzContainerRegistry.

Il nome del Registro di sistema deve essere univoco a livello globale all'interno di Azure e contenere 5-50 caratteri alfanumerici, esclusi i caratteri trattini (-). Questo nome fa parte del nome DNS completamente qualificato del registro.

$RandomString = (Get-Random -Minimum 1000000000 -Maximum 10000000000).ToString()
$MyAcr = "mycontainerregistry$RandomString"
$AcrResourceGroup = "myContainerRegistryResourceGroup"
$Location = "westcentralus"

New-AzResourceGroup -Name $AcrResourceGroup -Location $Location

$NewAcr = @{
 Name = $MyAcr
 ResourceGroupName = $AcrResourceGroup
 Location = $Location
 Sku = "Basic"
}

New-AzContainerRegistry @NewAcr

La $RandomString variabile archivia una stringa casuale a 10 cifre. Il $MyAcr valore è concatenato con il $RandomString valore per creare un nome univoco.

L'esempio Terraform nella sezione successiva crea ACR come parte della distribuzione completa di AKS e ACR.

Creare un nuovo cluster AKS e integrarlo con un Azure Container Registry esistente usando il az aks create comando con il parametro --attach-acr. Questo comando consente di autorizzare un Azure Container Registry (ACR) esistente nella tua sottoscrizione e di configurare il ruolo AcrPull appropriato per l'identità gestita.

export CLUSTER_NAME="myAKSCluster"
export CLUSTER_RESOURCE_GROUP="myClusterResourceGroup"

az group create \
  --name $CLUSTER_RESOURCE_GROUP \
  --location $LOCATION

az aks create \
  --name $CLUSTER_NAME \
  --resource-group $CLUSTER_RESOURCE_GROUP \
  --generate-ssh-keys \
  --attach-acr $MYACR

Usare un ACR in una sottoscrizione diversa o collegarsi usando l'ID risorsa

Se si utilizza un ACR situato in una sottoscrizione diversa dal cluster AKS o si preferisce usare l'ID risorsa dell'ACR anziché il nome dell'ACR, usare la sintassi seguente. In questo esempio viene creata la ACR_RESOURCE_ID variabile usando il registro contenitori creato nella sezione precedente.

ACR_RESOURCE_ID=$(az acr show \
  --name $MYACR \
  --resource-group $ACR_RESOURCE_GROUP \
  --query id --output tsv)

az aks create \
  --name $CLUSTER_NAME \
  --resource-group $CLUSTER_RESOURCE_GROUP \
  --generate-ssh-keys \
  --attach-acr $ACR_RESOURCE_ID

Creare un nuovo cluster del servizio Azure Kubernetes e integrare con un Registro Azure Container esistente usando il cmdlet New-AzAksCluster con il parametro -AcrNameToAttach. Questo comando consente di autorizzare un Azure Container Registry (ACR) esistente nella tua sottoscrizione e di configurare il ruolo AcrPull appropriato per l'identità gestita.

$ClusterName = "myAKSCluster"
$ClusterResourceGroup = "myClusterResourceGroup"

New-AzResourceGroup -Name $ClusterResourceGroup -Location $Location

$NewCluster = @{
 Name = $ClusterName
 ResourceGroupName = $ClusterResourceGroup
 GenerateSshKey = $true
 AcrNameToAttach = $MyAcr
}

New-AzAksCluster @NewCluster

Usare un ACR in una sottoscrizione diversa o collegarsi usando l'ID risorsa

Azure PowerShell supporta solo il collegamento di ACR a AKS usando il parametro -AcrNameToAttach e non consente di collegarsi a un ACR tramite ID risorsa.

Creare un file main.tf e copiarne la configurazione di esempio testata seguente. Il repository GitHub di Azure Terraform contiene l'esempio nel repository GitHub di Azure Terraform. L'esempio crea un registro Azure Container Registry (ACR) e un cluster AKS, assegna il ruolo AcrPull all'identità gestita del kubelet, importa un'immagine NGINX nel registro e distribuisce l'immagine nel cluster.

terraform {
  required_version = ">= 1.6.0"
  required_providers {
    azapi = {
      source  = "azure/azapi"
      version = "~> 2.0"
    }
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 4.0"
    }
    random = {
      source  = "hashicorp/random"
      version = "~> 3.6"
    }
    kubernetes = {
      source  = "hashicorp/kubernetes"
      version = "~> 2.30"
    }
  }
}
provider "azurerm" {
  features {}
}
resource "random_string" "suffix" {
  length  = 6
  upper   = false
  special = false
}
locals {
  resource_group_name = "rg-aks-acr-demo"
  location            = "eastus"
  aks_name            = "aks-acr-demo"
  acr_name            = "acraksdemo${random_string.suffix.result}"
}
resource "azurerm_resource_group" "rg" {
  name     = local.resource_group_name
  location = local.location
}
resource "azurerm_container_registry" "acr" {
  name                = local.acr_name
  resource_group_name = azurerm_resource_group.rg.name
  location            = azurerm_resource_group.rg.location
  sku                 = "Basic"
  admin_enabled       = false
}
resource "azurerm_kubernetes_cluster" "aks" {
  name                = local.aks_name
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  dns_prefix          = local.aks_name
  identity {
    type = "SystemAssigned"
  }
 default_node_pool {
 name       = "systempool"
 node_count = 2
 vm_size    = "Standard_D2s_v3"
 upgrade_settings {
   drain_timeout_in_minutes      = 0
   max_surge                     = "10%"
   node_soak_duration_in_minutes = 0
 }
}
}
resource "azurerm_role_assignment" "aks_acr_pull" {
  scope                = azurerm_container_registry.acr.id
  role_definition_name = "AcrPull"
  principal_id         = azurerm_kubernetes_cluster.aks.kubelet_identity[0].object_id
}
resource "azapi_resource_action" "import_nginx_to_acr" {
  type        = "Microsoft.ContainerRegistry/registries@2023-07-01"
  resource_id = azurerm_container_registry.acr.id
  action      = "importImage"
  method      = "POST"
  body = {
    source = {
      registryUri = "docker.io"
      sourceImage = "library/nginx:latest"
    }
    targetTags = ["nginx:v1"]
    mode       = "Force"
  }
}
provider "kubernetes" {
  host                   = azurerm_kubernetes_cluster.aks.kube_config[0].host
  client_certificate     = base64decode(azurerm_kubernetes_cluster.aks.kube_config[0].client_certificate)
  client_key             = base64decode(azurerm_kubernetes_cluster.aks.kube_config[0].client_key)
  cluster_ca_certificate = base64decode(azurerm_kubernetes_cluster.aks.kube_config[0].cluster_ca_certificate)
}
resource "kubernetes_deployment_v1" "nginx" {
  depends_on = [
    azurerm_role_assignment.aks_acr_pull,
    azapi_resource_action.import_nginx_to_acr
  ]
  metadata {
    name = "nginx0-deployment"
    labels = {
      app = "nginx0-deployment"
    }
  }
  spec {
    replicas = 2
    selector {
      match_labels = {
        app = "nginx0"
      }
    }
    template {
      metadata {
        labels = {
          app = "nginx0"
        }
      }
      spec {
        container {
          name  = "nginx"
          image = "${azurerm_container_registry.acr.login_server}/nginx:v1"
          port {
            container_port = 80
          }
        }
      }
    }
  }
}
output "resource_group_name" {
  value = azurerm_resource_group.rg.name
}
output "aks_cluster_name" {
  value = azurerm_kubernetes_cluster.aks.name
}
output "acr_name" {
  value = azurerm_container_registry.acr.name
}
output "acr_login_server" {
  value = azurerm_container_registry.acr.login_server
}

Integrare un Azure Container Registry esistente con un cluster del servizio Azure Kubernetes esistente usando il comando az aks update con il parametro --attach-acr.

# Attach using acr-name
az aks update \
  --name $CLUSTER_NAME \
  --resource-group $CLUSTER_RESOURCE_GROUP \
  --attach-acr $MYACR


# Attach using acr-resource-id
az aks update \
  --name $CLUSTER_NAME \
  --resource-group $CLUSTER_RESOURCE_GROUP \
  --attach-acr $ACR_RESOURCE_ID

Il comando az aks update --attach-acr usa le autorizzazioni dell'utente che esegue il comando per creare l'assegnazione del ruolo di Registro Azure Container. Questo ruolo viene assegnato all'identità gestita kubelet. Per altre informazioni sulle identità gestite del servizio Azure Kubernetes, vedere Riepilogo delle identità gestite.

Integrare un Azure Container Registry esistente con un cluster del servizio Azure Kubernetes esistente usando il comando Set-AzAksCluster con il parametro -AcrNameToAttach.

$AttachCluster = @{
 Name = $ClusterName
 ResourceGroupName = $ClusterResourceGroup
 AcrNameToAttach = $MyAcr
}

Set-AzAksCluster @AttachCluster

Il Set-AzAksCluster -AcrNameToAttach cmdlet usa le autorizzazioni dell'utente che esegue il comando per creare l'assegnazione del ruolo ACR. Questo ruolo viene assegnato all'identità gestita kubelet. Per altre informazioni sulle identità gestite del servizio Azure Kubernetes, vedere Riepilogo delle identità gestite.

L'esempio Terraform testato crea nuove risorse AKS e ACR. Per integrare le risorse esistenti, usare la scheda interfaccia della riga di comando di Azure o Azure PowerShell oppure adattare l'assegnazione di ruolo dellAcrPull'esempio per fare riferimento alle risorse esistenti.

Rimuovere l'integrazione tra un Registro Azure Container e un cluster del servizio Azure Kubernetes usando il az aks update comando con il parametro --detach-acr.

# Detach using acr-name
az aks update \
  --name $CLUSTER_NAME \
  --resource-group $CLUSTER_RESOURCE_GROUP \
  --detach-acr $MYACR

# Detach using acr-resource-id
az aks update \
  --name $CLUSTER_NAME \
  --resource-group $CLUSTER_RESOURCE_GROUP \
  --detach-acr $ACR_RESOURCE_ID

Rimuovere l'integrazione tra un Registro Azure Container e un cluster del servizio Azure Kubernetes usando il Set-AzAksCluster comando con il parametro -AcrNameToDetach.

$DetachCluster = @{
 Name = $ClusterName
 ResourceGroupName = $ClusterResourceGroup
 AcrNameToDetach = $MyAcr
}

Set-AzAksCluster @DetachCluster

L'esempio Terraform testato non definisce un flusso di lavoro di disconnessione indipendente. Per revocare l'accesso mantenendo le risorse AKS e ACR, rimuovere dalla configurazione entrambe le risorse kubernetes_deployment_v1.nginx e azurerm_role_assignment.aks_acr_pull, quindi applicare il piano Terraform aggiornato.

Inizializzare e distribuire la configurazione

Al termine della configurazione, inizializzare Terraform ed esaminare il piano di esecuzione prima di applicarla.

terraform fmt
terraform init
terraform validate
terraform plan
terraform apply

A questo punto, il cluster AKS è configurato per recuperare le immagini da Azure Container Registry.

È ora possibile:

• Importare immagini nel Registro Azure Container.
• Distribuire carichi di lavoro su AKS.
• Verificare la distribuzione del pod.

Importare un'immagine da Docker Hub nel Azure Container Registry usando il comando az acr import.

az acr import \
  --name $MYACR \
  --source docker.io/library/nginx:latest \
  --image nginx:v1

Eseguire i comandi seguenti per verificare che l'immagine sia stata importata.

az acr repository show --name $MYACR --repository nginx
az acr repository show-tags --name $MYACR --repository nginx

L'esempio Terraform importa l'immagine NGINX in Azure Container Registry durante la distribuzione.

Importare un'immagine da Docker Hub nel Azure Container Registry usando il cmdlet Import-AzContainerRegistryImage.

$ImportImage = @{
 RegistryName = $MyAcr
 ResourceGroupName = $AcrResourceGroup
 SourceRegistryUri = 'docker.io'
 SourceImage = 'library/nginx:latest'
 TargetTag = 'nginx:v1'
}

Import-AzContainerRegistryImage @ImportImage

Eseguire i comandi seguenti per verificare che l'immagine sia stata importata.

Get-AzContainerRegistryRepository -RegistryName $MyAcr

Get-AzContainerRegistryTag -RegistryName $MyAcr -Repository nginx

1. Assicurarsi di disporre delle credenziali del servizio Azure Kubernetes appropriate usando il comando az aks get-credentials.

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

2. Eseguire la distribuzione nel cluster del servizio Azure Kubernetes usando il comando kubectl apply.

   kubectl apply -f acr-nginx.yaml
   

3. Monitorare la distribuzione usando il comando kubectl get pods.

   kubectl get pods
   

   L'output dovrebbe mostrare due pod in esecuzione, come illustrato nell'output di esempio seguente:

   NAME                                 READY   STATUS    RESTARTS   AGE
   nginx0-deployment-669dfc4d4b-x74kr   1/1     Running   0          20s
   nginx0-deployment-669dfc4d4b-xdpd6   1/1     Running   0          20s
   

L'esempio Terraform configura il provider Kubernetes e distribuisce il carico di lavoro NGINX durante terraform apply. Ottenere le credenziali del cluster e quindi verificare la distribuzione:

RESOURCE_GROUP=$(terraform output -raw resource_group_name)
CLUSTER_NAME=$(terraform output -raw aks_cluster_name)
az aks get-credentials \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME
kubectl get pods

1. Assicurarsi di disporre delle credenziali del servizio Azure Kubernetes appropriate usando il cmdlet Import-AzAksCredential.

   Import-AzAksCredential -ResourceGroupName $ClusterResourceGroup -Name $ClusterName
   

2. Eseguire la distribuzione nel cluster del servizio Azure Kubernetes usando il comando kubectl apply.

   kubectl apply -f acr-nginx.yaml
   

3. Monitorare la distribuzione usando il comando kubectl get pods.

   kubectl get pods
   

   L'output dovrebbe mostrare due pod in esecuzione, come illustrato nell'output di esempio seguente:

   NAME                                 READY   STATUS    RESTARTS   AGE
   nginx0-deployment-669dfc4d4b-x74kr   1/1     Running   0          20s
   nginx0-deployment-669dfc4d4b-xdpd6   1/1     Running   0          20s
   

az group delete --name $ACR_RESOURCE_GROUP --yes --no-wait
az group delete --name $CLUSTER_RESOURCE_GROUP --yes --no-wait

Eseguire il comando seguente dalla directory che contiene la configurazione di Terraform:

terraform destroy

Remove-AzResourceGroup -Name $AcrResourceGroup -Force
Remove-AzResourceGroup -Name $ClusterResourceGroup -Force