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

Artículo
10/25/2023

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

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

Nota:

Se recomienda usar Microsoft Entra Workload ID e identidades administradas en AKS para el acceso a Azure OpenAI, ya que permite un proceso de autenticación seguro 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 un nombre de dominio personalizado habilitado en su cuenta de Azure OpenAI para usarlo para la autorización de Microsoft Entra. Para obtener más información, consulte Nombres de subdominios personalizados para servicios de Azure AI.

Requisitos previos

Use el entorno de Bash en Azure Cloud Shell. Para más información, consulte Inicio rápido para Bash en Azure Cloud Shell.
Si prefiere ejecutar comandos de referencia de la CLI localmente, instale la CLI de Azure. Si utiliza Windows o macOS, considere la posibilidad de ejecutar la CLI de Azure en un contenedor Docker. Para más información, vea Ejecución de la CLI de Azure en un contenedor de Docker.
- Si usa una instalación local, inicie sesión en la 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 Inicio de sesión con la CLI de Azure.
- En caso de que se le solicite, instale las extensiones de la CLI de Azure la primera vez que la use. Para más información sobre las extensiones, consulte Uso de extensiones con la 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 Microsoft Entra Workload ID en un clúster de AKS

Las características Microsoft Entra Workload ID y punto de conexión del emisor de OIDC no están habilitadas en AKS de forma predeterminada. Debe habilitarlas en el clúster de AKS para poder usarlas.

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 resource group variable
AKS_NAME=$(az resource list --resource-group $RG_NAME --resource-type Microsoft.ContainerService/managedClusters --query "[0].name" -o tsv)

Habilite las características de Microsoft Entra Workload ID y punto de conexión del emisor de OIDC en el clúster de AKS existente mediante el comando az aks update.
```
az aks update \
    --resource-group $RG_NAME \
    --name $AKS_NAME \
    --enable-workload-identity \
    --enable-oidc-issuer
```

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

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

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

Cree una identidad administrada asignada por el usuario de 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

Obtenga el id. de cliente de identidad administrada y el identificador de objeto mediante el comando az identity show.

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

Obtenga el id. de recurso de Azure OpenAI 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)

Conceda a la identidad administrada acceso al recurso de Azure OpenAI 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 de Microsoft Entra ID

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

Cree la credencial federada mediante el comando az identity federated-credential create.

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 Microsoft Entra Workload ID en AKS

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

Creación de una cuenta de servicio

Obtenga kubeconfig para el clúster mediante el comando az aks get-credentials.

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

Cree una instancia de Kubernetes ServiceAccount mediante el comando kubectl apply.

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

Habilitación de Microsoft Entra Workload ID en el pod

Configure las variables de nombre de recurso, punto de conexión y nombre de implementación de Azure OpenAI.

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

Vuelva a implementar ai-service con ServiceAccount y la anotación azure.workload.identity/use establecida en true mediante el comando kubectl apply.

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

Compruebe que el pod está en ejecución mediante el comando kubectl get pods.
```
kubectl get pods --selector app=ai-service -w
```
Obtenga los registros del pod mediante el comando kubectl logs. El pod puede tardar unos minutos en inicializarse.
```
kubectl logs --selector app=ai-service -f
```
En la salida de ejemplo siguiente se muestra que la aplicación se ha inicializado y está lista para aceptar solicitudes. La primera línea sugiere que faltan variables de configuración en el código. Sin embargo, el SDK de Identidad de Azure controla este proceso y configura las variables AZURE_CLIENT_ID y AZURE_TENANT_ID.
```
Incomplete environment configuration. These variables are set: AZURE_CLIENT_ID, AZURE_TENANT_ID
INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:5001 (Press CTRL+C to quit)
```
Obtenga las variables de entorno de pod mediante el comando kubectl describe pod. La salida muestra que la clave de API de Azure OpenAI ya no existe en las variables de entorno del pod.
```
kubectl describe pod --selector app=ai-service
```
Abra un nuevo terminal y obtenga la dirección IP del servicio de administración de la tienda mediante el siguiente comando echo.
```
echo "http://$(kubectl get svc/store-admin -o jsonpath='{.status.loadBalancer.ingress[0].ip}')"
```
Abra un explorador y vaya a la dirección IP desde el paso anterior.
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 Microsoft Entra Workload ID.

Para obtener más información sobre Microsoft Entra Workload ID, consulte Microsoft Entra Workload ID.

Share via