Guida introduttiva: Distribuire un cluster del servizio Azure Kubernetes con Terraform

• Per altre informazioni sulla creazione di un pool di nodi di Windows Server, vedere Creare un cluster del servizio Azure Kubernetes che supporta i contenitori di Windows Server.

• Installa e configura Terraform.
• Scaricare kubectl.
• Creare un valore casuale per il nome del gruppo di risorse di Azure usando random_pet.
• Creare un gruppo di risorse di Azure usando azurerm_resource_group.
• Accedere alla configurazione del provider AzureRM per ottenere l'ID oggetto di Azure usando azurerm_client_config.
• Creare un cluster Kubernetes usando azurerm_kubernetes_cluster.
• Creare una risorsa AzAPI azapi_resource.
• Creare una risorsa AzAPI per generare una coppia di chiavi SSH usando azapi_resource_action.

Accedere al proprio account Azure

Prima di tutto, accedere all'account Azure ed eseguire l'autenticazione usando uno dei metodi descritti nella sezione seguente.

Terraform supporta solo l'autenticazione in Azure con l'interfaccia della riga di comando di Azure. L'autenticazione con Azure PowerShell non è supportata. Pertanto, anche se è possibile usare il modulo Azure PowerShell quando si esegue il lavoro di Terraform, è prima necessario eseguire l'autenticazione in Azure.

Implementare il codice Terraform

1. Creare una directory che è possibile usare per testare il codice Terraform di esempio e impostarlo come directory corrente.

2. Creare un file denominato providers.tf e inserire il codice seguente:

   terraform {
     required_version = ">=1.0"
   
     required_providers {
       azapi = {
         source  = "azure/azapi"
         version = "~>1.5"
       }
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~>3.0"
       }
       random = {
         source  = "hashicorp/random"
         version = "~>3.0"
       }
       time = {
         source  = "hashicorp/time"
         version = "0.9.1"
       }
     }
   }
   
   provider "azurerm" {
     features {}
   }
   

3. Creare un file denominato ssh.tf e inserire il codice seguente:

   resource "random_pet" "ssh_key_name" {
     prefix    = "ssh"
     separator = ""
   }
   
   resource "azapi_resource_action" "ssh_public_key_gen" {
     type        = "Microsoft.Compute/sshPublicKeys@2022-11-01"
     resource_id = azapi_resource.ssh_public_key.id
     action      = "generateKeyPair"
     method      = "POST"
   
     response_export_values = ["publicKey", "privateKey"]
   }
   
   resource "azapi_resource" "ssh_public_key" {
     type      = "Microsoft.Compute/sshPublicKeys@2022-11-01"
     name      = random_pet.ssh_key_name.id
     location  = azurerm_resource_group.rg.location
     parent_id = azurerm_resource_group.rg.id
   }
   
   output "key_data" {
     value = azapi_resource_action.ssh_public_key_gen.output.publicKey
   }
   

4. Creare un file denominato main.tf e inserire il codice seguente:

   # Generate random resource group name
   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 "azurerm_kubernetes_cluster" "k8s" {
     location            = azurerm_resource_group.rg.location
     name                = random_pet.azurerm_kubernetes_cluster_name.id
     resource_group_name = azurerm_resource_group.rg.name
     dns_prefix          = random_pet.azurerm_kubernetes_cluster_dns_prefix.id
   
     identity {
       type = "SystemAssigned"
     }
   
     default_node_pool {
       name       = "agentpool"
       vm_size    = "Standard_D2_v2"
       node_count = var.node_count
     }
     linux_profile {
       admin_username = var.username
   
       ssh_key {
         key_data = azapi_resource_action.ssh_public_key_gen.output.publicKey
       }
     }
     network_profile {
       network_plugin    = "kubenet"
       load_balancer_sku = "standard"
     }
   }
   

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

   variable "resource_group_location" {
     type        = string
     default     = "eastus"
     description = "Location of the resource group."
   }
   
   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 "node_count" {
     type        = number
     description = "The initial quantity of nodes for the node pool."
     default     = 3
   }
   
   variable "msi_id" {
     type        = string
     description = "The Managed Service Identity ID. Set this value if you're running this example using Managed Identity as the authentication method."
     default     = null
   }
   
   variable "username" {
     type        = string
     description = "The admin username for the new cluster."
     default     = "azureadmin"
   }
   

