Verifiëren met Azure Container Registry (ACR) van Azure Kubernetes Service (AKS)

• Als u Azure CLI gebruikt, moet u voor dit artikel Azure CLI versie 2.7.0 of hoger gebruiken. voer de az --version opdracht uit om de versie te vinden. Zie Install Azure CLI als u Azure CLI wilt installeren of upgraden.

• Als u Azure PowerShell gebruikt, moet u voor dit artikel Azure PowerShell versie 5.9.0 of hoger uitvoeren. Voer de Get-InstalledModule -Name Az opdracht uit om de versie te vinden. Zie Azure PowerShell installeren als u moet installeren of upgraden.
• Voorbeelden en syntaxis voor het gebruik van Terraform voor het configureren van ACR vindt u in de Terraform-verwijzing.

• Terraform geïnstalleerd (>= 1.6).
• Azure CLI geïnstalleerd en aangemeld bij uw abonnement.
• Machtigingen voor het toewijzen van rollen (eigenaar of beheerder van gebruikerstoegang).

In dit artikel configureert u een Azure Kubernetes Service (AKS)-cluster om op een veilige manier images te halen uit een Azure Container Registry (ACR). Gebruik in Azure CLI --attach-acr. Wijs in Terraform de AcrPull rol toe aan de door AKS kubelet beheerde identiteit.

Dit artikel volgt dezelfde stroom als de Azure CLI werkstroom tijdens het gebruik van Terraform voor het inrichten van de infrastructuur. Gebruik de volgende Azure CLI opdrachten om te controleren of u bent aangemeld bij het juiste abonnement:

az login
az account show

Als u nog geen ACR hebt, maakt u er een met behulp van de az acr create opdracht.

De registernaam moet globaal uniek zijn binnen Azure en moet 5-50 alfanumerieke tekens bevatten, met uitzondering van streepjes (-). Deze naam maakt deel uit van de volledig gekwalificeerde DNS-naam van het register.

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

De RANDOM_STRING variabele slaat een willekeurige tekenreeks van 10 cijfers op. De MYACR waarde wordt samengevoegd met de RANDOM_STRING waarde om een unieke naam te maken.

Als u nog geen ACR hebt, maakt u er een met behulp van de New-AzContainerRegistry cmdlet.

De registernaam moet globaal uniek zijn binnen Azure en moet 5-50 alfanumerieke tekens bevatten, met uitzondering van streepjes (-). Deze naam maakt deel uit van de volledig gekwalificeerde DNS-naam van het register.

$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

De $RandomString variabele slaat een willekeurige tekenreeks van 10 cijfers op. De $MyAcr waarde wordt samengevoegd met de $RandomString waarde om een unieke naam te maken.

Maak een main.tf-bestand voor de configuratie en begin met het definiëren van de Terraform-providers en het genereren van een uniek achtervoegsel voor globaal unieke resourcenamen. Een wereldwijd unieke naam zorgt ervoor dat uw Azure Container Registry naam niet conflicteert met bestaande registers.

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
}

Maak een nieuw AKS-cluster en integreer met een bestaande ACR met behulp van de az aks create opdracht met de --attach-acr parameter. Met deze opdracht kunt u een bestaande ACR in uw abonnement autoriseren en de juiste AcrPull rol voor de beheerde identiteit configureren.

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

Een ACR in een ander abonnement gebruiken of koppelen met behulp van resource-id

Als u een ACR gebruikt in een ander abonnement dan uw AKS-cluster of liever de ACR-resource-id gebruikt in plaats van de ACR-naam, gebruikt u de volgende syntaxis. In dit voorbeeld wordt de ACR_RESOURCE_ID variabele gemaakt met behulp van het containerregister dat in de vorige sectie is gemaakt.

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

Maak een nieuw AKS-cluster en integreer met een bestaande ACR met behulp van de New-AzAksCluster cmdlet met de -AcrNameToAttach parameter. Met deze opdracht kunt u een bestaande ACR in uw abonnement autoriseren en de juiste AcrPull rol voor de beheerde identiteit configureren.

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

New-AzResourceGroup -Name $ClusterResourceGroup -Location $Location

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

New-AzAksCluster @NewCluster

Een ACR in een ander abonnement gebruiken of koppelen met behulp van resource-id

Azure PowerShell biedt alleen ondersteuning voor het koppelen van ACR aan AKS met behulp van de parameter -AcrNameToAttach en biedt geen ondersteuning voor het koppelen aan een ACR door middel van resource-id.

