Creare un Azure Red Hat OpenShift con cluster di architettura standard con identità gestite

Questo articolo illustra come distribuire un Azure Red Hat OpenShift con un cluster di architettura standard usando identità gestite. Non è possibile eseguire la migrazione di un cluster esistente che usa un service principal in modo che usi un'identità gestita. È necessario creare un nuovo cluster che usa un'identità gestita in un Azure Red Hat OpenShift con cluster di architettura standard.

Azure Red Hat OpenShift con architettura standard è un servizio OpenShift gestito che supporta identità gestite e identità del carico di lavoro. Le identità gestite e le identità del carico di lavoro consentono di ridurre al minimo i rischi quando si proteggono i carichi di lavoro e le applicazioni fornendo token di breve durata anziché credenziali di lunga durata, ad esempio un'entità servizio con credenziali segrete client.

Per altre informazioni, vedere:

Prerequisiti

Se non si usa il portale di Azure, assicurarsi di usare interfaccia della riga di comando di Azure versione 2.90.0 o successiva, che contiene gli argomenti dell'interfaccia della riga di comando completamente supportati per i cluster di identità gestiti. Usare az --version per trovare la versione dell'interfaccia della riga di comando di Azure installata. Se è necessario eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure.

Azure Red Hat OpenShift richiede almeno 44 core per creare un cluster OpenShift. La quota di risorse di Azure predefinita per una nuova sottoscrizione di Azure non soddisfa questo requisito. Per richiedere un aumento del limite di risorse, vedere Aumentare quote vCPU della famiglia di VM.

I 44 core vengono usati come segue:

Macchina bootstrap: 8 core
Piano di controllo (macchine master): 24 core
Calcolo (computer di lavoro): 12 core

Al termine dell'installazione, il computer bootstrap viene rimosso e il cluster usa un totale di 36 core. Per altre informazioni, vedere Installazione in Azure.

Esegui il comando seguente per verificare la quota della tua sottoscrizione Azure per la dimensione Standard DSv5 della macchina virtuale, che è la dimensione predefinita per la macchina virtuale nella CLI o nel portale:

LOCATION=eastus
az vm list-usage -l $LOCATION \
--query "[?contains(name.value, 'standardDSv5Family')]" -o table

Verificare le autorizzazioni

In questo articolo viene creato un gruppo di risorse che contiene la rete virtuale e le identità gestite per il cluster. Per creare un gruppo di risorse, sono necessarie le autorizzazioni Collaboratore e Amministratore accesso utenti o Proprietario per il gruppo di risorse o la sottoscrizione che lo contiene.

Sono necessarie anche autorizzazioni sufficienti di Microsoft Entra (un utente membro del tenant o un ospite assegnato con il ruolo di Amministratore delle applicazioni) per creare un set di identità gestite e assegnare ruoli da utilizzare per il cluster. Per altre informazioni, vedere Membri e guest e Assegnare ruoli di amministratore e non amministratore agli utenti con ID Microsoft Entra.

Registrare i provider di risorse

Per usare alcuni provider di risorse Azure, incluso il provider di risorse Azure Red Hat OpenShift, è necessario registrarli. Quando si registra un provider di risorse, si crea un'entità servizio nella sottoscrizione che autorizza il provider di risorse a eseguire determinate azioni, ad esempio la creazione di risorse. Per istruzioni sulla registrazione dei provider di risorse tramite il portale di Azure o per altre informazioni sulla registrazione del provider di risorse, vedere Registrare il provider di risorse.

Se sono presenti più sottoscrizioni di Azure, specificare l'ID sottoscrizione pertinente:
```
az account set --subscription <SUBSCRIPTION ID>
```
Registrare il provider di risorse Microsoft.RedHatOpenShift:
```
az provider register -n Microsoft.RedHatOpenShift --wait
```
Registrare il provider di risorse Microsoft.Compute:
```
az provider register -n Microsoft.Compute --wait
```
Registrare il provider di risorse Microsoft.Storage:
```
az provider register -n Microsoft.Storage --wait
```
Registrare il provider di risorse Microsoft.Authorization:
```
az provider register -n Microsoft.Authorization --wait
```

Ottieni un pull secret di Red Hat (facoltativo)

Il pull secret di Azure Red Hat OpenShift non cambia il costo della sottoscrizione a Red Hat OpenShift.

Un segreto pull di Red Hat consente al cluster di accedere ai registri contenitori Red Hat, insieme ad altri contenuti, ad esempio gli operatori di OperatorHub. Questo passaggio è facoltativo ma consigliato. Se decidi di aggiungere il secret di pull in un secondo momento, segui questa guida. Il campo cloud.openshift.com viene rimosso dal tuo segreto anche se il tuo segreto di pull contiene tale campo. Questo campo abilita una funzionalità di monitoraggio aggiuntiva, che invia i dati a Red Hat ed è quindi disabilitata per impostazione predefinita. Per abilitare questa funzionalità, vedere Abilitazione dei report sull'integrità remota.

Passare al portale di Gestione cluster Red Hat OpenShift ed eseguire l'accesso.

È necessario accedere all'account Red Hat o creare un nuovo account Red Hat con il messaggio di posta elettronica aziendale e accettare i termini e le condizioni.
Selezionare Download pull secret per salvare una copia da utilizzare con il cluster Azure Red Hat OpenShift.

Conservare il file pull-secret.txt salvato in una posizione sicura. Il file viene usato in ogni creazione del cluster se è necessario creare un cluster che includa esempi o operatori per Red Hat o partner certificati.

Quando si esegue il comando az aro create, è possibile fare riferimento al segreto di pull usando il parametro --pull-secret @pull-secret.txt. Eseguire az aro create dalla directory in cui è stato archiviato il pull-secret.txt file. In caso contrario, sostituire @pull-secret.txt con @/path/to/my/pull-secret.txt.

Se si copia il segreto pull o vi si fa riferimento in altri script, il segreto pull deve essere formattato come stringa JSON valida.

Preparare un dominio personalizzato per il cluster (facoltativo)

Quando si esegue il comando az aro create, è possibile specificare un dominio personalizzato per il cluster con il parametro --domain foo.example.com.

Annotazioni

L'aggiunta di un nome di dominio è facoltativa quando si crea un cluster tramite l'interfaccia della riga di comando di Azure. Quando si aggiunge un cluster tramite il portale, è necessario un nome di dominio (o un prefisso usato come parte del nome DNS generato automaticamente per la console OpenShift e i server API). Per altre informazioni, vedere Avvio rapido: Distribuire un cluster Azure Red Hat OpenShift usando il portale di Azure.

Se si specifica un dominio personalizzato per il cluster, tenere presente quanto segue:

Dopo aver creato il cluster, è necessario creare due record DNS A nel server DNS per l'oggetto --domain specificato:
- api : puntando all'indirizzo IP del server API
- *.apps, che punta all'indirizzo IP di ingresso
- Recuperare questi valori eseguendo il comando seguente dopo la creazione del cluster: az aro show $CLUSTER -g $RESOURCEGROUP --query '{api:apiserverProfile.ip, ingress:ingressProfiles[0].ip}'.
La console OpenShift è disponibile in un URL, https://console-openshift-console.apps.example.comad esempio , anziché nel dominio https://console-openshift-console.apps.<random>.<location>.aroapp.iopredefinito .
Per impostazione predefinita, OpenShift usa certificati autofirmati per tutte le route create in domini personalizzati *.apps.example.com. Se si sceglie di usare DNS personalizzato dopo la connessione al cluster, è necessario seguire la documentazione di OpenShift per configurare una CA personalizzata per il controller di ingresso e una CA personalizzata per il server API.

