Servizio Azure Kubernetes (AKS) per le zone estese

Usare il parametro extendedLocation per specificare la zona estesa di Azure desiderata in un modello di Resource Manager.

"extendedLocation": {
    "name": "<extended-zone-id>",
    "type": "EdgeZone",
},

Il modello di Resource Manager seguente distribuisce un nuovo cluster in una zona estesa di Azure.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "metadata": {
    "_generator": {
      "name": "bicep",
      "version": "0.9.1.41621",
      "templateHash": "2637152180661081755"
    }
  },
  "parameters": {
    "clusterName": {
      "type": "string",
      "defaultValue": "myAKSCluster",
      "metadata": {
        "description": "The name of the Managed Cluster resource."
      }
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]",
      "metadata": {
        "description": "The location of the Managed Cluster resource."
      }
    },
    "edgeZoneName": {
      "type": "String",
      "metadata": {
        "description": "The name of the Azure Extended Zone"
      }
    },
    "dnsPrefix": {
      "type": "string",
      "metadata": {
        "description": "Optional DNS prefix to use with hosted Kubernetes API server FQDN."
      }
    },
    "osDiskSizeGB": {
      "type": "int",
      "defaultValue": 0,
      "maxValue": 1023,
      "minValue": 0,
      "metadata": {
        "description": "Disk size (in GB) to provision for each of the agent pool nodes. This value ranges from 0 to 1023. Specifying 0 will apply the default disk size for that agentVMSize."
      }
    },
    "agentCount": {
      "type": "int",
      "defaultValue": 3,
      "maxValue": 50,
      "minValue": 1,
      "metadata": {
        "description": "The number of nodes for the cluster."
      }
    },
    "agentVMSize": {
      "type": "string",
      "defaultValue": "standard_d2s_v3",
      "metadata": {
        "description": "The size of the Virtual Machine."
      }
    },
    "linuxAdminUsername": {
      "type": "string",
      "metadata": {
        "description": "User name for the Linux Virtual Machines."
      }
    },
    "sshRSAPublicKey": {
      "type": "string",
      "metadata": {
        "description": "Configure all linux machines with the SSH RSA public key string. Your key should include three parts, for example 'ssh-rsa AAAAB...snip...UcyupgH azureuser@linuxvm'"
      }
    }
  },
  "resources": [
    {
      "type": "Microsoft.ContainerService/managedClusters",
      "apiVersion": "2024-09-01",
      "name": "[parameters('clusterName')]",
      "location": "[parameters('location')]",
      "extendedLocation": {
        "name": "[parameters('edgeZoneName')]",
        "type": "EdgeZone"
      },
      "identity": {
        "type": "SystemAssigned"
      },
      "properties": {
        "dnsPrefix": "[parameters('dnsPrefix')]",
        "agentPoolProfiles": [
          {
            "name": "agentpool",
            "osDiskSizeGB": "[parameters('osDiskSizeGB')]",
            "count": "[parameters('agentCount')]",
            "vmSize": "[parameters('agentVMSize')]",
            "osType": "Linux",
            "mode": "System"
          }
        ],
        "linuxProfile": {
          "adminUsername": "[parameters('linuxAdminUsername')]",
          "ssh": {
            "publicKeys": [
              {
                "keyData": "[parameters('sshRSAPublicKey')]"
              }
            ]
          }
        }
      }
    }
  ],
  "outputs": {
    "controlPlaneFQDN": {
      "type": "string",
      "value": "[reference(resourceId('Microsoft.ContainerService/managedClusters', parameters('clusterName'))).fqdn]"
    }
  }
}

Se non si ha familiarità con i modelli di Resource Manager, vedere l'esercitazione sulla distribuzione di un modello di Resource Manager locale.

Preparare le variabili seguenti per distribuire un cluster del servizio Azure Kubernetes in una zona estesa di Azure usando l'interfaccia della riga di comando di Azure:

SUBSCRIPTION="<your-subscription>"
RG_NAME="<your-resource-group>"
CLUSTER_NAME="<your-cluster>"
EXTENDED_ZONE_NAME="<extended-zone-id>"
LOCATION="<parent-region>" # Ensure this location corresponds to the parent region for your targeted Azure Extended Zone

