Aktivieren des Federal Information Processing Standard (FIPS) für Azure Kubernetes Service (AKS) Knotenpools

• Terraform lokal installiert. Installationsanweisungen finden Sie unter Install Terraform.

• Azure CLI Version 2.32.0 oder höher installiert und konfiguriert. Führen Sie az --version aus, um die Version zu finden. Weitere Informationen zum Installieren oder Aktualisieren des Azure CLI finden Sie unter Install Azure CLI.

• ARM-Vorlagenbeispiele in diesem Artikel verwenden API-Version 2023-03-01 für Microsoft.ContainerService/managedClusters und Microsoft.ContainerService/managedClusters/agentPools.

• In den Bicep-Beispielen in diesem Artikel wird API-Version 2023-03-01 für Microsoft.ContainerService/managedClusters und Microsoft.ContainerService/managedClusters/agentPools verwendet.

• Terraform-Beispiele in diesem Artikel verwenden den AzureRM-Anbieter 3.x.
• Für die Terraform FIPS-Einstellungen wird enable_fips_image auf azurerm_kubernetes_cluster.default_node_pool und fips_enabled auf azurerm_kubernetes_cluster_node_pool verwendet.

Erstellen der Terraform-Konfigurationsdatei

Terraform-Konfigurationsdateien definieren die Infrastruktur, die Terraform erstellt und verwaltet.

1. Erstellen Sie eine Datei mit dem Namen main.tf, und fügen Sie den folgenden Code hinzu, um die Terraform-Version zu definieren und den Azure Anbieter anzugeben:

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

2. Fügen Sie dem main.tf den folgenden Code hinzu, um eine Azure Ressourcengruppe zu erstellen. Sie können den Namen und den Speicherort der Ressourcengruppe nach Bedarf ändern.

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

Wenn Sie weitere Knotenpools auf einem Cluster erstellen, der bereits über einen FIPS-aktivierten Standardknotenpool verfügt, müssen Sie FIPS auch für die neuen Knotenpools mit dem --enable-fips-image Parameter aktivieren.

1. Erstellen Sie einen AKS-Cluster mit FIPS, der im Standardknotenpool aktiviert ist, mithilfe des az aks create Befehls mit dem --enable-fips-image Parameter.

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

2. Überprüfen Sie, ob der Knotenpool FIPS-aktiviert ist, indem Sie den az aks show Befehl und die Abfrage für den enableFIPS-Wert in agentPoolProfiles verwenden.

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

   Die folgende Beispielausgabe zeigt, dass der Standardknotenpool FIPS-aktiviert ist:

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

Das Aktivieren von FIPS während der Erstellung von AKS-Clustern wird zurzeit im Azure-Portal nicht unterstützt. Um einen Cluster mit einem FIPS-aktivierten Standardknotenpool zu erstellen, verwenden Sie die Anweisungen für Azure CLI, ARM, Bicep oder Terraform in diesem Artikel.

Wenn Sie weitere Knotenpools in einem Cluster erstellen, der bereits über einen FIPS-aktivierten Standardknotenpool verfügt, müssen Sie FIPS auch für die neuen Knotenpools aktivieren, indem Sie diese Einstellung festlegen enableFipstrue.

