Condividi tramite

Abilitare FIPS (Federal Information Processing Standard) per i pool di nodi di Servizio Azure Kubernetes (AKS)

Federal Information Processing Standard (FIPS) 140-2 è uno standard del governo degli Stati Uniti che definisce i requisiti minimi di sicurezza per i moduli crittografici nei prodotti e nei sistemi informatici. Servizio Azure Kubernetes (AKS) consente di creare pool di nodi Linux e Windows con FIPS 140-2 abilitato. Le distribuzioni in esecuzione nei pool di nodi abilitati per FIPS possono usare tali moduli crittografici per fornire maggiore sicurezza e contribuire al rispetto dei controlli di sicurezza come parte della conformità a FedRAMP. Per altre informazioni su FIPS 140-2, vedere Federal Information Processing Standard (FIPS) 140.

Importante

A partire da March 17, 2027, Servizio Azure Kubernetes (AKS) non supporta più o fornisce aggiornamenti della sicurezza per Ubuntu 20.04. Tutte le immagini dei nodi esistenti verranno eliminate e non sarà possibile ridimensionare i pool di nodi che eseguono Ubuntu 20.04. Eseguire la migrazione a una versione di Ubuntu supportata aggiornando i pool di nodi a Kubernetes versione 1.35+. Per ulteriori informazioni su questa disattivazione, vedere il problema su GitHub e l'annuncio di disattivazione degli aggiornamenti Azure. Seguire le note di rilascio AKS per rimanere informati sugli annunci e sugli aggiornamenti.

Importante

A partire da November 30, 2025, Servizio Azure Kubernetes (AKS) non supporta più o fornisce aggiornamenti della sicurezza per Azure Linux 2.0. L'immagine del nodo Azure Linux 2.0 è bloccata nella versione 202512.06.0. A partire dal 31 marzo 2026, le immagini dei nodi verranno rimosse e non sarà possibile ridimensionare i pool di nodi. Esegui la migrazione a una versione supportata di Azure Linux aggiornando i tuoi pool di nodi a una versione di Kubernetes supportata o migrando a osSku AzureLinux3. Per altre informazioni, vedere questione GitHub di ritiro e l'annuncio di ritiro degli aggiornamenti di Azure. Per rimanere informati sugli annunci e sugli aggiornamenti, segui le note sulla versione AKS.

Prerequisiti

  • Sottoscrizione attiva Azure. Se non si ha una sottoscrizione Azure, creare un account free prima di iniziare.

  • Impostare il contesto della sottoscrizione usando il az account set comando . Per esempio:

    az account set --subscription "00000000-0000-0000-0000-000000000000"

  • kubectl installato. È possibile installarlo in locale usando il az aks install-cli comando .

Compatibilità delle versioni

  • interfaccia della riga di comando di Azure versione 2.32.0 o successiva installata e configurata. Per trovare la versione, eseguire az --version. Per altre informazioni sull'installazione o l'aggiornamento della interfaccia della riga di comando di Azure, vedere Installare interfaccia della riga di comando di Azure.
  • Esempi di modelli arm in questo articolo usano la versione api 2023-03-01 per Microsoft.ContainerService/managedClusters e Microsoft.ContainerService/managedClusters/agentPools.
  • Gli esempi di Bicep in questo articolo usano la versione dell'API 2023-03-01 per Microsoft.ContainerService/managedClusters e Microsoft.ContainerService/managedClusters/agentPools.
  • Esempi di Terraform in questo articolo usano il provider AzureRM 3.x.
  • Per le impostazioni FIPS di Terraform, usare enable_fips_image su azurerm_kubernetes_cluster.default_node_pool e fips_enabled su azurerm_kubernetes_cluster_node_pool.

Limitazioni