6. Creare un file denominato outputs.tf e inserire il codice seguente:

   output "resource_group_name" {
     value = azurerm_resource_group.rg.name
   }
   
   output "kubernetes_cluster_name" {
     value = azurerm_kubernetes_cluster.k8s.name
   }
   
   output "client_certificate" {
     value     = azurerm_kubernetes_cluster.k8s.kube_config[0].client_certificate
     sensitive = true
   }
   
   output "client_key" {
     value     = azurerm_kubernetes_cluster.k8s.kube_config[0].client_key
     sensitive = true
   }
   
   output "cluster_ca_certificate" {
     value     = azurerm_kubernetes_cluster.k8s.kube_config[0].cluster_ca_certificate
     sensitive = true
   }
   
   output "cluster_password" {
     value     = azurerm_kubernetes_cluster.k8s.kube_config[0].password
     sensitive = true
   }
   
   output "cluster_username" {
     value     = azurerm_kubernetes_cluster.k8s.kube_config[0].username
     sensitive = true
   }
   
   output "host" {
     value     = azurerm_kubernetes_cluster.k8s.kube_config[0].host
     sensitive = true
   }
   
   output "kube_config" {
     value     = azurerm_kubernetes_cluster.k8s.kube_config_raw
     sensitive = true
   }
   

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.

Creare un piano di esecuzione Terraform

Eseguire terraform plan per creare un piano di esecuzione.

terraform plan -out main.tfplan

Punti principali:

• Il comando terraform plan consente di creare un piano di esecuzione, ma non di eseguirlo. 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 -out facoltativo consente di specificare un file di output per il piano. L'uso del parametro -out garantisce che il piano esaminato sia esattamente quello che viene applicato.

Applicare un piano di esecuzione Terraform

Eseguire 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.

Verificare i risultati

1. Ottenere il nome del gruppo di risorse di Azure usando il comando seguente.

   resource_group_name=$(terraform output -raw resource_group_name)
   

2. Visualizzare il nome del nuovo cluster Kubernetes usando il comando az aks list.

   az aks list \
     --resource-group $resource_group_name \
     --query "[].{\"K8s cluster name\":name}" \
     --output table
   

3. Ottenere la configurazione di Kubernetes dallo stato Terraform e archiviarla in un file che kubectl può leggere usando il comando seguente.

   echo "$(terraform output kube_config)" > ./azurek8s
   

4. Verificare che il comando precedente non abbia aggiunto un carattere EOT ASCII usando il comando seguente.

   cat ./azurek8s
   

   Punti principali:

   • Se viene visualizzato << EOT all'inizio e EOT alla fine, rimuovere questi caratteri dal file. In caso contrario, è possibile che venga visualizzato il messaggio di errore seguente: error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context

5. Impostare una variabile di ambiente in modo che kubectl possa selezionare la configurazione corretta usando il comando seguente.

   export KUBECONFIG=./azurek8s
   

6. Verificare l'integrità del cluster usando il comando kubectl get nodes.

   kubectl get nodes
   

Punti principali:

• Quando è stato creato il cluster del servizio Azure Kubernetes, il monitoraggio è stato abilitato per acquisire le metriche di integrità sia per i nodi del cluster che per i pod. Queste metriche di integrità sono disponibili nel portale di Azure. Per altre informazioni sul monitoraggio dell'integrità dei contenitori, vedere Monitorare l'integrità del servizio Azure Kubernetes.
• Diversi valori chiave classificati come output quando è stato applicato il piano di esecuzione Terraform. Ad esempio, l'indirizzo host, il nome utente del cluster del servizio Azure Kubernetes e la password del cluster del servizio Azure Kubernetes vengono restituiti.

Distribuire l'applicazione

Per distribuire l'applicazione, usare un file manifesto per creare tutti gli oggetti necessari per eseguire l'applicazione di Archiviazione del servizio Azure Kubernetes. Un file manifesto Kubernetes definisce lo stato desiderato di un cluster, ad esempio le immagini del contenitore da eseguire. Il manifesto include le distribuzioni e i servizi Kubernetes seguenti:

• Front-store: applicazione Web per i clienti per visualizzare i prodotti ed effettuare ordini.
• Servizio prodotto: mostra le informazioni sul prodotto.
• Servizio ordini: effettua ordini.
• Rabbit MQ: coda di messaggi per una coda di ordini.

