Azure Kubernetes Service (AKS) kümesinde Microsoft Entra İş Yükü Kimliği dağıtma ve yapılandırma

Bu makalede, Microsoft Entra İş Yükü Kimliği ile bir Azure Kubernetes Service (AKS) kümesi dağıtmayı ve yapılandırmayı öğreneceksiniz. Bu makaledeki adımlar şunlardır:

• OpenID Connect (OIDC) veren ve Microsoft Entra İş Yükü Kimliği etkin olan Azure CLI veya Terraform kullanarak yeni bir AKS kümesi oluşturun veya var olan bir AKS kümesini güncelleştirin.
• bir iş yükü kimliği ve Kubernetes hizmet hesabı oluşturun.
• Belirteç federasyonu için yönetilen kimliği yapılandırın.
• İş yükünü dağıtın ve iş yükü kimliğiyle kimlik doğrulamasını doğrulayın.
• Kümedeki bir pod'a, isteğe bağlı olarak Azure Key Vault'taki gizli bilgilere erişim verin.

Önkoşullar

• Azure hesabınız yoksa başlamadan önce free hesabı oluşturun.
• Bu makale, Azure CLI 2.47.0 veya sonraki bir sürümünü gerektirir. Azure Cloud Shell kullanıyorsanız en son sürüm zaten yüklüdür. Sürümü bulmak için az --version komutunu çalıştırın. Yüklemeniz veya yükseltmeniz gerekiyorsa bkz. Azure CLI yükleme.
• Kümenizi oluşturmak için kullandığınız kimliğin uygun minimum izinlere sahip olduğundan emin olun. Daha fazla bilgi için bkz. Access ve Azure Kubernetes Service (AKS) için kimlik seçenekleri.
• Birden çok Azure aboneliğiniz varsa, az account set komutu kullanılarak kaynakların faturalandırılacağı uygun abonelik kimliğini seçin.

• Terraform yerel olarak yüklendi. Yükleme yönergeleri için bkz . Terraform'u yükleme.

Not

Bazı adımları otomatik olarak yapılandırmanıza yardımcı olması için Service Connector'ı kullanabilirsiniz. Daha fazla bilgi için bkz. Tutorial: Microsoft Entra İş Yükü Kimliği kullanarak Hizmet Bağlayıcısı ile Azure Kubernetes Service (AKS)'da Azure depolama hesabına bağlanma.

Terraform yapılandırma dosyasını oluşturma

Terraform yapılandırma dosyaları, Terraform'un oluşturduğu ve yönettiği altyapıyı tanımlar.

1. main.tf adlı bir dosya oluşturun ve Terraform sürümünü tanımlamak ve Azure sağlayıcısını belirtmek için aşağıdaki kodu ekleyin:

   terraform {
    required_version = ">= 1.5.0"
    required_providers {
      azurerm = {
        source  = "hashicorp/azurerm"
        version = "~> 4.0"
      }
      kubernetes = {
        source  = "hashicorp/kubernetes"
        version = "~> 2.30"
      }
      random = {
        source  = "hashicorp/random"
        version = "~> 3.6"
      }
    }
   }
   provider "azurerm" {
    features {}
    subscription_id = var.subscription_id
   }
   data "azurerm_client_config" "current" {}
   

2. Yeniden kullanılabilir değişkenleri tanımlamak ve tüm kaynaklar için benzersiz adlar oluşturmak için aşağıdaki kodu main.tf ekleyin:

   resource "random_string" "suffix" {
    length  = 6
    upper   = false
    special = false
    numeric = true
   }
   locals {
    suffix = random_string.suffix.result
    resource_group_name       = "rg-aks-wi-${local.suffix}"
    cluster_name              = "akswi${local.suffix}"
    managed_identity_name     = "uami-wi-${local.suffix}"
    federated_credential_name = "fic-wi-${local.suffix}"
    key_vault_name            = lower(substr("kvwi${local.suffix}", 0, 24))
    secret_name               = "secret-${local.suffix}"
    service_account_name      = "workload-sa-${local.suffix}"
    service_account_namespace = "default"
    workload_identity_subject = "system:serviceaccount:${local.service_account_namespace}:${local.service_account_name}"
   }
   

