Szybki start: wdrażanie Azure Red Hat OpenShift przy użyciu standardowego klastra architektury przy użyciu szablonu Azure Resource Manager lub pliku Bicep

W tym artykule opisano, jak użyć szablonu usługi Azure Resource Manager (szablonu ARM) albo narzędzia Bicep do utworzenia klastra Azure Red Hat OpenShift w architekturze standardowej. Klaster można wdrożyć za pomocą programu PowerShell lub interfejsu wiersza polecenia Azure (Azure CLI).

Szablon usługi Azure Resource Manager to plik JavaScript Object Notation (JSON), który definiuje infrastrukturę i konfigurację projektu. Szablon używa składni deklaratywnej. Możesz opisać zamierzone wdrożenie bez konieczności pisania sekwencji poleceń programowania w celu utworzenia wdrożenia.

Bicep to język specyficzny dla domeny (DSL), który używa składni deklaratywnej do wdrażania zasobów platformy Azure. W pliku Bicep zdefiniujesz infrastrukturę, którą chcesz wdrożyć na platformie Azure, a następnie użyjesz tego pliku w całym cyklu życia programowania, aby wielokrotnie wdrażać infrastrukturę. Zasoby są wdrażane w spójny sposób.

Uwaga / Notatka

Aby uzyskać informacje na temat wdrażania klastrów usługi Azure Red Hat OpenShift przy użyciu programu Terraform, zobacz Microsoft.RedHatOpenShift openShiftClusters Terraform.

Wymagania wstępne

Utwórz szablon ARM lub plik Bicep

Wybierz szablon Azure Resource Manager (szablon ARM) lub plik Azure Bicep. Następnie możesz wdrożyć szablon przy użyciu wiersza polecenia platformy Azure (azure-cli) lub programu PowerShell.

Utwórz szablon ARM

W poniższym przykładzie pokazano, jak szablon usługi ARM powinien wyglądać po skonfigurowaniu klastra usługi Azure RedHat OpenShift.

Szablon definiuje trzy zasoby platformy Azure:

Więcej przykładów szablonów usługi Azure Red Hat OpenShift można znaleźć w witrynie internetowej Red Hat OpenShift.

Zapisz następujący przykład jako 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 vNet"
          }
      },
      "clusterVnetCidr": {
          "type": "string",
          "defaultValue": "10.100.0.0/15",
          "metadata": {
              "description": "vNet Address Space"
          }
      },
      "workerSubnetCidr": {
          "type": "string",
          "defaultValue": "10.100.70.0/23",
          "metadata": {
              "description": "Worker node subnet address space"
          }
      },
      "masterSubnetCidr": {
          "type": "string",
          "defaultValue": "10.100.76.0/24",
          "metadata": {
              "description": "Master node subnet address space"
          }
      },
      "masterVmSize" : {
          "type": "string",
          "defaultValue": "Standard_D8s_v3",
          "metadata": {
              "description": "Master Node VM Type"
          }
      },
      "workerVmSize": {
          "type": "string",
          "defaultValue": "Standard_D4s_v3",
          "metadata": {
              "description": "Worker Node VM Type"
          }
      },
      "workerVmDiskSize": {
          "type" : "int",
          "defaultValue": 128,
          "minValue": 128,
          "metadata": {
              "description": "Worker Node Disk Size in GB"
          }
      },
      "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')]",
        "fpNetworkRole": "[concat('/subscriptions/', subscription().subscriptionId, '/providers/Microsoft.Authorization/roleDefinitions/', '42f3c60f-e7b1-46d7-ba56-6de681664342')]"
    },
    "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('fpNetworkRole ')]",
                "principalId":"[parameters('rpObjectId')]"
            }
        },
        {
            "type": "Microsoft.RedHatOpenShift/OpenShiftClusters",
            "apiVersion": "2025-07-25",
            "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')), '2025-07-25')]"
         },
         "oauthCallbackURL": {
             "type": "string",
             "value": "[concat('https://oauth-openshift.apps.', parameters('domain'), '.', parameters('location'), '.aroapp.io/oauth2callback/AAD')]"
         }
    }
}

Tworzenie pliku Bicep

Poniższy przykład pokazuje, jak powinien wyglądać plik Azure Bicep skonfigurowany dla klastra Azure Red Hat OpenShift.

Plik Bicep definiuje trzy zasoby platformy Azure:

Więcej szablonów usługi Azure Red Hat OpenShift można znaleźć w witrynie internetowej Red Hat OpenShift.

Utwórz następujący plik Bicep zawierający definicję klastra Usługi Azure Red Hat OpenShift. W poniższym przykładzie pokazano, jak plik Bicep powinien wyglądać po skonfigurowaniu.

