Ativar o Standard de Processamento de Informação Federal (FIPS) para pools de nós no Azure Kubernetes Service (AKS)

O Federal Information Processing Standard (FIPS) 140-2 é uma norma do governo dos Estados Unidos que define os requisitos mínimos de segurança para módulos criptográficos nos produtos e sistemas das tecnologias de informação. O Azure Kubernetes Service (AKS) permite criar pools de nós para Linux e Windows com o FIPS 140-2 ativado. As implementações em execução nos conjuntos de nós com o FIPS ativado podem utilizar esses módulos criptográficos para fornecer maior segurança e ajudar a satisfazer os controlos de segurança como parte da conformidade com o FedRAMP. Para obter mais informações sobre o FIPS 140-2, consulte Federal Information Processing Standard (FIPS) 140.

Importante

A partir de 17 de março de 2027, Azure Kubernetes Service (AKS) já não suporta nem fornece atualizações de segurança para o Ubuntu 20.04. Quaisquer imagens de nós existentes serão apagadas e não conseguirás escalar pools de nós a correr Ubuntu 20.04. Migre para uma versão suportada do Ubuntu atualizando os seus pools de nós para a versão 1.35+ do Kubernetes. Para mais informações sobre esta aposentação, consulte o issue do GitHub sobre a aposentação e o anúncio de aposentação no Azure Updates. Para se manter informado sobre anúncios e atualizações, siga as notas de lançamento da AKS.

Importante

A partir de 30 de novembro de 2025, Azure Kubernetes Service (AKS) já não suporta nem fornece atualizações de segurança para Azure Linux 2.0. A imagem do nó Azure Linux 2.0 está congelada na versão 202512.06.0. A partir de 31 de março de 2026, as imagens dos nós serão removidas e não poderá ajustar o tamanho dos seus pools de nós. Migre para uma versão Azure Linux suportada atualizando os seus pools de nós para uma versão Kubernetes suportada ou migrando para osSku AzureLinux3. Para mais informações, consulte o issue Retirement do GitHub e o anúncio de descontinuação das Atualizações do Azure. Para se manter informado sobre anúncios e atualizações, siga as notas de lançamento do AKS.

Pré-requisitos

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

  • Defina o seu contexto de subscrição usando o az account set comando. Por exemplo:

    az account set --subscription "00000000-0000-0000-0000-000000000000"

  • Kubectl instalado. Você pode instalá-lo localmente usando o az aks install-cli comando.

  • Terraform instalado localmente. Para instruções de instalação, consulte Instalar Terraform.

Compatibilidade de versões

  • CLI do Azure versão 2.32.0 ou posterior instalada e configurada. Para localizar a versão, execute az --version. Para mais informações sobre a instalação ou atualização do CLI do Azure, consulte Install CLI do Azure.
  • Exemplos de modelos ARM neste artigo usam a versão da API 2023-03-01 para Microsoft.ContainerService/managedClusters e Microsoft.ContainerService/managedClusters/agentPools.
  • Exemplos de Bicep neste artigo usam a versão de API 2023-03-01 para Microsoft.ContainerService/managedClusters e Microsoft.ContainerService/managedClusters/agentPools.
  • Exemplos de Terraform neste artigo utilizam o fornecedor AzureRM 3.x.
  • Para as definições FIPS do Terraform, use enable_fips_image no azurerm_kubernetes_cluster.default_node_pool e fips_enabled no azurerm_kubernetes_cluster_node_pool.

Limitações

Os pools de nós com FIPS ativado têm as seguintes limitações:

  • Os pools de nós ativados para FIPS exigem a versão 1.19 ou superior do Kubernetes.
  • Para atualizar os pacotes ou módulos subjacentes usados no FIPS, deve usar Node image upgrade.
  • As imagens de contentores nos nós FIPS não são avaliadas quanto à compatibilidade com FIPS.
  • A montagem de um compartilhamento CIFS falha porque o FIPS desabilita alguns módulos de autenticação. Para contornar esse problema, consulte Erros ao montar um compartilhamento de arquivos em um pool de nós habilitado para FIPS.
  • Os pools de nós ativados para FIPS com VMs Arm64 apenas são suportados com Azure Linux 3.0+.
  • O complemento de monitorização AKS suporta pools de nós habilitados para FIPS com Ubuntu, Azure Linux e Windows, começando com a versão 3.1.17 do Agente (Linux) e Win-3.1.17 (Windows).

Importante

A imagem Linux habilitada para FIPS é uma imagem diferente da imagem Linux padrão usada para pools de nós baseados em Linux.

Imagens de nó com suporte FIPS podem ter números de versão diferentes, como a versão do kernel, em comparação com imagens sem suporte FIPS. O ciclo de atualização para pools de nós com FIPS habilitado e imagens de nós pode diferir em relação aos pools de nós e imagens que não têm FIPS habilitado.

Versões de SO suportadas

Pode criar pools de nós ativados para FIPS em todas as versões de sistemas operativos suportados (Linux e Windows). No entanto, nem todas as versões do sistema operacional suportam pools de nós habilitados para FIPS. Depois que uma nova versão do sistema operacional é lançada, normalmente há um período de espera antes que ela seja compatível com FIPS.

