Configurare un provider di autenticazione esterno (anteprima)

Configurare Azure Red Hat OpenShift con piani di controllo ospitati per usare un provider di identità OIDC (OpenID Connect) esterno per l'autenticazione anziché il server OAuth OpenShift predefinito. Anche se il server OAuth predefinito supporta diversi provider di identità, offre funzionalità limitate. Integrando direttamente i provider di identità OIDC esterni con Azure Red Hat OpenShift con i piani di controllo ospitati, è possibile abilitare flussi di lavoro da computer a computer, ad esempio l'accesso all'interfaccia della riga di comando e ottenere funzionalità non disponibili con il server OAuth predefinito.

Questo articolo descrive come configurare Microsoft Entra ID come provider di autenticazione esterno per fornire l'accesso sia all'interfaccia della riga di comando che alla console OpenShift.

Prerequisiti

interfaccia della riga di comando di Azure versione 2.67.0 o successiva. Usare az --version per trovare la versione installata. Se è necessario installare o aggiornare, vedere Installare interfaccia della riga di comando di Azure.
Assicurarsi di aver installato le credenziali di amministratore temporanee.
Autorizzazione per registrare le applicazioni nel tenant Microsoft Entra ID. Per impostazione predefinita, tutti gli utenti possono registrare le applicazioni. Se questa impostazione è stata modificata in "No", è necessario il ruolo Sviluppatore applicazione o Amministratore applicazioni .

L'estensione CLI di ARO HCP è installata. Se è necessario installarlo, eseguire az extension add --name aro.

Preparare le variabili di ambiente

Assicurarsi che siano definite le variabili di ambiente seguenti:

CUSTOMER_RG_NAME="<resource-group-name>"
CLUSTER_NAME="<cluster-name>"
EXTERNAL_AUTH_DISPLAY_NAME="${CLUSTER_NAME}-auth"
EXTERNAL_AUTH_NAME="entra"
TENANT_ID=$(az account show --query tenantId --output tsv)
ISSUER_URL="https://login.microsoftonline.com/${TENANT_ID}/v2.0"

SUBSCRIPTION_ID=$(az account show --query id --output tsv)
CUSTOMER_RG_NAME="<resource-group-name>"
CLUSTER_NAME="<cluster-name>"
EXTERNAL_AUTH_DISPLAY_NAME="${CLUSTER_NAME}-auth"
EXTERNAL_AUTH_NAME="entra"
TENANT_ID=$(az account show --query tenantId --output tsv)
ISSUER_URL="https://login.microsoftonline.com/${TENANT_ID}/v2.0"

Configurare Microsoft Entra ID

Recupera l'URL di callback di OpenShift Authentication.

CONSOLE_URL=$(az aro hcp cluster show \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --name "${CLUSTER_NAME}" \
  --query properties.console.url --output tsv)
CONSOLE_CALLBACK_URL="${CONSOLE_URL}/auth/callback"

Registrare una nuova applicazione in Microsoft Entra ID. Per accedere al server API tramite le CLI oc o kubectl, aggiungi un secondo URI di reindirizzamento.

L'esempio seguente crea un'applicazione Microsoft Entra ID con due URI di reindirizzamento: l'URL di callback di OpenShift Authentication richiesto e un secondo reindirizzamento per l'accesso all'interfaccia della riga di comando:
```
CLIENT_ID=$(az ad app create \
  --display-name "${EXTERNAL_AUTH_DISPLAY_NAME}" \
  --web-redirect-uris ${CONSOLE_CALLBACK_URL} http://localhost:8000 \
  --query appId --output tsv)
```
Creare un segreto client per l'applicazione. Un messaggio della console informa che l'output del comando contiene credenziali. Usa il segreto del client più avanti nell'articolo.

Note

Dopo aver completato tutti i passaggi di questo articolo, cancellare la variabile. Consulta Ripulire le variabili sensibili.
```
CLIENT_SECRET=$(az ad app credential reset --id ${CLIENT_ID} --query password --output tsv)
```

Creare un provider di autenticazione esterno

Le seguenti mappature delle attestazioni mostrano a OpenShift come leggere le attestazioni preferred_username e groups che hai configurato in Microsoft Entra ID per l'emissione.

Creare il provider di autenticazione esterno per Azure Red Hat OpenShift con piani di controllo ospitati.

