Início Rápido: Implantar um Azure Linux com o cluster AKS do OS Guard (versão prévia) usando um modelo do ARM

Comece a usar o Host de Contêiner Linux do Azure implantando um cluster com um modelo do Azure Resource Manager (ARM). Depois de instalar os pré-requisitos, você vai instalar a extensão aks-preview da CLI do Azure, registrar o sinalizador de recurso AzureLinuxOSGuardPreview, criar um par de chaves SSH, revisar, implantar e validar o modelo e, por fim, implantar um aplicativo.

Um modelo do Azure Resource Manager é um arquivo JSON (JavaScript Object Notation) que define a infraestrutura e a configuração do seu projeto. O modelo usa sintaxe declarativa. Você descreve a implantação pretendida sem escrever a sequência de comandos de programação para criar a implantação.

Considerações e limitações

Antes de começar, examine as seguintes considerações e limitações para o Azure Linux com o OS Guard (versão prévia):

• O Kubernetes versão 1.32.0 ou superior é necessário para o Linux do Azure com o SO Guard.
• Todas as imagens do Azure Linux com proteção de SO têm o padrão FIPS e o início confiável habilitados.
• Os modelos do ARM e a CLI do Azure são os únicos métodos de implantação com suporte para o Azure Linux com proteção de SO no AKS na versão prévia. Não há suporte para o PowerShell e o Terraform.
• Não há suporte para imagens do Arm64 no Azure Linux com proteção de SO no AKS na versão prévia.
• NodeImage e None são os únicos canais de atualização do sistema operacional com suporte para o Azure Linux com o OS Guard no AKS. Unmanaged e SecurityPatch são incompatíveis com o Azure Linux com o OS Guard devido ao diretório /usr imutável.
• 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 (máquinas virtuais) de geração 1.

Pré-requisitos

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

• Utilize o ambiente Bash no Azure Cloud Shell. Para saber mais, confira Início rápido do Azure Cloud Shell – Bash.

• Se você preferir executar comandos de referência da CLI localmente, instale a 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 na 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.

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

  • Execute o comando 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.

• Se você ainda não tiver o kubectl instalado, instale-o por meio da CLI do Azure usando az aks install-cli ou siga as instruções upstream.

• Forneça uma chave pública SSH para criar um cluster do AKS usando um modelo do Resource Manager. Caso precise desse recurso, confira a seção abaixo. Caso contrário, vá para a seção Examinar o modelo.

