Ověřování pomocí Azure Container Registry (ACR) ze služby Azure Kubernetes Service (AKS)

Pokud používáte Azure Container Registry (ACR) se službou Azure Kubernetes Service (AKS), musíte vytvořit mechanismus ověřování. Požadovaná oprávnění mezi ACR a AKS můžete nakonfigurovat pomocí Azure CLI, Azure PowerShell nebo portálu Azure. Tento článek obsahuje příklady konfigurace ověřování mezi těmito službami Azure pomocí Azure CLI nebo Azure PowerShell.

Integrace AKS do ACR přiřadí roli AcrPull spravované identitě Microsoft Entra ID přidružené k fondu agentů v clusteru AKS. Další informace o spravovaných identitách AKS najdete v souhrnu spravovaných identit.

Důležité

Při připojování ACR dochází k problému s latencí Microsoft Entra skupin. Pokud je role AcrPull udělena skupině Microsoft Entra a do skupiny se přidá identita kubeletu, aby se Azure dokončila konfigurace řízení přístupu na základě role (Azure RBAC), může dojít ke zpoždění, než se skupina RBAC projeví. Pokud používáte automatizaci, která vyžaduje úplnou konfiguraci RBAC Azure, doporučujeme jako alternativní řešení použít vlastní pracovní identitu kubeletu. Můžete předem vytvořit identitu přiřazenou uživatelem, přidat ji do skupiny Microsoft Entra a pak použít identitu jako identitu kubelet k vytvoření clusteru AKS. Tato metoda zajistí, že se identita přidá do skupiny Microsoft Entra před vygenerováním tokenu pomocí kubeletu, což zabrání problému s latencí.

Poznámka:

Tento článek se zabývá automatickým ověřováním mezi AKS a ACR. Pokud potřebujete načíst image z privátního externího registru, použijte tajný klíč pro vyžádání image.

Upozornění

Integrace AKS-ACR prostřednictvím není podporovaná pro registry ACR s podporou ABAC, kde je režim oprávnění přiřazení role nastaven na "RBAC Registry + ABAC Repository Permissions" (Registr RBAC + oprávnění úložiště ABAC). ACR registry s podporou ABAC vyžadují k udělení oprávnění na stahování obrazů roli místo role . U registrů ACR s podporou ABAC byste neměli používat az aks --attach-acr, ale místo toho ručně přiřaďte přiřazení role Container Registry Repository Reader pomocí portálu Azure, az role assignment CLI nebo Azure Resource Manager. Další informace o registrech ACR s podporou ABAC najdete v tématu Azure řízení přístupu na základě atributů.

V tomto názorném postupu nakonfigurujete cluster Azure Kubernetes Service (AKS) tak, aby bezpečně načítá image z Azure Container Registry (ACR). V Azure CLI použijte --attach-acr. V Terraformu AcrPull přiřaďte roli spravované identitě AKS kubelet. Tato příručka se řídí stejným tokem jako pracovní postup Azure CLI při používání Terraformu pro zřizování infrastruktury.

Než začnete

Potřebujete roli Owner, Azure správce účtu nebo Azure spolusprávce v předplatném Azure.
- Abyste se vyhnuli nutnosti těchto rolí, můžete místo toho použít existující spravovanou identitu k ověření ACR z AKS. Další informace najdete v tématu Použití spravované identity Azure k ověření ve službě ACR.

Pokud používáte Azure CLI, tento článek vyžaduje, abyste měli spuštěnou verzi Azure CLI 2.7.0 nebo novější. pokud chcete najít verzi, spusťte az --version příkaz. Pokud potřebujete nainstalovat nebo upgradovat, přečtěte si téma Instalace Azure CLI.

Pokud používáte Azure PowerShell, je vyžadováno, abyste měli verzi Azure PowerShell 5.9.0 nebo novější. Verzi najdete spuštěním Get-InstalledModule -Name Az příkazu. Pokud potřebujete nainstalovat nebo upgradovat, přečtěte si téma Instalace Azure PowerShell.
Příklady a syntaxe pro použití Terraformu pro konfiguraci ACR najdete v referenčních informacích k Terraformu.

Nainstalovaný Terraform (>= 1.6).
Azure CLI je nainstalováno a jste přihlášeni k vašemu předplatnému.
Oprávnění k přiřazování rolí (vlastník nebo správce uživatelských přístupů)