1. Creare un file denominato aks-store-quickstart.yaml e copiarlo nel manifesto seguente:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: rabbitmq
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: rabbitmq
     template:
       metadata:
         labels:
           app: rabbitmq
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: rabbitmq
           image: mcr.microsoft.com/mirror/docker/library/rabbitmq:3.10-management-alpine
           ports:
           - containerPort: 5672
             name: rabbitmq-amqp
           - containerPort: 15672
             name: rabbitmq-http
           env:
           - name: RABBITMQ_DEFAULT_USER
             value: "username"
           - name: RABBITMQ_DEFAULT_PASS
             value: "password"
           resources:
             requests:
               cpu: 10m
               memory: 128Mi
             limits:
               cpu: 250m
               memory: 256Mi
           volumeMounts:
           - name: rabbitmq-enabled-plugins
             mountPath: /etc/rabbitmq/enabled_plugins
             subPath: enabled_plugins
         volumes:
         - name: rabbitmq-enabled-plugins
           configMap:
             name: rabbitmq-enabled-plugins
             items:
             - key: rabbitmq_enabled_plugins
               path: enabled_plugins
   ---
   apiVersion: v1
   data:
     rabbitmq_enabled_plugins: |
       [rabbitmq_management,rabbitmq_prometheus,rabbitmq_amqp1_0].
   kind: ConfigMap
   metadata:
     name: rabbitmq-enabled-plugins            
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: rabbitmq
   spec:
     selector:
       app: rabbitmq
     ports:
       - name: rabbitmq-amqp
         port: 5672
         targetPort: 5672
       - name: rabbitmq-http
         port: 15672
         targetPort: 15672
     type: ClusterIP
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: order-service
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: order-service
     template:
       metadata:
         labels:
           app: order-service
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: order-service
           image: ghcr.io/azure-samples/aks-store-demo/order-service:latest
           ports:
           - containerPort: 3000
           env:
           - name: ORDER_QUEUE_HOSTNAME
             value: "rabbitmq"
           - name: ORDER_QUEUE_PORT
             value: "5672"
           - name: ORDER_QUEUE_USERNAME
             value: "username"
           - name: ORDER_QUEUE_PASSWORD
             value: "password"
           - name: ORDER_QUEUE_NAME
             value: "orders"
           - name: FASTIFY_ADDRESS
             value: "0.0.0.0"
           resources:
             requests:
               cpu: 1m
               memory: 50Mi
             limits:
               cpu: 75m
               memory: 128Mi
         initContainers:
         - name: wait-for-rabbitmq
           image: busybox
           command: ['sh', '-c', 'until nc -zv rabbitmq 5672; do echo waiting for rabbitmq; sleep 2; done;']
           resources:
             requests:
               cpu: 1m
               memory: 50Mi
             limits:
               cpu: 75m
               memory: 128Mi    
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: order-service
   spec:
     type: ClusterIP
     ports:
     - name: http
       port: 3000
       targetPort: 3000
     selector:
       app: order-service
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: product-service
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: product-service
     template:
       metadata:
         labels:
           app: product-service
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: product-service
           image: ghcr.io/azure-samples/aks-store-demo/product-service:latest
           ports:
           - containerPort: 3002
           resources:
             requests:
               cpu: 1m
               memory: 1Mi
             limits:
               cpu: 1m
               memory: 7Mi
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: product-service
   spec:
     type: ClusterIP
     ports:
     - name: http
       port: 3002
       targetPort: 3002
     selector:
       app: product-service
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: store-front
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: store-front
     template:
       metadata:
         labels:
           app: store-front
       spec:
         nodeSelector:
           "kubernetes.io/os": linux
         containers:
         - name: store-front
           image: ghcr.io/azure-samples/aks-store-demo/store-front:latest
           ports:
           - containerPort: 8080
             name: store-front
           env: 
           - name: VUE_APP_ORDER_SERVICE_URL
             value: "http://order-service:3000/"
           - name: VUE_APP_PRODUCT_SERVICE_URL
             value: "http://product-service:3002/"
           resources:
             requests:
               cpu: 1m
               memory: 200Mi
             limits:
               cpu: 1000m
               memory: 512Mi
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: store-front
   spec:
     ports:
     - port: 80
       targetPort: 8080
     selector:
       app: store-front
     type: LoadBalancer
   

   Per un dettaglio dei file manifesto YAML, vedere Distribuzioni e manifesti YAML.

   Se si crea e si salva il file YAML in locale, è possibile caricare il file manifesto nella directory predefinita in CloudShell selezionando il pulsante Carica/Scarica file e selezionando il file dal file system locale.

