Activer la norme FIPS (Federal Information Processing Standard) pour les pools de nœuds Azure Kubernetes Service (AKS)

• Terraform installé localement. Pour obtenir des instructions d’installation, consultez Installer Terraform.

• Azure CLI version 2.32.0 ou ultérieure installée et configurée. Pour connaître la version de l’interface, exécutez az --version. Pour plus d’informations sur l’installation ou la mise à niveau du Azure CLI, consultez Install Azure CLI.

• Les exemples de modèles ARM de cet article utilisent la version de l’API 2023-03-01 pour Microsoft.ContainerService/managedClusters et Microsoft.ContainerService/managedClusters/agentPools.

• Les exemples Bicep de cet article utilisent la version d’API 2023-03-01 pour Microsoft.ContainerService/managedClusters et Microsoft.ContainerService/managedClusters/agentPools.

• Les exemples Terraform de cet article utilisent le fournisseur AzureRM 3.x.
• Pour les paramètres FIPS Terraform, utilisez enable_fips_image sur azurerm_kubernetes_cluster.default_node_pool et fips_enabled sur azurerm_kubernetes_cluster_node_pool.

Créer le fichier de configuration Terraform

Les fichiers de configuration Terraform définissent l’infrastructure que Terraform crée et gère.

1. Créez un fichier nommé main.tf et ajoutez le code suivant pour définir la version Terraform et spécifier le fournisseur Azure :

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

2. Ajoutez le code suivant à main.tf pour créer un groupe de ressources Azure. N’hésitez pas à modifier le nom et l’emplacement du groupe de ressources en fonction des besoins.

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

Lors de la création de pools de nœuds supplémentaires sur un cluster qui possède déjà un pool de nœuds par défaut compatible FIPS, vous devez également activer FIPS sur les nouveaux pools de nœuds à l’aide du --enable-fips-image paramètre.

1. Créez un cluster AKS avec FIPS activé sur le pool de nœuds par défaut à l’aide de la az aks create commande avec le --enable-fips-image paramètre.

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

2. Vérifiez que votre pool de nœuds est activé par FIPS à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds par défaut est activé par FIPS :

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

L'activation de FIPS lors de la création d'un cluster AKS n'est pas prise en charge dans le portail Azure. Pour créer un cluster avec un pool de nœuds par défaut compatible FIPS, utilisez les instructions Azure CLI, arm, Bicep ou Terraform dans cet article.

Lors de la création de pools de nœuds supplémentaires sur un cluster qui a déjà un pool de nœuds par défaut compatible FIPS, vous devez également activer FIPS sur les nouveaux pools de nœuds en définissant enableFips sur true.

