Tworzenie klastra Azure Red Hat OpenShift z hostowanymi płaszczyznami sterowania (wersja zapoznawcza)

W tym artykule opisano sposób tworzenia Azure Red Hat OpenShift z hostowanymi płaszczyznami sterowania (HCP) przy użyciu Azure CLI lub pliku Bicep.

Plik Bicep definiuje wszystkie zasoby Azure wymagane dla klastra, w tym infrastrukturę sieci, tożsamości zarządzane, przypisania ról, konfigurację klastra i pulę węzłów.

Polecenia interfejsu wiersza poleceń tworzą wszystkie zasoby platformy Azure wymagane przez klaster, w tym infrastrukturę sieciową, tożsamości zarządzane, przypisania ról, konfigurację klastra i pulę węzłów.

Wymagania wstępne

Przygotowywanie środowiska

Przed utworzeniem klastra sprawdź, czy środowisko Azure spełnia następujące wymagania.

Azure CLI

Upewnij się, że używasz interfejsu wiersza polecenia platformy Azure w wersji 2.67.0 lub nowszej. Użyj az --version polecenia , aby sprawdzić zainstalowaną wersję. Aby zainstalować lub uaktualnić, zobacz Install Azure CLI.

Rozszerzenie CLI ARO HCP

  1. Zainstaluj rozszerzenie.

    az extension add --name aro

  2. Sprawdź, czy rozszerzenie jest zainstalowane:

    az aro hcp -h

Limit przydziału zasobów

Azure Red Hat OpenShift z hostowanymi płaszczyznami sterowania wymaga co najmniej 20 rdzeni do utworzenia i uruchomienia klastra. Domyślny limit przydziału zasobów platformy Azure dla nowej subskrypcji platformy Azure nie spełnia tego wymagania. Aby zażądać zwiększenia limitu zasobów, zobacz Limit przydziału Standard: Zwiększ limity według serii maszyn wirtualnych. Sprawdź, czy masz wystarczający przydział dla rodziny maszyn wirtualnych wybranej z obsługiwanych rozmiarów maszyn wirtualnych węzłów roboczych.

Aby sprawdzić bieżący limit przydziału dla domyślnej rodziny maszyn wirtualnych:

LOCATION=eastus
az vm list-usage -l $LOCATION \
  --query "[?contains(name.value, 'standardDSv5Family')]" -o table

Uprawnienia

Potrzebujesz uprawnień współautora i administratora dostępu użytkowników lub uprawnień właściciela w grupie zasobów lub subskrypcji, w której tworzysz klaster. Te uprawnienia są wymagane do utworzenia grupy zasobów, sieci wirtualnej, tożsamości zarządzanych i przypisań ról.

Aby uzyskać więcej informacji, zobacz Weryfikowanie uprawnień.

Zarejestruj dostawców zasobów

Zarejestruj następujących dostawców zasobów w subskrypcji Azure:

  • Microsoft.RedHatOpenShift
  • Microsoft.Compute
  • Microsoft.Storage
  • Microsoft.Authorization

Aby sprawdzić, czy dostawca zasobów jest zarejestrowany:

az provider list --query "[?namespace=='Microsoft.RedHatOpenShift'].registrationState" \
  --output table

Jeśli znajdziesz żadnych dostawców zasobów, którzy nie są zarejestrowani, zarejestruj je.

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

Aby uzyskać więcej informacji na temat rejestrowania dostawców zasobów, zobacz Rejestrowanie dostawców zasobów.

Ustawianie zmiennych środowiskowych

Ustaw następujące zmienne środowiskowe, aby zdefiniować nazwy tworzonych zasobów. Zastąp wartości zastępcze własnymi.

# Azure resource location and subscription
LOCATION="<region>"
SUBSCRIPTION_ID="$(az account show --query id --output tsv)"
CUSTOMER_RG_NAME="<resource-group-name>"

# Network resources
CUSTOMER_NSG="<nsg-name>"
CUSTOMER_VNET_NAME="<vnet-name>"
CUSTOMER_VNET_SUBNET1="<worker-subnet-name>"
CUSTOMER_VNET_INTEGRATION_SUBNET_NAME="<vnet-integration-subnet-name>"

# Cluster and node pool
CLUSTER_NAME="<cluster-name>"
MANAGED_RESOURCE_GROUP="${CLUSTER_NAME}-managed-rg"
NP_NAME="<node-pool-name>"
CLUSTER_VERSION="<major.minor>"    # Example: 4.22
NP_VERSION="<major.minor.patch>"   # Example: 4.22.1

Note

Aby uzyskać więcej informacji na temat wymagań dotyczących wersji klastra i puli węzłów, zapoznaj się z obsługiwanymi kombinacjami wersji.

Note

Aby uzyskać listę obsługiwanych regionów, zobacz Wybieranie regionu klastra.

Tworzenie grupy zasobów

Utwórz grupę zasobów do przechowywania zasobów klastra, sieci wirtualnej i tożsamości zarządzanych.

az group create \
  --name "${CUSTOMER_RG_NAME}" \
  --subscription "${SUBSCRIPTION_ID}" \
  --location "${LOCATION}"

Tworzenie pliku Bicep

Utwórz plik o nazwie azuredeploy.bicep z następującą zawartością. Ten szablon Bicep definiuje wszystkie zasoby wymagane do wdrożenia Azure Red Hat OpenShift z hostowanym klastrem płaszczyzn sterowania, w tym sieciową grupą zabezpieczeń, siecią wirtualną, tożsamościami zarządzanymi, przypisaniami ról, Key Vault, kluczem szyfrowania usługi KMS, klastrem i pulą węzłów.

Szablon wdraża klaster z siecią OVN-Kubernetes, domyślnymi zakresami CIDR, szyfrowaniem etcd zarządzanym przez klienta, wychodzącą łącznością modułu równoważenia obciążenia oraz jedną pulą węzłów z dwoma Standard_D8s_v6 węzłami roboczymi.

Aby dostosować konfigurację klastra lub puli węzłów, zobacz informacje o pliku Bicep.

Note

Jeśli dodasz reguły niestandardowe do sieciowej grupy zabezpieczeń, upewnij się, że sieciowa grupa zabezpieczeń zezwala na ruch opisany w sekcji Wymagany ruch sieciowej grupy zabezpieczeń.

@description('Network Security Group Name')
param customerNsgName string

@description('Virtual Network Name')
param customerVnetName string

@description('Subnet Name')
param customerVnetSubnetName string

@description('Virtual Network Integration Subnet Name')
param customerVirtualNetworkIntegrationSubnetName string

@description('Name of the cluster')
param clusterName string

@description('The cluster managed resource group name')
param managedResourceGroupName string

@description('The name of the node pool')
param nodePoolName string

@description('The OpenShift version for the cluster (X.Y format, e.g. 4.20)')
param clusterVersion string

@description('The OpenShift version for the node pool (X.Y.Z format, e.g. 4.20.8)')
param nodePoolVersion string

@description('Deploy ARO HCP with a private key vault')
param privateKeyVault bool

@description('API server visibility')
@allowed([
  'Public'
  'Private'
])
param apiVisibility string = 'Public'

@description('Default ingress type')
@allowed([
  'Public'
  'Private'
])
param ingressType string = 'Public'

@description('Cryptographic restrictions for kernel and userspace libraries (immutable after creation)')
@allowed(['None', 'FIPS'])
param cryptoRestrictions string = 'None'


var etcdEncryptionKeyName = 'etcd-data-kms-encryption-key'
var randomSuffix = toLower(uniqueString(clusterName))
var randomKeyVaultSuffix = toLower(uniqueString(resourceGroup().id))
var customerKeyVaultName string = 'cust-kv-${randomKeyVaultSuffix}'
var addressPrefix = '10.0.0.0/16'
var subnetPrefix = '10.0.0.0/24'
var virtualNetworkIntegrationSubnetPrefix = '10.0.1.0/24'


// Network Security Group
resource customerNsg 'Microsoft.Network/networkSecurityGroups@2023-05-01' = {
  name: customerNsgName
  location: resourceGroup().location
}

// Virtual network with worker subnet and VNet integration subnet
resource customerVnet 'Microsoft.Network/virtualNetworks@2023-05-01' = {
  name: customerVnetName
  location: resourceGroup().location
  properties: {
    addressSpace: {
      addressPrefixes: [
        addressPrefix
      ]
    }
    subnets: [
      {
        name: customerVnetSubnetName
        properties: {
          addressPrefix: subnetPrefix
          networkSecurityGroup: {
            id: customerNsg.id
          }
        }
      }
      {
        name: customerVirtualNetworkIntegrationSubnetName
        properties: {
          addressPrefix: virtualNetworkIntegrationSubnetPrefix
          networkSecurityGroup: {
            id: customerNsg.id
          }
          delegations: [
            {
              name: 'aro-hcp-delegation'
              properties: {
                serviceName: 'Microsoft.RedHatOpenShift/hcpOpenShiftClusters'
              }
            }
          ]
        }
      }
    ]
  }
}