2. Distribuire l'applicazione usando il comando kubectl apply e specificare il nome del manifesto YAML.

   kubectl apply -f aks-store-quickstart.yaml
   

   L'output di esempio seguente mostra le distribuzioni e i servizi:

   deployment.apps/rabbitmq created
   service/rabbitmq created
   deployment.apps/order-service created
   service/order-service created
   deployment.apps/product-service created
   service/product-service created
   deployment.apps/store-front created
   service/store-front created
   

Testare l'applicazione

Quando l'applicazione viene eseguita, un servizio Kubernetes espone il front-end dell'applicazione a Internet. Questo processo può richiedere alcuni minuti.

1. Controllare lo stato dei pod distribuiti usando il comando kubectl get pods. Fare in modo che tutti i pod siano Running prima di procedere.

   kubectl get pods
   

2. Verificare la presenza di un indirizzo IP pubblico per l'applicazione front-store. Monitorare lo stato di avanzamento usando il comando kubectl get service con l'argomento --watch.

   kubectl get service store-front --watch
   

   L'output EXTERNAL-IP per il servizio store-front inizialmente viene visualizzato come in sospeso:

   NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
   store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m
   

3. Quando l'indirizzo EXTERNAL-IP passa da in sospeso a un effettivo indirizzo IP pubblico, usare CTRL-C per arrestare il processo di controllo kubectl.

   L'output di esempio seguente mostra un indirizzo IP pubblico valido assegnato al servizio:

   NAME          TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)        AGE
   store-front   LoadBalancer   10.0.100.10   20.62.159.19   80:30025/TCP   4h5m
   

4. Aprire un Web browser all'indirizzo IP esterno del servizio per visualizzare l'app di Azure Store in azione.

   

Pulire le risorse

Eliminare le risorse del servizio Azure Kubernetes

Quando le risorse create tramite Terraform non sono più necessarie, seguire questa procedura:

1. Eseguire terraform plan e specificare il flag destroy.

   terraform plan -destroy -out main.destroy.tfplan
   

   Punti principali:

   • Il comando terraform plan consente di creare un piano di esecuzione, ma non di eseguirlo. 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 -out facoltativo consente di specificare un file di output per il piano. L'uso del parametro -out garantisce che il piano esaminato sia esattamente quello che viene applicato.

2. Eseguire terraform apply per applicare il piano di esecuzione.

   terraform apply main.destroy.tfplan
   

Eliminare l'entità servizio

1. Ottenere l'ID entità servizio usando il comando seguente.

   sp=$(terraform output -raw sp)
   

2. Eliminare l'entità servizio usando il comando az ad sp delete.

   az ad sp delete --id $sp
   

• Installare Azure Developer CLI (AZD)
• Installa e configura Terraform.
• È possibile rivedere il codice dell'applicazione usato in Azure-Samples/aks-store-demo repo.

Clonare il modello di Azure Developer CLI

Azure Developer CLI consente di scaricare rapidamente esempi dal repository Azure-Samples. In avvio rapido, si scarica l'applicazione aks-store-demo. Per altre informazioni sui casi d'uso generali, vedere la panoramica di azd.

1. Clonare il modello demo dell'archivio del servizio Azure Kubernetes dal repository Azure-Samples usando il comando azd init con il parametro --template.

   azd init --template Azure-Samples/aks-store-demo
   

2. Immettere un nome ambiente per il progetto, che deve usare solo caratteri alfanumerici e trattini, ad esempio aks-terraform-1.

   Enter a new environment name: aks-terraform-1
   

Accedere all'account Cloud di Azure

Il modello azd contiene tutto il codice necessario per creare i servizi, ma per ospitare l'applicazione nel servizio Azure Kubernetes è necessario accedere all'account Azure.

1. Accedere all'account usando il comando azd auth login.

   azd auth login
   

