Snabbstart: Distribuera ett AKS-kluster (Azure Kubernetes Service) med Terraform

  • Artikel

Azure Kubernetes Service (AKS) är en hanterad Kubernetes-tjänst som gör att du snabbt kan distribuera och hantera kluster. I den här snabbstarten kommer du att göra följande:

  • Distribuera ett AKS-kluster med Terraform.
  • Kör ett exempelprogram med flera containrar med en grupp mikrotjänster och webbklientdelar som simulerar ett detaljhandelsscenario.

Kommentar

För att komma igång med att snabbt etablera ett AKS-kluster innehåller den här artikeln steg för att distribuera ett kluster med standardinställningar endast i utvärderingssyfte. Innan du distribuerar ett produktionsklart kluster rekommenderar vi att du bekantar dig med vår referensarkitektur för baslinje för att överväga hur det överensstämmer med dina affärskrav.

Innan du börjar

Kommentar

Azure Linux-nodpoolen är nu allmänt tillgänglig (GA). Mer information om fördelarna och distributionsstegen finns i Introduktion till Azure Linux Container Host for AKS.

Logga in på ditt Azure-konto

Logga först in på ditt Azure-konto och autentisera med någon av metoderna som beskrivs i följande avsnitt.

Scenarier för Terraform- och Azure-autentisering

Terraform stöder endast autentisering till Azure via Azure CLI. Autentisering med Azure PowerShell stöds inte. Även om du kan använda Azure PowerShell-modulen när du utför ditt Terraform-arbete måste du därför först autentisera till Azure med hjälp av Azure CLI.

Den här artikeln beskriver hur du autentiserar Terraform till Azure för följande scenarier. Mer information om alternativ för att autentisera Terraform till Azure finns i Autentisera med Hjälp av Azure CLI.

Autentisera till Azure via ett Microsoft-konto

Ett Microsoft-konto är ett användarnamn (associerat med ett e-postmeddelande och dess autentiseringsuppgifter) som används för att logga in på Microsoft-tjänster – till exempel Azure. Ett Microsoft-konto kan associeras med en eller flera Azure-prenumerationer, där en av dessa prenumerationer är standard.

Följande steg visar hur:

  • Logga in på Azure interaktivt med ett Microsoft-konto
  • Visa en lista över kontots associerade Azure-prenumerationer (inklusive standard)
  • Ange den aktuella prenumerationen.

  1. Öppna en kommandorad som har åtkomst till Azure CLI.

  2. Kör az login utan några parametrar och följ anvisningarna för att logga in på Azure.

    az login

    Viktiga punkter:

    • Vid lyckad inloggning az login visar en lista över De Azure-prenumerationer som är associerade med det inloggade Microsoft-kontot, inklusive standardprenumerationen.

  3. Bekräfta den aktuella Azure-prenumerationen genom att köra az account show.

    az account show

  4. Om du vill visa alla Azure-prenumerationsnamn och ID:er för ett specifikt Microsoft-konto kör du az account list.

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

    Viktiga punkter:

    • <microsoft_account_email> Ersätt platshållaren med den Microsoft-konto-e-postadress vars Azure-prenumerationer du vill visa.
    • Med ett Live-konto , till exempel en Hotmail eller Outlook, kan du behöva ange den fullständigt kvalificerade e-postadressen. Om din e-postadress till exempel är admin@hotmail.comkan du behöva ersätta platshållaren med live.com#admin@hotmail.com.

  5. Om du vill använda en specifik Azure-prenumeration kör du az account set.

    az account set --subscription "<subscription_id_or_subscription_name>"

    Viktiga punkter:

    • <subscription_id_or_subscription_name> Ersätt platshållaren med ID:t eller namnet på den prenumeration som du vill använda.
    • Samtal az account set visar inte resultatet av att växla till den angivna Azure-prenumerationen. Du kan dock använda az account show för att bekräfta att den aktuella Azure-prenumerationen har ändrats.
    • Om du kör az account list kommandot från föregående steg ser du att standardprenumerationen för Azure har ändrats till den prenumeration som du angav med az account set.

