Quickstart: Implementar um cluster Azure Container Linux (ACL) Azure Kubernetes Service (AKS) usando um modelo ARM

Neste arranque rápido, utiliza um modelo do Azure Resource Manager (ARM) para criar um cluster do Azure Kubernetes Service (AKS) que utiliza o Azure Container Linux (ACL) como sistema operativo (SO) dos nós. Depois de instalar os pré-requisitos, cria um par de chaves SSH, revê o modelo, implementa o modelo e liga-se ao cluster.

Considerações e limitações do Azure Container Linux (ACL)

Antes de começar, reveja as seguintes considerações e limitações para o ACL:

Pré-requisitos

Note

Pode usar Azure Cloud Shell ou uma instalação local do CLI do Azure para executar os comandos neste quickstart.

  • Se estiveres a correr o CLI do Azure localmente, instala o CLI do Azure. Se estiver a usar Windows ou macOS, considere executar o CLI do Azure num contentor Docker. Para mais informações, veja Como executar o CLI do Azure num contentor Docker.
  • Se estiveres a usar uma instalação local, inicia sessão no CLI do Azure usando o comando az login. Para concluir o processo de autenticação, siga os passos exibidos no seu terminal. Para outras opções de iniciação de sessão, veja Iniciar sessão com a CLI do Azure.
  • Se lhe for pedido, instale a extensão da CLI do Azure na primeira utilização. Para obter mais informações sobre as extensões, veja Utilizar extensões com o CLI do Azure.
  • O Azure Container Linux requer CLI do Azure versão 2.86.0 ou superior. Use o comando az version para encontrar a versão CLI do Azure e as bibliotecas dependentes instaladas. Para atualizar para a versão mais recente, use o az upgrade comando.
  • Se ainda não tiver o kubectl instalado, instale-o através de CLI do Azure usando o comando az aks install-cli ou siga as instruções upstream.
  • Para criar um cluster AKS usando um template ARM, é necessário fornecer uma chave pública SSH. Se precisar deste recurso, vá à secção Criar um par de chaves SSH para gerar um antes de implementar o modelo. Se já tiveres um par de chaves SSH, podes saltar para a secção Rever o modelo.
  • A identidade que estás a usar para criar o teu cluster precisa de ter as permissões mínimas apropriadas. Para obter mais informações sobre acesso e identidade para AKS, consulte Opções de acesso e identidade para o Serviço Kubernetes do Azure (AKS).
  • Para implementar um template ARM, precisa de permissões de escrita nos recursos que está a implementar e de acesso a todas as operações do tipo de recurso Microsoft.Resources/deployments. Por exemplo, para implementar uma máquina virtual (VM), precisa das permissões Microsoft.Compute/virtualMachines/write e Microsoft.Resources/deployments/*. Para obter uma lista de funções e permissões, veja Funções incorporadas do Azure.

Criar um par de chaves SSH

Para acessar os nós AKS, você se conecta usando um par de chaves SSH (público e privado), que você gera usando o ssh-keygen comando. Por padrão, esses arquivos são criados no diretório ~/.ssh . A execução do ssh-keygen comando substitui qualquer par de chaves SSH com o mesmo nome já existente no local determinado.

  1. Vá para https://shell.azure.com para abrir Cloud Shell no seu navegador.

  2. Execute o comando ssh-keygen. O exemplo a seguir cria um par de chaves SSH usando criptografia RSA e um comprimento de bit de 4096:

    ssh-keygen -t rsa -b 4096

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

Rever o modelo

A seguinte implementação utiliza um template ARM de Azure Quickstart Templates:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "clusterName": {
      "type": "string",
      "defaultValue": "aclakscluster",
      "metadata": {
        "description": "The name of the Managed Cluster resource."
      }
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]",
      "metadata": {
        "description": "The location of the Managed Cluster resource."
      }
    },
    "dnsPrefix": {
      "type": "string",
      "metadata": {
        "description": "Optional DNS prefix to use with hosted Kubernetes API server FQDN."
      }
    },
    "osDiskSizeGB": {
      "type": "int",
      "defaultValue": 0,
      "minValue": 0,
      "maxValue": 1023,
      "metadata": {
        "description": "Disk size (in GB) to provision for each of the agent pool nodes. Specifying 0 applies the default disk size for that agentVMSize."
      }
    },
    "agentCount": {
      "type": "int",
      "defaultValue": 3,
      "minValue": 1,
      "maxValue": 50,
      "metadata": {
        "description": "The number of nodes for the cluster."
      }
    },
    "agentVMSize": {
      "type": "string",
      "defaultValue": "standard_d2s_v3",
      "metadata": {
        "description": "The size of the Virtual Machine."
      }
    },
    "linuxAdminUsername": {
      "type": "string",
      "metadata": {
        "description": "User name for the Linux Virtual Machines."
      }
    },
    "sshRSAPublicKey": {
      "type": "string",
      "metadata": {
        "description": "Configure all linux machines with the SSH RSA public key string."
      }
    }
  },
  "resources": [
    {
      "type": "Microsoft.ContainerService/managedClusters",
      "apiVersion": "2026-03-01",
      "name": "[parameters('clusterName')]",
      "location": "[parameters('location')]",
      "identity": {
        "type": "SystemAssigned"
      },
      "properties": {
        "dnsPrefix": "[parameters('dnsPrefix')]",
        "agentPoolProfiles": [
          {
            "name": "agentpool",
            "osDiskSizeGB": "[parameters('osDiskSizeGB')]",
            "count": "[parameters('agentCount')]",
            "vmSize": "[parameters('agentVMSize')]",
            "osType": "Linux",
            "osSKU": "AzureContainerLinux",
            "mode": "System"
          }
        ],
        "linuxProfile": {
          "adminUsername": "[parameters('linuxAdminUsername')]",
          "ssh": {
            "publicKeys": [
              {
                "keyData": "[parameters('sshRSAPublicKey')]"
              }
            ]
          }
        }
      }
    }
  ],
  "outputs": {
    "controlPlaneFQDN": {
      "type": "string",
      "value": "[reference(resourceId('Microsoft.ContainerService/managedClusters', parameters('clusterName')), '2024-02-01').fqdn]"
    }
  }
}

O tipo de recurso definido no modelo ARM é Microsoft.ContainerService/managedClusters.

Implementar o modelo

  1. Selecione Implantar no Azure para entrar e abrir um modelo.

    Botão para implantar o modelo do Gerenciador de Recursos no Azure.

  2. Na página Noções básicas, deixe os valores padrão para GB de tamanho de disco do sistema operacional, contagem de agentes, tamanho da VM do agente e tipo de sistema operacional e configure os seguintes parâmetros de modelo:

    • Subscrição: selecione uma subscrição do Azure.
    • Grupo de recursos: selecione Criar novo. Introduza um nome único para o grupo de recursos, como myACLResourceGroup, e depois selecione OK.
    • SKU do SO: Especifique AzureContainerLinux.
    • Localização: Selecione uma localização, como Oeste dos EUA.
    • Nome do cluster: Insira um nome único para o cluster AKS, como myACLCluster.
    • Prefixo DNS: Introduza um prefixo DNS único para o seu cluster, como myaclcluster.
    • Linux Admin Username: insira um nome de usuário para se conectar usando SSH, como azureuser.
    • Origem da chave pública SSH: Selecione Usar chave pública existente.
    • Nome do par de chaves: copie e cole a parte pública do seu par de chaves SSH (por padrão, o conteúdo de ~/.ssh/id_rsa.pub).

  3. Selecione Rever + Criar>Criar.

    A criação do cluster do AKS demora alguns minutos. Espere que a implementação termine antes de se ligar ao cluster.

Ligar ao cluster

Para gerenciar um cluster Kubernetes, use o cliente de linha de comando Kubernetes, kubectl. kubectl já está instalado se usares Azure Cloud Shell. Para instalar kubectl localmente, use o az aks install-cli comando.

  1. Configure kubectl para se conectar ao cluster do Kubernetes usando o az aks get-credentials comando. Este comando baixa credenciais e configura a CLI do Kubernetes para usá-las.

    az aks get-credentials --resource-group myACLResourceGroup --name myACLCluster

  2. Verifique a conexão ao seu cluster utilizando o comando kubectl get. Este comando devolve uma lista dos nodes do cluster.

    kubectl get nodes

    A saída de exemplo a seguir mostra os três nós criados nas etapas anteriores. Certifique-se de que o estado do nó está Pronto:

    NAME                       STATUS   ROLES   AGE     VERSION
aks-agentpool-12345678-0   Ready    agent   6m44s   v1.34.0
aks-agentpool-12345678-1   Ready    agent   6m46s   v1.34.0
aks-agentpool-12345678-2   Ready    agent   6m45s   v1.34.0

Eliminar o cluster

Se já não precisares dos recursos que criaste neste quickstart, podes limpá-los para evitar cobranças do Azure.

Elimine o grupo de recursos Azure e todos os recursos relacionados usando o comando az group delete:

az group delete --name myACLResourceGroup --yes --no-wait

Conteúdo relacionado

Neste quickstart, implementou um cluster Azure Container Linux (ACL) AKS usando um modelo ARM. Para saber mais sobre o LCA, consulte os seguintes recursos:

  • Last updated on