Condividi tramite

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

  • Articolo

Il servizio Azure Kubernetes è un servizio Kubernetes gestito che permette di distribuire e gestire rapidamente i cluster. Questa guida introduttiva spiega come:

  • Distribuire un cluster del servizio Azure Kubernetes usando Terraform.
  • Eseguire un'applicazione multi-contenitore di esempio con un gruppo di microservizi e front-end Web simulando uno scenario di vendita al dettaglio.

Nota

Per iniziare ad effettuare un veloce provisioning di un cluster del servizio Azure Kubernetes, questo articolo include i passaggi per la distribuzione di un cluster con impostazioni predefinite a solo scopo di valutazione. Prima di distribuire un cluster pronto per la produzione, è consigliabile acquisire familiarità con l'architettura di riferimento di base per valutare il modo in cui è allineato ai requisiti aziendali.

Operazioni preliminari

Nota

Il pool di nodi Linux di Azure è ora disponibile a livello generale (GA). Per informazioni sui vantaggi e sui passaggi di distribuzione, vedere Introduzione all'host contenitore Linux di Azure per il servizio Azure Kubernetes.

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

Nota

Il codice di esempio per questo articolo si trova nel repository GitHub di Azure Terraform. È possibile visualizzare il file di log contenente i risultati del test delle versioni correnti e precedenti di Terraform.

Vedere altri articoli e codice di esempio che illustrano come usare Terraform per gestire le risorse di Azure

  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:

Screenshot dell'architettura di esempio di Azure Store.

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

Nota

Non è consigliabile eseguire contenitori con stato, ad esempio Rabbit MQ, senza l'archiviazione permanente per la produzione. Questi vengono usati qui per semplicità, ma è consigliabile usare servizi gestiti, ad esempio Azure CosmosDB o il bus di servizio di Azure.

  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.

    Screenshot dell'applicazione di esempio dello Store del servizio Azure Kubernetes.

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

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:

Diagramma che mostra l'architettura di esempio di Microsoft Azure Store.

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

Nota

Non è consigliabile eseguire contenitori con stato, ad esempio Rabbit MQ, senza l'archiviazione permanente per la produzione. Questi vengono usati qui per semplicità, ma è consigliabile usare servizi gestiti, ad esempio Azure Cosmos DB o il bus di servizio di Azure.

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.

    Screenshot dell'applicazione di esempio dello Store del servizio Azure Kubernetes.

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.

Risolvere i problemi di Terraform in Azure

Risolvere i problemi comuni relativi all'uso di Terraform in Azure.

Passaggi successivi

In questa guida introduttiva, è stato distribuito un cluster Kubernetes, successivamente è stata distribuita una semplice applicazione multi-contenitore. Questa applicazione di esempio è solo a scopo dimostrativo e non rappresenta tutte le procedure consigliate per le applicazioni Kubernetes. Per indicazioni sulla creazione di soluzioni complete con il servizio Azure Kubernetes per la produzione, vedere Linee guida per le soluzioni del servizio Azure Kubernetes.

Per altre informazioni sul servizio Azure Container e l'analisi del codice completo per un esempio di distribuzione, passare all'esercitazione sul cluster Kubernetes.

Altre informazioni sull'uso del servizio Azure Kubernetes.