az aro hcp cluster external-auth create \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --cluster-name "${CLUSTER_NAME}" \
  --name "${EXTERNAL_AUTH_NAME}" \
  --issuer-url "${ISSUER_URL}" \
  --issuer-audience "[${CLIENT_ID}]" \
  --claim groups \
  --username-claim preferred_username \
  --username-prefix-policy NoPrefix \
  --client client-id="${CLIENT_ID}" component-name=console auth-client-namespace=openshift-console extra-scopes="[profile]" type=Confidential \
  --client client-id="${CLIENT_ID}" component-name=cli auth-client-namespace=openshift-console extra-scopes="[profile]" type=Public

Verificare la configurazione del provider di autenticazione esterno.

az aro hcp cluster external-auth show \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --cluster-name "${CLUSTER_NAME}" \
  --name "${EXTERNAL_AUTH_NAME}"

Configurare il provider di autenticazione esterno per Azure Red Hat OpenShift con piani di controllo ospitati. Per configurare un provider di autenticazione esterno, definire una externalAuths risorsa. L'esempio seguente mostra una risorsa externalAuths in un file Bicep. Per altre informazioni sulle proprietà del provider di autenticazione esterno, vedere Proprietà di configurazione dell'autenticazione esterna.

Salvare l'esempio seguente come externalauth.bicep:

@description('The name of the external auth provider configuration')
param externalAuthName string

@description('The issuer url')
param issuerURL string

@description('The client ID')
param clientID string

@description('Name of the hypershift cluster')
param clusterName string

resource hcp 'Microsoft.RedHatOpenShift/hcpOpenShiftClusters@2026-09-01-preview' existing = {
  name: clusterName
}

resource externalauth 'Microsoft.RedHatOpenShift/hcpOpenShiftClusters/externalAuths@2026-09-01-preview' = {
  parent: hcp
  name: externalAuthName
  properties: {
    claim: {
      mappings: {
        username: {
          claim: 'preferred_username'
          prefixPolicy: 'NoPrefix'
        }
        groups: {
          claim: 'groups'
        }
      }
    }
    clients: [
      {
        clientId: clientID
        component: {
          name: 'console'
          authClientNamespace: 'openshift-console'
        }
        extraScopes: [
          'profile'
        ]
        type: 'Confidential'
      }
      {
        clientId: clientID
        component: {
          name: 'cli'
          authClientNamespace: 'openshift-console'
        }
        extraScopes: [
          'profile'
        ]
        type: 'Public'
      }
    ]
    issuer: {
      url: issuerURL
      audiences: [
        clientID
      ]
    }
  }
}

Applica il file Bicep.

az deployment group create \
--name 'aro-hcp-auth' \
--subscription "${SUBSCRIPTION_ID}" \
--resource-group "${CUSTOMER_RG_NAME}" \
--template-file externalauth.bicep \
--parameters \
   externalAuthName="${EXTERNAL_AUTH_NAME}" \
   issuerURL="${ISSUER_URL}" \
   clientID="${CLIENT_ID}" \
   clusterName="${CLUSTER_NAME}"

Verificare la configurazione del provider di autenticazione esterno.

az aro hcp cluster external-auth show \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --cluster-name "${CLUSTER_NAME}" \
  --name "${EXTERNAL_AUTH_NAME}"

Configurare l'autenticazione e l'autorizzazione in OpenShift

Dopo aver creato il provider di autenticazione esterno, accedere al Azure Red Hat OpenShift con il cluster dei piani di controllo ospitati per configurare l'accesso per il client riservato (la console OpenShift) e configurare il controllo degli accessi in base al ruolo.

Se non si dispone di credenziali amministrative temporanee per il Azure Red Hat OpenShift con cluster di piani di controllo ospitati, generarne uno. Per altre informazioni, vedere Connettersi a un cluster Azure Red Hat OpenShift con piani di controllo ospitati.

Creare il segreto del client in OpenShift.

oc create secret generic ${EXTERNAL_AUTH_NAME}-console-openshift-console \
--namespace openshift-config \
--from-literal=clientSecret=${CLIENT_SECRET}

(Facoltativo) Se necessario, assegnare utenti e gruppi al tuo cluster Azure Red Hat OpenShift con piani di controllo ospitati.

Per impostazione predefinita, tutti gli utenti nel tenant Microsoft Entra possono accedere alle applicazioni registrate dopo l'autenticazione. Microsoft Entra ID consente agli amministratori tenant e agli sviluppatori di limitare un'app a un set specifico di utenti o gruppi di sicurezza nel tenant.