2. Copiare il codice del dispositivo visualizzato nell'output e premere INVIO per accedere.

   Start by copying the next code: XXXXXXXXX
   Then press enter and continue to log in from your browser...
   

   Importante

   Se si usa una macchina virtuale fuori rete o GitHub codespace, alcuni criteri di sicurezza di Azure, quando vengono usati per accedere con azd auth login, causano conflitti. Se si verifica un problema qui, è possibile seguire la soluzione alternativa azd auth fornita. Questa implica l'uso di una richiesta curl all'URL localhost a cui si è stati reindirizzati dopo l'esecuzione di azd auth login.

3. Eseguire l'autenticazione con le credenziali nella pagina di accesso dell'organizzazione.

4. Confermare che si stia provando a connettersi all'interfaccia della riga di comando di Azure.

5. Verificare il messaggio “Autenticazione del codice del dispositivo completata. Connesso ad Azure.” viene visualizzato nel terminale originale.

   Waiting for you to complete authentication in the browser...
   Device code authentication completed.
   Logged in to Azure.
   

Soluzione alternativa azd auth

Questa soluzione alternativa richiede l'installazione dell'interfaccia della riga di comando di Azure.

1. Aprire una finestra del terminale e accedere con l'interfaccia della riga di comando di Azure usando il comando az login con il parametro --scope impostato su https://graph.microsoft.com/.default.

   az login --scope https://graph.microsoft.com/.default
   

   Si dovrebbe essere reindirizzati a una pagina di autenticazione in una nuova scheda per creare un token di accesso al browser, come nell'esempio seguente:

   https://login.microsoftonline.com/organizations/oauth2/v2.0/authorize?clientid=<your_client_id>.
   

2. Copiare l'URL localhost della pagina Web ricevuta dopo il tentativo di accesso con azd auth login.

3. In una nuova finestra del terminale usare la seguente richiesta curl per accedere. Assicurarsi di sostituire il segnaposto <localhost> con l'URL localhost copiato nel passaggio precedente.

   curl <localhost>
   

   Un account di accesso riuscito restituisce una pagina Web HTML, come nell'esempio seguente:

   <!DOCTYPE html>
   <html>
   <head>
       <meta charset="utf-8" />
       <meta http-equiv="refresh" content="60;url=https://docs.microsoft.com/cli/azure/">
       <title>Login successfully</title>
       <style>
           body {
               font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
           }
   
           code {
               font-family: Consolas, 'Liberation Mono', Menlo, Courier, monospace;
               display: inline-block;
               background-color: rgb(242, 242, 242);
               padding: 12px 16px;
               margin: 8px 0px;
           }
       </style>
   </head>
   <body>
       <h3>You have logged into Microsoft Azure!</h3>
       <p>You can close this window, or we will redirect you to the <a href="https://docs.microsoft.com/cli/azure/">Azure CLI documentation</a> in 1 minute.</p>
       <h3>Announcements</h3>
       <p>[Windows only] Azure CLI is collecting feedback on using the <a href="https://learn.microsoft.com/windows/uwp/security/web-account-manager">Web Account Manager</a> (WAM) broker for the login experience.</p>
       <p>You may opt-in to use WAM by running the following commands:</p>
       <code>
           az config set core.allow_broker=true<br>
           az account clear<br>
           az login
       </code>
   </body>
   </html>
   

4. Chiudere il terminale corrente e aprire il terminale originale. Verrà visualizzato un elenco JSON delle sottoscrizioni.

5. Copiare il campo id della sottoscrizione da usare.

6. Impostare la sottoscrizione usando il comando az account set.

   az account set --subscription <subscription_id>
   

Creare e distribuire le risorse per il cluster

Per distribuire l'applicazione, usare il comando azd up per creare tutti gli oggetti necessari per eseguire l'applicazione di archiviazione del servizio Azure Kubernetes.

• Un file azure.yaml definisce lo stato desiderato di un cluster, ad esempio quali sono le immagini del contenitore da recuperare. Inoltre include le distribuzioni e i servizi Kubernetes seguenti:

• Front-store: applicazione Web per i clienti per visualizzare i prodotti ed effettuare ordini.
• Servizio prodotto: mostra le informazioni sul prodotto.
• Servizio ordini: effettua ordini.
• Rabbit MQ: coda di messaggi per una coda di ordini.

Distribuire le risorse dell'applicazione

