Configuración de enlaces de identidad en Azure Kubernetes Service (AKS) (versión preliminar)

Configure enlaces de identidad en los clústeres de Azure Kubernetes Service (AKS) para asignar una identidad administrada asignada por el usuario (UAMI) en varios clústeres mientras usa una única credencial de identidad federada (FIC). Esta configuración le ayuda a escalar la autenticación de Microsoft Entra para cargas de trabajo sin alcanzar los límites de FIC.

Prerrequisitos

Instalación o actualización de la aks-preview extensión

  • Instale o actualice la extensión de la CLI aks-preview de Azure a la versión más reciente mediante el az extension add comando o az extension update :

    # Install the aks-preview extension
az extension add --name aks-preview

# Update to the latest version if already installed
az extension update --name aks-preview

Habilite la marca de características IdentityBindingPreview

  1. Registre la marca de características IdentityBindingPreview en su suscripción de Azure mediante el comando az feature register.

    az feature register --namespace Microsoft.ContainerService --name IdentityBindingPreview

    El registro de características puede tardar hasta 15 minutos en completarse.

  2. Espere a que la característica termine de registrarse con el az feature show comando .

    az feature show --namespace Microsoft.ContainerService --name IdentityBindingPreview

  3. Una vez que la característica se muestre como Registered, actualice el registro del proveedor mediante el az provider register comando .

    az provider register --namespace Microsoft.ContainerService

Limitaciones

Creación de recursos de prueba

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

    export RESOURCE_GROUP="ib-test"
export LOCATION="westus2"

az group create --name $RESOURCE_GROUP --location $LOCATION

  2. Cree un clúster de AKS con la identidad del trabajo y el emisor de OIDC habilitados mediante el comando az aks create con las marcas --enable-workload-identity y --enable-oidc-issuer.

    export CLUSTER_NAME="ib-test-cluster"

az aks create --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --location $LOCATION --no-ssh-key --enable-workload-identity --enable-oidc-issuer

  3. Cree una identidad administrada asignada por el usuario (UAMI) mediante el az identity create comando .

    export MI_NAME="ib-test-mi"
az identity create --resource-group $RESOURCE_GROUP --name $MI_NAME

Comprobación de la versión del webhook de identidad de carga de trabajo

  • El enlace de identidad requiere la versión preliminar del webhook de identidad de carga de trabajo. Compruebe la versión de webhook instalada con el siguiente kubectl get pods comando:

    kubectl -n kube-system get pods -l azure-workload-identity.io/system=true -o yaml | grep v1.6.0

    La salida debe mostrarse v1.6.0-alpha.1 en la etiqueta de imagen, lo que confirma que está instalada la versión correcta.

Obtención de los identificadores UAMI

  • Obtenga los identificadores de recurso, principal, cliente y tenant de UAMI y establézcalos como variables de entorno mediante los siguientes az identity show comandos:

    export MI_RESOURCE_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $MI_NAME --query id --output tsv)
export MI_PRINCIPAL_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $MI_NAME --query principalId --output tsv)
export MI_CLIENT_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $MI_NAME --query clientId --output tsv)
export MI_TENANT_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $MI_NAME --query tenantId --output tsv)

Crear una vinculación de identidad

  • Asigne la UAMI al clúster de AKS con un enlace de identidad mediante el comando az aks identity-binding create.

    az aks identity-binding create --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME --name "${MI_NAME}-ib" --managed-identity-resource-id $MI_RESOURCE_ID

    Nota:

    Al crear un enlace de identidad, AKS crea automáticamente una credencial de identidad federada (FIC) denominada aks-identity-binding bajo la UAMI. AKS administra esta credencial. No modifique ni elimínelo mientras los enlaces de identidad están en uso. El FIC creado para las vinculaciones de identidad se comparte entre todas las vinculaciones de identidad que referencian la misma UAMI.

Obtener la URL del emisor de OIDC para UAMI

  • Para obtener la URL del emisor de OIDC asociada con UAMI, inspeccione la vinculación de identidad mediante el comando az aks identity-binding show.

    az aks identity-binding show --resource-group $RESOURCE_GROUP --cluster-name $CLUSTER_NAME --name "${MI_NAME}-ib"

    Salida de ejemplo condensada:

    {
  "oidcIssuer": {
    "oidcIssuerUrl": "https://ib.oic.prod-aks.azure.com/<MI-tenant-id>/<MI-client-id>"
  }
}