Maak vervolgens een resourcegroep en een Azure Container Registry. In dit register worden de containerimages opgeslagen die uw AKS-cluster later trekt.

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
}

Maak nu het AKS-cluster dat installatiekopieën uit het register verbruikt. Dit cluster maakt gebruik van een door het systeem toegewezen beheerde identiteit, die gemachtigd is om afbeeldingen op te halen.

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 deze fase bestaat het AKS-cluster, maar heeft het nog geen toegang tot het containerregister. Gebruik in Azure CLI de parameter --attach-acr. In Terraform wijst u de AcrPull rol expliciet toe.

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
}

Integreer een bestaande ACR met een bestaand AKS-cluster met behulp van de az aks update opdracht met de --attach-acr parameter.

# 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

De az aks update --attach-acr opdracht gebruikt de machtigingen van de gebruiker die de opdracht uitvoert om de ACR-roltoewijzing te maken. Deze rol wordt toegewezen aan de kubelet-beheerde identiteit. Zie Samenvatting van beheerde identiteiten in AKS voor meer informatie over beheerde AKS-identiteiten.

Integreer een bestaande ACR met een bestaand AKS-cluster met behulp van de Set-AzAksCluster opdracht met de -AcrNameToAttach parameter.

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

Set-AzAksCluster @AttachCluster

De Set-AzAksCluster -AcrNameToAttach cmdlet gebruikt de machtigingen van de gebruiker die het commando uitvoert om de ACR-roltoewijzing te maken. Deze rol wordt toegewezen aan de kubelet-beheerde identiteit. Zie Samenvatting van beheerde identiteiten in AKS voor meer informatie over beheerde AKS-identiteiten.

Als uw AKS-cluster al bestaat, kunt u een ACR koppelen door te verwijzen naar beide resources en dezelfde roltoewijzing te maken.

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
}

Verwijder de integratie tussen een ACR en een AKS-cluster met behulp van de az aks update opdracht met de --detach-acr parameter.

# 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

Verwijder de integratie tussen een ACR en een AKS-cluster met behulp van de Set-AzAksCluster opdracht met de -AcrNameToDetach parameter.

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

Set-AzAksCluster @DetachCluster

Verwijder de roltoewijzing die het cluster toestemming verleent om afbeeldingen op te halen om de toegang te verwijderen.

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

De configuratie initialiseren en implementeren

Nadat uw configuratie is voltooid, initialiseert u Terraform en controleert u het uitvoeringsplan voordat u deze toepast.

terraform fmt
terraform init
terraform validate
terraform plan
terraform apply

Op dit moment is uw AKS-cluster geconfigureerd om images uit ACR te halen.

U kunt nu:

• Importeer afbeeldingen in ACR.
• Workloads implementeren in AKS.
• Controleer de implementatie van de pod.

Importeer een afbeelding uit Docker Hub in uw ACR met behulp van de opdracht az acr import.

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

Voer de volgende commando's uit om te verifiëren of de image is geïmporteerd.

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

Importeer een afbeelding uit Docker Hub in uw ACR met behulp van de cmdlet Import-AzContainerRegistryImage.

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

Import-AzContainerRegistryImage @ImportImage

Voer de volgende opdrachten uit om te verifiëren of de afbeelding is geïmporteerd.

Get-AzContainerRegistryRepository -RegistryName $MyAcr

Get-AzContainerRegistryTag -RegistryName $MyAcr -Repository nginx

1. Zorg ervoor dat u de juiste AKS-referenties hebt met behulp van de az aks get-credentials opdracht.

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

2. Voer de implementatie uit in uw AKS-cluster met behulp van de kubectl apply opdracht.

   kubectl apply -f acr-nginx.yaml
   

3. Bewaak de implementatie met behulp van de kubectl get pods opdracht.

   kubectl get pods
   

   In de uitvoer moeten twee actieve pods worden weergegeven, zoals wordt weergegeven in de volgende voorbeelduitvoer:

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

1. Zorg ervoor dat u de juiste AKS-referenties hebt met behulp van de Import-AzAksCredential cmdlet.

   Import-AzAksCredential -ResourceGroupName $ClusterResourceGroup -Name $ClusterName
   

2. Voer de implementatie uit in uw AKS-cluster met behulp van de kubectl apply opdracht.

   kubectl apply -f acr-nginx.yaml
   

3. Bewaak de implementatie met behulp van de kubectl get pods opdracht.

   kubectl get pods
   

   In de uitvoer moeten twee actieve pods worden weergegeven, zoals wordt weergegeven in de volgende voorbeelduitvoer:

   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