Il modello azd per questo avvio rapido crea un nuovo gruppo di risorse con un cluster del servizio Azure Kubernetes e Azure Key Vault. L'insieme di credenziali delle chiavi archivia i segreti client ed esegue i servizi nello spazio dei nomi pets.

1. Creare tutte le risorse dell'applicazione usando il comando azd up.

   azd up
   

   azd up esegue tutti gli hook all'interno della azd-hooks cartella per pre-registrare, effettuare il provisioning e distribuire i servizi dell'applicazione.

   Personalizzare gli hook per aggiungere codice personalizzato nelle fasi del flusso di lavoro azd. Per altre informazioni, vedere le informazioni di riferimento azd sugli hook.

2. Selezionare una sottoscrizione di Azure per l'utilizzo della fatturazione.

   ? Select an Azure Subscription to use:  [Use arrows to move, type to filter]
   > 1. My Azure Subscription (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
   

3. Selezionare un'area in cui distribuire l'applicazione.

   Select an Azure location to use:  [Use arrows to move, type to filter]
     1.  (South America) Brazil Southeast (brazilsoutheast)
     2.  (US) Central US (centralus)
     3.  (US) East US (eastus)
   > 43. (US) East US 2 (eastus2)
     4.  (US) East US STG (eastusstg)
     5.  (US) North Central US (northcentralus)
     6.  (US) South Central US (southcentralus)
   

   azd esegue automaticamente gli hook di preprovisioning e postprovisioning per creare le risorse per l'applicazione. Questo processo può richiedere alcuni minuti. Al termine, sarà visualizzato un output simile all'esempio seguente:

   SUCCESS: Your workflow to provision and deploy to Azure completed in 9 minutes 40 seconds.
   

Generare i piani Terraform

All'interno del modello di Azure Developer, la cartella /infra/terraform contiene tutto il codice usato per generare il piano Terraform.

Terraform distribuisce ed esegue comandi usando terraform apply come parte del passaggio di provisioning di azd. Al termine, sarà visualizzato un output simile all'esempio seguente:

Plan: 5 to add, 0 to change, 0 to destroy.
...
Saved the plan to: /workspaces/aks-store-demo/.azure/aks-terraform-azd/infra/terraform/main.tfplan

Testare l'applicazione

Quando l'applicazione viene eseguita, un servizio Kubernetes espone il front-end dell'applicazione a Internet. Questo processo può richiedere alcuni minuti.

1. Impostare lo spazio dei nomi come spazio dei nomi demo pets usando il comando kubectl set-context.

   kubectl config set-context --current --namespace=pets
   

2. Controllare lo stato dei pod distribuiti usando il comando kubectl get pods. Fare in modo che tutti i pod siano Running prima di procedere.

   kubectl get pods
   

3. Verificare la presenza di un indirizzo IP pubblico per l'applicazione vetrina e monitorare lo stato di avanzamento usando il kubectl get service comando con l'argomento --watch.

   kubectl get service store-front --watch
   

   L'output EXTERNAL-IP per il servizio store-front inizialmente viene visualizzato come in sospeso:

   NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
   store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m
   

4. Quando l’indirizzo EXTERNAL-IP passa da in sospeso a un effettivo indirizzo IP pubblico, usare CTRL-C per arrestare il processo di controllo kubectl.

   L'output di esempio seguente mostra un indirizzo IP pubblico valido assegnato al servizio:

   NAME          TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)        AGE
   store-front   LoadBalancer   10.0.100.10   20.62.159.19   80:30025/TCP   4h5m
   

5. Aprire un browser web all'indirizzo IP esterno del servizio per visualizzare l'applicazione di Azure Store in azione.

   

Eliminare il cluster

Al termine dell'avvio rapido, eseguire la pulizia delle risorse non necessarie per evitare addebiti di Azure.

1. Usando il comando azd down, eliminare tutte le risorse create in avvio rapido.

   azd down
   

2. Confermare la decisione di rimuovere tutte le risorse usate dalla sottoscrizione digitando y e premendo Enter.

   ? Total resources to delete: 14, are you sure you want to continue? (y/N)
   

3. Consentire di rimuovere definitivamente per riutilizzare le variabili di avvio rapido, se applicabile, digitando y e premendo Enter.

   [Warning]: These resources have soft delete enabled allowing them to be recovered for a period or time after deletion. During this period, their names can't be reused. In the future, you can use the argument --purge to skip this confirmation.