resource subnet 'Microsoft.Network/virtualNetworks/subnets@2022-07-01' existing = {
  name: customerVnetSubnetName
  parent: customerVnet
}

resource vnetIntegrationSubnet 'Microsoft.Network/virtualNetworks/subnets@2022-07-01' existing = {
  name: customerVirtualNetworkIntegrationSubnetName
  parent: customerVnet
}

resource customerKeyVault 'Microsoft.KeyVault/vaults@2024-12-01-preview' = {
  name: customerKeyVaultName
  location: resourceGroup().location
  properties: {
    enableRbacAuthorization: true
    tenantId: subscription().tenantId
    publicNetworkAccess: privateKeyVault ? 'Disabled' : 'Enabled'
    sku: {
      family: 'A'
      name: 'standard'
    }
  }
}

resource etcdEncryptionKey 'Microsoft.KeyVault/vaults/keys@2024-12-01-preview' = {
  parent: customerKeyVault
  name: 'etcd-data-kms-encryption-key'
  properties: {
    kty: 'RSA'
    keySize: 2048
  }
}

resource privateEndpointDnsZone 'Microsoft.Network/privateDnsZones@2020-06-01' = if (privateKeyVault) {
  name: 'privatelink.vaultcore.azure.net'
  location: 'global'
  properties: {}
  dependsOn: [
    privateEndpoint
  ]
}

resource privateEndpoint 'Microsoft.Network/privateEndpoints@2023-09-01' = if (privateKeyVault) {
  name: 'kv-private-endpoint'
  properties: {
    privateLinkServiceConnections: [
      {
        name: 'kv-private-endpoint'
        properties: {
          privateLinkServiceId: customerKeyVault.id
          groupIds: ['vault']
        }
      }
    ]
    subnet: {
      id: customerVnet.properties.subnets[0].id
    }
  }
  location: resourceGroup().location
}

resource privateEndpointDnsGroup 'Microsoft.Network/privateEndpoints/privateDnsZoneGroups@2023-09-01' = if (privateKeyVault) {
  name: 'kv-private-ep-dns-group'
  parent: privateEndpoint
  properties: {
    privateDnsZoneConfigs: [
      {
        name: 'config1'
        properties: {
          privateDnsZoneId: privateEndpointDnsZone.id
        }
      }
    ]
  }
  dependsOn: [
    privateDnsZoneVnetLink
  ]
}

resource privateDnsZoneVnetLink 'Microsoft.Network/privateDnsZones/virtualNetworkLinks@2020-06-01' = if (privateKeyVault) {
  name: uniqueString('kv-private-dns-zone-link')
  parent: privateEndpointDnsZone
  location: 'global'
  properties: {
    registrationEnabled: false
    virtualNetwork: {
      id: customerVnet.id
    }
  }
}

//
// Control plane identities
//

// Reader
var readerRoleId = subscriptionResourceId(
  'Microsoft.Authorization/roleDefinitions',
  'acdd72a7-3385-48ef-bd42-f606fba81ae7'
)

//
// Cluster API Azure managed identity
//

resource clusterApiAzureMi 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: '${clusterName}-cp-cluster-api-azure-${randomSuffix}'
  location: resourceGroup().location
}

// Azure Red Hat OpenShift with hosted control planes Cluster API Provider
var hcpClusterApiProviderRoleId = subscriptionResourceId(
  'Microsoft.Authorization/roleDefinitions',
  '88366f10-ed47-4cc0-9fab-c8a06148393e'
)

resource hcpClusterApiProviderRoleVnetAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, clusterApiAzureMi.id, hcpClusterApiProviderRoleId, customerVnet.id)
  scope: customerVnet
  properties: {
    principalId: clusterApiAzureMi.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: hcpClusterApiProviderRoleId
  }
}

resource serviceManagedIdentityReaderOnClusterApiAzureMi 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, serviceManagedIdentity.id, readerRoleId, clusterApiAzureMi.id)
  scope: clusterApiAzureMi
  properties: {
    principalId: serviceManagedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: readerRoleId
  }
}

//
// KMS managed identity
//

resource kmsMi 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: '${clusterName}-cp-kms-${randomSuffix}'
  location: resourceGroup().location
}

// Key Vault Crypto User
var keyVaultCryptoUserRoleId = subscriptionResourceId(
  'Microsoft.Authorization/roleDefinitions',
  '12338af0-0e69-4776-bea7-57ae8d297424'
)

resource keyVaultCryptoUserToKeyVaultRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, kmsMi.id, keyVaultCryptoUserRoleId, customerKeyVault.id)
  scope: customerKeyVault
  properties: {
    principalId: kmsMi.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: keyVaultCryptoUserRoleId
  }
}

resource serviceManagedIdentityReaderOnKmsMi 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, serviceManagedIdentity.id, readerRoleId, kmsMi.id)
  scope: kmsMi
  properties: {
    principalId: serviceManagedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: readerRoleId
  }
}

//
// Control plane operator managed identity
//

resource controlPlaneMi 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: '${clusterName}-cp-control-plane-${randomSuffix}'
  location: resourceGroup().location
}

// Azure Red Hat OpenShift with hosted control planes Control Plane Operator
var hcpControlPlaneOperatorRoleId = subscriptionResourceId(
  'Microsoft.Authorization/roleDefinitions',
  'fc0c873f-45e9-4d0d-a7d1-585aab30c6ed'
)

resource hcpControlPlaneOperatorVnetRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, controlPlaneMi.id, hcpControlPlaneOperatorRoleId, customerVnet.id)
  scope: customerVnet
  properties: {
    principalId: controlPlaneMi.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: hcpControlPlaneOperatorRoleId
  }
}

resource hcpControlPlaneOperatorNsgRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, controlPlaneMi.id, hcpControlPlaneOperatorRoleId, customerNsg.id)
  scope: customerNsg
  properties: {
    principalId: controlPlaneMi.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: hcpControlPlaneOperatorRoleId
  }
}

resource serviceManagedIdentityReaderOnControlPlaneMi 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, serviceManagedIdentity.id, readerRoleId, controlPlaneMi.id)
  scope: controlPlaneMi
  properties: {
    principalId: serviceManagedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: readerRoleId
  }
}

//
// Cloud controller manager managed identity
//

resource cloudControllerManagerMi 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: '${clusterName}-cp-cloud-controller-manager-${randomSuffix}'
  location: resourceGroup().location
}

// Azure Red Hat OpenShift Cloud Controller Manager
var cloudControllerManagerRoleId = subscriptionResourceId(
  'Microsoft.Authorization/roleDefinitions',
  'a1f96423-95ce-4224-ab27-4e3dc72facd4'
)

resource cloudControllerManagerRoleNsgAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, cloudControllerManagerMi.id, cloudControllerManagerRoleId, customerNsg.id)
  scope: customerNsg
  properties: {
    principalId: cloudControllerManagerMi.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: cloudControllerManagerRoleId
  }
}

resource cloudControllerManagerRoleVnetAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, cloudControllerManagerMi.id, cloudControllerManagerRoleId, customerVnet.id)
  scope: customerVnet
  properties: {
    principalId: cloudControllerManagerMi.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: cloudControllerManagerRoleId
  }
}

resource serviceManagedIdentityReaderOnCloudControllerManagerMi 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, serviceManagedIdentity.id, readerRoleId, cloudControllerManagerMi.id)
  scope: cloudControllerManagerMi
  properties: {
    principalId: serviceManagedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: readerRoleId
  }
}

//
// Ingress managed identity
//

resource ingressMi 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: '${clusterName}-cp-ingress-${randomSuffix}'
  location: resourceGroup().location
}

// Azure Red Hat OpenShift Cluster Ingress Operator
var ingressOperatorRoleId = subscriptionResourceId(
  'Microsoft.Authorization/roleDefinitions',
  '0336e1d3-7a87-462b-b6db-342b63f7802c'
)

// Azure Red Hat OpenShift Image Registry Operator
var imageRegistryOperatorRoleId = subscriptionResourceId(
  'Microsoft.Authorization/roleDefinitions',
  '8b32b316-c2f5-4ddf-b05b-83dacd2d08b5'
)

resource ingressOperatorRoleVnetAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, ingressMi.id, ingressOperatorRoleId, customerVnet.id)
  scope: customerVnet
  properties: {
    principalId: ingressMi.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: ingressOperatorRoleId
  }
}

resource serviceManagedIdentityReaderOnIngressMi 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, serviceManagedIdentity.id, readerRoleId, ingressMi.id)
  scope: ingressMi
  properties: {
    principalId: serviceManagedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: readerRoleId
  }
}

//
// Disk CSI driver managed identity
//

resource diskCsiDriverMi 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: '${clusterName}-cp-disk-csi-driver-${randomSuffix}'
  location: resourceGroup().location
}

resource serviceManagedIdentityReaderOnDiskCsiDriverMi 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, serviceManagedIdentity.id, readerRoleId, diskCsiDriverMi.id)
  scope: diskCsiDriverMi
  properties: {
    principalId: serviceManagedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: readerRoleId
  }
}

//
// File CSI driver managed identity
//

