Habilitar o FIPS (Federal Information Processing Standard) para os pools de nós do Serviço Azure Kubernetes (AKS)

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

• CLI do Azure versão 2.32.0 ou posterior instalada e configurada. Para saber qual é a versão, execute az --version. Para obter mais informações sobre como instalar ou atualizar o CLI do Azure, consulte Instalar CLI do Azure.

• Os exemplos de modelo do 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 versão da API 2023-03-01 para Microsoft.ContainerService/managedClusters e Microsoft.ContainerService/managedClusters/agentPools.

• Os exemplos do Terraform neste artigo usam o provedor do AzureRM 3.x.
• Para configurações do Terraform FIPS, use enable_fips_image em azurerm_kubernetes_cluster.default_node_pool e fips_enabled em azurerm_kubernetes_cluster_node_pool.

Criar o arquivo de configuração do Terraform

Os arquivos de configuração do Terraform definem a infraestrutura que o Terraform cria e gerencia.

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

   terraform {
     required_version = ">= 1.0"
   
     required_providers {
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~> 3.0"
       }
     }
   }
   
   provider "azurerm" {
     features {}
   }
   

2. Adicione o código a seguir para main.tf para criar um grupo de recursos Azure. Fique à vontade para alterar o nome e o local do grupo de recursos conforme necessário.

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

Ao criar mais pools de nós em um cluster que já tem um pool de nós padrão habilitado para FIPS, você também deve habilitar o FIPS nos novos pools de nós usando o --enable-fips-image parâmetro.

1. Crie um cluster do AKS com FIPS habilitado no pool de nós padrão 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 seu pool de nós está habilitado para FIPS, utilizando 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 padrão está habilitado para FIPS:

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

Habilitar o FIPS durante a criação do cluster AKS atualmente não tem suporte no portal do Azure. Para criar um cluster com um pool de nós padrão habilitado para FIPS, use as instruções CLI do Azure, modelo ARM, Bicep ou Terraform neste artigo.

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

1. Crie um cluster do AKS com FIPS habilitado no pool de nós padrão usando um modelo ARM definindo a enableFips propriedade 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. Implante o modelo do ARM usando o portal Azure, CLI do Azure ou Azure PowerShell. Para obter mais informações sobre como implantar modelos do ARM, consulte Implantar recursos com modelos do ARM.

3. Verifique se o pool de nodes está habilitado para FIPS 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
   

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

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

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

1. Crie um cluster do AKS com FIPS habilitado no pool de nós padrão 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. Implante o arquivo Bicep usando o CLI do Azure, o Azure PowerShell ou o portal Azure. Para obter mais informações sobre como implantar arquivos Bicep, consulte Criar arquivos Bicep usando Visual Studio Code.

3. Verifique se o pool de nodes está habilitado para FIPS 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
   

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

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

Ao criar mais pools de nós em um cluster que já possui um pool de nós padrão habilitado para FIPS, você também deve habilitar o FIPS nos novos pools de nós definindo fips_enabled para true em azurerm_kubernetes_cluster_node_pool.

1. Adicione o seguinte código a main.tf para criar um cluster do AKS com FIPS habilitado 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 main.tf arquivo usando o terraform init comando.

   terraform init
   

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

   terraform plan
   

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

   terraform apply
   

5. Conecte-se ao cluster do 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 pool de nodes está habilitado para FIPS 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
   

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

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

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

1. Adicione um pool de nós do 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 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
   

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

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

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

   kubectl get nodes
   

   A saída de exemplo a seguir mostra uma lista dos nós no cluster. Os nós que começam com aks-fipsnp e fazem parte do pool de nós 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 em um 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. Seu resultado deve ser semelhante ao seguinte exemplo de saída:

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

   Os pools de nós habilitados para FIPS também têm um rótulo kubernetes.azure.com/fips_enabled=true, que as implantações podem usar para direcionar esses pools de nós.

Habilitar o FIPS ao adicionar um pool de nós do Linux atualmente não é suportado no Azure portal. Para adicionar um pool de nós do Linux com FIPS habilitado, utilize o CLI do Azure, um modelo ARM, ou as instruções em Bicep ou Terraform disponíveis neste artigo.

1. Crie um pool de nós Linux com suporte a FIPS utilizando um modelo ARM ao implantar um recurso de pool de agentes, com a propriedade enableFips configurada 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. Implante o modelo do ARM usando o portal Azure, CLI do Azure ou Azure PowerShell. Para obter mais informações sobre como implantar modelos do ARM, consulte Implantar recursos com modelos do ARM.

