Início rápido: Implementar um cluster do Azure Kubernetes Service (AKS) com Azure Linux e OS Guard (pré-visualização) com a CLI do Azure

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

Pré-requisitos

• Se não tiver uma conta do Azure, crie uma conta gratuita antes de começar.

• Usa o ambiente Bash em Azure Cloud Shell. Para obter mais informações, consulte Azure Cloud Shell Quickstart - Bash.

  

• Se preferires executar comandos de referência de CLI 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.
  • Quando solicitado, instale a extensão do 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.
  • Execute az version para localizar a versão e as bibliotecas dependentes que estão instaladas. Para atualizar para a versão mais recente, execute az upgrade.

Considerações e limitações do Azure Linux com OS Guard

Antes de começar, revise as seguintes considerações e limitações para o Azure Linux com o OS Guard (visualização):

• O Kubernetes versão 1.32.0 ou superior é necessário para o Azure Linux com OS Guard.
• Todas as imagens do Azure Linux com OS Guard têm o Federal Information Process Standard (FIPS) e o Trusted Launch habilitados.
• O CLI do Azure e os modelos ARM são os únicos métodos de implementação com suporte para o Azure Linux com o OS Guard no AKS em pré-visualização. O PowerShell e o Terraform não são suportados.
• As imagens Arm64 não são suportadas com Azure Linux e OS Guard no AKS na versão preview.
• NodeImage e None são os únicos canais de atualização sistema operativo (SO) suportados para Azure Linux com OS Guard em AKS. Unmanaged e SecurityPatch são incompatíveis com o Azure Linux com o OS Guard devido ao diretório /usr imutável.
• O Streaming de Artefactos não é suportado.
• O Pod Sandboxing não é suportado.
• Não há suporte para Máquinas Virtuais Confidenciais (CVMs).
• Não há suporte para máquinas virtuais (VMs) de geração 1.

Instala a extensão aks-preview CLI do Azure

Instale a aks-preview extensão usando o az extension add comando.

az extension add --name aks-preview

Atualize a aks-preview extensão para a versão mais recente usando o az extension update comando.

az extension update --name aks-preview

Registar o sinalizador de funcionalidade AzureLinuxOSGuardPreview

1. Registe o sinalizador de funcionalidade AzureLinuxOSGuardPreview com o comando az feature register.

   az feature register --namespace "Microsoft.ContainerService" --name "AzureLinuxOSGuardPreview"
   

   Leva alguns minutos para que o status mostre Registrado.

2. Verifique o status do registro usando o az feature show comando.

   az feature show --namespace "Microsoft.ContainerService" --name "AzureLinuxOSGuardPreview"
   

3. Quando o status refletir Registrado, atualize o registro do provedor 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 criar nomes de recursos únicos para cada implementação. Substitua <your-resource-group-name>, <your-region> e <your-cluster-name> pelos seus próprios valores. Pode, opcionalmente, usar o openssl rand -hex 3 comando para gerar uma cadeia aleatória para adicionar aos nomes do seu grupo de recursos e clusters (por exemplo, export RESOURCE_GROUP="myResourceGroup$RANDOM_ID").

# Create random string
export RANDOM_ID="$(openssl rand -hex 3)"

# Set environment variables
export RESOURCE_GROUP="<your-resource-group-name>"
export REGION="<your-region>"
export CLUSTER_NAME="<your-cluster-name>"

Criar um grupo de recursos

Um grupo de recursos do Azure é um grupo lógico, no qual os recursos do Azure são implementados e geridos. Ao criar um grupo de recursos no Azure, é obrigatório especificar uma localização. Esta localização é a localização de armazenamento dos metadados do teu grupo de recursos e onde os teus recursos correm no Azure se não especificares outra região ao criar um 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/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/$RESOURCE_GROUPxxxxxx",
  "location": "$REGION",
  "managedBy": null,
  "name": "$RESOURCE_GROUPxxxxxx",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Criar um cluster do Azure Linux com o OS Guard

Crie um cluster AKS usando o az aks create comando com o --os-sku parâmetro para provisionar o cluster AKS com uma imagem do Azure Linux com OS Guard.

az aks create --name $CLUSTER_NAME --resource-group $RESOURCE_GROUP --os-sku AzureLinuxOSGuard --node-osdisk-type Managed --enable-fips-image --enable-secure-boot --enable-vtpm 

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

• 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 processamento de pedidos.

1. Crie um arquivo nomeado 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
   

   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.

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

   kubectl apply -f aks-store-quickstart.yaml
   

Testar a aplicação

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

curl $IP_ADDRESS

Resultados:

<!doctype html>
<html lang="">
   <head>
      <meta charset="utf-8">
      <meta http-equiv="X-UA-Compatible" content="IE=edge">
      <meta name="viewport" content="width=device-width,initial-scale=1">
      <link rel="icon" href="/favicon.ico">
      <title>store-front</title>
      <script defer="defer" src="/js/chunk-vendors.df69ae47.js"></script>
      <script defer="defer" src="/js/app.7e8cfbb2.js"></script>
      <link href="/css/app.a5dc49f6.css" rel="stylesheet">
   </head>
   <body>
      <div id="app"></div>
   </body>
</html>

echo "You can now visit your web server at $IP_ADDRESS"

Eliminar o cluster

Se você não precisar mais deles, poderá limpar recursos desnecessários 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 $RESOURCE_GROUP --yes --no-wait

Conteúdo relacionado

Neste início rápido, você implantou um cluster do Azure Linux com o OS Guard. Para saber mais sobre o Azure Linux com o OS Guard, consulte os seguintes recursos:

• Azure Série de tutoriais Linux OS Guard: Parte 1
• Visão geral do Azure Linux OS Guard para AKS