Conexión al clúster de AKS

  1. Obtenga las credenciales del clúster de AKS mediante el az aks get-credentials comando y guárdelas en un archivo kubeconfig independiente:

    az aks get-credentials --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME -a -f "${CLUSTER_NAME}.kubeconfig"

  2. Establezca la KUBECONFIG variable de entorno para que apunte al nuevo archivo kubeconfig:

    export KUBECONFIG="$(pwd)/${CLUSTER_NAME}.kubeconfig"

Autorizar espacios de nombres y cuentas de servicio

  • Configura el control de acceso basado en roles (RBAC) para conceder a determinados sujetos el permiso para usar la identidad administrada a través de la vinculación de identidad aplicando el siguiente manifiesto con el siguiente kubectl apply comando.

    Nota:

    El ejemplo siguiente se refiere explícitamente a la cuenta de servicio demo en el espacio de nombres demo. Aunque hacer referencia explícitamente a una cuenta de servicio específica es una opción, también es posible hacer referencia a una colección de cuentas de servicio en subjects. Para más información, consulte Referencia a temas en la documentación de Kubernetes.

    kubectl apply -f - <<EOF
apiVersion: v1
kind: Namespace
metadata:
  name: demo
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: demo
  namespace: demo
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: use-mi-${MI_CLIENT_ID}
rules:
  - verbs: ["use-managed-identity"]
    apiGroups: ["cid.wi.aks.azure.com"]
    resources: ["${MI_CLIENT_ID}"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: use-mi-${MI_CLIENT_ID}
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: use-mi-${MI_CLIENT_ID}
subjects:
  - kind: ServiceAccount
    name: demo
    namespace: demo
EOF

Crear un almacén de claves con protección contra purgas y autorización de Azure RBAC

  • Cree un almacén de claves con protección de purga y autorización de RBAC de Azure habilitada utilizando el comando az keyvault create con las marcas --enable-purge-protection y --enable-rbac-authorization. También puede usar un almacén de claves existente si está configurado para la protección de purga y la autorización de RBAC de Azure.

    export KEY_VAULT_NAME="ib-test"

az keyvault create \
    --name $KEY_VAULT_NAME \
    --resource-group $RESOURCE_GROUP \
    --location $LOCATION \
    --enable-purge-protection \
    --enable-rbac-authorization

Obtener el identificador y la dirección URL del recurso del almacén de claves

  1. Obtenga el identificador de recurso del almacén de claves mediante el az keyvault show comando y establézcalo como una variable de entorno:

    export KEY_VAULT_RESOURCE_ID=$(az keyvault show --resource-group $RESOURCE_GROUP \
    --name $KEY_VAULT_NAME \
    --query id \
    --output tsv)

  2. Obtenga la dirección URL del almacén de claves mediante el az keyvault show comando y establézcala como una variable de entorno:

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

Configuración del acceso al almacén de claves y creación de secretos

En los pasos siguientes se muestra cómo acceder a secretos, claves o certificados en Azure Key Vault desde el pod. Los ejemplos de esta sección configuran el acceso a secretos en el almacén de claves para la identidad de carga de trabajo, pero puede realizar pasos similares para configurar el acceso a claves o certificados.

En el ejemplo siguiente se muestra cómo usar el modelo de permisos RBAC de Azure para conceder al pod acceso al almacén de claves. Para más información sobre el modelo de permisos RBAC de Azure para Azure Key Vault, consulte Concesión de permiso a las aplicaciones para acceder a Azure Key Vault mediante Azure RBAC.

  1. Obtenga el identificador de objeto del usuario que ha iniciado sesión con el az ad signed-in-user show comando y establézcalo como una variable de entorno:

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

  2. Asígnese el rol de Agente de secretos del almacén de claves de Azure RBAC en el almacén de claves mediante el comando az role assignment create.

    az role assignment create --assignee $CALLER_OBJECT_ID \
    --role "Key Vault Secrets Officer" \
    --scope $KEY_VAULT_RESOURCE_ID

  3. Cree un secreto en el almacén de claves mediante el comando az keyvault secret set.

    export KEY_VAULT_SECRET_NAME="my-secret"

az keyvault secret set \
    --vault-name $KEY_VAULT_NAME \
    --name $KEY_VAULT_SECRET_NAME \
    --value "Hello\!"

  4. Asigne el rol Usuario de secretos de Key Vault al UAMI usando el comando az role assignment create.

    az role assignment create \
    --assignee-object-id $MI_PRINCIPAL_ID \
    --role "Key Vault Secrets User" \
    --scope $KEY_VAULT_RESOURCE_ID \
    --assignee-principal-type ServicePrincipal

Anotación de la cuenta de servicio

  1. Anote la cuenta de servicio con el ID del inquilino de identidad administrada mediante el comando kubectl annotate.

    kubectl annotate sa demo -n demo azure.workload.identity/tenant-id=$MI_TENANT_ID

  2. Anote la cuenta de servicio con el ID del cliente de identidad administrada mediante el comando kubectl annotate.

    kubectl annotate sa demo -n demo azure.workload.identity/client-id=$MI_CLIENT_ID

Implementación de una aplicación de ejemplo

  • Implemente el pod de ejemplo que usa el enlace de identidad para obtener un token de acceso para la identidad administrada para acceder a Azure Key Vault mediante el comando siguiente kubectl apply :

    kubectl apply -f - <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: demo
  namespace: demo
  labels:
    azure.workload.identity/use: "true"
  annotations:
    azure.workload.identity/use-identity-binding: "true"
spec:
  serviceAccount: demo
  containers:
    - name: azure-sdk
      # source code: https://github.com/Azure/azure-workload-identity/blob/feature/custom-token-endpoint/examples/identitybinding-msal-go/main.go
      image: ghcr.io/bahe-msft/azure-workload-identity/identitybinding-msal-go:latest-linux-amd64
      env:
        - name: KEYVAULT_URL
          value: ${KEYVAULT_URL}
        - name: SECRET_NAME
          value: ${KEY_VAULT_SECRET_NAME}
  restartPolicy: Never
EOF

Comprobación del acceso al almacén de claves desde una aplicación de ejemplo

  1. Describa el pod y confirme que las variables de entorno y los montajes de volúmenes de tokens proyectados están presentes utilizando el comando kubectl describe pod.

    kubectl describe pod demo -n demo

    La salida esperada debe contener valores para AZURE_CLIENT_ID, AZURE_TENANT_ID, AZURE_FEDERATED_TOKEN_FILE, , AZURE_AUTHORITY_HOST, AZURE_KUBERNETES_TOKEN_PROXY. AZURE_KUBERNETES_SNI_NAME y AZURE_KUBERNETES_CA_FILE.

  2. Compruebe que el pod puede obtener un token y acceder al recurso mediante el kubectl logs comando .

    kubectl logs demo -n demo

    Si se ejecuta correctamente, la salida debe ser similar al ejemplo siguiente:

    I1107 20:03:42.865180       1 main.go:77] "successfully got secret" secret="Hello!"

Escalar vinculaciones de identidad en varios clústeres

Las vinculaciones de identidad permiten asignar varios clústeres de AKS al mismo UAMI manteniendo el uso de un único FIC. Para escalar los enlaces de identidad en varios clústeres, puede repetir los pasos desde Crear un enlace de identidad hasta verificar el acceso al almacén de claves desde la aplicación de ejemplo para cada clúster adicional que desee asignar a la misma UAMI (creando un nuevo enlace de identidad por clúster).

Limpieza de recursos

Si ya no necesita los recursos que creó en este artículo, puede limpiarlos para evitar incurrir en costos futuros.

  1. Elimine el pod mediante el kubectl delete pod comando .

    kubectl delete pod demo -n demo

  2. Elimine el espacio de nombres con el comando kubectl delete ns.

    kubectl delete ns demo

  3. Elimine el grupo de recursos y todos los recursos relacionados mediante el az group delete comando .

    az group delete --name $RESOURCE_GROUP --yes --no-wait

Contenido relacionado

  • Last updated on