3. Verifique a configuração do 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
   

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

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

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

   kubectl get nodes
   

   A saída de exemplo a seguir mostra uma lista dos nós no cluster. Os nós que começam com aks-fipsnp e fazem parte do pool de nós 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 em um 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. Seu resultado deve ser semelhante ao seguinte exemplo de saída:

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

   Os pools de nós habilitados para FIPS também têm um rótulo kubernetes.azure.com/fips_enabled=true, que as implantações podem usar para direcionar esses pools de nós.

1. Crie um pool de nós do Linux habilitado para FIPS usando Bicep implantando um recurso de pool de agentes com enableFIPS definido como 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. Implante o arquivo Bicep usando o CLI do Azure, o Azure PowerShell ou o portal Azure. Para obter mais informações sobre como implantar arquivos Bicep, consulte Criar arquivos Bicep usando Visual Studio Code.

3. Verifique a configuração do pool de nós usando o comando az aks show e realize 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 está habilitado para FIPS:

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

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

   kubectl get nodes
   

   A saída de exemplo a seguir mostra uma lista dos nós no cluster. Os nós que começam com aks-fipsnp e fazem parte do pool de nós 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 em um 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. Seu resultado deve ser semelhante ao seguinte exemplo de saída:

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

   Os pools de nós habilitados para FIPS também têm um rótulo kubernetes.azure.com/fips_enabled=true, que as implantações podem usar para direcionar esses pools de nós.

1. Adicione o seguinte código em main.tf para adicionar um pool de nós do Linux habilitado para FIPS no cluster do 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. Aplique a configuração atualizada do Terraform usando os comandos terraform plan e terraform apply.

   terraform plan
   terraform apply
   

3. Conecte-se ao cluster do 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 pool de nós 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 fipsnp está habilitado para FIPS:

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

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

   kubectl get nodes
   

   A saída de exemplo a seguir mostra uma lista dos nós no cluster. Os nós que começam com aks-fipsnp e fazem parte do pool de nós 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 em um 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. Seu resultado deve ser semelhante ao seguinte exemplo de saída:

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

   Os pools de nós habilitados para FIPS também têm um rótulo kubernetes.azure.com/fips_enabled=true, que as implantações podem usar para direcionar esses pools de nós.

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

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

3. Verifique se os pools de nós do Windows têm acesso às bibliotecas criptográficas FIPS ao criar uma conexão RDP com um nó Windows em um pool de nós e verificar o registro. No aplicativo Executar, insira regedit.

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

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

   

   Os pools de nós habilitados para FIPS também têm um rótulo kubernetes.azure.com/fips_enabled=true, que as implantações podem usar para direcionar esses pools de nós.

Não há uma experiência no portal do Azure para habilitar ou desabilitar as configurações do FIPS para pools de nós do Windows. Qualquer pool de nós Windows criado usando o portal do Azure tem FIPS habilitado. Windows Server 2022 e pools de nós de versões posteriores habilitam o FIPS por padrão, e pools de nós Windows Server 2025 e posteriores não oferecem suporte à desabilitação do FIPS.

1. Crie um pool de nós Windows usando um modelo ARM, implantando um recurso de pool de agentes com osType definido como 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. Implante o modelo do ARM usando o portal Azure, CLI do Azure ou Azure PowerShell. Para obter mais informações sobre como implantar modelos do ARM, consulte Implantar recursos com modelos do ARM.

3. Verifique a configuração do pool de nós usando o comando az aks show e verifique 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 às bibliotecas criptográficas FIPS criando uma conexão RDP com um nó Windows em um pool de nós e verificando o registro do sistema. No aplicativo Executar, insira regedit.

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

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

   

   Os pools de nós habilitados para FIPS também têm um rótulo kubernetes.azure.com/fips_enabled=true, que as implantações podem usar para direcionar esses pools de nós.

1. Crie um pool de nós Windows usando Bicep implantando 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. Implante o arquivo Bicep usando o CLI do Azure, o Azure PowerShell ou o portal Azure. Para obter mais informações sobre como implantar arquivos Bicep, consulte Criar arquivos Bicep usando Visual Studio Code.

3. Verifique a configuração do pool de nós usando o comando az aks show e consultar 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 às bibliotecas criptográficas FIPS estabelecendo uma conexão RDP com um nó Windows em um pool de nós e verificando o registro. No aplicativo Executar, insira regedit.

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

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

   

   Os pools de nós habilitados para FIPS também têm um rótulo kubernetes.azure.com/fips_enabled=true, que as implantações podem usar para direcionar esses pools de nós.

1. Adicione o seguinte código a main.tf para criar um pool de nós Windows no cluster do 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. Aplique a configuração atualizada do Terraform usando os comandos terraform plan e terraform apply.

   terraform plan
   terraform apply
   