Eseguire l'installazione usando il interfaccia della riga di comando di Azure

Questa sezione descrive come usare il interfaccia della riga di comando di Azure per creare un cluster Azure Red Hat OpenShift usando le identità gestite. Sono disponibili tre opzioni per creare il cluster usando l'interfaccia della riga di comando:

Completamente automatizzato: l'interfaccia della riga di comando gestisce la creazione delle identità gestite assegnate dall'utente, delle assegnazioni di ruolo e della creazione del cluster in un unico comando. È comunque necessario creare in modo preliminare le risorse di rete.
Parzialmente automatizzato: la creazione del cluster è costituita da due parti:
- Creazione di identità e assegnazione di ruolo: l'interfaccia della riga di comando crea le identità e le assegnazioni di ruolo necessarie.
- Creazione del cluster: eseguire il comando di creazione del cluster specificando i nomi di identità gestita (o GLI ID risorsa) appena creati.
Manuale: creare le identità gestite e le assegnazioni di ruolo assegnate dall'utente necessarie e quindi specificarli nel comando di creazione del cluster.
- È anche possibile fare in modo che l'interfaccia della riga di comando restituisca i comandi da eseguire per creare le identità e le assegnazioni di ruolo necessarie.

Creare una rete virtuale contenente due subnet vuote

Creare una rete virtuale contenente due subnet vuote. Se si dispone di una rete virtuale esistente che soddisfa le proprie esigenze, ignorare questo passaggio.

Per informazioni sulle funzionalità di rete e sui requisiti, vedere Rete per Azure Red Hat OpenShift.

Impostare le variabili seguenti nell'ambiente della shell in cui si eseguono i az comandi.

LOCATION=eastus                 # the location of your cluster
RESOURCEGROUP=aro-rg            # the name of the resource group where you want to create your cluster
CLUSTER=cluster                 # the name of your cluster

Creare un gruppo di risorse.

Un gruppo di risorse di Azure è un gruppo logico in cui le risorse di Azure vengono distribuite e gestite. Quando si crea un gruppo di risorse, viene chiesto di specificare una posizione. Questa posizione è la posizione in cui vengono archiviati i metadati del gruppo di risorse e dove vengono eseguite le risorse in Azure se non si specifica un'altra area durante la creazione delle risorse. Creare un gruppo di risorse con il comando az group create.

Annotazioni

Azure Red Hat OpenShift non è disponibile in tutte le aree in cui è possibile creare un gruppo di risorse di Azure. Per informazioni su dove è supportato Azure Red Hat OpenShift, vedere Available regions (Aree disponibili).
```
az group create \
  --location $LOCATION \
  --name $RESOURCEGROUP
```

Creare una rete virtuale, una subnet master e di lavoro nello stesso gruppo di risorse creato in precedenza.

I cluster Azure Red Hat OpenShift richiedono una rete virtuale con due subnet vuote per i nodi master e di lavoro. È possibile creare una nuova rete virtuale o usare una rete virtuale esistente.

az network vnet create \
   --resource-group $RESOURCEGROUP \
   --name aro-vnet \
   --address-prefixes 10.0.0.0/22

az network vnet subnet create \
   --resource-group $RESOURCEGROUP \
   --vnet-name aro-vnet \
   --name master \
   --address-prefixes 10.0.0.0/23

az network vnet subnet create \
   --resource-group $RESOURCEGROUP \
   --vnet-name aro-vnet \
   --name worker \
   --address-prefixes 10.0.2.0/23

Metodi di creazione

Completamente automatizzato

Per creare un cluster usando il metodo completamente automatizzato, eseguire il comando seguente che aggiunge il --enable-managed-identity parametro . Questo comando crea anche le identità gestite e le assegnazioni di ruolo assegnate dall'utente necessarie. Per aggiungere un segreto pull o usare un dominio personalizzato, vedere Creare il cluster.

az aro create \
    --resource-group $RESOURCEGROUP \
    --name $CLUSTER \
    --vnet aro-vnet \
    --master-subnet master \
    --worker-subnet worker \
    --version <VERSION> \
    --enable-managed-identity

Inizia la creazione del cluster. Per usare una versione specifica di OpenShift, vedere Selezionare una versione Azure Red Hat OpenShift diversa. Quando il cluster è pronto, vedere Pulire per informazioni su come eliminarlo.

Automazione parziale

Per creare solo le identità gestite e le assegnazioni di ruolo assegnate dall'utente necessarie, eseguire il comando seguente:

az aro identity create-required \
    --resource-group $RESOURCEGROUP \
    --location $LOCATION \
    --vnet aro-vnet \
    --master-subnet master \
    --worker-subnet worker \
    --version <VERSION>

Al termine del comando, vengono visualizzati i dettagli di ogni identità gestita creata.

Esempio:

[
  {
    "clientId": "22222222-2222-2222-2222-222222222222",
    "id": "/subscriptions/<SUBSCRIPTION>/resourcegroups/<RESOURCEGROUP>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/aro-cluster",
    "isolationScope": "None",
    "location": "westus3",
    "name": "aro-cluster",
    "principalId": "33333333-3333-3333-3333-333333333333",
    "resourceGroup": "<RESOURCEGROUP>",
    "tags": {},
    "tenantId": "11111111-1111-1111-1111-111111111111",
    "type": "Microsoft.ManagedIdentity/userAssignedIdentities"
  },
[...]

Continuare a usare i nomi di identità o gli ID risorsa restituiti dal comando precedente nel comando Creare il cluster .

Manual

Creare in modo indipendente le identità gestite e le assegnazioni di ruolo assegnate dall'utente necessarie e quindi Creare il cluster.

Crea le identità gestite assegnate dall'utente richieste. Azure Red Hat OpenShift richiede nove identità gestite, ognuna delle quali richiede un ruolo predefinito assegnato:
- Sette identità gestite correlate agli operatori OpenShift principali.
- Un'identità gestita per l'operatore del servizio Azure Red Hat OpenShift.
- Un'altra identità per il cluster per consentire l'uso di queste identità.
I componenti dell'identità gestita sono:
- Operatore del registro di immagini di OpenShift (image-registry)
- Operatore di rete OpenShift (cloud-network-config)
- Operatore di archiviazione su disco OpenShift (disk-csi-driver)
- Operatore di archiviazione file OpenShift (file-csi-driver)
- Operatore di ingresso del cluster OpenShift (ingresso)
- OpenShift Cloud Controller Manager (cloud-controller-manager)
- Operatore API delle macchine di OpenShift (machine-api)
- Operatore del servizio Azure Red Hat OpenShift (operatore aro)
Esistono otto diverse identità gestite e i ruoli predefiniti corrispondenti che rappresentano le autorizzazioni necessarie per ogni componente di Azure Red Hat OpenShift per svolgere le proprie mansioni. Inoltre, la piattaforma richiede un'altra identità, l'identità del cluster, per eseguire la creazione di credenziali federate per i componenti di identità gestiti elencati in precedenza (aro-cluster).

Per ulteriori informazioni sugli operatori del cluster Red Hat OpenShift, vedere il Riferimento agli operatori del cluster.

Per altre informazioni sulle identità gestite in Azure Red Hat OpenShift, vedere Informazioni sulle identità gestite in Azure Red Hat OpenShift.

Annotazioni

È anche possibile ottenere i comandi di creazione dell'identità e assegnazione di ruolo dall'interfaccia della riga di comando usando az aro identity get-required.

Creare le identità necessarie:
```
az identity create \
--resource-group $RESOURCEGROUP \
--name aro-cluster
```
```
az identity create \
--resource-group $RESOURCEGROUP \
--name cloud-controller-manager
```
```
az identity create \
--resource-group $RESOURCEGROUP \
--name ingress
```
```
az identity create \
--resource-group $RESOURCEGROUP \
--name machine-api
```
```
az identity create \
--resource-group $RESOURCEGROUP \
--name disk-csi-driver
```
```
az identity create \
--resource-group $RESOURCEGROUP \
--name cloud-network-config
```
```
az identity create \
--resource-group $RESOURCEGROUP \
--name image-registry
```
```
az identity create \
--resource-group $RESOURCEGROUP \
--name file-csi-driver
```
```
az identity create \
--resource-group $RESOURCEGROUP \
--name aro-operator
```

Creare le assegnazioni di ruolo necessarie per ogni identità dell'operatore, l'identità del cluster e il servizio principale di prima parte.

Annotazioni

Questo articolo presuppone che siano presenti solo subnet master e worker. Se sono state configurate più subnet del cluster in fase di installazione, è necessario concedere l'ambito di assegnazione di ruolo a tali subnet per gli operatori che lo richiedono.

Le assegnazioni di ruolo seguenti per le subnet master e worker presuppongono che non siano collegati un gruppo di sicurezza di rete (NSG), una tabella di route o un gateway NAT (Network Address Translation). Se si esegue l'installazione di una di queste risorse di rete, è necessario creare più assegnazioni di ruolo che concedono autorizzazioni per le identità degli operatori per tali risorse di rete aggiuntive. Per ogni operatore che richiede un'assegnazione di ruolo per le subnet seguenti o per la rete virtuale, è necessaria anche un'assegnazione di ruolo per la risorsa di rete aggiuntiva.

SUBSCRIPTION_ID=$(az account show --query 'id' -o tsv)

# assign cluster identity permissions over the identities

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name aro-cluster --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/ef318e2a-8334-4a05-9e4a-295a196c6a6e" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/aro-operator"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name aro-cluster --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/ef318e2a-8334-4a05-9e4a-295a196c6a6e" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/cloud-controller-manager"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name aro-cluster --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/ef318e2a-8334-4a05-9e4a-295a196c6a6e" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/ingress"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name aro-cluster --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/ef318e2a-8334-4a05-9e4a-295a196c6a6e" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/machine-api"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name aro-cluster --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/ef318e2a-8334-4a05-9e4a-295a196c6a6e" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/disk-csi-driver"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name aro-cluster --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/ef318e2a-8334-4a05-9e4a-295a196c6a6e" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/cloud-network-config"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name aro-cluster --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/ef318e2a-8334-4a05-9e4a-295a196c6a6e" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/image-registry"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name aro-cluster --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/ef318e2a-8334-4a05-9e4a-295a196c6a6e" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/file-csi-driver"

# assign vnet-level permissions for operators that require it, and subnets-level permission for operators that require it

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name cloud-controller-manager --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/a1f96423-95ce-4224-ab27-4e3dc72facd4" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCEGROUP/providers/Microsoft.Network/virtualNetworks/aro-vnet/subnets/master"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name cloud-controller-manager --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/a1f96423-95ce-4224-ab27-4e3dc72facd4" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCEGROUP/providers/Microsoft.Network/virtualNetworks/aro-vnet/subnets/worker"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name ingress --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/0336e1d3-7a87-462b-b6db-342b63f7802c" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCEGROUP/providers/Microsoft.Network/virtualNetworks/aro-vnet/subnets/master"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name ingress --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/0336e1d3-7a87-462b-b6db-342b63f7802c" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCEGROUP/providers/Microsoft.Network/virtualNetworks/aro-vnet/subnets/worker"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name machine-api --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/0358943c-7e01-48ba-8889-02cc51d78637" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCEGROUP/providers/Microsoft.Network/virtualNetworks/aro-vnet/subnets/master"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name machine-api --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/0358943c-7e01-48ba-8889-02cc51d78637" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCEGROUP/providers/Microsoft.Network/virtualNetworks/aro-vnet/subnets/worker"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name cloud-network-config --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/be7a6435-15ae-4171-8f30-4a343eff9e8f" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCEGROUP/providers/Microsoft.Network/virtualNetworks/aro-vnet"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name file-csi-driver --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/0d7aedc0-15fd-4a67-a412-efad370c947e" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCEGROUP/providers/Microsoft.Network/virtualNetworks/aro-vnet"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name image-registry --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/8b32b316-c2f5-4ddf-b05b-83dacd2d08b5" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCEGROUP/providers/Microsoft.Network/virtualNetworks/aro-vnet"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name aro-operator --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/4436bae4-7702-4c84-919b-c4069ff25ee2" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCEGROUP/providers/Microsoft.Network/virtualNetworks/aro-vnet/subnets/master"

az role assignment create \
    --assignee-object-id "$(az identity show --resource-group $RESOURCEGROUP --name aro-operator --query principalId -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/4436bae4-7702-4c84-919b-c4069ff25ee2" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCEGROUP/providers/Microsoft.Network/virtualNetworks/aro-vnet/subnets/worker"

az role assignment create \
    --assignee-object-id "$(az ad sp list --display-name "Azure Red Hat OpenShift RP" --query '[0].id' -o tsv)" \
    --assignee-principal-type ServicePrincipal \
    --role "/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.Authorization/roleDefinitions/42f3c60f-e7b1-46d7-ba56-6de681664342" \
    --scope "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCEGROUP/providers/Microsoft.Network/virtualNetworks/aro-vnet"

Creare il cluster

Per creare un cluster, eseguire il comando seguente illustrato nelle opzioni. Se si sceglie di usare una delle opzioni seguenti, modificare il comando di conseguenza:

Opzione 1: Fornisci il pull secret di Red Hat, che consente al cluster di accedere ai registry dei container Red Hat oltre ad altri contenuti. Aggiungere l'argomento --pull-secret @pull-secret.txt al comando.
Opzione 2: usare un dominio personalizzato. Aggiungi l'argomento --domain foo.example.com al comando, sostituendo foo.example.com con il tuo dominio personalizzato.

Creare il cluster con le variabili di ambiente necessarie. Per ogni --assign-platform-workload-identity flag, il primo argomento rappresenta la chiave, che indica al provider di risorse Azure Red Hat OpenShift quale operatore OpenShift usare per una determinata identità. Il secondo argomento rappresenta il riferimento all'identità stessa.

az aro create \
    --resource-group $RESOURCEGROUP \
    --name $CLUSTER \
    --vnet aro-vnet \
    --master-subnet master \
    --worker-subnet worker \
    --version <VERSION> \
    --enable-managed-identity \
    --assign-cluster-identity aro-cluster \
    --assign-platform-workload-identity file-csi-driver file-csi-driver \
    --assign-platform-workload-identity cloud-controller-manager cloud-controller-manager \
    --assign-platform-workload-identity ingress ingress \
    --assign-platform-workload-identity image-registry image-registry \
    --assign-platform-workload-identity machine-api machine-api \
    --assign-platform-workload-identity cloud-network-config cloud-network-config \
    --assign-platform-workload-identity aro-operator aro-operator \
    --assign-platform-workload-identity disk-csi-driver disk-csi-driver

Se le risorse di identità si trovano in una diversa area o in un diverso gruppo di risorse, è possibile utilizzare gli ID completi delle risorse per la creazione. Vedere l'esempio seguente:

az aro create \
    --resource-group $RESOURCEGROUP \
    --name $CLUSTER \
    --vnet aro-vnet \
    --master-subnet master \
    --worker-subnet worker \
    --version <VERSION> \
    --enable-managed-identity \
    --assign-cluster-identity /subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/aro-cluster \
    --assign-platform-workload-identity file-csi-driver /subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/file-csi-driver \
    --assign-platform-workload-identity cloud-controller-manager /subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/cloud-controller-manager \
    --assign-platform-workload-identity ingress /subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/ingress \
    --assign-platform-workload-identity image-registry /subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/image-registry \
    --assign-platform-workload-identity machine-api /subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/machine-api \
    --assign-platform-workload-identity cloud-network-config /subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/cloud-network-config \
    --assign-platform-workload-identity aro-operator /subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/aro-operator \
    --assign-platform-workload-identity disk-csi-driver /subscriptions/$SUBSCRIPTION_ID/resourcegroups/$RESOURCEGROUP/providers/Microsoft.ManagedIdentity/userAssignedIdentities/disk-csi-driver

Selezionare una versione diversa di Azure Red Hat OpenShift

È possibile scegliere di usare una versione specifica di Azure Red Hat OpenShift durante la creazione del cluster. Usare prima di tutto l'interfaccia della riga di comando per eseguire una query per le versioni di Azure Red Hat OpenShift disponibili:

az aro get-versions --location <REGION>

Dopo aver scelto la versione, specificarla usando il --version parametro nel az aro create comando .

Eseguire l'installazione con Bicep

Questa sezione descrive come usare Bicep per creare un cluster Azure Red Hat OpenShift con identità gestite.

Salvare il file Bicep di esempio in un file. Per questo esempio, salvarlo come azuredeploy.bicep.

Imposta le seguenti variabili nell'ambiente della shell in cui prevedi di eseguire i comandi az.

LOCATION=eastus                     # the location of your cluster
RESOURCEGROUP=aro-rg                # the name of the resource group where you want to create your cluster
CLUSTER=cluster                     # the name of your cluster
VERSION=4.21.22                     # the version of the cluster
PULL_SECRET=$(cat pull-secret.txt)  # the Red Hat pull secret JSON, provided as file or string

Creare un gruppo di risorse per contenere la risorsa del cluster, la rete virtuale del cluster e le identità.
```
az group create --name $RESOURCEGROUP --location $LOCATION
```
Per il provider di risorse, controllare l'ID oggetto dell'entità del servizio di prima parte per la sottoscrizione.
```
ARO_RP_SP_OBJECT_ID=$(az ad sp list --display-name "Azure Red Hat OpenShift RP" --query '[0].id' -o tsv)
```

Distribuire il file Bicep:

az deployment group create \
  --name aroDeployment \
  --resource-group $RESOURCEGROUP \
  --template-file azuredeploy.bicep \
  --parameters location=$LOCATION \
  --parameters version=$VERSION \
  --parameters clusterName=$CLUSTER \
  --parameters rpObjectId=$ARO_RP_SP_OBJECT_ID

Se si usano i parametri facoltativi per il pull secret o il dominio personalizzato, aggiungere una barra rovesciata di continuazione di riga (\) dopo il parametro rpObjectId e includere i seguenti parametri nel comando di distribuzione:

--parameters domain=$DOMAIN \ #optional
--parameters pullSecret=$PULL_SECRET # optional

File Bicep di esempio

Annotazioni

@description('Location')
param location string = resourceGroup().location

@description('Domain Prefix')
param domain string

@description('Version of the OpenShift cluster')
param version string

@description('Pull secret from cloud.redhat.com. The json should be input as a string')
@secure()
param pullSecret string = ''

@description('Name of vNet')
param clusterVnetName string = 'aro-vnet'

@description('vNet Address Space')
param clusterVnetCidr string = '10.100.0.0/15'

@description('Worker node subnet address space')
param workerSubnetCidr string = '10.100.70.0/23'

@description('Master node subnet address space')
param masterSubnetCidr string = '10.100.76.0/24'

@description('Master Node VM Type')
param masterVmSize string = 'Standard_D8s_v3'

@description('Worker Node VM Type')
param workerVmSize string = 'Standard_D4s_v3'

@description('Worker Node Disk Size in GB')
@minValue(128)
param workerVmDiskSize int = 128

@description('Cidr for Pods')
param podCidr string = '10.128.0.0/14'

@metadata({
 description: 'Cidr of service'
})
param serviceCidr string = '172.30.0.0/16'

@description('Unique name for the cluster')
param clusterName string

@description('Api Server Visibility')
@allowed([
 'Private'
 'Public'
])
param apiServerVisibility string = 'Public'

@description('Ingress Visibility')
@allowed([
 'Private'
 'Public'
])
param ingressVisibility string = 'Public'

@description('The ObjectID of the Resource Provider Service Principal')
param rpObjectId string

@description('Specify if FIPS validated crypto modules are used')
@allowed([
 'Enabled'
 'Disabled'
])
param fips string = 'Disabled'

@description('Specify if master VMs are encrypted at host')
@allowed([
 'Enabled'
 'Disabled'
])
param masterEncryptionAtHost string = 'Disabled'

@description('Specify if worker VMs are encrypted at host')
@allowed([
 'Enabled'
 'Disabled'
])
param workerEncryptionAtHost string = 'Disabled'

var resourceGroupId = '/subscriptions/${subscription().subscriptionId}/resourceGroups/aro-${domain}-${location}'
var masterSubnetId=resourceId('Microsoft.Network/virtualNetworks/subnets', clusterVnetName, 'master')
var workerSubnetId=resourceId('Microsoft.Network/virtualNetworks/subnets', clusterVnetName, 'worker')

resource vnet 'Microsoft.Network/virtualNetworks@2023-06-01' = {
 name: clusterVnetName
 location: location
 properties: {
   addressSpace: { addressPrefixes: [ clusterVnetCidr ] }
   subnets: [
     {
       name: 'master'
       properties: {
         addressPrefixes: [ masterSubnetCidr ]
         serviceEndpoints: [ { service: 'Microsoft.ContainerRegistry' } ]
       }
     }
     {
       name: 'worker'
       properties: {
         addressPrefixes: [ workerSubnetCidr ]
         serviceEndpoints: [ { service: 'Microsoft.ContainerRegistry' } ]
       }
     }
   ]
 }
}

resource workerSubnet 'Microsoft.Network/virtualNetworks/subnets@2020-08-01' existing = {
 parent: vnet
 name: 'worker'
}

resource masterSubnet 'Microsoft.Network/virtualNetworks/subnets@2020-08-01' existing = {
 parent: vnet
 name: 'master'
}

// create required identities

resource cloudControllerManager 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
   name: 'cloud-controller-manager'
   location: location
}

