Habilitación del estándar federal de procesamiento de información (FIPS) para grupos de nodos de Azure Kubernetes Service (AKS)

• Terraform instalado localmente. Para obtener instrucciones de instalación, consulte Instalación de Terraform.

• CLI de Azure versión 2.32.0 o posterior instalada y configurada. Para encontrar la versión, ejecute az --version. Para obtener más información sobre cómo instalar o actualizar el CLI de Azure, consulte Install CLI de Azure.

• En los ejemplos de plantillas de ARM de este artículo se usa la versión de API 2023-03-01 para Microsoft.ContainerService/managedClusters y Microsoft.ContainerService/managedClusters/agentPools.

• Los ejemplos de Bicep de este artículo usan la versión de API 2023-03-01 para Microsoft.ContainerService/managedClusters y Microsoft.ContainerService/managedClusters/agentPools.

• En los ejemplos de Terraform de este artículo se usa el proveedor azureRM 3.x.
• Para la configuración de FIPS de Terraform, use enable_fips_image en azurerm_kubernetes_cluster.default_node_pool y fips_enabled en azurerm_kubernetes_cluster_node_pool.

Creación del archivo de configuración de Terraform

Los archivos de configuración de Terraform definen la infraestructura que Terraform crea y administra.

1. Cree un archivo denominado main.tf y agregue el código siguiente para definir la versión de Terraform y especifique el proveedor de Azure:

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

2. Agregue el código siguiente a main.tf para crear un grupo de recursos de Azure. No dude en cambiar el nombre y la ubicación del grupo de recursos según sea necesario.

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

Al crear más grupos de nodos en un clúster que ya tiene un grupo de nodos predeterminado habilitado para FIPS, también debe habilitar FIPS en los nuevos grupos de nodos mediante el --enable-fips-image parámetro .

1. Cree un clúster de AKS con FIPS habilitado en el grupo de nodos predeterminado mediante el comando az aks create con el parámetro --enable-fips-image.

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

2. Compruebe que el grupo de nodos está habilitado para FIPS con el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   En la salida de ejemplo siguiente se muestra que el grupo de nodos predeterminado está habilitado para FIPS:

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

Habilitar FIPS durante la creación de clústeres de AKS actualmente no se admite en el portal de Azure. Para crear un clúster con un grupo de nodos predeterminado habilitado para FIPS, use las instrucciones de CLI de Azure, plantilla de ARM, Bicep o Terraform de este artículo.

Al crear más pools de nodos en un clúster que ya tiene un pool de nodos predeterminado con FIPS habilitado, también debe habilitar FIPS en los nuevos pools de nodos configurando enableFips a true.

