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, utilizza --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.

Creare un file di main.tf per la configurazione e iniziare definendo i provider Terraform e generando un suffisso univoco per i nomi di risorse univoci a livello globale. Un nome univoco globale garantisce che il nome Registro Azure Container non sia in conflitto con i registri esistenti.

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
}

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 Registro Azure Container esistente nella 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 quindi un gruppo di risorse e un Registro Azure Container. Questo registro archivia le immagini del contenitore che il tuo cluster AKS scarica successivamente.

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
}

Ora crea il cluster AKS che utilizza le immagini dal registro. Questo cluster usa un'identità gestita assegnata dal sistema, a cui verrà concessa l'autorizzazione per il pull delle immagini.

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"
 }
}

In questa fase, il cluster AKS esiste, ma non ha ancora accesso al registro contenitori. In interfaccia della riga di comando di Azure usare il parametro --attach-acr. In Terraform si assegna in modo esplicito il AcrPull ruolo.

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
}

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.

Se il cluster AKS esiste già, è possibile collegare un Registro Azure Container riferendosi a entrambe le risorse e creando la stessa assegnazione di ruolo.

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
}

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

Per rimuovere l'accesso, eliminare l'assegnazione di ruolo che concede l'autorizzazione del cluster a scaricare le immagini.

# 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
# }

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

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
   

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

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