A tabela seguinte inclui as versões suportadas do sistema operativo para pools de nós com FIPS:

Tipo de SO OS Código de Armazenamento (SKU) Conformidade com FIPS Predefinição
Linux Ubuntu Suportado Desabilitado por padrão
Linux Azure Linux Suportado Desabilitado por padrão
Windows Windows Server 2022 Suportado Ativado por padrão
Windows Windows Server 2025 Suportado Ativado por defeito e não pode ser desativado

Ao solicitar o Ubuntu com FIPS ativado, se a versão padrão do Ubuntu não suportar FIPS, o AKS adota automaticamente a versão mais recente do Ubuntu que suporta FIPS. Por exemplo, o Ubuntu 22.04 é padrão para pools de nós do Linux. Como o 22.04 não suporta FIPS atualmente, o AKS assume como padrão o Ubuntu 20.04 para pools de nós habilitados para FIPS do Linux.

Nota

Anteriormente, podia usar a GetOSOptions API para determinar se um determinado sistema operativo suportava FIPS. A GetOSOptions API está agora obsoleta e já não está incluída nas novas versões da API do AKS a partir de 01-05-2024.

Criar o ficheiro de configuração do Terraform

Os ficheiros de configuração do Terraform definem a infraestrutura que o Terraform cria e gere.

  1. Crie um ficheiro chamado main.tf e adicione o seguinte código para definir a versão do Terraform e especificar o fornecedor Azure:

    terraform {
  required_version = ">= 1.0"

  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 3.0"
    }
  }
}

provider "azurerm" {
  features {}
}

  2. Adicione o código seguinte a main.tf para criar um grupo de recursos Azure. Sinta-se à vontade para alterar o nome e a localização do grupo de recursos conforme necessário.

    resource "azurerm_resource_group" "example" {
  name     = "example-fips-rg"
  location = "East US"
}

Criar um cluster AKS com um pool de nós predefinido habilitado para FIPS

Pode ativar o FIPS no pool de nós pré-definido ao criar um novo cluster AKS.

Ao criar mais grupos de nós num cluster que já tem um grupo de nós predefinido com FIPS, também deve ativar o FIPS nos novos grupos de nós usando o parâmetro --enable-fips-image.

  1. Crie um cluster AKS com o FIPS ativado no pool de nós predefinido usando o comando az aks create com o parâmetro --enable-fips-image.

    az aks create \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --node-count 3 \
    --enable-fips-image

  2. Verifique se o seu pool de nós está com FIPS ativado usando o comando az aks show e consulte o valor enableFIPS em agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

    O seguinte exemplo mostra que o pool de nós por defeito está habilitado para FIPS:

    Name       enableFips
---------  ------------
nodepool1  True

Ativar o FIPS durante a criação do cluster AKS atualmente não é suportado no portal Azure. Para criar um cluster com um pool de nós predefinido habilitado para FIPS, utilize as instruções CLI do Azure, template ARM, Bicep ou Terraform neste artigo.

Ao criar mais pools de nós num cluster que já tem um pool de nós padrão habilitado por FIPS, deve também ativar o FIPS nos novos pools de nós definindo enableFips para true.

  1. Crie um cluster AKS com FIPS ativado no pool de nós predefinido usando um template ARM, definindo a enableFips propriedade como true no perfil do pool de agentes. Por exemplo:

    {
  "type": "Microsoft.ContainerService/managedClusters",
  "location": "[parameters('location')]",
  "name": "[parameters('clusterName')]",
  "properties": {
    "kubernetesVersion": "1.27",
    "enableRBAC": true,
    "dnsPrefix": "[parameters('dnsPrefix')]",
    "agentPoolProfiles": [
      {
        "name": "nodepool1",
        "count": 3,
        "vmSize": "Standard_D2s_v3",
        "osType": "Linux",
        "osSKU": "Ubuntu",
        "type": "VirtualMachineScaleSets",
        "mode": "System",
        "enableFips": true
      }
    ]
  },
  "identity": {
    "type": "SystemAssigned"
  }
}

  2. Implemente o template ARM usando o portal Azure, CLI do Azure ou Azure PowerShell. Para mais informações sobre a implementação de templates ARM, consulte Deploy resources with ARM templates.

  3. Verifique se o seu pool de nós tem o FIPS ativado usando o comando az aks show e consultando o valor enableFIPS em agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

    O seguinte exemplo mostra que o pool de nós por defeito está habilitado para FIPS:

    Name       enableFips
---------  ------------
nodepool1  True

Ao criar mais pools de nós num cluster que já tem um pool de nós padrão habilitado por FIPS, deve também ativar o FIPS nos novos pools de nós definindo enableFIPS para true.

  1. Crie um cluster AKS com FIPS ativado no pool de nós predefinido usando Bicep definindo enableFIPS para true no perfil do pool de agentes. Por exemplo:

    param location string
param clusterName string
param dnsPrefix string

