Compartir vía

Inicio rápido: Implementación de un clúster de Red Hat OpenShift en Azure con una plantilla de Azure Resource Manager o un archivo Bicep

  • Artículo

En este artículo se describe cómo usar una plantilla de Azure Resource Manager (plantilla de ARM) o Bicep para crear un clúster de Red Hat OpenShift en Azure. Puede implementar el clúster de Red Hat OpenShift en Azure con PowerShell o la interfaz de la línea de comandos de Azure (CLI de Azure).

Una plantilla de Azure Resource Manager es un archivo de notación de objetos JavaScript (JSON) que define tanto la infraestructura como la configuración de un proyecto. La plantilla usa sintaxis declarativa. Se describe la implementación deseada sin escribir la secuencia de comandos de programación para crear la implementación.

Bicep es un lenguaje específico de dominio (DSL) que usa una sintaxis declarativa para implementar recursos de Azure. En un archivo Bicep, defina la infraestructura que desea implementar en Azure y, a continuación, use ese archivo durante todo el ciclo de vida de desarrollo para implementar repetidamente la infraestructura. Los recursos se implementan de forma coherente.

Nota:

Para obtener información sobre la implementación de clústeres de Red Hat OpenShift de Azure mediante Terraform, consulte Microsoft.RedHatOpenShift openShiftClusters Terraform.

Requisitos previos

Creación de una plantilla de ARM o un archivo Bicep

Elija una plantilla de Azure Resource Manager (plantilla de ARM) o un archivo de Azure Bicep. A continuación, puede implementar la plantilla mediante la línea de comandos de Azure (azure-cli) o PowerShell.

Creación de una plantilla de Resource Manager

En el ejemplo siguiente se muestra el aspecto de la plantilla de ARM cuando se configura para el clúster de RedHat OpenShift en Azure.

La plantilla define tres recursos de Azure:

Hay más ejemplos de plantillas de Red Hat OpenShift en Azure en el sitio web de Red Hat OpenShift.

