Configurare l'ingresso con l'API del gateway Kubernetes tramite il componente aggiuntivo di routing dell'applicazione per Servizio Azure Kubernetes (AKS)

Aggiornare la versione dell'interfaccia della riga di comando di Azure

È necessario usare azure-cli versione 2.86.0 o successiva. Eseguire az --version per trovare la azure-cli versione ed eseguire az upgrade per eseguire l'aggiornamento.

Abilitare le CRD di Managed Gateway API

Abilitare l'installazione dell'API del gateway gestito. L'uso dei CRD dell'API Gateway autogestiti con il componente aggiuntivo per il routing delle applicazioni non è supportato.

Comportamento predefinito automatico di AKS (AKS 1.36 e versioni successive)

Nei nuovi cluster automatici del servizio Azure Kubernetes che eseguono il servizio Azure Kubernetes 1.36 o versione successiva, l'API del gateway Kubernetes tramite il componente aggiuntivo di routing dell'applicazione è abilitata per impostazione predefinita.

In genere non è necessario eseguire il comando di abilitazione delle funzionalità, a meno che non si sia:

• Uso di un cluster esistente.
• Uso di una versione precedente di AKS.
• Riabilitare la funzionalità dopo averlo disabilitato.

Abilitare l'implementazione dell'API del gateway di routing dell'applicazione

Abilitare durante la creazione del cluster

Esegui il comando seguente per abilitare l'implementazione dell'API Gateway per l'instradamento dell'applicazione durante la creazione di un cluster Standard di AKS:

# Set environment variables
export CLUSTER=<cluster-name>
export RESOURCE_GROUP=<resource-group-name>

# Enable the application routing Gateway API implementation during AKS Standard cluster creation
az aks create --resource-group ${RESOURCE_GROUP} --name ${CLUSTER} --enable-gateway-api --enable-app-routing-istio

Abilitare per un cluster esistente

Eseguire il comando seguente per abilitare l'implementazione dell'API gateway di routing dell'applicazione per un cluster esistente:

# Set environment variables
export CLUSTER=<cluster-name>
export RESOURCE_GROUP=<resource-group-name>

# Enable the application routing Gateway API implementation for an existing cluster
az aks update --resource-group ${RESOURCE_GROUP} --name ${CLUSTER} --enable-gateway-api --enable-app-routing-istio

I pod istiod devono essere visualizzati nello spazio dei nomi aks-istio-system:

kubectl get pods -n aks-istio-system

NAME                      READY   STATUS    RESTARTS   AGE
istiod-12a3bc45de-fghi6   1/1     Running   0          3m15s
istiod-78j9kl01mn-opqrs   1/1     Running   0          3m

Dovresti anche vedere il ValidatingWebhookConfiguration venire distribuito:

kubectl get validatingwebhookconfiguration

NAME                                        WEBHOOKS   AGE
aks-node-validating-webhook                 1          117m
azure-service-mesh-ccp-validating-webhook   1          4m2s

Se l'installazione dell'API del gateway gestito è abilitata, deve essere visualizzata anche la creazione dell'oggetto ConfigMap per la personalizzazione del gateway Istio:

kubectl get cm -n aks-istio-system

NAME                                  DATA   AGE
...
istio-gateway-class-defaults          2      43s
...

Configurare l'ingresso con un gateway Kubernetes

Distribuire l'applicazione di esempio

Per prima cosa, distribuisci l'applicazione di esempio httpbin nello spazio dei nomi default

export ISTIO_RELEASE="release-1.27"
kubectl apply -f https://raw.githubusercontent.com/istio/istio/$ISTIO_RELEASE/samples/httpbin/httpbin.yaml

Creare un Gateway di Kubernetes e un HTTPRoute

Distribuire quindi una configurazione dell'API del gateway nello spazio dei nomi default con gatewayClassName impostato su approuting-istio.

kubectl apply -f - <<EOF
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: httpbin-gateway
spec:
  gatewayClassName: approuting-istio
  listeners:
  - name: http
    port: 80
    protocol: HTTP
    allowedRoutes:
      namespaces:
        from: Same
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: httpbin
spec:
  parentRefs:
  - name: httpbin-gateway
  hostnames: ["httpbin.example.com"]
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /get
    backendRefs:
    - name: httpbin
      port: 8000
