Compartir a través de

Acceso seguro a Azure OpenAI desde Azure Kubernetes Service (AKS)

En este artículo, aprenderá a proteger el acceso a Azure OpenAI desde Azure Kubernetes Service (AKS) mediante Id. de carga de trabajo de Microsoft Entra. Aprenderá a:

  • Active las identidades de carga de trabajo en un clúster AKS.
  • Cree una identidad administrada asignada por el usuario de Azure.
  • Cree una credencial federada Microsoft Entra ID.
  • Habilite la identidad de carga de trabajo en un pod de Kubernetes.

Nota:

Se recomienda usar Id. de carga de trabajo de Microsoft Entra e identidades administradas en AKS para Azure acceso openAI, ya que permite un proceso de autenticación seguro y sin contraseña para acceder a los recursos de Azure.

Antes de empezar

  • Necesita una cuenta de Azure con una suscripción activa. Si no tiene ninguna cuenta, cree una gratuita.
  • Este artículo se basa en Implementación de una aplicación que usa OpenAI en AKS. Debe completar ese artículo antes de comenzar este.
  • Necesita habilitar un nombre de dominio personalizado en su cuenta de Azure OpenAI para utilizarlo en la autorización de Microsoft Entra. Para obtener más información, consulte Nombres de subdominios personalizados para herramientas de fundición.

Requisitos previos

  • Use el entorno de Bash en Azure Cloud Shell. Para obtener más información, consulte Get started with Azure Cloud Shell.

  • Si prefiere ejecutar localmente comandos de referencia de la CLI, instale la CLI de Azure. Si se ejecuta en Windows o macOS, considere la posibilidad de ejecutar CLI de Azure en un contenedor de Docker. Para obtener más información, consulte Cómo ejecutar el CLI de Azure en un contenedor de Docker.

    • Si usa una instalación local, inicie sesión en el CLI de Azure mediante el comando az login. Siga los pasos que se muestran en el terminal para completar el proceso de autenticación. Para ver otras opciones de inicio de sesión, consulte Authenticate para Azure con CLI de Azure.

    • Cuando se le solicite, instale la extensión CLI de Azure en el primer uso. Para obtener más información sobre las extensiones, consulte Use y administre extensiones con el CLI de Azure.

    • Ejecute az version para buscar cuál es la versión y las bibliotecas dependientes que están instaladas. Para realizar la actualización a la versión más reciente, ejecute az upgrade.

Habilitación de Id. de carga de trabajo de Microsoft Entra en un clúster de AKS

Las funciones Id. de carga de trabajo de Microsoft Entra y el endpoint del emisor de OIDC no están habilitadas en AKS por defecto. Debe habilitarlas en el clúster de AKS para poder usarlas.

  1. Establezca el nombre del grupo de recursos y las variables de nombre del grupo de recursos del clúster de AKS.

    # Set the resource group variable
RG_NAME=myResourceGroup

# Set the AKS cluster name based on the resource group variable
AKS_NAME=$(az resource list --resource-group $RG_NAME --resource-type Microsoft.ContainerService/managedClusters --query "[0].name" -o tsv)

  2. Habilite las características de Id. de carga de trabajo de Microsoft Entra y de punto de conexión del emisor OIDC en su clúster AKS existente utilizando el comando az aks update.

    az aks update \
    --resource-group $RG_NAME \
    --name $AKS_NAME \
    --enable-workload-identity \
    --enable-oidc-issuer

  3. Obtenga la dirección URL del punto de conexión del emisor OIDC de AKS mediante el comando .

    AKS_OIDC_ISSUER=$(az aks show --resource-group $RG_NAME --name $AKS_NAME --query "oidcIssuerProfile.issuerUrl" -o tsv)

Creación de una identidad administrada asignada por el usuario Azure

  1. Cree una identidad administrada asignada por el usuario Azure mediante el comando az identity create.

    # Set the managed identity name variable
MANAGED_IDENTITY_NAME=myIdentity

# Create the managed identity
az identity create \
    --resource-group $RG_NAME \
    --name $MANAGED_IDENTITY_NAME

  2. Obtenga el ID de cliente de identidad administrada y el ID de objeto usando el comando.

    # Get the managed identity client ID
MANAGED_IDENTITY_CLIENT_ID=$(az identity show --resource-group $RG_NAME --name $MANAGED_IDENTITY_NAME --query clientId -o tsv)

# Get the managed identity object ID
MANAGED_IDENTITY_OBJECT_ID=$(az identity show --resource-group $RG_NAME --name $MANAGED_IDENTITY_NAME --query principalId -o tsv)

  3. Obtenga el identificador de recurso de OpenAI de Azure mediante el comando az resource list.

    AOAI_RESOURCE_ID=$(az resource list --resource-group $RG_NAME --resource-type Microsoft.CognitiveServices/accounts --query "[0].id" -o tsv)

  4. Conceda a la identidad administrada acceso al recurso de OpenAI de Azure mediante el comando az role assignment create.

    az role assignment create \
    --role "Cognitive Services OpenAI User" \
    --assignee-object-id $MANAGED_IDENTITY_OBJECT_ID \
    --assignee-principal-type ServicePrincipal \
    --scope $AOAI_RESOURCE_ID