V tomto článku nakonfigurujete cluster Azure Kubernetes Service (AKS) tak, aby bezpečně načítá image z Azure Container Registry (ACR). V Azure CLI použijte --attach-acr. V Terraformu AcrPull přiřaďte roli spravované identitě AKS kubelet.

Tento článek se řídí stejným tokem jako pracovní postup Azure CLI při používání Terraformu pro zřizování infrastruktury. Pokud chcete ověřit, že jste přihlášeni ke správnému předplatnému, použijte následující příkazy Azure CLI:

az login
az account show

Vytvořte nový ACR

Pokud ještě nemáte ACR, vytvořte ho az acr create pomocí příkazu.

Název registru musí být globálně jedinečný v rámci Azure a musí obsahovat 5–50 alfanumerických znaků s výjimkou znaků pomlčky (-). Tento název je součástí plně kvalifikovaného názvu DNS registru.

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

Proměnná RANDOM_STRING ukládá náhodný 10místný řetězec. Hodnota MYACR je zřetězena s RANDOM_STRING hodnotou pro vytvoření jedinečného názvu.

Pokud ještě nemáte službu ACR, vytvořte ji pomocí rutiny New-AzContainerRegistry .

$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

Proměnná $RandomString ukládá náhodný 10místný řetězec. Hodnota $MyAcr je zřetězena s $RandomString hodnotou pro vytvoření jedinečného názvu.

Vytvořte soubor main.tf pro konfiguraci a začněte definováním zprostředkovatelů Terraformu a vygenerováním jedinečné přípony pro globálně jedinečné názvy prostředků. Globálně jedinečný název zajišťuje, že název Azure Container Registry není v konfliktu s existujícími registry.

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
}

Vytvoření nového clusteru AKS a integrace s existující službou ACR

Vytvořte nový cluster AKS a integrujte se stávající službou ACR pomocí az aks create příkazu s parametrem --attach-acr . Tento příkaz umožňuje autorizovat existující službu ACR ve vašem předplatném a nakonfigurovat odpovídající AcrPull roli pro spravovanou identitu.

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

Použijte ACR v jiném předplatném nebo připojte s využitím ID prostředku

Pokud používáte službu ACR umístěnou v jiném předplatném než v clusteru AKS nebo chcete místo názvu ACR použít ID prostředku ACR, použijte následující syntaxi. Tento příklad vytvoří proměnnou ACR_RESOURCE_ID pomocí registru kontejneru vytvořeného v předchozí části.

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

Vytvořte nový cluster AKS a integrujte se stávající službou ACR pomocí New-AzAksCluster rutiny s parametrem -AcrNameToAttach . Tento příkaz umožňuje autorizovat existující službu ACR ve vašem předplatném a nakonfigurovat odpovídající AcrPull roli pro spravovanou identitu.

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

New-AzResourceGroup -Name $ClusterResourceGroup -Location $Location

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

New-AzAksCluster @NewCluster

Použijte ACR v jiném předplatném nebo jej připojte pomocí ID prostředku

Azure PowerShell podporuje připojení ACR k AKS pouze pomocí parametru -AcrNameToAttach a nepodporuje připojení k ACR pomocí ID zdroje.

Dále vytvořte skupinu prostředků a registr kontejnerů Azure. Tento registr ukládá image kontejneru, které cluster AKS načítá později.

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
}

Teď vytvořte cluster AKS, který využívá image z registru. Tento cluster používá spravovanou identitu přiřazenou systémem, která bude mít udělena oprávnění ke stahování obrazů.

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

V této fázi cluster AKS existuje, ale ještě nemá přístup k registru kontejneru. V Azure CLI použijte parametr --attach-acr. V Terraformu AcrPull explicitně přiřadíte roli.

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
}

Konfigurace integrace ACR pro existující cluster AKS

ACR můžete připojit k existujícímu clusteru AKS nebo odpojit ACR od clusteru AKS, pokud už nechcete, aby měl cluster přístup k registru.

Předchozí příklady v článku vytvořily Azure Container Registry a cluster Azure Kubernetes Service připojený k ACR. Tady jsou příklady připojení nebo odpojení registru kontejneru z clusteru a použití clusteru ACR a AKS vytvořeného v tomto článku. Hodnoty proměnných můžete nahradit vlastními hodnotami clusteru ACR a AKS.

Připojení ACR k existujícímu clusteru AKS

Integrujte existující službu ACR se stávajícím clusterem AKS pomocí az aks update příkazu s parametrem --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

