Autenticar com o Azure Container Registry (ACR) a partir do Azure Kubernetes Service (AKS)

• Se está a usar CLI do Azure, este artigo exige que esteja a correr a versão 2.7.0 ou posterior do CLI do Azure. Para encontrar a versão, execute o az --version comando. Se precisares de instalar ou atualizar, vê Install CLI do Azure.

• Se estiveres a usar Azure PowerShell, este artigo exige que estejas a correr Azure PowerShell versão 5.9.0 ou posterior. Para localizar a versão, execute o Get-InstalledModule -Name Az comando. Se precisares de instalar ou atualizar, vê Install Azure PowerShell.
• Exemplos e sintaxe para usar o Terraform para configurar o ACR podem ser encontrados na referência Terraform.

• Terraform instalado (>= 1.6).
• CLI do Azure instalado e iniciado sessão na sua subscrição.
• Permissões para atribuir funções (Proprietário ou Administrador de Acesso ao Utilizador).

Neste artigo, configura um cluster Azure Kubernetes Service (AKS) para extrair imagens de forma segura de um Azure Container Registry (ACR). Em CLI do Azure, use --attach-acr. No Terraform, atribuir a AcrPull função à identidade gerida pelo kubelet do AKS.

Este artigo segue o mesmo fluxo de trabalho do CLI do Azure, utilizando o Terraform para o provisionamento da infraestrutura. Para verificar se está iniciado sessão na subscrição correta, use os seguintes comandos do CLI do Azure:

az login
az account show

Se você ainda não tiver um ACR, crie um usando o az acr create comando.

O nome do registo deve ser globalmente único dentro de Azure e conter entre 5 a 50 caracteres alfanuméricos, excluindo os caracteres traço (-). Este nome faz parte do nome DNS totalmente qualificado do registo.

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

A RANDOM_STRING variável armazena uma sequência aleatória de 10 dígitos. O MYACR valor é concatenado com o RANDOM_STRING valor para criar um nome único.

Se você ainda não tiver um ACR, crie um usando o New-AzContainerRegistry cmdlet.

O nome do registo deve ser globalmente único dentro de Azure e conter entre 5 a 50 caracteres alfanuméricos, excluindo os caracteres traço (-). Este nome faz parte do nome DNS totalmente qualificado do registo.

$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

A $RandomString variável armazena uma sequência aleatória de 10 dígitos. O $MyAcr valor é concatenado com o $RandomString valor para criar um nome único.

Crie um ficheiro main.tf para a configuração e comece por definir os fornecedores Terraform e gerar um sufixo único para nomes de recursos globalmente únicos. Um nome globalmente único garante que o seu nome Azure Container Registry não conflita com registos existentes.

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
}

Crie um novo cluster AKS e integre com um ACR existente usando o az aks create comando com o --attach-acr parâmetro. Este comando permite-lhe autorizar um ACR existente na sua subscrição e configura o papel apropriado AcrPull para a identidade gerida.

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

Use um ACR numa subscrição diferente ou anexe usando o ID do recurso

Se estiver a usar um ACR localizado numa subscrição diferente do seu cluster AKS ou preferir usar o ID de recurso ACR em vez do nome ACR, use a seguinte sintaxe. Este exemplo cria a ACR_RESOURCE_ID variável usando o registo de contentores criado na secção anterior.

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

Crie um novo cluster AKS e integre com um ACR existente usando o New-AzAksCluster cmdlet com o -AcrNameToAttach parâmetro. Este comando permite-lhe autorizar um ACR na sua subscrição existente e configura a função apropriada AcrPull para a identidade gerida.

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

New-AzResourceGroup -Name $ClusterResourceGroup -Location $Location

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

New-AzAksCluster @NewCluster

Use um ACR numa subscrição diferente ou anexe usando o ID do recurso

Azure PowerShell só suporta ligar ACR ao AKS usando o parâmetro -AcrNameToAttach e não suporta ligar a um ACR por ID de recurso.