resource fileCsiDriverMi 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: '${clusterName}-cp-file-csi-driver-${randomSuffix}'
  location: resourceGroup().location
}

// Azure Red Hat OpenShift File Storage Operator
var fileStorageOperatorRoleId = subscriptionResourceId(
  'Microsoft.Authorization/roleDefinitions',
  '0d7aedc0-15fd-4a67-a412-efad370c947e'
)

resource fileStorageOperatorRoleNsgAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, fileCsiDriverMi.id, fileStorageOperatorRoleId, customerNsg.id)
  scope: customerNsg
  properties: {
    principalId: fileCsiDriverMi.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: fileStorageOperatorRoleId
  }
}

resource fileStorageOperatorRoleVnetAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, fileCsiDriverMi.id, fileStorageOperatorRoleId, customerVnet.id)
  scope: customerVnet
  properties: {
    principalId: fileCsiDriverMi.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: fileStorageOperatorRoleId
  }
}

resource serviceManagedIdentityReaderOnFileCsiDriverMi 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, serviceManagedIdentity.id, readerRoleId, fileCsiDriverMi.id)
  scope: fileCsiDriverMi
  properties: {
    principalId: serviceManagedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: readerRoleId
  }
}

//
// Image registry managed identity
//

resource imageRegistryMi 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: '${clusterName}-cp-image-registry-${randomSuffix}'
  location: resourceGroup().location
}

resource serviceManagedIdentityReaderOnImageRegistryMi 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, serviceManagedIdentity.id, readerRoleId, imageRegistryMi.id)
  scope: imageRegistryMi
  properties: {
    principalId: serviceManagedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: readerRoleId
  }
}

resource imageRegistryOperatorRoleVnetAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, imageRegistryMi.id, imageRegistryOperatorRoleId, customerVnet.id)
  scope: customerVnet
  properties: {
    principalId: imageRegistryMi.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: imageRegistryOperatorRoleId
  }
}

//
// Cloud network config managed identity
//

resource cloudNetworkConfigMi 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: '${clusterName}-cp-cloud-network-config-${randomSuffix}'
  location: resourceGroup().location
}

// Azure Red Hat OpenShift Network Operator
var networkOperatorRoleId = subscriptionResourceId(
  'Microsoft.Authorization/roleDefinitions',
  'be7a6435-15ae-4171-8f30-4a343eff9e8f'
)

resource networkOperatorRoleVnetAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, cloudNetworkConfigMi.id, networkOperatorRoleId, customerVnet.id)
  scope: customerVnet
  properties: {
    principalId: cloudNetworkConfigMi.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: networkOperatorRoleId
  }
}

resource serviceManagedIdentityReaderOnCloudNetworkMi 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, serviceManagedIdentity.id, readerRoleId, cloudNetworkConfigMi.id)
  scope: cloudNetworkConfigMi
  properties: {
    principalId: serviceManagedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: readerRoleId
  }
}

//
// Data plane identities
//

// Azure Red Hat OpenShift Federated Credential
var federatedCredentialsRoleId = subscriptionResourceId(
  'Microsoft.Authorization/roleDefinitions',
  'ef318e2a-8334-4a05-9e4a-295a196c6a6e'
)

resource dpDiskCsiDriverMi 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: '${clusterName}-dp-disk-csi-driver-${randomSuffix}'
  location: resourceGroup().location
}

resource dpDiskCsiDriverMiFederatedCredentialsRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, dpDiskCsiDriverMi.id, federatedCredentialsRoleId)
  scope: dpDiskCsiDriverMi
  properties: {
    principalId: serviceManagedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: federatedCredentialsRoleId
  }
}

resource dpFileCsiDriverMi 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: '${clusterName}-dp-file-csi-driver-${randomSuffix}'
  location: resourceGroup().location
}

resource dpFileCsiDriverMiFederatedCredentialsRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, dpFileCsiDriverMi.id, federatedCredentialsRoleId)
  scope: dpFileCsiDriverMi
  properties: {
    principalId: serviceManagedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: federatedCredentialsRoleId
  }
}

resource dpFileCsiDriverFileStorageOperatorRoleNsgAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, dpFileCsiDriverMi.id, fileStorageOperatorRoleId, customerNsg.id)
  scope: customerNsg
  properties: {
    principalId: dpFileCsiDriverMi.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: fileStorageOperatorRoleId
  }
}

resource dpFileCsiDriverFileStorageOperatorRoleVnetAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, dpFileCsiDriverMi.id, fileStorageOperatorRoleId, customerVnet.id)
  scope: customerVnet
  properties: {
    principalId: dpFileCsiDriverMi.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: fileStorageOperatorRoleId
  }
}

resource dpImageRegistryMi 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: '${clusterName}-dp-image-registry-${randomSuffix}'
  location: resourceGroup().location
}

resource dpImageRegistryMiFederatedCredentialsRoleAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, dpImageRegistryMi.id, federatedCredentialsRoleId)
  scope: dpImageRegistryMi
  properties: {
    principalId: serviceManagedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: federatedCredentialsRoleId
  }
}

resource dpImageRegistryOperatorRoleVnetAssignment 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, dpImageRegistryMi.id, imageRegistryOperatorRoleId, customerVnet.id)
  scope: customerVnet
  properties: {
    principalId: dpImageRegistryMi.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: imageRegistryOperatorRoleId
  }
}

//
// Service managed identity
//

resource serviceManagedIdentity 'Microsoft.ManagedIdentity/userAssignedIdentities@2023-01-31' = {
  name: '${clusterName}-service-managed-identity-${randomSuffix}'
  location: resourceGroup().location
}

// Azure Red Hat OpenShift with hosted control planes Service Managed Identity
var hcpServiceManagedIdentityRoleId = subscriptionResourceId(
  'Microsoft.Authorization/roleDefinitions',
  'c0ff367d-66d8-445e-917c-583feb0ef0d4'
)

resource serviceManagedIdentityRoleAssignmentVnet 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, serviceManagedIdentity.id, hcpServiceManagedIdentityRoleId, customerVnet.id)
  scope: customerVnet
  properties: {
    principalId: serviceManagedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: hcpServiceManagedIdentityRoleId
  }
}

resource serviceManagedIdentityRoleAssignmentNSG 'Microsoft.Authorization/roleAssignments@2022-04-01' = {
  name: guid(resourceGroup().id, serviceManagedIdentity.id, hcpServiceManagedIdentityRoleId, customerNsg.id)
  scope: customerNsg
  properties: {
    principalId: serviceManagedIdentity.properties.principalId
    principalType: 'ServicePrincipal'
    roleDefinitionId: hcpServiceManagedIdentityRoleId
  }
}


// Cluster resource
resource hcp 'Microsoft.RedHatOpenShift/hcpOpenShiftClusters@2026-09-01-preview' = {
  name: clusterName
  location: resourceGroup().location
  properties: {
    version: {
      id: clusterVersion
      channelGroup: 'stable'
    }
    dns: {}
    network: {
      networkType: 'OVNKubernetes'
      podCidr: '10.128.0.0/14'
      serviceCidr: '172.30.0.0/16'
      machineCidr: '10.0.0.0/16'
      hostPrefix: 23
    }
    etcd: {
      dataEncryption: {
        keyManagementMode: 'CustomerManaged'
        customerManaged: {
          encryptionType: 'KMS'
          kms: {
            activeKey: {
              name: etcdEncryptionKeyName
              version: last(split(etcdEncryptionKey.properties.keyUriWithVersion, '/'))
            }
            vaultName: customerKeyVaultName
            visibility: privateKeyVault ? 'Private' : 'Public'
          }
        }
      }
    }
    api: {
      visibility: apiVisibility
    }
    ingress: {
      type: ingressType
    }
    cryptoRestrictions: cryptoRestrictions
    clusterImageRegistry: {
      state: 'Enabled'
    }
    platform: {
      managedResourceGroup: managedResourceGroupName
      subnetId: subnet.id
      vnetIntegrationSubnetId: vnetIntegrationSubnet.id
      outboundType: 'LoadBalancer'
      networkSecurityGroupId: customerNsg.id
      operatorsAuthentication: {
        userAssignedIdentities: {
          controlPlaneOperators: {
            'cluster-api-azure': clusterApiAzureMi.id
            'control-plane': controlPlaneMi.id
            'cloud-controller-manager': cloudControllerManagerMi.id
            ingress: ingressMi.id
            'disk-csi-driver': diskCsiDriverMi.id
            'file-csi-driver': fileCsiDriverMi.id
            'image-registry': imageRegistryMi.id
            'cloud-network-config': cloudNetworkConfigMi.id
            kms: kmsMi.id
          }
          dataPlaneOperators: {
            'disk-csi-driver': dpDiskCsiDriverMi.id
            'file-csi-driver': dpFileCsiDriverMi.id
            'image-registry': dpImageRegistryMi.id
          }
          serviceManagedIdentity: serviceManagedIdentity.id
        }
      }
    }
  }
  identity: {
    type: 'UserAssigned'
    userAssignedIdentities: {
      '${serviceManagedIdentity.id}': {}
      '${clusterApiAzureMi.id}': {}
      '${controlPlaneMi.id}': {}
      '${cloudControllerManagerMi.id}': {}
      '${ingressMi.id}': {}
      '${diskCsiDriverMi.id}': {}
      '${fileCsiDriverMi.id}': {}
      '${imageRegistryMi.id}': {}
      '${cloudNetworkConfigMi.id}': {}
      '${kmsMi.id}': {}
    }
  }
  dependsOn: [
    hcpClusterApiProviderRoleVnetAssignment
    keyVaultCryptoUserToKeyVaultRoleAssignment
    hcpControlPlaneOperatorVnetRoleAssignment
    hcpControlPlaneOperatorNsgRoleAssignment
    cloudControllerManagerRoleNsgAssignment
    cloudControllerManagerRoleVnetAssignment
    ingressOperatorRoleVnetAssignment
    fileStorageOperatorRoleNsgAssignment
    fileStorageOperatorRoleVnetAssignment
    networkOperatorRoleVnetAssignment
    dpDiskCsiDriverMiFederatedCredentialsRoleAssignment
    dpFileCsiDriverMiFederatedCredentialsRoleAssignment
    dpImageRegistryMiFederatedCredentialsRoleAssignment
    serviceManagedIdentityRoleAssignmentVnet
    serviceManagedIdentityRoleAssignmentNSG
    dpFileCsiDriverFileStorageOperatorRoleNsgAssignment
    dpFileCsiDriverFileStorageOperatorRoleVnetAssignment
    imageRegistryOperatorRoleVnetAssignment
    dpImageRegistryOperatorRoleVnetAssignment
    serviceManagedIdentityReaderOnControlPlaneMi
    serviceManagedIdentityReaderOnCloudControllerManagerMi
    serviceManagedIdentityReaderOnIngressMi
    serviceManagedIdentityReaderOnDiskCsiDriverMi
    serviceManagedIdentityReaderOnFileCsiDriverMi
    serviceManagedIdentityReaderOnImageRegistryMi
    serviceManagedIdentityReaderOnCloudNetworkMi
    serviceManagedIdentityReaderOnClusterApiAzureMi
    serviceManagedIdentityReaderOnKmsMi
  ]
}