Příkaz az aks update --attach-acr používá oprávnění uživatele, který příkaz spouští, k vytvoření přiřazení role ACR. Tato role je přiřazená spravované identitě kubeletu . Další informace o spravovaných identitách AKS najdete v souhrnu spravovaných identit.

Integrujte existující službu ACR se stávajícím clusterem AKS pomocí Set-AzAksCluster příkazu s parametrem -AcrNameToAttach .

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

Set-AzAksCluster @AttachCluster

Rutina Set-AzAksCluster -AcrNameToAttach používá oprávnění uživatele, který příkaz spouští, k vytvoření přiřazení role ACR. Tato role je přiřazená spravované identitě kubeletu . Další informace o spravovaných identitách AKS najdete v souhrnu spravovaných identit.

Pokud už cluster AKS existuje, můžete připojit ACR tak, že odkážete na oba zdroje a vytvoříte stejné přiřazení role.

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
}

Odpojení ACR od clusteru AKS

Pomocí příkazu s az aks update parametrem odeberte integraci mezi ACR a clusterem --detach-acr AKS.

# 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

Pomocí příkazu s Set-AzAksCluster parametrem odeberte integraci mezi ACR a clusterem -AcrNameToDetach AKS.

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

Set-AzAksCluster @DetachCluster

Pokud chcete odebrat přístup, odstraňte přiřazení role, které clusteru přidělilo oprávnění ke stahování obrázků.

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

Inicializace a nasazení konfigurace

Po dokončení konfigurace inicializujte Terraform a před použitím zkontrolujte plán provádění.

terraform fmt
terraform init
terraform validate
terraform plan
terraform apply

V tuto chvíli je cluster AKS nakonfigurovaný tak, aby načítá image z ACR.

Teď můžete:

Import obrázků do ACR.
Nasaďte úlohy do AKS.
Ověřte nasazení podu.

Práce s ACR a AKS

Naimportujte image do služby ACR a pak ji nasaďte do clusteru AKS.

Importujte obrázek do své ACR

Importujte obrázek z Docker Hub do služby ACR pomocí příkazu az acr import.

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

Spuštěním následujících příkazů ověřte, že obraz byl importován.

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

Importujte obrázek z Docker Hub do služby ACR pomocí rutiny Import-AzContainerRegistryImage.

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

Import-AzContainerRegistryImage @ImportImage

Spuštěním následujících příkazů ověřte, zda byl obrázek importován.

Get-AzContainerRegistryRepository -RegistryName $MyAcr

Get-AzContainerRegistryTag -RegistryName $MyAcr -Repository nginx

Vytvořte soubor nasazení

Vytvořte nasazení Kubernetes, které odkazuje na image, kterou jste naimportovali do ACR. Pokud je nasazení úspěšné a obraz se načte správně, je váš cluster AKS vhodně integrován s ACR.

Pomocí následujícího ukázkového YAML vytvořte soubor s názvem acr-nginx.yaml . image Ve vlastnosti nahraďte acr-name názvem vaší služby ACR. V Azure CLI spuštěním příkazu echo $MYACR zobrazte název služby ACR. V Azure PowerShell spuštěním příkazu $MyAcr zobrazte název služby ACR.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx0-deployment
  labels:
    app: nginx0-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx0
  template:
    metadata:
      labels:
        app: nginx0
    spec:
      containers:
      - name: nginx
        image: <acr-name>.azurecr.io/nginx:v1
        ports:
        - containerPort: 80

Získání přihlašovacích údajů a spuštění nasazení

Pomocí příkazu se ujistěte, že máte správné přihlašovací údaje az aks get-credentials AKS.
```
az aks get-credentials \
  --resource-group $CLUSTER_RESOURCE_GROUP \
  --name $CLUSTER_NAME
```
Spusťte nasazení v clusteru AKS pomocí kubectl apply příkazu.
```
kubectl apply -f acr-nginx.yaml
```

Pomocí příkazu monitorujte nasazení kubectl get pods .

kubectl get pods

Výstup by měl zobrazit dva spuštěné pody, jak ukazuje následující ukázka výstupu.

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

Pomocí rutiny Import-AzAksCredential se ujistěte, že máte správné přihlašovací údaje AKS.
```
Import-AzAksCredential -ResourceGroupName $ClusterResourceGroup -Name $ClusterName
```
Spusťte nasazení v clusteru AKS pomocí kubectl apply příkazu.
```
kubectl apply -f acr-nginx.yaml
```