Início rápido: Implante um cluster do AKS (Serviço de Kubernetes do Azure) com Azure Container Linux (ACL) usando um modelo ARM

Neste guia de início rápido, você usará um modelo do Azure Resource Manager (ARM) para criar um cluster do AKS (Serviço de Kubernetes do Azure) que executa o Azure Container Linux (ACL) como sistema operacional (SO) dos nós. Depois de instalar os pré-requisitos, crie um par de chaves SSH, examine o modelo, implante o modelo e conecte-se ao cluster.

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

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

A ACL geralmente está disponível a partir do AKS v1.34.
ACL requer Trusted Launch com Inicialização Segura e vTPM. As variantes de início não confiável não estão disponíveis.
A ACL no Arm64 requer SKUs baseadas em Cobalt (v6) para habilitar a compatibilidade do início confiável.
NodeImage e None são os únicos canais de atualização do sistema operacional (SO) com suporte. Unmanaged e SecurityPatch são incompatíveis com ACL devido ao diretório imutável /usr .
O suporte para Streaming de Artefatos não está disponível.
Não há suporte para o Pod Sandboxing.
Não há suporte para CVMs (Máquinas Virtuais Confidenciais).
Não há suporte para VMs de geração 1.

Pré-requisitos

Note

Você pode usar Azure Cloud Shell ou uma instalação local do CLI do Azure para executar os comandos neste início rápido.

Se você estiver executando o CLI do Azure localmente, instale o CLI do Azure. Se você estiver executando no Windows ou no macOS, considere executar a CLI do Azure em um contêiner do Docker. Para obter mais informações, confira Como executar a CLI do Azure em um contêiner do Docker.
Se você estiver usando uma instalação local, entre no CLI do Azure usando o comando az login. Para concluir o processo de autenticação, siga as etapas exibidas em seu terminal. Para ver outras opções de entrada, confira Conectar-se com a CLI do Azure.
Se for solicitado, instale a extensão da CLI do Azure no primeiro uso. Para obter mais informações sobre extensões, confira Usar extensões com a CLI do Azure.
Azure Contêiner linux requer CLI do Azure versão 2.86.0 ou superior. Use o comando az version para localizar 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 você ainda não tiver o kubectl instalado, instale-o por meio de CLI do Azure usando o comando az aks install-cli ou siga as instruções upstream.
Para criar um cluster do AKS usando um modelo do ARM, você precisa fornecer uma chave pública SSH. Se você precisar desse recurso, vá para a seção Criar um par de chaves SSH para gerar um antes de implantar o modelo. Se você já tiver um par de chaves SSH, poderá pular para a seção Examinar o modelo .
A identidade que você está usando para criar seu cluster precisa ter as permissões mínimas apropriadas. Para obter mais informações sobre acesso e identidade do AKS, confira Opções de acesso e identidade para o AKS (Serviço de Kubernetes do Azure).
Para implantar um modelo ARM, você precisa de permissão de gravação nos recursos que você está implantando e acesso a todas as operações do tipo de recurso Microsoft.Resources/deployments. Por exemplo, para implantar uma máquina virtual (VM), você precisa das permissões Microsoft.Compute/virtualMachines/write e Microsoft.Resources/deployments/*. Para obter uma lista de funções e permissões, consulte funções internas do Azure.

Criar um par de chaves SSH

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

Acesse https://shell.azure.com para abrir o Cloud Shell no navegador.
Execute o comando ssh-keygen. O seguinte exemplo cria um par de chaves SSH usando a criptografia RSA e o tamanho de bit 4096:
```
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.

Examinar o modelo

A implantação a seguir usa um modelo 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.

Implantar o modelo

Selecione Implantar no Azure para entrar e abrir um modelo.
Na página Noções Básicas, deixe os valores padrão para Tamanho do 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:
- Assinatura: Selecione uma assinatura do Azure.
- Grupo de recursos: Selecione Criar novo. Insira um nome exclusivo para o grupo de recursos, como myACLResourceGroup e selecione OK.
- SKU do sistema operacional: especifique AzureContainerLinux.
- Local: selecione um local, como Oeste dos EUA.
- Nome do cluster: insira um nome exclusivo para o cluster do AKS, como myACLCluster.
- Prefixo DNS: insira um prefixo DNS exclusivo para seu cluster, como myaclcluster.
- Nome do Usuário Administrador do Linux: insira um nome de usuário para se conectar usando SSH, como azureuser.
- Origem de chave pública SSH: selecione Usar chave pública existente.
- Nome do par de chaves: copie e cole o bloco público do seu par de chaves SSH (por padrão, o conteúdo de ~/.ssh/id_rsa.pub).
Selecione Examinar + Criar>Criar.

Leva alguns minutos para o cluster do AKS ser criado. Aguarde a conclusão da implantação antes de se conectar ao cluster.

Conectar-se ao cluster

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

Configure o kubectl para se conectar ao cluster do Kubernetes usando o comando az aks get-credentials. Este comando baixa as credenciais e configura a CLI do Kubernetes para usá-las.
```
az aks get-credentials --resource-group myACLResourceGroup --name myACLCluster
```

Verifique a conexão com o cluster usando o comando kubectl get. Esse comando retorna uma lista dos nós de cluster.

kubectl get nodes

A saída de exemplo a seguir mostra os três nós criados nas etapas anteriores. Verifique se que o status do nó é 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

Excluir o cluster

Se você não precisar mais dos recursos que criou neste guia de início rápido, poderá excluí-los para evitar cobranças do Azure.

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

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

Neste início rápido, você implantou um cluster AKS do AZURE Container Linux (ACL) usando um modelo do ARM. Para saber mais sobre a ACL, confira os seguintes recursos:

O que é Azure ACL (Container Linux) para AKS (Serviço de Kubernetes do Azure)?

Comentários

Esta página foi útil?

Last updated on 2026-06-03