resource aks 'Microsoft.ContainerService/managedClusters@2023-03-01' = {
  name: clusterName
  location: location
  identity: {
    type: 'SystemAssigned'
  }
  properties: {
    kubernetesVersion: '1.27'
    enableRBAC: true
    dnsPrefix: dnsPrefix
    agentPoolProfiles: [
      {
        name: 'nodepool1'
        count: 3
        vmSize: 'Standard_D2s_v3'
        osType: 'Linux'
        osSKU: 'Ubuntu'
        type: 'VirtualMachineScaleSets'
        mode: 'System'
        enableFIPS: true
      }
    ]
  }
}

  2. Implemente o ficheiro Bicep usando o portal CLI do Azure, Azure PowerShell ou o portal Azure. Para mais informações sobre a implementação de ficheiros Bicep, veja Criar ficheiros Bicep usando o Visual Studio Code.

  3. Verifique se o seu pool de nós tem o FIPS ativado usando o comando az aks show e consultando o valor enableFIPS em agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

    O seguinte exemplo mostra que o pool de nós por defeito está habilitado para FIPS:

    Name       enableFips
---------  ------------
nodepool1  True

Ao criar mais pools de nós num cluster que já tem um pool de nós por defeito com FIPS ativado, deve também ativar o FIPS nos novos pools definindo fips_enabled para true em azurerm_kubernetes_cluster_node_pool.

  1. Adicione o seguinte código a main.tf para criar um cluster AKS com FIPS ativado no pool de nós padrão:

    resource "azurerm_kubernetes_cluster" "example" {
  name                = "example-aks-cluster"
  location            = azurerm_resource_group.example.location
  resource_group_name = azurerm_resource_group.example.name
  dns_prefix          = "example-aks"

  default_node_pool {
    name              = "nodepool1"
    node_count        = 3
    vm_size           = "Standard_D2s_v3"
    os_sku            = "Ubuntu"
    enable_fips_image = true
  }

  identity {
    type = "SystemAssigned"
  }
}

  2. Inicialize o Terraform no diretório que contém o seu main.tf ficheiro usando o terraform init comando.

    terraform init

  3. Crie um plano de execução Terraform usando o terraform plan comando.

    terraform plan

  4. Aplique a configuração usando o terraform apply comando para implementar o cluster com um pool de nós predefinido habilitado por FIPS.

    terraform apply

  5. Liga-te ao cluster AKS usando o comando [az aks get-credentials][az-aks-get-credentials].

    az aks get-credentials \
    --resource-group myResourceGroup \
    --name myAKSCluster

  6. Verifique se o seu pool de nós tem o FIPS ativado usando o comando az aks show e consultando o valor enableFIPS em agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

    O seguinte exemplo mostra que o pool de nós por defeito está habilitado para FIPS:

    Name       enableFips
---------  ------------
nodepool1  True

Para mais informações sobre o recurso azurerm_kubernetes_cluster, consulte a documentação do Terraform Azure provider.

Adicionar um pool de nós Linux habilitado para FIPS a um cluster AKS existente

  1. Adicione um pool de nós Linux habilitado para FIPS a um cluster existente usando o az aks nodepool add comando com o --enable-fips-image parâmetro.

    az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name fipsnp \
    --enable-fips-image

  2. Verifique a configuração do seu pool de nós utilizando o comando az aks show e realizando uma consulta para o valor enableFIPS em agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

    A saída de exemplo a seguir mostra que o pool de nós fipsnp é habilitado para FIPS:

    Name       enableFips
---------  ------------
fipsnp     True
nodepool1  False

  3. Liste os nós usando o kubectl get nodes comando.

    kubectl get nodes

    A saída de exemplo a seguir mostra uma lista dos nós no cluster. Os nodos que começam com aks-fipsnp fazem parte do pool de nodos habilitado para FIPS.

    NAME                                STATUS   ROLES   AGE     VERSION
aks-fipsnp-12345678-vmss000000      Ready    agent   6m4s    v1.19.9
aks-fipsnp-12345678-vmss000001      Ready    agent   5m21s   v1.19.9
aks-fipsnp-12345678-vmss000002      Ready    agent   6m8s    v1.19.9
aks-nodepool1-12345678-vmss000000   Ready    agent   34m     v1.19.9

  4. Execute uma implantação com uma sessão interativa num dos nós no pool de nós habilitado para FIPS usando o comando kubectl debug.

    kubectl debug node/aks-fipsnp-12345678-vmss000000 -it --image=mcr.microsoft.com/dotnet/runtime-deps:6.0

  5. Na saída da sessão interativa, verifique se as bibliotecas criptográficas FIPS estão habilitadas. Sua saída deve ser semelhante à saída de exemplo a seguir:

    root@aks-fipsnp-12345678-vmss000000:/# cat /proc/sys/crypto/fips_enabled
1

    Os pools de nodos com FIPS ativado também têm um rótulo kubernetes.azure.com/fips_enabled=true, que os desdobramentos podem usar para direcionar essas pools de nodos.