Zapisz następujący plik jako 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 vNet')
param clusterVnetName string = 'aro-vnet'

@description('vNet Address Space')
param clusterVnetCidr string = '10.100.0.0/15'

@description('Worker node subnet address space')
param workerSubnetCidr string = '10.100.70.0/23'

@description('Master node subnet address space')
param masterSubnetCidr string = '10.100.76.0/24'

@description('Master Node VM Type')
param masterVmSize string = 'Standard_D8s_v3'

@description('Worker Node VM Type')
param workerVmSize string = 'Standard_D4s_v3'

@description('Worker Node Disk Size in GB')
@minValue(128)
param workerVmDiskSize int = 128

@description('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 firstPartyNetworkRoleDefinitionId = resourceId('Microsoft.Authorization/roleDefinitions', '42f3c60f-e7b1-46d7-ba56-6de681664342')
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, firstPartyNetworkRoleDefinitionId)
  scope: clusterVnetName_resource
  properties: {
    roleDefinitionId: firstPartyNetworkRoleDefinitionId
    principalId: rpObjectId
    principalType: 'ServicePrincipal'
  }
}

resource clusterName_resource 'Microsoft.RedHatOpenShift/OpenShiftClusters@2025-07-25' = {
  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
  ]
}

Wdrażanie szablonu azuredeploy.json

Szablon azuredeploy.json służy do wdrażania klastra usługi Azure Red Hat OpenShift. Wymagane są następujące parametry:

Uwaga / Notatka

Dla parametru domain określ prefiks domeny, który będzie używany jako część automatycznie generowanej nazwy DNS dla konsoli OpenShift i serwerów interfejsu API. Ten prefiks jest również używany jako część nazwy grupy zasobów utworzonej do hostowania maszyn wirtualnych klastra.

Majątek Opis Prawidłowe opcje Wartość domyślna
domain Prefiks domeny dla klastra. żadne
pullSecret Klucz tajny pobierania, który uzyskano z witryny Red Hat OpenShift Cluster Manager.
clusterName Nazwa klastra.
aadClientId Identyfikator aplikacji (GUID) aplikacji klienckiej Microsoft Entra.
aadObjectId Identyfikator obiektu (GUID) nazwy głównej usługi dla aplikacji klienckiej Microsoft Entra.
aadClientSecret Klucz tajny klienta jednostki usługi dla aplikacji klienckiej Microsoft Entra, w postaci bezpiecznego ciągu.
rpObjectId Identyfikator obiektu (identyfikator GUID) jednostki usługi dostawcy zasobów.

Poniższe parametry szablonu mają wartości domyślne. Można je określić, ale nie są one jawnie wymagane.

Majątek Opis Prawidłowe opcje Wartość domyślna
location Lokalizacja nowego klastra. Ta lokalizacja może być taka sama jak lub inna niż region grupy zasobów. eastus
clusterVnetName Nazwa sieci wirtualnej klastra. aro-vnet
clusterVnetCidr Przestrzeń adresowa sieci wirtualnej w notacji Classless Inter-Domain Routing (CIDR). 10.100.0.0/15
workerSubnetCidr Przestrzeń adresowa podsieci węzła roboczego w notacji CIDR. 10.100.70.0/23
masterSubnetCidr Przestrzeń adresowa podsieci węzła płaszczyzny sterowania w notacji CIDR. 10.100.76.0/24
masterVmSize Typ/rozmiar maszyny wirtualnej węzła płaszczyzny sterowania. Standard_D8s_v3
workerVmSize Typ/rozmiar maszyny wirtualnej dla węzła roboczego. Standard_D4s_v3
workerVmDiskSize Rozmiar dysku węzła roboczego w gigabajtach. 128
workerCount Liczba węzłów roboczych. 3
podCidr Przestrzeń adresowa podów zapisana w notacji CIDR. 10.128.0.0/14
serviceCidr Przestrzeń adresowa usługi w notacji CIDR. 172.30.0.0/16
tags Tabela skrótów tagów zasobów. @{env = 'Dev'; dept = 'Ops'}
apiServerVisibility Widoczność serwera interfejsu API (Public lub Private). Publiczność
ingressVisibility Widoczność ruchu przychodzącego (wejściowego) (Public lub Private). Publiczność

Poniższe sekcje zawierają instrukcje dotyczące korzystania z programu PowerShell lub interfejsu wiersza polecenia platformy Azure.

Kroki programu PowerShell

Wykonaj następujące kroki, jeśli używasz programu PowerShell.

Przed rozpoczęciem — PowerShell

