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 iniziale per valutare se è in linea con i requisiti aziendali.

Operazioni preliminari

Nota

Il pool di nodi Linux di Azure è ora disponibile a livello generale. 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.

Scenari di autenticazione di Terraform e Azure

Terraform supporta solo l'autenticazione in Azure tramite 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 usando l'interfaccia della riga di comando di Azure.

Questo articolo illustra come autenticare Terraform in Azure per gli scenari seguenti. Per altre informazioni sulle opzioni per autenticare Terraform in Azure, vedere Autenticazione tramite l'interfaccia della riga di comando di Azure.

Eseguire l'autenticazione in Azure tramite un account Microsoft

Un account Microsoft è un nome utente (associato a un messaggio di posta elettronica e alle relative credenziali) usato per accedere ai servizi Microsoft, ad esempio Azure. Un account Microsoft può essere associato a una o più sottoscrizioni di Azure, con una di queste sottoscrizioni predefinite.

I passaggi seguenti illustrano come:

  • Accedere ad Azure in modo interattivo usando un account Microsoft
  • Elencare le sottoscrizioni di Azure associate dell'account (incluso il valore predefinito)
  • Impostare la sottoscrizione corrente.

  1. Aprire una riga di comando che abbia accesso all'interfaccia della riga di comando di Azure.

  2. Eseguire az login senza parametri e seguire le istruzioni per accedere ad Azure.

    az login

    Punti principali:

    • Al termine dell'accesso, az login visualizza un elenco delle sottoscrizioni di Azure associate all'account Microsoft connesso, inclusa la sottoscrizione predefinita.

  3. Per confermare la sottoscrizione di Azure corrente, eseguire az account show.

    az account show

  4. Per visualizzare tutti i nomi e gli ID delle sottoscrizioni di Azure per un account Microsoft specifico, eseguire az account list.

    az account list --query "[?user.name=='<microsoft_account_email>'].{Name:name, ID:id, Default:isDefault}" --output Table

    Punti principali:

    • Sostituire il segnaposto <microsoft_account_email> con l'indirizzo di posta elettronica dell'account Microsoft di cui si desidera elencare le sottoscrizioni di Azure.
    • Con un account live, ad esempio Hotmail o Outlook, potrebbe essere necessario specificare l'indirizzo di posta elettronica completo. Ad esempio, se l'indirizzo di posta elettronica è admin@hotmail.com, potrebbe essere necessario sostituire il segnaposto con live.com#admin@hotmail.com.

  5. Per usare una sottoscrizione di Azure specifica, eseguire az account set.

    az account set --subscription "<subscription_id_or_subscription_name>"

    Punti principali:

    • Sostituire il segnaposto <subscription_id_or_subscription_name> con l'ID o il nome della sottoscrizione che si vuole usare.
    • La chiamata a az account set non visualizza i risultati del passaggio alla sottoscrizione di Azure specificata. È però possibile usare az account show per confermare che la sottoscrizione di Azure corrente è cambiata.
    • Se si esegue il comando az account list del passaggio precedente, si noterà che la sottoscrizione di Azure predefinita è stata modificata nella sottoscrizione specificata con az account set.

Creare un'entità servizio

Gli strumenti automatici che distribuiscono o usano servizi di Azure, come Terraform, devono sempre avere autorizzazioni limitate. Anziché avere applicazioni che accedono come utente con privilegi completi, Azure fornisce entità servizio.

