Creare un cluster Azure Red Hat OpenShift con identità gestite (anteprima)

Importante

Attualmente, questa funzionalità di Azure Red Hat OpenShift è disponibile solo in anteprima. Le funzionalità di anteprima sono disponibili in auto-servizio, su base adesione volontaria. Le anteprime vengono fornite così com'è e come sono disponibili e vengono escluse dai contratti di servizio e dalla garanzia limitata. Le anteprime di Azure Red Hat OpenShift sono parzialmente coperte dall'assistenza clienti con la massima diligenza possibile. Di conseguenza, queste funzionalità non sono destinate all'uso in produzione.

Questo articolo illustra come distribuire un cluster Azure Red Hat OpenShift usando identità gestite. Un cluster esistente che utilizza un principal del servizio non può essere migrato per usare un'identità gestita. È necessario creare un nuovo cluster che usa un'identità gestita in un cluster Azure Red Hat OpenShift.

Azure Red Hat OpenShift è 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

Assicurarsi di usare l'interfaccia della riga di comando di Azure versione 2.67.0 o successiva. 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.

Ad esempio, per controllare la quota di sottoscrizione corrente dello SKU della famiglia di macchine virtuali più piccola supportata "Standard DSv5":

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

Scarica il wheel file dell'estensione Red Hat OpenShift di Azure (solo anteprima)

Per eseguire i comandi in questo articolo, scaricare prima di tutto il file wheel dell'estensione Azure Red Hat OpenShift da https://aka.ms/az-aroext-latest. Per installare l'estensione , eseguire il comando seguente:

az extension add -s <path to downloaded whl file>

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

Alcuni provider di risorse di Azure, incluso il provider di risorse Azure Red Hat OpenShift, richiedono la registrazione per funzionare. La registrazione di un provider di risorse crea un'entità servizio all'interno della sottoscrizione che autorizza il provider di risorse a eseguire determinate azioni, ad esempio la creazione di risorse. 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
```

Ottenere un segreto pull di Red Hat (facoltativo)

Un pull secret di Azure Red Hat OpenShift non modifica il costo della licenza 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 si decide di aggiungere il segreto pull in un secondo momento, seguire questa guida. Il campo cloud.openshift.com viene rimosso dal segreto anche se il segreto pull contiene tale campo. Questo campo abilita una funzionalità di monitoraggio aggiuntiva, che invia i dati a RedHat ed è quindi disabilitata per impostazione predefinita. Per abilitare questa funzionalità, vedere Abilitazione dei report sull'integrità remota.

Passare al portale di gestione cluster di Red Hat OpenShift ed effettuare 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 Scarica segreto pull e quindi scaricare un segreto pull da usare 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 file pull-secret.txt. 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
- *.app, che punta all'indirizzo IP del traffico in ingresso
- Recuperare questi valori eseguendo il comando seguente dopo la creazione del cluster: az aro show -n -g --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.

Installazione

È possibile usare l'interfaccia della riga di comando di Azure, Bicep o un modello di Azure Resource Manager per distribuire un cluster Azure Red Hat OpenShift che usa identità gestite.

Eseguire l'installazione con l'interfaccia della riga di comando di Azure

Questa sezione descrive come usare l'interfaccia della riga di comando di Azure per creare un cluster Azure Red Hat OpenShift usando identità gestite.

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

Creare le identità gestite assegnate agli utenti richieste

Creare le seguenti identità richieste. Azure Red Hat OpenShift richiede nove identità gestite, ognuna delle quali deve avere 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.

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 identities previously created

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/4d97b98b-1d4f-4787-a291-c67834d212e7" \
    --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: è possibile passare il segreto pull di Red Hat, che consente al cluster di accedere ai registri contenitori Red Hat insieme ad altri contenuti. Aggiungere l'argomento --pull-secret @pull-secret.txt al comando.
Opzione 2: è possibile usare un dominio personalizzato. Aggiungere l'argomento --domain foo.example.com al comando, sostituendo foo.example.com con il 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.15.35                     # 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', '4d97b98b-1d4f-4787-a291-c67834d212e7')
       principalType: 'ServicePrincipal'
   }
}

// create cluster

resource cluster 'Microsoft.RedHatOpenShift/openShiftClusters@2024-08-12-preview' = {
   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 con un modello di 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.15.35                     # 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

Se si usano i parametri facoltativi per il segreto pull o il dominio personalizzato, aggiungere una barra rovesciata (\) dopo il parametro rpObjectId e includere i parametri seguenti al comando di distribuzione.

--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', '4d97b98b-1d4f-4787-a291-c67834d212e7')]",
        "principalType": "ServicePrincipal"
      },
      "dependsOn": [
        "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
      ]
    },
    {
      "type": "Microsoft.RedHatOpenShift/openShiftClusters",
      "apiVersion": "2024-08-12-preview",
      "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')]"
      ]
    }
  ]
}

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 (anteprima).

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-11-26

Condividi tramite

Creare un cluster Azure Red Hat OpenShift con identità gestite (anteprima)

Prerequisiti

Scarica il wheel file dell'estensione Red Hat OpenShift di Azure (solo anteprima)

Verificare le autorizzazioni

Registrare i provider di risorse

Ottenere un segreto pull di Red Hat (facoltativo)

Preparare un dominio personalizzato per il cluster (facoltativo)

Installazione

Eseguire l'installazione con l'interfaccia della riga di comando di Azure

Creare una rete virtuale contenente due subnet vuote

Creare le identità gestite assegnate agli utenti richieste

Creare il cluster

Selezionare una versione diversa di Azure Red Hat OpenShift

Eseguire l'installazione con Bicep

File Bicep di esempio

Installare con un modello di ARM

Modello di ARM di esempio

Pulizia

Contenuti correlati

Commenti e suggerimenti

Risorse aggiuntive