Skapa ett huvudnamn för tjänsten

Automatiserade verktyg som distribuerar eller använder Azure-tjänster , till exempel Terraform, bör alltid ha begränsade behörigheter. I stället för att låta program logga in som en fullt privilegierad användare erbjuder Azure huvudkonton för tjänsten.

Det vanligaste mönstret är att interaktivt logga in på Azure, skapa ett huvudnamn för tjänsten, testa tjänstens huvudnamn och sedan använda tjänstens huvudnamn för framtida autentisering (antingen interaktivt eller från dina skript).

  1. Logga in på Azure för att skapa ett huvudnamn för tjänsten. När du har autentiserat till Azure via ett Microsoft-konto går du tillbaka hit.

  2. Om du skapar ett huvudnamn för tjänsten från Git Bash anger du MSYS_NO_PATHCONV miljövariabeln. (Det här steget är inte nödvändigt om du använder Cloud Shell.)

    export MSYS_NO_PATHCONV=1

    Viktiga punkter:

    • Du kan ange MSYS_NO_PATHCONV miljövariabeln globalt (för alla terminalsessioner) eller lokalt (bara för den aktuella sessionen). Eftersom det inte är något du gör ofta när du skapar ett huvudnamn för tjänsten, anger exemplet värdet för den aktuella sessionen. Om du vill ange den här miljövariabeln globalt lägger du till inställningen i ~/.bashrc filen.

  3. Om du vill skapa ett huvudnamn för tjänsten kör du az ad sp create-for-rbac.

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

    Viktiga punkter:

    • Du kan ersätta <service-principal-name> med ett anpassat namn för din miljö eller utelämna parametern helt. Om du utelämnar parametern genereras tjänstens huvudnamn baserat på aktuellt datum och tid.
    • När du har slutfört az ad sp create-for-rbac det visar flera värden. Värdena appId, passwordoch tenant används i nästa steg.
    • Lösenordet kan inte hämtas om det går förlorat. Därför bör du lagra ditt lösenord på en säker plats. Om du glömmer lösenordet kan du återställa autentiseringsuppgifterna för tjänstens huvudnamn.
    • I den här artikeln används ett huvudnamn för tjänsten med rollen Deltagare . Mer information om rollbaserad åtkomstkontroll (RBAC) finns i RBAC: Inbyggda roller.
    • Utdata från att skapa tjänstens huvudnamn innehåller känsliga autentiseringsuppgifter. Se till att du inte inkluderar dessa autentiseringsuppgifter i koden eller kontrollera autentiseringsuppgifterna i källkontrollen.
    • Mer information om alternativ när du skapar ett huvudnamn för tjänsten med Azure CLI finns i artikeln Skapa ett Huvudnamn för Azure-tjänsten med Azure CLI.

Ange autentiseringsuppgifter för tjänstens huvudnamn i miljövariabler

När du har skapat ett huvudnamn för tjänsten kan du ange dess autentiseringsuppgifter för Terraform via miljövariabler.

  1. ~/.bashrc Redigera filen genom att lägga till följande miljövariabler.

    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. Kör skriptet genom att ~/.bashrc köra source ~/.bashrc (eller dess förkortade motsvarighet . ~/.bashrc). Du kan också avsluta och öppna Cloud Shell igen för att skriptet ska köras automatiskt.

    . ~/.bashrc

  3. När miljövariablerna har angetts kan du verifiera deras värden på följande sätt:

    printenv | grep ^ARM*

Viktiga punkter:

  • Precis som med alla miljövariabler använder du följande syntax för att komma åt ett Azure-prenumerationsvärde inifrån ett Terraform-skript: ${env.<environment_variable>}. Om du till exempel vill komma åt värdet ARM_SUBSCRIPTION_ID anger du ${env.ARM_SUBSCRIPTION_ID}.
  • När du skapar och tillämpar Terraform-körningsplaner ändras den Azure-prenumeration som är associerad med tjänstens huvudnamn. Det här kan ibland vara förvirrande om du är inloggad i en Azure-prenumeration och miljövariablerna pekar på en andra Azure-prenumeration. Nu ska vi titta på följande exempel för att förklara. Anta att du har två Azure-prenumerationer: SubA och SubB. Om den aktuella Azure-prenumerationen är UnderA (bestäms via az account show) medan miljövariablerna pekar på UnderB finns alla ändringar som görs av Terraform på underb. Därför skulle du behöva logga in på din underb-prenumeration för att köra Azure CLI-kommandon eller Azure PowerShell-kommandon för att visa dina ändringar.