resource ingress 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
   name: 'ingress'
   location: location
}

resource machineApi 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
   name: 'machine-api'
   location: location
}

resource diskCsiDriver 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
   name: 'disk-csi-driver'
   location: location
}

resource cloudNetworkConfig 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
   name: 'cloud-network-config'
   location: location
}

resource imageRegistry 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
   name: 'image-registry'
   location: location
}

resource fileCsiDriver 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
   name: 'file-csi-driver'
   location: location
}

resource aroOperator 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
   name: 'aro-operator'
   location: location
}

resource clusterMsi 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
   name: 'cluster'
   location: location
}

// create required role assignments on vnet / subnets

resource cloudControllerManagerMasterSubnetRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(masterSubnet.id, 'cloud-controller-manager')
   scope: masterSubnet
   properties: {
       principalId: cloudControllerManager.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'a1f96423-95ce-4224-ab27-4e3dc72facd4')
       principalType: 'ServicePrincipal'
   }
}

resource cloudControllerManagerWorkerSubnetRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
 name: guid(workerSubnet.id, 'cloud-controller-manager')
 scope: workerSubnet
 properties: {
     principalId: cloudControllerManager.properties.principalId
     roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'a1f96423-95ce-4224-ab27-4e3dc72facd4')
     principalType: 'ServicePrincipal'
 }
}

