Share via

Avvio rapido: Distribuire un cluster Azure Red Hat OpenShift con un modello di Azure Resource Manager o un file Bicep

  • Articolo

Questo argomento di avvio rapido descrive come usare il modello di Azure Resource Manager o Bicep per creare un cluster Azure Red Hat OpenShift. È possibile distribuire il cluster Azure Red Hat OpenShift con PowerShell o l'interfaccia della riga di comando di Azure.

Un modello di Azure Resource Manager è un file JSON (JavaScript Object Notation) che definisce l'infrastruttura e la configurazione per il progetto. Il modello utilizza la sintassi dichiarativa. Si descrive la distribuzione prevista senza scrivere la sequenza di comandi di programmazione per creare la distribuzione.

Bicep è un linguaggio specifico di dominio (DSL) che usa la sintassi dichiarativa per distribuire le risorse di Azure. L'infrastruttura da distribuire in Azure viene definita in un file Bicep che viene quindi usato in tutto il ciclo di vita di sviluppo per distribuire ripetutamente l'infrastruttura. Le risorse vengono distribuite in modo coerente.

Prerequisiti

  • È necessario un account Azure con una sottoscrizione attiva. Se non è già disponibile, è possibile creare gratuitamente un account.

  • Possibilità di assegnare ruoli Di accesso utente Amministrazione istrator e Collaboratore. Se non si dispone di questa capacità, contattare l'amministratore di Microsoft Entra per gestire i ruoli.

  • Un account Red Hat. Se non ne hai uno, dovrai registrarti per un account.

  • Segreto pull per il cluster Azure Red Hat OpenShift. Scaricare il file segreto pull dal sito Web Red Hat OpenShift Cluster Manager.

  • Se si vuole eseguire il codice di Azure PowerShell in locale, Azure PowerShell.

  • Se si vuole eseguire il codice dell'interfaccia della riga di comando di Azure in locale:

Creare un modello arm o un file Bicep

Scegliere un modello di Azure Resource Manager (modello arm) o un file Azure Bicep. È quindi possibile distribuire il modello usando la riga di comando di Azure (azure-cli) o PowerShell.

Creare un modello di Azure Resource Manager

L'esempio seguente illustra l'aspetto del modello arm quando configurato per il cluster Azure RedHat OpenShift.

Il modello definisce tre risorse di Azure:

Altri esempi di modelli di Azure Red Hat OpenShift sono disponibili nel sito Web di Red Hat OpenShift.