Guarde el ejemplo siguiente como azuredeploy.json:

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
      "location" : {
        "type": "string",
        "defaultValue": "eastus",
        "metadata": {
          "description": "Location"
        }
      },
      "domain": {
          "type": "string",
          "defaultValue": "",
          "metadata": {
              "description": "Domain Prefix"
          }
      },
      "pullSecret": {
          "type": "string",
          "metadata": {
              "description": "Pull secret from cloud.redhat.com. The json should be input as a string"
          }
      },
      "clusterVnetName": {
          "type": "string",
          "defaultValue": "aro-vnet",
          "metadata": {
              "description": "Name of ARO vNet"
          }
      },
      "clusterVnetCidr": {
          "type": "string",
          "defaultValue": "10.100.0.0/15",
          "metadata": {
              "description": "ARO vNet Address Space"
          }
      },
      "workerSubnetCidr": {
          "type": "string",
          "defaultValue": "10.100.70.0/23",
          "metadata": {
              "description": "Worker node subnet address space"
          }
      },
      "masterSubnetCidr": {
          "type": "string",
          "defaultValue": "10.100.76.0/24",
          "metadata": {
              "description": "Master node subnet address space"
          }
      },
      "masterVmSize" : {
          "type": "string",
          "defaultValue": "Standard_D8s_v3",
          "metadata": {
              "description": "Master Node VM Type"
          }
      },
      "workerVmSize": {
          "type": "string",
          "defaultValue": "Standard_D4s_v3",
          "metadata": {
              "description": "Worker Node VM Type"
          }
      },
      "workerVmDiskSize": {
          "type" : "int",
          "defaultValue": 128,
          "minValue": 128,
          "metadata": {
              "description": "Worker Node Disk Size in GB"
          }
      },
      "workerCount": {
          "type": "int",
          "defaultValue": 3,
          "minValue": 3,
          "metadata": {
              "description": "Number of Worker Nodes"
          }
      },
      "podCidr": {
          "type": "string",
          "defaultValue": "10.128.0.0/14",
          "metadata": {
              "description": "Cidr for Pods"
          }
      },
      "serviceCidr": {
          "type": "string",
          "defaultValue": "172.30.0.0/16",
          "metadata": {
              "description": "Cidr of service"
          }
      },
      "clusterName" : {
        "type": "string",
        "metadata": {
          "description": "Unique name for the cluster"
        }
      },
      "tags": {
          "type": "object",
          "defaultValue" : {
              "env": "Dev",
              "dept": "Ops"
          },
          "metadata": {
              "description": "Tags for resources"
          }
      },
      "apiServerVisibility": {
          "type": "string",
          "allowedValues": [
              "Private",
              "Public"
          ],
          "defaultValue": "Public",
          "metadata": {
              "description": "Api Server Visibility"
          }
      },
      "ingressVisibility": {
          "type": "string",
          "allowedValues": [
              "Private",
              "Public"
          ],
          "defaultValue": "Public",
          "metadata": {
              "description": "Ingress Visibility"
          }
      },
      "aadClientId" : {
        "type": "string",
        "metadata": {
          "description": "The Application ID of an Azure Active Directory client application"
        }
      },
      "aadObjectId": {
          "type": "string",
          "metadata": {
              "description": "The Object ID of an Azure Active Directory client application"
          }
      },
      "aadClientSecret" : {
        "type":"securestring",
        "metadata": {
          "description": "The secret of an Azure Active Directory client application"
        }
      },
      "rpObjectId": {
          "type": "String",
          "metadata": {
              "description": "The ObjectID of the Resource Provider Service Principal"
          }
      }
    },
    "variables": {
        "contribRole": "[concat('/subscriptions/', subscription().subscriptionId, '/providers/Microsoft.Authorization/roleDefinitions/', 'b24988ac-6180-42a0-ab88-20f7382dd24c')]"
    },
    "resources": [
        {
            "type": "Microsoft.Network/virtualNetworks",
            "apiVersion": "2020-05-01",
            "name": "[parameters('clusterVnetName')]",
            "location": "[parameters('location')]",
            "tags": "[parameters('tags')]",
            "properties": {
                "addressSpace": {
                "addressPrefixes": [
                    "[parameters('clusterVnetCidr')]"
                    ]
                },
                "subnets": [
                {
                    "name": "master",
                    "properties": {
                        "addressPrefix": "[parameters('masterSubnetCidr')]",
                        "serviceEndpoints": [
                            {
                                "service": "Microsoft.ContainerRegistry"
                            }
                        ],
                        "privateLinkServiceNetworkPolicies": "Disabled"
                    }
                },
                {
                    "name": "worker",
                    "properties": {
                        "addressPrefix": "[parameters('workerSubnetCidr')]",
                        "serviceEndpoints": [
                            {
                                "service": "Microsoft.ContainerRegistry"
                            }
                        ]
                    }
                }]
            }
        },
        {
            "type": "Microsoft.Network/virtualNetworks/providers/roleAssignments",
            "apiVersion": "2018-09-01-preview",
            "name": "[concat(parameters('clusterVnetName'), '/Microsoft.Authorization/', guid(resourceGroup().id, deployment().name, parameters('aadObjectId')))]",
            "dependsOn": [
                "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
            ],
            "properties": {
                "roleDefinitionId": "[variables('contribRole')]",
                "principalId":"[parameters('aadObjectId')]"
            }
        },
        {
            "type": "Microsoft.Network/virtualNetworks/providers/roleAssignments",
            "apiVersion": "2018-09-01-preview",
            "name": "[concat(parameters('clusterVnetName'), '/Microsoft.Authorization/', guid(resourceGroup().id, deployment().name, parameters('rpObjectId')))]",
            "dependsOn": [
                "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
            ],
            "properties": {
                "roleDefinitionId": "[variables('contribRole')]",
                "principalId":"[parameters('rpObjectId')]"
            }
        },
        {
            "type": "Microsoft.RedHatOpenShift/OpenShiftClusters",
            "apiVersion": "2020-04-30",
            "name": "[parameters('clusterName')]",
            "location": "[parameters('location')]",
            "tags": "[parameters('tags')]",
            "dependsOn": [
                "[resourceId('Microsoft.Network/virtualNetworks', parameters('clusterVnetName'))]"
            ],
            "properties": {
                "clusterProfile": {
                    "domain": "[parameters('domain')]",
                    "resourceGroupId": "[concat('/subscriptions/', subscription().subscriptionId,'/resourceGroups/aro-', parameters('domain'))]",
                    "pullSecret": "[parameters('pullSecret')]"
                },
                "networkProfile": {
                    "podCidr": "[parameters('podCidr')]",
                    "serviceCidr": "[parameters('serviceCidr')]"
                },
                "servicePrincipalProfile": {
                    "clientId": "[parameters('aadClientId')]",
                    "clientSecret": "[parameters('aadClientSecret')]"
                },
                "masterProfile": {
                    "vmSize": "[parameters('masterVmSize')]",
                    "subnetId": "[resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('clusterVnetName'), 'master')]"
                },
                "workerProfiles": [
                    {
                        "name": "worker",
                        "vmSize": "[parameters('workerVmSize')]",
                        "diskSizeGB": "[parameters('workerVmDiskSize')]",
                        "subnetId": "[resourceId('Microsoft.Network/virtualNetworks/subnets', parameters('clusterVnetName'), 'worker')]",
                        "count": "[parameters('workerCount')]"
                    }
                ],
                "apiserverProfile": {
                    "visibility": "[parameters('apiServerVisibility')]"
                },
                "ingressProfiles": [
                    {
                        "name": "default",
                        "visibility": "[parameters('ingressVisibility')]"
                    }
                ]
            }
        }
    ],
    "outputs": {
         "clusterCredentials": {
             "type": "object",
             "value": "[listCredentials(resourceId('Microsoft.RedHatOpenShift/OpenShiftClusters', parameters('clusterName')), '2020-04-30')]"
         },
         "oauthCallbackURL": {
             "type": "string",
             "value": "[concat('https://oauth-openshift.apps.', parameters('domain'), '.', parameters('location'), '.aroapp.io/oauth2callback/AAD')]"
         }
    }
}