Przed uruchomieniem poleceń w tym artykule może być konieczne uruchomienie polecenia Connect-AzAccount. Przed kontynuowaniem sprawdź, czy masz łączność z platformą Azure. Aby sprawdzić, czy masz łączność, uruchom polecenie Get-AzContext , aby sprawdzić, czy masz dostęp do aktywnej subskrypcji platformy Azure.

Uwaga / Notatka

Ten szablon używa treści pull secretu uzyskanej ze strony internetowej Red Hat OpenShift Cluster Manager. Przed kontynuowaniem upewnij się, że masz lokalnie zapisany pull secret jako 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

Zdefiniuj następujące parametry jako zmienne środowiskowe — PowerShell

$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
$aroClusterName="cluster"    # the name of the cluster

Rejestrowanie wymaganych dostawców zasobów — PowerShell

Zarejestruj następujących dostawców zasobów w subskrypcji: Microsoft.RedHatOpenShift, Microsoft.ComputeMicrosoft.Storage i Microsoft.Authorization.

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

Tworzenie nowej grupy zasobów — PowerShell

New-AzResourceGroup -Name $resourceGroup -Location $location

Utwórz nową jednostkę usługi i przypisz role — 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'

Pobierz hasło nazwy głównej usługi — PowerShell

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

Pobierz jednostkę usługi dla dostawcy zasobów OpenShift — PowerShell

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

Sprawdź parametry przed wdrożeniem klastra — 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

Wdrażanie klastra Azure Red Hat OpenShift przy użyciu szablonu usługi ARM — PowerShell

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

Nawiązywanie połączenia z klastrem

Aby nawiązać połączenie z nowym klastrem, zapoznaj się z instrukcjami w artykule Łączenie z klastrem usługi Azure Red Hat OpenShift 4.

Czyszczenie zasobów — PowerShell

Po zakończeniu uruchom następujące polecenie, aby usunąć grupę zasobów i wszystkie zasoby utworzone w tym artykule.

Remove-AzResourceGroup -Name $resourceGroup -Force

Kroki interfejsu wiersza polecenia Azure

Wykonaj następujące kroki, jeśli używasz interfejsu wiersza polecenia platformy Azure.

Przed rozpoczęciem — interfejs wiersza polecenia platformy Azure

Przed uruchomieniem poleceń opisanych w tym artykule może być konieczne uruchomienie polecenia az login. Przed kontynuowaniem sprawdź, czy masz łączność z platformą Azure. Aby sprawdzić, czy masz łączność, uruchom az account list polecenie i sprawdź, czy masz dostęp do aktywnej subskrypcji platformy Azure.

Uwaga / Notatka

Ten szablon użyje treści sekretu pull uzyskanej ze strony internetowej Red Hat OpenShift Cluster Manager. Przed kontynuowaniem upewnij się, że masz ten sekret zapisany lokalnie jako pull-secret.txt.

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

Zdefiniuj następujące parametry jako zmienne środowiskowe — interfejs wiersza polecenia platformy 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

Rejestrowanie wymaganych dostawców zasobów — interfejs wiersza polecenia platformy Azure

Zarejestruj następujących dostawców zasobów w subskrypcji: Microsoft.RedHatOpenShift, Microsoft.ComputeMicrosoft.Storage i 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

Utwórz nową grupę zasobów — Azure CLI

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

Utwórz nazwę główną usługi dla nowej aplikacji Microsoft Entra

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

Przypisz rolę Współautor do nowej jednostki usługi — Azure CLI

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'

Uzyskiwanie identyfikatora obiektu jednostki usługi dla dostawcy zasobów OpenShift — interfejs wiersza polecenia platformy Azure

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

Wdrażanie klastra — interfejs wiersza polecenia platformy 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

Łączenie z klastrem — Azure CLI

Aby nawiązać połączenie z nowym klastrem, zapoznaj się z instrukcjami w artykule Łączenie z klastrem usługi Azure Red Hat OpenShift 4.

Czyszczenie zasobów — Azure CLI

Po zakończeniu uruchom następujące polecenie, aby usunąć grupę zasobów i wszystkie zasoby utworzone w tym artykule.

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

Wskazówka

Masz problemy? Poinformuj nas na platformie GitHub, zgłaszając problem w repozytorium Azure Red Hat Openshift.

Dalsze kroki

W tym artykule przedstawiono sposób tworzenia klastra usługi Azure Red Hat OpenShift z systemem OpenShift 4 przy użyciu szablonów usługi ARM i aplikacji Bicep.

Przejdź do następnego artykułu, aby dowiedzieć się, jak skonfigurować klaster do uwierzytelniania przy użyciu identyfikatora Entra firmy Microsoft.

  • Last updated on