Nasazení a konfigurace ID úloh Microsoft Entra v clusteru Azure Kubernetes Service (AKS)

V tomto článku se dozvíte, jak nasadit a nakonfigurovat cluster Azure Kubernetes Service (AKS) pomocí ID úloh Microsoft Entra. Kroky v tomto článku zahrnují:

• Vytvořte nebo aktualizujte existující cluster AKS pomocí Azure CLI nebo Terraformu s povoleným OpenID Connect (OIDC) a ID úloh Microsoft Entra.
• Vytvořte identitu úlohy a účet služby Kubernetes.
• Nakonfigurujte spravovanou identitu pro federaci tokenů.
• Nasaďte úlohu a ověřte autentizaci pomocí identity úlohy.
• Volitelně můžete podu v clusteru udělit přístup k tajným kódům v trezoru klíčů Azure.

Požadavky

• Pokud účet Azure nemáte, vytvořte si účet free než začnete.
• Tento článek vyžaduje verzi 2.47.0 nebo novější Azure CLI. Pokud používáte Azure Cloud Shell, je už nainstalovaná nejnovější verze. Verzi zjistíte spuštěním příkazu az --version. Pokud potřebujete nainstalovat nebo upgradovat, přečtěte si téma Instalace Azure CLI.
• Ujistěte se, že identita, kterou používáte k vytvoření clusteru, má odpovídající minimální oprávnění. Další informace najdete v tématu Možnosti přístupu a identity pro Azure Kubernetes Service (AKS).
• Pokud máte více Azure předplatných, vyberte příslušné ID předplatného, ve kterém se mají prostředky fakturovat pomocí příkazu az account set.

• Terraform je nainstalovaný místně. Pokyny k instalaci najdete v tématu Instalace Terraformu.

Poznámka:

Pomocí konektoru Service Connector můžete automaticky nakonfigurovat některé kroky. Další informace najdete v tématu Tutorial: Připojení k účtu úložiště Azure v Azure Kubernetes Service (AKS) pomocí konektoru Service Connector pomocí ID úloh Microsoft Entra.

Vytvoření konfiguračního souboru Terraformu

Konfigurační soubory Terraformu definují infrastrukturu, kterou Terraform vytváří a spravuje.

1. Vytvořte soubor s názvem main.tf a přidejte následující kód, který definuje verzi Terraformu a určí zprostředkovatele Azure:

   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. Přidáním následujícího kódu main.tf definujte opakovaně použitelné proměnné a vygenerujte jedinečné názvy pro všechny prostředky:

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

Vytvoření skupiny zdrojů

Vytvořte skupinu prostředků pomocí příkazu az group create.

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

Přidáním následujícího kódu do main.tf vytvořte skupinu prostředků Azure. Aktualizujte hodnotu location tak, aby odpovídala preferované oblasti Azure.

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

Povolení vystavovatele OIDC a ID úloh Microsoft Entra v clusteru AKS

Můžete povolit poskytovatele OIDC a ID úloh Microsoft Entra v novém nebo stávajícím clusteru AKS.

Vytvoření nového clusteru AKS

Vytvořte cluster AKS pomocí příkazu az aks create s parametrem --enable-oidc-issuer, který povolí vystavitele OIDC a parametr --enable-workload-identity, aby bylo možné povolit ID úloh Microsoft Entra. Následující příklad vytvoří cluster s jedním uzlem:

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

Po několika minutách se příkaz dokončí a vrátí informace o clusteru ve formátu JSON.

Přidejte následující kód do main.tf a vytvořte cluster AKS s vystavitelem OIDC a s povoleným ID úloh Microsoft Entra:

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

Aktualizace existujícího clusteru AKS

Aktualizujte existující cluster AKS, aby bylo možné povolit vystavitele OIDC a ID úloh Microsoft Entra pomocí příkazu az aks update pomocí parametrů --enable-oidc-issuer a --enable-workload-identity.

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

Pokud už máte existující cluster AKS spravovaný Terraformem, můžete aktualizovat prostředek azurerm_kubernetes_cluster ve vašem souboru main.tf, abyste povolili vystavitele OIDC a ID úloh Microsoft Entra:

  oidc_issuer_enabled               = true
  workload_identity_enabled         = true

Získejte adresu URL vystavitele OIDC

Pomocí příkazu az aks show získejte adresu URL vystavitele OIDC a uložte ji do proměnné prostředí.

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

Proměnná prostředí by měla obsahovat adresu URL vystavitele, podobně jako v následujícím příkladu:

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