resource ingressMasterSubnetRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(masterSubnet.id, 'ingress')
   scope: masterSubnet
   properties: {
       principalId: ingress.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '0336e1d3-7a87-462b-b6db-342b63f7802c')
       principalType: 'ServicePrincipal'
   }
}

resource ingressWorkerSubnetRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
 name: guid(workerSubnet.id, 'ingress')
 scope: workerSubnet
 properties: {
     principalId: ingress.properties.principalId
     roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '0336e1d3-7a87-462b-b6db-342b63f7802c')
     principalType: 'ServicePrincipal'
 }
}

resource machineApiMasterSubnetRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(masterSubnet.id, 'machine-api')
   scope: masterSubnet
   properties: {
       principalId: machineApi.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '0358943c-7e01-48ba-8889-02cc51d78637')
       principalType: 'ServicePrincipal'
   }
}

resource machineApiWorkerSubnetRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(workerSubnet.id, 'machine-api')
   scope: workerSubnet
   properties: {
       principalId: machineApi.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '0358943c-7e01-48ba-8889-02cc51d78637')
       principalType: 'ServicePrincipal'
   }
}

resource cloudNetworkConfigVnetRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(vnet.id, 'cloud-network-config')
   scope: vnet
   properties: {
       principalId: cloudNetworkConfig.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'be7a6435-15ae-4171-8f30-4a343eff9e8f')
       principalType: 'ServicePrincipal'
   }
}

resource fileCsiDriverVnetRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(vnet.id, 'file-csi-driver')
   scope: vnet
   properties: {
       principalId: fileCsiDriver.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '0d7aedc0-15fd-4a67-a412-efad370c947e')
       principalType: 'ServicePrincipal'
   }
}

resource imageRegistryVnetRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(vnet.id, 'image-registry')
   scope: vnet
   properties: {
       principalId: imageRegistry.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '8b32b316-c2f5-4ddf-b05b-83dacd2d08b5')
       principalType: 'ServicePrincipal'
   }
}

resource aroOperatorMasterSubnetRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(masterSubnet.id, 'aro-operator')
   scope: masterSubnet
   properties: {
       principalId: aroOperator.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '4436bae4-7702-4c84-919b-c4069ff25ee2')
       principalType: 'ServicePrincipal'
   }
}

resource aroOperatorWorkerSubnetRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
 name: guid(workerSubnet.id, 'aro-operator')
 scope: workerSubnet
 properties: {
     principalId: aroOperator.properties.principalId
     roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '4436bae4-7702-4c84-919b-c4069ff25ee2')
     principalType: 'ServicePrincipal'
 }
}

// create required role assignments on cluster MSI

resource clusterMsiRoleAssignmentCloudControllerManager 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(cloudControllerManager.id, 'cluster')
   scope: cloudControllerManager
   properties: {
       principalId: clusterMsi.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')
       principalType: 'ServicePrincipal'
   }
}

resource clusterMsiRoleAssignmentIngress 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(ingress.id, 'cluster')
   scope: ingress
   properties: {
       principalId: clusterMsi.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')
       principalType: 'ServicePrincipal'
   }
}

resource clusterMsiRoleAssignmentMachineApi 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(machineApi.id, 'cluster')
   scope: machineApi
   properties: {
       principalId: clusterMsi.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')
       principalType: 'ServicePrincipal'
   }
}

resource clusterMsiRoleAssignmentDiskCsiDriver 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(diskCsiDriver.id, 'cluster')
   scope: diskCsiDriver
   properties: {
       principalId: clusterMsi.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')
       principalType: 'ServicePrincipal'
   }
}

resource clusterMsiRoleAssignmentCloudNetworkConfig 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(cloudNetworkConfig.id, 'cluster')
   scope: cloudNetworkConfig
   properties: {
       principalId: clusterMsi.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')
       principalType: 'ServicePrincipal'
   }
}

resource clusterMsiRoleAssignmentCloudImageRegistry 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(imageRegistry.id, 'cluster')
   scope: imageRegistry
   properties: {
       principalId: clusterMsi.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')
       principalType: 'ServicePrincipal'
   }
}

resource clusterMsiRoleAssignmentCloudFileCsiDriver 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(fileCsiDriver.id, 'cluster')
   scope: fileCsiDriver
   properties: {
       principalId: clusterMsi.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')
       principalType: 'ServicePrincipal'
   }
}

resource clusterMsiRoleAssignmentCloudAroOperator 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(aroOperator.id, 'cluster')
   scope: aroOperator
   properties: {
       principalId: clusterMsi.properties.principalId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')
       principalType: 'ServicePrincipal'
   }
}

// create first party role assignment over the vnet

resource fpspRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
   name: guid(vnet.id, rpObjectId)
   scope: vnet
   properties: {
       principalId: rpObjectId
       roleDefinitionId: subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '42f3c60f-e7b1-46d7-ba56-6de681664342')
       principalType: 'ServicePrincipal'
   }
}

// create cluster

resource cluster 'Microsoft.RedHatOpenShift/openShiftClusters@2025-07-25' = {
   name: clusterName
   location: location
   properties: {
       clusterProfile: {
           domain: domain
           #disable-next-line use-resource-id-functions
           resourceGroupId: resourceGroupId
           version: version
           fipsValidatedModules: fips
           pullSecret: pullSecret
       }
       networkProfile: {podCidr: podCidr, serviceCidr: serviceCidr}
       masterProfile: {
           vmSize: masterVmSize
           subnetId: masterSubnetId
           encryptionAtHost: masterEncryptionAtHost
       }
       workerProfiles: [{
           name: 'worker'
           count: 3
           diskSizeGB: workerVmDiskSize
           vmSize: workerVmSize
           subnetId: workerSubnetId
           encryptionAtHost: workerEncryptionAtHost
       }]
       apiserverProfile: {visibility: apiServerVisibility}
       ingressProfiles: [{name: 'default', visibility: ingressVisibility}]
       platformWorkloadIdentityProfile: {
           platformWorkloadIdentities: {
               'cloud-controller-manager': {resourceId: cloudControllerManager.id}
               ingress: {resourceId: ingress.id}
               'machine-api': {resourceId: machineApi.id}
               'disk-csi-driver': {resourceId: diskCsiDriver.id}
               'cloud-network-config': {resourceId: cloudNetworkConfig.id}
               'image-registry': {resourceId: imageRegistry.id}
               'file-csi-driver': {resourceId: fileCsiDriver.id}
               'aro-operator': {resourceId: aroOperator.id}
           }
       }
   }
   identity: {
       type: 'UserAssigned'
       userAssignedIdentities: {
           '${clusterMsi.id}': {}
       }
   }
}