1. Erstellen Sie einen AKS-Cluster mit FIPS aktiviert im Standardknotenpool, indem Sie mithilfe einer ARM-Vorlage die enableFips-Eigenschaft auf true im Agentpoolprofil festlegen. Beispiel:

   {
     "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. Stellen Sie die ARM-Vorlage mithilfe des portals Azure, Azure CLI oder Azure PowerShell bereit. Weitere Informationen zum Bereitstellen von ARM-Vorlagen finden Sie unter Bereitstellen von Ressourcen mit ARM-Vorlagen.

3. Überprüfen Sie, ob der Knotenpool FIPS-aktiviert ist, indem Sie den az aks show Befehl und die Abfrage für den enableFIPS-Wert in agentPoolProfiles verwenden.

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

   Die folgende Beispielausgabe zeigt, dass der Standardknotenpool FIPS-aktiviert ist:

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

Wenn Sie weitere Knotenpools in einem Cluster erstellen, der bereits über einen FIPS-aktivierten Standardknotenpool verfügt, müssen Sie FIPS auch für die neuen Knotenpools aktivieren, indem Sie diese Einstellung festlegen enableFIPStrue.

1. Erstellen Sie einen AKS-Cluster mit aktiviertem FIPS im Standardknotenpool mithilfe von Bicep, indem Sie im Agentenpoolprofil enableFIPS auf true setzen. Beispiel:

   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. Stellen Sie die Bicep Datei mithilfe der Azure CLI, Azure PowerShell oder des Azure Portals bereit. Weitere Informationen zum Bereitstellen von Bicep Dateien finden Sie unter Create Bicep files using Visual Studio Code.

3. Überprüfen Sie, ob der Knotenpool FIPS-aktiviert ist, indem Sie den az aks show Befehl und die Abfrage für den enableFIPS-Wert in agentPoolProfiles verwenden.

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

   Die folgende Beispielausgabe zeigt, dass der Standardknotenpool FIPS-aktiviert ist:

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

Wenn Sie weitere Knotenpools auf einem Cluster erstellen, der bereits über einen FIPS-aktivierten Standardknotenpool verfügt, müssen Sie FIPS auch für die neuen Knotenpools aktivieren, indem Sie fips_enabled auf true Ein azurerm_kubernetes_cluster_node_pool setzen.

1. Fügen Sie den folgenden Code zu main.tf hinzu, um einen AKS-Cluster mit aktiviertem FIPS im Standardknotenpool zu erstellen.

   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. Initialisieren Sie Terraform im Verzeichnis, das Ihre main.tf Datei enthält, mithilfe des terraform init Befehls.

   terraform init
   

3. Erstellen Sie mit dem Befehl „terraform plan“ einen Terraform-Ausführungsplan.

   terraform plan
   

4. Wenden Sie die Konfiguration mithilfe des terraform apply Befehls an, um den Cluster mit einem FIPS-aktivierten Standardknotenpool bereitzustellen.

   terraform apply
   

5. Stellen Sie mithilfe des Befehls [az aks get-credentials][az-aks-get-credentials] eine Verbindung mit dem AKS-Cluster her.

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

6. Überprüfen Sie, ob der Knotenpool FIPS-aktiviert ist, indem Sie den az aks show Befehl und die Abfrage für den enableFIPS-Wert in agentPoolProfiles verwenden.

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

   Die folgende Beispielausgabe zeigt, dass der Standardknotenpool FIPS-aktiviert ist:

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

Weitere Informationen zur ressource azurerm_kubernetes_cluster finden Sie in der Terraform Azure Anbieterdokumentation.

1. Fügen Sie einem vorhandenen Cluster mithilfe des Befehls mit dem az aks nodepool add--enable-fips-image Parameter einen FIPS-fähigen Linux-Knotenpool hinzu.

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

2. Überprüfen Sie die Konfiguration des Knotenpools mithilfe des az aks show Befehls und der Abfrage nach dem enableFIPS-Wert in "agentPoolProfiles".

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

   Die folgende Beispielausgabe zeigt, dass der Knotenpool fipsnp FIPS-fähig ist:

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

3. Listen Sie die Knoten mithilfe des Befehls „kubectl get nodes“ auf.

   kubectl get nodes
   

   Die folgende Beispielausgabe führt alle Knoten im Cluster auf. Die Knoten, deren Namen mit aks-fipsnp anfangen, sind Teil des FIPS-fähigen Knotenpools.

   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. Führen Sie mithilfe des Befehls „kubectl debug“ eine Bereitstellung bei einer interaktiven Sitzung auf einem dieser Knoten im FIPS-fähigen Knotenpool.

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

5. Überprüfen Sie anhand der Ausgabe der interaktiven Sitzung, ob die FIPS-Kryptografiebibliotheken aktiviert wurden. Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:

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

   FIPS-fähige Knotenpools haben auch die Bezeichnung kubernetes.azure.com/fips_enabled=true, die von Bereitstellungen für diese Knotenpools verwendet werden können.

Aktivieren von FIPS beim Hinzufügen eines Linux-Knotenpools wird derzeit im Azure Portal nicht unterstützt. Verwenden Sie zum Hinzufügen eines FIPS-fähigen Linux-Knotenpools die Anweisungen Azure CLI, ARM, Bicep oder Terraform in diesem Artikel.

1. Erstellen Sie einen FIPS-fähigen Linux-Knotenpool mithilfe einer ARM-Vorlage, indem Sie eine Agentpoolressource bereitstellen, bei der die Eigenschaft enableFips auf true gesetzt ist. Beispiel:

   {
     "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. Stellen Sie die ARM-Vorlage mithilfe des portals Azure, Azure CLI oder Azure PowerShell bereit. Weitere Informationen zum Bereitstellen von ARM-Vorlagen finden Sie unter Bereitstellen von Ressourcen mit ARM-Vorlagen.

3. Überprüfen Sie die Konfiguration des Knotenpools mithilfe des az aks show Befehls und der Abfrage nach dem enableFIPS-Wert in "agentPoolProfiles".

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

   Die folgende Beispielausgabe zeigt, dass der Knotenpool fipsnp FIPS-fähig ist:

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

4. Listen Sie die Knoten mithilfe des Befehls „kubectl get nodes“ auf.

   kubectl get nodes
   

   Die folgende Beispielausgabe führt alle Knoten im Cluster auf. Die Knoten, deren Namen mit aks-fipsnp anfangen, sind Teil des FIPS-fähigen Knotenpools.

   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. Führen Sie mithilfe des Befehls „kubectl debug“ eine Bereitstellung bei einer interaktiven Sitzung auf einem dieser Knoten im FIPS-fähigen Knotenpool.

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

6. Überprüfen Sie anhand der Ausgabe der interaktiven Sitzung, ob die FIPS-Kryptografiebibliotheken aktiviert wurden. Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:

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

   FIPS-fähige Knotenpools haben auch die Bezeichnung kubernetes.azure.com/fips_enabled=true, die von Bereitstellungen für diese Knotenpools verwendet werden können.

1. Erstellen Sie einen FIPS-fähigen Linux-Knotenpool mit Bicep, indem Sie eine Agentpoolressource bereitstellen, wobei enableFIPS auf true festgelegt ist. Beispiel:

   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. Stellen Sie die Bicep Datei mithilfe der Azure CLI, Azure PowerShell oder des Azure Portals bereit. Weitere Informationen zum Bereitstellen von Bicep Dateien finden Sie unter Create Bicep files using Visual Studio Code.

3. Überprüfen Sie die Konfiguration des Knotenpools mithilfe des az aks show Befehls und der Abfrage nach dem enableFIPS-Wert in "agentPoolProfiles".

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

   Die folgende Beispielausgabe zeigt, dass der Knotenpool fipsnp FIPS-fähig ist:

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

4. Listen Sie die Knoten mithilfe des Befehls „kubectl get nodes“ auf.

   kubectl get nodes
   

   Die folgende Beispielausgabe führt alle Knoten im Cluster auf. Die Knoten, deren Namen mit aks-fipsnp anfangen, sind Teil des FIPS-fähigen Knotenpools.

   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. Führen Sie mithilfe des Befehls „kubectl debug“ eine Bereitstellung bei einer interaktiven Sitzung auf einem dieser Knoten im FIPS-fähigen Knotenpool.

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

6. Überprüfen Sie anhand der Ausgabe der interaktiven Sitzung, ob die FIPS-Kryptografiebibliotheken aktiviert wurden. Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:

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

   FIPS-fähige Knotenpools haben auch die Bezeichnung kubernetes.azure.com/fips_enabled=true, die von Bereitstellungen für diese Knotenpools verwendet werden können.

1. Fügen Sie den folgenden Code zu main.tf hinzu, um einen FIPS-fähigen Linux-Knotenpool in Ihrem AKS-Cluster hinzuzufügen:

   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. Wenden Sie die aktualisierte Terraform-Konfiguration mit den Befehlen terraform plan und terraform apply an.

   terraform plan
   terraform apply
   

3. Stellen Sie mithilfe des Befehls [az aks get-credentials][az-aks-get-credentials] eine Verbindung mit dem AKS-Cluster her.

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

4. Überprüfen Sie die Konfiguration des Knotenpools mithilfe des az aks show Befehls und der Abfrage nach dem enableFIPS-Wert in "agentPoolProfiles".

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

   Die folgende Beispielausgabe zeigt, dass der Knotenpool fipsnp FIPS-fähig ist:

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

5. Listen Sie die Knoten mithilfe des Befehls „kubectl get nodes“ auf.

   kubectl get nodes
   

   Die folgende Beispielausgabe führt alle Knoten im Cluster auf. Die Knoten, deren Namen mit aks-fipsnp anfangen, sind Teil des FIPS-fähigen Knotenpools.

   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. Führen Sie mithilfe des Befehls „kubectl debug“ eine Bereitstellung bei einer interaktiven Sitzung auf einem dieser Knoten im FIPS-fähigen Knotenpool.

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

7. Überprüfen Sie anhand der Ausgabe der interaktiven Sitzung, ob die FIPS-Kryptografiebibliotheken aktiviert wurden. Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:

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

   FIPS-fähige Knotenpools haben auch die Bezeichnung kubernetes.azure.com/fips_enabled=true, die von Bereitstellungen für diese Knotenpools verwendet werden können.

Weitere Informationen zur ressource azurerm_kubernetes_cluster_node_pool finden Sie in der Terraform Azure Anbieterdokumentation.

1. Fügen Sie einen Linux-Knotenpool mit aktiviertem FIPS und aktiviertem vertrauenswürdigem Start mithilfe des az aks nodepool add Befehls hinzu.

   az aks nodepool add \
       --resource-group myResourceGroup \
       --cluster-name myAKSCluster \
       --name fipstlnp \
       --os-type Linux \
       --os-sku Ubuntu \
       --node-count 3 \
       --enable-fips-image \
       --enable-vtpm \
       --enable-secure-boot
   

2. Überprüfen Sie die Konfiguration Ihres Knotenpools mithilfe des az aks show Befehls und fragen Sie den Wert enableFIPS in agentPoolProfiles ab.

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

   Die folgende Beispielausgabe zeigt, dass der Fipstlnp-Knotenpool FIPS-aktiviert ist:

   Name       enableFips
   ---------  ------------
   fipstlnp   True
   nodepool1  False
   

3. Überprüfen Sie, ob der Knotenpool ein Trusted-Launch-Image verwendet.

   Trusted Launch-Knoten liefern die folgende Ausgabe zurück:

   • Node-Image-Version, die sowohl "TL" als auch "FIPS" enthält.
   • "Security-type" ist "Trusted Launch".

   kubectl get nodes
   kubectl describe node {node-name} | grep -e node-image-version -e security-type
   

Das Hinzufügen eines Linux-Knotenpools mit FIPS und vertrauenswürdigem Start wird derzeit im Azure-Portal nicht unterstützt. Um einen Linux-Knotenpool mit aktiviertem FIPS und aktiviertem vertrauenswürdigem Start hinzuzufügen, verwenden Sie die Azure CLI, Azure Resource Manager Vorlage (ARM-Vorlage) oder Bicep Anweisungen in diesem Artikel.

1. Erstellen Sie einen Linux-Knotenpool mit FIPS und aktiviertem vertrauenswürdigen Start mithilfe einer ARM-Vorlage. Stellen Sie eine Agentpoolressource bereit, wobei enableFips auf true und sowohl enableVTPM als auch enableSecureBoot auf true festgelegt sind. Beispiel:

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

2. Stellen Sie die ARM-Vorlage mithilfe des Azure Portals, Azure CLI oder Azure PowerShell bereit. Weitere Informationen zum Bereitstellen von ARM-Vorlagen finden Sie unter Bereitstellen von Ressourcen mit ARM-Vorlagen.

3. Überprüfen Sie die Konfiguration Ihres Knotenpools, indem Sie den Befehl az aks show verwenden und in agentPoolProfiles den Wert enableFIPS abfragen.

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

4. Überprüfen Sie, ob der Knotenpool ein Trusted-Launch-Image verwendet.

   Vertrauenswürdige Startknoten haben die folgende Ausgabe:

   • Node-Image-Version, die sowohl "TL" als auch "FIPS" enthält.
   • "Security-type" ist "Trusted Launch".

   kubectl get nodes
   kubectl describe node {node-name} | grep -e node-image-version -e security-type
   

1. Erstellen Sie mithilfe von Bicep einen Linux-Knotenpool mit aktiviertem FIPS und Trusted Launch. Stellen Sie eine Agentpoolressource bereit, bei der enableFIPS, enableVTPM und enableSecureBoot auf true festgelegt sind. Beispiel:

   param clusterName string
   param nodePoolName string = 'fipstlnp'
   
   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
       securityProfile: {
         enableVTPM: true
         enableSecureBoot: true
       }
     }
   }
   

