Condividi tramite

Distribuire e configurare un'applicazione usando l'identità del carico di lavoro in un cluster di identità gestita di Azure Red Hat OpenShift

Questo articolo illustra come:

  • Creare un ID carico di lavoro Microsoft Entra e un account del servizio Kubernetes.
  • Configurare l'identità gestita per la federazione dei token.
  • Creare un Key Vault di Microsoft Azure con un nuovo segreto e assegnazioni di ruolo (per una demo).
  • Distribuire il carico di lavoro e verificare l'autenticazione con l'identità del carico di lavoro.
  • Concedere a un pod nel cluster l'accesso ai segreti in un archivio di chiavi di Azure.

Il processo comporta:

  • Ottenere l'URL dell'autorità di certificazione OIDC (OpenID Connect).
  • Creare un'identità gestita assegnata dall'utente per l'applicazione.
  • Eseguire l'assegnazione di ruolo nella risorsa desiderata.
  • Creare un account del servizio Kubernetes.
  • Impostare l'annotazione nell'account del servizio.
  • Creare le credenziali federate.
  • Distribuire l'applicazione e assicurarsi che:
    • Il .spec.serviceAccountName è impostato.
    • L'etichetta azure.workload.identity/use: "true" è impostata.

Prerequisiti

È necessario un cluster Azure Red Hat OpenShift con identità gestita esistente.

Verificare la distribuzione di pod-identity-webhook

Esiste un webhook di ammissione mutante che proietta un token dell'account del servizio firmato su un percorso noto e inserisce le variabili di ambiente correlate all'autenticazione nei pod dell'applicazione. Per altre informazioni, vedere Modifica del webhook di ammissione.

Verifica che l'annotazione target.workload.openshift.io/management sia impostata sulla distribuzione pod-identity-webhook nello spazio dei nomi openshift-cloud-credential-operator eseguendo il comando seguente:

oc describe deployment pod-identity-webhook -n openshift-cloud-credential-operator | grep 'target.workload.openshift.io/management'

Verrà visualizzata una risposta simile alla seguente:

Annotations: target.workload.openshift.io/management: {"effect": "PreferredDuringScheduling"}

Se si rileva che l'annotazione non è presente, aprire un caso di supporto.

Esportare le variabili di ambiente

Iniziare impostando le variabili di ambiente corrispondenti all'identità gestita esistente del cluster Azure Red Hat OpenShift. Assicurati di impostare i namespace corretti RESOURCE_GROUP, LOCATION, CLUSTER_NAME e i nomi di identità desiderati:

export KEYVAULT_NAME="azwi-kv-$(openssl rand -hex 2)"
export KEYVAULT_SECRET_NAME="my-secret"
export KEYVAULT_LOCATION="eastus"
export RESOURCE_GROUP="<ARO_CLUSTER_RESOURCE_GROUP>"
export CLUSTER_NAME="<ARO_CLUSTER_NAME>"
export SUBSCRIPTION="$(az account show --query id --output tsv)"
export USER_ASSIGNED_IDENTITY_NAME="example-user-assigned-identity"
export FEDERATED_IDENTITY_CREDENTIAL_NAME="example-federated-identity"
export SERVICE_ACCOUNT_NAMESPACE="example-project"
export SERVICE_ACCOUNT_NAME="example-workload-identity-sa"

Recuperare l'URL dell'autorità di certificazione OIDC

Ottenere l'URL dell'emittente OIDC del cluster Azure Red Hat OpenShift usando l'OC CLI di OpenShift e impostare la variabile di ambiente:

export ARO_OIDC_ISSUER="$(oc get authentication cluster -o jsonpath='{.spec.serviceAccountIssuer}')"

Facoltativamente, se non si ha accesso al cluster, ottenere l'URL dell'autorità di certificazione OIDC del cluster Red Hat OpenShift usando l'interfaccia della riga di comando di Azure:

export ARO_OIDC_ISSUER="$(az aro show --subscription "${SUBSCRIPTION}" \
    --name "${CLUSTER_NAME}" \
    --resource-group "${RESOURCE_GROUP}" \
    --query "clusterProfile.oidcIssuer" \
    --output tsv)"

Verificare che l'URL corretto sia impostato:

echo $ARO_OIDC_ISSUER
https://eastus.oic.aro.azure.net/00000000-0000-0000-0000-000000000000/11111111-1111-1111-1111-111111111111

Per impostazione predefinita, l'autorità emittente è impostata per usare l'URL https://{region}.oic.aro.azure.net/{tenant_id}/{uuid}di base , dove il valore per {region} corrisponde alla posizione in cui viene distribuito il cluster Azure Red Hat OpenShift. Il valore {uuid} rappresenta la chiave OIDC, che è un GUID specifico del cluster non modificabile generato in modo casuale.

Creare una risorsa di esempio

In questo esempio viene creato un nuovo Key Vault di Microsoft Azure con un nuovo segreto, a cui si accede successivamente tramite l'ID del carico di lavoro di Microsoft Entra. Usare lo strumento da riga di comando di Azure az per creare l'insieme di credenziali che verrà successivamente accesso.