// Node pool resource
resource nodepool 'Microsoft.RedHatOpenShift/hcpOpenShiftClusters/nodePools@2026-09-01-preview' = {
  parent: hcp
  name: nodePoolName
  location: resourceGroup().location
  properties: {
    version: {
      id: nodePoolVersion
      channelGroup: 'stable'
    }
    platform: {
      subnetId: hcp.properties.platform.subnetId
      vmSize: 'Standard_D8s_v6'
      osDisk: {
        sizeGiB: 64
        diskStorageAccountType: 'StandardSSD_LRS'
      }
    }
    replicas: 2
  }
}

Wdróż plik Bicep

Wdróż szablon Bicep, aby utworzyć klaster i wszystkie wymagane zasoby.

az deployment group create \
  --name 'aro-hcp' \
  --subscription "${SUBSCRIPTION_ID}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --template-file azuredeploy.bicep \
  --parameters \
    customerNsgName="${CUSTOMER_NSG}" \
    customerVnetName="${CUSTOMER_VNET_NAME}" \
    customerVirtualNetworkIntegrationSubnetName="${CUSTOMER_VNET_INTEGRATION_SUBNET_NAME}" \
    customerVnetSubnetName="${CUSTOMER_VNET_SUBNET1}" \
    clusterName="${CLUSTER_NAME}" \
    managedResourceGroupName="${MANAGED_RESOURCE_GROUP}" \
    nodePoolName="${NP_NAME}" \
    clusterVersion="${CLUSTER_VERSION}" \
    nodePoolVersion="${NP_VERSION}" \
    apiVisibility="<Public-or-Private>" \
    ingressType="<Public-or-Private>" \
    privateKeyVault=<true-or-false> \
    cryptoRestrictions="<None-or-FIPS>"

Ustaw Public na apiVisibility dla serwera API dostępnego z Internetu lub na Private dla serwera API dostępnego wyłącznie przez połączenie z siecią prywatną.

Ustaw Public na ingressType dla tras aplikacji dostępnych z Internetu lub na Private dla tras aplikacji dostępnych tylko przez połączenie z siecią prywatną.

Ustaw privateKeyVault na wartość true, aby ograniczyć dostęp do usługi Key Vault wyłącznie do prywatnego punktu końcowego, lub na wartość false, aby zezwolić na dostęp publiczny. Jeśli ustawisz privateKeyVault na true, szablon Bicep wyłączy publiczny dostęp do usługi Key Vault, wdroży zasoby prywatnego punktu końcowego i ustawi widoczność magazynu na Private w klastrze.

Ustaw wartość cryptoRestrictions na FIPS, aby ograniczyć klaster do modułów kryptograficznych zweryfikowanych zgodnie z FIPS, lub na None (ustawienie domyślne), aby wdrożyć bez ograniczeń FIPS. To ustawienie jest niezmienne po utworzeniu klastra.

Note

Płaszczyzna sterowania jest zawsze hostowana w klastrze obsługującym standard FIPS niezależnie od tego ustawienia. Parametr cryptoRestrictions określa, czy pule węzłów roboczych używają modułów kryptograficznych zweryfikowanych zgodnie z FIPS.

Wdrożenie zwykle trwa od 15 do 20 minut.

Weryfikowanie wdrożenia

Po zakończeniu wdrażania sprawdź, czy klaster i pula węzłów zostały utworzone pomyślnie.

  1. Sprawdź, czy klaster został pomyślnie utworzony.

    az aro hcp cluster show \
  --name "${CLUSTER_NAME}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --query "properties.provisioningState" \
  --output tsv

    Gdy klaster jest gotowy, dane wyjściowe to Succeeded.

  2. Sprawdź, czy pula węzłów została pomyślnie utworzona.

    az aro hcp cluster nodepool show \
  --cluster-name "${CLUSTER_NAME}" \
  --name "${NP_NAME}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --query "properties.provisioningState" \
  --output tsv

    Gdy pula węzłów będzie gotowa, wynikiem będzie Succeeded.

Tworzenie infrastruktury sieci