Kaynak grubu oluşturma

az group create komutunu kullanarak bir kaynak grubu oluşturun.

export RANDOM_ID="$(openssl rand -hex 3)"
export RESOURCE_GROUP="myResourceGroup$RANDOM_ID"
export LOCATION="<your-preferred-region>"
az group create --name "${RESOURCE_GROUP}" --location "${LOCATION}"

Azure kaynak grubu oluşturmak için aşağıdaki kodu main.tf ekleyin. location değerini tercih ettiğiniz Azure bölgeyle eşleşecek şekilde güncelleştirin.

resource "azurerm_resource_group" "this" {
 name     = local.resource_group_name
 location = "eastus"
}

AKS kümesinde OIDC yayımcısını ve Microsoft Entra Workload Kimliğini etkinleştir

Yeni veya mevcut bir AKS kümesinde OIDC sağlayıcısını ve Microsoft Entra İş Yükü Kimliği'yi etkinleştirebilirsiniz.

Yeni AKS kümesi oluşturma

AKS kümesi oluşturmak için OIDC vereni etkinleştirmek adına az aks create komutunu --enable-oidc-issuer parametresi ve Microsoft Entra İş Yükü Kimliği'yi etkinleştirmek için --enable-workload-identity parametresiyle kullanın. Aşağıdaki örnek, tek düğümlü bir küme oluşturur:

export CLUSTER_NAME="myAKSCluster$RANDOM_ID"
az aks create \
    --resource-group "${RESOURCE_GROUP}" \
    --name "${CLUSTER_NAME}" \
    --enable-oidc-issuer \
    --enable-workload-identity \
    --generate-ssh-keys

Birkaç dakika sonra komut tamamlanıp kümeyle ilgili JSON biçimli bilgileri döndürür.

OIDC veren ve Microsoft Entra İş Yükü Kimliği etkin bir AKS kümesi oluşturmak için aşağıdaki kodu main.tf ekleyin:

resource "azurerm_kubernetes_cluster" "this" {
 name                              = local.cluster_name
 location                          = azurerm_resource_group.this.location
 resource_group_name               = azurerm_resource_group.this.name
 dns_prefix                        = local.cluster_name
 oidc_issuer_enabled               = true
 workload_identity_enabled         = true
 role_based_access_control_enabled = true
 default_node_pool {
   name       = "system"
   node_count = 1
   vm_size    = "Standard_B4ms"
 }
 identity {
   type = "SystemAssigned"
 }
}

Mevcut AKS kümesini güncelleştirme

az aks update ve --enable-oidc-issuer parametreleriyle --enable-workload-identity komutunu kullanarak OIDC vereni ve Microsoft Entra İş Yükü Kimliği etkinleştirmek için var olan bir AKS kümesini güncelleştirin.

az aks update \
    --resource-group "${RESOURCE_GROUP}" \
    --name "${CLUSTER_NAME}" \
    --enable-oidc-issuer \
    --enable-workload-identity

Terraform tarafından yönetilen mevcut bir AKS kümeniz varsa, OIDC vereni ve Microsoft Entra İş Yükü Kimliği etkinleştirmek için azurerm_kubernetes_cluster dosyanızdaki main.tf kaynağını güncelleştirebilirsiniz:

  oidc_issuer_enabled               = true
  workload_identity_enabled         = true

OIDC sağlayıcı URL'sini al

komutunu kullanarak OIDC veren URL'sini az aks show alın ve bir ortam değişkenine kaydedin.

export AKS_OIDC_ISSUER="$(az aks show --name "${CLUSTER_NAME}" \
    --resource-group "${RESOURCE_GROUP}" \
    --query "oidcIssuerProfile.issuerUrl" \
    --output tsv)"