1. Créez un cluster AKS avec FIPS activé sur le pool de nœuds par défaut à l’aide d’un modèle ARM en définissant la propriété enableFips à true dans le profil du pool de nœuds. Par exemple:

   {
     "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. Déployez le modèle ARM à l’aide du portail Azure, Azure CLI ou Azure PowerShell. Pour plus d’informations sur le déploiement de modèles ARM, consultez Déployer des ressources avec des modèles ARM.

3. Vérifiez que votre pool de nœuds est activé par FIPS à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds par défaut est activé par FIPS :

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

Lors de la création de pools de nœuds supplémentaires sur un cluster qui a déjà un pool de nœuds par défaut compatible FIPS, vous devez également activer FIPS sur les nouveaux pools de nœuds en définissant enableFIPS sur true.

1. Créez un cluster AKS avec FIPS activé sur le pool de nœuds par défaut à l’aide de Bicep en définissant enableFIPS sur true dans le profil du pool d’agents. Par exemple:

   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. Déployez le fichier Bicep à l’aide du Azure CLI, du Azure PowerShell ou du portail Azure. Pour plus d’informations sur le déploiement de fichiers Bicep, consultez Créer des fichiers Bicep à l’aide de Visual Studio Code.

3. Vérifiez que votre pool de nœuds est activé par FIPS à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds par défaut est activé par FIPS :

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

Lorsque vous créez d’autres pools de nœuds sur un cluster qui dispose déjà d’un pool de nœuds par défaut compatible FIPS, vous devez également activer FIPS sur les nouveaux pools de nœuds en réglant fips_enabled sur true dans azurerm_kubernetes_cluster_node_pool.

1. Ajoutez le code suivant pour main.tf créer un cluster AKS avec FIPS activé sur le pool de nœuds par défaut :

   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. Initialisez Terraform dans le répertoire contenant votre main.tf fichier à l’aide de la terraform init commande.

   terraform init
   

3. Créez un plan d’exécution Terraform à l’aide de la commande terraform plan.

   terraform plan
   

4. Appliquez la configuration à l’aide de la terraform apply commande pour déployer le cluster avec un pool de nœuds par défaut compatible FIPS.

   terraform apply
   

5. Connectez-vous au cluster AKS à l’aide de la commande [az aks get-credentials][az-aks-get-credentials].

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

6. Vérifiez que votre pool de nœuds est activé par FIPS à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds par défaut est activé par FIPS :

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

Pour plus d’informations sur la ressource , consultez la documentation du fournisseur Terraform Azure .

1. Ajoutez un pool de nœuds Linux compatible FIPS à un cluster existant à l’aide de la az aks nodepool add commande avec le --enable-fips-image paramètre.

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

2. Vérifiez la configuration de votre pool de nœuds à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds fipsnp est compatible FIPS :

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

3. Listez les nœuds à l’aide de la commande kubectl get nodes.

   kubectl get nodes
   

   L’exemple de sortie suivant présente la liste des nœuds du cluster. Les nœuds commençant par aks-fipsnp font partie du pool de nœuds compatible 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. Exécutez un déploiement avec une session interactive sur l’un des nœuds du pool de nœuds compatible FIPS à l’aide de la commande kubectl debug.

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

5. Dans la sortie de la session interactive, vérifiez que les bibliothèques de chiffrement FIPS sont activées. Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

   Les pools de nœuds compatibles FIPS présentent également une étiquette kubernetes.azure.com/fips_enabled=true, que les déploiements peuvent utiliser pour cibler ces pools de nœuds.

L'activation de FIPS lors de l'ajout d'un pool de nœuds Linux n'est actuellement pas prise en charge dans le portail Azure. Pour ajouter un pool de nœuds Linux compatible FIPS, utilisez les instructions Azure CLI, modèle ARM, Bicep ou Terraform dans cet article.

1. Créez un pool de nœuds Linux compatible FIPS à l’aide d’un modèle ARM en déployant une ressource de pool d’agents avec la propriété enableFips définie sur true. Par exemple:

   {
     "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. Déployez le modèle ARM à l’aide du portail Azure, Azure CLI ou Azure PowerShell. Pour plus d’informations sur le déploiement de modèles ARM, consultez Déployer des ressources avec des modèles ARM.

3. Vérifiez la configuration de votre pool de nœuds à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds fipsnp est compatible FIPS :

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

4. Listez les nœuds à l’aide de la commande kubectl get nodes.

   kubectl get nodes
   

   L’exemple de sortie suivant présente la liste des nœuds du cluster. Les nœuds commençant par aks-fipsnp font partie du pool de nœuds compatible 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. Exécutez un déploiement avec une session interactive sur l’un des nœuds du pool de nœuds compatible FIPS à l’aide de la commande kubectl debug.

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

6. Dans la sortie de la session interactive, vérifiez que les bibliothèques de chiffrement FIPS sont activées. Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

   Les pools de nœuds compatibles FIPS présentent également une étiquette kubernetes.azure.com/fips_enabled=true, que les déploiements peuvent utiliser pour cibler ces pools de nœuds.

1. Créez un pool de nœuds Linux compatible FIPS à l’aide de Bicep en déployant une ressource de pool d’agents avec enableFIPS défini sur true. Par exemple:

   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. Déployez le fichier Bicep à l’aide du Azure CLI, du Azure PowerShell ou du portail Azure. Pour plus d’informations sur le déploiement de fichiers Bicep, consultez Créer des fichiers Bicep à l’aide de Visual Studio Code.

3. Vérifiez la configuration de votre pool de nœuds à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds fipsnp est compatible FIPS :

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

4. Listez les nœuds à l’aide de la commande kubectl get nodes.

   kubectl get nodes
   

   L’exemple de sortie suivant présente la liste des nœuds du cluster. Les nœuds commençant par aks-fipsnp font partie du pool de nœuds compatible 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. Exécutez un déploiement avec une session interactive sur l’un des nœuds du pool de nœuds compatible FIPS à l’aide de la commande kubectl debug.

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

6. Dans la sortie de la session interactive, vérifiez que les bibliothèques de chiffrement FIPS sont activées. Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

   Les pools de nœuds compatibles FIPS présentent également une étiquette kubernetes.azure.com/fips_enabled=true, que les déploiements peuvent utiliser pour cibler ces pools de nœuds.

1. Ajoutez le code suivant à main.tf pour ajouter un pool de nœuds Linux compatible FIPS dans votre 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. Appliquez la configuration Terraform mise à jour à l’aide des commandes terraform plan et terraform apply.

   terraform plan
   terraform apply
   

3. Connectez-vous au cluster AKS à l’aide de la commande [az aks get-credentials][az-aks-get-credentials].

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

4. Vérifiez la configuration de votre pool de nœuds à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds fipsnp est compatible FIPS :

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

5. Listez les nœuds à l’aide de la commande kubectl get nodes.

   kubectl get nodes
   

   L’exemple de sortie suivant présente la liste des nœuds du cluster. Les nœuds commençant par aks-fipsnp font partie du pool de nœuds compatible 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. Exécutez un déploiement avec une session interactive sur l’un des nœuds du pool de nœuds compatible FIPS à l’aide de la commande kubectl debug.

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

7. Dans la sortie de la session interactive, vérifiez que les bibliothèques de chiffrement FIPS sont activées. Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

   Les pools de nœuds compatibles FIPS présentent également une étiquette kubernetes.azure.com/fips_enabled=true, que les déploiements peuvent utiliser pour cibler ces pools de nœuds.

Pour plus d'informations sur la ressource azurerm_kubernetes_cluster_node_pool, consultez la documentation du fournisseur Terraform pour Azure.

1. Créez un pool de nœuds Windows à l’aide de la commande az aks nodepool add. Contrairement aux pools de nœuds Linux, les pools de nœuds Windows partagent le même ensemble d’images.

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

2. Vérifiez la configuration de votre pool de nœuds à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

3. Vérifiez que Windows pools de nœuds ont accès aux bibliothèques de chiffrement FIPS en créant une connexion RDP à un nœud Windows dans un pool de nœuds et en vérifiant le Registre. À partir de l’application Exécuter, entrez regedit.

4. Recherchez HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy dans le registre.

5. Si Enabled est défini sur 1, FIPS est activé.

   

   Les pools de nœuds compatibles FIPS présentent également une étiquette kubernetes.azure.com/fips_enabled=true, que les déploiements peuvent utiliser pour cibler ces pools de nœuds.

Il n'existe pas d'expérience de portail Azure pour activer ou désactiver les paramètres FIPS pour les pools de nœuds Windows. Les pools de nœuds Windows créés à l’aide du portail Azure ont activé FIPS. Windows Server 2022 et les pools de nœuds ultérieurs activent FIPS par défaut, et Windows Server 2025 et les pools de nœuds ultérieurs ne prennent pas en charge la désactivation de FIPS.

1. Créez un pool de nœuds Windows à l’aide d’un modèle ARM en déployant une ressource de pool d’agents avec osType défini sur Windows. Par exemple:

   {
     "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. Déployez le modèle ARM à l’aide du portail Azure, Azure CLI ou Azure PowerShell. Pour plus d’informations sur le déploiement de modèles ARM, consultez Déployer des ressources avec des modèles ARM.

3. Vérifiez la configuration de votre pool de nœuds à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

4. Vérifiez que Windows pools de nœuds ont accès aux bibliothèques de chiffrement FIPS en créant une connexion RDP à un nœud Windows dans un pool de nœuds et en vérifiant le Registre. À partir de l’application Exécuter, entrez regedit.

5. Recherchez HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy dans le registre.

6. Si Enabled est défini sur 1, FIPS est activé.

   

   Les pools de nœuds compatibles FIPS présentent également une étiquette kubernetes.azure.com/fips_enabled=true, que les déploiements peuvent utiliser pour cibler ces pools de nœuds.

1. Créez un pool de nœuds Windows à l’aide de Bicep en déployant une ressource de pool d’agents avec osType configuré sur Windows. Par exemple:

   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. Déployez le fichier Bicep à l’aide du Azure CLI, du Azure PowerShell ou du portail Azure. Pour plus d’informations sur le déploiement de fichiers Bicep, consultez Créer des fichiers Bicep à l’aide de Visual Studio Code.

3. Vérifiez la configuration de votre pool de nœuds à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

4. Vérifiez que Windows pools de nœuds ont accès aux bibliothèques de chiffrement FIPS en créant une connexion RDP à un nœud Windows dans un pool de nœuds et en vérifiant le Registre. À partir de l’application Exécuter, entrez regedit.

5. Recherchez HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy dans le registre.

6. Si Enabled est défini sur 1, FIPS est activé.

   

   Les pools de nœuds compatibles FIPS présentent également une étiquette kubernetes.azure.com/fips_enabled=true, que les déploiements peuvent utiliser pour cibler ces pools de nœuds.

1. Ajoutez le code suivant à main.tf pour créer un pool de nœuds Windows dans votre 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. Appliquez la configuration Terraform mise à jour à l’aide des commandes terraform plan et terraform apply.

   terraform plan
   terraform apply
   

3. Connectez-vous au cluster AKS à l’aide de la commande [az aks get-credentials][az-aks-get-credentials].

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

4. Vérifiez la configuration de votre pool de nœuds à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

5. Vérifiez que Windows pools de nœuds ont accès aux bibliothèques de chiffrement FIPS en créant une connexion RDP à un nœud Windows dans un pool de nœuds et en vérifiant le Registre. À partir de l’application Exécuter, entrez regedit.

6. Recherchez HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy dans le registre.

7. Si Enabled est défini sur 1, FIPS est activé.

   

   Les pools de nœuds compatibles FIPS présentent également une étiquette kubernetes.azure.com/fips_enabled=true, que les déploiements peuvent utiliser pour cibler ces pools de nœuds.

Conditions préalables à la mise à jour d’un pool de nœuds existant

Azure CLI version 2.64.0 ou ultérieure. Pour connaître la version de l’interface, exécutez az --version. Si vous devez installer ou mettre à niveau, consultez Installer Azure CLI.

1. Mettez à jour un pool de nœuds à l'aide de la commande az aks nodepool update avec le paramètre --enable-fips-image.

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

   Cette commande déclenche immédiatement une nouvelle image du pool de nœuds pour déployer le système d’exploitation conforme à FIPS. Cette réinitialisation se produit pendant la mise à jour du pool de nœuds. Aucune étape supplémentaire n’est requise.

2. Vérifiez que votre pool de nœuds est activé par FIPS à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds np est compatible avec FIPS :

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

L'activation de FIPS sur un pool de nœuds existant n'est pas prise en charge dans le portail Azure. Pour activer FIPS sur un pool de nœuds existant, utilisez les instructions Azure CLI, modèle ARM, Bicep ou Terraform dans cet article.

1. Activez FIPS sur un pool de nœuds existant à l’aide d’un modèle ARM en mettant à jour le profil du pool d’agents pour définir la propriété enableFips à true. Par exemple:

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

2. Déployez le modèle mis à jour à l’aide du portail Azure, Azure CLI ou Azure PowerShell. Pour plus d’informations sur le déploiement de modèles ARM, consultez Déployer des ressources avec des modèles ARM.

3. Vérifiez que votre pool de nœuds est activé par FIPS à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds np est compatible avec FIPS :

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

1. Activez FIPS sur un pool de nœuds existant à l’aide de Bicep en mettant à jour la ressource du pool d’agents pour définir enableFIPS sur true. Par exemple:

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

2. Déployez le fichier Bicep mis à jour à l’aide des Azure CLI, des Azure PowerShell ou du portail Azure. Pour plus d’informations sur le déploiement de fichiers Bicep, consultez Créer des fichiers Bicep à l’aide de Visual Studio Code.

3. Vérifiez que votre pool de nœuds est activé par FIPS à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds np est compatible avec FIPS :

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

1. Mettez à jour la azurerm_kubernetes_cluster_node_pool ressource en main.tf définissant fips_enabled sur 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. Appliquez la configuration Terraform mise à jour à l’aide des commandes terraform plan et terraform apply. Terraform détecte la modification de fips_enabled et déclenche l’opération de réinitialisation nécessaire.

   terraform plan
   terraform apply
   

3. Connectez-vous au cluster AKS à l’aide de la commande [az aks get-credentials][az-aks-get-credentials].

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

4. Vérifiez que votre pool de nœuds est activé par FIPS à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds np est compatible avec FIPS :

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

1. Mettez à jour un pool de nœuds Linux à l’aide de la az aks nodepool update commande avec le --disable-fips-image paramètre.

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

   Cette commande déclenche immédiatement une nouvelle image du pool de nœuds pour déployer le système d’exploitation conforme à FIPS. Cette réinitialisation se produit pendant la mise à jour du pool de nœuds. Aucune étape supplémentaire n’est requise.

2. Vérifiez que votre pool de nœuds n’est pas activé par FIPS à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds np n’est pas activé par FIPS :

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

La désactivation de FIPS sur un pool de nœuds existant n'est pas prise en charge dans le portail Azure. Pour désactiver FIPS sur un pool de nœuds existant, utilisez les instructions Azure CLI, modèle ARM, Bicep ou Terraform dans cet article.

1. Désactivez FIPS sur un pool de nœuds existant à l’aide d’un modèle ARM en mettant à jour le profil du pool d’agents pour définir la propriété enableFips sur false. Par exemple:

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

2. Déployez le modèle mis à jour à l’aide du portail Azure, Azure CLI ou Azure PowerShell. Pour plus d’informations sur le déploiement de modèles ARM, consultez Déployer des ressources avec des modèles ARM.

3. Vérifiez que votre pool de nœuds n’est pas activé par FIPS à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds np n’est pas activé par FIPS :

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

1. Désactivez FIPS sur un pool de nœuds existant à l’aide de Bicep en mettant à jour la ressource du pool d’agents pour définir enableFIPS sur false. Par exemple:

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

2. Déployez le fichier Bicep mis à jour à l’aide des Azure CLI, des Azure PowerShell ou du portail Azure. Pour plus d’informations sur le déploiement de fichiers Bicep, consultez Créer des fichiers Bicep à l’aide de Visual Studio Code.

3. Vérifiez que votre pool de nœuds n’est pas activé par FIPS à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds np n’est pas activé par FIPS :

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

1. Mettez à jour la azurerm_kubernetes_cluster_node_pool ressource en main.tf définissant fips_enabled sur 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. Appliquez la configuration Terraform mise à jour à l’aide des commandes terraform plan et terraform apply. Terraform détecte la modification de fips_enabled et déclenche l’opération de réinitialisation nécessaire.

   terraform plan
   terraform apply
   

3. Vérifiez que votre pool de nœuds n’est pas activé par FIPS à l’aide de la az aks show commande et interrogez la valeur enableFIPS dans agentPoolProfiles.

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

   L’exemple de sortie suivant montre que le pool de nœuds np n’est pas activé par FIPS :

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

Message du jour

Vous pouvez remplacer le message du jour (MOTD) sur les nœuds Linux à l’aide de l’indicateur lors de la --message-of-the-day création d’un cluster ou de l’ajout d’un pool de nœuds.

Créez un cluster et remplacez le message du jour à l’aide de la az aks create commande par l’indicateur --message-of-the-day défini sur le chemin du nouveau fichier MOTD.

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

Ajoutez un pool de nœuds et remplacez le message du jour à l’aide de la az aks nodepool add commande par l’indicateur --message-of-the-day défini sur le chemin du nouveau fichier MOTD.

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