Ativação do FIPS quando se adiciona um pool de nós Linux atualmente não é suportada no portal Azure. Para adicionar um pool de nós Linux compatível com FIPS, utilize as instruções do CLI do Azure, modelo ARM, Bicep ou Terraform neste artigo.

  1. Crie um pool de nós Linux com suporte FIPS utilizando um modelo ARM ao implementar um recurso de pool de agentes com a propriedade enableFips definida como true. Por exemplo:

    {
  "type": "Microsoft.ContainerService/managedClusters/agentPools",
  "apiVersion": "2023-03-01",
  "name": "[concat(parameters('clusterName'), '/fipsnp')]",
  "properties": {
    "count": 3,
    "vmSize": "Standard_D2s_v3",
    "osType": "Linux",
    "osSKU": "Ubuntu",
    "mode": "User",
    "enableFips": true
  }
}

  2. Implemente o template ARM usando o portal Azure, CLI do Azure ou Azure PowerShell. Para mais informações sobre a implementação de templates ARM, consulte Deploy resources with ARM templates.

  3. Verifique a configuração do seu pool de nós utilizando o comando az aks show e faça a consulta do valor enableFIPS em agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

    A saída de exemplo a seguir mostra que o pool de nós fipsnp é habilitado para FIPS:

    Name       enableFips
---------  ------------
fipsnp     True
nodepool1  False

  4. Liste os nós usando o kubectl get nodes comando.

    kubectl get nodes

    A saída de exemplo a seguir mostra uma lista dos nós no cluster. Os nodos que começam com aks-fipsnp fazem parte do pool de nodos habilitado para FIPS.

    NAME                                STATUS   ROLES   AGE     VERSION
aks-fipsnp-12345678-vmss000000      Ready    agent   6m4s    v1.19.9
aks-fipsnp-12345678-vmss000001      Ready    agent   5m21s   v1.19.9
aks-fipsnp-12345678-vmss000002      Ready    agent   6m8s    v1.19.9
aks-nodepool1-12345678-vmss000000   Ready    agent   34m     v1.19.9

  5. Execute uma implantação com uma sessão interativa num dos nós no pool de nós habilitado para FIPS usando o comando kubectl debug.

    kubectl debug node/aks-fipsnp-12345678-vmss000000 -it --image=mcr.microsoft.com/dotnet/runtime-deps:6.0

  6. Na saída da sessão interativa, verifique se as bibliotecas criptográficas FIPS estão habilitadas. Sua saída deve ser semelhante à saída de exemplo a seguir:

    root@aks-fipsnp-12345678-vmss000000:/# cat /proc/sys/crypto/fips_enabled
1

    Os pools de nodos com FIPS ativado também têm um rótulo kubernetes.azure.com/fips_enabled=true, que os desdobramentos podem usar para direcionar essas pools de nodos.

  1. Crie um pool de nós Linux compatível com FIPS usando Bicep ao implementar um recurso de pool de agentes com enableFIPS definido para true. Por exemplo:

    param clusterName string
param nodePoolName string = 'fipsnp'

resource nodePool 'Microsoft.ContainerService/managedClusters/agentPools@2023-03-01' = {
  name: '${clusterName}/${nodePoolName}'
  properties: {
    count: 3
    vmSize: 'Standard_D2s_v3'
    osType: 'Linux'
    osSKU: 'Ubuntu'
    mode: 'User'
    enableFIPS: true
  }
}

  2. Implemente o ficheiro Bicep usando o portal CLI do Azure, Azure PowerShell ou o portal Azure. Para mais informações sobre a implementação de ficheiros Bicep, veja Criar ficheiros Bicep usando o Visual Studio Code.

  3. Verifique a configuração do seu pool de nós usando o az aks show comando e consulte o valor enableFIPS no agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

    A saída de exemplo a seguir mostra que o pool de nós fipsnp é habilitado para FIPS:

    Name       enableFips
---------  ------------
fipsnp     True
nodepool1  False

  4. Liste os nós usando o kubectl get nodes comando.

    kubectl get nodes

    A saída de exemplo a seguir mostra uma lista dos nós no cluster. Os nodos que começam com aks-fipsnp fazem parte do pool de nodos habilitado para FIPS.

    NAME                                STATUS   ROLES   AGE     VERSION
aks-fipsnp-12345678-vmss000000      Ready    agent   6m4s    v1.19.9
aks-fipsnp-12345678-vmss000001      Ready    agent   5m21s   v1.19.9
aks-fipsnp-12345678-vmss000002      Ready    agent   6m8s    v1.19.9
aks-nodepool1-12345678-vmss000000   Ready    agent   34m     v1.19.9

  5. Execute uma implantação com uma sessão interativa num dos nós no pool de nós habilitado para FIPS usando o comando kubectl debug.

    kubectl debug node/aks-fipsnp-12345678-vmss000000 -it --image=mcr.microsoft.com/dotnet/runtime-deps:6.0

  6. Na saída da sessão interativa, verifique se as bibliotecas criptográficas FIPS estão habilitadas. Sua saída deve ser semelhante à saída de exemplo a seguir:

    root@aks-fipsnp-12345678-vmss000000:/# cat /proc/sys/crypto/fips_enabled