2. Stellen Sie die Bicep Datei mithilfe der Azure CLI, Azure PowerShell oder des Azure Portals bereit. Weitere Informationen zum Bereitstellen von Bicep Dateien finden Sie unter Create Bicep files using Visual Studio Code.

3. Überprüfen Sie die Konfiguration Ihres Knotenpools mithilfe des Befehls az aks show und fragen Sie in agentPoolProfiles den Wert enableFIPS ab.

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

4. Überprüfen Sie, ob der Knotenpool ein Trusted Launch-Image verwendet.

   Trusted Launch-Knoten geben folgende Ausgabe aus:

   • Version des Node-Images, die sowohl "TL" als auch "FIPS" enthält.
   • "Security-type" ist "Trusted Launch".

   kubectl get nodes
   kubectl describe node {node-name} | grep -e node-image-version -e security-type
   

Das Hinzufügen eines Linux-Knotenpools mit sowohl FIPS als auch Trusted Launch mithilfe von Terraform wird derzeit nicht unterstützt vom AzureRM-Anbieter, da dieser keine Trusted Launch-Einstellungen für Knotenpools verfügbar macht.

Verwenden Sie zum Hinzufügen eines Linux-Knotenpools mit aktiviertem FIPS und aktiviertem Trusted Launch die Anweisungen zur Azure CLI, zur ARM-Vorlage oder zu Bicep in diesem Artikel.