Installare usando un modello ARM

Questa sezione descrive come usare un ARM template per creare un cluster di Azure Red Hat OpenShift con identità gestite.

Salva il modello ARM di esempio in un file. Per questo esempio, denominare il file azuredeploy.json.

Imposta le seguenti variabili nell'ambiente della shell in cui prevedi di eseguire i comandi az.

LOCATION=eastus                     # the location of your cluster
RESOURCEGROUP=aro-rg                # the name of the resource group where you want to create your cluster
CLUSTER=cluster                     # the name of your cluster
VERSION=4.21.22                     # the version of the cluster
PULL_SECRET=$(cat pull-secret.txt)  # the Red Hat pull secret JSON, provided as file or string

Creare un gruppo di risorse per contenere la risorsa del cluster, la rete virtuale del cluster e le identità.
```
az group create --name $RESOURCEGROUP --location $LOCATION
```
Per il provider di risorse, controllare l'ID oggetto dell'entità del servizio di prima parte per la sottoscrizione.
```
ARO_RP_SP_OBJECT_ID=$(az ad sp list --display-name "Azure Red Hat OpenShift RP" --query '[0].id' -o tsv)
```

Distribuire il template ARM:

az deployment group create \
  --name aroDeployment \
  --resource-group $RESOURCEGROUP \
  --template-file azuredeploy.json \
  --parameters location=$LOCATION \
  --parameters version=$VERSION \
  --parameters clusterName=$CLUSTER \
  --parameters rpObjectId=$ARO_RP_SP_OBJECT_ID

--parameters domain=$DOMAIN \ #optional
--parameters pullSecret=$PULL_SECRET # optional

Modello di ARM di esempio