Ortam değişkeni, aşağıdaki örneğe benzer şekilde veren URL'yi içermelidir:

https://eastus.oic.prod-aks.azure.com/00000000-0000-0000-0000-000000000000/11111111-1111-1111-1111-111111111111/

Varsayılan olarak, yayımcı, https://{region}.oic.prod-aks.azure.com/{tenant_id}/{uuid} temel URL'sini, değerinin AKS kümesinin dağıtıldığı konumla eşleştiği {region} ile kullanacak şekilde ayarlanır. değeri {uuid} , her küme için rastgele oluşturulan ve sabit bir GUID olan OIDC anahtarını temsil eder.

OIDC sağlayıcı URL'sini almak için aşağıdaki kodu main.tf öğesine ekleyin:

output "oidc_issuer_url" {
 value = azurerm_kubernetes_cluster.this.oidc_issuer_url
}

Yönetilen bir kimlik oluştur

1. Abonelik kimliğinizi alıp az account show komutunu kullanarak bir ortam değişkenine kaydedin.

   export SUBSCRIPTION="$(az account show --query id --output tsv)"
   

2. komutunu kullanarak az identity create kullanıcı tarafından atanan bir yönetilen kimlik oluşturun.

   export USER_ASSIGNED_IDENTITY_NAME="myIdentity$RANDOM_ID"
   az identity create \
       --name "${USER_ASSIGNED_IDENTITY_NAME}" \
       --resource-group "${RESOURCE_GROUP}" \
       --location "${LOCATION}" \
       --subscription "${SUBSCRIPTION}"
   

   Aşağıdaki çıkış örneğinde yönetilen kimliğin başarıyla oluşturulduğu gösterilmektedir:

   {
     "clientId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
     "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourcegroups/myResourceGroupxxxxxx/providers/Microsoft.ManagedIdentity/userAssignedIdentities/myIdentityxxxxxx",
     "location": "eastus",
     "name": "myIdentityxxxxxx",
     "principalId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
     "resourceGroup": "myResourceGroupxxxxxx",
     "systemData": null,
     "tags": {},
     "tenantId": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
     "type": "Microsoft.ManagedIdentity/userAssignedIdentities"
   }
   

3. Yönetilen kimliğin istemci kimliğini alın ve bir ortam değişkenine kaydetmek için az identity show komutunu kullanın.

   export USER_ASSIGNED_CLIENT_ID="$(az identity show \
       --resource-group "${RESOURCE_GROUP}" \
       --name "${USER_ASSIGNED_IDENTITY_NAME}" \
       --query 'clientId' \
       --output tsv)"
   

Yönetilen kimlik oluşturmak için aşağıdaki kodu main.tf ekleyin:

resource "azurerm_user_assigned_identity" "this" {
 name                = local.managed_identity_name
 location            = azurerm_resource_group.this.location
 resource_group_name = azurerm_resource_group.this.name
}

Kubernetes hizmet hesabı oluşturma

1. komutunu kullanarak AKS kümenize bağlanın az aks get-credentials .

   az aks get-credentials --name "${CLUSTER_NAME}" --resource-group "${RESOURCE_GROUP}"
   

2. Bir Kubernetes servis hesabı oluşturun ve aşağıdaki bildirimi kubectl apply komutunu uygulayarak yönetilen kimliğin istemci kimliğiyle açıklama ekleyin.

   export SERVICE_ACCOUNT_NAME="workload-identity-sa$RANDOM_ID"
   export SERVICE_ACCOUNT_NAMESPACE="default"
   cat <<EOF | kubectl apply -f -
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     annotations:
       azure.workload.identity/client-id: "${USER_ASSIGNED_CLIENT_ID}"
     name: "${SERVICE_ACCOUNT_NAME}"
     namespace: "${SERVICE_ACCOUNT_NAMESPACE}"
   EOF
   

   Aşağıdaki çıkışta iş yükü kimliğinin başarıyla oluşturulduğu gösterilmektedir:

   serviceaccount/workload-identity-sa created
   