EOF

Verificare che siano stati creati un Deployment, Service, HorizontalPodAutoscaler e PodDisruptionBudget per httpbin-gateway:

kubectl get deployment httpbin-gateway-approuting-istio

NAME                               READY   UP-TO-DATE   AVAILABLE   AGE
httpbin-gateway-approuting-istio   2/2     2            2           6m41s

kubectl get service httpbin-gateway-approuting-istio

NAME                               TYPE           CLUSTER-IP   EXTERNAL-IP      PORT(S)                        AGE
httpbin-gateway-approuting-istio   LoadBalancer   10.0.54.96   <external-ip>    15021:30580/TCP,80:32693/TCP   7m13s

kubectl get hpa httpbin-gateway-approuting-istio

NAME                               REFERENCE                                     TARGETS       MINPODS   MAXPODS   REPLICAS   AGE
httpbin-gateway-approuting-istio   Deployment/httpbin-gateway-approuting-istio   cpu: 3%/80%   2         5         2          8m13s

kubectl get pdb httpbin-gateway-approuting-istio

NAME                               MIN AVAILABLE   MAX UNAVAILABLE   ALLOWED DISRUPTIONS   AGE
httpbin-gateway-approuting-istio   1               N/A               1                     9m1s

Inviare una richiesta all'applicazione di esempio

Infine, provare a inviare una curl richiesta all'applicazione httpbin . Prima di tutto, impostare la INGRESS_HOST variabile di ambiente:

kubectl wait --for=condition=programmed gateways.gateway.networking.k8s.io httpbin-gateway
export INGRESS_HOST=$(kubectl get gateways.gateway.networking.k8s.io httpbin-gateway -ojsonpath='{.status.addresses[0].value}')

Provare quindi a inviare una richiesta HTTP a httpbin:

curl -s -I -HHost:httpbin.example.com "http://$INGRESS_HOST/get"

Verrà visualizzata una HTTP 200 risposta.

Per usare Terraform per creare un cluster AKS con l'implementazione Gateway API del routing dell'applicazione abilitata, è necessario:

• Terraform versione 1.9.0 o successiva installato.
• CLI di Azure installata e autenticata. Eseguire az --version per trovare la azure-cli versione ed eseguire az upgrade per eseguire l'aggiornamento. Si usa l'interfaccia della riga di comando di Azure (interfaccia della riga di comando di Azure) per connettersi al cluster dopo che Terraform lo ha creato.
• kubectl installato. È possibile installarlo in locale usando il az aks install-cli comando . Utilizza kubectl per distribuire l'applicazione di esempio e le risorse dell'API Gateway.

Distribuisci un cluster AKS con l'implementazione di Gateway API per il routing delle applicazioni con Terraform

Questa sezione illustra come usare Terraform per distribuire un cluster di Azure Kubernetes Service (AKS) con l'installazione di Managed Gateway API e l'implementazione di Gateway API per il routing delle applicazioni abilitata.

Questo esempio distribuisce:

• Un gruppo di risorse.
• Un cluster AKS che usa il plug-in di rete Azure CNI e un load balancer Standard.
• L'installazione dell'API gateway gestito e l'implementazione dell'API del gateway di routing dell'applicazione, entrambe abilitate nel cluster tramite il provider AzAPI. Abilitando entrambe le impostazioni, la GatewayClass gestita da AKS approuting-istio diventa disponibile nel cluster.