Creación de un archivo de Bicep

En el ejemplo siguiente se muestra el aspecto que debe tener el archivo de Azure Bicep cuando se configura para el clúster de Red Hat OpenShift en Azure.

El archivo Bicep define tres recursos de Azure:

Hay más plantillas de Red Hat OpenShift en Azure en el sitio web de Red Hat OpenShift.

Cree el siguiente archivo Bicep que contiene la definición del clúster de Red Hat OpenShift en Azure. El siguiente ejemplo muestra el aspecto de su archivo Bicep una vez configurado.

Guarde el siguiente archivo como azuredeploy.bicep:

@description('Location')
param location string = 'eastus'

@description('Domain Prefix')
param domain string = ''

@description('Pull secret from cloud.redhat.com. The json should be input as a string')
param pullSecret string

@description('Name of ARO vNet')
param clusterVnetName string = 'aro-vnet'

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

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

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

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

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

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

@description('Number of Worker Nodes')
@minValue(3)
param workerCount int = 3

@description('Cidr for Pods')
param podCidr string = '10.128.0.0/14'

@metadata({
  description: 'Cidr of service'
})
param serviceCidr string = '172.30.0.0/16'

@description('Unique name for the cluster')
param clusterName string

@description('Tags for resources')
param tags object = {
  env: 'Dev'
  dept: 'Ops'
}

@description('Api Server Visibility')
@allowed([
  'Private'
  'Public'
])
param apiServerVisibility string = 'Public'

@description('Ingress Visibility')
@allowed([
  'Private'
  'Public'
])
param ingressVisibility string = 'Public'

@description('The Application ID of an Azure Active Directory client application')
param aadClientId string

@description('The Object ID of an Azure Active Directory client application')
param aadObjectId string

@description('The secret of an Azure Active Directory client application')
@secure()
param aadClientSecret string

@description('The ObjectID of the Resource Provider Service Principal')
param rpObjectId string

@description('Specify if FIPS validated crypto modules are used')
@allowed([
  'Enabled'
  'Disabled'
])
param fips string = 'Disabled'

@description('Specify if master VMs are encrypted at host')
@allowed([
  'Enabled'
  'Disabled'
])
param masterEncryptionAtHost string = 'Disabled'

@description('Specify if worker VMs are encrypted at host')
@allowed([
  'Enabled'
  'Disabled'
])
param workerEncryptionAtHost string = 'Disabled'

var contributorRoleDefinitionId = resourceId('Microsoft.Authorization/roleDefinitions', 'b24988ac-6180-42a0-ab88-20f7382dd24c')
var resourceGroupId = '/subscriptions/${subscription().subscriptionId}/resourceGroups/aro-${domain}-${location}'
var masterSubnetId=resourceId('Microsoft.Network/virtualNetworks/subnets', clusterVnetName, 'master')
var workerSubnetId=resourceId('Microsoft.Network/virtualNetworks/subnets', clusterVnetName, 'worker')

resource clusterVnetName_resource 'Microsoft.Network/virtualNetworks@2020-05-01' = {
  name: clusterVnetName
  location: location
  tags: tags
  properties: {
    addressSpace: {
      addressPrefixes: [
        clusterVnetCidr
      ]
    }
    subnets: [
      {
        name: 'master'
        properties: {
          addressPrefix: masterSubnetCidr
          serviceEndpoints: [
            {
              service: 'Microsoft.ContainerRegistry'
            }
          ]
          privateLinkServiceNetworkPolicies: 'Disabled'
        }
      }
      {
        name: 'worker'
        properties: {
          addressPrefix: workerSubnetCidr
          serviceEndpoints: [
            {
              service: 'Microsoft.ContainerRegistry'
            }
          ]
        }
      }
    ]
  }
}