Ange autentiseringsuppgifter för tjänstens huvudnamn i ett Terraform-providerblock

Azure-providerblocket definierar syntax som gör att du kan ange autentiseringsinformation för din Azure-prenumeration.

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

Varning

Det kan vara praktiskt att ange dina autentiseringsuppgifter för Azure-prenumerationen i en Terraform-konfigurationsfil , särskilt när du testar. Det är dock inte lämpligt att lagra autentiseringsuppgifter i en klartextfil som kan visas av icke-betrodda personer.

Implementera Terraform-koden

Kommentar

Exempelkoden för den här artikeln finns på Azure Terraform GitHub-lagringsplatsen. Du kan visa loggfilen som innehåller testresultaten från aktuella och tidigare versioner av Terraform.

Se fler artiklar och exempelkod som visar hur du använder Terraform för att hantera Azure-resurser

  1. Skapa en katalog som du kan använda för att testa Terraform-exempelkoden och göra den till din aktuella katalog.

  2. Skapa en fil med namnet providers.tf och infoga följande kod:

    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. Skapa en fil med namnet ssh.tf och infoga följande kod:

    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. Skapa en fil med namnet main.tf och infoga följande kod:

    # 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. Skapa en fil med namnet variables.tf och infoga följande kod:

    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. Skapa en fil med namnet outputs.tf och infoga följande kod:

    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
}

Initiera Terraform

Kör terraform init för att initiera Terraform-distributionen. Det här kommandot laddar ned den Azure-provider som krävs för att hantera dina Azure-resurser.

terraform init -upgrade

Viktiga punkter:

  • Parametern -upgrade uppgraderar nödvändiga provider-plugin-program till den senaste versionen som uppfyller konfigurationens versionsbegränsningar.

Skapa en Terraform-körningsplan

Kör terraform-planen för att skapa en körningsplan.

terraform plan -out main.tfplan

Viktiga punkter:

  • Kommandot terraform plan skapar en körningsplan, men kör den inte. I stället avgör den vilka åtgärder som krävs för att skapa den konfiguration som anges i konfigurationsfilerna. Med det här mönstret kan du kontrollera om körningsplanen matchar dina förväntningar innan du gör några ändringar i faktiska resurser.
  • Med den valfria -out parametern kan du ange en utdatafil för planen. Med hjälp av parametern -out ser du till att planen du granskade är exakt vad som tillämpas.

Tillämpa en Terraform-körningsplan

Kör terraform gäller för att tillämpa körningsplanen på din molninfrastruktur.

terraform apply main.tfplan

Viktiga punkter:

  • terraform apply Exempelkommandot förutsätter att du tidigare körde terraform plan -out main.tfplan.
  • Om du har angett ett annat filnamn för parametern -out använder du samma filnamn i anropet till terraform apply.
  • Om du inte använde parametern -out anropar terraform apply du utan några parametrar.

Verifiera resultatet

  1. Hämta namnet på Azure-resursgruppen med hjälp av följande kommando.

    resource_group_name=$(terraform output -raw resource_group_name)

  2. Visa namnet på ditt nya Kubernetes-kluster med kommandot az aks list .

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

  3. Hämta Kubernetes-konfigurationen från Terraform-tillståndet och lagra den i en fil som kubectl kan läsas med hjälp av följande kommando.

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

  4. Kontrollera att föregående kommando inte lade till ett ASCII EOT-tecken med hjälp av följande kommando.

    cat ./azurek8s

    Viktiga punkter:

    • Om du ser << EOT i början och EOT i slutet tar du bort dessa tecken från filen. Annars kan du få följande felmeddelande: error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context

  5. Ange en miljövariabel så kubectl att du kan hämta rätt konfiguration med hjälp av följande kommando.

    export KUBECONFIG=./azurek8s

  6. Kontrollera hälsotillståndet för klustret med hjälp av kubectl get nodes kommandot .

    kubectl get nodes