I pool di nodi abilitati per FIPS presentano le limitazioni seguenti:

  • I pool di nodi abilitati per FIPS richiedono Kubernetes versione 1.19 e successive.
  • Per aggiornare i pacchetti o i moduli sottostanti usati per FIPS, è necessario usare l'aggiornamento dell'immagine node.
  • Le immagini dei container sui nodi FIPS non sono valutate per la conformità FIPS.
  • Il montaggio di una condivisione CIFS non riesce perché FIPS disabilita alcuni moduli di autenticazione. Per risolvere questo problema, vedere Errori durante il montaggio di una condivisione file in un pool di nodi abilitato per FIPS.
  • I pool di nodi abilitati per FIPS con macchine virtuali Arm64 sono supportati solo con Azure Linux 3.0+.
  • Il componente aggiuntivo di monitoraggio AKS supporta i pool di nodi abilitati per FIPS con Ubuntu, Azure Linux e Windows a partire da Agent version 3.1.17 (Linux) e Win-3.1.17 (Windows).

Importante

L'immagine Linux abilitata per FIPS è un'immagine diversa rispetto all'immagine Linux predefinita usata per i pool di nodi basati su Linux.

Le immagini dei nodi abilitate per FIPS possono avere numeri di versione diversi, ad esempio la versione del kernel, rispetto alle immagini non abilitate per FIPS. Il ciclo di aggiornamento per i pool di nodi abilitati per FIPS e le immagini dei nodi possono differire da pool di nodi e immagini non abilitati per FIPS.

Versioni del sistema operativo supportate

È possibile creare pool di nodi abilitati per FIPS in tutti i tipi di sistema operativo supportati (Linux e Windows). Tuttavia, non tutte le versioni del sistema operativo supportano pool di nodi abilitati per FIPS. Dopo il rilascio di una nuova versione del sistema operativo, è in genere previsto un periodo di attesa prima che sia conforme a FIPS.

La tabella seguente include le versioni del sistema operativo supportate per i pool di nodi abilitati per FIPS:

Tipo di sistema operativo SKU del sistema operativo Conformità FIPS Impostazione predefinita
Linux Ubuntu Supportato Disattivato per impostazione predefinita
Linux Azure Linux Supportato Disattivato per impostazione predefinita
Windows Windows Server 2022 Supportato Abilitata per impostazione predefinita
Windows Windows Server 2025 Supportato Abilitato per impostazione predefinita e non può essere disabilitato

Quando si richiede un'istanza di Ubuntu abilitato per FIPS, se la versione predefinita di Ubuntu non supporta FIPS, AKS utilizza la versione più recente di Ubuntu supportata da FIPS. Ad esempio, Ubuntu 22.04 è l'impostazione predefinita per i pool di nodi Linux. Poiché la versione 22.04 attualmente non supporta FIPS, AKS (Azure Kubernetes Service) utilizza di default Ubuntu 20.04 per i pool di nodi abilitati a FIPS per Linux.

Note

In precedenza, è possibile usare l'API GetOSOptions per determinare se un determinato sistema operativo supporta FIPS. L'API GetOSOptions è ora deprecata e non è più inclusa nelle nuove versioni dell'API del servizio Azure Kubernetes a partire dalla versione 2024-05-01.

Creare il file di configurazione terraform

I file di configurazione terraform definiscono l'infrastruttura creata e gestita da Terraform.

  1. Creare un file denominato main.tf e aggiungere il codice seguente per definire la versione di Terraform e specificare il provider Azure:

    terraform {
  required_version = ">= 1.0"

  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "~> 3.0"
    }
  }
}

provider "azurerm" {
  features {}
}

  2. Aggiungere il codice seguente a main.tf per creare un gruppo di risorse Azure. È possibile modificare il nome e la posizione del gruppo di risorse in base alle esigenze.

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

Creare un cluster AKS con un pool di nodi predefinito abilitato FIPS.

È possibile abilitare FIPS nel pool di nodi predefinito durante la creazione di un nuovo cluster del servizio Azure Kubernetes.