1. Kubernetes erişimini Kubernetes kaynaklarının oluşturulmasına izin verecek şekilde yapılandırmak için aşağıdaki kodu main.tf ekleyin:

   data "azurerm_kubernetes_cluster" "this" {
    name                = azurerm_kubernetes_cluster.this.name
    resource_group_name = azurerm_resource_group.this.name
   }
   provider "kubernetes" {
    host                   = data.azurerm_kubernetes_cluster.this.kube_config[0].host
    client_certificate     = base64decode(data.azurerm_kubernetes_cluster.this.kube_config[0].client_certificate)
    client_key             = base64decode(data.azurerm_kubernetes_cluster.this.kube_config[0].client_key)
    cluster_ca_certificate = base64decode(data.azurerm_kubernetes_cluster.this.kube_config[0].cluster_ca_certificate)
   }
   

2. Kubernetes hizmet hesabı oluşturmak için aşağıdaki kodu main.tf ekleyin ve yönetilen kimliğin istemci kimliğiyle buna ek açıklama ekleyin:

   resource "kubernetes_service_account" "this" {
    metadata {
      name      = local.service_account_name
      namespace = local.service_account_namespace
      annotations = {
        "azure.workload.identity/client-id" = azurerm_user_assigned_identity.this.client_id
      }
    }
   }
   

Birleşik kimlik kimlik bilgisi oluşturma

komutunu kullanarak az identity federated-credential create yönetilen kimlik, hizmet hesabı veren ve konu arasında bir federasyon kimliği kimlik bilgisi oluşturun.

export FEDERATED_IDENTITY_CREDENTIAL_NAME="myFedIdentity$RANDOM_ID"
az identity federated-credential create \
    --name ${FEDERATED_IDENTITY_CREDENTIAL_NAME} \
    --identity-name "${USER_ASSIGNED_IDENTITY_NAME}" \
    --resource-group "${RESOURCE_GROUP}" \
    --issuer "${AKS_OIDC_ISSUER}" \
    --subject system:serviceaccount:"${SERVICE_ACCOUNT_NAMESPACE}":"${SERVICE_ACCOUNT_NAME}" \
    --audience api://AzureADTokenExchange

Not

Federasyon kimlik bilgisinin eklendikten sonra yayılması birkaç saniye sürer. Federe kimlik bilgileri eklendikten hemen sonra bir belirteç isteği yapılırsa, istek başarısız olabilir önbellek yenilenene kadar. Bu sorunu önlemek için, federasyon kimliği kimlik bilgilerini ekledikten sonra biraz gecikme ekleyebilirsiniz.

Yönetilen kimlik, hizmet hesabı sağlayıcısı ve konu arasında federasyon kimliği kimlik bilgisi oluşturmak için aşağıdaki kodu main.tf ekleyin.

resource "azurerm_federated_identity_credential" "this" {
 name                = local.federated_credential_name
 resource_group_name = azurerm_resource_group.this.name
 parent_id           = azurerm_user_assigned_identity.this.id
 issuer              = azurerm_kubernetes_cluster.this.oidc_issuer_url
 subject             = local.workload_identity_subject
 audience            = ["api://AzureADTokenExchange"]
}

Microsoft Entra'daki federasyon kimlik bilgileri hakkında daha fazla bilgi için bkz. Microsoft Entra ID federasyon kimlik bilgilerinin genel görünümü.

Azure RBAC yetkilendirmesiyle bir anahtar kasası oluşturma

Aşağıdaki örnekte, pod'a anahtar kasasına erişim vermek için Azure rol tabanlı erişim denetimi (Azure RBAC) izin modelinin nasıl kullanılacağı gösterilmektedir. Azure Key Vault için Azure RBAC izin modeli hakkında daha fazla bilgi için Azure RBAC kullanarak uygulamalara Azure Key Vault erişme izni verme konusuna bakın.

