Partilhar via

Início rápido: implementar um cluster do Azure Red Hat OpenShift com um modelo do Azure Resource Manager ou um ficheiro Bicep

  • Artigo

Este artigo descreve como usar o modelo do Azure Resource Manager (modelo ARM) ou o Bicep para criar um cluster do Azure Red Hat OpenShift. Você pode implantar o cluster do Azure Red Hat OpenShift com o PowerShell ou a interface de linha de comando do Azure (CLI 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 utiliza 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 do domínio que utiliza sintaxe declarativa para implementar 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 sua infraestrutura. Seus recursos são implantados de maneira consistente.

Nota

Para obter informações sobre como implantar clusters do Azure Red Hat OpenShift usando o Terraform, consulte Microsoft.RedHatOpenShift openShiftClusters Terraform.

Pré-requisitos

  • É necessária uma conta do Azure com uma subscrição ativa. Se ainda não tiver uma, pode criar uma conta gratuitamente.

  • Capacidade de atribuir funções de Administrador de Acesso de Usuário e Colaborador. Se você não tiver essa capacidade, entre em contato com o administrador do Microsoft Entra para gerenciar funções.

  • Uma conta Red Hat. Se não tiver uma, terá de se registar para obter uma conta.

  • Um segredo de pull para seu cluster do Azure Red Hat OpenShift. Faça o download do arquivo pull secret do site do Red Hat OpenShift Cluster Manager.

  • Se você quiser executar o código do Azure PowerShell localmente, Azure PowerShell.

  • Se você quiser executar o código da CLI do Azure localmente:

Criar um modelo ARM ou um arquivo Bicep

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

Criar um modelo ARM

O exemplo a seguir mostra como seu modelo ARM deve parecer quando configurado para seu cluster RedHat OpenShift do Azure.

O modelo define três recursos do Azure:

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

Salve o seguinte exemplo como 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": {
              "description": "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 como seu arquivo Bicep do Azure deve parecer quando configurado para seu cluster do Azure Red Hat OpenShift.

O arquivo Bicep define três recursos do Azure:

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

Crie o seguinte arquivo Bicep contendo a definição para o cluster do Azure Red Hat OpenShift. O exemplo a seguir mostra como seu arquivo Bicep deve parecer quando configurado.

Salve o seguinte arquivo como 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
  ]
}

Implantar o modelo de azuredeploy.json

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

Nota

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

Property Description Opções válidas Valor Predefinido
domain O prefixo de domínio para o cluster. nenhum
pullSecret O segredo de pull que você obteve do site Red Hat OpenShift Cluster Manager.
clusterName O nome do cluster.
aadClientId A ID do aplicativo (um GUID) de um aplicativo cliente Microsoft Entra.
aadObjectId A ID do objeto (um GUID) da entidade de serviço para o aplicativo cliente Microsoft Entra.
aadClientSecret O segredo do cliente da entidade de serviço para o aplicativo cliente 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 do modelo abaixo têm valores padrão. Eles podem ser especificados, mas não são explicitamente necessários.

Property Description Opções válidas Valor Predefinido
location A localização do novo cluster ARO. Esse local pode ser igual ou diferente da região do grupo de recursos. eastus
clusterVnetName O nome da rede virtual para o cluster ARO. ARO-VNET
clusterVnetCidr O espaço de endereço da rede virtual ARO, na notação CIDR (Roteamento entre Domínios sem Classe ). 10.100.0.0/15
workerSubnetCidr O espaço de endereço da sub-rede do nó de trabalho, em notação CIDR. 10.100.70.0/23
masterSubnetCidr O espaço de endereço da sub-rede do nó do plano de controle, em notação CIDR. 10.100.76.0/24
masterVmSize O tipo/tamanho da máquina virtual do nó do 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, em notação CIDR. 10.128.0.0/14
serviceCidr O espaço de endereço do serviço, em notação CIDR. 172.30.0.0/16
tags Uma tabela de hash de tags de recursos. @{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 estiver usando o PowerShell.

Antes de começar - PowerShell

Antes de executar os comandos neste artigo, talvez seja necessário executar Connect-AzAccounto . Verifique 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.

Nota

Este modelo usa o texto secreto de pull que foi obtido do site do Red Hat OpenShift Cluster Manager. Antes de prosseguir, certifique-se de ter o segredo de pull 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

Registe os seguintes fornecedores de recursos na sua subscrição: 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 Azure Red Hat OpenShift usando o modelo ARM - PowerShell

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

Conectar-se ao cluster

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

Limpar recursos - PowerShell

Quando terminar, execute o seguinte comando para excluir seu grupo de recursos e todos os recursos criados neste artigo.

Remove-AzResourceGroup -Name $resourceGroup -Force

Etapas da CLI do Azure

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

Antes de começar - CLI do Azure

Talvez seja necessário executar az login antes de executar os comandos neste artigo. 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.

Nota

Este modelo usará o texto secreto de pull que foi obtido do site do Red Hat OpenShift Cluster Manager. Antes de prosseguir, certifique-se de que tem esse segredo guardado 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 - Azure CLI

Registe os seguintes fornecedores de recursos na sua subscrição: 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 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 de 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 do objeto principal 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.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

Conectar-se ao cluster - CLI do Azure

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

Limpar recursos - CLI do Azure

Quando terminar, execute o seguinte comando para excluir seu grupo de recursos e todos os recursos criados neste artigo.

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

Gorjeta

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

Próximos passos

Neste artigo, você aprendeu como criar um cluster do Azure Red Hat OpenShift executando o OpenShift 4 usando modelos ARM e Bicep.

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