• A identidade que você está usando para criar o cluster tem 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 arquivo Bicep ou um modelo do ARM, você precisa ter acesso de gravação nos recursos que está implantando e acesso a todas as operações no tipo de recurso Microsoft.Resources/deployments. Por exemplo, para implantar uma máquina virtual, você precisa das permissões Microsoft.Compute/virtualMachines/write e Microsoft.Resources/deployments/*. Para ver uma lista de funções e permissões, consulte Funções interna do Azure.

Instalar a extensão aks-preview da CLI do Azure

Para instalar a extensão aks-preview, execute o seguinte comando:

az extension add --name aks-preview

Execute o seguinte comando para atualizar para a versão mais recente da extensão lançada:

az extension update --name aks-preview

Registrar o sinalizador de recurso AzureLinuxOSGuardPreview

Registre o sinalizador de recurso AzureLinuxOSGuardPreview usando o comando [az feature register][az-feature-register], conforme mostrado no seguinte exemplo:

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

Demora alguns minutos para o status mostrar Registrado. Verifique o status do registro usando o comando [az feature show][az-feature-show]:

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

Quando o status refletir Registrado, atualize o registro do provedor de recursos Microsoft.ContainerService usando o comando [az provider register][az-provider-register]:

az provider register --namespace "Microsoft.ContainerService"

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.

1. Acesse https://shell.azure.com para abrir o Cloud Shell no navegador.

2. 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 do ARM dos Modelos de Início Rápido do Azure.

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.1",
    "parameters": {
        "clusterName": {
            "defaultValue": "osguardakscluster",
            "type": "String",
            "metadata": {
                "description": "The name of the Managed Cluster resource."
            }
        },
        "location": {
            "defaultValue": "[resourceGroup().location]",
            "type": "String",
            "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."
            }
        },
        "agentCount": {
            "defaultValue": 3,
            "minValue": 1,
            "maxValue": 50,
            "type": "Int",
            "metadata": {
                "description": "The number of nodes for the cluster."
            }
        },
        "agentVMSize": {
            "defaultValue": "Standard_DS2_v2",
            "type": "String",
            "metadata": {
                "description": "The size of the Virtual Machine."
            }
        },
        "osSKU": {
            "defaultValue": "AzureLinuxOSGuard",
            "allowedValues": [
                "AzureLinuxOSGuard",
                "AzureLinux3OSGuard"
            ],
            "type": "String",
            "metadata": {
                "description": "The Linux SKU to use."
            }
        }
    },
    "resources": [
        {
            "type": "Microsoft.ContainerService/managedClusters",
            "apiVersion": "2025-05-01",
            "name": "[parameters('clusterName')]",
            "location": "[parameters('location')]",
            "identity": {
                "type": "SystemAssigned"
            },
            "properties": {
                "dnsPrefix": "[parameters('dnsPrefix')]",
                "agentPoolProfiles": [
                    {
                        "name": "agentpool",
                        "mode": "System",
                        "count": "[parameters('agentCount')]",
                        "vmSize": "[parameters('agentVMSize')]",
                        "osType": "Linux",
                        "osSKU": "[parameters('osSKU')]",
                        "osDiskType": "Managed",
                        "enableFIPS": true,
                        "securityProfile": {
                            "enableSecureBoot": true,
                            "enableVTPM": true
                        },
                    }
                ]
            }
        }
    ],
    "outputs": {
        "controlPlaneFQDN": {
            "type": "String",
            "value": "[reference(parameters('clusterName')).fqdn]"
        }
    }
}

Para adicionar o Azure Linux com o OS Guard a um modelo do ARM existente, você precisa adicionar:

• "osSKU": "AzureLinuxOSGuard"
• "mode": "System" a agentPoolProfiles
• "osDiskType": "Managed" a agentPoolProfiles
• "enableFIPS": true a agentPoolProfiles
• "securityProfile": {enableSecureBoot: true enableVTPM: true} a agentPoolProfiles
• defina a apiVersion como 2025-05-01 ou mais recente ("apiVersion": "2025-05-01").

Implantar o modelo

1. Selecione o botão a seguir para entrar no Azure e abrir um modelo.

   

2. Selecione ou insira os seguintes valores.

   Para este início rápido, deixe os valores padrão para Tamanho em GB do Disco do Sistema Operacional, Contagem de Agentes, Tamanho da VM do Agente, Tipo de Sistema Operacional e Versão do Kubernetes. Forneça seus próprios valores para 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 testAzureLinuxOSGuardResourceGroup e escolha OK.
   • Localização: selecione um local, como Leste dos EUA.
   • Nome do cluster: insira um nome exclusivo para o cluster do AKS, como testAzureLinuxOSGuardCluster.
   • Prefixo DNS: insira um prefixo DNS exclusivo para seu cluster, como myAzureLinuxOSGuardCluster.
   • Nome do usuário administrador do Linux: insira um nome de usuário para se conectar usando SSH, como azureUser.
   • Chave pública RSA SSH: copie e cole a parte pública do seu par de chaves SSH (por padrão, o conteúdo de ~/.ssh/id_rsa.pub).

3. Selecione Examinar + criar.

Leva alguns minutos para criar o Azure Linux com o cluster do OS Guard. Aguarde até que o cluster seja implantado com êxito antes de passar para a próxima etapa.

Validar a implantação

Conectar-se ao cluster

Para gerenciar um cluster do Kubernetes, use o cliente de linha de comando do Kubernetes, kubectl.

1. Instale kubectl localmente usando o comando az aks install-cli:

   az aks install-cli
   

2. 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 testAzureLinuxOSGuardResourceGroup --name testAzureLinuxCluster
   

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

   O exemplo de saída 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-41324942-0   Ready    agent   6m44s   v1.12.6
   aks-agentpool-41324942-1   Ready    agent   6m46s   v1.12.6
   aks-agentpool-41324942-2   Ready    agent   6m45s   v1.12.6
   

Implantar o aplicativo

Um arquivo de manifesto do Kubernetes define o estado desejado de um cluster, por exemplo, as imagens de contêiner a serem executadas.

Neste guia de início rápido, você usa um manifesto para criar todos os objetos necessários para executar o aplicativo Azure Vote. Esse manifesto inclui duas implantações do Kubernetes:

• Os aplicativos Azure Vote de exemplo em Python.
• Uma instância do Redis.

Dois Serviços Kubernetes também são criados:

• Um serviço interno para a instância do Redis.
• Um serviço externo para acessar o aplicativo Azure Vote da Internet.

1. Crie um arquivo chamado azure-vote.yaml.

   • Se você usar o Azure Cloud Shell, esse arquivo poderá ser criado usando code, vi ou nano, como se você estivesse trabalhando em um sistema físico ou virtual

2. Copie a seguinte definição YAML:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: azure-vote-back
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: azure-vote-back
     template:
       metadata:
         labels:
           app: azure-vote-back
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: azure-vote-back
           image: mcr.microsoft.com/oss/bitnami/redis:6.0.8
           env:
           - name: ALLOW_EMPTY_PASSWORD
             value: "yes"
           resources:
             requests:
               cpu: 100m
               memory: 128Mi
             limits:
               cpu: 250m
               memory: 256Mi
           ports:
           - containerPort: 6379
             name: redis
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: azure-vote-back
   spec:
     ports:
     - port: 6379
     selector:
       app: azure-vote-back
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: azure-vote-front
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: azure-vote-front
     template:
       metadata:
         labels:
           app: azure-vote-front
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: azure-vote-front
           image: mcr.microsoft.com/azuredocs/azure-vote-front:v1
           resources:
             requests:
               cpu: 100m
               memory: 128Mi
             limits:
               cpu: 250m
               memory: 256Mi
           ports:
           - containerPort: 80
           env:
           - name: REDIS
             value: "azure-vote-back"
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: azure-vote-front
   spec:
     type: LoadBalancer
     ports:
     - port: 80
     selector:
       app: azure-vote-front
   

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

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

   kubectl apply -f azure-vote.yaml
   

   O exemplo a seguir é semelhante à saída que mostra as implantações e serviços criados com êxito:

   deployment "azure-vote-back" created
   service "azure-vote-back" created
   deployment "azure-vote-front" created
   service "azure-vote-front" created
   

Testar o aplicativo

Quando o aplicativo é executado, um serviço de Kubernetes expõe o front-end do aplicativo à Internet. A conclusão desse processo pode levar alguns minutos.

Monitore o andamento usando o comando kubectl get service com o argumento --watch.

kubectl get service azure-vote-front --watch

A saída EXTERNAL-IP do serviço azure-vote-front será mostrada inicialmente como pendente.

NAME               TYPE           CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
azure-vote-front   LoadBalancer   10.0.37.27   <pending>     80:30572/TCP   6s

Quando o endereço EXTERNAL-IP for alterado de pendente para um endereço IP público real, use CTRL-C para parar o processo de monitoramento do kubectl. A seguinte saída de exemplo mostra um endereço IP público válido atribuído ao serviço:

azure-vote-front   LoadBalancer   10.0.37.27   52.179.23.131   80:30572/TCP   2m

Para ver o aplicativo Azure Vote em ação, abra um navegador da Web no endereço IP externo do serviço.

Excluir o cluster

Se você não pretende continuar com os tutoriais a seguir, para evitar cobranças do Azure, limpe todos os recursos desnecessários. Para remover o grupo de recursos e todos os recursos associados, use o comando az group delete.

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

Próximas etapas

Neste início rápido, você implantou um Linux do Azure com o cluster do OS Guard. Para saber mais sobre o Azure Linux com o OS Guard e percorrer um exemplo completo de implantação e gerenciamento de cluster, continue no tutorial do Azure Linux com o OS Guard.