Tutorial: Uso de una identidad de carga de trabajo con una aplicación en Azure Kubernetes Service (AKS)

Artículo
10/25/2023

Azure Kubernetes Service (AKS) es un servicio de Kubernetes administrado que permite implementar y administrar clústeres de Kubernetes rápidamente. En este tutorial ha:

Implemente un clúster de AKS mediante la CLI de Azure con el emisor y la identidad administrada de OpenID Connect (OIDC).
Cree un secreto y una instancia de Azure Key Vault.
Cree un identificador de carga de trabajo de Microsoft Entra y una cuenta de servicio de Kubernetes.
Configure la identidad administrada para la federación de tokens.
Implemente la carga de trabajo y compruebe la autenticación con la identidad de carga de trabajo.

Antes de comenzar

En este tutorial se da por supuesto que tiene un conocimiento básico de los conceptos de Kubernetes. Para más información, consulte Conceptos básicos de Kubernetes de Azure Kubernetes Service (AKS).
Si no está familiarizado con Microsoft Entra Workload ID, consulte la información general sobre este.
Al crear un clúster de AKS, se crea automáticamente un segundo grupo de recursos para almacenar los recursos de dicho clúster. Para más información, consulte ¿Por qué se crean dos grupos de recursos con AKS?

Requisitos previos

Si no tiene una suscripción a Azure, cree una cuenta gratuita de Azure antes de empezar.
En este artículo se necesita la versión 2.47.0, o versiones posteriores, de la CLI de Azure. Si usa Azure Cloud Shell, ya está instalada la versión más reciente.
La identidad que usa para crear el clúster debe tener los permisos mínimos adecuados. Para más información sobre el acceso y la identidad en AKS, consulte Opciones de acceso e identidad en Azure Kubernetes Service (AKS).
Si tiene varias suscripciones de Azure, seleccione el identificador de suscripción adecuado en el que se deben facturar los recursos con el comando az account set.

Crear un grupo de recursos

Un grupo de recursos de Azure es un grupo lógico en el que se implementan y administran recursos de Azure. Cuando crea un grupo de recursos, se le pide que especifique una ubicación. Esta ubicación es la ubicación de almacenamiento de los metadatos del grupo de recursos y donde se ejecutan los recursos en Azure si no se especifica otra región durante la creación de recursos.

En el ejemplo siguiente, se crea un grupo de recursos denominado myResourceGroup en la ubicación eastus.

Cree un grupo de recursos con el comando az group create.

az group create --name myResourceGroup --location eastus

El ejemplo de salida siguiente es similar a la creación correcta del grupo de recursos:

{
  "id": "/subscriptions/<guid>/resourceGroups/myResourceGroup",
  "location": "eastus",
  "managedBy": null,
  "name": "myResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null
}

Exportación de variables de entorno

Para ayudar a simplificar los pasos para configurar las identidades necesarias, en los pasos siguientes se definen variables de entorno como referencia en el clúster.

Cree estas variables con los siguientes comandos. Reemplace los valores predeterminados de RESOURCE_GROUP, LOCATION, SERVICE_ACCOUNT_NAME, SUBSCRIPTION, USER_ASSIGNED_IDENTITY_NAME y FEDERATED_IDENTITY_CREDENTIAL_NAME.

export RESOURCE_GROUP="myResourceGroup"
export LOCATION="westcentralus"
export SERVICE_ACCOUNT_NAMESPACE="default"
export SERVICE_ACCOUNT_NAME="workload-identity-sa"
export SUBSCRIPTION="$(az account show --query id --output tsv)"
export USER_ASSIGNED_IDENTITY_NAME="myIdentity"
export FEDERATED_IDENTITY_CREDENTIAL_NAME="myFedIdentity"
export KEYVAULT_NAME="azwi-kv-tutorial"
export KEYVAULT_SECRET_NAME="my-secret"

Creación de un clúster de AKS

Cree un clúster de AKS con el comando az aks create y el parámetro --enable-oidc-issuer para utilizar el emisor de OIDC.
```
az aks create --resource-group "${RESOURCE_GROUP}" --name myAKSCluster --node-count 1 --enable-oidc-issuer --enable-workload-identity --generate-ssh-keys
```
Transcurridos unos minutos, el comando se completa y devuelve información en formato JSON sobre el clúster.
Obtenga la dirección URL del emisor de OIDC y guárdela en una variable de entorno con el siguiente comando. Reemplace el valor predeterminado de los argumentos -n, que es el nombre del clúster.
```
export AKS_OIDC_ISSUER="$(az aks show --name myAKSCluster --resource-group "${RESOURCE_GROUP}" --query "oidcIssuerProfile.issuerUrl" -o tsv)"
```
La variable debe contener una dirección URL del emisor similar al ejemplo siguiente:
```
https://eastus.oic.prod-aks.azure.com/00000000-0000-0000-0000-000000000000/00000000-0000-0000-0000-000000000000/
```
De manera predeterminada, el emisor tiene establecido usar la dirección URL base https://{region}.oic.prod-aks.azure.com, donde el valor de {region} coincide con la ubicación en la que se implementa el clúster de AKS.