Dopo essersi assicurati di aver eseguito l'accesso e usato la sottoscrizione appropriata, usare az aks create per distribuire il cluster, specificando la zona estesa di Azure di destinazione con la proprietà --edge-zone.

Creare un cluster pubblico

# Log in to Azure
az login

# Set the subscription you want to create the cluster on
az account set --subscription $SUBSCRIPTION 

# Create the resource group
az group create --name $RG_NAME --location $LOCATION

# Deploy the cluster in your designated Azure Extended Zone
az aks create \
    --resource-group $RG_NAME \
    --name $CLUSTER_NAME \
    --edge-zone $EXTENDED_ZONE_NAME \
    --location $LOCATION \
    --generate-ssh-keys

Creare un cluster privato

Per distribuire un cluster AKS privato in una Azure Extended Zone, aggiungere il flag --enable-private-cluster.

az aks create \
    --resource-group $RG_NAME \
    --name $CLUSTER_NAME \
    --edge-zone $EXTENDED_ZONE_NAME \
    --location $LOCATION \
    --enable-private-cluster \
    --generate-ssh-keys

Dopo aver distribuito un servizio Azure Kubernetes per il cluster di Zone Estese, è possibile controllare lo stato e monitorare le metriche del cluster usando il portale di Azure o l'interfaccia della riga di comando di Azure.

Il codice seguente crea un gruppo di risorse e un cluster Kubernetes in Azure, con scalabilità automatica abilitata e impostazioni di rete specifiche usando Terraform.

1. Creare una directory in cui testare ed eseguire il codice Terraform di esempio e impostarla come directory corrente.

2. Creare un file denominato main.tfe inserire il codice seguente:

   resource "random_pet" "rg_name" {
     prefix = var.resource_group_name_prefix
   }
   
   resource "azurerm_resource_group" "rg" {
     location = var.resource_group_location
     name     = random_pet.rg_name.id
   }
   
   resource "random_pet" "azurerm_kubernetes_cluster_name" {
     prefix = "cluster"
   }
   
   resource "random_pet" "azurerm_kubernetes_cluster_dns_prefix" {
     prefix = "dns"
   }
   
   resource "azapi_resource" "aks" {
     type      = "Microsoft.ContainerService/ManagedClusters@2024-05-01"
     name      = random_pet.azurerm_kubernetes_cluster_name.id
     parent_id = azurerm_resource_group.rg.id
     location  = azurerm_resource_group.rg.location
     identity {
       type = "SystemAssigned"
     }
     body = {
       extendedLocation = {
         name = replace(lower(var.aks_extended_zone), " ", "")
         type = "EdgeZone"
       }
       sku = {
         name = "Base"
         tier = "Free"
       }
       properties = {
         dnsPrefix         = random_pet.azurerm_kubernetes_cluster_dns_prefix.id
         kubernetesVersion = "1.29"
         agentPoolProfiles = [
           {
             name                   = "agentpool"
             count                  = var.aks_node_count
             vmSize                 = var.aks_node_vm_size
             osDiskSizeGB           = 128
             kubeletDiskType        = "OS"
             maxPods                = 30
             type                   = "VirtualMachineScaleSets"
             enableAutoScaling      = false,
             scaleDownMode          = "Delete",
             orchestratorVersion    = "1.29"
             enableNodePublicIP     = false
             mode                   = "System"
             enableEncryptionAtHost = false
             enableUltraSSD         = false
             osType                 = "Linux"
             osSKU                  = "Ubuntu"
             upgradeSettings = {
               maxSurge = "10%"
             }
             enableFIPS = false
           }
         ]
         windowsProfile = {
           adminUsername  = var.admin_username
           adminPassword  = var.admin_password
           licenseType    = "None"
           enableCSIProxy = true
         }
         servicePrincipalProfile = {
           clientId = "msi"
         }
         enableRBAC  = true
         supportPlan = "KubernetesOfficial"
         networkProfile = {
           networkPlugin    = "azure"
           networkPolicy    = "none"
           networkDataplane = "azure"
           loadBalancerSku  = "standard"
           loadBalancerProfile = {
             managedOutboundIPs = {
               count = 1
             }
             backendPoolType = "nodeIPConfiguration"
           }
           serviceCidr  = "10.0.0.0/16"
           dnsServiceIP = "10.0.0.10"
           outboundType = "loadBalancer"
           serviceCidrs = [
             "10.0.0.0/16",
           ]
           ipFamilies = ["IPv4"]
         }
         autoUpgradeProfile = {
           upgradeChannel       = "none"
           nodeOSUpgradeChannel = "NodeImage"
         }
         disableLocalAccounts = false
         storageProfile = {
           diskCSIDriver = {
             enabled = true
           }
           fileCSIDriver = {
             enabled = true
           }
           snapshotController = {
             enabled = true
           }
         }
         oidcIssuerProfile = {
           enabled = false
         }
         azureMonitorProfile = {
           metrics = {
             enabled = false
           }
         }
       }
     }
     timeouts {
       create = "6h"
     }
   }
   