1. az keyvault create komutunu kullanarak temizleme koruması ve Azure RBAC yetkilendirmesi etkinleştirilmiş bir anahtar kasası oluşturun. Ayrıca, hem temizleme koruması hem de Azure RBAC yetkilendirmesi için yapılandırılmışsa mevcut bir anahtar kasasını da kullanabilirsiniz.

   export KEYVAULT_NAME="keyvault-workload-id$RANDOM_ID" # Ensure the key vault name is between 3-24 characters
   az keyvault create \
       --name "${KEYVAULT_NAME}" \
       --resource-group "${RESOURCE_GROUP}" \
       --location "${LOCATION}" \
       --enable-purge-protection \
       --enable-rbac-authorization
   

2. Anahtar kasası kaynak kimliğini alın ve az keyvault show komutunu kullanarak bir ortam değişkenine kaydedin.

   export KEYVAULT_RESOURCE_ID=$(az keyvault show --resource-group "${RESOURCE_GROUP}" \
       --name "${KEYVAULT_NAME}" \
       --query id \
       --output tsv)
   

main.tf'a aşağıdaki kodu ekleyerek Azure RBAC yetkilendirmesine sahip bir anahtar kasası oluşturun:

resource "azurerm_key_vault" "this" {
 name                          = local.key_vault_name
 location                      = azurerm_resource_group.this.location
 resource_group_name           = azurerm_resource_group.this.name
 tenant_id                     = data.azurerm_client_config.current.tenant_id
 sku_name                      = "standard"
 rbac_authorization_enabled    = true
}

Anahtar kasası yönetimi için RBAC izinleri atama

1. az ad signed-in-user show komutunu kullanarak çağıran nesne kimliğini alın ve bir ortam değişkenine kaydedin.

   export CALLER_OBJECT_ID=$(az ad signed-in-user show --query id -o tsv)
   

2. Yeni anahtar kasasında bir gizli oluşturabilmeniz için Azure RBAC Key Vault Secrets Officer rolünü kendinize atayın ve az role assignment create komutunu kullanın.

   az role assignment create --assignee "${CALLER_OBJECT_ID}" \
       --role "Key Vault Secrets Officer" \
       --scope "${KEYVAULT_RESOURCE_ID}"
   

Yeni bir anahtar kasasında gizli diziler oluşturabilmeniz ve kullanıcı tarafından atanan yönetilen kimliğe "Key Vault Gizli Dizi Kullanıcısı" rolünü atayabilmeniz için, kendinize Azure RBAC "Key Vault Gizli Dizi Görevlisi" rolünü atamak üzere main.tf kodunu ekleyin.

resource "azurerm_role_assignment" "user" {
 scope                = azurerm_key_vault.this.id
 role_definition_name = "Key Vault Secrets Officer"
 principal_id         = data.azurerm_client_config.current.object_id
}
resource "azurerm_role_assignment" "identity" {
 scope                = azurerm_key_vault.this.id
 role_definition_name = "Key Vault Secrets User"
 principal_id         = azurerm_user_assigned_identity.this.principal_id
}

Gizli erişim oluşturma ve yapılandırma

1. az keyvault secret set komutunu kullanarak anahtar kasasında bir gizli oluşturun.

   export KEYVAULT_SECRET_NAME="my-secret$RANDOM_ID"
   az keyvault secret set \
       --vault-name "${KEYVAULT_NAME}" \
       --name "${KEYVAULT_SECRET_NAME}" \
       --value "Hello\!"
   

2. Kullanıcıya atanan yönetilen kimliğin kimlik bilgilerini alın ve az identity show komutunu kullanarak bir ortam değişkenine kaydedin.

   export IDENTITY_PRINCIPAL_ID=$(az identity show \
       --name "${USER_ASSIGNED_IDENTITY_NAME}" \
       --resource-group "${RESOURCE_GROUP}" \
       --query principalId \
       --output tsv)
   

