Udostępnij za pośrednictwem

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

  • Artykuł

W tym artykule opisano sposób tworzenia klastra Usługi Azure Red Hat OpenShift przy użyciu szablonu usługi Azure Resource Manager (szablonu arm) lub Bicep. Klaster Usługi Azure Red Hat OpenShift można wdrożyć za pomocą programu PowerShell lub interfejsu wiersza polecenia platformy Azure (interfejs wiersza polecenia platformy Azure).

Szablon usługi Azure Resource Manager to plik JavaScript Object Notation (JSON), który definiuje infrastrukturę i konfigurację projektu. W szablonie używana jest składnia deklaratywna. 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

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

  • Wymagane jest konto platformy Azure z aktywną subskrypcją. Jeśli jeszcze go nie masz, możesz bezpłatnie utworzyć konto.

  • Możliwość przypisywania ról administratora dostępu użytkowników i współautora. Jeśli nie masz takiej możliwości, skontaktuj się z administratorem firmy Microsoft Entra, aby zarządzać rolami.

  • Konto Red Hat. Jeśli go nie masz, musisz zarejestrować się na koncie.

  • Wpis tajny ściągania dla klastra usługi Azure Red Hat OpenShift. Pobierz plik wpisu tajnego ściągania z witryny internetowej Menedżera klastra Red Hat OpenShift.

  • Jeśli chcesz uruchomić kod programu Azure PowerShell lokalnie, program Azure PowerShell.

  • Jeśli chcesz uruchomić kod interfejsu wiersza polecenia platformy Azure lokalnie:

Tworzenie szablonu usługi ARM lub pliku Bicep

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

Tworzenie szablonu usługi Resource Manager

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 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')]"
         }
    }
}

Tworzenie pliku Bicep

W poniższym przykładzie pokazano, jak plik Bicep platformy Azure powinien wyglądać po skonfigurowaniu klastra usługi 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 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
  ]
}

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

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.

Właściwości opis Prawidłowe opcje Wartość domyślna
domain Prefiks domeny dla klastra. Brak
pullSecret Wpis tajny ściągania uzyskany z witryny internetowej Menedżera klastra Red Hat OpenShift.
clusterName Nazwa klastra.
aadClientId Identyfikator aplikacji (identyfikator GUID) aplikacji klienckiej firmy Microsoft Entra.
aadObjectId Identyfikator obiektu (IDENTYFIKATOR GUID) jednostki usługi dla aplikacji klienckiej Firmy Microsoft Entra.
aadClientSecret Wpis tajny klienta jednostki usługi dla aplikacji klienckiej Firmy Microsoft Entra jako bezpieczny ciąg.
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.

Właściwości opis Prawidłowe opcje Wartość domyślna
location Lokalizacja nowego klastra usługi ARO. Ta lokalizacja może być taka sama jak lub inna niż region grupy zasobów. eastus
clusterVnetName Nazwa sieci wirtualnej klastra ARO. aro-vnet
clusterVnetCidr Przestrzeń adresowa sieci wirtualnej ARO w notacji CiDR (Classless Inter-Domain Routing ). 10.100.0.0/15
workerSubnetCidr Przestrzeń adresowa podsieci węzła procesu 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. Standardowa_D8s_v3
workerVmSize Typ/rozmiar maszyny wirtualnej węzła roboczego. Standardowa_D4s_v3
workerVmDiskSize Rozmiar dysku węzła roboczego w gigabajtach. 128
workerCount Liczba węzłów roboczych. 3
podCidr Przestrzeń adresowa zasobników 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). Publiczne
ingressVisibility Widoczność ruchu przychodzącego (wejście) (Public lub Private). Publiczne

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

Ten szablon używa tekstu tajnego ściągania uzyskanego z witryny internetowej Menedżera klastra Red Hat OpenShift. Przed kontynuowaniem upewnij się, że klucz tajny ściągania został zapisany lokalnie 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 ARO 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

Tworzenie nowej jednostki usługi i przypisywanie ról — 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'

Pobieranie hasła jednostki usługi — PowerShell

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

Pobieranie jednostki 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 platformy 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ń w tym artykule może być konieczne uruchomienie az login polecenia. 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

Ten szablon będzie używać tekstu tajnego ściągania uzyskanego z witryny internetowej Menedżera klastra Red Hat OpenShift. Przed kontynuowaniem upewnij się, że wpis tajny został 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

Tworzenie nowej grupy zasobów — interfejs wiersza polecenia platformy Azure

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

Tworzenie jednostki usługi dla nowej aplikacji Firmy Microsoft Entra

  • Interfejs wiersza polecenia platformy 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')

Przypisywanie roli Współautor do nowej jednostki usługi — interfejs wiersza polecenia platformy 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'

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

Nawiązywanie połączenia z klastrem — interfejs wiersza polecenia platformy Azure

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 — interfejs wiersza polecenia platformy Azure

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

Napiwek

Masz problemy? Poinformuj nas o usłudze GitHub, otwierając problem w repozytorium Azure Red Hat Openshift (ARO).

Następne 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.