Compartilhar via

Início Rápido: Implantar um cluster de Red Hat OpenShift no Azure com um modelo do Azure Resource Manager ou um arquivo Bicep

  • Artigo

Este início rápido descreve como usar o modelo do Azure Resource Manager (ARM) ou o Bicep para criar um cluster de Red Hat OpenShift no Azure. É possível implantar o cluster de Red Hat OpenShift no Azure com o PowerShell ou a CLI do Azure (interface de linha de comando do Azure).

Um modelo do Azure Resource Manager é um arquivo JSON (JavaScript Object Notation) que define a infraestrutura e a configuração do seu projeto. O modelo usa a sintaxe declarativa. Você descreve a implantação pretendida sem escrever a sequência de comandos de programação para criar a implantação.

O Bicep é uma linguagem específica de domínio (DSL) que usa sintaxe declarativa para implantar recursos do Azure. Em um arquivo Bicep, você define a infraestrutura que deseja implantar no Azure e, em seguida, usa esse arquivo durante todo o ciclo de vida de desenvolvimento para implantar repetidamente a sua infraestrutura. Os seus recursos são implantados de maneira consistente.

Pré-requisitos

Criar um modelo do ARM ou um arquivo Bicep

Escolha um modelo do ARM (modelo do Azure Resource Manager) ou um arquivo Bicep do Azure. Em seguida, você pode implantar o modelo usando a Azure-cli (linha de comando do Azure) ou o PowerShell.

Criar um modelo do Resource Manager

O exemplo a seguir mostra a aparência do modelo do ARM quando configurado para seu cluster do Red Hat OpenShift no Azure.

O modelo define três recursos do Azure:

Mais exemplos de modelos do Red Hat OpenShift no Azure podem ser encontrados no site do Red Hat OpenShift.

Salve o exemplo a seguir como 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')]"
         }
    }
}

Criar um arquivo Bicep

O exemplo a seguir mostra a aparência do arquivo Bicep do Azure quando configurado para seu cluster do Red Hat OpenShift no Azure.

O arquivo Bicep define três recursos do Azure:

Mais modelos do Red Hat OpenShift no Azure podem ser encontrados no site do Red Hat OpenShift.

Crie o seguinte arquivo Bicep que contém a definição para o cluster do Red Hat OpenShift no Azure. O exemplo a seguir mostra como o seu arquivo Bicep deve ficar quando configurado.

Salve o seguinte arquivo como azuredeploy.json:

@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
  ]
}

Implantar o modelo azuredeploy.json

O modelo azuredeploy.json é usado para implantar um cluster do Red Hat OpenShift no Azure. Os seguintes parâmetros são obrigatórios:

Observação

Para o domain parâmetro, especifique o prefixo de domínio que será usado como parte do nome DNS gerado automaticamente para servidores de API e console do OpenShift. Esse prefixo também é usado como parte do nome do grupo de recursos criado para hospedar as VMs do cluster.

Propriedade Descrição Opções válidas Valor padrão
domain O prefixo de domínio para o cluster. nenhum
pullSecret O segredo de pull obtido no site do Gerenciador de Cluster do Red Hat OpenShift.
clusterName O nome do cluster.
aadClientId A ID do aplicativo (um GUID) de um aplicativo cliente do Microsoft Entra.
aadObjectId A ID do objeto (um GUID) da entidade de serviço para o aplicativo cliente do Microsoft Entra.
aadClientSecret O segredo do cliente da entidade de serviço para o aplicativo cliente do Microsoft Entra, como uma cadeia de caracteres segura.
rpObjectId A ID do objeto (um GUID) da entidade de serviço do provedor de recursos.

Os parâmetros de modelo abaixo têm valores padrão. Eles podem ser especificados, mas não são explicitamente necessários.

Propriedade Descrição Opções válidas Valor padrão
location O local do novo cluster do ARO. Esta localização pode ser igual ou diferente da região do grupo de recursos. eastus
clusterVnetName O nome da rede virtual para o cluster do ARO. aro-vnet
clusterVnetCidr O espaço de endereço da rede virtual do ARO, em notação do CIDR (Roteamento entre Domínios sem Classificação). 10.100.0.0/15
workerSubnetCidr O espaço de endereço da sub-rede do nó de trabalho, na notação do CIDR. 10.100.70.0/23
masterSubnetCidr O espaço de endereço da sub-rede do nó de plano de controle, na notação do CIDR. 10.100.76.0/24
masterVmSize O tipo/tamanho da máquina virtual do nó de plano de controle. Standard_D8s_v3
workerVmSize O tipo/tamanho da máquina virtual do nó de trabalho. Standard_D4s_v3
workerVmDiskSize O tamanho do disco do nó de trabalho, em gigabytes. 128
workerCount O número de nós de trabalho. 3
podCidr O espaço de endereço dos pods, na notação do CIDR. 10.128.0.0/14
serviceCidr O espaço de endereço do serviço, na notação do CIDR. 172.30.0.0/16
tags Uma tabela de hash de marcas de recurso. @{env = 'Dev'; dept = 'Ops'}
apiServerVisibility A visibilidade do servidor de API (Public ou Private). Público
ingressVisibility A visibilidade de entrada (entrada) (Public ou Private). Público

