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

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

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

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

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.

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.

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.

   

   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.

   

   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.

   

   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.

   

   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.

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.

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  
   

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