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

Neste guia de início rápido, você usará a CLI do Azure para criar um cluster do AKS (Serviço de Kubernetes do Azure) que usa o Azure Container Linux (ACL) como sistema operacional (SO) dos nós. Depois de implantar o cluster, você se conecta a ele usando kubectl e verifica se os nós de ACL estão em execução conforme o esperado.

Considerações e limitações

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. Variantes de inicialização não confiáveis não estão disponíveis.
A ACL no Arm64 requer SKUs baseadas em Cobalt (v6) para habilitar a compatibilidade de Inicialização Confiável.
NodeImage e None são os únicos canais de atualização do sistema operacional 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.
Nodos com FIPS habilitado ainda não são compatíveis.

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.
Use o comando az version para localizar a versão CLI do Azure e as bibliotecas dependentes instaladas. Azure Contêiner linux requer CLI do Azure versão 2.86.0 ou superior. Para atualizar para a versão mais recente, use o az upgrade comando.
Se necessário, registre o provedor de recursos Microsoft.ContainerService em sua assinatura do Azure.

Registre o provedor de recursos Microsoft.ContainerService

Talvez seja necessário registrar provedores de recursos em sua assinatura do Azure. Verifique o status do registro usando o az provider show comando.

az provider show --namespace Microsoft.ContainerService --query registrationState

Se necessário, registre o provedor de recursos usando o az provider register comando.

az provider register --namespace Microsoft.ContainerService

Criar um grupo de recursos

Um grupo de recursos do Azure é um grupo lógico no qual os recursos do Azure são implantados e gerenciados. Ao criar um grupo de recursos, você precisa especificar um local. Este local é:

O local de armazenamento dos metadados do grupo de recursos.
Esse será o local em que seus recursos serão executados no Azure caso você não especifique outra região durante a criação de recursos.

Crie um grupo de recursos usando o comando az group create. O exemplo a seguir define variáveis de ambiente para o nome do grupo de recursos, a região e o nome do cluster do AKS e, em seguida, cria um grupo de recursos no local especificado. Você pode substituir os valores das variáveis de ambiente por seus próprios nomes e região preferenciais.

export MY_RESOURCE_GROUP_NAME="myACLResourceGroup"
export REGION="westus"
export MY_AKS_CLUSTER_NAME="myACLCluster"

az group create --name $MY_RESOURCE_GROUP_NAME --location $REGION

Exemplo de saída:

{
  "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myACLResourceGroup",
  "location": "westus",
  "managedBy": null,
  "name": "myACLResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Criar um cluster de ACL

Crie um cluster do AKS usando o az aks create comando com o --os-sku AzureContainerLinux parâmetro para provisionar o cluster do AKS com uma imagem ACL.

az aks create \
  --resource-group $MY_RESOURCE_GROUP_NAME \
  --name $MY_AKS_CLUSTER_NAME \
  --os-sku AzureContainerLinux \
  --node-count 3 \
  --generate-ssh-keys

Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.

Conectar-se ao cluster

Para gerenciar um cluster 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 $MY_RESOURCE_GROUP_NAME --name $MY_AKS_CLUSTER_NAME
```
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
```

Implantar o aplicativo

Para implantar o aplicativo, use um arquivo de manifesto para criar todos os objetos necessários para executar o aplicativo AKS Store. Um arquivo de manifesto do Kubernetes define o estado desejado de um cluster, como quais imagens de contêiner executar. O manifesto inclui as seguintes implantações e serviços do Kubernetes:

Frente de loja: Aplicativo Web para clientes visualizarem produtos e fazerem pedidos.
Serviço do produto: Mostra informações do produto.
Serviço de pedido: Realiza pedidos.
Rabbit MQ: Fila de mensagens para uma fila de pedidos.

Note

Não é recomendável executar contêineres com estado, como o Rabbit MQ, sem armazenamento persistente para produção. Elas são usadas aqui para simplificar, mas recomendamos o uso de serviços gerenciados, como Azure Cosmos DB ou Barramento de Serviço do Azure.

Crie um arquivo chamado aks-store-quickstart.yaml e copie-o para o manifesto a seguir:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: rabbitmq
spec:
  serviceName: rabbitmq
  replicas: 1
  selector:
    matchLabels:
      app: rabbitmq
  template:
    metadata:
      labels:
        app: rabbitmq
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: rabbitmq
        image: mcr.microsoft.com/mirror/docker/library/rabbitmq:3.10-management-alpine
        ports:
        - containerPort: 5672
          name: rabbitmq-amqp
        - containerPort: 15672
          name: rabbitmq-http
        env:
        - name: RABBITMQ_DEFAULT_USER
          value: "username"
        - name: RABBITMQ_DEFAULT_PASS
          value: "password"
        resources:
          requests:
            cpu: 10m
            memory: 128Mi
          limits:
            cpu: 250m
            memory: 256Mi
        volumeMounts:
        - name: rabbitmq-enabled-plugins
          mountPath: /etc/rabbitmq/enabled_plugins
          subPath: enabled_plugins
      volumes:
      - name: rabbitmq-enabled-plugins
        configMap:
          name: rabbitmq-enabled-plugins
          items:
          - key: rabbitmq_enabled_plugins
            path: enabled_plugins
---
apiVersion: v1
data:
  rabbitmq_enabled_plugins: |
    [rabbitmq_management,rabbitmq_prometheus,rabbitmq_amqp1_0].
kind: ConfigMap
metadata:
  name: rabbitmq-enabled-plugins
---
apiVersion: v1
kind: Service
metadata:
  name: rabbitmq
spec:
  selector:
    app: rabbitmq
  ports:
    - name: rabbitmq-amqp
      port: 5672
      targetPort: 5672
    - name: rabbitmq-http
      port: 15672
      targetPort: 15672
  type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: order-service
        image: ghcr.io/azure-samples/aks-store-demo/order-service:latest
        ports:
        - containerPort: 3000
        env:
        - name: ORDER_QUEUE_HOSTNAME
          value: "rabbitmq"
        - name: ORDER_QUEUE_PORT
          value: "5672"
        - name: ORDER_QUEUE_USERNAME
          value: "username"
        - name: ORDER_QUEUE_PASSWORD
          value: "password"
        - name: ORDER_QUEUE_NAME
          value: "orders"
        - name: FASTIFY_ADDRESS
          value: "0.0.0.0"
        resources:
          requests:
            cpu: 1m
            memory: 50Mi
          limits:
            cpu: 75m
            memory: 128Mi
---
apiVersion: v1
kind: Service
metadata:
  name: order-service
spec:
  type: ClusterIP
  ports:
  - name: http
    port: 3000
    targetPort: 3000
  selector:
    app: order-service
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: product-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: product-service
  template:
    metadata:
      labels:
        app: product-service
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: product-service
        image: ghcr.io/azure-samples/aks-store-demo/product-service:latest
        ports:
        - containerPort: 3002
        resources:
          requests:
            cpu: 1m
            memory: 1Mi
          limits:
            cpu: 1m
            memory: 7Mi
---
apiVersion: v1
kind: Service
metadata:
  name: product-service
spec:
  type: ClusterIP
  ports:
  - name: http
    port: 3002
    targetPort: 3002
  selector:
    app: product-service
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: store-front
spec:
  replicas: 1
  selector:
    matchLabels:
      app: store-front
  template:
    metadata:
      labels:
        app: store-front
    spec:
      nodeSelector:
        "kubernetes.io/os": linux
      containers:
      - name: store-front
        image: ghcr.io/azure-samples/aks-store-demo/store-front:latest
        ports:
        - containerPort: 8080
          name: store-front
        env:
        - name: VUE_APP_ORDER_SERVICE_URL
          value: "http://order-service:3000/"
        - name: VUE_APP_PRODUCT_SERVICE_URL
          value: "http://product-service:3002/"
        resources:
          requests:
            cpu: 1m
            memory: 200Mi
          limits:
            cpu: 1000m
            memory: 512Mi
---
apiVersion: v1
kind: Service
metadata:
  name: store-front
spec:
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: store-front
  type: LoadBalancer

Implante o aplicativo usando o comando kubectl apply e especifique o nome do manifesto YAML.
```
kubectl apply -f aks-store-quickstart.yaml
```

Testar o aplicativo

Você pode validar se o aplicativo está em execução visitando o endereço IP público ou a URL do aplicativo.

Obtenha a URL do aplicativo usando os seguintes comandos:

runtime="5 minutes"
endtime=$(date -ud "$runtime" +%s)
while [[ $(date -u +%s) -le $endtime ]]
do
   STATUS=$(kubectl get pods -l app=store-front -o 'jsonpath={..status.conditions[?(@.type=="Ready")].status}')
   echo "Status: $STATUS"
   if [ "$STATUS" == 'True' ]
   then
      export IP_ADDRESS=$(kubectl get service store-front --output 'jsonpath={..status.loadBalancer.ingress[0].ip}')
      echo "Service IP Address: $IP_ADDRESS"
      break
   else
      sleep 10
   fi
done

echo "http://$IP_ADDRESS"

Excluir o cluster

Se você não planeja seguir os tutoriais, limpe os recursos desnecessários para evitar cobranças do Azure.

Remova o grupo de recursos, o serviço de contêiner e todos os recursos relacionados usando o comando az group delete.

az group delete --name $MY_RESOURCE_GROUP_NAME --yes --no-wait

Para saber mais sobre ACL para AKS, consulte 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