Creación de un secreto y una instancia de Azure Key Vault

Cree una instancia de Azure Key Vault en el grupo de recursos que ha creado en este tutorial mediante el comando az keyvault create.
```
az keyvault create --resource-group "${RESOURCE_GROUP}" --location "${LOCATION}" --name "${KEYVAULT_NAME}" --enable-rbac-authorization false
```
La salida de este comando muestra las propiedades del almacén de claves que acaba de crear. Tome nota de las dos propiedades siguientes:
- Name: nombre del almacén que proporcionó al parámetro --name.
- vaultUri: en el ejemplo, es https://<your-unique-keyvault-name>.vault.azure.net/. Las aplicaciones que utilizan el almacén a través de su API de REST deben usar este identificador URI.
En este momento, su cuenta de Azure es la única autorizada para realizar operaciones en este nuevo almacén.
Agregue un secreto al almacén con el comando az keyvault secret set. La contraseña es el valor especificado para la variable de entorno KEYVAULT_SECRET_NAME y almacena el valor de Hello! en ella.
```
az keyvault secret set --vault-name "${KEYVAULT_NAME}" --name "${KEYVAULT_SECRET_NAME}" --value 'Hello!'
```

Agregue la dirección URL de Key Vault a la variable de entorno KEYVAULT_URL mediante el comando az keyvault show.

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

Creación de una identidad administrada y concesión de permisos para acceder al secreto

Establezca una suscripción específica como la suscripción activa actual mediante el comando az account set.
```
az account set --subscription "${SUBSCRIPTION}"
```

Cree una identidad administrada mediante el comando az identity create.

az identity create --name "${USER_ASSIGNED_IDENTITY_NAME}" --resource-group "${RESOURCE_GROUP}" --location "${LOCATION}" --subscription "${SUBSCRIPTION}"

Establezca una directiva de acceso para que la identidad administrada acceda al secreto de Key Vault mediante los siguientes comandos.

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

az keyvault set-policy --name "${KEYVAULT_NAME}" --secret-permissions get --spn "${USER_ASSIGNED_CLIENT_ID}"

Creación de una cuenta de servicio de Kubernetes

Cree una cuenta de servicio de Kubernetes y anote en ella el identificador de cliente de la identidad administrada creada en el paso anterior mediante el comando az aks get-credentials. Reemplace el valor predeterminado para el nombre del clúster y el nombre del grupo de recursos.
```
az aks get-credentials --name myAKSCluster --resource-group "${RESOURCE_GROUP}"
```

Copie la siguiente entrada de varias líneas en el terminal y ejecute el comando para crear la cuenta de servicio.

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

El ejemplo de salida siguiente es similar a la creación correcta del grupo de recursos:

Serviceaccount/workload-identity-sa created

Establecimiento de una credencial de identidad federada

Cree la credencial de identidad federada entre la identidad administrada, el emisor de la cuenta de servicio y el firmante mediante el comando az identity federated-credential create.
```
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}
```
Nota:

La credencial de identidad federada tarda unos segundos en propagarse después de agregarse inicialmente. Si una solicitud de token está disponible inmediatamente después de agregar la credencial de identidad federada, podría aparecer un error durante un par de minutos, ya que la memoria caché se rellena en el directorio con datos antiguos. Para evitar este problema, puede agregar un ligero retraso después de agregar la credencial de identidad federada.

Implementación de la carga de trabajo

Implemente un pod que haga referencia a la cuenta de servicio creada en el paso anterior mediante el siguiente comando.

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: quick-start
  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

El ejemplo de salida siguiente es similar a la creación correcta del pod:

pod/quick-start created

Compruebe si todas las propiedades se insertan correctamente con el webhook mediante el comando kubectl describe.
```
kubectl describe pod quick-start
```
Compruebe que el pod pueda obtener un token y acceder al secreto desde la instancia de Key Vault mediante el comando kubectl logs.
```
kubectl logs quick-start
```
El ejemplo de salida siguiente es similar al acceso correcto del token:
```
I1013 22:49:29.872708       1 main.go:30] "successfully got secret" secret="Hello!"
```

Limpieza de recursos

Es posible que desee dejar estos recursos en su lugar. Si ya no necesita estos recursos, use los siguientes comandos para eliminarlos.

Elimine el pod mediante el comando kubectl delete pod.
```
kubectl delete pod quick-start
```

Elimine la cuenta de servicio mediante el comando kubectl delete sa.

kubectl delete sa "${SERVICE_ACCOUNT_NAME}" --namespace "${SERVICE_ACCOUNT_NAMESPACE}"

Elimine el grupo de recursos de Azure y todos sus recursos mediante el comando az group delete.
```
az group delete --name "${RESOURCE_GROUP}"
```

Pasos siguientes

En este tutorial, ha implementado un clúster de Kubernetes y una aplicación de contenedor simple para probar cómo se trabaja con una instancia de Id. de carga de trabajo de Microsoft Entra.

Este inicio rápido es una introducción. Para instrucciones sobre cómo crear soluciones completas con AKS para producción, consulte Guía de soluciones de AKS.

Share via