Ve výchozím nastavení je vystavitel nastavený tak, aby používal základní adresu URL https://{region}.oic.prod-aks.azure.com/{tenant_id}/{uuid}, kde hodnota {region} odpovídá umístění, do kterého je cluster AKS nasazen. Hodnota {uuid} představuje klíč OIDC, což je náhodně vygenerovaný a neměnný identifikátor GUID pro každý cluster.

Přidejte následující kód do main.tf, abyste načetli adresu URL vydavatele OIDC:

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

Vytvoření spravované identity

1. Získejte ID předplatného a pomocí příkazu az account show ho uložte do proměnné prostředí.

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

2. Vytvořte spravovanou identitu přiřazenou uživatelem pomocí příkazu az identity create.

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

   Následující příklad výstupu ukazuje úspěšné vytvoření spravované identity:

   {
     "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. Získejte ID klienta spravované identity a pomocí příkazu ho uložte do proměnné az identity show prostředí.

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

Přidejte následující kód do main.tf pro vytvoření spravované identity.

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
}

Vytvoření účtu služby Kubernetes

1. Připojte se ke clusteru AKS pomocí az aks get-credentials příkazu.

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

2. Vytvořte účet služby Kubernetes a označte ho ID klienta spravované identity použitím následujícího manifestu kubectl apply pomocí příkazu.

   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
   

   Následující výstup ukazuje úspěšné vytvoření identity úlohy:

   serviceaccount/workload-identity-sa created
   

1. Přidáním následujícího kódu main.tf nakonfigurujte přístup Kubernetes tak, aby umožňoval vytváření prostředků Kubernetes:

   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. Přidáním následujícího kódu main.tf vytvořte účet služby Kubernetes a přidejte k němu poznámku s ID klienta spravované identity:

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

Vytvořte přihlašovací údaje pro federovanou identitu

Pomocí příkazu az identity federated-credential create vytvořte přihlašovací údaje federované identity mezi spravovanou identitou, vystavitelem účtu služby a předmětem.

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

Poznámka:

Přihlašovací údaje federované identity se po přidání rozšíří během několika sekund. Pokud se žádost o token provede okamžitě po přidání přihlašovacích údajů federované identity, může požadavek selhat, dokud se mezipaměť neaktualizuje. Abyste se tomuto problému vyhnuli, můžete po přidání přihlašovacích údajů federované identity přidat mírné zpoždění.

Přidejte následující kód do main.tf, abyste vytvořili přihlašovací údaje federované identity mezi spravovanou identitou, vystavitelem účtu služby a předmětem:

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

Další informace o přihlašovacích údajích federované identity v Microsoft Entra najdete v tématu Přehled přihlašovacích údajů federované identity v Microsoft Entra ID.

Vytvořte trezor klíčů s autorizací Azure RBAC

Následující příklad ukazuje, jak pomocí modelu oprávnění řízení přístupu na základě role (Azure RBAC) Azure udělit podu přístup k trezoru klíčů. Další informace o modelu oprávnění RBAC Azure pro Azure Key Vault najdete v Udělte oprávnění aplikacím pro přístup k trezoru klíčů Azure pomocí Azure RBAC.

1. Pomocí příkazu az keyvault create vytvořte úložiště klíčů s povolenou ochranou před vymazáním a autorizací pomocí Azure RBAC. Stávající úložiště klíčů můžete použít, pokud je nakonfigurováno jak pro ochranu před vymazáním, tak pro ověřování pomocí Azure RBAC.

   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. Získejte ID prostředku trezoru klíčů a pomocí příkazu ho uložte do proměnné az keyvault show prostředí.

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

Do main.tf přidejte následující kód pro vytvoření trezoru klíčů s autorizací RBAC Azure:

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
}

Přiřazení oprávnění RBAC pro správu trezoru klíčů

1. Pomocí příkazu získejte ID objektu volajícího a uložte ho az ad signed-in-user show do proměnné prostředí.

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

2. Přiřaďte si roli Azure RBAC Key Vault Secrets Officer, abyste mohli v novém trezoru klíčů vytvořit tajný kód pomocí příkazu az role assignment create.

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

Do main.tf přidejte následující kód, který vám přiřadí roli Azure RBAC důstojník pro tajemství Key Vault, abyste mohli vytvořit tajemství v novém Key Vault a přiřadit roli uživatel tajemství Key Vault identitě spravované uživatelem:

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
}

Vytvoření a konfigurace přístupu k tajným kódům

1. Pomocí příkazu az keyvault secret set vytvořte tajemství v klíčovém trezoru.

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

2. Získejte ID hlavního objektu pro uživatelem přiřazenou řízenou identitu a pomocí příkazu az identity show ho uložte do proměnné prostředí.

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