1

    Os pools de nodos com FIPS ativado também têm um rótulo kubernetes.azure.com/fips_enabled=true, que os desdobramentos podem usar para direcionar essas pools de nodos.

  1. Adicione o seguinte código ao main.tf para adicionar um pool de nós Linux habilitado para FIPS no seu cluster AKS:

    resource "azurerm_kubernetes_cluster_node_pool" "fips_linux" {
  name                   = "fipsnp"
  kubernetes_cluster_id  = azurerm_kubernetes_cluster.example.id
  vm_size                = "Standard_D2s_v3"
  os_type                = "Linux"
  os_sku                 = "Ubuntu"
  node_count             = 3
  fips_enabled           = true

  node_taints = []
}

  2. Aplica a configuração atualizada do Terraform usando os terraform plan comandos e terraform apply .

    terraform plan
terraform apply

  3. Liga-te ao cluster AKS usando o comando [az aks get-credentials][az-aks-get-credentials].

    az aks get-credentials \
    --resource-group myResourceGroup \
    --name myAKSCluster

  4. Verifique a configuração do seu pool de nós usando o comando az aks show e execute uma consulta para o valor enableFIPS em agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

    A saída de exemplo a seguir mostra que o pool de nós fipsnp é habilitado para FIPS:

    Name       enableFips
---------  ------------
fipsnp     True
nodepool1  False

  5. Liste os nós usando o kubectl get nodes comando.

    kubectl get nodes

    A saída de exemplo a seguir mostra uma lista dos nós no cluster. Os nodos que começam com aks-fipsnp fazem parte do pool de nodos habilitado para FIPS.

    NAME                                STATUS   ROLES   AGE     VERSION
aks-fipsnp-12345678-vmss000000      Ready    agent   6m4s    v1.19.9
aks-fipsnp-12345678-vmss000001      Ready    agent   5m21s   v1.19.9
aks-fipsnp-12345678-vmss000002      Ready    agent   6m8s    v1.19.9
aks-nodepool1-12345678-vmss000000   Ready    agent   34m     v1.19.9

  6. Execute uma implantação com uma sessão interativa num dos nós no pool de nós habilitado para FIPS usando o comando kubectl debug.

    kubectl debug node/aks-fipsnp-12345678-vmss000000 -it --image=mcr.microsoft.com/dotnet/runtime-deps:6.0

  7. Na saída da sessão interativa, verifique se as bibliotecas criptográficas FIPS estão habilitadas. Sua saída deve ser semelhante à saída de exemplo a seguir:

    root@aks-fipsnp-12345678-vmss000000:/# cat /proc/sys/crypto/fips_enabled
1

    Os pools de nodos com FIPS ativado também têm um rótulo kubernetes.azure.com/fips_enabled=true, que os desdobramentos podem usar para direcionar essas pools de nodos.

Para mais informações sobre o recurso azurerm_kubernetes_cluster_node_pool, consulte a documentação do Terraform Azure provider.

Adicionar um pool de nós do Windows com FIPS

Nesta secção, adicionamos um pool de nós do Windows a um cluster AKS existente. Os pools de nós do Windows Server 2022 e posteriores ativam o FIPS por padrão, mesmo que enableFips não mostre True. Pools de nós de Windows Server 2025 e posteriores não suportam a desativação do FIPS.

  1. Crie um pool de nós Windows usando o comando az aks nodepool add. Ao contrário dos pools de nós baseados em Linux, os pools de nós do Windows partilham o mesmo conjunto de imagens.

    az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name fipsnp \
    --enable-fips-image \
    --os-type Windows

  2. Verifique a configuração do seu pool de nós usando o az aks show comando e consulte o valor enableFIPS no agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

  3. Verifique se os pools de nós do Windows têm acesso a bibliotecas criptográficas FIPS, criando uma ligação RDP para um nó Windows num pool de nós e verificando o registo do sistema. No aplicativo Executar, digite regedit.

  4. Procure HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy no registro.

  5. Se Enabled estiver definido como 1, o FIPS estará ativado.

    A captura de tela mostra uma imagem do editor do Registro para a Política de Algoritmo FIPS e ela está sendo ativada.

    Os pools de nodos com FIPS ativado também têm um rótulo kubernetes.azure.com/fips_enabled=true, que os desdobramentos podem usar para direcionar essas pools de nodos.