Il modello più comune consiste nell'accedere in modo interattivo ad Azure, creare un'entità servizio, testare l'entità servizio e quindi usare tale entità servizio per l'autenticazione futura (in modo interattivo o dagli script).

  1. Per creare un'entità servizio, accedere ad Azure. Dopo l'autenticazione in Azure tramite un account Microsoft, tornare qui.

  2. Se si crea un'entità servizio da Git Bash, impostare la variabile di ambiente MSYS_NO_PATHCONV. Questo passaggio non è necessario se si usa Cloud Shell.

    export MSYS_NO_PATHCONV=1

    Punti principali:

    • È possibile impostare la variabile di ambiente MSYS_NO_PATHCONV a livello globale (per tutte le sessioni del terminale) o localmente (solo per la sessione corrente). Poiché la creazione di un'entità servizio non è un'operazione eseguita spesso, l'esempio imposta il valore per la sessione corrente. Per impostare questa variabile di ambiente a livello globale, aggiungere l'impostazione al file di ~/.bashrc.

  3. Per creare un'entità servizio, eseguire az ad sp create-for-rbac.

    az ad sp create-for-rbac --name <service_principal_name> --role Contributor --scopes /subscriptions/<subscription_id>

    Punti principali:

    • È possibile sostituire <service-principal-name> con un nome personalizzato per l'ambiente o omettere completamente il parametro. Se si omette il parametro, il nome dell'entità servizio viene generato in base alla data e all'ora correnti.
    • Al termine, az ad sp create-for-rbac visualizza diversi valori. I valori appId, password e tenant vengono usati nel passaggio successivo.
    • Se viene persa, questa password non può essere recuperata. Di conseguenza, è consigliabile archiviarla in un luogo sicuro. Se si dimentica la password, è possibile reimpostare le credenziali dell'entità servizio.
    • Per questo articolo viene usata un'entità servizio con un ruolo collaboratore. Per altre informazioni sui ruoli controllo degli accessi in base al ruolo, vedere controllo degli accessi in base al ruolo: ruoli predefiniti.
    • L'output della creazione dell'entità servizio include credenziali riservate. Assicurarsi di non includere queste credenziali nel codice o di controllare le credenziali nel controllo del codice sorgente.
    • Per altre informazioni sulle opzioni per la creazione di un'entità servizio con l'interfaccia della riga di comando di Azure, vedere l'articolo Creare un'entità servizio di Azure con l'interfaccia della riga di comando di Azure.

Specificare le credenziali dell'entità servizio nelle variabili di ambiente

Dopo aver creato un'entità servizio, è possibile specificarne le credenziali in Terraform tramite variabili di ambiente.

  1. Modificare il file ~/.bashrc aggiungendo le variabili di ambiente seguenti.

    export ARM_SUBSCRIPTION_ID="<azure_subscription_id>"
export ARM_TENANT_ID="<azure_subscription_tenant_id>"
export ARM_CLIENT_ID="<service_principal_appid>"
export ARM_CLIENT_SECRET="<service_principal_password>"

  2. Per eseguire lo script di ~/.bashrc, eseguire source ~/.bashrc (o il relativo . ~/.bashrc equivalente abbreviato). È anche possibile uscire e riaprire Cloud Shell perché lo script venga eseguito automaticamente.

    . ~/.bashrc

  3. Dopo aver impostato le variabili di ambiente, è possibile verificarne i valori nel modo seguente:

    printenv | grep ^ARM*

Punti principali:

  • Come per qualsiasi variabile di ambiente, per accedere a un valore di sottoscrizione di Azure dall'interno di uno script Terraform, usare la sintassi seguente: ${env.<environment_variable>}. Ad esempio, per accedere al valore di ARM_SUBSCRIPTION_ID, specificare ${env.ARM_SUBSCRIPTION_ID}.
  • La creazione e l'applicazione di piani di esecuzione terraform apporta modifiche alla sottoscrizione di Azure associata all'entità servizio. Questo fatto può talvolta generare confusione se si è connessi a una sottoscrizione di Azure e le variabili di ambiente puntano a una seconda sottoscrizione di Azure. Esaminiamo l'esempio seguente per spiegarlo. Si supponga di avere due sottoscrizioni di Azure: SubA e SubB. Se la sottoscrizione di Azure corrente è SubA (determinata tramite az account show) mentre le variabili di ambiente puntano a SubB, tutte le modifiche apportate da Terraform si trovano in SubB. È quindi necessario accedere alla sottoscrizione SubB per eseguire i comandi dell'interfaccia della riga di comando di Azure o i comandi di Azure PowerShell per visualizzare le modifiche.