Viktiga punkter:

  • När du skapade AKS-klustret aktiverades övervakning för att samla in hälsomått för både klusternoderna och poddarna. De här hälsomåtten är tillgängliga i Azure-portalen. Mer information om övervakning av hälsotillstånd för containrar finns i Övervaka hälsotillstånd för Azure Kubernets Service.
  • Flera nyckelvärden klassificerade som utdata när du tillämpade Terraform-körningsplanen. Till exempel är värdadressen, AKS-klustrets användarnamn och AKS-klusterlösenordet utdata.

Distribuera programmet

För att distribuera programmet använder du en manifestfil för att skapa alla objekt som krävs för att köra AKS Store-programmet. En Kubernetes-manifestfil definierar ett klusters önskade tillstånd, till exempel vilka containeravbildningar som ska köras. Manifestet innehåller följande Kubernetes-distributioner och -tjänster:

Skärmbild av Azure Store-exempelarkitektur.

  • Butiksfront: Webbprogram där kunder kan visa produkter och göra beställningar.
  • Produkttjänst: Visar produktinformation.
  • Ordertjänst: Gör beställningar.
  • Rabbit MQ: Meddelandekö för en orderkö.

Kommentar

Vi rekommenderar inte att du kör tillståndskänsliga containrar, till exempel Rabbit MQ, utan beständig lagring för produktion. Dessa används här för enkelhetens skull, men vi rekommenderar att du använder hanterade tjänster, till exempel Azure CosmosDB eller Azure Service Bus.

  1. Skapa en fil med namnet aks-store-quickstart.yaml och kopiera i följande manifest:

    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

    En uppdelning av YAML-manifestfiler finns i Distributioner och YAML-manifest.

    Om du skapar och sparar YAML-filen lokalt kan du ladda upp manifestfilen till standardkatalogen i CloudShell genom att välja knappen Ladda upp/ladda ned filer och välja filen från det lokala filsystemet.

  2. Distribuera programmet med kommandot kubectl apply och ange namnet på ditt YAML-manifest.

    kubectl apply -f aks-store-quickstart.yaml

    Följande exempelutdata visar distributioner och tjänster:

    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

Testa programmet

När programmet körs så exponerar en Kubernetes-tjänst programmets klientdel mot Internet. Den här processen kan ta ett par minuter att slutföra.

  1. Kontrollera statusen för de distribuerade poddarna med kommandot kubectl get pods . Gör så att alla poddar är Running innan du fortsätter.

    kubectl get pods

  2. Sök efter en offentlig IP-adress för programmet store-front. Övervaka förloppet med kommandot kubectl get service med --watch argumentet .

    kubectl get service store-front --watch

    EXTERNA IP-utdata för store-front tjänsten visas inledningsvis som väntande:

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

  3. När DEN EXTERNA IP-adressen ändras från väntande till en faktisk offentlig IP-adress använder du CTRL-C för att stoppa kubectl bevakningsprocessen.

    Följande exempelutdata visar en giltig offentlig IP-adress som har tilldelats tjänsten:

    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. Öppna en webbläsare till tjänstens externa IP-adress för att se hur Azure Store-appen fungerar.

    Skärmbild av AKS Store-exempelprogrammet.

Rensa resurser

Ta bort AKS-resurser