Não existe uma experiência do portal do Azure para ativar ou desativar as configurações FIPS para pools de nós do Windows. Qualquer pool de nós do Windows criado usando o portal do Azure tem o FIPS ativado. Os pools de nós do Windows Server 2022 e posteriores ativam o FIPS por defeito, e os pools de nós do Windows Server 2025 e posteriores não suportam desativar o FIPS.

  1. Crie um pool de nós Windows usando um modelo ARM ao implementar um recurso de grupo de agentes com osType definido para Windows. Por exemplo:

    {
  "type": "Microsoft.ContainerService/managedClusters/agentPools",
  "apiVersion": "2023-03-01",
  "name": "[concat(parameters('clusterName'), '/fipsnp')]",
  "properties": {
    "count": 3,
    "vmSize": "Standard_D2s_v3",
    "osType": "Windows",
    "osSKU": "Windows2022",
    "mode": "User"
  }
}

  2. Implemente o template ARM usando o portal Azure, CLI do Azure ou Azure PowerShell. Para mais informações sobre a implementação de templates ARM, consulte Deploy resources with ARM templates.

  3. Verifique a configuração do seu pool de nós usando o az aks show comando e a consulta para o valor enableFIPS no agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

  4. Verifique se os pools de nós do Windows têm acesso a bibliotecas criptográficas FIPS criando uma ligação RDP para um nó do Windows num pool de nós e verificando no registo. No aplicativo Executar, digite regedit.

  5. Procure HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy no registro.

  6. Se Enabled estiver definido como 1, o FIPS estará ativado.

    A captura de tela mostra uma imagem do editor do Registro para a Política de Algoritmo FIPS e ela está sendo ativada.

    Os pools de nodos com FIPS ativado também têm um rótulo kubernetes.azure.com/fips_enabled=true, que os desdobramentos podem usar para direcionar essas pools de nodos.

  1. Crie um pool de nós do Windows usando Bicep, implementando um recurso de pool de agentes com osType definido como Windows. Por exemplo:

    param clusterName string
param nodePoolName string = 'fipsnp'

resource nodePool 'Microsoft.ContainerService/managedClusters/agentPools@2023-03-01' = {
  name: '${clusterName}/${nodePoolName}'
  properties: {
    count: 3
    vmSize: 'Standard_D2s_v3'
    osType: 'Windows'
    osSKU: 'Windows2022'
    mode: 'User'
    enableFIPS: true
  }
}

  2. Implemente o ficheiro Bicep usando o portal CLI do Azure, Azure PowerShell ou o portal Azure. Para mais informações sobre a implementação de ficheiros Bicep, veja Criar ficheiros Bicep usando o Visual Studio Code.

  3. Verifique a configuração do seu pool de nós usando o comando az aks show e consulte o valor enableFIPS em agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

  4. Verifique se os pools de nós do Windows têm acesso a bibliotecas criptográficas FIPS criando uma conexão RDP a um nó do Windows num pool de nós e verificando o registo. No aplicativo Executar, digite regedit.

  5. Procure HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy no registro.

  6. Se Enabled estiver definido como 1, o FIPS estará ativado.

    A captura de tela mostra uma imagem do editor do Registro para a Política de Algoritmo FIPS e ela está sendo ativada.

    Os pools de nodos com FIPS ativado também têm um rótulo kubernetes.azure.com/fips_enabled=true, que os desdobramentos podem usar para direcionar essas pools de nodos.

  1. Adicione o seguinte código a main.tf para criar um pool de nós Windows no seu cluster AKS.

    resource "azurerm_kubernetes_cluster_node_pool" "fips_windows" {
  name                   = "fipsnp"
  kubernetes_cluster_id  = azurerm_kubernetes_cluster.example.id
  vm_size                = "Standard_D2s_v3"
  os_type                = "Windows"
  os_sku                 = "Windows2022"
  node_count             = 3
  fips_enabled           = true

  node_taints = []
}

  2. Aplica a configuração atualizada do Terraform usando os terraform plan comandos e terraform apply .

    terraform plan
terraform apply

  3. Liga-te ao cluster AKS usando o comando [az aks get-credentials][az-aks-get-credentials].

    az aks get-credentials \
    --resource-group myResourceGroup \
    --name myAKSCluster

  4. Verifique a configuração do seu pool de nós usando o az aks show comando e consulte o valor enableFIPS no agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

  5. Verifique se os grupos de nós Windows têm acesso a bibliotecas criptográficas FIPS, criando uma conexão RDP com um nó Windows em um grupo de nós e verificando o registo do sistema. No aplicativo Executar, digite regedit.

  6. Procure HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy no registro.

  7. Se Enabled estiver definido como 1, o FIPS estará ativado.

    A captura de tela mostra uma imagem do editor do Registro para a Política de Algoritmo FIPS e ela está sendo ativada.

    Os pools de nodos com FIPS ativado também têm um rótulo kubernetes.azure.com/fips_enabled=true, que os desdobramentos podem usar para direcionar essas pools de nodos.

Atualizar um pool de nós existente para habilitar ou desabilitar o FIPS

Os pools de nós Linux existentes podem ser atualizados para habilitar ou desabilitar o FIPS. Se você estiver planejando migrar seus pools de nós de não-FIPS para FIPS, primeiro valide se seu aplicativo está funcionando corretamente em um ambiente de teste antes de migrá-lo para um ambiente de produção. Validar seu aplicativo em um ambiente de teste deve evitar problemas causados pelo kernel FIPS bloqueando algum algoritmo de cifra ou criptografia fraco, como um algoritmo MD4 que não é compatível com FIPS.

Nota

Ao atualizar um pool de nós Linux existente para ativar ou desativar o FIPS, a atualização transita entre a imagem FIPS e a imagem não FIPS. Esta atualização do pool de nós aciona uma reimagem para concluir a atualização. Isso pode fazer com que a atualização do pool de nós demore alguns minutos para ser concluída.