Assicurati che il ruolo di Ufficiale delle chiavi segrete di Key Vault nel controllo degli accessi basato sul ruolo di Azure (RBAC) sia assegnato a te stesso.

# If necessary, create the Resource Group
az group create --resource-group "${RESOURCE_GROUP}" --location "${KEYVAULT_LOCATION}"

# Create the Keyvault and set a secret value
az keyvault create --resource-group "${RESOURCE_GROUP}" --location "${KEYVAULT_LOCATION}" --name "${KEYVAULT_NAME}"
az keyvault secret set --vault-name "${KEYVAULT_NAME}" --name "${KEYVAULT_SECRET_NAME}" --value "Hello world"

# Create an environment variable for the key vault URL:
export KEYVAULT_URL="$(az keyvault show --resource-group ${RESOURCE_GROUP} --name ${KEYVAULT_NAME} --query properties.vaultUri --output tsv)"

# Create an environment variable for the key vault Resource ID:
export KEYVAULT_RESOURCE_ID=$(az keyvault show --resource-group "${RESOURCE_GROUP}" --name "${KEYVAULT_NAME}" | jq -r '.id')

Creare un'identità gestita e concedere l'autorizzazione per accedere ad Azure Key Vault

Nei passaggi successivi creare un'identità gestita assegnata dall'utente e l'assegnazione di ruolo corrispondente:

# Create the identity
az identity create --name "${USER_ASSIGNED_IDENTITY_NAME}" --resource-group "${RESOURCE_GROUP}"

# Assign Key Vault Secrets User to the identity
export USER_ASSIGNED_IDENTITY_OBJECT_ID="$(az identity show --name "${USER_ASSIGNED_IDENTITY_NAME}" --resource-group "${RESOURCE_GROUP}" --query 'principalId' -o tsv)"
export USER_ASSIGNED_IDENTITY_CLIENT_ID="$(az identity show --name "${USER_ASSIGNED_IDENTITY_NAME}" --resource-group "${RESOURCE_GROUP}" --query 'clientId' -o tsv)"

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

Creare un account del servizio Kubernetes

  • In OpenShift Container Platform, creare il Service Account con azure.workload.identity/client-id impostato su USER_ASSIGNED_IDENTITY_CLIENT_ID creato in precedenza.
  • Per altre informazioni sulla creazione di account di servizio, vedere Creazione di account del servizio.

Creare il nuovo progetto per questa app di esempio:

oc new-project ${SERVICE_ACCOUNT_NAMESPACE}

Creare l'account del servizio:

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

Creare le credenziali dell'identità federata

Creare una credenziale di identità federata di Azure che collega l'account di servizio in OpenShift Container Platform all'identità gestita dall'utente di Azure.

az identity federated-credential create \
--name "${FEDERATED_IDENTITY_CREDENTIAL_NAME}" \
--identity-name "${USER_ASSIGNED_IDENTITY_NAME}" \
--resource-group "${RESOURCE_GROUP}" \
--issuer "${ARO_OIDC_ISSUER}" \
--subject "system:serviceaccount:${SERVICE_ACCOUNT_NAMESPACE}:${SERVICE_ACCOUNT_NAME}"

Distribuire l'applicazione

L'account del servizio OpenShift Container Platform è ora configurato come previsto. Si noti che .spec.serviceAccountName è impostato e viene usata l'etichetta azure.workload.identity/use: "true" :

cat <<EOF | oc 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}
  securityContext:
    runAsNonRoot: true
    seccompProfile:
      type: RuntimeDefault
  containers:
    - image: ghcr.io/azure/azure-workload-identity/msal-go
      name: oidc
      securityContext:
        allowPrivilegeEscalation: false
        capabilities:
          drop: [ "ALL" ]
      env:
        - name: KEYVAULT_URL
          value: ${KEYVAULT_URL}
        - name: SECRET_NAME
          value: ${KEYVAULT_SECRET_NAME}
EOF

Verificare il carico di lavoro distribuito

Nel carico di lavoro appena distribuito verificare che le variabili di ambiente e il volume proiettato siano entrambi presenti. Eseguire il comando seguente:

oc describe pod quick-start

Vedere l'output di esempio seguente:

[..]
 Environment:
   KEYVAULT_URL:                https://azwi-kv-45ff.vault.azure.net/
   SECRET_NAME:                 my-secret
   AZURE_CLIENT_ID:             00001111-aaaa-2222-bbbb-3333cccc4444
   AZURE_TENANT_ID:             aaaabbbb-0000-cccc-1111-dddd2222eeee
   AZURE_FEDERATED_TOKEN_FILE:  /var/run/secrets/azure/tokens/azure-identity-token
   AZURE_AUTHORITY_HOST:        https://login.microsoftonline.com/
[..]
Volumes:
[..]
 azure-identity-token:
   Type:                    Projected (a volume that contains injected data from multiple sources)
   TokenExpirationSeconds:  3600

Verificare nei log che il carico di lavoro sia stato in grado di accedere al Key Vault di Microsoft Azure utilizzando le chiavi iniettate:

$ oc logs quick-start
I0816 09:43:37.961113       1 main.go:63] "successfully got secret" secret="Hello world"

Passaggi successivi

  • Last updated on