1. Erstellen Sie einen Windows Knotenpool mithilfe des Befehls az aks nodepool add. Im Gegensatz zu Linux-basierten Knotenpools verwenden Windows Knotenpools denselben Imagesatz.

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

2. Überprüfen Sie die Konfiguration des Knotenpools mithilfe des az aks show Befehls und der Abfrage nach dem enableFIPS-Wert in "agentPoolProfiles".

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

3. Überprüfen Sie, ob Windows Knotenpools Zugriff auf FIPS-Kryptografiebibliotheken haben, indem Sie eine RDP-Verbindung mit einem Windows Knoten in einem Knotenpool erstellen und die Registrierung überprüfen. Geben Sie über die Ausführen-Anwendung regedit ein.

4. Suchen Sie in der Registrierung nach HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy.

5. Wenn Enabled auf 1 festgelegt ist, ist FIPS aktiviert.

   

   FIPS-fähige Knotenpools haben auch die Bezeichnung kubernetes.azure.com/fips_enabled=true, die von Bereitstellungen für diese Knotenpools verwendet werden können.

Es gibt keine Azure Portalumgebung, um FIPS-Einstellungen für Windows Knotenpools zu aktivieren oder zu deaktivieren. Alle Windows Knotenpools, die mit Azure Portal erstellt wurden, sind FIPS aktiviert. Windows Server 2022 und neueren Knotenpools FIPS standardmäßig aktivieren, und Windows Server 2025- und höher-Knotenpools unterstützen das Deaktivieren von FIPS nicht.