Pré-requisitos para atualizar um pool de nós existente

CLI do Azure versão 2.64.0 ou posterior. Para localizar a versão, execute az --version. Se precisares de instalar ou atualizar, vê Install CLI do Azure.

Habilitar FIPS em um pool de nós existente

Podes atualizar pools de nós Linux existentes para ativar o FIPS. Quando você atualiza um pool de nós existente, a imagem do nó muda da imagem atual para a imagem FIPS recomendada da mesma SKU do sistema operacional.

  1. Atualize um pool de nós usando o az aks nodepool update comando com o --enable-fips-image parâmetro.

    az aks nodepool update \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name np \
    --enable-fips-image

    Este comando desencadeia imediatamente uma reimagem do pool de nós para implementar o sistema operativo compatível com FIPS. Essa nova imagem ocorre durante a atualização do pool de nós. Não são necessárias etapas adicionais.

  2. Verifique se o seu pool de nós tem o FIPS ativado usando o comando az aks show e consultando o valor enableFIPS em agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

    A saída de exemplo a seguir mostra que o pool de nós np é ativado para FIPS:

    Name       enableFips
---------  ------------
np         True
nodepool1  False

Ativar o FIPS num pool de nós existente atualmente não é suportado no portal Azure. Para ativar o FIPS num pool de nós existente, utilize as instruções do CLI do Azure, modelo ARM, Bicep ou Terraform neste artigo.

  1. Ative o FIPS num pool de nós existente usando um template ARM atualizando o perfil do pool de agentes para definir a enableFips propriedade para true. Por exemplo:

    {
  "type": "Microsoft.ContainerService/managedClusters/agentPools",
  "name": "[concat(parameters('clusterName'), '/np')]",
  "apiVersion": "2023-03-01",
  "properties": {
    "enableFips": true
  }
}

  2. Implemente o modelo atualizado usando o portal Azure, CLI do Azure ou Azure PowerShell. Para mais informações sobre a implementação de templates ARM, consulte Deploy resources with ARM templates.

  3. Verifique se o seu pool de nós tem o FIPS ativado usando o comando az aks show e consultando o valor enableFIPS em agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

    A saída de exemplo a seguir mostra que o pool de nós np é ativado para FIPS:

    Name       enableFips
---------  ------------
np         True
nodepool1  False

  1. Ative o FIPS num pool de nós existente usando Bicep atualizando o recurso do pool de agentes para definir enableFIPS para true. Por exemplo:

    param clusterName string
param nodePoolName string = 'np'

resource nodePool 'Microsoft.ContainerService/managedClusters/agentPools@2023-03-01' = {
  name: '${clusterName}/${nodePoolName}'
  properties: {
    enableFIPS: true
  }
}

  2. Implemente o ficheiro Bicep atualizado usando o CLI do Azure, Azure PowerShell ou o portal Azure. Para mais informações sobre a implementação de ficheiros Bicep, veja Criar ficheiros Bicep usando o Visual Studio Code.

  3. Verifique se o seu pool de nós está ativado para FIPS usando o comando az aks show e consultando o valor enableFIPS em agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

    A saída de exemplo a seguir mostra que o pool de nós np é ativado para FIPS:

    Name       enableFips
---------  ------------
np         True
nodepool1  False

  1. Atualize o recurso azurerm_kubernetes_cluster_node_pool em main.tf definindo fips_enabled para true.

    resource "azurerm_kubernetes_cluster_node_pool" "example" {
  name                   = "np"
  kubernetes_cluster_id  = azurerm_kubernetes_cluster.example.id
  vm_size                = "Standard_D2s_v3"
  os_type                = "Linux"
  os_sku                 = "Ubuntu"
  node_count             = 3
  fips_enabled           = true
}

  2. Aplica a configuração atualizada do Terraform usando os terraform plan comandos e terraform apply . O Terraform deteta a alteração para fips_enabled e aciona a necessária operação de recriação.

    terraform plan
terraform apply

  3. Liga-te ao cluster AKS usando o comando [az aks get-credentials][az-aks-get-credentials].

    az aks get-credentials \
    --resource-group myResourceGroup \
    --name myAKSCluster

  4. Verifique se o seu pool de nós tem o FIPS ativado usando o comando az aks show e consultando o valor enableFIPS em agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

    A saída de exemplo a seguir mostra que o pool de nós np é ativado para FIPS:

    Name       enableFips
---------  ------------
np         True
nodepool1  False

Desativar FIPS num grupo de nós existente

Pode atualizar os pools de nós Linux existentes para desativar o FIPS. Ao atualizar um pool de nós existente, a imagem do nó muda da imagem FIPS atual para a imagem não-FIPS recomendada da mesma SKU do sistema operacional. A alteração da imagem do nó ocorre após uma reimagem.

  1. Atualize um pool de nós Linux usando o az aks nodepool update comando com o --disable-fips-image parâmetro.

    az aks nodepool update \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name np \
    --disable-fips-image

    Este comando desencadeia imediatamente uma reimagem do pool de nós para implementar o sistema operativo compatível com FIPS. Essa nova imagem ocorre durante a atualização do pool de nós. Não são necessárias etapas adicionais.

  2. Verifique se o seu pool de nós não está com FIPS habilitado usando o comando az aks show e consultando o valor enableFIPS em agentPoolProfiles.

    az aks show \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
    -o table

    A saída de exemplo a seguir mostra que o pool de nós np não está habilitado para FIPS:

    Name       enableFips