De seguida, crie um grupo de recursos e um Azure Container Registry. Este registo armazena as imagens de containers que o seu cluster AKS obtém posteriormente.

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
}

Agora cria o cluster AKS que consome imagens do registo. Este cluster utiliza uma identidade gerida atribuída pelo sistema, que terá permissão para extrair imagens.

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

Nesta fase, o cluster AKS existe, mas ainda não tem acesso ao registo de contentores. Em CLI do Azure, usa o parâmetro --attach-acr. Em Terraform, atribuis explicitamente a AcrPull função.

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
}

Integre um ACR existente com um cluster AKS existente usando o az aks update comando com o --attach-acr parâmetro.

# 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

O az aks update --attach-acr comando usa as permissões do usuário que executa o comando para criar a atribuição de função ACR. Essa função é atribuída à identidade gerenciada pelo kubelet . Para obter mais informações sobre identidades gerenciadas pelo AKS, consulte Resumo de identidades gerenciadas.

Integre um ACR existente com um cluster AKS existente usando o Set-AzAksCluster comando com o -AcrNameToAttach parâmetro.

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

Set-AzAksCluster @AttachCluster

O Set-AzAksCluster -AcrNameToAttach cmdlet utiliza as permissões do utilizador que executa o comando para criar a atribuição de funções ACR. Essa função é atribuída à identidade gerenciada pelo kubelet . Para obter mais informações sobre identidades gerenciadas pelo AKS, consulte Resumo de identidades gerenciadas.

Se o teu cluster AKS já existe, podes anexar um ACR referenciando ambos os recursos e criando a mesma atribuição de funções.

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
}

Remova a integração entre um ACR e um cluster AKS usando o az aks update comando com o --detach-acr parâmetro.

# 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

Remova a integração entre um ACR e um cluster AKS usando o Set-AzAksCluster comando com o -AcrNameToDetach parâmetro.

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

Set-AzAksCluster @DetachCluster

Para remover o acesso, elimine a atribuição de função que concede permissão ao cluster para extrair imagens.

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

Inicializar e implementar a configuração

Depois de concluída a sua configuração, inicialize o Terraform e reveja o plano de execução antes de aplicar.

terraform fmt
terraform init
terraform validate
terraform plan
terraform apply

Neste ponto, o teu cluster AKS está configurado para extrair imagens do ACR.

Agora pode:

• Importa imagens para ACR.
• Implementar cargas de trabalho no AKS.
• Verificar a implementação do pod.

Importa uma imagem de Docker Hub para o teu ACR usando o comando az acr import.

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

Execute os seguintes comandos para verificar se a imagem foi importada.

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

Importa uma imagem da Docker Hub para o teu ACR usando o cmdlet Import-AzContainerRegistryImage.

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

Import-AzContainerRegistryImage @ImportImage

Execute os seguintes comandos para verificar se a imagem foi importada.

Get-AzContainerRegistryRepository -RegistryName $MyAcr

Get-AzContainerRegistryTag -RegistryName $MyAcr -Repository nginx

1. Certifique-se de ter as credenciais AKS adequadas usando o az aks get-credentials comando.

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

2. Execute a implementação no cluster AKS usando o kubectl apply comando.

   kubectl apply -f acr-nginx.yaml
   

3. Monitore a implantação usando o kubectl get pods comando.

   kubectl get pods
   

   A saída deve mostrar dois pods em execução, como mostrado no exemplo de saída a seguir:

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

1. Certifique-se de ter as credenciais AKS adequadas usando o Import-AzAksCredential cmdlet.

   Import-AzAksCredential -ResourceGroupName $ClusterResourceGroup -Name $ClusterName
   

2. Execute a implementação no cluster AKS usando o kubectl apply comando.

   kubectl apply -f acr-nginx.yaml
   

3. Monitore a implantação usando o kubectl get pods comando.

   kubectl get pods
   

   A saída deve mostrar dois pods em execução, como mostrado no exemplo de saída a seguir:

   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