resource clusterVnetName_Microsoft_Authorization_id_name_aadObjectId 'Microsoft.Authorization/roleAssignments@2020-10-01-preview' = {
  name: guid(aadObjectId, clusterVnetName_resource.id, contributorRoleDefinitionId)
  scope: clusterVnetName_resource
  properties: {
    roleDefinitionId: contributorRoleDefinitionId
    principalId: aadObjectId
    principalType: 'ServicePrincipal'
  }
}

resource clusterVnetName_Microsoft_Authorization_id_name_rpObjectId 'Microsoft.Authorization/roleAssignments@2020-10-01-preview' = {
  name: guid(rpObjectId, clusterVnetName_resource.id, contributorRoleDefinitionId)
  scope: clusterVnetName_resource
  properties: {
    roleDefinitionId: contributorRoleDefinitionId
    principalId: rpObjectId
    principalType: 'ServicePrincipal'
  }
}

resource clusterName_resource 'Microsoft.RedHatOpenShift/OpenShiftClusters@2023-04-01' = {
  name: clusterName
  location: location
  tags: tags
  properties: {
    clusterProfile: {
      domain: domain
      resourceGroupId: resourceGroupId
      pullSecret: pullSecret
      fipsValidatedModules: fips
    }
    networkProfile: {
      podCidr: podCidr
      serviceCidr: serviceCidr
    }
    servicePrincipalProfile: {
      clientId: aadClientId
      clientSecret: aadClientSecret
    }
    masterProfile: {
      vmSize: masterVmSize
      subnetId: masterSubnetId
      encryptionAtHost: masterEncryptionAtHost
    }
    workerProfiles: [
      {
        name: 'worker'
        vmSize: workerVmSize
        diskSizeGB: workerVmDiskSize
        subnetId: workerSubnetId
        count: workerCount
        encryptionAtHost: workerEncryptionAtHost
      }
    ]
    apiserverProfile: {
      visibility: apiServerVisibility
    }
    ingressProfiles: [
      {
        name: 'default'
        visibility: ingressVisibility
      }
    ]
  }
  dependsOn: [
    clusterVnetName_resource
  ]
}

Implementación de la plantilla azuredeploy.json

La plantilla azuredeploy.json se usa para implementar un clúster de Red Hat OpenShift en Azure. Los siguientes parámetros son necesarios:

Nota:

Para el parámetro domain, especifique el prefijo de dominio que se usará como parte del nombre DNS generado automáticamente para la consola de OpenShift y los servidores de API. Este prefijo también se usa como parte del nombre del grupo de recursos que se crea para hospedar las máquinas virtuales del clúster.

Propiedad Descripción Opciones válidas Valor predeterminado
domain Prefijo de dominio para el clúster. ninguno
pullSecret Secreto de extracción que obtuvo del sitio web del administrador del clúster de Red Hat OpenShift.
clusterName Nombre del clúster.
aadClientId El identificador de aplicación (un GUID) de una aplicación cliente de Microsoft Entra.
aadObjectId Identificador de objeto (un GUID) de la entidad de servicio para la aplicación cliente de Microsoft Entra.
aadClientSecret Secreto de cliente de la entidad de servicio para la aplicación cliente de Microsoft Entra, como una cadena segura.
rpObjectId Identificador de objeto (un GUID) de la entidad de servicio del proveedor de recursos.

Los parámetros de plantilla siguientes tienen valores predeterminados. Se pueden especificar, pero no se requieren explícitamente.

Propiedad Descripción Opciones válidas Valor predeterminado
location Ubicación del nuevo clúster de ARO. La ubicación puede ser la misma región del grupo de recursos u otra. eastus
clusterVnetName Nombre de la red virtual para el clúster de ARO. aro-vnet
clusterVnetCidr Espacio de direcciones de la red virtual de ARO, en notación Enrutamiento de interdominios sin clases (CIDR). 10.100.0.0/15
workerSubnetCidr Espacio de direcciones de la subred del nodo de trabajo, en notación CIDR. 10.100.70.0/23
masterSubnetCidr Espacio de direcciones de la subred del nodo del plano de control, en notación CIDR. 10.100.76.0/24
masterVmSize Tipo o tamaño de máquina virtual del nodo del plano de control. Standard_D8s_v3
workerVmSize Tipo o tamaño de máquina virtual del nodo de trabajo. Standard_D4s_v3
workerVmDiskSize Tamaño del disco del nodo de trabajo, en gigabytes. 128
workerCount El número de nodos de trabajo. 3
podCidr Espacio de direcciones de los pods, en notación CIDR. 10.128.0.0/14
serviceCidr Espacio de direcciones del servicio, en notación CIDR. 172.30.0.0/16
tags Tabla hash de etiquetas de recursos. @{env = 'Dev'; dept = 'Ops'}
apiServerVisibility Visibilidad del servidor de API (Public o Private). Público
ingressVisibility Visibilidad de entrada (Public o Private). Público