---------  ------------
np         False
nodepool1  False

Desativar o FIPS num pool de nós existente atualmente não é suportado no portal Azure. Para desativar o FIPS num pool de nós existente, utilize as instruções do CLI do Azure, modelo ARM, Bicep ou Terraform neste artigo.

  1. Desative o FIPS num pool de nós existente usando um template ARM atualizando o perfil do pool de agentes para definir a enableFips propriedade como false. Por exemplo:

    {
  "type": "Microsoft.ContainerService/managedClusters/agentPools",
  "name": "[concat(parameters('clusterName'), '/np')]",
  "apiVersion": "2023-03-01",
  "properties": {
    "enableFips": false
  }
}

  2. Implemente o modelo atualizado usando o portal Azure, CLI do Azure ou Azure PowerShell. Para mais informações sobre a implementação de templates ARM, consulte Deploy resources with ARM templates.

  3. Verifique se o seu pool de nós não está compatível com FIPS usando o comando az aks show e consulte o valor de enableFIPS em agentPoolProfiles.

    az aks show \
  --resource-group myResourceGroup \
  --name myAKSCluster \
  --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
  -o table

    A saída de exemplo a seguir mostra que o pool de nós np não está habilitado para FIPS:

    Name       enableFips
---------  ------------
np         False
nodepool1  False

  1. Desative o FIPS num pool de nodes existente usando Bicep, atualizando o recurso do pool de agentes para definir enableFIPS para false. Por exemplo:

    param clusterName string
param nodePoolName string = 'np'

resource nodePool 'Microsoft.ContainerService/managedClusters/agentPools@2023-03-01' = {
  name: '${clusterName}/${nodePoolName}'
  properties: {
    enableFIPS: false
  }
}

  2. Implemente o ficheiro Bicep atualizado usando o CLI do Azure, o Azure PowerShell ou o portal Azure. Para mais informações sobre a implementação de ficheiros Bicep, consulte Crie ficheiros Bicep usando o Visual Studio Code.

  3. Verifique se o seu pool de nós não está habilitado para FIPS usando o az aks show comando e consultar o valor de enableFIPS no agentPoolProfiles.

    az aks show \
  --resource-group myResourceGroup \
  --name myAKSCluster \
  --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
  -o table

    A saída de exemplo a seguir mostra que o pool de nós np não está habilitado para FIPS:

    Name       enableFips
---------  ------------
np         False
nodepool1  False

  1. Atualize o recurso azurerm_kubernetes_cluster_node_pool em main.tf definindo fips_enabled para false:

    resource "azurerm_kubernetes_cluster_node_pool" "example" {
  name                   = "np"
  kubernetes_cluster_id  = azurerm_kubernetes_cluster.example.id
  vm_size                = "Standard_D2s_v3"
  os_type                = "Linux"
  os_sku                 = "Ubuntu"
  node_count             = 3
  fips_enabled           = false
}

  2. Aplica a configuração atualizada do Terraform usando os terraform plan comandos e terraform apply . O Terraform detecta a alteração em fips_enabled e aciona a operação necessária de restauração da imagem.

    terraform plan
terraform apply

  3. Verifique se o seu pool de nós não está habilitado para FIPS, utilizando o comando az aks show e consultar o valor de enableFIPS em agentPoolProfiles.

    az aks show \
  --resource-group myResourceGroup \
  --name myAKSCluster \
  --query="agentPoolProfiles[].{Name:name enableFips:enableFips}" \
  -o table

    A saída de exemplo a seguir mostra que o pool de nós np não está habilitado para FIPS:

    Name       enableFips
---------  ------------
np         False
nodepool1  False

Mensagem do dia

Pode substituir a Mensagem do Dia (MOTD) nos nós Linux utilizando a --message-of-the-day flag ao criar um cluster ou adicionar um pool de nós.

Crie um cluster e substitua a mensagem do dia usando o comando az aks create com o sinalizador --message-of-the-day definido para o caminho do novo ficheiro de MOTD.

az aks create --cluster-name myAKSCluster --resource-group myResourceGroup --message-of-the-day ./newMOTD.txt

Adicione um pool de nós e substitua a mensagem do dia usando o comando az aks nodepool add com a flag --message-of-the-day definida para o caminho do novo ficheiro MOTD.

az aks nodepool add --name mynodepool1 --cluster-name myAKSCluster --resource-group myResourceGroup --message-of-the-day ./newMOTD.txt

Conteúdo relacionado

Para saber mais sobre a segurança do AKS, consulte Melhores práticas para segurança de clusters e atualizações em Azure Kubernetes Service (AKS).

  • Last updated on