Gör följande när du inte längre behöver de resurser som skapats via Terraform:

  1. Kör terraform-plan och ange destroy flaggan.

    terraform plan -destroy -out main.destroy.tfplan

    Viktiga punkter:

    • Kommandot terraform plan skapar en körningsplan, men kör den inte. I stället avgör den vilka åtgärder som krävs för att skapa den konfiguration som anges i konfigurationsfilerna. Med det här mönstret kan du kontrollera om körningsplanen matchar dina förväntningar innan du gör några ändringar i faktiska resurser.
    • Med den valfria -out parametern kan du ange en utdatafil för planen. Med hjälp av parametern -out ser du till att planen du granskade är exakt vad som tillämpas.

  2. Kör terraform tillämpa för att tillämpa körningsplanen.

    terraform apply main.destroy.tfplan

Ta bort tjänstens huvudnamn

  1. Hämta tjänstens huvudnamns-ID med hjälp av följande kommando.

    sp=$(terraform output -raw sp)

  2. Ta bort tjänstens huvudnamn med kommandot az ad sp delete .

    az ad sp delete --id $sp

Klona CLI-mallen för Azure Developer

Med Azure Developer CLI kan du snabbt ladda ned exempel från Azure-Samples-lagringsplatsen . I vår snabbstart laddar du ned programmet aks-store-demo . Mer information om de allmänna användningsfallen finns i översiktenazd.

  1. Klona AKS Store-demomallen från Azure-Samples-lagringsplatsen med hjälp av azd init kommandot med parametern --template .

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

  2. Ange ett miljönamn för projektet som endast använder alfanumeriska tecken och bindestreck, till exempel aks-terraform-1.

    Enter a new environment name: aks-terraform-1

Logga in på ditt Azure Cloud-konto

Mallen azd innehåller all kod som behövs för att skapa tjänsterna, men du måste logga in på ditt Azure-konto för att vara värd för programmet på AKS.

  1. Logga in på ditt konto med kommandot azd auth login .

    azd auth login

  2. Kopiera enhetskoden som visas i utdata och tryck på Retur för att logga in.

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

    Viktigt!

    Om du använder en virtuell dator utan nätverk eller GitHub Codespace orsakar vissa Azure-säkerhetsprinciper konflikter när de används för att logga in med azd auth login. Om du stöter på ett problem här kan du följa auth-lösningen azd som tillhandahålls, vilket innebär att du använder en curl begäran till den localhost-URL som du omdirigerades till efter att ha kört azd auth login.

  3. Autentisera med dina autentiseringsuppgifter på organisationens inloggningssida.

  4. Bekräfta att du försöker ansluta från Azure CLI.

  5. Kontrollera meddelandet "Enhetskodautentiseringen har slutförts. Inloggad i Azure." visas i den ursprungliga terminalen.

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

azd auth workaround

Den här lösningen kräver att du har Azure CLI installerat.

  1. Öppna ett terminalfönster och logga in med Azure CLI med az login kommandot med parametern --scope inställd på https://graph.microsoft.com/.default.

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

    Du bör omdirigeras till en autentiseringssida på en ny flik för att skapa en webbläsaråtkomsttoken, som du ser i följande exempel:

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

  2. Kopiera localhost-URL:en för webbsidan som du fick när du försökte logga in med azd auth login.

  3. I ett nytt terminalfönster använder du följande curl begäran för att logga in. Se till att du ersätter <localhost> platshållaren med den localhost-URL som du kopierade i föregående steg.

    curl <localhost>

    En lyckad inloggning matar ut en HTML-webbsida, som du ser i följande exempel:

    <!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. Stäng den aktuella terminalen och öppna den ursprungliga terminalen. Du bör se en JSON-lista över dina prenumerationer.

  5. Kopiera fältet för id den prenumeration som du vill använda.

  6. Ange din prenumeration med hjälp av az account set kommandot .

    az account set --subscription <subscription_id>

Skapa och distribuera resurser för klustret

Om du vill distribuera programmet använder azd up du kommandot för att skapa alla objekt som krävs för att köra AKS Store-programmet.

  • En azure.yaml fil definierar ett klusters önskade tillstånd, till exempel vilka containeravbildningar som ska hämtas och innehåller följande Kubernetes-distributioner och -tjänster:

Diagram som visar Azure Store-exempelarkitekturen.

  • Butiksfront: Webbprogram där kunder kan visa produkter och göra beställningar.
  • Produkttjänst: Visar produktinformation.
  • Ordertjänst: Gör beställningar.
  • Rabbit MQ: Meddelandekö för en orderkö.

Kommentar

Vi rekommenderar inte att du kör tillståndskänsliga containrar, till exempel Rabbit MQ, utan beständig lagring för produktion. Dessa används här för enkelhetens skull, men vi rekommenderar att du använder hanterade tjänster, till exempel Azure Cosmos DB eller Azure Service Bus.

Distribuera programresurser

Mallen azd för den här snabbstarten skapar en ny resursgrupp med ett AKS-kluster och ett Azure Key Vault. Nyckelvalvet lagrar klienthemligheter och kör tjänsterna i pets namnområdet.

  1. Skapa alla programresurser med kommandot azd up .

    azd up

    azd up kör alla krokar i azd-hooks mappen för att förregistrera, etablera och distribuera programtjänsterna.

    Anpassa krokar för att lägga till anpassad kod i arbetsflödesstegen azd . Mer information finns i referensen för azd krokar .

  2. Välj en Azure-prenumeration för din faktureringsanvändning.

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

  3. Välj en region som programmet ska distribueras till.

    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 kör automatiskt företablerings- och postprovision-krokarna för att skapa resurserna för ditt program. Den här processen kan ta ett par minuter att slutföra. När du är klar bör du se utdata som liknar följande exempel:

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

Generera Terraform-planer

I din Azure Developer-mall /infra/terraform innehåller mappen all kod som används för att generera Terraform-planen.

Terraform distribuerar och kör kommandon med hjälp terraform apply av som en del av azdetableringssteget. När du är klar bör du se utdata som liknar följande exempel:

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

Testa programmet

När programmet körs så exponerar en Kubernetes-tjänst programmets klientdel mot Internet. Den här processen kan ta ett par minuter att slutföra.

  1. Ange ditt namnområde som demonamnområdet pets med hjälp av kubectl set-context kommandot .

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

  2. Kontrollera statusen för de distribuerade poddarna med kommandot kubectl get pods . Kontrollera att alla poddar är Running innan du fortsätter.

    kubectl get pods

  3. Sök efter en offentlig IP-adress för store-front-programmet och övervaka förloppet med hjälp av kubectl get service kommandot med --watch argumentet .

    kubectl get service store-front --watch

    EXTERNA IP-utdata för store-front tjänsten visas inledningsvis som väntande:

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

  4. När DEN EXTERNA IP-adressen ändras från väntande till en faktisk offentlig IP-adress använder du CTRL-C för att stoppa kubectl bevakningsprocessen.

    Följande exempelutdata visar en giltig offentlig IP-adress som tilldelats tjänsten:

    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. Öppna en webbläsare till tjänstens externa IP-adress för att se hur Azure Store-appen fungerar.

    Skärmbild av AKS Store-exempelprogrammet.

Ta bort klustret

När du är klar med snabbstarten rensar du onödiga resurser för att undvika Azure-avgifter.

  1. Ta bort alla resurser som skapades i snabbstarten azd down med kommandot .

    azd down

  2. Bekräfta ditt beslut att ta bort alla använda resurser från din prenumeration genom att y skriva och trycka på Enter.

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

  3. Tillåt att rensning återanvänder snabbstartsvariablerna om det är tillämpligt genom att y skriva och trycka på 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.

Felsöka Terraform i Azure

Felsöka vanliga problem när du använder Terraform i Azure.

Nästa steg

I den här snabbstarten distribuerade du ett Kubernetes-kluster och distribuerade sedan ett enkelt program med flera containrar till det. Det här exempelprogrammet är endast i demosyfte och representerar inte alla metodtips för Kubernetes-program. Vägledning om hur du skapar fullständiga lösningar med AKS för produktion finns i AKS-lösningsvägledning.

Om du vill veta mer om AKS och gå igenom ett komplett exempel på kod-till-distribution fortsätter du till självstudiekursen för Kubernetes-klustret.

Läs mer om hur du använder AKS.