Annotazioni

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "metadata": {
    "_generator": {
      "name": "bicep",
      "version": "0.38.33.27573",
      "templateHash": "9848565761041118745"
    }
  },
  "parameters": {
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]",
      "metadata": {
        "description": "Location"
      }
    },
    "domain": {
      "type": "string",
      "metadata": {
        "description": "Domain Prefix"
      }
    },
    "version": {
      "type": "string",
      "metadata": {
        "description": "Version of the OpenShift cluster"
      }
    },
    "pullSecret": {
      "type": "securestring",
      "defaultValue": "",
      "metadata": {
        "description": "Pull secret from cloud.redhat.com. The json should be input as a string"
      }
    },
    "clusterVnetName": {
      "type": "string",
      "defaultValue": "aro-vnet",
      "metadata": {
        "description": "Name of vNet"
      }
    },
    "clusterVnetCidr": {
      "type": "string",
      "defaultValue": "10.100.0.0/15",
      "metadata": {
        "description": "vNet Address Space"
      }
    },
    "workerSubnetCidr": {
      "type": "string",
      "defaultValue": "10.100.70.0/23",
      "metadata": {
        "description": "Worker node subnet address space"
      }
    },
    "masterSubnetCidr": {
      "type": "string",
      "defaultValue": "10.100.76.0/24",
      "metadata": {
        "description": "Master node subnet address space"
      }
    },
    "masterVmSize": {
      "type": "string",
      "defaultValue": "Standard_D8s_v3",
      "metadata": {
        "description": "Master Node VM Type"
      }
    },
    "workerVmSize": {
      "type": "string",
      "defaultValue": "Standard_D4s_v3",
      "metadata": {
        "description": "Worker Node VM Type"
      }
    },
    "workerVmDiskSize": {
      "type": "int",
      "defaultValue": 128,
      "minValue": 128,
      "metadata": {
        "description": "Worker Node Disk Size in GB"
      }
    },
    "podCidr": {
      "type": "string",
      "defaultValue": "10.128.0.0/14",
      "metadata": {
        "description": "Cidr for Pods"
      }
    },
    "serviceCidr": {
      "type": "string",
      "defaultValue": "172.30.0.0/16",
      "metadata": {
        "description": "Cidr of service"
      }
    },
    "clusterName": {
      "type": "string",
      "metadata": {
        "description": "Unique name for the cluster"
      }
    },
    "apiServerVisibility": {
      "type": "string",
      "defaultValue": "Public",
      "allowedValues": [
        "Private",
        "Public"
      ],
      "metadata": {
        "description": "Api Server Visibility"
      }
    },
    "ingressVisibility": {
      "type": "string",
      "defaultValue": "Public",
      "allowedValues": [
        "Private",
        "Public"
      ],
      "metadata": {
        "description": "Ingress Visibility"
      }
    },
    "rpObjectId": {
      "type": "string",
      "metadata": {
        "description": "The ObjectID of the Resource Provider Service Principal"
      }
    },
    "fips": {
      "type": "string",
      "defaultValue": "Disabled",
      "allowedValues": [
        "Enabled",
        "Disabled"
      ],
      "metadata": {
        "description": "Specify if FIPS validated crypto modules are used"
      }
    },
    "masterEncryptionAtHost": {
      "type": "string",
      "defaultValue": "Disabled",
      "allowedValues": [
        "Enabled",
        "Disabled"
      ],
      "metadata": {
        "description": "Specify if master VMs are encrypted at host"
      }
    },
    "workerEncryptionAtHost": {
      "type": "string",
      "defaultValue": "Disabled",
      "allowedValues": [
        "Enabled",
        "Disabled"
      ],
      "metadata": {
        "description": "Specify if worker VMs are encrypted at host"
      }
    }
  },
  "variables": {
    "resourceGroupId": "[format('/subscriptions/{0}/resourceGroups/aro-{1}-{2}', subscription().subscriptionId, parameters('domain'), parameters('location'))]",
    "masterSubnetId": "[resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('clusterVnetName'), 'master')]",
    "workerSubnetId": "[resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('clusterVnetName'), 'worker')]"
  },
  "resources": [
    {
      "type": "Microsoft.Network/virtualNetworks",
      "apiVersion": "2023-06-01",
      "name": "[parameters('clusterVnetName')]",
      "location": "[parameters('location')]",
      "properties": {
        "addressSpace": {
          "addressPrefixes": [
            "[parameters('clusterVnetCidr')]"
          ]
        },
        "subnets": [
          {
            "name": "master",
            "properties": {
              "addressPrefixes": [
                "[parameters('masterSubnetCidr')]"
              ],
              "serviceEndpoints": [
                {
                  "service": "Microsoft.ContainerRegistry"
                }
              ]
            }
          },
          {
            "name": "worker",
            "properties": {
              "addressPrefixes": [
                "[parameters('workerSubnetCidr')]"
              ],
              "serviceEndpoints": [
                {
                  "service": "Microsoft.ContainerRegistry"
                }
              ]
            }
          }
        ]
      }
    },
    {
      "type": "Microsoft.ManagedIdentity/userAssignedIdentities",
      "apiVersion": "2023-01-31",
      "name": "cloud-controller-manager",
      "location": "[parameters('location')]"
    },
    {
      "type": "Microsoft.ManagedIdentity/userAssignedIdentities",
      "apiVersion": "2023-01-31",
      "name": "ingress",
      "location": "[parameters('location')]"
    },
    {
      "type": "Microsoft.ManagedIdentity/userAssignedIdentities",
      "apiVersion": "2023-01-31",
      "name": "machine-api",
      "location": "[parameters('location')]"
    },
    {
      "type": "Microsoft.ManagedIdentity/userAssignedIdentities",
      "apiVersion": "2023-01-31",
      "name": "disk-csi-driver",
      "location": "[parameters('location')]"
    },
    {
      "type": "Microsoft.ManagedIdentity/userAssignedIdentities",
      "apiVersion": "2023-01-31",
      "name": "cloud-network-config",
      "location": "[parameters('location')]"
    },
    {
      "type": "Microsoft.ManagedIdentity/userAssignedIdentities",
      "apiVersion": "2023-01-31",
      "name": "image-registry",
      "location": "[parameters('location')]"
    },
    {
      "type": "Microsoft.ManagedIdentity/userAssignedIdentities",
      "apiVersion": "2023-01-31",
      "name": "file-csi-driver",
      "location": "[parameters('location')]"
    },
    {
      "type": "Microsoft.ManagedIdentity/userAssignedIdentities",
      "apiVersion": "2023-01-31",
      "name": "aro-operator",
      "location": "[parameters('location')]"
    },
    {
      "type": "Microsoft.ManagedIdentity/userAssignedIdentities",
      "apiVersion": "2023-01-31",
      "name": "cluster",
      "location": "[parameters('location')]"
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.Network/virtualNetworks/{0}/subnets/{1}', parameters('clusterVnetName'), 'master')]",
      "name": "[guid(resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('clusterVnetName'), 'master'), 'cloud-controller-manager')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cloud-controller-manager'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'a1f96423-95ce-4224-ab27-4e3dc72facd4')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cloud-controller-manager')]",
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.Network/virtualNetworks/{0}/subnets/{1}', parameters('clusterVnetName'), 'worker')]",
      "name": "[guid(resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('clusterVnetName'), 'worker'), 'cloud-controller-manager')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cloud-controller-manager'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'a1f96423-95ce-4224-ab27-4e3dc72facd4')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cloud-controller-manager')]",
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.Network/virtualNetworks/{0}/subnets/{1}', parameters('clusterVnetName'), 'master')]",
      "name": "[guid(resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('clusterVnetName'), 'master'), 'ingress')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'ingress'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '0336e1d3-7a87-462b-b6db-342b63f7802c')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'ingress')]",
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.Network/virtualNetworks/{0}/subnets/{1}', parameters('clusterVnetName'), 'worker')]",
      "name": "[guid(resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('clusterVnetName'), 'worker'), 'ingress')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'ingress'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '0336e1d3-7a87-462b-b6db-342b63f7802c')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'ingress')]",
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.Network/virtualNetworks/{0}/subnets/{1}', parameters('clusterVnetName'), 'master')]",
      "name": "[guid(resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('clusterVnetName'), 'master'), 'machine-api')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'machine-api'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '0358943c-7e01-48ba-8889-02cc51d78637')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'machine-api')]",
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.Network/virtualNetworks/{0}/subnets/{1}', parameters('clusterVnetName'), 'worker')]",
      "name": "[guid(resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('clusterVnetName'), 'worker'), 'machine-api')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'machine-api'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '0358943c-7e01-48ba-8889-02cc51d78637')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'machine-api')]",
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.Network/virtualNetworks/{0}', parameters('clusterVnetName'))]",
      "name": "[guid(resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName')), 'cloud-network-config')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cloud-network-config'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'be7a6435-15ae-4171-8f30-4a343eff9e8f')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cloud-network-config')]",
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.Network/virtualNetworks/{0}', parameters('clusterVnetName'))]",
      "name": "[guid(resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName')), 'file-csi-driver')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'file-csi-driver'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '0d7aedc0-15fd-4a67-a412-efad370c947e')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'file-csi-driver')]",
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.Network/virtualNetworks/{0}', parameters('clusterVnetName'))]",
      "name": "[guid(resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName')), 'image-registry')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'image-registry'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '8b32b316-c2f5-4ddf-b05b-83dacd2d08b5')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'image-registry')]",
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.Network/virtualNetworks/{0}/subnets/{1}', parameters('clusterVnetName'), 'master')]",
      "name": "[guid(resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('clusterVnetName'), 'master'), 'aro-operator')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'aro-operator'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '4436bae4-7702-4c84-919b-c4069ff25ee2')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'aro-operator')]",
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.Network/virtualNetworks/{0}/subnets/{1}', parameters('clusterVnetName'), 'worker')]",
      "name": "[guid(resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('clusterVnetName'), 'worker'), 'aro-operator')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'aro-operator'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '4436bae4-7702-4c84-919b-c4069ff25ee2')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'aro-operator')]",
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.ManagedIdentity/userAssignedIdentities/{0}', 'cloud-controller-manager')]",
      "name": "[guid(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cloud-controller-manager'), 'cluster')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cloud-controller-manager')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster')]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.ManagedIdentity/userAssignedIdentities/{0}', 'ingress')]",
      "name": "[guid(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'ingress'), 'cluster')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'ingress')]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.ManagedIdentity/userAssignedIdentities/{0}', 'machine-api')]",
      "name": "[guid(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'machine-api'), 'cluster')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'machine-api')]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.ManagedIdentity/userAssignedIdentities/{0}', 'disk-csi-driver')]",
      "name": "[guid(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'disk-csi-driver'), 'cluster')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'disk-csi-driver')]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.ManagedIdentity/userAssignedIdentities/{0}', 'cloud-network-config')]",
      "name": "[guid(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cloud-network-config'), 'cluster')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cloud-network-config')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster')]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.ManagedIdentity/userAssignedIdentities/{0}', 'image-registry')]",
      "name": "[guid(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'image-registry'), 'cluster')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'image-registry')]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.ManagedIdentity/userAssignedIdentities/{0}', 'file-csi-driver')]",
      "name": "[guid(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'file-csi-driver'), 'cluster')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'file-csi-driver')]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.ManagedIdentity/userAssignedIdentities/{0}', 'aro-operator')]",
      "name": "[guid(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'aro-operator'), 'cluster')]",
      "properties": {
        "principalId": "[reference(resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster'), '2023-01-31').principalId]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', 'ef318e2a-8334-4a05-9e4a-295a196c6a6e')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'aro-operator')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster')]"
      ]
    },
    {
      "type": "Microsoft.Authorization/roleAssignments",
      "apiVersion": "2022-04-01",
      "scope": "[format('Microsoft.Network/virtualNetworks/{0}', parameters('clusterVnetName'))]",
      "name": "[guid(resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName')), parameters('rpObjectId'))]",
      "properties": {
        "principalId": "[parameters('rpObjectId')]",
        "roleDefinitionId": "[subscriptionResourceId('Microsoft.Authorization/roleDefinitions', '42f3c60f-e7b1-46d7-ba56-6de681664342')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
      ]
    },
    {
      "type": "Microsoft.RedHatOpenShift/openShiftClusters",
      "apiVersion": "2025-07-25",
      "name": "[parameters('clusterName')]",
      "location": "[parameters('location')]",
      "properties": {
        "clusterProfile": {
          "domain": "[parameters('domain')]",
          "resourceGroupId": "[variables('resourceGroupId')]",
          "version": "[parameters('version')]",
          "fipsValidatedModules": "[parameters('fips')]",
          "pullSecret": "[parameters('pullSecret')]"
        },
        "networkProfile": {
          "podCidr": "[parameters('podCidr')]",
          "serviceCidr": "[parameters('serviceCidr')]"
        },
        "masterProfile": {
          "vmSize": "[parameters('masterVmSize')]",
          "subnetId": "[variables('masterSubnetId')]",
          "encryptionAtHost": "[parameters('masterEncryptionAtHost')]"
        },
        "workerProfiles": [
          {
            "name": "worker",
            "count": 3,
            "diskSizeGB": "[parameters('workerVmDiskSize')]",
            "vmSize": "[parameters('workerVmSize')]",
            "subnetId": "[variables('workerSubnetId')]",
            "encryptionAtHost": "[parameters('workerEncryptionAtHost')]"
          }
        ],
        "apiserverProfile": {
          "visibility": "[parameters('apiServerVisibility')]"
        },
        "ingressProfiles": [
          {
            "name": "default",
            "visibility": "[parameters('ingressVisibility')]"
          }
        ],
        "platformWorkloadIdentityProfile": {
          "platformWorkloadIdentities": {
            "cloud-controller-manager": {
              "resourceId": "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cloud-controller-manager')]"
            },
            "ingress": {
              "resourceId": "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'ingress')]"
            },
            "machine-api": {
              "resourceId": "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'machine-api')]"
            },
            "disk-csi-driver": {
              "resourceId": "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'disk-csi-driver')]"
            },
            "cloud-network-config": {
              "resourceId": "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cloud-network-config')]"
            },
            "image-registry": {
              "resourceId": "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'image-registry')]"
            },
            "file-csi-driver": {
              "resourceId": "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'file-csi-driver')]"
            },
            "aro-operator": {
              "resourceId": "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'aro-operator')]"
            }
          }
        }
      },
      "identity": {
        "type": "UserAssigned",
        "userAssignedIdentities": {
          "[format('{0}', resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster'))]": {}
        }
      },
      "dependsOn": [
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'aro-operator')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cloud-controller-manager')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cloud-network-config')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'cluster')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'disk-csi-driver')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'file-csi-driver')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'image-registry')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'ingress')]",
        "[resourceId('Microsoft.ManagedIdentity/userAssignedIdentities', 'machine-api')]"
      ]
    }
  ]
}

