Guia de início rápido: implantar um host de contêiner Linux do Azure para um cluster AKS usando o Azure PowerShell

Artigo
09/27/2024

Comece a usar o Host de Contêiner Linux do Azure usando o Azure PowerShell para implantar um Host de Contêiner Linux do Azure para um cluster AKS. Depois de instalar os pré-requisitos, você cria um grupo de recursos, cria um cluster AKS, conecta-se ao cluster e executa um aplicativo de vários contêineres de exemplo no cluster.

Pré-requisitos

Se não tiver uma subscrição do Azure, crie uma conta gratuita do Azure antes de começar.
Use o ambiente do PowerShell no Azure Cloud Shell. Para obter mais informações, consulte Azure Cloud Shell Quickstart.
Se você estiver executando o PowerShell localmente, instale o Az PowerShell módulo e conecte-se à sua conta do Azure usando o Connect-AzAccount cmdlet. Para obter mais informações sobre como instalar o módulo Az PowerShell, consulte Instalar o Azure PowerShell.
A identidade usada para criar o cluster tem as permissões mínimas apropriadas. Para obter mais detalhes sobre acesso e identidade para AKS, consulte Opções de acesso e identidade para o Serviço Kubernetes do Azure (AKS).

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. 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.

O exemplo a seguir cria o grupo de recursos chamado testAzureLinuxResourceGroup na região eastus.

Crie um grupo de recursos usando o New-AzResourceGroup cmdlet.

New-AzResourceGroup -Name testAzureLinuxResourceGroup -Location eastus

O exemplo de saída a seguir é semelhante à criação bem-sucedida do grupo de recursos:

ResourceGroupName : testAzureLinuxResourceGroup
Location          : eastus
ProvisioningState : Succeeded
Tags              :
ResourceId        : /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/testAzureLinuxResourceGroup

Nota

O exemplo acima usa eastus, mas os clusters do Host de Contêiner do Azure Linux estão disponíveis em todas as regiões.

Criar um cluster de Host de Contêiner Linux do Azure

O exemplo a seguir cria um cluster chamado testAzureLinuxCluster com um nó.

Crie um cluster AKS usando o New-AzAksCluster cmdlet com o sinalizador -NodeOsSKU definido como AzureLinux.
```
New-AzAksCluster -ResourceGroupName testAzureLinuxResourceGroup -Name testAzureLinuxCluster -NodeOsSKU AzureLinux
```
Após alguns minutos, o comando conclui e retorna informações formatadas em JSON sobre o cluster.

Ligar ao cluster

Para gerenciar um cluster Kubernetes, use o cliente de linha de comando Kubernetes, kubectl. kubectl já está instalado se você usar o Azure Cloud Shell.

Instale kubectl localmente usando o Install-AzAksCliTool cmdlet.
```
Install-AzAksCliTool
```
Configure kubectl para se conectar ao cluster do Kubernetes usando o Import-AzAksCredential cmdlet. Este comando baixa credenciais e configura a CLI do Kubernetes para usá-las.
```
Import-AzAksCredential -ResourceGroupName testAzureLinuxResourceGroup -Name testAzureLinuxCluster
```
Verifique a conexão com o cluster usando o kubectl get comando. Este comando retorna uma lista dos pods de cluster.
```
kubectl get pods --all-namespaces
```

Implementar a aplicação

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 devem ser executadas. O manifesto inclui as seguintes implantações e serviços do Kubernetes:

Vitrine: aplicativo Web para que os clientes visualizem produtos e façam pedidos.
Serviço do produto: Mostra as informações do produto.
Serviço de pedidos: Faz pedidos.
Rabbit MQ: Fila de mensagens para uma fila de pedidos.

Nota

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

Crie um arquivo nomeado aks-store-quickstart.yaml e copie no seguinte manifesto:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: rabbitmq
spec:
  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
      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
        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

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

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

kubectl apply -f aks-store-quickstart.yaml

A saída de exemplo a seguir mostra as implantaçõ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.

Verifique o status dos pods implantados usando o comando kubectl get pods . Certifique-se de que todos os pods estão Running antes de prosseguir.
```
kubectl get pods
```
Verifique se há um endereço IP público para o aplicativo de vitrine. Monitore o progresso usando o comando kubectl get service com o --watch argumento.
```
kubectl get service store-front --watch
```
A saída EXTERNAL-IP para o store-front serviço inicialmente mostra 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 interromper o kubectl processo de monitoramento.

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
```
Abra um navegador da Web no endereço IP externo do seu serviço para ver o aplicativo da Loja Azure em ação.

Eliminar o cluster

Se você não planeja continuar com os tutoriais a seguir, remova os recursos criados para evitar incorrer em cobranças do Azure.

Remova o grupo de recursos e todos os recursos relacionados usando o RemoveAzResourceGroup cmdlet.
```
Remove-AzResourceGroup -Name testAzureLinuxResourceGroup
```

Próximos passos

Neste início rápido, você implantou um cluster AKS do Host de Contêiner Linux do Azure. Para saber mais sobre o Host de Contêiner Linux do Azure e percorrer um exemplo completo de implantação e gerenciamento de cluster, continue para o tutorial do Host de Contêiner Linux do Azure.

Tutorial do Azure Linux Container Host

Partilhar via