3. Key Vault Gizli Kullanıcısı rolünü az role assignment create komutunu kullanarak kullanıcı atamalı yönetilen kimliğe atanacak şekilde ayarlayın. Bu adım, yönetilen kimliğe anahtar kasasından gizli bilgileri okuma izni verir.

   az role assignment create \
       --assignee-object-id "${IDENTITY_PRINCIPAL_ID}" \
       --role "Key Vault Secrets User" \
       --scope "${KEYVAULT_RESOURCE_ID}" \
       --assignee-principal-type ServicePrincipal
   

4. komutunu kullanarak az keyvault show anahtar kasası URL'si için bir ortam değişkeni oluşturun.

   export KEYVAULT_URL="$(az keyvault show \
       --resource-group "${RESOURCE_GROUP}" \
       --name ${KEYVAULT_NAME} \
       --query properties.vaultUri \
       --output tsv)"
   

Anahtar kasasında gizli dizi oluşturmak için aşağıdaki kodu main.tf ekleyin:

resource "azurerm_key_vault_secret" "this" {
 name         = local.secret_name
 value        = "Hello from Key Vault"
 key_vault_id = azurerm_key_vault.this.id
}

Bir doğrulama podu dağıtın ve erişimi test edin

1. İş yükü kimliğinin anahtar kasasındaki gizli bilgiyi erişebildiğini doğrulamak için bir pod dağıtın. Aşağıdaki örnek, Microsoft Entra İş Yükü Kimliği kullanarak Azure Key Vault'dan gizli dizi alan örnek bir uygulama içeren ghcr.io/azure/azure-workload-identity/msal-go görüntüsünü kullanır:

   kubectl apply -f - <<EOF
   apiVersion: v1
   kind: Pod
   metadata:
       name: sample-workload-identity-key-vault
       namespace: ${SERVICE_ACCOUNT_NAMESPACE}
       labels:
           azure.workload.identity/use: "true"
   spec:
       serviceAccountName: ${SERVICE_ACCOUNT_NAME}
       containers:
         - image: ghcr.io/azure/azure-workload-identity/msal-go
           name: oidc
           env:
             - name: KEYVAULT_URL
               value: ${KEYVAULT_URL}
             - name: SECRET_NAME
               value: ${KEYVAULT_SECRET_NAME}
       nodeSelector:
           kubernetes.io/os: linux
   EOF
   

2. komutunu kullanarak Ready pod'un kubectl wait durumunda olmasını bekleyin.

   kubectl wait --namespace ${SERVICE_ACCOUNT_NAMESPACE} --for=condition=Ready pod/sample-workload-identity-key-vault --timeout=120s
   

3. komutunu kullanarak SECRET_NAME ortam değişkeninin kubectl describe podda ayarlandığını denetleyin.

   kubectl describe pod sample-workload-identity-key-vault | grep "SECRET_NAME:"
   

   Başarılı olursa, çıktı aşağıdaki örneğe benzer olmalıdır:

   SECRET_NAME: ${KEYVAULT_SECRET_NAME}
   

4. Podların bir token alıp kubectl logs komutunu kullanarak kaynağa erişebildiğini doğrulayın.

   kubectl logs sample-workload-identity-key-vault
   

   Başarılı olursa, çıktı aşağıdaki örneğe benzer olmalıdır:

   I0114 10:35:09.795900       1 main.go:63] "successfully got secret" secret="Hello\\!"
   

   Önemli

   Azure RBAC rol atamalarının yayılması 10 dakika kadar sürebilir. Pod gizli bilgiye erişemezse rol atamasının yayılmasını beklemeniz gerekebilir. Daha fazla bilgi için bkz. RBAC Azure sorun giderme.

AKS kümesinde Microsoft Entra İş Yükü Kimliği devre dışı bırakma