En las secciones siguientes se proporcionan instrucciones con PowerShell o la CLI de Azure.

pasos de PowerShell

Realice los pasos siguientes si usa PowerShell.

Antes de empezar: PowerShell

Antes de ejecutar los comandos de este artículo, es posible que tenga que ejecutar Connect-AzAccount. Compruebe si tiene conectividad con Azure antes de continuar. Para comprobar si tiene conectividad, ejecute Get-AzContext para comprobar si tiene acceso a una suscripción de Azure activa.

Nota

Esta plantilla usa el texto del secreto de extracción que se obtuvo del sitio web del administrador del clúster de Red Hat OpenShift. Antes de continuar, asegúrese de que el secreto de extracción se guarda localmente como pull-secret.txt.

$rhosPullSecret= Get-Content .\pull-secret.txt -Raw # the pull secret text that was obtained from the Red Hat OpenShift Cluster Manager website

Definición de los parámetros siguientes como variables de entorno: 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

Registro de los proveedores de recursos necesarios: PowerShell

Registre los siguientes proveedores de recursos en la suscripción: Microsoft.RedHatOpenShift, Microsoft.Compute, Microsoft.Storage y Microsoft.Authorization.

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

Creación del nuevo grupo de recursos: PowerShell

New-AzResourceGroup -Name $resourceGroup -Location $location

Creación de una nueva entidad de servicio y asignación de roles: 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'

Obtención de la contraseña de la entidad de servicio: PowerShell

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

Obtención de la entidad de servicio para el proveedor de recursos de OpenShift: PowerShell

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

Comprobación de los parámetros antes de implementar el clúster: 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

Implementación del clúster de Red Hat OpenShift en Azure mediante la plantilla de ARM: PowerShell

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

Conexión al clúster

Para conectarse al nuevo clúster, revise los pasos de Conexión a un clúster de Red Hat OpenShift en Azure 4.

Limpieza de recursos: PowerShell

Una vez que haya terminado, ejecute el siguiente comando para eliminar el grupo de recursos y todos los recursos que creó en este artículo.

Remove-AzResourceGroup -Name $resourceGroup -Force

Pasos de la CLI de Azure

Siga estos pasos si usa la CLI de Azure.

Antes de empezar: CLI de Azure

Es posible que tenga que ejecutar az login antes de ejecutar los comandos de este artículo. Compruebe si tiene conectividad con Azure antes de continuar. Para comprobar si tiene conectividad, ejecute az account list y compruebe que tiene acceso a una suscripción activa de Azure.

Nota

Esta plantilla usará el texto del secreto de extracción que se obtuvo del sitio web del administrador del clúster de Red Hat OpenShift. Antes de continuar, asegúrese de que ese secreto se guarda localmente como pull-secret.txt.

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

Definición de los parámetros siguientes como variables de entorno: CLI de 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

Registro de los proveedores de recursos necesarios - CLI de Azure

Registre los siguientes proveedores de recursos en la suscripción: Microsoft.RedHatOpenShift, Microsoft.Compute, Microsoft.Storage y 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

Creación del nuevo grupo de recursos: CLI de Azure

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

Creación de una entidad de servicio para la nueva aplicación de Microsoft Entra

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

Asignación del rol Colaborador a la nueva entidad de servicio: CLI de 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'

Obtención del identificador de objeto de la entidad de servicio para el proveedor de recursos de OpenShift: CLI de Azure

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

Implementación del clúster: CLI de 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

Conexión al clúster: CLI de Azure

Para conectarse al nuevo clúster, revise los pasos de Conexión a un clúster de Red Hat OpenShift en Azure 4.

Limpieza de recursos: CLI de Azure

Una vez que haya terminado, ejecute el siguiente comando para eliminar el grupo de recursos y todos los recursos que creó en este artículo.

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

Sugerencia

¿Tiene problemas? Háganoslo saber en GitHub abriendo una incidencia en el repositorio de Red Hat OpenShift en Azure (ARO).

Pasos siguientes

En este artículo, ha aprendido a crear un clúster de Red Hat OpenShift en Azure que ejecuta OpenShift 4 mediante plantillas de ARM y Bicep.

Pase al siguiente artículo, donde aprenderá a configurar el clúster para la autenticación mediante Microsoft Entra ID.