S’authentifier avec Azure Container Registry (ACR) à partir d’Azure Kubernetes Service (AKS)

• Si vous utilisez Azure CLI, cet article nécessite que vous exécutez Azure CLI version 2.7.0 ou ultérieure. pour rechercher la version, exécutez la az --version commande. Si vous devez installer ou mettre à niveau, consultez Installer Azure CLI.

• Si vous utilisez Azure PowerShell, cet article nécessite que vous exécutez Azure PowerShell version 5.9.0 ou ultérieure. Pour connaître la version de l’interface, exécutez la commande Get-InstalledModule -Name Az. Si vous devez installer ou mettre à niveau, consultez Installer Azure PowerShell.
• Vous trouverez des exemples et une syntaxe pour utiliser Terraform pour configurer ACR dans la référence Terraform.

• Terraform installé (>= 1.6).
• Azure CLI installé et connecté à votre abonnement.
• Autorisations d’attribution de rôles (propriétaire ou administrateur de l’accès utilisateur).

Dans cet article, vous allez configurer un cluster Azure Kubernetes Service (AKS) pour extraire en toute sécurité des images d’un Azure Container Registry (ACR). Dans Azure CLI, utilisez --attach-acr. Dans Terraform, affectez le AcrPull rôle à l’identité managée AKS kubelet.

Cet article suit le même flux que le flux de travail Azure CLI lors de l’utilisation de Terraform pour l’approvisionnement d’infrastructure. Pour vérifier que vous êtes connecté à l'abonnement approprié, utilisez les commandes Azure CLI suivantes :

az login
az account show

Si vous n’avez pas encore de registre ACR, créez-en un à l’aide de la commande az acr create.

Le nom du registre doit être globalement unique dans Azure et contenir 5 à 50 caractères alphanumériques, à l’exception du caractère tiret (-). Ce nom fait partie du nom DNS complet du Registre.

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 variable stocke une chaîne à 10 chiffres aléatoire. La MYACR valeur est concaténée avec la RANDOM_STRING valeur pour créer un nom unique.

Si vous n’avez pas encore de registre ACR, créez-en un à l’aide de la cmdlet New-AzContainerRegistry.

Le nom du registre doit être globalement unique dans Azure et contenir 5 à 50 caractères alphanumériques, à l’exception du caractère tiret (-). Ce nom fait partie du nom DNS complet du Registre.

$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 variable stocke une chaîne à 10 chiffres aléatoire. La $MyAcr valeur est concaténée avec la $RandomString valeur pour créer un nom unique.

L’exemple Terraform dans la section suivante crée l’ACR dans le cadre du déploiement complet d’AKS et d’ACR.

Créez un cluster AKS et intégrez-le à un ACR existant à l’aide de la az aks create commande avec le --attach-acr paramètre. Cette commande vous permet d’autoriser un ACR existant dans votre abonnement et de configurer le rôle approprié AcrPull pour l’identité managée.

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

Utiliser un ACR dans un autre abonnement ou attacher à l’aide de l’ID de ressource

Si vous utilisez un ACR situé dans un autre abonnement que votre cluster AKS ou si vous préférez utiliser l’ID de ressource ACR au lieu du nom ACR, utilisez la syntaxe suivante. Cet exemple crée la ACR_RESOURCE_ID variable à l’aide du registre de conteneurs créé dans la section précédente.

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

Créez un cluster AKS et intégrez-le à un ACR existant à l’aide de l’applet New-AzAksCluster de commande avec le -AcrNameToAttach paramètre. Cette commande vous permet d’autoriser un ACR existant dans votre abonnement et de configurer le rôle approprié AcrPull pour l’identité managée.

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

New-AzResourceGroup -Name $ClusterResourceGroup -Location $Location

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

New-AzAksCluster @NewCluster

Utiliser un ACR dans un autre abonnement ou attacher à l’aide de l’ID de ressource

Azure PowerShell prend uniquement en charge l'attachement d'ACR à AKS à l'aide du paramètre -AcrNameToAttach et ne prend pas en charge l'attachement à un ACR par resource ID.

Créez un fichier main.tf et copiez l’exemple de configuration testé suivant. Le dépôt Azure Terraform GitHub gère l’exemple dans le référentiel Azure Terraform GitHub. L’exemple crée un ACR et un cluster AKS, affecte le AcrPull rôle à l’identité managée kubelet, importe une image NGINX dans le Registre et déploie cette image sur le 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
}