Specificare le credenziali dell'entità servizio in un blocco di provider Terraform

Il blocco del provider di Azure definisce la sintassi che consente di specificare le informazioni di autenticazione della sottoscrizione di Azure.

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

provider "azurerm" {
  features {}

  subscription_id   = "<azure_subscription_id>"
  tenant_id         = "<azure_subscription_tenant_id>"
  client_id         = "<service_principal_appid>"
  client_secret     = "<service_principal_password>"
}

# Your code goes here

Attenzione

La possibilità di specificare le credenziali della sottoscrizione di Azure in un file di configurazione terraform può essere utile, soprattutto durante i test. Tuttavia, non è consigliabile archiviare le credenziali in un file di testo non crittografato che può essere visualizzato da utenti non attendibili.

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 = jsondecode(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 = jsondecode(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 di file diverso per il parametro -out, usare lo stesso nome di 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 persistente 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 una suddivisione 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 il piano Terraform 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 dell'interfaccia della riga di comando per sviluppatori di Azure

L'interfaccia della riga di comando per sviluppatori di Azure consente di scaricare rapidamente esempi dal repository Azure-Samples . Nella guida introduttiva si scarica l'applicazione aks-store-demo . Per altre informazioni sui casi d'uso generali, vedere la azd panoramica.

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

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

  2. Immettere un nome di ambiente per il progetto che usa 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 azd modello contiene tutto il codice necessario per creare i servizi, ma è necessario accedere all'account Azure per ospitare l'applicazione nel servizio Azure Kubernetes.

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

    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 causano conflitti quando vengono usati per accedere con azd auth login. Se si verifica un problema qui, è possibile seguire la soluzione alternativa azd auth fornita, che implica l'uso di una curl richiesta all'URL localhost a cui si è stati reindirizzati dopo l'esecuzione azd auth logindi .

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

  4. Verificare che si stia provando a connettersi dall'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.

azd auth workaround

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 az login comando con il --scope parametro impostato su https://graph.microsoft.com/.default.

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

    È necessario essere reindirizzati a una pagina di autenticazione in una nuova scheda per creare un token di accesso al browser, come illustrato 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 richiesta seguente curl per accedere. Assicurarsi di sostituire il <localhost> segnaposto con l'URL localhost copiato nel passaggio precedente.

    curl <localhost>

    Un account di accesso riuscito restituisce una pagina Web HTML, come illustrato 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 id campo della sottoscrizione da usare.

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

    az account set --subscription <subscription_id>

Creare e distribuire risorse per il cluster

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

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

Diagramma che mostra l'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 persistente per la produzione. Questi vengono usati qui per semplicità, ma è consigliabile usare servizi gestiti, ad esempio Azure Cosmos DB o bus di servizio di Azure.

Distribuire le risorse dell'applicazione

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

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

    azd up

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

    Personalizzare gli hook per aggiungere codice personalizzato nelle fasi del azd flusso di lavoro. Per altre informazioni, vedere le azd informazioni di riferimento 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, verrà visualizzato un output simile all'esempio seguente:

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

Generare piani Terraform

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

Terraform distribuisce ed esegue comandi usando terraform apply come parte del azdpassaggio di provisioning. Al termine, verrà 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 pets demo usando il kubectl set-context comando .

    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 front-store 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, pulire le risorse non necessarie per evitare addebiti di Azure.

  1. Eliminare tutte le risorse create nella guida introduttiva usando il azd down comando .

    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 l'eliminazione 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 questo avvio rapido è stato distribuito un cluster Kubernetes ed è stata quindi 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 la soluzione 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.