Per limitare un'app Microsoft Entra a un set specifico di utenti, vedere Limitare un'app Microsoft Entra a un set di utenti.
Configurare RBAC per concedere all'utente o al gruppo l'accesso al ruolo cluster-admin.

Per impostazione predefinita, OpenShift non concede autorizzazioni per eseguire alcuna azione all'interno del cluster quando un utente accede per la prima volta. Azure Red Hat OpenShift con piani di controllo ospitati include un numero significativo di ruoli preconfigurati, incluso il ruolo di amministratore del cluster che concede l'accesso completo e il controllo sul cluster. Il cluster non crea automaticamente gli oggetti RoleBinding e ClusterRoleBinding per gli utenti autenticati; sei tu responsabile della creazione manuale di tali associazioni.

In questo esempio viene illustrato come creare un oggetto ClusterRoleBinding che concede il ruolo di amministratore del cluster a un utente o gruppo Microsoft Entra ID specifico. È anche possibile creare un binding di ruolo per un gruppo di sicurezza seguendo le istruzioni in Uso di RBAC.
- Accesso utente
- Accesso al gruppo
1. Recuperare il nome dell'entità utente (UPN) di Microsoft Entra ID per l'utente a cui si vuole concedere l'accesso.
```
USER_NAME=$(az ad user show --id "<user-email>" --query userPrincipalName -o tsv)
```
2. Creare un ClusterRoleBinding oggetto che concede all'utente il ruolo di amministratore del cluster.
```
oc apply -f - <<EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: aro-admin
roleRef:
   apiGroup: rbac.authorization.k8s.io
   kind: ClusterRole
   name: cluster-admin
subjects:
 - apiGroup: rbac.authorization.k8s.io
   kind: User
   name: $USER_NAME
EOF
```
1. Configurare la registrazione dell'applicazione per includere i claim del gruppo di sicurezza.
```
az ad app update \
--id ${CLIENT_ID} \
--set groupMembershipClaims=SecurityGroup
```
2. Recuperare l'ID del gruppo di Microsoft Entra ID per il gruppo di sicurezza a cui si vuole concedere l'accesso.
```
# List your groups. 
az ad user get-member-groups --id $(az ad signed-in-user show --query id -o tsv) -o tsv

# Set an environment variable for the group you want to grant access to.
GROUP_ID="<group-id>"
```
3. Creare un ClusterRoleBinding oggetto che concede al gruppo il ruolo cluster-admin.
```
oc apply -f - <<EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: aro-admin
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: Group
  apiGroup: rbac.authorization.k8s.io
  name: $GROUP_ID
EOF
```

Convalidare la configurazione di autenticazione esterna

Dopo aver configurato l'autenticazione esterna per il cluster, è possibile convalidare la configurazione per l'interfaccia della riga di comando di OpenShift e la console Web.

Verificare l'accesso tramite la console Web OpenShift

Recupera l'URL per la console web di OpenShift.

az aro hcp cluster show \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --name "${CLUSTER_NAME}" \
  --query properties.console.url --output tsv

Aprire l'URL nel Web browser e accedere.

Verificare l'accesso tramite l'interfaccia della riga di comando di OpenShift

È possibile usare Microsoft Entra ID per accedere allo strumento da riga di comando OpenShift. Questo metodo di autenticazione funziona perché il plug-in delle credenziali client-go kubelogin è ora integrato direttamente nello strumento.

Recuperare l'URL dell'API.

API_URL=$(az aro hcp cluster show \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --name "${CLUSTER_NAME}" \
  --query properties.api.url --output tsv)

Accedere al cluster eseguendo il comando seguente:
```
oc login $API_URL \
  --exec-plugin=oc-oidc \
  --client-id=$CLIENT_ID \
  --client-secret=$CLIENT_SECRET \
  --issuer-url=$ISSUER_URL \ 
  --extra-scopes=profile \
  --callback-port=8000
```
Il comando visualizza un URL. Usare l'URL per completare il processo di autenticazione nel browser. Al termine, la CLI di OpenShift è autenticata.

Verificare che le credenziali siano impostate correttamente:

oc auth whoami

Output di esempio:

ATTRIBUTE    VALUE
Username     user@email.com
Groups       [<group-id> system:authenticated]

Pulire le variabili sensibili

Dopo aver verificato che l'autenticazione esterna funzioni, cancellare le variabili sensibili dalla sessione della shell.

CLIENT_SECRET=""

Commenti e suggerimenti

Questa pagina è stata utile?

Ultimo aggiornamento: 2026-10-08