Quando si creano più pool di nodi in un cluster che dispone già di un pool di nodi predefinito abilitato per FIPS, è anche necessario abilitare FIPS nei nuovi pool di nodi usando il --enable-fips-image parametro .

  1. Creare un cluster dell'AKS con FIPS abilitato nel pool di nodi predefinito usando il comando az aks create con il parametro --enable-fips-image.

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

  2. Verificare che il pool di nodi sia abilitato per FIPS usando il comando az aks show e consultando il valore enableFIPS in agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi predefinito è abilitato per FIPS:

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

L'abilitazione di FIPS durante la creazione di un cluster di Azure Kubernetes Service non è attualmente supportata nel portale di Azure. Per creare un cluster con un pool di nodi predefinito abilitato per FIPS, usare le istruzioni interfaccia della riga di comando di Azure, arm, Bicep o Terraform in questo articolo.

Quando si creano più pool di nodi in un cluster che dispone già di un pool di nodi predefinito abilitato per FIPS, è anche necessario abilitare FIPS nei nuovi pool di nodi impostando su enableFipstrue.

  1. Creare un cluster AKS di Azure con FIPS abilitato nel pool di nodi predefinito usando un modello ARM impostando la proprietà enableFips su true nel profilo del pool di agenti. Per esempio:

    {
  "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. Distribuire il modello ARM usando il portale Azure, interfaccia della riga di comando di Azure o Azure PowerShell. Per altre informazioni sulla distribuzione di modelli di Resource Manager, vedere Distribuire risorse con i modelli di Resource Manager.

  3. Verificare che il pool di nodi sia abilitato per FIPS usando il comando az aks show e consultando il valore enableFIPS in agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi predefinito è abilitato per FIPS:

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

Quando si creano più pool di nodi in un cluster che dispone già di un pool di nodi predefinito abilitato per FIPS, è anche necessario abilitare FIPS nei nuovi pool di nodi impostando su enableFIPStrue.

  1. Creare un cluster AKS con FIPS abilitato nel pool di nodi predefinito usando Bicep impostando enableFIPS su true nel profilo del pool di agenti. Per esempio:

    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. Distribuire il file di Bicep usando interfaccia della riga di comando di Azure, Azure PowerShell o il portale Azure. Per altre informazioni sulla distribuzione di file di Bicep, vedere Creare file Bicep usando Visual Studio Code.

  3. Verificare che il pool di nodi sia abilitato per FIPS usando il az aks show comando ed eseguire una query per il valore enableFIPS in agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi predefinito è abilitato per FIPS:

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

Quando si creano più pool di nodi in un cluster che dispone già di un pool di nodi predefinito abilitato per FIPS, è anche necessario abilitare FIPS nei nuovi pool di nodi impostando fips_enabled su true su azurerm_kubernetes_cluster_node_pool.

  1. Aggiungere il seguente codice in main.tf per creare un cluster AKS con FIPS abilitato sul pool di nodi predefinito:

    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. Inizializzare Terraform nella directory contenente il main.tf file usando il terraform init comando .

    terraform init

  3. Creare un piano di esecuzione terraform usando il comando terraform plan.

    terraform plan

  4. Applicare la configurazione usando il terraform apply comando per distribuire il cluster con un pool di nodi predefinito abilitato per FIPS.

    terraform apply

  5. Connettersi al cluster AKS usando il comando [az aks get-credentials][az-aks-get-credentials].

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

  6. Verificare che il pool di nodi sia abilitato per FIPS usando il comando az aks show e consultando il valore enableFIPS in agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi predefinito è abilitato per FIPS:

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

Per altre informazioni sulla risorsa azurerm_kubernetes_cluster, vedere la documentazione Terraform Azure provider.

Aggiungere un pool di nodi Linux abilitato per FIPS a un cluster AKS esistente

  1. Aggiungere un pool di nodi Linux abilitato per FIPS a un cluster esistente usando il az aks nodepool add comando con il --enable-fips-image parametro .

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

  2. Verificare la configurazione del pool di nodi usando il az aks show comando e interrogare il valore enableFIPS in agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi fipsnp è abilitato per FIPS:

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

  3. Elencare i nodi usando il comando kubectl get nodes.

    kubectl get nodes

    L'output di esempio seguente mostra un elenco dei nodi del cluster. I nodi che iniziano con aks-fipsnp fanno parte del pool di nodi abilitato per 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. Eseguire una distribuzione con una sessione interattiva in uno dei nodi del pool di nodi abilitato per FIPS usando il comando kubectl debug.

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

  5. Dall'output interattivo della sessione verificare che le librerie di crittografia FIPS siano abilitate. L'output dovrebbe essere simile all'output di esempio seguente:

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

    I pool di nodi abilitati per FIPS hanno anche un'etichetta kubernetes.azure.com/fips_enabled=true, che le distribuzioni possono usare per indirizzare tali pool di nodi.

Abilitare FIPS quando si aggiunge un pool di nodi Linux attualmente non è supportato nel portale di Azure. Per aggiungere un pool di nodi Linux abilitato per FIPS, usare le istruzioni interfaccia della riga di comando di Azure, arm, Bicep o Terraform in questo articolo.

  1. Creare un pool di nodi Linux abilitato FIPS usando un modello ARM distribuendo una risorsa del pool di agenti con la enableFips proprietà impostata su true. Per esempio:

    {
  "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. Distribuire il template ARM usando il portale Azure, interfaccia della riga di comando di Azure o Azure PowerShell. Per altre informazioni sulla distribuzione di modelli di Resource Manager, vedere Distribuire risorse con i modelli di Resource Manager.

  3. Verificare la configurazione del pool di nodi utilizzando il comando az aks show ed eseguendo una query per il valore enableFIPS presente in agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi fipsnp è abilitato per FIPS:

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

  4. Elencare i nodi usando il comando kubectl get nodes.

    kubectl get nodes

    L'output di esempio seguente mostra un elenco dei nodi del cluster. I nodi che iniziano con aks-fipsnp fanno parte del pool di nodi abilitato per 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. Eseguire una distribuzione con una sessione interattiva in uno dei nodi del pool di nodi abilitato per FIPS usando il comando kubectl debug.

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

  6. Dall'output interattivo della sessione verificare che le librerie di crittografia FIPS siano abilitate. L'output dovrebbe essere simile all'output di esempio seguente:

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

    I pool di nodi abilitati per FIPS hanno anche un'etichetta kubernetes.azure.com/fips_enabled=true, che le distribuzioni possono usare per indirizzare tali pool di nodi.

  1. Creare un pool di nodi Linux abilitato per FIPS usando Bicep distribuendo una risorsa del pool di agenti con enableFIPS impostata su true. Per esempio:

    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. Distribuire il file di Bicep usando interfaccia della riga di comando di Azure, Azure PowerShell o il portale Azure. Per altre informazioni sulla distribuzione di file di Bicep, vedere Creare file Bicep usando Visual Studio Code.

  3. Verificare la configurazione del pool di nodi usando il comando az aks show e interrogare il valore enableFIPS in agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi fipsnp è abilitato per FIPS:

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

  4. Elencare i nodi usando il comando kubectl get nodes.

    kubectl get nodes

    L'output di esempio seguente mostra un elenco dei nodi del cluster. I nodi che iniziano con aks-fipsnp fanno parte del pool di nodi abilitato per 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. Eseguire una distribuzione con una sessione interattiva in uno dei nodi del pool di nodi abilitato per FIPS usando il comando kubectl debug.

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

  6. Dall'output interattivo della sessione verificare che le librerie di crittografia FIPS siano abilitate. L'output dovrebbe essere simile all'output di esempio seguente:

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

    I pool di nodi abilitati per FIPS hanno anche un'etichetta kubernetes.azure.com/fips_enabled=true, che le distribuzioni possono usare per indirizzare tali pool di nodi.

  1. Aggiungere il seguente codice a main.tf per creare un pool di nodi Linux con supporto FIPS nel 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. Applicare la configurazione aggiornata di Terraform utilizzando i comandi terraform plan e terraform apply.

    terraform plan
terraform apply

  3. Connetti al cluster AKS usando il comando [az aks get-credentials][az-aks-get-credentials].

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

  4. Verifica la configurazione del pool di nodi usando il comando az aks show e interrogando il valore enableFIPS in agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi fipsnp è abilitato per FIPS:

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

  5. Elencare i nodi usando il comando kubectl get nodes.

    kubectl get nodes

    L'output di esempio seguente mostra un elenco dei nodi del cluster. I nodi che iniziano con aks-fipsnp fanno parte del pool di nodi abilitato per 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. Eseguire una distribuzione con una sessione interattiva in uno dei nodi del pool di nodi abilitato per FIPS usando il comando kubectl debug.

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

  7. Dall'output interattivo della sessione verificare che le librerie di crittografia FIPS siano abilitate. L'output dovrebbe essere simile all'output di esempio seguente:

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

    I pool di nodi abilitati per FIPS hanno anche un'etichetta kubernetes.azure.com/fips_enabled=true, che le distribuzioni possono usare per indirizzare tali pool di nodi.

Per altre informazioni sulla risorsa azurerm_kubernetes_cluster_node_pool, vedere la documentazione Terraform Azure provider.

Aggiungere un pool di nodi Windows abilitato per FIPS

In questa sezione viene aggiunto un pool di nodi Windows a un cluster del servizio Azure Kubernetes esistente. Windows Server 2022 e pool di nodi successivi abilitano FIPS per impostazione predefinita anche se enableFips non mostra True. Windows Server 2025 e pool di nodi successivi non supportano la disabilitazione di FIPS.

  1. Creare un pool di nodi Windows usando il comando az aks nodepool add. A differenza dei pool di nodi basati su Linux, Windows pool di nodi condividono lo stesso set di immagini.

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

  2. Verificare la configurazione del pool di nodi usando il comando az aks show per interrogare il valore enableFIPS in agentPoolProfiles.

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

  3. Verificare che i pool di nodi Windows abbiano accesso alle librerie di crittografia FIPS, creando una connessione RDP a un nodo Windows in un pool di nodi e controllando il registro di sistema. Nell'applicazione Esegui immettere regedit.

  4. Cercare HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy nel Registro di sistema.

  5. Se Enabled è impostato su 1, FIPS è abilitato.

    Screenshot che mostra un'immagine dell'editor del Registro di sistema per i criteri dell'algoritmo FIPS e che è abilitata.

    I pool di nodi abilitati per FIPS hanno anche un'etichetta kubernetes.azure.com/fips_enabled=true, che le distribuzioni possono usare per indirizzare tali pool di nodi.

Non esiste un'esperienza Azure portale per abilitare o disabilitare le impostazioni FIPS per i pool di nodi Windows. Tutti i pool di nodi Windows creati con Azure portale sono abilitati per FIPS. Windows Server 2022 e i pool di nodi successivi abilitano FIPS per impostazione predefinita e Windows Server 2025 e pool di nodi successivi non supportano la disabilitazione di FIPS.

  1. Creare un pool di nodi Windows utilizzando un modello di Resource Manager distribuendo una risorsa del pool di agenti con osType impostato su Windows. Per esempio:

    {
  "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. Distribuire il modello ARM usando il portale Azure, interfaccia della riga di comando di Azure o Azure PowerShell. Per altre informazioni sulla distribuzione di modelli di Resource Manager, vedere Distribuire risorse con i modelli di Resource Manager.

  3. Verificare la configurazione del pool di nodi utilizzando il comando az aks show ed eseguire la query per il valore enableFIPS in agentPoolProfiles.

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

  4. Verificare che i pool di nodi Windows hanno accesso alle librerie di crittografia FIPS creando una connessione RDP a un nodo Windows in un pool di nodi e controllando il registro di sistema. Nell'applicazione Esegui immettere regedit.

  5. Cercare HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy nel Registro di sistema.

  6. Se Enabled è impostato su 1, FIPS è abilitato.

    Screenshot che mostra un'immagine dell'editor del Registro di sistema per i criteri dell'algoritmo FIPS e che è abilitata.

    I pool di nodi abilitati per FIPS hanno anche un'etichetta kubernetes.azure.com/fips_enabled=true, che le distribuzioni possono usare per indirizzare tali pool di nodi.

  1. Creare un pool di nodi Windows usando Bicep distribuendo una risorsa del pool di agenti con osType impostato su Windows. Per esempio:

    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. Distribuire il file di Bicep usando interfaccia della riga di comando di Azure, Azure PowerShell o il portale Azure. Per altre informazioni sulla distribuzione di file di Bicep, vedere Creare file Bicep usando Visual Studio Code.

  3. Verificare la configurazione del pool di nodi usando il comando az aks show ed eseguendo una query per verificare il valore enableFIPS in agentPoolProfiles.

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

  4. Verificare che i pool di nodi di Windows abbiano accesso alle librerie di crittografia FIPS creare una connessione RDP verso un nodo Windows in un pool di nodi e controllare il Registro. Nell'applicazione Esegui immettere regedit.

  5. Cercare HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy nel Registro di sistema.

  6. Se Enabled è impostato su 1, FIPS è abilitato.

    Screenshot che mostra un'immagine dell'editor del Registro di sistema per i criteri dell'algoritmo FIPS e che è abilitata.

    I pool di nodi abilitati per FIPS hanno anche un'etichetta kubernetes.azure.com/fips_enabled=true, che le distribuzioni possono usare per indirizzare tali pool di nodi.

  1. Aggiungere il codice seguente a main.tf per creare un pool di nodi Windows nel cluster del servizio Azure Kubernetes:

    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. Applicare la configurazione aggiornata di Terraform utilizzando i comandi terraform plan e terraform apply.

    terraform plan
terraform apply

  3. Connettersi al cluster AKS usando il comando [az aks get-credentials][az-aks-get-credentials].

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

  4. Verificare la configurazione del pool di nodi usando il comando az aks show e interrogare per il valore enableFIPS in agentPoolProfiles.

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

  5. Verificare che i pool di nodi Windows abbiano accesso alle librerie di crittografia FIPS creando una connessione RDP a un nodo Windows in un pool di nodi e controllando il registro. Nell'applicazione Esegui immettere regedit.

  6. Cercare HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\FIPSAlgorithmPolicy nel Registro di sistema.

  7. Se Enabled è impostato su 1, FIPS è abilitato.

    Screenshot che mostra un'immagine dell'editor del Registro di sistema per i criteri dell'algoritmo FIPS e che è abilitata.

    I pool di nodi abilitati per FIPS hanno anche un'etichetta kubernetes.azure.com/fips_enabled=true, che le distribuzioni possono usare per indirizzare tali pool di nodi.

Aggiornare un pool di nodi esistente per abilitare o disabilitare FIPS

I pool di nodi Linux esistenti possono essere aggiornati per abilitare o disabilitare FIPS. Se si prevede di eseguire la migrazione dei pool di nodi da non FIPS a FIPS, verificare prima di tutto che l'applicazione funzioni correttamente in un ambiente di test prima di eseguirne la migrazione a un ambiente di produzione. La convalida dell'applicazione in un ambiente di test deve impedire problemi causati dal kernel FIPS che blocca alcuni algoritmi di crittografia o crittografia deboli, ad esempio un algoritmo MD4 non conforme a FIPS.

Note

Quando si aggiorna un pool di nodi Linux esistente per abilitare o disabilitare FIPS, l'aggiornamento del pool di nodi si sposta tra l'immagine fips e l'immagine nonfips. Questo aggiornamento del pool di nodi attiva una ricreazione dell'immagine per completare l'aggiornamento. Questo può causare che l'aggiornamento del pool di nodi richieda alcuni minuti per essere completato.

Prerequisiti per l'aggiornamento di un pool di nodi esistente

interfaccia della riga di comando di Azure versione 2.64.0 o successiva. Per trovare la versione, eseguire az --version. Se è necessario installare o aggiornare, vedere Installare interfaccia della riga di comando di Azure.

Abilitare FIPS in un pool di nodi esistente

È possibile aggiornare i pool di nodi Linux esistenti per abilitare FIPS. Quando si aggiorna un pool di nodi esistente, l'immagine del nodo passa dall'immagine corrente all'immagine FIPS consigliata dello stesso SKU del sistema operativo.

  1. Aggiornare un pool di nodi usando il az aks nodepool update comando con il --enable-fips-image parametro .

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

    Questo comando avvia immediatamente una reimmagine del pool di nodi per distribuire il sistema operativo conforme FIPS. Questa ricreazione dell'immagine si verifica durante l'aggiornamento del pool di nodi. Non sono necessari passaggi aggiuntivi.

  2. Verificare che il pool di nodi sia abilitato per FIPS utilizzando il comando az aks show e effettuando un'interrogazione per il valore enableFIPS in agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi np è abilitato per FIPS:

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

L'abilitazione di FIPS in un pool di nodi esistente non è supportata nel portale di Azure. Per abilitare FIPS in un pool di nodi esistente, usare le istruzioni interfaccia della riga di comando di Azure, ARM, Bicep o Terraform in questo articolo.

  1. Abilitare FIPS in un pool di nodi esistente usando un modello di Azure Resource Manager aggiornando il profilo del pool di agenti per impostare la enableFips proprietà su true. Per esempio:

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

  2. Distribuire il modello aggiornato usando il portale Azure, interfaccia della riga di comando di Azure o Azure PowerShell. Per altre informazioni sulla distribuzione di modelli di Resource Manager, vedere Distribuire risorse con i modelli di Resource Manager.

  3. Verifica che il pool di nodi sia abilitato a FIPS utilizzando il comando az aks show e interrogando il valore enableFIPS in agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi np è abilitato per FIPS:

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

  1. Abilitare FIPS in un pool di nodi esistente usando Bicep aggiornando la risorsa del pool di agenti per impostare enableFIPS su true. Per esempio:

    param clusterName string
param nodePoolName string = 'np'

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

  2. Distribuire il file di Bicep aggiornato usando interfaccia della riga di comando di Azure, Azure PowerShell o il portale Azure. Per altre informazioni sulla distribuzione di file di Bicep, vedere Creare file Bicep usando Visual Studio Code.

  3. Verificare che il pool di nodi sia abilitato per FIPS usando il comando az aks show e interrogando per il valore enableFIPS in agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi np è abilitato per FIPS:

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

  1. Aggiornare la risorsa azurerm_kubernetes_cluster_node_pool in main.tf impostando 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. Applicare la configurazione aggiornata di Terraform utilizzando i comandi terraform plan e terraform apply. Terraform rileva la modifica in fips_enabled e attiva l'operazione di ricreazione dell'immagine necessaria.

    terraform plan
terraform apply

  3. Connettersi al cluster AKS usando il comando [az aks get-credentials][az-aks-get-credentials].

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

  4. Verificare che il pool di nodi sia abilitato per FIPS usando il comando az aks show e cercando il valore enableFIPS in agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi np è abilitato per FIPS:

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

Disabilitare FIPS in un pool di nodi esistente

È possibile aggiornare i pool di nodi Linux esistenti per disabilitare FIPS. Quando si aggiorna un pool di nodi esistente, l'immagine del nodo passa dall'immagine FIPS corrente all'immagine non FIPS consigliata dello stesso SKU del sistema operativo. La modifica dell'immagine del nodo si verifica dopo una ricreazione dell'immagine.

  1. Aggiornare un pool di nodi Linux usando il az aks nodepool update comando con il --disable-fips-image parametro .

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

    Questo comando attiva immediatamente una reimpostazione dell'immagine del pool di nodi per distribuire il sistema operativo conforme a FIPS. Questa ricreazione dell'immagine si verifica durante l'aggiornamento del pool di nodi. Non sono necessari passaggi aggiuntivi.

  2. Verificare che il pool di nodi non sia abilitato per FIPS effettuando il comando az aks show e la ricerca del valore enableFIPS in agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi np non è abilitato per FIPS:

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

Attualmente, la disabilitazione di FIPS in un pool di nodi esistente non è supportata nel portale di Azure. Per disabilitare FIPS in un pool di nodi esistente, usare le indicazioni di interfaccia della riga di comando di Azure, ARM, Bicep o Terraform in questo articolo.

  1. Disabilitare FIPS in un pool di nodi esistente usando un modello ARM aggiornando il profilo del pool di agenti per impostare la proprietà enableFips su false. Per esempio:

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

  2. Distribuire il modello aggiornato usando il portale Azure, interfaccia della riga di comando di Azure o Azure PowerShell. Per altre informazioni sulla distribuzione di modelli di Resource Manager, vedere Distribuire risorse con i modelli di Resource Manager.

  3. Verificare che il pool di nodi non sia con FIPS abilitato utilizzando il comando az aks show ed eseguendo la query per il valore enableFIPS in agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi np non è abilitato per FIPS:

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

  1. Disabilitare FIPS in un pool di nodi esistente usando Bicep aggiornando la risorsa del pool di agenti per impostare enableFIPS su false. Per esempio:

    param clusterName string
param nodePoolName string = 'np'

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

  2. Distribuire il file di Bicep aggiornato usando interfaccia della riga di comando di Azure, Azure PowerShell o il portale Azure. Per altre informazioni sulla distribuzione di file di Bicep, vedere Creare file Bicep usando Visual Studio Code.

  3. Verificare che il pool di nodi non sia abilitato per FIPS utilizzando il comando az aks show per interrogare il valore enableFIPS in agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi np non è abilitato per FIPS:

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

  1. Aggiornare la azurerm_kubernetes_cluster_node_pool risorsa in main.tf impostando fips_enabled su 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. Applicare la configurazione aggiornata di Terraform utilizzando i comandi terraform plan e terraform apply. Terraform rileva la modifica in fips_enabled e attiva l'operazione di ricreazione dell'immagine necessaria.

    terraform plan
terraform apply

  3. Verificare che il pool di nodi non sia FIPS abilitato usando il comando az aks show e interroga il valore enableFIPS nell'agentPoolProfiles.

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

    L'output di esempio seguente mostra che il pool di nodi np non è abilitato per FIPS:

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

Messaggio del giorno

È possibile sostituire il messaggio del giorno (MOTD) nei nodi Linux usando il flag durante la --message-of-the-day creazione di un cluster o l'aggiunta di un pool di nodi.

Creare un cluster e sostituire il messaggio del giorno utilizzando il comando az aks create con il flag --message-of-the-day impostato sul percorso del nuovo file MOTD.

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

Aggiungere un pool di nodi e sostituire il messaggio del giorno utilizzando il comando az aks nodepool add con il flag --message-of-the-day impostato sul percorso del nuovo file MOTD.

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

Contenuti correlati

Per altre informazioni sulla sicurezza del servizio Azure Kubernetes, vedere Best practices for cluster security and upgrades in Servizio Azure Kubernetes (AKS).

  • Last updated on