Salvare l'esempio seguente come azuredeploy.bicep:

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
      "location" : {
        "type": "string",
        "defaultValue": "eastus",
        "metadata": {
          "description": "Location"
        }
      },
      "domain": {
          "type": "string",
          "defaultValue": "",
          "metadata": {
              "description": "Domain Prefix"
          }
      },
      "pullSecret": {
          "type": "string",
          "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 ARO vNet"
          }
      },
      "clusterVnetCidr": {
          "type": "string",
          "defaultValue": "10.100.0.0/15",
          "metadata": {
              "description": "ARO 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"
          }
      },
      "workerCount": {
          "type": "int",
          "defaultValue": 3,
          "minValue": 3,
          "metadata": {
              "description": "Number of Worker Nodes"
          }
      },
      "podCidr": {
          "type": "string",
          "defaultValue": "10.128.0.0/14",
          "metadata": {
              "description": "Cidr for Pods"
          }
      },
      "serviceCidr": {
          "type": "string",
          "defaultValue": "172.30.0.0/16",
          "metadata": {
              "decription": "Cidr of service"
          }
      },
      "clusterName" : {
        "type": "string",
        "metadata": {
          "description": "Unique name for the cluster"
        }
      },
      "tags": {
          "type": "object",
          "defaultValue" : {
              "env": "Dev",
              "dept": "Ops"
          },
          "metadata": {
              "description": "Tags for resources"
          }
      },
      "apiServerVisibility": {
          "type": "string",
          "allowedValues": [
              "Private",
              "Public"
          ],
          "defaultValue": "Public",
          "metadata": {
              "description": "Api Server Visibility"
          }
      },
      "ingressVisibility": {
          "type": "string",
          "allowedValues": [
              "Private",
              "Public"
          ],
          "defaultValue": "Public",
          "metadata": {
              "description": "Ingress Visibility"
          }
      },
      "aadClientId" : {
        "type": "string",
        "metadata": {
          "description": "The Application ID of an Azure Active Directory client application"
        }
      },
      "aadObjectId": {
          "type": "string",
          "metadata": {
              "description": "The Object ID of an Azure Active Directory client application"
          }
      },
      "aadClientSecret" : {
        "type":"securestring",
        "metadata": {
          "description": "The secret of an Azure Active Directory client application"
        }
      },
      "rpObjectId": {
          "type": "String",
          "metadata": {
              "description": "The ObjectID of the Resource Provider Service Principal"
          }
      }
    },
    "variables": {
        "contribRole": "[concat('/subscriptions/', subscription().subscriptionId, '/providers/Microsoft.Authorization/roleDefinitions/', 'b24988ac-6180-42a0-ab88-20f7382dd24c')]"
    },
    "resources": [
        {
            "type": "Microsoft.Network/virtualNetworks",
            "apiVersion": "2020-05-01",
            "name": "[parameters('clusterVnetName')]",
            "location": "[parameters('location')]",
            "tags": "[parameters('tags')]",
            "properties": {
                "addressSpace": {
                "addressPrefixes": [
                    "[parameters('clusterVnetCidr')]"
                    ]
                },
                "subnets": [
                {
                    "name": "master",
                    "properties": {
                        "addressPrefix": "[parameters('masterSubnetCidr')]",
                        "serviceEndpoints": [
                            {
                                "service": "Microsoft.ContainerRegistry"
                            }
                        ],
                        "privateLinkServiceNetworkPolicies": "Disabled"
                    }
                },
                {
                    "name": "worker",
                    "properties": {
                        "addressPrefix": "[parameters('workerSubnetCidr')]",
                        "serviceEndpoints": [
                            {
                                "service": "Microsoft.ContainerRegistry"
                            }
                        ]
                    }
                }]
            }
        },
        {
            "type": "Microsoft.Network/virtualNetworks/providers/roleAssignments",
            "apiVersion": "2018-09-01-preview",
            "name": "[concat(parameters('clusterVnetName'), '/Microsoft.Authorization/', guid(resourceGroup().id, deployment().name, parameters('aadObjectId')))]",
            "dependsOn": [
                "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
            ],
            "properties": {
                "roleDefinitionId": "[variables('contribRole')]",
                "principalId":"[parameters('aadObjectId')]"
            }
        },
        {
            "type": "Microsoft.Network/virtualNetworks/providers/roleAssignments",
            "apiVersion": "2018-09-01-preview",
            "name": "[concat(parameters('clusterVnetName'), '/Microsoft.Authorization/', guid(resourceGroup().id, deployment().name, parameters('rpObjectId')))]",
            "dependsOn": [
                "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
            ],
            "properties": {
                "roleDefinitionId": "[variables('contribRole')]",
                "principalId":"[parameters('rpObjectId')]"
            }
        },
        {
            "type": "Microsoft.RedHatOpenShift/OpenShiftClusters",
            "apiVersion": "2020-04-30",
            "name": "[parameters('clusterName')]",
            "location": "[parameters('location')]",
            "tags": "[parameters('tags')]",
            "dependsOn": [
                "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
            ],
            "properties": {
                "clusterProfile": {
                    "domain": "[parameters('domain')]",
                    "resourceGroupId": "[concat('/subscriptions/', subscription().subscriptionId,'/resourceGroups/aro-', parameters('domain'))]",
                    "pullSecret": "[parameters('pullSecret')]"
                },
                "networkProfile": {
                    "podCidr": "[parameters('podCidr')]",
                    "serviceCidr": "[parameters('serviceCidr')]"
                },
                "servicePrincipalProfile": {
                    "clientId": "[parameters('aadClientId')]",
                    "clientSecret": "[parameters('aadClientSecret')]"
                },
                "masterProfile": {
                    "vmSize": "[parameters('masterVmSize')]",
                    "subnetId": "[resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('clusterVnetName'), 'master')]"
                },
                "workerProfiles": [
                    {
                        "name": "worker",
                        "vmSize": "[parameters('workerVmSize')]",
                        "diskSizeGB": "[parameters('workerVmDiskSize')]",
                        "subnetId": "[resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('clusterVnetName'), 'worker')]",
                        "count": "[parameters('workerCount')]"
                    }
                ],
                "apiserverProfile": {
                    "visibility": "[parameters('apiServerVisibility')]"
                },
                "ingressProfiles": [
                    {
                        "name": "default",
                        "visibility": "[parameters('ingressVisibility')]"
                    }
                ]
            }
        }
    ],
    "outputs": {
         "clusterCredentials": {
             "type": "object",
             "value": "[listCredentials(resourceId('Microsoft.RedHatOpenShift/OpenShiftClusters', parameters('clusterName')), '2020-04-30')]"
         },
         "oauthCallbackURL": {
             "type": "string",
             "value": "[concat('https://oauth-openshift.apps.', parameters('domain'), '.', parameters('location'), '.aroapp.io/oauth2callback/AAD')]"
         }
    }
}

