Autentisera med Azure Container Registry (ACR) från Azure Kubernetes Service (AKS)

• Om du använder Azure CLI kräver den här artikeln att du kör Azure CLI version 2.7.0 eller senare. för att hitta versionen kör du az --version kommandot . Om du behöver installera eller uppgradera kan du läsa Installera Azure CLI.

• Om du använder Azure PowerShell kräver den här artikeln att du kör Azure PowerShell version 5.9.0 eller senare. Kör kommando Get-InstalledModule -Name Az för att hitta versionen. Om du behöver installera eller uppgradera kan du läsa Installera Azure PowerShell.
• Exempel och syntax för att använda Terraform för att konfigurera ACR finns i Terraform-referensen.

• Terraform installerat (>= 1.6).
• Azure CLI installerad och inloggad till din prenumeration.
• Behörigheter för att tilldela roller (ägare eller administratör för användaråtkomst).

I den här artikeln konfigurerar du ett Azure Kubernetes Service (AKS) kluster för att på ett säkert sätt hämta avbildningar från en Azure Container Registry (ACR). I Azure CLI använder du --attach-acr. I Terraform tilldelar du AcrPull rollen till den hanterade AKS-kubelet-identiteten.

Den här artikeln följer samma flöde som det Azure CLI arbetsflödet när terraform används för infrastrukturetablering. Om du vill kontrollera att du är inloggad på rätt prenumeration använder du följande Azure CLI kommandon:

az login
az account show

Om du inte redan har en ACR skapar du en med kommandot az acr create .

Registernamnet måste vara globalt unikt inom Azure och innehålla 5–50 alfanumeriska tecken, exklusive strecktecken (-). Det här namnet är en del av registrets fullständigt kvalificerade DNS-namn.

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

Variabeln RANDOM_STRING lagrar en slumpmässig 10-siffrig sträng. Värdet MYACR sammanfogas med värdet RANDOM_STRING för att skapa ett unikt namn.

Om du inte redan har en ACR skapar du en med hjälp av cmdleten New-AzContainerRegistry .

Registernamnet måste vara globalt unikt inom Azure och innehålla 5–50 alfanumeriska tecken, exklusive strecktecken (-). Det här namnet är en del av registrets fullständigt kvalificerade DNS-namn.

$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

Variabeln $RandomString lagrar en slumpmässig 10-siffrig sträng. Värdet $MyAcr sammanfogas med värdet $RandomString för att skapa ett unikt namn.

Skapa en main.tf-fil för konfigurationen och börja med att definiera Terraform-leverantörerna och generera ett unikt suffix för globalt unika resursnamn. Ett globalt unikt namn säkerställer att ditt Azure Container Registry namn inte är i konflikt med befintliga register.

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
}

Skapa ett nytt AKS-kluster och integrera med en befintlig ACR med kommandot az aks create med parametern --attach-acr . Med det här kommandot kan du auktorisera en befintlig ACR i din prenumeration och konfigurerar lämplig AcrPull roll för den hanterade identiteten.

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

Använd en ACR i en annan prenumeration eller koppla med resurs-ID

Om du använder en ACR som finns i en annan prenumeration än ditt AKS-kluster eller föredrar att använda ACR-resurs-ID:t i stället för ACR-namnet använder du följande syntax. Det här exemplet skapar variabeln ACR_RESOURCE_ID med hjälp av containerregistret som skapades i föregående avsnitt.

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

Skapa ett nytt AKS-kluster och integrera med en befintlig ACR med hjälp av cmdleten New-AzAksCluster med parametern -AcrNameToAttach . Med det här kommandot kan du auktorisera en befintlig ACR i din prenumeration och konfigurerar lämplig AcrPull roll för den hanterade identiteten.

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

New-AzResourceGroup -Name $ClusterResourceGroup -Location $Location

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

New-AzAksCluster @NewCluster

Använd en ACR i en annan prenumeration eller koppla genom resurs-ID

Azure PowerShell stöder endast anslutning av ACR till AKS med parametern -AcrNameToAttach och stöder inte anslutning till en ACR med resource ID.