1. Erstellen Sie einen Windows Knotenpool mithilfe einer ARM-Vorlage, indem Sie eine Agentpoolressource bereitstellen, wobei osType auf Windows festgelegt ist. Beispiel:

   {
     "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. Stellen Sie die ARM-Vorlage mithilfe des portals Azure, Azure CLI oder Azure PowerShell bereit. Weitere Informationen zum Bereitstellen von ARM-Vorlagen finden Sie unter Bereitstellen von Ressourcen mit ARM-Vorlagen.

3. Überprüfen Sie die Konfiguration des Knotenpools mithilfe des az aks show Befehls und der Abfrage nach dem enableFIPS-Wert in "agentPoolProfiles".

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

4. Überprüfen Sie, ob Windows Knotenpools Zugriff auf FIPS-Kryptografiebibliotheken haben, indem Sie eine RDP-Verbindung mit einem Windows Knoten in einem Knotenpool erstellen und die Registrierung überprüfen. Geben Sie über die Ausführen-Anwendung regedit ein.

5. Suchen Sie in der Registrierung nach HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy.

6. Wenn Enabled auf 1 festgelegt ist, ist FIPS aktiviert.

   

   FIPS-fähige Knotenpools haben auch die Bezeichnung kubernetes.azure.com/fips_enabled=true, die von Bereitstellungen für diese Knotenpools verwendet werden können.

1. Erstellen Sie einen Windows Knotenpool mithilfe von Bicep, indem Sie eine Agentpoolressource bereitstellen, wobei osType auf Windows festgelegt ist. Beispiel:

   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. Stellen Sie die Bicep Datei mithilfe der Azure CLI, Azure PowerShell oder des Azure Portals bereit. Weitere Informationen zum Bereitstellen von Bicep Dateien finden Sie unter Create Bicep files using Visual Studio Code.

3. Überprüfen Sie die Konfiguration des Knotenpools mithilfe des az aks show Befehls und der Abfrage nach dem enableFIPS-Wert in "agentPoolProfiles".

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

4. Überprüfen Sie, ob Windows Knotenpools Zugriff auf FIPS-Kryptografiebibliotheken haben, indem Sie eine RDP-Verbindung mit einem Windows Knoten in einem Knotenpool erstellen und die Registrierung überprüfen. Geben Sie über die Ausführen-Anwendung regedit ein.

5. Suchen Sie in der Registrierung nach HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy.

6. Wenn Enabled auf 1 festgelegt ist, ist FIPS aktiviert.

   

   FIPS-fähige Knotenpools haben auch die Bezeichnung kubernetes.azure.com/fips_enabled=true, die von Bereitstellungen für diese Knotenpools verwendet werden können.

1. Fügen Sie den folgenden Code zu main.tf hinzu, um einen Windows-Knotenpool in Ihrem AKS-Cluster zu erstellen.

   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. Wenden Sie die aktualisierte Terraform-Konfiguration mit den Befehlen terraform plan und terraform apply an.

   terraform plan
   terraform apply
   

3. Stellen Sie mithilfe des Befehls [az aks get-credentials][az-aks-get-credentials] eine Verbindung mit dem AKS-Cluster her.

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

4. Überprüfen Sie die Konfiguration des Knotenpools mithilfe des az aks show Befehls und der Abfrage nach dem enableFIPS-Wert in "agentPoolProfiles".

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

5. Überprüfen Sie, ob Windows Knotenpools Zugriff auf FIPS-Kryptografiebibliotheken haben, indem Sie eine RDP-Verbindung mit einem Windows Knoten in einem Knotenpool erstellen und die Registrierung überprüfen. Geben Sie über die Ausführen-Anwendung regedit ein.

6. Suchen Sie in der Registrierung nach HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy.

7. Wenn Enabled auf 1 festgelegt ist, ist FIPS aktiviert.

   

   FIPS-fähige Knotenpools haben auch die Bezeichnung kubernetes.azure.com/fips_enabled=true, die von Bereitstellungen für diese Knotenpools verwendet werden können.

Voraussetzungen für die Aktualisierung eines vorhandenen Knotenpools

Azure CLI Version 2.64.0 oder höher. Führen Sie az --version aus, um die Version zu finden. Informationen zum Installieren oder Aktualisieren finden Sie unter Install Azure CLI.

1. Aktualisieren Sie einen Knotenpool mithilfe des az aks nodepool update Befehls mit dem --enable-fips-image Parameter.

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

   Dieser Befehl löst sofort eine Neuimage des Knotenpools aus, um das FIPS-kompatible Betriebssystem bereitzustellen. Dieser Reimagingvorgang wird während des Knotenpoolupdates durchgeführt. Es sind keine zusätzlichen Schritte erforderlich.

2. Überprüfen Sie, ob der Knotenpool FIPS-aktiviert ist, indem Sie den az aks show Befehl und die Abfrage für den enableFIPS-Wert in agentPoolProfiles verwenden.

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

   Die folgende Beispielausgabe zeigt, dass der Knotenpool np FIPS-fähig ist:

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

Das Aktivieren von FIPS in einem vorhandenen Knotenpool wird derzeit im Azure Portal nicht unterstützt. Um FIPS in einem vorhandenen Knotenpool zu aktivieren, verwenden Sie die Anweisungen Azure CLI, ARM, Bicep oder Terraform in diesem Artikel.

1. Aktivieren Sie FIPS in einem vorhandenen Knotenpool mithilfe einer ARM-Vorlage, indem Sie das Agentpoolprofil aktualisieren, um die enableFips Eigenschaft auf festzulegen true. Beispiel:

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

2. Stellen Sie die aktualisierte Vorlage mithilfe des portals Azure, Azure CLI oder Azure PowerShell bereit. Weitere Informationen zum Bereitstellen von ARM-Vorlagen finden Sie unter Bereitstellen von Ressourcen mit ARM-Vorlagen.

3. Überprüfen Sie, ob der Knotenpool FIPS-aktiviert ist, indem Sie den az aks show Befehl und die Abfrage für den enableFIPS-Wert in agentPoolProfiles verwenden.

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

   Die folgende Beispielausgabe zeigt, dass der Knotenpool np FIPS-fähig ist:

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

1. Aktivieren Sie FIPS in einem vorhandenen Knotenpool mithilfe von Bicep, indem Sie die Agentpoolressource aktualisieren, um enableFIPS auf true festzulegen. Beispiel:

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

2. Stellen Sie die aktualisierte Bicep Datei mithilfe der Azure CLI, Azure PowerShell oder des Azure Portals bereit. Weitere Informationen zum Bereitstellen von Bicep Dateien finden Sie unter Create Bicep files using Visual Studio Code.

3. Stellen Sie sicher, dass ihr Knotenpool FIPS-aktiviert ist, indem Sie den az aks show Befehl verwenden und den enableFIPS-Wert in "agentPoolProfiles" abfragen.

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

   Die folgende Beispielausgabe zeigt, dass der Knotenpool np FIPS-fähig ist:

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

1. Aktualisieren Sie die azurerm_kubernetes_cluster_node_pool Ressource in main.tf, indem Sie fips_enabled auf true festlegen.

   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. Wenden Sie die aktualisierte Terraform-Konfiguration mit den Befehlen terraform plan und terraform apply an. Terraform erkennt die Änderung an fips_enabled und löst den notwendigen Reimage-Vorgang aus.

   terraform plan
   terraform apply
   

3. Stellen Sie mithilfe des Befehls [az aks get-credentials][az-aks-get-credentials] eine Verbindung mit dem AKS-Cluster her.

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

4. Überprüfen Sie, ob der Knotenpool FIPS-aktiviert ist, indem Sie den az aks show Befehl und die Abfrage für den enableFIPS-Wert in agentPoolProfiles verwenden.

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

   Die folgende Beispielausgabe zeigt, dass der Knotenpool np FIPS-fähig ist:

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

1. Aktualisieren Sie einen Linux-Knotenpool mithilfe des az aks nodepool update Befehls mit dem --disable-fips-image Parameter.

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

   Dieser Befehl löst sofort eine Neuimage des Knotenpools aus, um das FIPS-kompatible Betriebssystem bereitzustellen. Dieser Reimagingvorgang wird während des Knotenpoolupdates durchgeführt. Es sind keine zusätzlichen Schritte erforderlich.

2. Überprüfen Sie, ob ihr Knotenpool nicht FIPS-aktiviert ist, indem Sie den az aks show Befehl verwenden und den EnableFIPS-Wert in "agentPoolProfiles" abfragen.

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

   Die folgende Beispielausgabe zeigt, dass der np-Knotenpool nicht FIPS-aktiviert ist.

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

Deaktivieren von FIPS in einem vorhandenen Knotenpool ist derzeit im Azure-Portal nicht unterstützt. Um FIPS in einem vorhandenen Knotenpool zu deaktivieren, verwenden Sie die Anweisungen Azure CLI, ARM, Bicep oder Terraform in diesem Artikel.

1. Deaktivieren Sie FIPS in einem vorhandenen Knotenpool mithilfe einer ARM-Vorlage, indem Sie das Agentpoolprofil aktualisieren, um die enableFips Eigenschaft auf festzulegen false. Beispiel:

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

2. Stellen Sie die aktualisierte Vorlage mithilfe des portals Azure, Azure CLI oder Azure PowerShell bereit. Weitere Informationen zum Bereitstellen von ARM-Vorlagen finden Sie unter Bereitstellen von Ressourcen mit ARM-Vorlagen.

3. Überprüfen Sie, ob ihr Knotenpool nicht FIPS-aktiviert ist, indem Sie den az aks show Befehl verwenden und den EnableFIPS-Wert in "agentPoolProfiles" abfragen.

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

   Die folgende Beispielausgabe zeigt, dass der np-Knotenpool nicht FIPS-aktiviert ist.

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

1. Deaktivieren Sie FIPS für einen vorhandenen Knotenpool mithilfe von Bicep, indem Sie die Agentpoolressource aktualisieren, um enableFIPS auf false festzulegen. Beispiel:

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

2. Stellen Sie die aktualisierte Bicep Datei mithilfe der Azure CLI, Azure PowerShell oder des Azure Portals bereit. Weitere Informationen zum Bereitstellen von Bicep Dateien finden Sie unter Create Bicep files using Visual Studio Code.

3. Überprüfen Sie, ob ihr Knotenpool nicht FIPS-aktiviert ist, indem Sie den az aks show Befehl verwenden und den EnableFIPS-Wert in "agentPoolProfiles" abfragen.

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

   Die folgende Beispielausgabe zeigt, dass der np-Knotenpool nicht FIPS-aktiviert ist.

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

1. Aktualisieren Sie die azurerm_kubernetes_cluster_node_pool Ressource in main.tf, indem Sie fips_enabled auf false festlegen.

   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. Wenden Sie die aktualisierte Terraform-Konfiguration mit den Befehlen terraform plan und terraform apply an. Terraform erkennt die Änderung an fips_enabled und löst den notwendigen Reimage-Vorgang aus.

   terraform plan
   terraform apply
   

3. Überprüfen Sie, ob ihr Knotenpool nicht FIPS-aktiviert ist, indem Sie den az aks show Befehl verwenden und den EnableFIPS-Wert in "agentPoolProfiles" abfragen.

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

   Die folgende Beispielausgabe zeigt, dass der np-Knotenpool nicht FIPS-aktiviert ist.

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

Nachricht des Tages

Sie können die Nachricht des Tages (MOTD) auf Linux-Knoten mithilfe der --message-of-the-day Kennzeichnung ersetzen, wenn Sie einen Cluster erstellen oder einen Knotenpool hinzufügen.

Erstellen Sie einen Cluster und ersetzen Sie die Nachricht des Tages (MOTD) mithilfe des Befehls az aks create, wobei das Kennzeichen --message-of-the-day auf den Pfad der neuen MOTD-Datei festgelegt ist.

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

Fügen Sie einen Knotenpool hinzu und ersetzen Sie die Nachricht des Tages, indem Sie den az aks nodepool add-Befehl verwenden und das --message-of-the-day-Flag auf den Pfad der neuen MOTD-Datei festlegen.

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