3. Creare un file denominato outputs.tfe inserire il codice seguente:

   output "resource_group_name" {
     value = azurerm_resource_group.rg.name
   }
   
   output "aks_cluster_name" {
     value = azapi_resource.aks.name
   }
   
   output "aks_extended_zone" {
     value = azapi_resource.aks.body.extendedLocation.name
   }
   

4. Creare un file denominato providers.tfe inserire il codice seguente:

   terraform {
     required_providers {
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~>3.0"
       }
       azapi = {
         source  = "Azure/azapi"
         version = "2.0.1"
       }
       random = {
         source  = "hashicorp/random"
         version = "~>3.0"
       }
     }
   }
   
   provider "azurerm" {
     features {}
   }
   

5. Creare un file denominato variables.tfe inserire il codice seguente:

   variable "resource_group_name_prefix" {
     type        = string
     default     = "rg"
     description = "Prefix of the resource group name that's combined with a random ID so name is unique in your Azure subscription."
   }
   
   variable "resource_group_location" {
     type        = string
     default     = "West US"
     description = "Location of the resource group."
   }
   
   variable "virtual_network_name" {
     type        = string
     description = "Virtual network names"
     default     = "example-vnet"
   }
   
   variable "aks_node_count" {
     type        = number
     description = "AKS node count"
     default     = 3
   }
   
   variable "aks_node_vm_size" {
     type        = string
     description = "AKS node VM size"
     default     = "Standard_D2_v2"
   }
   
   variable "admin_username" {
     type        = string
     description = "The admin username for the Windows node pool."
     default     = "azureuser"
   }
   
   variable "admin_password" {
     type        = string
     description = "The admin password for the Windows node pool."
     default     = "Passw0rd1234Us!"
   }
   
   variable "aks_extended_zone" {
     type        = string
     description = "AKS extended zone"
     default     = "Los Angeles"
   }
   

6. Inizializzare Terraform.

   Per inizializzare la distribuzione di Terraform, eseguire terraform init. Questo comando scarica il provider di Azure necessario per gestire le risorse di Azure.

   terraform init -upgrade
   

   Punti principali:

   • Il parametro -upgrade aggiorna i plug-in del provider necessari alla versione più recente conforme ai vincoli di versione della configurazione.

7. Creare un piano di esecuzione di Terraform.

   Eseguire terraform plan per creare un piano di esecuzione.

   terraform plan -out main.tfplan
   

   Punti principali:

   • Il comando terraform plan crea un piano di esecuzione, ma non lo esegue. Determina invece le azioni necessarie per creare la configurazione specificata nei file di configurazione. Questo modello consente di verificare se il piano di esecuzione corrisponde alle aspettative prima di apportare modifiche alle risorse effettive.
   • Il parametro facoltativo -out consente di specificare un file di output per il piano. L'uso del parametro -out garantisce che il piano esaminato sia esattamente quello applicato.

8. Applicare un piano di esecuzione Terraform.

   Esegui terraform apply per applicare il piano di esecuzione all'infrastruttura cloud.

   terraform apply main.tfplan
   

   Punti principali:

   • Il comando terraform apply di esempio presuppone che in precedenza sia stato eseguito terraform plan -out main.tfplan.
   • Se è stato specificato un nome file diverso per il parametro -out, usare lo stesso nome file nella chiamata a terraform apply.
   • Se non è stato usato il parametro -out, chiamare terraform apply senza parametri.