Skapa sedan en resursgrupp och en Azure Container Registry. Det här registret lagrar de containeravbildningar som AKS-klustret hämtar senare.

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
}

Skapa nu AKS-klustret som använder avbildningar från registret. Det här klustret använder en systemtilldelad hanterad identitet som beviljas behörighet att hämta avbildningar.

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

I det här skedet finns AKS-klustret, men det har ännu inte åtkomst till containerregistret. I Azure CLI använder du parametern --attach-acr. I Terraform tilldelar du uttryckligen AcrPull rollen.

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
}

Integrera en befintlig ACR med ett befintligt AKS-kluster med hjälp av az aks update kommandot med parametern --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

Kommandot az aks update --attach-acr använder behörigheterna för användaren som kör kommandot för att skapa ACR-rolltilldelningen. Den här rollen tilldelas till den kubelet-hanterade identiteten. Mer information om AKS-hanterade identiteter finns i Sammanfattning av hanterade identiteter.

Integrera en befintlig ACR med ett befintligt AKS-kluster med hjälp av Set-AzAksCluster kommandot med parametern -AcrNameToAttach .

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

Set-AzAksCluster @AttachCluster

Cmdleten Set-AzAksCluster -AcrNameToAttach använder behörigheterna för användaren som kör kommandot för att skapa tilldelningen av rollen ACR. Den här rollen tilldelas till den kubelet-hanterade identiteten. Mer information om AKS-hanterade identiteter finns i Sammanfattning av hanterade identiteter.

Om AKS-klustret redan finns kan du koppla en ACR genom att referera till båda resurserna och skapa samma rolltilldelning.

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
}

Ta bort integreringen mellan en ACR och ett AKS-kluster med kommandot az aks update med parametern --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

Ta bort integreringen mellan en ACR och ett AKS-kluster med kommandot Set-AzAksCluster med parametern -AcrNameToDetach .

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

Set-AzAksCluster @DetachCluster

Ta bort åtkomst genom att ta bort rolltilldelningen som ger klustret behörighet att hämta avbildningar.

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

Initiera och distribuera konfigurationen

När konfigurationen är klar initierar du Terraform och granskar körningsplanen innan du tillämpar den.

terraform fmt
terraform init
terraform validate
terraform plan
terraform apply

Nu är DITT AKS-kluster konfigurerat för att hämta avbildningar från ACR.

Du kan nu:

• Importera avbildningar till ACR.
• Distribuera arbetsbelastningar till AKS.
• Verifiera podddistributionen.

Importera en avbildning från Docker Hub till din ACR med hjälp av kommandot az acr import.

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

Kör följande kommandon för att kontrollera att avbildningen har importerats.

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

Importera en avbildning från Docker Hub till din ACR med hjälp av cmdleten Import-AzContainerRegistryImage.

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

Import-AzContainerRegistryImage @ImportImage

Kör följande kommandon för att kontrollera att avbildningen har importerats.

Get-AzContainerRegistryRepository -RegistryName $MyAcr

Get-AzContainerRegistryTag -RegistryName $MyAcr -Repository nginx

1. Kontrollera att du har rätt AKS-autentiseringsuppgifter med kommandot az aks get-credentials .

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

2. Kör distributionen i AKS-klustret med hjälp av kubectl apply kommandot .

   kubectl apply -f acr-nginx.yaml
   

3. Övervaka distributionen med kommandot kubectl get pods .

   kubectl get pods
   

   Utdata ska visa två körande pods, som visas i exempelutdata nedan:

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

1. Kontrollera att du har rätt AKS-autentiseringsuppgifter med hjälp av cmdleten Import-AzAksCredential .

   Import-AzAksCredential -ResourceGroupName $ClusterResourceGroup -Name $ClusterName
   

2. Kör distributionen i AKS-klustret med hjälp av kubectl apply kommandot .

   kubectl apply -f acr-nginx.yaml
   

3. Övervaka distributionen med kommandot kubectl get pods .

   kubectl get pods
   

   Utdata ska visa två körande pods, som visas i exempelutdata nedan:

   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