Criar clusters do Kubernetes usando o Bicep

Artigo
11/23/2024

Este artigo descreve como criar clusters do Kubernetes no Azure Local usando o Bicep. O fluxo de trabalho é o seguinte:

Criar um par de chaves SSH
Crie um cluster do Kubernetes no Azure Local, versão 23H2 usando o Bicep. Por padrão, o cluster está conectado ao Azure Arc.
Valide a implantação e conecte-se ao cluster.

Antes de começar

Antes de iniciar, verifique se você cumpre os seguintes pré-requisitos:

Obtenha os seguintes detalhes do administrador de infraestrutura local:
- ID da assinatura do Azure: a ID da assinatura do Azure que usa o Azure Local para implantação e registro.
- Nome ou ID do local personalizado: a ID do Azure Resource Manager do local personalizado. O local personalizado é configurado durante a implantação do cluster local do Azure. O administrador de infraestrutura deve fornecer a ID do Resource Manager do local personalizado. Esse parâmetro é necessário para criar clusters do Kubernetes. Você também pode obter a ID do Resource Manager usando az customlocation show --name "<custom location name>" --resource-group <azure resource group> --query "id" -o tsv, se o administrador de infraestrutura fornecer um nome de local personalizado e um nome de grupo de recursos.
- Nome ou ID da rede lógica: a ID do Azure Resource Manager da rede lógica local do Azure que foi criada seguindo estas etapas. Seu administrador deve fornecer o ID da rede lógica. Esse parâmetro é necessário para criar clusters do Kubernetes. Você também pode obter a ID do Azure Resource Manager usando az stack-hci-vm network lnet show --name "<lnet name>" --resource-group <azure resource group> --query "id" -o tsv se souber o grupo de recursos no qual a rede lógica foi criada.
Verifique se você tem a versão mais recente da CLI do Azure em seu computador de desenvolvimento. Você também pode atualizar sua versão da CLI do Azure usando az upgradeo .
Baixe e instale o kubectl em seu computador de desenvolvimento. A ferramenta de linha de comando do Kubernetes, kubectl, permite que você execute comandos em clusters do Kubernetes. Você pode usar o kubectl para implantar aplicativos, inspecionar e gerenciar recursos de cluster e exibir logs.

Criar um par de chaves SSH

Para criar um par de chaves SSH (igual ao Azure AKS), use o seguinte procedimento:

Abra uma sessão do Cloud Shell no navegador.
Crie um par de chaves SSH usando o comando da CLI do az sshkey create Azure ou o ssh-keygen comando:
```
# Create an SSH key pair using Azure CLI
az sshkey create --name "mySSHKey" --resource-group "myResourceGroup"
```
Ou crie um par de chaves SSH usando ssh-keygen:
```
ssh-keygen -t rsa -b 4096
```

Para obter mais informações sobre como criar chaves SSH, confira Criar e gerenciar chaves SSH para autenticação no Azure.

Atualizar e revisar os scripts do Bicep

Esta seção mostra o parâmetro Bicep e os arquivos de modelo. Esses arquivos também estão disponíveis em um modelo de Início Rápido do Azure.

Arquivo de parâmetro Bicep: aksarc.bicepparam

using 'main.bicep'
param aksClusterName = 'aksarc-bicep-new'
param aksControlPlaneIP = 'x.x.x.x'
param sshPublicKey = 'ssh_public_key'
param hciLogicalNetworkName = 'lnet_name'
param hciCustomLocationName = 'cl_name'
param aksNodePoolOSType = 'Linux'
param aksNodePoolNodeCount = 1

Arquivo de modelo Bicep: main.bicep

@description('The name of AKS Arc cluster resource')
param aksClusterName string
param location string = 'eastus'

// Default to 1 node CP
@description('The name of AKS Arc cluster control plane IP, provide this parameter during deployment')
param aksControlPlaneIP string
param aksControlPlaneNodeSize string = 'Standard_A4_v2'
param aksControlPlaneNodeCount int = 1

