Condividi tramite

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

  • Articolo

Questo articolo descrive come usare il modello di Azure Resource Manager (modello ARM) o il file 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 del progetto. Il modello utilizza la sintassi dichiarativa. Si descrive la distribuzione prevista senza scrivere la sequenza di comandi di programmazione necessari 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

Creare un modello di Azure Resource Manager o un file Bicep

Scegliere un modello di Azure Resource Manager (modello di ARM) o un file Bicep per Azure. È 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 mostra l'aspetto che il modello di Azure Resource Manager dovrebbe avere quando è configurato per il cluster Azure Red Hat 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.json:

{
    "$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 mostra l'aspetto che il file Bicep per Azure dovrebbe avere 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 che il file Bicep dovrebbe avere quando è configurato.

Salvare l'esempio 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 azuredeploy.json

Il modello azuredeploy.json viene usato per distribuire un cluster Azure Red Hat OpenShift. Sono obbligatori i parametri seguenti:

Nota

Per il parametro domain, 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 di Red Hat OpenShift Cluster Manager.
clusterName Nome del cluster.
aadClientId ID applicazione (GUID) di un'applicazione client di Microsoft Entra.
aadObjectId ID oggetto (GUID) dell'entità servizio per l'applicazione client di Microsoft Entra.
aadClientSecret Segreto client dell'entità servizio per l'applicazione client di 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 specificati, ma non sono richiesti in modo esplicito.

Proprietà Descrizione Opzioni valide Valore predefinito
location Posizione del nuovo cluster Azure Red Hat OpenShift. La posizione può corrispondere o meno all'area del gruppo di risorse. eastus
clusterVnetName Nome della rete virtuale per il cluster Azure Red Hat OpenShift. aro-vnet
clusterVnetCidr Spazio indirizzi della rete virtuale di Azure Red Hat OpenShift, nella notazione Classless Inter-Domain Routing (CIDR). 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 (entrata) (Public o Private). Pubblico

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

Passaggi per PowerShell

Se si usa PowerShell, seguire questa procedura.

Prima di iniziare - PowerShell

Prima di eseguire i comandi in questo articolo, è necessario eseguire Connect-AzAccount. Prima di procedere, controllare se è disponibile la connettività ad Azure. Per verificare se è disponibile la connettività, eseguire Get-AzContext per verificare se si ha accesso a una sottoscrizione di Azure attiva.

Nota

Questo modello usa il testo del segreto pull ottenuto dal sito Web di 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.Compute, Microsoft.Storage e 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 Azure Resource Manager - PowerShell

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

Connettersi al cluster

Per connettersi al nuovo cluster, esaminare i passaggi descritti in Connettersi 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 questo articolo.

Remove-AzResourceGroup -Name $resourceGroup -Force

Passaggi per l'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

È necessario eseguire az login prima di eseguire i comandi in questo articolo. Prima di procedere, controllare se è disponibile la connettività ad Azure. Per verificare se è disponibile la connettività, eseguire az account list e verificare se si ha accesso a una sottoscrizione di Azure attiva.

Nota

Questo modello userà il testo del segreto pull ottenuto dal sito Web di 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.Compute, Microsoft.Storage e 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 di 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.json \
    --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

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

Connettersi al cluster - Interfaccia della riga di comando di Azure

Per connettersi al nuovo cluster, esaminare i passaggi descritti in Connettersi 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 questo articolo.

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

Suggerimento

Problemi? Segnalare i problemi su 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 di Azure Resource Manager sia Bicep.

Per informazioni su come configurare il cluster per l'autenticazione tramite Microsoft Entra ID, passare all'articolo successivo.