1. Creare una directory per testare ed eseguire il codice Terraform di esempio e impostarlo come directory corrente.

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

   terraform {
     required_version = ">= 1.9.0"
   
     required_providers {
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~> 4.0"
       }
       azapi = {
         source  = "Azure/azapi"
         version = "~> 2.0"
       }
       random = {
         source  = "hashicorp/random"
         version = "~> 3.0"
       }
     }
   }
   
   provider "azurerm" {
     features {}
   }
   
   provider "azapi" {
     enable_preflight = true
   }
   
   resource "random_string" "suffix" {
     length  = 6
     upper   = false
     special = false
   }
   
   locals {
     location            = "eastus"
     resource_group_name = "rg-aks-gateway-api-${random_string.suffix.result}"
     cluster_name        = "aks-gwapi-${random_string.suffix.result}"
   }
   
   resource "azurerm_resource_group" "example" {
     name     = local.resource_group_name
     location = local.location
   }
   
   resource "azurerm_kubernetes_cluster" "example" {
     name                              = local.cluster_name
     location                          = azurerm_resource_group.example.location
     resource_group_name               = azurerm_resource_group.example.name
     dns_prefix                        = local.cluster_name
     role_based_access_control_enabled = true
   
     default_node_pool {
       name       = "system"
       node_count = 2
       vm_size    = "Standard_D4s_v4"
   
       upgrade_settings {
         drain_timeout_in_minutes      = 0
         max_surge                     = "10%"
         node_soak_duration_in_minutes = 0
       }
     }
   
     identity {
       type = "SystemAssigned"
     }
   
     network_profile {
       network_plugin    = "azure"
       load_balancer_sku = "standard"
     }
   }
   
   resource "azapi_update_resource" "gateway_api_app_routing" {
     type        = "Microsoft.ContainerService/managedClusters@2026-03-01"
     resource_id = azurerm_kubernetes_cluster.example.id
     body = {
       properties = {
         ingressProfile = {
           gatewayAPI = {
             installation = "Standard"
           }
           webAppRouting = {
             gatewayAPIImplementations = {
               appRoutingIstio = {
                 mode = "Enabled"
               }
             }
           }
         }
       }
     }
     response_export_values = [
       "properties.ingressProfile"
     ]
     depends_on = [
       azurerm_kubernetes_cluster.example
     ]
   }
   
   output "resource_group_name" {
     value = azurerm_resource_group.example.name
   }
   
   output "cluster_name" {
     value = azurerm_kubernetes_cluster.example.name
   }
   
   output "get_credentials_command" {
     value = "az aks get-credentials --resource-group ${azurerm_resource_group.example.name} --name ${azurerm_kubernetes_cluster.example.name} --overwrite-existing"
   }
   

3. Inizializzare Terraform eseguendo il terraform init comando . Questo comando scarica i provider di Azure necessari per gestire le risorse Azure con Terraform.

   terraform init
   

4. Formattare e convalidare la configurazione eseguendo i terraform fmt comandi e terraform validate .

   terraform fmt
   terraform validate
   

5. Crea un piano di esecuzione di Terraform eseguendo il comando terraform plan. Questo comando mostra le risorse create o modificate da Terraform nella sottoscrizione Azure.

   terraform plan
   

6. Applica il piano di esecuzione di Terraform eseguendo il comando terraform apply. Questo comando crea le risorse definite nel main.tf file nella sottoscrizione Azure. Quando richiesto, immettere yes per confermare.

   terraform apply
   

Connettersi al cluster AKS usando Terraform

1. Ottenere il gruppo di risorse e i nomi dei cluster dagli output di Terraform.

   terraform output -raw resource_group_name
   terraform output -raw cluster_name
   

2. Configura kubectl per connetterti al tuo cluster utilizzando il comando az aks get-credentials. Questo comando scarica le credenziali e configura l'interfaccia della riga di comando di Kubernetes per usarle. Sostituire <resource-group-name> e <cluster-name> con i valori del passaggio precedente. In alternativa, eseguire terraform output -raw get_credentials_command per ottenere il comando completo pronto per l'esecuzione.

   az aks get-credentials --resource-group <resource-group-name> --name <cluster-name>
   

3. Verificare che il cluster sia in esecuzione eseguendo il kubectl get nodes comando .

   kubectl get nodes
   

Verificare la configurazione dell'API gateway usando Terraform

1. Verifica che i pod istiod siano in esecuzione nel namespace aks-istio-system.

   kubectl get pods -n aks-istio-system
   

2. Verificare che GatewayClass approuting-istio esista e che sia accettato.

   kubectl get gatewayclass
   

   GatewayClass approuting-istio deve restituire True nella ACCEPTED colonna .

Configurare l'ingresso usando un gateway Kubernetes con Terraform

Distribuire l'applicazione di esempio usando Terraform

Distribuisci l'applicazione di esempio nel namespace default:

kubectl apply -f https://raw.githubusercontent.com/istio/istio/release-1.27/samples/httpbin/httpbin.yaml

Verifica che il httpbin pod e il servizio siano disponibili:

kubectl get pods -l app=httpbin
kubectl get svc httpbin

Creare le risorse gateway e HTTPRoute usando Terraform

L'esempio di implementazione della Gateway API per il routing delle applicazioni include un Gateway manifest che crea un listener HTTP sulla porta 80 e usa la approuting-istio GatewayClass gestita da AKS.

1. Creare un file denominato gateway.yamle inserire il codice seguente:

   apiVersion: gateway.networking.k8s.io/v1
   kind: Gateway
   metadata:
     name: httpbin-gateway
   spec:
     gatewayClassName: approuting-istio
     listeners:
       - name: http
         port: 80
         protocol: HTTP
         allowedRoutes:
           namespaces:
             from: Same
   

2. Applicare la Gateway configurazione:

   kubectl apply -f gateway.yaml
   

   L'esempio include anche un HTTPRoute manifest che instrada le richieste per httpbin.example.com/get al servizio httpbin sulla porta 8000.

3. Creare un file denominato httproute.yamle inserire il codice seguente:

   apiVersion: gateway.networking.k8s.io/v1
   kind: HTTPRoute
   metadata:
     name: httpbin
   spec:
     parentRefs:
       - name: httpbin-gateway
     hostnames:
       - httpbin.example.com
     rules:
       - matches:
           - path:
               type: PathPrefix
               value: /get
         backendRefs:
           - name: httpbin
             port: 8000
   

4. Applicare la HTTPRoute configurazione:

   kubectl apply -f httproute.yaml
   

Verificare che siano stati creati un Deployment, Service, HorizontalPodAutoscaler e PodDisruptionBudget per httpbin-gateway:

kubectl get deployment httpbin-gateway-approuting-istio
kubectl get service httpbin-gateway-approuting-istio
kubectl get hpa httpbin-gateway-approuting-istio
kubectl get pdb httpbin-gateway-approuting-istio

Inviare una richiesta all'applicazione di esempio usando Terraform

Attendere che il gateway segnala una Programmed condizione, quindi ottenere il relativo indirizzo esterno:

kubectl wait --for=condition=programmed gateways.gateway.networking.k8s.io httpbin-gateway
export INGRESS_HOST=$(kubectl get gateways.gateway.networking.k8s.io httpbin-gateway -ojsonpath='{.status.addresses[0].value}')

Quindi, inviare una richiesta a httpbin attraverso il Gateway:

curl -s -I -HHost:httpbin.example.com "http://$INGRESS_HOST/get"

Verrà visualizzata una HTTP 200 risposta.

Disabilitare l'implementazione dell'API del gateway di routing dell'applicazione

Eseguire il comando seguente per disabilitare l'implementazione dell'API del gateway di routing dell'applicazione:

az aks update --resource-group ${RESOURCE_GROUP} --name ${CLUSTER} --disable-app-routing-istio

Pulire le risorse

Eseguire i comandi seguenti per eliminare le Gateway risorse e HTTPRoute :

kubectl delete gateways.gateway.networking.k8s.io httpbin-gateway
kubectl delete httproute httpbin

Se è stato creato un oggetto ConfigMap per personalizzare Gateway, eseguire il comando seguente per eliminare ConfigMap:

kubectl delete configmap gw-options

Se è stato creato un secretProviderClass e un segreto da usare per la terminazione TLS, eliminare le risorse seguenti:

kubectl delete secret httpbin-credential
kubectl delete pod secrets-store-sync-httpbin
kubectl delete secretproviderclass httpbin-credential-spc

Pulire le risorse usando Terraform

In questa sezione, hai distribuito un'applicazione di esempio con ambito namespace e risorse dell'API Gateway. Se queste risorse Kubernetes non sono più necessarie, eliminarle prima di rimuovere l'infrastruttura di Azure sottostante.

Eliminare HTTPRoute, Gateway e l'applicazione di esempio utilizzando il comando kubectl delete:

kubectl delete -f httproute.yaml
kubectl delete -f gateway.yaml
kubectl delete -f https://raw.githubusercontent.com/istio/istio/release-1.27/samples/httpbin/httpbin.yaml

Rimuovere le risorse Azure create da Terraform usando il terraform destroy comando . Quando richiesto, immettere yes per confermare.

terraform destroy