// Default to 1 node NP
param aksNodePoolName string = 'nodepool1'
param aksNodePoolNodeSize string = 'Standard_A4_v2'
param aksNodePoolNodeCount int = 1
@allowed(['Linux', 'Windows'])
param aksNodePoolOSType string = 'Linux'

@description('SSH public key used for cluster creation, provide this parameter during deployment')
param sshPublicKey string

// Build LNet ID from LNet name
@description('The name of LNet resource, provide this parameter during deployment')
param hciLogicalNetworkName string
resource logicalNetwork 'Microsoft.AzureStackHCI/logicalNetworks@2023-09-01-preview' existing = {
  name: hciLogicalNetworkName
}

// Build custom location ID from custom location name
@description('The name of custom location resource, provide this parameter during deployment')
param hciCustomLocationName string
var customLocationId = resourceId('Microsoft.ExtendedLocation/customLocations', hciCustomLocationName) 

// Create the connected cluster. This is the Arc representation of the AKS cluster, used to create a Managed Identity for the provisioned cluster.
resource connectedCluster 'Microsoft.Kubernetes/ConnectedClusters@2024-01-01' = {
  location: location
  name: aksClusterName
  identity: {
    type: 'SystemAssigned'
  }
  kind: 'ProvisionedCluster'
  properties: {
    agentPublicKeyCertificate: ''
    aadProfile: {
      enableAzureRBAC: false
    }
  }
}

// Create the provisioned cluster instance. This is the actual AKS cluster and provisioned on your Azure Local cluster via the Arc Resource Bridge.
resource provisionedClusterInstance 'Microsoft.HybridContainerService/provisionedClusterInstances@2024-01-01' = {
  name: 'default'
  scope: connectedCluster
  extendedLocation: {
    type: 'CustomLocation'
    name: customLocationId
  }
  properties: {
    linuxProfile: {
      ssh: {
        publicKeys: [
          {
            keyData: sshPublicKey
          }
        ]
      }
    }
    controlPlane: {
      count: aksControlPlaneNodeCount
      controlPlaneEndpoint: {
        hostIP: aksControlPlaneIP
      }
      vmSize: aksControlPlaneNodeSize
    }
    networkProfile: {
      loadBalancerProfile: {
        count: 0
      }
      networkPolicy: 'calico'
    }
    agentPoolProfiles: [
      {
        name: aksNodePoolName
        count: aksNodePoolNodeCount
        vmSize: aksNodePoolNodeSize
        osType: aksNodePoolOSType
      }
    ]
    cloudProviderProfile: {
      infraNetworkProfile: {
        vnetSubnetIds: [
          logicalNetwork.id
        ]
      }
    }
    storageProfile: {
      nfsCsiDriver: {
        enabled: true
      }
      smbCsiDriver: {
        enabled: true
      }
    }
  }
}

O recurso Microsoft.HybridContainerService/provisionedClusterInstances é definido no arquivo Bicep. Se você quiser explorar mais propriedades, consulte a referência da API.

Implante o arquivo Bicep

Salve o arquivo Bicep como main.bicep em seu computador local.
Atualize os parâmetros definidos em aksarc.bicepparam e salve-os no computador local.

Implante o arquivo Bicep usando a CLI do Azure:

az deployment group create --name BicepDeployment --resource-group myResourceGroupName --template-file main.bicep –-parameters aksarc.bicepparam

Validar a implantação do Bicep e conectar-se ao cluster

Agora você pode se conectar ao cluster do Kubernetes executando o az connectedk8s proxy comando no computador de desenvolvimento. Você também pode usar kubectl para ver o status do nó e do pod. Siga as mesmas etapas descritas em Conectar-se ao cluster do Kubernetes.

Próximas etapas

Criar clusters do Kubernetes usando a CLI do Azure

Compartilhar via