As seções a seguir fornecem instruções usando o PowerShell ou a CLI do Azure.

etapas do PowerShell

Execute as etapas a seguir se você estiver usando o PowerShell.

Antes de começar - PowerShell

Antes de executar os comandos neste guia de início rápido, talvez seja necessário executar o Connect-AzAccount. Selecione para determinar se você tem conectividade com o Azure antes de continuar. Para verificar se você tem conectividade, execute Get-AzContext para verificar se você tem acesso a uma assinatura ativa do Azure.

Observação

Este modelo usa o texto de segredo de pull que foi obtido do site do Gerenciador de cluster do Red Hat OpenShift. Antes de continuar, verifique se o segredo de pull foi salvo localmente como 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

Definir os seguintes parâmetros como variáveis de 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

Registrar os provedores de recursos necessários - PowerShell

Registre os seguintes provedores de recursos em sua assinatura: Microsoft.RedHatOpenShift, Microsoft.ComputeMicrosoft.Storage e Microsoft.Authorization.

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

Criar o novo grupo de recursos - PowerShell

New-AzResourceGroup -Name $resourceGroup -Location $location

Criar uma nova entidade de serviço e atribuir funções - 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'

Obter a senha da entidade de serviço - PowerShell

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

Obter a entidade de serviço para o provedor de recursos OpenShift - PowerShell

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

Verifique os parâmetros antes de implantar o 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

Implantar o cluster do Red Hat OpenShift no Azure usando o modelo do ARM – PowerShell

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

Conectar-se ao seu cluster

Para se conectar ao seu novo cluster, revise as etapas em Conectar-se a um cluster do Red Hat OpenShift 4 no Azure.

Limpar recursos - PowerShell

Quando terminar, execute o comando a seguir para excluir o grupo de recursos e todos os recursos criados neste tutorial.

Remove-AzResourceGroup -Name $resourceGroup -Force

Etapas da CLI do Azure

Execute as etapas a seguir se você estiver usando a CLI do Azure.

Antes de começar - CLI do Azure

Talvez seja necessário executar o az login antes de executar os comandos neste guia de início rápido. Verifique se você tem conectividade com o Azure antes de continuar. Para verificar se você tem conectividade, execute az account list e verifique se você tem acesso a uma assinatura ativa do Azure.

Observação

Este modelo usará o texto de segredo de pull que foi obtido do site do Gerenciador de cluster do Red Hat OpenShift. Antes de continuar, verifique se esse segredo foi salvo localmente como pull-secret.txt.

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

Definir os seguintes parâmetros como variáveis de ambiente - CLI do 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

Registrar os provedores de recursos necessários - CLI do Azure

Registre os seguintes provedores de recursos em sua assinatura: Microsoft.RedHatOpenShift, Microsoft.ComputeMicrosoft.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

Criar o novo grupo de recursos - CLI do Azure

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

Criar uma entidade de serviço para o novo aplicativo do Microsoft Entra

  • CLI do 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')

Atribuir a função colaborador à nova entidade de serviço -CLI do 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'

Obter a ID de objeto da entidade de serviço para o provedor de recursos OpenShift - CLI do Azure

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

Implantar o cluster - CLI do 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

Conexão ao seu cluster - CLI do Azure

Para se conectar ao seu novo cluster, revise as etapas em Conectar-se a um cluster do Red Hat OpenShift 4 no Azure.

Limpar recursos - CLI do Azure

Quando terminar, execute o comando a seguir para excluir o grupo de recursos e todos os recursos criados neste tutorial.

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

Dica

Está enfrentando problemas? Informe-nos no GitHub abrindo um problema no repositório do ARO (Red Hat Openshift no Azure).

Próximas etapas

Neste artigo, você aprendeu a criar um cluster do Red Hat OpenShift no Azure executando o OpenShift 4 usando os modelos do ARM e bicep.

Prossiga para o próximo artigo para saber como configurar o cluster para autenticação usando o Microsoft Entra ID.