Creare un cluster di Azure Red Hat OpenShift

Accedi al portale di Azure.
Nel menu del portale di Azure o nella pagina Home selezionare Tutti i servizi in tre barre orizzontali nella pagina in alto a sinistra.
Cercare e selezionare cluster di Azure Red Hat OpenShift.
Fare clic su Crea.
Nella scheda Informazioni di base configurare le opzioni seguenti:
- Dettagli del progetto:
  - Selezionare una sottoscrizione di Azure.
  - Selezionare o creare un gruppo di risorse di Azure, ad esempio test-aro-rg.
- Dettagli dell'istanza:
  - Selezionare un’Area geografica per il cluster di Azure Red Hat OpenShift.
  - Immettere un nome di cluster OpenShift, ad esempio testcluster.
  - Immettere un nome di dominio, ad esempio testdomain.
  - Selezionare una versione del cluster OpenShift
  - Selezionare Dimensioni VM Master e Dimensioni VM Worker.
  - Selezionare Conteggio dei nodi di lavoro (il numero di nodi di lavoro da creare).
Annotazioni

Il campo Nome dominio è prepopolato con una stringa casuale. È possibile specificare un nome di dominio come example.com o una stringa/prefisso come abc che viene usato come parte del nome DNS generato automaticamente per la console OpenShift e i server API. Questo prefisso viene usato anche come parte del nome del gruppo di risorse creato per ospitare le macchine virtuali del cluster se non viene specificato un nome di gruppo di risorse.
Nella scheda Autenticazione completare le sezioni seguenti.

È possibile selezionare il meccanismo di autenticazione per il cluster utilizzando identità gestite oppure un principale di servizio. Il valore predefinito è l'identità gestita.

In Identità gestita selezionare Crea automaticamente identità e ruoli oppure Usa identità e assegnazioni di ruolo esistenti

Se si seleziona Crea identità e ruoli automaticamente, l'utente connesso deve avere le autorizzazioni per creare identità gestite assegnate dall'utente e assegnazioni di ruolo. Le identità gestite assegnate dall'utente necessarie e le assegnazioni di ruolo appropriate usando i ruoli predefiniti corrispondenti verranno eseguite per conto dell'utente.

Se si seleziona Usa identità e assegnazioni di ruolo esistenti, è necessario disporre delle identità gestite assegnate dall'utente corrette e delle assegnazioni di ruolo corrispondenti già create. Se si seleziona questa opzione, verrà espansa una sezione seguente, che consente di selezionare l'identità gestita assegnata dall'utente per ogni componente.

Annotazioni

Vedere Informazioni sull'architettura di assegnazione dei ruoli di identità per informazioni dettagliate sulle identità gestite assegnate dall'utente e sulle assegnazioni di ruolo che devono essere create.

Fare clic su Seleziona per ogni componente e il pannello di selezione dell'identità verrà aperto a destra per selezionare l'identità gestita corrispondente.
Nella scheda Rete configurare le impostazioni necessarie.

Annotazioni

I cluster di Azure Red Hat OpenShift che eseguono OpenShift 4 richiedono una rete virtuale con due subnet vuoti: uno per il piano di controllo e uno per i nodi di lavoro.

Annotazioni

Se si usano identità gestite esistenti, è necessario avere una rete virtuale e subnet esistenti. Non sarà possibile creare una nuova rete virtuale come parte del flusso di creazione del cluster.
Nella scheda Tag aggiungere tag per organizzare le risorse.
Selezionare Rivedi e crea e quindi Crea al termine della convalida. Prendere nota del meccanismo di autenticazione selezionato e se si è scelto il flusso di identità automatizzato o esistente.
La creazione del cluster Azure Red Hat OpenShift richiede circa 45 minuti. Al termine del deployment, accedi alla tua risorsa in uno dei seguenti modi:
- Selezionare Vai alla risorsa.
- Passare al gruppo di risorse del cluster Azure Red Hat OpenShift e selezionare la risorsa Azure Red Hat OpenShift.

Pulizia

Per eliminare un cluster di identità gestita, eseguire il comando seguente:

az aro delete -n $CLUSTER -g $RESOURCEGROUP

Il comando delete non rimuove le identità gestite assegnate dal cluster, che sono state create come parte dell'installazione. È necessario eliminare manualmente le identità e le assegnazioni di ruolo.

Per altre informazioni, vedere Informazioni sulle identità gestite in Azure Red Hat OpenShift.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-09-04

Creare un Azure Red Hat OpenShift con cluster di architettura standard con identità gestite

Prerequisiti

Verificare le autorizzazioni

Registrare i provider di risorse

Ottieni un pull secret di Red Hat (facoltativo)

Preparare un dominio personalizzato per il cluster (facoltativo)

Eseguire l'installazione usando il interfaccia della riga di comando di Azure

Creare una rete virtuale contenente due subnet vuote

Metodi di creazione

Completamente automatizzato

Automazione parziale

Manual

Creare il cluster

Selezionare una versione diversa di Azure Red Hat OpenShift

Eseguire l'installazione con Bicep

File Bicep di esempio

Installare usando un modello ARM

Modello di ARM di esempio

Creare un cluster di Azure Red Hat OpenShift

Pulizia

Contenuti correlati

Commenti e suggerimenti

Risorse aggiuntive