3. Pomocí příkazu az role assignment create přiřaďte roli Key Vault Secrets User spravované identitě přiřazené uživatelem. Tento krok poskytuje spravované identitě oprávnění ke čtení tajných kódů z trezoru klíčů.

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

4. Vytvořte pomocí příkazu az keyvault show proměnnou prostředí pro adresu URL trezoru klíčů.

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

Přidejte následující kód do main.tf pro vytvoření tajemství v klíčovém trezoru:

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

Nasazení ověřovacího podu a testovacího přístupu

1. Nasaďte pod, abyste ověřili, že identita úlohy má přístup k tajnému kódu v trezoru klíčů. Následující příklad používá image ghcr.io/azure/azure-workload-identity/msal-go, která obsahuje ukázkovou aplikaci, která načte tajný kód z Azure Key Vault pomocí ID úloh Microsoft Entra:

   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. Počkejte, až bude pod ve stavu Ready pomocí příkazu kubectl wait.

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

3. Pomocí příkazu SECRET_NAME zkontrolujte, zda je v podu nastavena proměnná prostředí kubectl describe.

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

   V případě úspěchu by měl být výstup podobný následujícímu příkladu:

   SECRET_NAME: ${KEYVAULT_SECRET_NAME}
   

4. Pomocí příkazu kubectl logs ověřte, že pody můžou získat token a přistoupit k prostředku.

   kubectl logs sample-workload-identity-key-vault
   

   V případě úspěchu by měl být výstup podobný následujícímu příkladu:

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

   Důležité

   Přiřazení rolí v Azure RBAC může trvat až 10 minut, než se projeví. Pokud pod nemůže získat přístup k tajnému kódu, možná budete muset počkat, až se přiřazení role rozšíří. Další informace najdete v tématu Troubleshoot Azure RBAC.

Zakázání ID úloh Microsoft Entra v clusteru AKS

Zakažte ID úloh Microsoft Entra v clusteru AKS, kde je povolený a nakonfigurovaný, aktualizujte cluster AKS pomocí příkazu az aks update pomocí parametru --disable-workload-identity.

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

Nasazení ověřovacího podu

Přidejte následující kód do main.tf, abyste nasadili ověřovací pod, který používá identitu úlohy pro přístup k tajemství v úložišti klíčů.

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

Inicializujte Terraform

Inicializace Terraformu v adresáři obsahujícím váš main.tf soubor pomocí terraform init příkazu Tento příkaz stáhne poskytovatele Azure potřebného ke správě Azure prostředků pomocí Terraformu.

terraform init

Vytvoření plánu provádění Terraformu

Pomocí příkazu vytvořte plán provádění Terraformu terraform plan . Tento příkaz ukazuje prostředky, které Terraform vytvoří nebo upraví ve vašem předplatném Azure.

terraform plan

Aplikujte konfiguraci Terraformu

Po kontrole a potvrzení plánu provádění aplikujte konfiguraci Terraformu pomocí příkazu terraform apply. Tento příkaz vytvoří nebo upraví prostředky definované v souboru main.tf ve vašem předplatném Azure.

terraform apply

Ověření nasazení

1. Připojte se ke clusteru AKS pomocí az aks get-credentials příkazu.

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

2. Pomocí příkazu zkontrolujte stav ověřovacího podu kubectl get pods .

3. Jakmile pod dosáhne Ready stavu, ověřte, že má přístup k tajnému kódu trezoru klíčů. Zkontrolujte protokoly podů pomocí kubectl logs příkazu.

   kubectl logs workload-identity-test
   

Související obsah

V tomto článku jste nasadili cluster Kubernetes a nakonfigurovali ho tak, aby používal ID úloh Microsoft Entra při přípravě úloh aplikací k ověření pomocí těchto přihlašovacích údajů. Teď jste připraveni nasadit aplikaci a nakonfigurovat ji tak, aby používala identitu úlohy s nejnovější verzí klientské knihovny Azure Identity. Pokud nemůžete přepsat svou aplikaci tak, aby používala nejnovější verzi klientské knihovny, můžete nastavit pod aplikace pro ověření pomocí spravované identity s identitou úloh jako dočasné řešení migrace.

Integrace Konektoru služby Service Connector pomáhá zjednodušit konfiguraci připojení pro úlohy AKS a podpůrné služby Azure. Bezpečně zpracovává konfiguraci ověřování a sítě a dodržuje osvědčené postupy pro připojení ke službám Azure. Další informace najdete v tématu Pojení k Azure OpenAI v modelech Foundry v AKS pomocí Microsoft Entra identity úloh a úvodu ke konektoru Service Connector.