Etkinleştirildiği ve yapılandırıldığı AKS kümesinde Microsoft Entra İş Yükü Kimliği devre dışı bırakın, az aks update komutunu --disable-workload-identity parametresiyle kullanarak AKS kümesini güncelleştirin.

az aks update \
    --resource-group "${RESOURCE_GROUP}" \
    --name "${CLUSTER_NAME}" \
    --disable-workload-identity

Doğrulama podu dağıt.

Anahtar kasasının içindeki sırrı erişmek için iş yükü kimliğini kullanan bir doğrulama podunu dağıtmak ve çalıştırmak için aşağıdaki kodu main.tf ekleyin.

resource "kubernetes_pod" "test" {
 metadata {
   name      = "workload-identity-test"
   namespace = local.service_account_namespace
   labels = {
     "azure.workload.identity/use" = "true"
   }
 }
 spec {
   service_account_name = kubernetes_service_account.this.metadata[0].name
   container {
     name  = "test"
     image = "ghcr.io/azure/azure-workload-identity/msal-go"
     env {
       name  = "KEYVAULT_URL"
       value = azurerm_key_vault.this.vault_uri
     }
     env {
       name  = "SECRET_NAME"
       value = azurerm_key_vault_secret.this.name
     }
   }
 }
}

Terraform'u başlatma

main.tf komutunu kullanarak terraform init dosyanızın bulunduğu dizinde Terraform'u başlatın. Bu komut Terraform ile Azure kaynakları yönetmek için gereken Azure sağlayıcısını indirir.

terraform init

Terraform için bir yürütme planı oluşturun

terraform plan komutunu kullanarak bir Terraform yürütme planı oluşturun. Bu komut, Terraform'un Azure aboneliğinizde oluşturacağı veya değiştireceği kaynakları gösterir.

terraform plan

Terraform yapılandırmasını uygulama

Yürütme planını gözden geçirip onayladıktan sonra komutunu kullanarak terraform apply Terraform yapılandırmasını uygulayın. Bu komut, Azure aboneliğinizdeki main.tf dosyanızda tanımlanan kaynakları oluşturur veya değiştirir.

terraform apply

Dağıtımı doğrulayın.

1. komutunu kullanarak AKS kümenize bağlanın az aks get-credentials .

   az aks get-credentials --name <cluster-name> --resource-group <resource-group>
   

2. komutunu kullanarak kubectl get pods doğrulama podunun durumunu denetleyin.

3. Pod bir Ready duruma ulaştığında, kubectl logs komutunu kullanarak pod günlüklerini denetleyip anahtar kasası sırrına erişebildiğinden emin olun.

   kubectl logs workload-identity-test
   

İlgili içerik

Bu makalede, bir Kubernetes kümesi dağıttınız ve uygulama iş yüklerinin bu kimlik bilgisiyle kimlik doğrulaması yapabilmesi için Microsoft Entra İş Yükü Kimliği kullanacak şekilde yapılandırdınız. Artık uygulamanızı dağıtmaya ve Azure Identity istemci kitaplığının en son sürümüyle iş yükü kimliğini kullanacak şekilde yapılandırmaya hazırsınız. Uygulamanızı en son istemci kitaplığı sürümünü kullanacak şekilde yeniden yazamıyorsanız, uygulama podunuzu kısa vadeli bir geçiş çözümü olarak iş yükü kimliğiyle yönetilen kimlik kullanarak kimlik doğrulaması yapmak üzere ayarlayabilirsiniz.

Service Connector tümleştirmesi, AKS iş yükleri ve Azure destek hizmetleri için bağlantı yapılandırmasını basitleştirmeye yardımcı olur. Kimlik doğrulaması ve ağ yapılandırmalarını güvenli bir şekilde işler ve Azure hizmetlerine bağlanmak için en iyi yöntemleri izler. Daha fazla bilgi için bkz. AKS'deki Döküm Modellerinde Microsoft Entra İş Yükü Kimliğini Kullanarak Azure OpenAI'ye Bağlanma ve Service Connector tanıtımı.