Quickstart: Implementar um Azure Container Linux (ACL) para cluster AKS usando CLI do Azure

Comece com o Azure Container Linux (ACL) para AKS implementando um cluster AKS usando a CLI do Azure.

Neste início rápido, vais aprender como:

  • Crie um cluster AKS usando ACL para AKS.
  • Implemente o cluster usando CLI do Azure.
  • Executar uma aplicação de exemplo com múltiplos contentores, incluindo um grupo de microserviços e interfaces web que simulam um cenário de retalho.

Note

Este artigo inclui etapas para implantar um cluster com configurações padrão apenas para fins de avaliação. Antes de implantar um cluster pronto para produção, recomendamos que você se familiarize com nossa arquitetura de referência de linha de base para considerar como ela se alinha aos seus requisitos de negócios.

Importante

Se estiver a usar Azure Container Linux (ACL) no AKS, certifique-se de rever as seguintes considerações e limitações:

Pré-requisitos

Registe os fornecedores de recursos necessários

Pode ser necessário registar os fornecedores de recursos necessários, como Microsoft.ContainerService na sua subscrição de Azure.

Verificar o estado do registo

Verifique o status do registro usando o az provider show comando.

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

Registar o fornecedor de recursos

Se necessário, registar o fornecedor de recursos Microsoft.ContainerService usando o comando az provider register.

az provider register --namespace Microsoft.ContainerService

Definir variáveis de ambiente

Defina as seguintes variáveis de ambiente para uso durante este início rápido. Podes substituir os valores pelos teus próprios nomes personalizados, se preferires.

export RESOURCE_GROUP="myAKSResourceGroup"
export REGION="westus"
export CLUSTER_NAME="myAKSCluster"

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ê será solicitado a especificar um local. Esse local é o local de armazenamento dos metadados do grupo de recursos e onde os recursos são executados no Azure se você não especificar outra região durante a criação do recurso.

Crie um grupo de recursos usando o comando az group create.

az group create \
  --name $RESOURCE_GROUP \
  --location $REGION

Exemplo de saída:

{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/myAKSResourceGroup",
  "location": "westus",
  "managedBy": null,
  "name": "myAKSResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Criar um cluster do AKS

Crie um cluster AKS usando o az aks create comando. O parâmetro --os-sku AzureContainerLinux configura o pool de nós do sistema para utilizar a ACL como sistema operativo dos nós. O exemplo a seguir cria um cluster com um nó e habilita uma identidade gerenciada atribuída ao sistema:

az aks create \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --os-sku AzureContainerLinux \
  --node-count 1 \
  --generate-ssh-keys

Note

Quando você cria um novo cluster, o AKS cria automaticamente um segundo grupo de recursos para armazenar os recursos do AKS. Para obter mais informações, consulte Por que dois grupos de recursos são criados com o AKS?

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 $RESOURCE_GROUP \
  --name $CLUSTER_NAME

  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

Implementar a aplicação

Para implementar a aplicação, utiliza-se um ficheiro manifesto para criar todos os objetos necessários para executar a aplicação AKS Store. Um arquivo de manifesto do Kubernetes define o estado desejado de um cluster, como quais imagens de contêiner devem ser executadas. O manifesto inclui as seguintes implantações e serviços do Kubernetes:

Captura de ecrã da arquitetura de exemplos da Azure Store.

  • Loja online: aplicação web para os clientes verem produtos e encomendar.
  • Serviço do produto: Mostra as informações do produto.
  • Serviço de pedidos: Faz pedidos.
  • RabbitMQ: Fila de mensagens para uma fila de pedidos.

Note

Não recomendamos a execução de contêineres com monitoração de estado, como RabbitMQ, sem armazenamento persistente para produção. Usamos isso aqui para simplificar, mas recomendamos o uso de serviços gerenciados, como o Azure Cosmos DB ou o Azure Service Bus.

  1. Crie um ficheiro chamado aks-store-quickstart.yaml e copie no seguinte manifesto:

    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
        startupProbe:
          httpGet:
            path: /health
            port: 3000
          failureThreshold: 5
          initialDelaySeconds: 20
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 3000
          failureThreshold: 3
          initialDelaySeconds: 3
          periodSeconds: 5
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          failureThreshold: 5
          initialDelaySeconds: 3
          periodSeconds: 3
      initContainers:
      - name: wait-for-rabbitmq
        image: busybox
        command: ['sh', '-c', 'until nc -zv rabbitmq 5672; do echo waiting for rabbitmq; sleep 2; done;']
        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
        env:
        - name: AI_SERVICE_URL
          value: "http://ai-service:5001/"
        resources:
          requests:
            cpu: 1m
            memory: 1Mi
          limits:
            cpu: 2m
            memory: 20Mi
        readinessProbe:
          httpGet:
            path: /health
            port: 3002
          failureThreshold: 3
          initialDelaySeconds: 3
          periodSeconds: 5
        livenessProbe:
          httpGet:
            path: /health
            port: 3002
          failureThreshold: 5
          initialDelaySeconds: 3
          periodSeconds: 3
---
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
        startupProbe:
          httpGet:
            path: /health
            port: 8080
          failureThreshold: 3
          initialDelaySeconds: 5
          periodSeconds: 5
        readinessProbe:
          httpGet:
            path: /health
            port: 8080
          failureThreshold: 3
          initialDelaySeconds: 3
          periodSeconds: 3
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          failureThreshold: 5
          initialDelaySeconds: 3
          periodSeconds: 3
---
apiVersion: v1
kind: Service
metadata:
  name: store-front
spec:
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: store-front
  type: LoadBalancer

    Para obter um detalhamento dos arquivos de manifesto YAML, consulte Implementações e manifestos YAML.

    Se você criar e salvar o arquivo YAML localmente, poderá carregar o arquivo de manifesto para seu diretório padrão no Cloud Shell selecionando o botão Upload/Download de arquivos e selecionando o arquivo do seu sistema de arquivos local.

  2. Implante o aplicativo usando o kubectl apply comando e especifique o nome do seu manifesto YAML.

    kubectl apply -f aks-store-quickstart.yaml

    A saída de exemplo a seguir mostra as implementações e os serviços.

    deployment.apps/rabbitmq created
service/rabbitmq created
deployment.apps/order-service created
service/order-service created
deployment.apps/product-service created
service/product-service created
deployment.apps/store-front created
service/store-front created

Testar a aplicação

Quando o aplicativo é executado, um serviço Kubernetes expõe o front-end do aplicativo à Internet. Este processo pode demorar alguns minutos a concluir.

  1. Verifique o status dos pods implantados usando o kubectl get pods comando. Certifique-se de que todos os pods estejam Running antes de prosseguir.

    kubectl get pods

  2. Verifique se há um endereço IP público para o store-front aplicativo. Monitore o progresso usando o kubectl get service comando com o --watch argumento.

    kubectl get service store-front --watch

    O resultado EXTERNAL-IP para o store-front serviço aparece inicialmente como pendente.

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m

    Quando o endereço EXTERNAL-IP mudar de pendente para um endereço IP público real, use CTRL-C para parar o processo de monitoramento kubectl.

    A saída de exemplo a seguir mostra um endereço IP público válido atribuído ao serviço:

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)        AGE
store-front   LoadBalancer   10.0.100.10   20.62.159.19   80:30025/TCP   4h5m

  3. Abra um navegador da Web no endereço IP externo do seu serviço para ver o aplicativo da Loja Azure em ação.

    Captura de ecrã da aplicação de exemplo da AKS Store.

Eliminar o cluster

Se você não planeja passar pelo tutorial do AKS, limpe recursos desnecessários para evitar cobranças de cobrança do Azure.

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

az group delete --name $RESOURCE_GROUP

O cluster AKS foi criado com uma identidade gerenciada atribuída ao sistema, que é a opção de identidade padrão usada neste início rápido. A plataforma gerencia essa identidade para que você não precise removê-la manualmente.

Conteúdo relacionado

Neste quickstart, implementaste um cluster AKS com ACL para AKS usando CLI do Azure. Para saber mais sobre ACL para AKS, consulte Azure Container Linux (ACL) para Azure Kubernetes Service (AKS).

  • Last updated on