1. Cree un clúster de AKS con FIPS habilitado en el grupo de nodos predeterminado mediante una plantilla de ARM. Para ello, en la propiedad enableFips use true en el perfil del grupo de agentes. Por ejemplo:

   {
     "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 la plantilla de ARM mediante el portal Azure, CLI de Azure o Azure PowerShell. Para más información sobre la implementación de plantillas de ARM, consulte Implementación de recursos con plantillas de ARM.

3. Compruebe que el grupo de nodos está habilitado para FIPS con el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   En la salida de ejemplo siguiente se muestra que el grupo de nodos predeterminado está habilitado para FIPS:

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

Al crear más grupos de nodos en un clúster que ya tenga un grupo de nodos predeterminado habilitado para FIPS, también debe habilitar FIPS en los nuevos grupos de nodos configurando los parámetros de enableFIPS a true.

1. Cree un clúster de AKS con FIPS habilitado en el grupo de nodos predeterminado utilizando Bicep. Para ello, en enableFIPS use true en el perfil del grupo de agentes. Por ejemplo:

   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 el archivo Bicep mediante el CLI de Azure, el Azure PowerShell o el portal Azure. Para obtener más información sobre la implementación de archivos Bicep, consulte Crear archivos de Bicep mediante Visual Studio Code.

3. Compruebe que el grupo de nodos está habilitado para FIPS con el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   En la salida de ejemplo siguiente se muestra que el grupo de nodos predeterminado está habilitado para FIPS:

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

Al crear más grupos de nodos en un clúster que ya tiene un grupo de nodos predeterminado habilitado para FIPS, también debe habilitar FIPS en los nuevos grupos de nodos estableciendo fips_enabledtrue en azurerm_kubernetes_cluster_node_pool.

1. Agregue el código siguiente en main.tf para crear un clúster de AKS con FIPS habilitado en el grupo de nodos predeterminado:

   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. Inicialice Terraform en el directorio que contiene el archivo main.tf usando el comando terraform init.

   terraform init
   

3. Cree un plan de ejecución de Terraform mediante el comando terraform plan.

   terraform plan
   

4. Aplique la configuración mediante el terraform apply comando para implementar el clúster con un grupo de nodos predeterminado habilitado para FIPS.

   terraform apply
   

5. Conéctese al clúster de AKS mediante el comando [az aks get-credentials][az-aks-get-credentials].

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

6. Compruebe que el grupo de nodos está habilitado para FIPS con el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   En la salida de ejemplo siguiente se muestra que el grupo de nodos predeterminado está habilitado para FIPS:

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

Para obtener más información sobre el recurso azurerm_kubernetes_cluster, consulte la documentación del proveedor Terraform Azure.

1. Agregue un grupo de nodos de Linux habilitado para FIPS a un clúster existente mediante el comando az aks nodepool add con el parámetro --enable-fips-image.

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

2. Compruebe la configuración del grupo de nodos con el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   La siguiente salida de ejemplo muestra que el grupo de nodos fipsnp tiene FIPS habilitado:

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

3. Enumere los nodos mediante el comando kubectl get nodes.

   kubectl get nodes
   

   La siguiente salida de ejemplo muestra una lista de todos los nodos del clúster. Los nodos que empiezan por aks-fipsnp forman parte del grupo de nodos con FIPS habilitado.

   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. Ejecute una implementación con una sesión interactiva en uno de los nodos del grupo de nodos con FIPS habilitado mediante el comando kubectl debug.

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

5. Desde la salida de sesión interactiva, puede comprobar que las bibliotecas criptográficas de FIPS estén habilitadas. El resultado debería ser similar al ejemplo siguiente:

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

   Los grupos de nodos con FIPS habilitado también tienen la etiqueta kubernetes.azure.com/fips_enabled=true, que las implementaciones pueden usar para dirigirse a esos grupos de nodos.

Habilitar FIPS al agregar un grupo de nodos de Linux actualmente no está soportado en el portal de Azure. Para agregar un grupo de nodos de Linux habilitado para FIPS, use las instrucciones de CLI de Azure, plantilla de ARM, Bicep o Terraform de este artículo.

1. Cree un grupo de nodos de Linux habilitado para FIPS usando una plantilla de ARM al implementar un recurso de grupo de agentes con la propiedad enableFips configurada en true. Por ejemplo:

   {
     "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 la plantilla de ARM mediante el portal Azure, CLI de Azure o Azure PowerShell. Para más información sobre la implementación de plantillas de ARM, consulte Implementación de recursos con plantillas de ARM.

3. Compruebe la configuración del grupo de nodos con el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   La siguiente salida de ejemplo muestra que el grupo de nodos fipsnp tiene FIPS habilitado:

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

4. Enumere los nodos mediante el comando kubectl get nodes.

   kubectl get nodes
   

   La siguiente salida de ejemplo muestra una lista de todos los nodos del clúster. Los nodos que empiezan por aks-fipsnp forman parte del grupo de nodos con FIPS habilitado.

   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. Ejecute una implementación con una sesión interactiva en uno de los nodos del grupo de nodos con FIPS habilitado mediante el comando kubectl debug.

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

6. Desde la salida de sesión interactiva, puede comprobar que las bibliotecas criptográficas de FIPS estén habilitadas. El resultado debería ser similar al ejemplo siguiente:

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

   Los grupos de nodos con FIPS habilitado también tienen la etiqueta kubernetes.azure.com/fips_enabled=true, que las implementaciones pueden usar para dirigirse a esos grupos de nodos.

1. Cree un grupo de nodos de Linux habilitado para FIPS mediante Bicep mediante la implementación de un recurso de grupo de agentes con enableFIPS establecido en true. Por ejemplo:

   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 el archivo Bicep mediante el CLI de Azure, el Azure PowerShell o el portal Azure. Para obtener más información sobre la implementación de archivos Bicep, consulte Crear archivos de Bicep mediante Visual Studio Code.

3. Compruebe la configuración del grupo de nodos con el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   La siguiente salida de ejemplo muestra que el grupo de nodos fipsnp tiene FIPS habilitado:

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

4. Enumere los nodos mediante el comando kubectl get nodes.

   kubectl get nodes
   

   La siguiente salida de ejemplo muestra una lista de todos los nodos del clúster. Los nodos que empiezan por aks-fipsnp forman parte del grupo de nodos con FIPS habilitado.

   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. Ejecute una implementación con una sesión interactiva en uno de los nodos del grupo de nodos con FIPS habilitado mediante el comando kubectl debug.

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

6. Desde la salida de sesión interactiva, puede comprobar que las bibliotecas criptográficas de FIPS estén habilitadas. El resultado debería ser similar al ejemplo siguiente:

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

   Los grupos de nodos con FIPS habilitado también tienen la etiqueta kubernetes.azure.com/fips_enabled=true, que las implementaciones pueden usar para dirigirse a esos grupos de nodos.

1. Agregue el siguiente código a main.tf para añadir un grupo de nodos de Linux habilitado para FIPS en su clúster de 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 la configuración actualizada de Terraform mediante los terraform plan comandos y terraform apply .

   terraform plan
   terraform apply
   

3. Conéctese al clúster de AKS mediante el comando [az aks get-credentials][az-aks-get-credentials].

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

4. Compruebe la configuración del grupo de nodos con el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   La siguiente salida de ejemplo muestra que el grupo de nodos fipsnp tiene FIPS habilitado:

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

5. Enumere los nodos mediante el comando kubectl get nodes.

   kubectl get nodes
   

   La siguiente salida de ejemplo muestra una lista de todos los nodos del clúster. Los nodos que empiezan por aks-fipsnp forman parte del grupo de nodos con FIPS habilitado.

   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. Ejecute una implementación con una sesión interactiva en uno de los nodos del grupo de nodos con FIPS habilitado mediante el comando kubectl debug.

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

7. Desde la salida de sesión interactiva, puede comprobar que las bibliotecas criptográficas de FIPS estén habilitadas. El resultado debería ser similar al ejemplo siguiente:

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

   Los grupos de nodos con FIPS habilitado también tienen la etiqueta kubernetes.azure.com/fips_enabled=true, que las implementaciones pueden usar para dirigirse a esos grupos de nodos.

Para obtener más información sobre el recurso azurerm_kubernetes_cluster_node_pool, consulte la documentación del proveedor Terraform Azure.

1. Cree un grupo de nodos de Windows mediante el comando az aks nodepool add. A diferencia de los grupos de nodos basados en Linux, Windows grupos de nodos comparten el mismo conjunto de imágenes.

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

2. Compruebe la configuración del grupo de nodos con el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

3. Compruebe que los grupos de nodos de Windows tienen acceso a las bibliotecas criptográficas FIPS creando una conexión RDP con un nodo de Windows en un grupo de nodos y comprobando el registro. En Ejecutar aplicación, escriba regedit.

4. Busque HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy en el registro.

5. Si Enabled está establecido en 1, FIPS está habilitado.

   

   Los grupos de nodos con FIPS habilitado también tienen la etiqueta kubernetes.azure.com/fips_enabled=true, que las implementaciones pueden usar para dirigirse a esos grupos de nodos.

No hay una experiencia del portal de Azure para habilitar o deshabilitar la configuración de FIPS para grupos de nodos de Windows. Los grupos de nodos de Windows creados mediante Azure portal tienen habilitado FIPS. Windows Server 2022 y grupos de nodos posteriores habilitan FIPS de forma predeterminada y Windows Server 2025 y grupos de nodos posteriores no admiten la deshabilitación de FIPS.

1. Cree un grupo de nodos de Windows mediante una plantilla de ARM mediante la implementación de un recurso de grupo de agentes con osType establecido en Windows. Por ejemplo:

   {
     "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 la plantilla de ARM mediante el portal Azure, CLI de Azure o Azure PowerShell. Para más información sobre la implementación de plantillas de ARM, consulte Implementación de recursos con plantillas de ARM.

3. Compruebe la configuración del grupo de nodos con el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

4. Compruebe que los grupos de nodos de Windows tienen acceso a las bibliotecas criptográficas FIPS creando una conexión RDP a un nodo de Windows en un grupo de nodos y compruebe el registro. En Ejecutar aplicación, escriba regedit.

5. Busque HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy en el registro.

6. Si Enabled está establecido en 1, FIPS está habilitado.

   

   Los grupos de nodos con FIPS habilitado también tienen la etiqueta kubernetes.azure.com/fips_enabled=true, que las implementaciones pueden usar para dirigirse a esos grupos de nodos.

1. Cree un grupo de nodos de Windows mediante Bicep mediante la implementación de un recurso de grupo de agentes con osType establecido en Windows. Por ejemplo:

   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 el archivo Bicep mediante el CLI de Azure, el Azure PowerShell o el portal Azure. Para obtener más información sobre la implementación de archivos Bicep, consulte Crear archivos de Bicep mediante Visual Studio Code.

3. Compruebe la configuración del grupo de nodos con el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

4. Verifique que los grupos de nodos de Windows tengan acceso a las bibliotecas criptográficas FIPS mediante la creación de una conexión RDP a un nodo de Windows en un grupo de nodos y la comprobación del registro. En Ejecutar aplicación, escriba regedit.

5. Busque HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy en el registro.

6. Si Enabled está establecido en 1, FIPS está habilitado.

   

   Los grupos de nodos con FIPS habilitado también tienen la etiqueta kubernetes.azure.com/fips_enabled=true, que las implementaciones pueden usar para dirigirse a esos grupos de nodos.

1. Agregue el código siguiente a main.tf para crear un grupo de nodos de Windows en el clúster de 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 la configuración actualizada de Terraform mediante los terraform plan comandos y terraform apply .

   terraform plan
   terraform apply
   

3. Conéctese al clúster de AKS mediante el comando [az aks get-credentials][az-aks-get-credentials].

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

4. Compruebe la configuración del grupo de nodos con el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

5. Compruebe que los grupos de nodos de Windows tienen acceso a las bibliotecas criptográficas FIPS creando una conexión RDP a un nodo de Windows en un grupo de nodos y comprobar el registro. En Ejecutar aplicación, escriba regedit.

6. Busque HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy en el registro.

7. Si Enabled está establecido en 1, FIPS está habilitado.

   

   Los grupos de nodos con FIPS habilitado también tienen la etiqueta kubernetes.azure.com/fips_enabled=true, que las implementaciones pueden usar para dirigirse a esos grupos de nodos.

Requisitos previos para actualizar un grupo de nodos existente

CLI de Azure versión 2.64.0 o posterior. Para encontrar la versión, ejecute az --version. Si necesita instalar o actualizar, consulte Install CLI de Azure.

1. Actualice un grupo de nodos mediante el az aks nodepool update comando con el --enable-fips-image parámetro .

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

   Este comando desencadena una nueva imagen del grupo de nodos inmediatamente para implementar el sistema operativo compatible con FIPS. Esta nueva imagen se produce durante la actualización del grupo de nodos. No se requieren pasos adicionales.

2. Compruebe que el grupo de nodos está habilitado para FIPS con el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   La siguiente salida de ejemplo muestra que el grupo de nodos np está habilitado para FIPS:

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

Habilitar FIPS en un grupo de nodos existente actualmente no se admite en el portal de Azure. Para habilitar FIPS en un grupo de nodos existente, use las instrucciones de CLI de Azure, plantilla de ARM, Bicep o Terraform de este artículo.

1. Habilite FIPS en un grupo de nodos existente mediante una plantilla de ARM mediante la actualización del perfil del grupo de agentes para establecer la enableFips propiedad en true. Por ejemplo:

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

2. Implemente la plantilla actualizada mediante el portal de Azure, CLI de Azure o Azure PowerShell. Para más información sobre la implementación de plantillas de ARM, consulte Implementación de recursos con plantillas de ARM.

3. Compruebe que el grupo de nodos está habilitado para FIPS con el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   La siguiente salida de ejemplo muestra que el grupo de nodos np está habilitado para FIPS:

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

1. Habilite FIPS en un grupo de nodos existente mediante Bicep actualizando el recurso del grupo de agentes para establecer enableFIPS en true. Por ejemplo:

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

2. Implemente el archivo de Bicep actualizado mediante el CLI de Azure, el Azure PowerShell o el portal Azure. Para obtener más información sobre la implementación de archivos Bicep, consulte Crear archivos de Bicep mediante Visual Studio Code.

3. Compruebe que el grupo de nodos está habilitado para FIPS mediante el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   La siguiente salida de ejemplo muestra que el grupo de nodos np está habilitado para FIPS:

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

1. Actualice el recurso azurerm_kubernetes_cluster_node_pool en main.tf configurando fips_enabled a 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 la configuración actualizada de Terraform mediante los terraform plan comandos y terraform apply . Terraform detecta el cambio a fips_enabled y desencadena la operación de reimagen necesaria.

   terraform plan
   terraform apply
   

3. Conéctese al clúster de AKS mediante el comando [az aks get-credentials][az-aks-get-credentials].

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

4. Compruebe que el grupo de nodos está habilitado para FIPS con el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   La siguiente salida de ejemplo muestra que el grupo de nodos np está habilitado para FIPS:

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

1. Actualice un grupo de nodos de Linux mediante el az aks nodepool update comando con el --disable-fips-image parámetro .

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

   Este comando desencadena una nueva imagen del grupo de nodos inmediatamente para implementar el sistema operativo compatible con FIPS. Esta nueva imagen se produce durante la actualización del grupo de nodos. No se requieren pasos adicionales.

2. Compruebe que el grupo de nodos no está habilitado para FIPS mediante el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   En la salida de ejemplo siguiente se muestra que el grupo de nodos np no está habilitado para FIPS:

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

Deshabilitar FIPS en un grupo de nodos existente actualmente no se admite en el portal de Azure. Para deshabilitar FIPS en un grupo de nodos existente, use las instrucciones de CLI de Azure, plantilla de ARM, Bicep o Terraform de este artículo.

1. Deshabilite FIPS en un grupo de nodos existente mediante una plantilla de ARM mediante la actualización del perfil del grupo de agentes para establecer la enableFips propiedad en false. Por ejemplo:

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

2. Implemente la plantilla actualizada mediante el portal de Azure, CLI de Azure o Azure PowerShell. Para más información sobre la implementación de plantillas de ARM, consulte Implementación de recursos con plantillas de ARM.

3. Compruebe que el grupo de nodos no está habilitado para FIPS mediante el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   En la salida de ejemplo siguiente se muestra que el grupo de nodos np no está habilitado para FIPS:

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

1. Deshabilite FIPS en un grupo de nodos existente mediante Bicep actualizando el recurso del grupo de agentes para establecer enableFIPS en false. Por ejemplo:

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

2. Implemente el archivo de Bicep actualizado mediante el CLI de Azure, el Azure PowerShell o el portal Azure. Para obtener más información sobre la implementación de archivos Bicep, consulte Crear archivos de Bicep mediante Visual Studio Code.

3. Compruebe que el grupo de nodos no está habilitado para FIPS mediante el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   En la salida de ejemplo siguiente se muestra que el grupo de nodos np no está habilitado para FIPS:

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

1. Actualice el recurso azurerm_kubernetes_cluster_node_pool en main.tf cambiando fips_enabled por el valor 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 la configuración actualizada de Terraform mediante los terraform plan comandos y terraform apply . Terraform detecta el cambio en fips_enabled y desencadena la operación de reimagen necesaria.

   terraform plan
   terraform apply
   

3. Compruebe que el grupo de nodos no está habilitado para FIPS mediante el az aks show comando y consulte el valor enableFIPS en agentPoolProfiles.

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

   En la salida de ejemplo siguiente se muestra que el grupo de nodos np no está habilitado para FIPS:

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

Mensaje del día

Puede reemplazar el mensaje del día (MOTD) en los nodos de Linux mediante la --message-of-the-day marca al crear un clúster o agregar un grupo de nodos.

Cree un clúster y reemplace el mensaje del día usando el comando az aks create con la bandera --message-of-the-day establecida en la ruta del nuevo archivo de mensaje del día (MOTD).

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

Agregue un grupo de nodos y reemplace el mensaje del día usando el comando az aks nodepool add con el parámetro --message-of-the-day establecido en la ruta de acceso del nuevo archivo MOTD.

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