Utwórz grupę zabezpieczeń sieci, sieć wirtualną z podsiecią roboczą oraz podsieć integracji z siecią VNet z delegowaniem.

  1. Utwórz sieciową grupę zabezpieczeń.

    Note

    Jeśli dodasz reguły niestandardowe do grupy zabezpieczeń sieciowych (NSG), upewnij się, że reguły te zezwalają na ruch opisany w Wymagany ruch dla grupy zabezpieczeń sieciowych.

    az network nsg create \
  --name "${CUSTOMER_NSG}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --location "${LOCATION}"

  2. Utwórz sieć wirtualną z podsiecią roboczą.

    az network vnet create \
  --name "${CUSTOMER_VNET_NAME}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --location "${LOCATION}" \
  --address-prefixes 10.0.0.0/16 \
  --subnet-name "${CUSTOMER_VNET_SUBNET1}" \
  --subnet-prefixes 10.0.0.0/24 \
  --nsg "${CUSTOMER_NSG}"

  3. Utwórz podsieć integracji VNet z wymaganą delegacją.

    az network vnet subnet create \
  --name "${CUSTOMER_VNET_INTEGRATION_SUBNET_NAME}" \
  --vnet-name "${CUSTOMER_VNET_NAME}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --address-prefixes 10.0.1.0/24 \
  --delegations Microsoft.RedHatOpenShift/hcpOpenShiftClusters

  4. Pobierz identyfikatory zasobów dla zasobów sieciowych.

    NSG_ID=$(az network nsg show \
  --name "${CUSTOMER_NSG}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --query id --output tsv)

SUBNET_ID=$(az network vnet subnet show \
  --name "${CUSTOMER_VNET_SUBNET1}" \
  --vnet-name "${CUSTOMER_VNET_NAME}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --query id --output tsv)

VNET_ID=$(az network vnet show \
  --name "${CUSTOMER_VNET_NAME}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --query id --output tsv)

VNET_INTEGRATION_SUBNET_ID=$(az network vnet subnet show \
  --name "${CUSTOMER_VNET_INTEGRATION_SUBNET_NAME}" \
  --vnet-name "${CUSTOMER_VNET_NAME}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --query id --output tsv)

Tworzenie tożsamości zarządzanych

Utwórz tożsamości zarządzane przypisane przez użytkownika dla operatorów klastra oraz tożsamość zarządzaną usługi. Aby uzyskać opis każdej tożsamości i jej przeznaczenia, zobacz Wymagane tożsamości zarządzane i przypisania ról.

# Control plane operator identities
az identity create --name "${CLUSTER_NAME}-cp-cluster-api-azure" --resource-group "${CUSTOMER_RG_NAME}"
az identity create --name "${CLUSTER_NAME}-cp-control-plane" --resource-group "${CUSTOMER_RG_NAME}"
az identity create --name "${CLUSTER_NAME}-cp-cloud-controller-manager" --resource-group "${CUSTOMER_RG_NAME}"
az identity create --name "${CLUSTER_NAME}-cp-ingress" --resource-group "${CUSTOMER_RG_NAME}"
az identity create --name "${CLUSTER_NAME}-cp-disk-csi-driver" --resource-group "${CUSTOMER_RG_NAME}"
az identity create --name "${CLUSTER_NAME}-cp-file-csi-driver" --resource-group "${CUSTOMER_RG_NAME}"
az identity create --name "${CLUSTER_NAME}-cp-image-registry" --resource-group "${CUSTOMER_RG_NAME}"
az identity create --name "${CLUSTER_NAME}-cp-cloud-network-config" --resource-group "${CUSTOMER_RG_NAME}"

# Data plane operator identities
az identity create --name "${CLUSTER_NAME}-dp-disk-csi-driver" --resource-group "${CUSTOMER_RG_NAME}"
az identity create --name "${CLUSTER_NAME}-dp-file-csi-driver" --resource-group "${CUSTOMER_RG_NAME}"
az identity create --name "${CLUSTER_NAME}-dp-image-registry" --resource-group "${CUSTOMER_RG_NAME}"

# Service managed identity
az identity create --name "${CLUSTER_NAME}-service-managed-identity" --resource-group "${CUSTOMER_RG_NAME}"

Pobierz identyfikatory zasobów i identyfikatory podmiotów zabezpieczeń dla tożsamości zarządzanych.

# Control plane identity resource IDs and principal IDs
CLUSTER_API_AZURE_MI_ID=$(az identity show --name "${CLUSTER_NAME}-cp-cluster-api-azure" --resource-group "${CUSTOMER_RG_NAME}" --query id --output tsv)
CLUSTER_API_AZURE_MI_PID=$(az identity show --name "${CLUSTER_NAME}-cp-cluster-api-azure" --resource-group "${CUSTOMER_RG_NAME}" --query principalId --output tsv)

CONTROL_PLANE_MI_ID=$(az identity show --name "${CLUSTER_NAME}-cp-control-plane" --resource-group "${CUSTOMER_RG_NAME}" --query id --output tsv)
CONTROL_PLANE_MI_PID=$(az identity show --name "${CLUSTER_NAME}-cp-control-plane" --resource-group "${CUSTOMER_RG_NAME}" --query principalId --output tsv)

CLOUD_CONTROLLER_MANAGER_MI_ID=$(az identity show --name "${CLUSTER_NAME}-cp-cloud-controller-manager" --resource-group "${CUSTOMER_RG_NAME}" --query id --output tsv)
CLOUD_CONTROLLER_MANAGER_MI_PID=$(az identity show --name "${CLUSTER_NAME}-cp-cloud-controller-manager" --resource-group "${CUSTOMER_RG_NAME}" --query principalId --output tsv)

INGRESS_MI_ID=$(az identity show --name "${CLUSTER_NAME}-cp-ingress" --resource-group "${CUSTOMER_RG_NAME}" --query id --output tsv)
INGRESS_MI_PID=$(az identity show --name "${CLUSTER_NAME}-cp-ingress" --resource-group "${CUSTOMER_RG_NAME}" --query principalId --output tsv)

DISK_CSI_DRIVER_MI_ID=$(az identity show --name "${CLUSTER_NAME}-cp-disk-csi-driver" --resource-group "${CUSTOMER_RG_NAME}" --query id --output tsv)

FILE_CSI_DRIVER_MI_ID=$(az identity show --name "${CLUSTER_NAME}-cp-file-csi-driver" --resource-group "${CUSTOMER_RG_NAME}" --query id --output tsv)
FILE_CSI_DRIVER_MI_PID=$(az identity show --name "${CLUSTER_NAME}-cp-file-csi-driver" --resource-group "${CUSTOMER_RG_NAME}" --query principalId --output tsv)

IMAGE_REGISTRY_MI_ID=$(az identity show --name "${CLUSTER_NAME}-cp-image-registry" --resource-group "${CUSTOMER_RG_NAME}" --query id --output tsv)
IMAGE_REGISTRY_MI_PID=$(az identity show --name "${CLUSTER_NAME}-cp-image-registry" --resource-group "${CUSTOMER_RG_NAME}" --query principalId --output tsv)

CLOUD_NETWORK_CONFIG_MI_ID=$(az identity show --name "${CLUSTER_NAME}-cp-cloud-network-config" --resource-group "${CUSTOMER_RG_NAME}" --query id --output tsv)
CLOUD_NETWORK_CONFIG_MI_PID=$(az identity show --name "${CLUSTER_NAME}-cp-cloud-network-config" --resource-group "${CUSTOMER_RG_NAME}" --query principalId --output tsv)

# Data plane identity resource IDs and principal IDs
DP_DISK_CSI_DRIVER_MI_ID=$(az identity show --name "${CLUSTER_NAME}-dp-disk-csi-driver" --resource-group "${CUSTOMER_RG_NAME}" --query id --output tsv)

DP_FILE_CSI_DRIVER_MI_ID=$(az identity show --name "${CLUSTER_NAME}-dp-file-csi-driver" --resource-group "${CUSTOMER_RG_NAME}" --query id --output tsv)
DP_FILE_CSI_DRIVER_MI_PID=$(az identity show --name "${CLUSTER_NAME}-dp-file-csi-driver" --resource-group "${CUSTOMER_RG_NAME}" --query principalId --output tsv)

DP_IMAGE_REGISTRY_MI_ID=$(az identity show --name "${CLUSTER_NAME}-dp-image-registry" --resource-group "${CUSTOMER_RG_NAME}" --query id --output tsv)
DP_IMAGE_REGISTRY_MI_PID=$(az identity show --name "${CLUSTER_NAME}-dp-image-registry" --resource-group "${CUSTOMER_RG_NAME}" --query principalId --output tsv)

# Service managed identity resource ID and principal ID
SERVICE_MI_ID=$(az identity show --name "${CLUSTER_NAME}-service-managed-identity" --resource-group "${CUSTOMER_RG_NAME}" --query id --output tsv)
SERVICE_MI_PID=$(az identity show --name "${CLUSTER_NAME}-service-managed-identity" --resource-group "${CUSTOMER_RG_NAME}" --query principalId --output tsv)

Tworzenie przypisań ról

Przypisz wymagane role Azure do każdej tożsamości zarządzanej. Aby uzyskać szczegółowy opis każdej tożsamości i jej wymaganych przypisań ról, zobacz Wymagane tożsamości zarządzane i przypisania ról.

  1. Ustaw identyfikatory GUID definicji roli.

    READER_ROLE="acdd72a7-3385-48ef-bd42-f606fba81ae7"
HCP_CLUSTER_API_PROVIDER_ROLE="88366f10-ed47-4cc0-9fab-c8a06148393e"
HCP_CONTROL_PLANE_OPERATOR_ROLE="fc0c873f-45e9-4d0d-a7d1-585aab30c6ed"
CLOUD_CONTROLLER_MANAGER_ROLE="a1f96423-95ce-4224-ab27-4e3dc72facd4"
INGRESS_OPERATOR_ROLE="0336e1d3-7a87-462b-b6db-342b63f7802c"
FILE_STORAGE_OPERATOR_ROLE="0d7aedc0-15fd-4a67-a412-efad370c947e"
NETWORK_OPERATOR_ROLE="be7a6435-15ae-4171-8f30-4a343eff9e8f"
FEDERATED_CREDENTIAL_ROLE="ef318e2a-8334-4a05-9e4a-295a196c6a6e"
HCP_SERVICE_MI_ROLE="c0ff367d-66d8-445e-917c-583feb0ef0d4"
IMAGE_REGISTRY_OPERATOR_ROLE="8b32b316-c2f5-4ddf-b05b-83dacd2d08b5"

  2. Przypisz role operatora płaszczyzny sterowania.

    # Cluster API Azure → ARO HCP Cluster API Provider on the VNet
az role assignment create --assignee-object-id "${CLUSTER_API_AZURE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${HCP_CLUSTER_API_PROVIDER_ROLE}" --scope "${VNET_ID}"

# Control Plane → ARO HCP Control Plane Operator on VNet and NSG
az role assignment create --assignee-object-id "${CONTROL_PLANE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${HCP_CONTROL_PLANE_OPERATOR_ROLE}" --scope "${VNET_ID}"
az role assignment create --assignee-object-id "${CONTROL_PLANE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${HCP_CONTROL_PLANE_OPERATOR_ROLE}" --scope "${NSG_ID}"

# Cloud Controller Manager → ARO Cloud Controller Manager on VNet and NSG
az role assignment create --assignee-object-id "${CLOUD_CONTROLLER_MANAGER_MI_PID}" --assignee-principal-type ServicePrincipal --role "${CLOUD_CONTROLLER_MANAGER_ROLE}" --scope "${NSG_ID}"
az role assignment create --assignee-object-id "${CLOUD_CONTROLLER_MANAGER_MI_PID}" --assignee-principal-type ServicePrincipal --role "${CLOUD_CONTROLLER_MANAGER_ROLE}" --scope "${VNET_ID}"

# Ingress → ARO Cluster Ingress Operator on VNet
az role assignment create --assignee-object-id "${INGRESS_MI_PID}" --assignee-principal-type ServicePrincipal --role "${INGRESS_OPERATOR_ROLE}" --scope "${VNET_ID}"

# File CSI Driver → ARO File Storage Operator on VNet and NSG
az role assignment create --assignee-object-id "${FILE_CSI_DRIVER_MI_PID}" --assignee-principal-type ServicePrincipal --role "${FILE_STORAGE_OPERATOR_ROLE}" --scope "${NSG_ID}"
az role assignment create --assignee-object-id "${FILE_CSI_DRIVER_MI_PID}" --assignee-principal-type ServicePrincipal --role "${FILE_STORAGE_OPERATOR_ROLE}" --scope "${VNET_ID}"

# Cloud Network Config → ARO Network Operator on VNet
az role assignment create --assignee-object-id "${CLOUD_NETWORK_CONFIG_MI_PID}" --assignee-principal-type ServicePrincipal --role "${NETWORK_OPERATOR_ROLE}" --scope "${VNET_ID}"

# Image Registry → ARO Image Registry Operator on VNet
az role assignment create --assignee-object-id "${IMAGE_REGISTRY_MI_PID}" --assignee-principal-type ServicePrincipal --role "${IMAGE_REGISTRY_OPERATOR_ROLE}" --scope "${VNET_ID}"

  3. Przypisz role tożsamości zarządzanej usługi.

    # Service MI → ARO HCP Service Managed Identity on VNet and NSG
az role assignment create --assignee-object-id "${SERVICE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${HCP_SERVICE_MI_ROLE}" --scope "${VNET_ID}"
az role assignment create --assignee-object-id "${SERVICE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${HCP_SERVICE_MI_ROLE}" --scope "${NSG_ID}"

# Service MI → Reader on each control plane identity
az role assignment create --assignee-object-id "${SERVICE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${READER_ROLE}" --scope "${CLUSTER_API_AZURE_MI_ID}"
az role assignment create --assignee-object-id "${SERVICE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${READER_ROLE}" --scope "${CONTROL_PLANE_MI_ID}"
az role assignment create --assignee-object-id "${SERVICE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${READER_ROLE}" --scope "${CLOUD_CONTROLLER_MANAGER_MI_ID}"
az role assignment create --assignee-object-id "${SERVICE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${READER_ROLE}" --scope "${INGRESS_MI_ID}"
az role assignment create --assignee-object-id "${SERVICE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${READER_ROLE}" --scope "${DISK_CSI_DRIVER_MI_ID}"
az role assignment create --assignee-object-id "${SERVICE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${READER_ROLE}" --scope "${FILE_CSI_DRIVER_MI_ID}"
az role assignment create --assignee-object-id "${SERVICE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${READER_ROLE}" --scope "${IMAGE_REGISTRY_MI_ID}"
az role assignment create --assignee-object-id "${SERVICE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${READER_ROLE}" --scope "${CLOUD_NETWORK_CONFIG_MI_ID}"

  4. Przypisywanie ról operatora płaszczyzny danych.

    # Service MI → ARO Federated Credential on each data plane identity
az role assignment create --assignee-object-id "${SERVICE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${FEDERATED_CREDENTIAL_ROLE}" --scope "${DP_DISK_CSI_DRIVER_MI_ID}"
az role assignment create --assignee-object-id "${SERVICE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${FEDERATED_CREDENTIAL_ROLE}" --scope "${DP_FILE_CSI_DRIVER_MI_ID}"
az role assignment create --assignee-object-id "${SERVICE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${FEDERATED_CREDENTIAL_ROLE}" --scope "${DP_IMAGE_REGISTRY_MI_ID}"

# Data Plane File CSI Driver → ARO File Storage Operator on VNet and NSG
az role assignment create --assignee-object-id "${DP_FILE_CSI_DRIVER_MI_PID}" --assignee-principal-type ServicePrincipal --role "${FILE_STORAGE_OPERATOR_ROLE}" --scope "${NSG_ID}"
az role assignment create --assignee-object-id "${DP_FILE_CSI_DRIVER_MI_PID}" --assignee-principal-type ServicePrincipal --role "${FILE_STORAGE_OPERATOR_ROLE}" --scope "${VNET_ID}"

# Data Plane Image Registry → ARO Image Registry Operator on VNet
az role assignment create --assignee-object-id "${DP_IMAGE_REGISTRY_MI_PID}" --assignee-principal-type ServicePrincipal --role "${IMAGE_REGISTRY_OPERATOR_ROLE}" --scope "${VNET_ID}"

Skonfiguruj zarządzane przez klienta szyfrowanie etcd

Azure Red Hat OpenShift z hostowanymi płaszczyznami sterowania szyfruje dane itp. przy użyciu kluczy zarządzanych przez klienta.

Utwórz tożsamość zarządzaną KMS

  1. Ustaw zmienne środowiskowe dla klucza Key Vault i usługi KMS.

    KEYVAULT_NAME="<key-vault-name>"
KMS_KEY_NAME="etcd-kms-key"

  2. Utwórz tożsamość zarządzaną usługi KMS.

    az identity create --name "${CLUSTER_NAME}-cp-kms" --resource-group "${CUSTOMER_RG_NAME}"

  3. Pobierz identyfikator zasobu i identyfikator podmiotu zabezpieczeń dla zarządzanej tożsamości KMS.

    KMS_MI_ID=$(az identity show --name "${CLUSTER_NAME}-cp-kms" --resource-group "${CUSTOMER_RG_NAME}" --query id --output tsv)
KMS_MI_PID=$(az identity show --name "${CLUSTER_NAME}-cp-kms" --resource-group "${CUSTOMER_RG_NAME}" --query principalId --output tsv)

Tworzenie przypisań ról usługi KMS

Przypisz tożsamość zarządzaną usługi rolę Czytelnik w tożsamości zarządzanej usługi KMS.

az role assignment create --assignee-object-id "${SERVICE_MI_PID}" --assignee-principal-type ServicePrincipal --role "${READER_ROLE}" --scope "${KMS_MI_ID}"

Tworzenie klucza Key Vault i usługi KMS

Utwórz Azure Key Vault z autoryzacją RBAC i kluczem szyfrowania RSA 2048-bitowym na potrzeby szyfrowania zarządzanego przez klienta itp.

  1. Utwórz Key Vault.

    az keyvault create \
  --name "${KEYVAULT_NAME}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --location "${LOCATION}" \
  --enable-rbac-authorization true

  2. Przypisz sobie rolę użytkownika Key Vault Crypto Officer. Ta rola udziela uprawnień do tworzenia klucza szyfrowania usługi KMS.

    az role assignment create \
  --role "Key Vault Crypto Officer" \
  --assignee "$(az account show --query user.name -o tsv)" \
  --scope "$(az keyvault show --name "${KEYVAULT_NAME}" --resource-group "${CUSTOMER_RG_NAME}" --query id -o tsv)"

  3. Utwórz klucz szyfrowania usługi KMS.

    az keyvault key create \
  --vault-name "${KEYVAULT_NAME}" \
  --name "${KMS_KEY_NAME}" \
  --kty RSA \
  --size 2048

  4. Pobierz wersję klucza.

    KMS_KEY_VERSION=$(az keyvault key show \
  --vault-name "${KEYVAULT_NAME}" \
  --name "${KMS_KEY_NAME}" \
  --query "key.kid" --output tsv | rev | cut -d'/' -f1 | rev)

  5. Przypisz rolę użytkownika kryptograficznego Key Vault do tożsamości zarządzanej usługi KMS w Key Vault.

    KEY_VAULT_CRYPTO_USER_ROLE="12338af0-0e69-4776-bea7-57ae8d297424"
KEYVAULT_ID=$(az keyvault show --name "${KEYVAULT_NAME}" --query id --output tsv)

az role assignment create \
  --assignee-object-id "${KMS_MI_PID}" \
  --assignee-principal-type ServicePrincipal \
  --role "${KEY_VAULT_CRYPTO_USER_ROLE}" \
  --scope "${KEYVAULT_ID}"

(Opcjonalnie) Ograniczanie dostępu Key Vault do prywatnego punktu końcowego

Jeśli chcesz ograniczyć dostęp Key Vault do prywatnego punktu końcowego, utwórz następujące zasoby. Jeśli nie potrzebujesz prywatnej Key Vault, przejdź do sekcji Tworzenie klastra.

Ważna

Kroki opisane w tej sekcji umożliwiają skonfigurowanie dostępu prywatnego tylko w Azure Key Vault. Podczas tworzenia klastra Azure Red Hat OpenShift z hostowanymi płaszczyznami sterowania ustaw również --vault-visibility Private. Oba ustawienia muszą być zgodne.

  1. Wyłącz dostęp do sieci publicznej w Key Vault.

    az keyvault update \
  --name "${KEYVAULT_NAME}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --public-network-access Disabled

  2. Utwórz prywatny punkt końcowy dla Key Vault.

    az network private-endpoint create \
  --name "kv-private-endpoint" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --vnet-name "${CUSTOMER_VNET_NAME}" \
  --subnet "${CUSTOMER_VNET_SUBNET1}" \
  --private-connection-resource-id "${KEYVAULT_ID}" \
  --group-ids vault \
  --connection-name "kv-private-endpoint"

  3. Utwórz prywatną strefę DNS i połącz ją z siecią wirtualną.

    az network private-dns zone create \
  --name "privatelink.vaultcore.azure.net" \
  --resource-group "${CUSTOMER_RG_NAME}"

az network private-dns link vnet create \
  --name "kv-private-dns-zone-link" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --zone-name "privatelink.vaultcore.azure.net" \
  --virtual-network "${CUSTOMER_VNET_NAME}" \
  --registration-enabled false

  4. Utwórz grupę stref DNS dla prywatnego punktu końcowego.

    az network private-endpoint dns-zone-group create \
  --name "kv-private-ep-dns-group" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --endpoint-name "kv-private-endpoint" \
  --private-dns-zone "privatelink.vaultcore.azure.net" \
  --zone-name "config1"

Tworzenie klastra

Utwórz klaster Azure Red Hat OpenShift z hostowanymi płaszczyznami sterowania na podstawie infrastruktury sieciowej, tożsamości zarządzanych i przypisań ról skonfigurowanych w poprzednich krokach.

Note

Aby uzyskać informacje o wszystkich konfigurowalnych parametrach klastra, zobacz pomoc polecenia (az aro hcp cluster create -h).

Utwórz klaster za pomocą następującego polecenia:

az aro hcp cluster create \
  --name "${CLUSTER_NAME}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --location "${LOCATION}" \
  --version "${CLUSTER_VERSION}" \
  --channel-group stable \
  --subnet-id "${SUBNET_ID}" \
  --vnet-integration-subnet-id "${VNET_INTEGRATION_SUBNET_ID}" \
  --nsg "${NSG_ID}" \
  --managed-resource-group-name "${MANAGED_RESOURCE_GROUP}" \
  --kms-vault-name "${KEYVAULT_NAME}" \
  --vault-visibility <Public-or-Private> \
  --kms-active-key "{name:${KMS_KEY_NAME},version:${KMS_KEY_VERSION}}" \
  --api-visibility <Public-or-Private> \
  --ingress-visibility <Public-or-Private> \
  --assign-service-managed-identity "${SERVICE_MI_ID}" \
  --assign-control-plane-operator-identity cluster-api-azure "${CLUSTER_API_AZURE_MI_ID}" \
  --assign-control-plane-operator-identity control-plane "${CONTROL_PLANE_MI_ID}" \
  --assign-control-plane-operator-identity cloud-controller-manager "${CLOUD_CONTROLLER_MANAGER_MI_ID}" \
  --assign-control-plane-operator-identity ingress "${INGRESS_MI_ID}" \
  --assign-control-plane-operator-identity disk-csi-driver "${DISK_CSI_DRIVER_MI_ID}" \
  --assign-control-plane-operator-identity file-csi-driver "${FILE_CSI_DRIVER_MI_ID}" \
  --assign-control-plane-operator-identity image-registry "${IMAGE_REGISTRY_MI_ID}" \
  --assign-control-plane-operator-identity cloud-network-config "${CLOUD_NETWORK_CONFIG_MI_ID}" \
  --assign-control-plane-operator-identity kms "${KMS_MI_ID}" \
  --assign-data-plane-operator-identity disk-csi-driver "${DP_DISK_CSI_DRIVER_MI_ID}" \
  --assign-data-plane-operator-identity file-csi-driver "${DP_FILE_CSI_DRIVER_MI_ID}" \
  --assign-data-plane-operator-identity image-registry "${DP_IMAGE_REGISTRY_MI_ID}"

Jeśli ograniczono usługę Key Vault do prywatnego punktu końcowego, ustaw --vault-visibility na Private zamiast Public, aby ustawienie klastra było zgodne z konfiguracją sieci Azure Key Vault.

Ustaw Public na --api-visibility dla serwera API dostępnego z Internetu lub na Private dla serwera API dostępnego wyłącznie przez połączenie z siecią prywatną.

Ustaw Public na --ingress-visibility dla tras aplikacji dostępnych z Internetu lub na Private dla tras aplikacji dostępnych tylko przez połączenie z siecią prywatną.

Wdrożenie zwykle trwa od 15 do 20 minut.

Sprawdź, czy klaster został pomyślnie utworzony.

az aro hcp cluster show \
  --name "${CLUSTER_NAME}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --query "properties.provisioningState" \
  --output tsv

Gdy klaster jest gotowy, dane wyjściowe to Succeeded.

Tworzenie puli węzłów

Utwórz pulę węzłów, aby zwiększyć zasoby obliczeniowe węzłów roboczych w klastrze. Następujące polecenie tworzy pulę węzłów z dwoma Standard_D8s_v6 węzłami roboczymi.

Ważna

Przed utworzeniem puli węzłów sprawdź, czy reguły sieciowej grupy zabezpieczeń zezwalają na wymagany ruch sieciowy opisany w artykule Planowanie sieci klastra. Pasująca reguła „Odmów” może uniemożliwić zakończenie aprowizacji puli węzłów.

az aro hcp cluster nodepool create \
  --cluster-name "${CLUSTER_NAME}" \
  --name "${NP_NAME}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --replicas 2 \
  --vm-size Standard_D8s_v6 \
  --version "${NP_VERSION}" \
  --channel-group stable

Sprawdź, czy pula węzłów została pomyślnie utworzona.

az aro hcp cluster nodepool show \
  --cluster-name "${CLUSTER_NAME}" \
  --name "${NP_NAME}" \
  --resource-group "${CUSTOMER_RG_NAME}" \
  --query "properties.provisioningState" \
  --output tsv

Gdy pula węzłów będzie gotowa, wynikiem będzie Succeeded.

dokumentacja pliku Bicep

Przykładowy plik Bicep wdraża klaster z domyślnymi wartościami konfiguracji. W tej sekcji opisano każdy zasób i właściwość w pliku Bicep, który można dostosować przed wdrożeniem.

Zasoby sieciowe

Plik Bicep definiuje grupę zabezpieczeń sieciowych (NSG), sieć wirtualną z podsiecią roboczą i podsiecią integracji z siecią wirtualną oraz delegowanie podsieci integracji z siecią wirtualną. Informacje na temat rozmiaru podsieci, ich rozmieszczenia oraz wymagań dotyczących grup zabezpieczeń sieci (NSG) można znaleźć w artykule Zaplanuj sieć klastra.

Tożsamości zarządzane i przypisania ról

Plik Bicep definiuje tożsamość zarządzaną przypisaną przez użytkownika dla każdego operatora klastra OpenShift oraz przypisania ról, które przyznają każdej tożsamości wymagane uprawnienia. Aby uzyskać szczegółowy opis każdej tożsamości i jej wymaganych przypisań ról, zobacz Wymagane tożsamości zarządzane i przypisania ról.

Zasoby szyfrowania etcd

Plik Bicep zawiera następujące zasoby dotyczące szyfrowania etcd zarządzanego przez klienta:

  • Tożsamość zarządzana usługi KMS — tożsamość zarządzana przypisana przez użytkownika w celu uzyskania dostępu do klucza usługi KMS. Ta tożsamość wymaga:
    • Przypisanie roli użytkownika kryptograficznego Key Vault ograniczone do Azure Key Vault
    • Przypisanie roli Czytelnik, które przyznaje tożsamości zarządzanej usługi dostęp do odczytu za pośrednictwem tożsamości zarządzanej usługi KMS
  • Azure Key Vault — Azure Key Vault z włączoną autoryzacją RBAC
  • Klucz szyfrowania usługi KMS — klucz RSA 2048 utworzony w Key Vault

Jeśli ustawisz parametr privateKeyVault na wartość true, plik Bicep wdraża również następujące zasoby, aby ograniczyć dostęp do usługi Key Vault wyłącznie do prywatnego punktu końcowego:

  • Prywatny punkt końcowy dla usługi Key Vault
  • Prywatna strefa DNS (privatelink.vaultcore.azure.net)
  • Prywatna grupa stref DNS, która kojarzy prywatny punkt końcowy ze strefą DNS
  • Łącze sieci wirtualnej łączące prywatną strefę DNS z siecią wirtualną klastra

Właściwości zasobu klastra

Zasób klastra (Microsoft.RedHatOpenShift/hcpOpenShiftClusters) definiuje konfigurację klastra. Aby uzyskać więcej informacji na temat każdej opcji konfiguracji, zobacz Wybieranie stałych ustawień klastra.

Majątek Wymagane Description
version.id Yes Wersja pomocnicza openShift do zainstalowania. Na przykład 4.20. Aby wyświetlić listę dostępnych wersji, zobacz List available OpenShift versions (Lista dostępnych wersji platformy OpenShift).
version.channelGroup Yes Kanał aktualizacji OpenShift. Jedyną obsługiwaną opcją jest stable.
dns.baseDomainPrefix No Niestandardowy prefiks nazwy domeny podstawowej klastra. Maksymalna długość 15 znaków. Musi zaczynać się od małej litery i może zawierać tylko małe litery, cyfry i łączniki (-).
network.networkType No Wtyczka Container Network Interface (CNI). Prawidłowe wartości to OVNKubernetes (wartość domyślna) lub Other.
network.podCidr No Zakres adresów IP dla zasobników. Wartość domyślna: 10.128.0.0/14.
network.serviceCidr No Zakres adresów IP dla usług. Wartość domyślna: 172.30.0.0/16.
network.machineCidr No Zakres adresów IP dla węzłów obliczeniowych. Wartość domyślna: 10.0.0.0/16.
network.hostPrefix No Długość prefiksu podsieci przydzielona do każdego węzła dla jego podów. Wartość domyślna: 23.
api.visibility No Widoczność serwera interfejsu API. Prawidłowe wartości to Public (wartość domyślna) lub Private. To ustawienie jest niezmienne.
api.authorizedCidrs No Lista autoryzowanych bloków CIDR (tylko IPv4), z których dozwolony jest dostęp do serwera API. Maksymalnie 500 wpisów.
ingress.type No Typ domyślnego ingressu klastra. Prawidłowe wartości to Public (wartość domyślna) lub Private. To ustawienie jest niezmienne.
cryptoRestrictions No Ograniczenia kryptograficzne dla bibliotek jądra i przestrzeni użytkownika. Prawidłowe wartości to None (wartość domyślna) lub FIPS. Po ustawieniu wartości FIPS wszystkie operacje kryptograficzne używają modułów zgodnych z FIPS, a wszystkie pule węzłów dziedziczą konfigurację FIPS. To ustawienie jest niezmienne po utworzeniu klastra.
etcd.dataEncryption.keyManagementMode Yes Tryb zarządzania kluczami szyfrowania. Jedyną obsługiwaną wartością jest CustomerManaged.
etcd.dataEncryption.customerManaged.encryptionType Yes Typ szyfrowania. Jedyną obsługiwaną wartością jest KMS.
etcd.dataEncryption.customerManaged.kms.vaultName Yes Nazwa Azure Key Vault.
etcd.dataEncryption.customerManaged.kms.visibility Yes Jak klaster Azure Red Hat OpenShift z hostowanymi płaszczyznami sterowania uzyskuje dostęp do usługi Key Vault. Prawidłowe wartości to Public lub Private. Jeśli ustawisz tę opcję na Private, musisz również wyłączyć dostęp z sieci publicznej w usłudze Key Vault i utworzyć prywatny punkt końcowy w sieci wirtualnej klastra.
etcd.dataEncryption.customerManaged.kms.activeKey.name Yes Nazwa klucza szyfrowania.
etcd.dataEncryption.customerManaged.kms.activeKey.version Yes Wersja klucza szyfrowania.
clusterImageRegistry.state No Stan wewnętrznego rejestru obrazów. Prawidłowe wartości to Enabled (wartość domyślna) lub Disabled.
platform.managedResourceGroup No Nazwa zarządzanej grupy zasobów. Maksymalna długość 90 znaków.
platform.subnetId Yes Identyfikator zasobu Azure podsieci roboczej.
platform.vnetIntegrationSubnetId Yes Identyfikator zasobów Azure podsieci integracji VNet.
platform.outboundType No Model łączności wychodzącej. Jedyną obsługiwaną wartością jest loadBalancer.
platform.networkSecurityGroupId Yes Identyfikator zasobu platformy Azure dla sieciowej grupy zabezpieczeń.
platform.operatorsAuthentication Yes Przypisania tożsamości zarządzanej dla operatorów klastra.
autoscaling.maxNodesTotal No Maksymalna liczba węzłów, które może utworzyć autoskalator klastra. Domyślne: 0 (bez limitu).
autoscaling.maxPodGracePeriodSeconds No Maksymalna liczba sekund na łagodne zakończenie działania poda przed zmniejszeniem skali.
autoscaling.maxNodeProvisionTimeSeconds No Maksymalna liczba sekund na aprowizację węzłów. Wartość domyślna: 900.
autoscaling.podPriorityThreshold No Próg priorytetu poniżej zasobników, które są traktowane jako najlepsze nakłady pracy przez narzędzie do automatycznego skalowania. Wartość domyślna: -10.
imageDigestMirrors No Wpisy lustrzane skrótów obrazów, które przekierowują pobieranie obrazów z rejestru źródłowego do rejestrów lustrzanych. Maksymalnie 240 wpisów.
nodeDrainTimeoutMinutes No Domyślny okres prolongaty opróżniania węzła dla wszystkich pul węzłów w minutach. Zakres: 0 do 10080. Ustawienie domyślne: 0 (brak limitu czasu).
identity.type Yes Typ tożsamości. Musi mieć wartość UserAssigned.
identity.userAssignedIdentities Yes Mapa identyfikatorów zasobów tożsamości zarządzanej przypisanej przez użytkownika.

Właściwości zasobu puli węzłów

Zasób puli węzłów (Microsoft.RedHatOpenShift/hcpOpenShiftClusters/nodePools) określa grupę węzłów roboczych, które mają tę samą konfigurację.

Majątek Wymagane Description
version.id Yes Wersja aktualizacji OpenShift dla tej puli węzłów. Na przykład 4.20.8. Wersja puli węzłów musi być wersją poprawkową w ramach pobocznej wersji klastra. Aby wyświetlić listę dostępnych wersji, zobacz List available OpenShift versions (Lista dostępnych wersji platformy OpenShift).
version.channelGroup Yes Kanał aktualizacji OpenShift. Jedyną obsługiwaną opcją jest stable.
platform.vmSize Yes Rozmiar maszyny wirtualnej Azure dla węzłów. Aby wyświetlić listę dostępnych rozmiarów maszyn wirtualnych, zobacz Wyświetlanie listy dostępnych rozmiarów maszyn wirtualnych.
platform.subnetId Yes Identyfikator zasobu Azure podsieci. Jeśli nie określisz tej właściwości, pula węzłów używa podsieci roboczej klastra.
platform.osDisk.diskSizeGiB No Rozmiar dysku systemu operacyjnego w GiB. Minimum: 16.
platform.osDisk.diskStorageAccountType No Typ konta magazynu dysku. Prawidłowe wartości to Premium_LRS, StandardSSD_LRSlub Standard_LRS.
platform.osDisk.encryptionSetId No Identyfikator zasobu platformy Azure obiektu DiskEncryptionSet służącego do szyfrowania dysków systemu operacyjnego.
platform.osDisk.diskType No Typ dysku systemu operacyjnego. Prawidłowe wartości to Managed lub Ephemeral.
platform.availabilityZone No Strefa dostępności Azure dla puli węzłów.
platform.enableEncryptionAtHost No Włącza szyfrowanie na poziomie hosta dla maszyn wirtualnych. Wartość domyślna: false.
replicas Warunkowy Liczba węzłów. Wymagane, jeśli autoScaling nie zostało skonfigurowane.
autoScaling.min Warunkowy Minimalna liczba węzłów. Wymagane, jeśli replicas nie zostało skonfigurowane.
autoScaling.max Warunkowy Maksymalna liczba węzłów. Wymagane, jeśli replicas nie zostało skonfigurowane.
autoRepair No Włącza sprawdzanie kondycji węzłów. Wartość domyślna: true.
labels No Etykiety Kubernetes przypisane do węzłów, jako tablica par klucz–wartość.
taints No Tainty Kubernetes zastosowane do węzłów. Każde skażenie ma key, value oraz effect (NoSchedule, PreferNoSchedule lub NoExecute).
nodeDrainTimeoutMinutes No Okres prolongaty opróżniania węzła dla tej puli węzłów, w minutach. Nadpisuje ustawienie domyślne klastra. Zakres: 0 do 10080.

Lista dostępnych wersji openShift

Klaster version.id używa wersji podrzędnej (na przykład 4.20), podczas gdy pula węzłów version.id używa wersji poprawek (na przykład 4.20.8). Aby wyświetlić listę dostępnych wersji platformy OpenShift w twoim regionie, uruchom następujące polecenie:

az aro hcp get-versions --location "${LOCATION}" --output table

Wyświetlanie listy dostępnych rozmiarów maszyn wirtualnych

Dostępność rozmiarów maszyn wirtualnych zależy od regionu Azure klastra. Aby wyświetlić listę rozmiarów maszyn wirtualnych dostępnych w twoim regionie, uruchom następujące polecenie:

az vm list-sizes --location "${LOCATION}" --output table

Aby uzyskać listę obsługiwanych rozmiarów maszyn wirtualnych węzła roboczego dla Azure Red Hat OpenShift z hostowanymi płaszczyznami sterowania, zobacz Obsługiwane rozmiary maszyn wirtualnych. Skorzystaj z listy regionów, aby sprawdzić, czy obsługiwany rozmiar jest dostępny w regionie klastra.

Następne kroki

Nawiązywanie połączenia z Azure Red Hat OpenShift za pomocą klastra hostowanych płaszczyzn sterowania

  • Ostatnia aktualizacja o