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 rôle AcrPull à l’identité managée de kubelet AKS.

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, sans les caractères de type 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.

Créez un fichier main.tf pour la configuration, puis commencez par définir les fournisseurs Terraform et générez un suffixe unique pour les noms de ressources globaux uniques. Un nom global unique garantit que votre nom de Azure Container Registry n'est pas en conflit avec les registres existants.

terraform {
 required_version = ">= 1.6.0"
 required_providers {
   azurerm = {
     source  = "hashicorp/azurerm"
     version = "~> 4.0"
   }
   random = {
     source  = "hashicorp/random"
     version = "~> 3.6"
   }
 }
}
provider "azurerm" {
 features {}
}
resource "random_string" "suffix" {
 length  = 6
 upper   = false
 special = false
}

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 l'associer avec 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.

Ensuite, créez un groupe de ressources et un Azure Container Registry. Ce Registre stocke les images conteneur que votre cluster AKS extrait ultérieurement.

locals {
 location           = "westcentralus"
 acr_name           = "myacr${random_string.suffix.result}"
 acr_resource_group = "myContainerRegistryResourceGroup"
}
resource "azurerm_resource_group" "acr_rg" {
 name     = local.acr_resource_group
 location = local.location
}
resource "azurerm_container_registry" "acr" {
 name                = local.acr_name
 resource_group_name = azurerm_resource_group.acr_rg.name
 location            = azurerm_resource_group.acr_rg.location
 sku                 = "Basic"
 admin_enabled       = false
}

Créez maintenant le cluster AKS qui utilise des images du registre. Ce cluster utilise une identité managée affectée par le système, qui sera autorisée à extraire des images.

locals {
 aks_name           = "myAKSCluster"
 aks_resource_group = "myClusterResourceGroup"
}
resource "azurerm_resource_group" "aks_rg" {
 name     = local.aks_resource_group
 location = local.location
}
resource "azurerm_kubernetes_cluster" "aks" {
 name                = local.aks_name
 location            = azurerm_resource_group.aks_rg.location
 resource_group_name = azurerm_resource_group.aks_rg.name
 dns_prefix          = local.aks_name
 identity {
   type = "SystemAssigned"
 }
 default_node_pool {
   name       = "systempool"
   node_count = 2
   vm_size    = "Standard_DS2_v2"
 }
}

À ce stade, le cluster AKS existe, mais il n’a pas encore accès au registre de conteneurs. Dans Azure CLI, utilisez le paramètre --attach-acr. Dans Terraform, vous attribuez explicitement le AcrPull rôle.

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
}

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.

Si votre cluster AKS existe déjà, vous pouvez attacher un ACR en référençant les deux ressources et en créant la même attribution de rôle.

data "azurerm_kubernetes_cluster" "existing_aks" {
 name                = "myAKSCluster"
 resource_group_name = "myClusterResourceGroup"
}
data "azurerm_container_registry" "existing_acr" {
 name                = "mycontainerregistry"
 resource_group_name = "myContainerRegistryResourceGroup"
}
resource "azurerm_role_assignment" "existing_aks_acr_pull" {
 scope                = data.azurerm_container_registry.existing_acr.id
 role_definition_name = "AcrPull"
 principal_id         = data.azurerm_kubernetes_cluster.existing_aks.kubelet_identity[0].object_id
}

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

Pour supprimer l’accès, supprimez l’attribution de rôle qui accorde l’autorisation du cluster pour tirer des images.

# Remove this resource to revoke access
# resource "azurerm_role_assignment" "existing_aks_acr_pull" {
#   scope                = data.azurerm_container_registry.existing_acr.id
#   role_definition_name = "AcrPull"
#   principal_id         = data.azurerm_kubernetes_cluster.existing_aks.kubelet_identity[0].object_id
# }

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

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
   

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

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