Creación de una credencial federada Microsoft Entra ID

  1. Configure las variables de credencial federada, espacio de nombres y cuenta de servicio.

    # Set the federated credential name variable
FEDERATED_CREDENTIAL_NAME=myFederatedCredential

# Set the namespace variable
SERVICE_ACCOUNT_NAMESPACE=default

# Set the service account variable
SERVICE_ACCOUNT_NAME=ai-service-account

  2. Cree la credencial federada mediante el comando .

    az identity federated-credential create \
    --name ${FEDERATED_CREDENTIAL_NAME} \
    --resource-group ${RG_NAME} \
    --identity-name ${MANAGED_IDENTITY_NAME} \
    --issuer ${AKS_OIDC_ISSUER} \
    --subject system:serviceaccount:${SERVICE_ACCOUNT_NAMESPACE}:${SERVICE_ACCOUNT_NAME}

Uso de Id. de carga de trabajo de Microsoft Entra en AKS

Para usar Id. de carga de trabajo de Microsoft Entra en AKS, debe realizar algunos cambios en el manifiesto de implementación de ai-service.

Creación de una cuenta de servicio

  1. Obtenga kubeconfig para el clúster mediante el comando .

    az aks get-credentials \
    --resource-group $RG_NAME \
    --name $AKS_NAME

  2. Cree un ServiceAccount de Kubernetes usando el comando.

    kubectl apply -f - <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
  annotations:
    azure.workload.identity/client-id: ${MANAGED_IDENTITY_CLIENT_ID}
  name: ${SERVICE_ACCOUNT_NAME}
  namespace: ${SERVICE_ACCOUNT_NAMESPACE}
EOF

Habilitar Id. de carga de trabajo de Microsoft Entra en el pod

  1. Establezca las variables: nombre del recurso de Azure OpenAI, endpoint y nombre de implementación.

    # Get the Azure OpenAI resource name
AOAI_NAME=$(az resource list \
  --resource-group $RG_NAME \
  --resource-type Microsoft.CognitiveServices/accounts \
  --query "[0].name" -o tsv)

# Get the Azure OpenAI endpoint
AOAI_ENDPOINT=$(az cognitiveservices account show \
  --resource-group $RG_NAME \
  --name $AOAI_NAME \
  --query properties.endpoint -o tsv)

# Get the Azure OpenAI deployment name
AOAI_DEPLOYMENT_NAME=$(az cognitiveservices account deployment list  \
  --resource-group $RG_NAME \
  --name $AOAI_NAME \
  --query "[0].name" -o tsv)

  2. Vuelva a implementar con ServiceAccount y la anotación establecida en mediante el comando .

    kubectl apply -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ai-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ai-service
  template:
    metadata:
      labels:
        app: ai-service
        azure.workload.identity/use: "true"
    spec:
      serviceAccountName: $SERVICE_ACCOUNT_NAME
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: ai-service
        image: ghcr.io/azure-samples/aks-store-demo/ai-service:latest
        ports:
        - containerPort: 5001
        env:
        - name: USE_AZURE_OPENAI
          value: "True"
        - name: USE_AZURE_AD
          value: "True"
        - name: AZURE_OPENAI_DEPLOYMENT_NAME
          value: "${AOAI_DEPLOYMENT_NAME}"
        - name: AZURE_OPENAI_ENDPOINT
          value: "${AOAI_ENDPOINT}"
        resources:
          requests:
            cpu: 20m
            memory: 50Mi
          limits:
            cpu: 50m
            memory: 128Mi
EOF

Prueba de la aplicación

  1. Compruebe que el nuevo pod está ejecutándose mediante el comando .

    kubectl get pods --selector app=ai-service

  2. Obtenga las variables de entorno del pod mediante el comando. La salida muestra que la clave de API de OpenAI de Azure ya no existe en las variables de entorno del pod.

    kubectl describe pod --selector app=ai-service

  3. Abra un nuevo terminal y obtenga la dirección IP del servicio de administración de la tienda mediante el siguiente comando .

    echo "http://$(kubectl get svc/store-admin -o jsonpath='{.status.loadBalancer.ingress[0].ip}')"

  4. Abra un explorador y vaya a la dirección IP desde el paso anterior.

  5. Seleccione Productos. Debería poder agregar un nuevo producto y obtener una descripción para él mediante Azure OpenAI.

Pasos siguientes

En este artículo, ha aprendido a proteger el acceso a Azure OpenAI desde Azure Kubernetes Service (AKS) mediante Id. de carga de trabajo de Microsoft Entra.

Para obtener más información sobre Id. de carga de trabajo de Microsoft Entra, consulte Id. de carga de trabajo de Microsoft Entra.

  • Last updated on