Intégrez un ACR existant à un cluster AKS existant à l’aide de la commande az aks update avec le paramètre --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

La commande az aks update --attach-acr utilise les autorisations de l’utilisateur qui exécute la commande pour créer l’attribution de rôle ACR. Ce rôle est attribué à l’identité managée kubelet. Pour plus d’informations sur les identités managées AKS, consultez Résumé des identités managées.

Intégrez un ACR existant à un cluster AKS existant à l’aide de la commande Set-AzAksCluster avec le paramètre -AcrNameToAttach.

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

Set-AzAksCluster @AttachCluster

L’applet Set-AzAksCluster -AcrNameToAttach de commande utilise les autorisations de l’utilisateur exécutant la commande pour créer l’attribution de rôle ACR. Ce rôle est attribué à l’identité managée kubelet. Pour plus d’informations sur les identités managées AKS, consultez Résumé des identités managées.

L’exemple Terraform testé crée de nouvelles ressources AKS et ACR. Pour intégrer des ressources existantes, utilisez l'onglet Azure CLI ou Azure PowerShell, ou adaptez l'attribution de rôle de AcrPull l'exemple pour référencer vos ressources existantes.

Supprimez l’intégration entre un ACR et un cluster AKS à l’aide de la az aks update commande avec le --detach-acr paramètre.

# 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

Supprimez l’intégration entre un ACR et un cluster AKS à l’aide de la Set-AzAksCluster commande avec le -AcrNameToDetach paramètre.

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

Set-AzAksCluster @DetachCluster

L’exemple Terraform testé ne définit pas de workflow distinct de dissociation. Pour révoquer l’accès tout en préservant les ressources AKS et ACR, supprimez de votre configuration les ressources azurerm_role_assignment.aks_acr_pull et kubernetes_deployment_v1.nginx, puis appliquez le plan Terraform mis à jour.

Initialiser et déployer la configuration

Une fois votre configuration terminée, initialisez Terraform et passez en revue le plan d’exécution avant d’appliquer.

terraform fmt
terraform init
terraform validate
terraform plan
terraform apply

À ce stade, votre cluster AKS est configuré pour extraire des images d’ACR.

Vous pouvez désormais :

• Importez des images dans ACR.
• Déployez des charges de travail sur AKS.
• Vérifier le pod de déploiement.

Importez une image à partir de Docker Hub dans votre ACR à l’aide de la commande az acr import.

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

Exécutez les commandes suivantes pour vérifier que l’image a été importée.

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

L’exemple Terraform importe l’image NGINX dans ACR pendant le déploiement.

Importez une image à partir de Docker Hub dans votre ACR à l’aide de l’applet de commande Import-AzContainerRegistryImage.

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

Import-AzContainerRegistryImage @ImportImage

Exécutez les commandes suivantes pour vérifier que l’image a été importée.

Get-AzContainerRegistryRepository -RegistryName $MyAcr

Get-AzContainerRegistryTag -RegistryName $MyAcr -Repository nginx

1. Vérifiez que vous disposez des informations d’identification AKS appropriées à l’aide de la commande az aks get-credentials.

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

2. Exécutez le déploiement dans votre cluster AKS à l’aide de la commande kubectl apply.

   kubectl apply -f acr-nginx.yaml
   

3. Surveillez le déploiement à l’aide de la commande kubectl get pods.

   kubectl get pods
   

   La sortie doit afficher deux pods en cours d’exécution, comme indiqué dans l’exemple de sortie suivant :

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

L’exemple Terraform configure le fournisseur Kubernetes et déploie la charge de travail NGINX pendant terraform apply. Obtenez les informations d’identification du cluster, puis vérifiez le déploiement :

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. Vérifiez que vous disposez des informations d’identification AKS appropriées à l’aide de la cmdlet Import-AzAksCredential.

   Import-AzAksCredential -ResourceGroupName $ClusterResourceGroup -Name $ClusterName
   

2. Exécutez le déploiement dans votre cluster AKS à l’aide de la commande kubectl apply.

   kubectl apply -f acr-nginx.yaml
   

3. Surveillez le déploiement à l’aide de la commande kubectl get pods.

   kubectl get pods
   

   La sortie doit afficher deux pods en cours d’exécution, comme indiqué dans l’exemple de sortie suivant :

   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

Exécutez la commande suivante à partir du répertoire qui contient la configuration Terraform :

terraform destroy

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