3. Conecte-se ao cluster do 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 grupo 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
   

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

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

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

   

   Os pools de nós habilitados para FIPS também têm um rótulo kubernetes.azure.com/fips_enabled=true, que as implantações podem usar para direcionar esses pools de nós.

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

CLI do Azure versão 2.64.0 ou posterior. Para saber qual é a versão, execute az --version. Se precisar instalar ou atualizar, consulte Instalar CLI do Azure.

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
   

   Esse comando dispara uma nova imagem do pool de nós imediatamente para implantar o sistema operacional compatível com FIPS. Essa criação de imagem ocorre durante a atualização do pool de nós. Nenhuma etapa adicional é necessária.

2. Verifique se o pool de nodes está habilitado para FIPS 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 exemplo de saída a seguir mostra que o pool de nós np está habilitado para FIPS:

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

Habilitar FIPS em um pool de nós existente atualmente não é suportado no portal do Azure. Para habilitar o FIPS em um pool de nós existente, use o CLI do Azure, o template ARM, o Bicep, ou as instruções do Terraform neste artigo.

1. Habilite o FIPS no conjunto de nós existente usando um modelo ARM atualizando o perfil do pool de agentes para definir a propriedade enableFips como true. Por exemplo:

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

2. Implante o modelo atualizado usando o portal Azure, CLI do Azure ou Azure PowerShell. Para obter mais informações sobre como implantar modelos do ARM, consulte Implantar recursos com modelos do ARM.

3. Verifique se o pool de nodes está habilitado para FIPS 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 exemplo de saída a seguir mostra que o pool de nós np está habilitado para FIPS:

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

1. Habilite o FIPS em um pool de nós existente usando Bicep atualizando o recurso do pool de agentes para definir enableFIPS como 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. Implante o arquivo de Bicep atualizado usando o CLI do Azure, Azure PowerShell ou o portal Azure. Para obter mais informações sobre como implantar arquivos Bicep, consulte Criar arquivos Bicep usando Visual Studio Code.

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

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

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

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

1. Atualize o recurso azurerm_kubernetes_cluster_node_pool em main.tf definindo fips_enabled como 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. Aplique a configuração atualizada do Terraform usando os comandos terraform plan e terraform apply. O Terraform detecta a alteração em fips_enabled e dispara a operação de reinstalação de imagem necessária.

   terraform plan
   terraform apply
   

3. Conecte-se ao cluster do 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 pool de nodes está habilitado para FIPS 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 exemplo de saída a seguir mostra que o pool de nós np está habilitado para FIPS:

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

1. Atualize um pool de nós do 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
   

   Esse comando dispara uma nova imagem do pool de nós imediatamente para implantar o sistema operacional compatível com FIPS. Essa criação de imagem ocorre durante a atualização do pool de nós. Nenhuma etapa adicional é necessária.

2. Verifique se o pool de nós não está habilitado 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 não está habilitado para FIPS:

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

Atualmente, não há suporte para a desabilitação do FIPS em um pool de nós existente no portal do Azure. Para desabilitar o FIPS em um pool de nós existente, use as instruções do CLI do Azure, modelo ARM, Bicep ou Terraform neste artigo.

1. Desative o FIPS em um pool de nós existente utilizando um modelo ARM, atualizando o perfil do pool de agentes para definir a propriedade enableFips para false. Por exemplo:

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

2. Implante o modelo atualizado usando o portal Azure, CLI do Azure ou Azure PowerShell. Para obter mais informações sobre como implantar modelos do ARM, consulte Implantar recursos com modelos do ARM.

3. Verifique se o pool de nós não está habilitado para FIPS 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
   

   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. Desabilite o FIPS em um pool de nós existente usando Bicep atualizando o recurso do pool de agentes para definir enableFIPS como 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. Implante o arquivo de Bicep atualizado usando o CLI do Azure, Azure PowerShell ou o portal Azure. Para obter mais informações sobre como implantar arquivos Bicep, consulte Criar arquivos Bicep usando Visual Studio Code.

3. Verifique se o pool de nós não está habilitado para FIPS 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
   

   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 como 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. Aplique a configuração atualizada do Terraform usando os comandos terraform plan e terraform apply. O Terraform detecta a alteração em fips_enabled e aciona a operação de reimagem necessária.

   terraform plan
   terraform apply
   

3. Verifique se o pool de nós não está habilitado para FIPS usando o comando az aks show para consultar 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  
   

Mensagem do dia

Você pode substituir a Mensagem do Dia (MOTD) em nós do Linux usando a flag --message-of-the-day 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 a flag --message-of-the-day definida para o caminho do novo arquivo 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 configurada para o caminho do novo arquivo MOTD.

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