Creare un file Bicep

L'esempio seguente illustra l'aspetto del file Bicep di Azure quando è configurato per il cluster Azure Red Hat OpenShift.

Il file Bicep definisce tre risorse di Azure:

Altri modelli di Azure Red Hat OpenShift sono disponibili nel sito Web di Red Hat OpenShift.

Creare il file Bicep seguente contenente la definizione per il cluster Azure Red Hat OpenShift. L'esempio seguente mostra l'aspetto del file Bicep quando configurato.

Salvare il file seguente come azuredeploy.bicep:

@description('Location')
param location string = 'eastus'

@description('Domain Prefix')
param domain string = ''

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

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

@description('ARO 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('Number of Worker Nodes')
@minValue(3)
param workerCount int = 3

@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('Tags for resources')
param tags object = {
  env: 'Dev'
  dept: 'Ops'
}

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

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

@description('The Application ID of an Azure Active Directory client application')
param aadClientId string

@description('The Object ID of an Azure Active Directory client application')
param aadObjectId string

@description('The secret of an Azure Active Directory client application')
@secure()
param aadClientSecret string

@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 contributorRoleDefinitionId = resourceId('Microsoft.Authorization/roleDefinitions', 'b24988ac-6180-42a0-ab88-20f7382dd24c')
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 clusterVnetName_resource 'Microsoft.Network/virtualNetworks@2020-05-01' = {
  name: clusterVnetName
  location: location
  tags: tags
  properties: {
    addressSpace: {
      addressPrefixes: [
        clusterVnetCidr
      ]
    }
    subnets: [
      {
        name: 'master'
        properties: {
          addressPrefix: masterSubnetCidr
          serviceEndpoints: [
            {
              service: 'Microsoft.ContainerRegistry'
            }
          ]
          privateLinkServiceNetworkPolicies: 'Disabled'
        }
      }
      {
        name: 'worker'
        properties: {
          addressPrefix: workerSubnetCidr
          serviceEndpoints: [
            {
              service: 'Microsoft.ContainerRegistry'
            }
          ]
        }
      }
    ]
  }
}

resource clusterVnetName_Microsoft_Authorization_id_name_aadObjectId 'Microsoft.Authorization/roleAssignments@2020-10-01-preview' = {
  name: guid(aadObjectId, clusterVnetName_resource.id, contributorRoleDefinitionId)
  scope: clusterVnetName_resource
  properties: {
    roleDefinitionId: contributorRoleDefinitionId
    principalId: aadObjectId
    principalType: 'ServicePrincipal'
  }
}

resource clusterVnetName_Microsoft_Authorization_id_name_rpObjectId 'Microsoft.Authorization/roleAssignments@2020-10-01-preview' = {
  name: guid(rpObjectId, clusterVnetName_resource.id, contributorRoleDefinitionId)
  scope: clusterVnetName_resource
  properties: {
    roleDefinitionId: contributorRoleDefinitionId
    principalId: rpObjectId
    principalType: 'ServicePrincipal'
  }
}

resource clusterName_resource 'Microsoft.RedHatOpenShift/OpenShiftClusters@2023-04-01' = {
  name: clusterName
  location: location
  tags: tags
  properties: {
    clusterProfile: {
      domain: domain
      resourceGroupId: resourceGroupId
      pullSecret: pullSecret
      fipsValidatedModules: fips
    }
    networkProfile: {
      podCidr: podCidr
      serviceCidr: serviceCidr
    }
    servicePrincipalProfile: {
      clientId: aadClientId
      clientSecret: aadClientSecret
    }
    masterProfile: {
      vmSize: masterVmSize
      subnetId: masterSubnetId
      encryptionAtHost: masterEncryptionAtHost
    }
    workerProfiles: [
      {
        name: 'worker'
        vmSize: workerVmSize
        diskSizeGB: workerVmDiskSize
        subnetId: workerSubnetId
        count: workerCount
        encryptionAtHost: workerEncryptionAtHost
      }
    ]
    apiserverProfile: {
      visibility: apiServerVisibility
    }
    ingressProfiles: [
      {
        name: 'default'
        visibility: ingressVisibility
      }
    ]
  }
  dependsOn: [
    clusterVnetName_resource
  ]
}

Distribuire il modello di azuredeploy.json

Questa sezione fornisce informazioni sulla distribuzione del modello di azuredeploy.json.

parametri azuredeploy.json

Il modello di azuredeploy.json viene usato per distribuire un cluster Azure Red Hat OpenShift. I parametri seguenti sono obbligatori.

Nota

Per il domain parametro specificare il prefisso di dominio che verrà 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.

Proprietà Descrizione Opzioni valide Valore predefinito
domain Prefisso di dominio per il cluster. Nessuno
pullSecret Segreto pull ottenuto dal sito Web Red Hat OpenShift Cluster Manager.
clusterName Nome del cluster.
aadClientId ID applicazione (GUID) di un'applicazione client Microsoft Entra.
aadObjectId ID oggetto (GUID) dell'entità servizio per l'applicazione client Microsoft Entra.
aadClientSecret Segreto client dell'entità servizio per l'applicazione client Microsoft Entra, come stringa sicura.
rpObjectId ID oggetto (GUID) dell'entità servizio del provider di risorse.

I parametri del modello seguenti hanno valori predefiniti. Possono essere specificate, ma non sono richieste in modo esplicito.

Proprietà Descrizione Opzioni valide Valore predefinito
location Posizione del nuovo cluster ARO. Questa posizione può essere uguale o diversa dall'area del gruppo di risorse. eastus
clusterVnetName Nome della rete virtuale per il cluster ARO. aro-vnet
clusterVnetCidr Spazio indirizzi della rete virtuale ARO, nella notazione CIDR (Classless Inter-Domain Routing ). 10.100.0.0/15
workerSubnetCidr Spazio indirizzi della subnet del nodo di lavoro, nella notazione CIDR. 10.100.70.0/23
masterSubnetCidr Spazio indirizzi della subnet del nodo del piano di controllo, nella notazione CIDR. 10.100.76.0/24
masterVmSize Tipo /dimensione della macchina virtuale del nodo del piano di controllo. Standard_D8s_v3
workerVmSize Tipo/dimensione della macchina virtuale del nodo di lavoro. Standard_D4s_v3
workerVmDiskSize Dimensioni del disco del nodo di lavoro, in gigabyte. 128
workerCount Il numero di nodi di lavoro. 3
podCidr Spazio degli indirizzi dei pod, nella notazione CIDR. 10.128.0.0/14
serviceCidr Spazio indirizzi del servizio, nella notazione CIDR. 172.30.0.0/16
tags Tabella hash dei tag delle risorse. @{env = 'Dev'; dept = 'Ops'}
apiServerVisibility Visibilità del server API (Public o Private). Pubblico
ingressVisibility Visibilità in ingresso (ingresso) (Public o Private). Pubblico

Le sezioni seguenti forniscono istruzioni con PowerShell o l'interfaccia della riga di comando di Azure.

Passaggi di PowerShell

Se si usa PowerShell, seguire questa procedura.

Prima di iniziare - PowerShell

Prima di eseguire i comandi in questa guida introduttiva, potrebbe essere necessario eseguire Connect-AzAccount. Controllare se è disponibile la connettività ad Azure prima di procedere. Per verificare se si dispone di connettività, eseguire Get-AzContext per verificare se si ha accesso a una sottoscrizione di Azure attiva.

Nota

Questo modello usa il testo segreto pull ottenuto dal sito Web Red Hat OpenShift Cluster Manager. Prima di procedere, assicurarsi di avere il segreto pull salvato in locale come pull-secret.txt.

$rhosPullSecret= Get-Content .\pull-secret.txt -Raw # the pull secret text that was obtained from the Red Hat OpenShift Cluster Manager website

Definire i parametri seguenti come variabili di ambiente - PowerShell

$resourceGroup="aro-rg"	     # the new resource group for the cluster
$location="eastus"    		 # the location of the new ARO cluster
$domain="mydomain"           # the domain prefix for the cluster  
$aroClusterName="cluster"    # the name of the cluster

Registrare i provider di risorse necessari - PowerShell

Registrare i provider di risorse seguenti nella sottoscrizione: Microsoft.RedHatOpenShift, Microsoft.StorageMicrosoft.Computee Microsoft.Authorization.

Register-AzResourceProvider -ProviderNamespace Microsoft.RedHatOpenShift
Register-AzResourceProvider -ProviderNamespace Microsoft.Compute
Register-AzResourceProvider -ProviderNamespace Microsoft.Storage
Register-AzResourceProvider -ProviderNamespace Microsoft.Authorization

Creare il nuovo gruppo di risorse - PowerShell

New-AzResourceGroup -Name $resourceGroup -Location $location

Creare una nuova entità servizio e assegnare ruoli - PowerShell

$suffix=Get-Random # random suffix for the Service Principal
$spDisplayName="sp-$resourceGroup-$suffix"
$azureADAppSp = New-AzADServicePrincipal -DisplayName $spDisplayName -Role Contributor

New-AzRoleAssignment -ObjectId $azureADAppSp.Id -RoleDefinitionName 'User Access Administrator' -ResourceGroupName $resourceGroup -ObjectType 'ServicePrincipal'
New-AzRoleAssignment -ObJectId $azureADAppSp.Id -RoleDefinitionName 'Contributor' -ResourceGroupName $resourceGroup -ObjectType 'ServicePrincipal'

Ottenere la password dell'entità servizio - PowerShell

$aadClientSecretDigest = ConvertTo-SecureString -String $azureADAppSp.PasswordCredentials.SecretText -AsPlainText -Force

Ottenere l'entità servizio per il provider di risorse OpenShift - PowerShell

$rpOpenShift =  Get-AzADServicePrincipal -DisplayName 'Azure Red Hat OpenShift RP' | Select-Object -ExpandProperty Id -Property Id -First 1

Controllare i parametri prima di distribuire il cluster - PowerShell

# setup the parameters for the deployment
$templateParams = @{  
    domain = $domain
    clusterName = $aroClusterName
    location = $location
    aadClientId = $azureADAppSp.AppId
    aadObjectId = $azureADAppSp.Id
    aadClientSecret = $aadClientSecretDigest 
    rpObjectId = $rpOpenShift.Id
    pullSecret = $rhosPullSecret
}

Write-Verbose (ConvertTo-Json $templateParams) -Verbose

Distribuire il cluster Azure Red Hat OpenShift usando il modello di Resource Manager - PowerShell

New-AzResourceGroupDeployment -ResourceGroupName $resourceGroup @templateParams `
    -TemplateFile azuredeploy.json

Connettersi al cluster

Per connettersi al nuovo cluster, esaminare i passaggi descritti in Connessione a un cluster Azure Red Hat OpenShift 4.

Pulire le risorse - PowerShell

Al termine, eseguire il comando seguente per eliminare il gruppo di risorse e tutte le risorse create in questa esercitazione.

Remove-AzResourceGroup -Name $resourceGroup -Force

Passaggi dell'interfaccia della riga di comando di Azure

Se si usa l'interfaccia della riga di comando di Azure, seguire questa procedura.

Prima di iniziare - Interfaccia della riga di comando di Azure

Potrebbe essere necessario eseguire az login prima di eseguire i comandi in questa guida introduttiva. Controllare se è disponibile la connettività ad Azure prima di procedere. Per verificare se si dispone di connettività, eseguire az account list e verificare di avere accesso a una sottoscrizione di Azure attiva.

Nota

Questo modello userà il testo del segreto pull ottenuto dal sito Web Red Hat OpenShift Cluster Manager. Prima di procedere, assicurarsi di aver salvato il segreto in locale come pull-secret.txt.

PULL_SECRET=$(cat pull-secret.txt)    # the pull secret text

Definire i parametri seguenti come variabili di ambiente - Interfaccia della riga di comando di Azure

RESOURCEGROUP=aro-rg            # the new resource group for the cluster
LOCATION=eastus                 # the location of the new cluster
DOMAIN=mydomain                 # the domain prefix for the cluster
ARO_CLUSTER_NAME=aro-cluster    # the name of the cluster

Registrare i provider di risorse necessari - Interfaccia della riga di comando di Azure

Registrare i provider di risorse seguenti nella sottoscrizione: Microsoft.RedHatOpenShift, Microsoft.StorageMicrosoft.Computee Microsoft.Authorization.

az provider register --namespace 'Microsoft.RedHatOpenShift' --wait
az provider register --namespace 'Microsoft.Compute' --wait
az provider register --namespace 'Microsoft.Storage' --wait
az provider register --namespace 'Microsoft.Authorization' --wait

Creare il nuovo gruppo di risorse - Interfaccia della riga di comando di Azure

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

Creare un'entità servizio per la nuova applicazione Microsoft Entra

  • Interfaccia della riga di comando di Azure
az ad sp create-for-rbac --name "sp-$RG_NAME-${RANDOM}" > app-service-principal.json
SP_CLIENT_ID=$(jq -r '.appId' app-service-principal.json)
SP_CLIENT_SECRET=$(jq -r '.password' app-service-principal.json)
SP_OBJECT_ID=$(az ad sp show --id $SP_CLIENT_ID | jq -r '.id')

Assegnare il ruolo Collaboratore alla nuova entità servizio - Interfaccia della riga di comando di Azure

az role assignment create \
    --role 'User Access Administrator' \
    --assignee-object-id $SP_OBJECT_ID \
    --scope $SCOPE \
    --assignee-principal-type 'ServicePrincipal'

az role assignment create \
    --role 'Contributor' \
    --assignee-object-id $SP_OBJECT_ID \
    --scope $SCOPE \
    --assignee-principal-type 'ServicePrincipal'

Ottenere l'ID oggetto dell'entità servizio per il provider di risorse OpenShift - Interfaccia della riga di comando di Azure

ARO_RP_SP_OBJECT_ID=$(az ad sp list --display-name "Azure Red Hat OpenShift RP" --query [0].id -o tsv)

Distribuire il cluster - Interfaccia della riga di comando di Azure

az deployment group create \
    --name aroDeployment \
    --resource-group $RESOURCEGROUP \
    --template-file azuredeploy.bicep \
    --parameters location=$LOCATION \
    --parameters domain=$DOMAIN \
    --parameters pullSecret=$PULL_SECRET \
    --parameters clusterName=$ARO_CLUSTER_NAME \
    --parameters aadClientId=$SP_CLIENT_ID \
    --parameters aadObjectId=$SP_OBJECT_ID \
    --parameters aadClientSecret=$SP_CLIENT_SECRET \
    --parameters rpObjectId=$ARO_RP_SP_OBJECT_ID

Connessione al cluster - Interfaccia della riga di comando di Azure

Per connettersi al nuovo cluster, esaminare i passaggi descritti in Connessione a un cluster Azure Red Hat OpenShift 4.

Pulire le risorse - Interfaccia della riga di comando di Azure

Al termine, eseguire il comando seguente per eliminare il gruppo di risorse e tutte le risorse create in questa esercitazione.

az aro delete --resource-group $RESOURCEGROUP --name $CLUSTER

Suggerimento

Problemi? Segnalare il problema in GitHub aprendo un problema nel repository Azure Red Hat Openshift (ARO).

Passaggi successivi

In questo articolo si è appreso come creare un cluster Azure Red Hat OpenShift che esegue OpenShift 4 usando sia i modelli arm che Bicep.

Passare all'articolo successivo per informazioni su come configurare il cluster per l'autenticazione usando Microsoft Entra ID.