Rychlý start: Nasazení clusteru Azure Kubernetes Service (AKS) pomocí Terraformu

  • Článek

Azure Kubernetes Service (AKS) je spravovaná služba Kubernetes, která umožňuje rychle nasazovat a spravovat clustery. V tomto rychlém startu:

  • Nasaďte cluster AKS pomocí Terraformu.
  • Spusťte ukázkovou vícekontenerovou aplikaci se skupinou mikroslužeb a webových front-endů simulujících scénář maloobchodního prodeje.

Poznámka:

Pokud chcete začít rychle zřizovat cluster AKS, najdete v tomto článku postup nasazení clusteru s výchozím nastavením pouze pro účely vyhodnocení. Před nasazením clusteru připraveného pro produkční prostředí doporučujeme seznámit se s naší referenční architekturou podle směrného plánu a zvážit, jak je v souladu s vašimi obchodními požadavky.

Než začnete

Poznámka:

Fond uzlů Azure s Linuxem je teď obecně dostupný (GA). Další informace o výhodách a postupu nasazení najdete v tématu Úvod do služby Azure Linux Container Host for AKS.

Přihlaste se ke svému účtu Azure.

Nejprve se přihlaste ke svému účtu Azure a ověřte se pomocí jedné z metod popsaných v následující části.

Scénáře ověřování Terraformu a Azure

Terraform podporuje ověřování pouze v Azure prostřednictvím Azure CLI. Ověřování pomocí Azure PowerShellu se nepodporuje. Modul Azure PowerShellu proto můžete použít při práci Terraformu, musíte se nejdřív ověřit v Azure pomocí Azure CLI.

Tento článek vysvětluje, jak ověřit Terraform v Azure pro následující scénáře. Další informace o možnostech ověřování Terraformu v Azure najdete v tématu Ověřování pomocí Azure CLI.

Ověřování v Azure pomocí účtu Microsoft

Účet Microsoft je uživatelské jméno (přidružené k e-mailu a jeho přihlašovacím údajům), které slouží k přihlášení k služby Microsoft , jako je Azure. Účet Microsoft může být přidružený k jednomu nebo několika předplatným Azure, přičemž jedno z těchto předplatných je výchozí.

Následující kroky ukazují, jak:

  • Interaktivní přihlášení k Azure pomocí účtu Microsoft
  • Výpis přidružených předplatných Azure účtu (včetně výchozího)
  • Nastavte aktuální předplatné.

  1. Otevřete příkazový řádek, který má přístup k Azure CLI.

  2. Spusťte az login bez jakýchkoli parametrů a postupujte podle pokynů pro přihlášení k Azure.

    az login

    Klíčové body:

    • Po úspěšném přihlášení az login se zobrazí seznam předplatných Azure přidružených k přihlášeným účtům Microsoft, včetně výchozího předplatného.

  3. Pokud chcete potvrdit aktuální předplatné Azure, spusťte příkaz az account show.

    az account show

  4. Pokud chcete zobrazit všechny názvy a ID předplatných Azure pro konkrétní účet Microsoft, spusťte příkaz az account list.

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

    Klíčové body:

    • <microsoft_account_email> Zástupný symbol nahraďte e-mailovou adresou účtu Microsoft, jejíž předplatná Azure chcete vypsat.
    • U účtu Live , jako je hotmail nebo Outlook, možná budete muset zadat plně kvalifikovanou e-mailovou adresu. Pokud je admin@hotmail.comnapříklad vaše e-mailová adresa , možná budete muset zástupný symbol nahradit znakem live.com#admin@hotmail.com.

  5. Pokud chcete použít konkrétní předplatné Azure, spusťte příkaz az account set.

    az account set --subscription "<subscription_id_or_subscription_name>"

    Klíčové body:

    • <subscription_id_or_subscription_name> Zástupný symbol nahraďte ID nebo názvem předplatného, které chcete použít.
    • Volání az account set nezobrazuje výsledky přechodu na zadané předplatné Azure. Můžete ale použít az account show k potvrzení, že se aktuální předplatné Azure změnilo.
    • Pokud spustíte az account list příkaz z předchozího kroku, uvidíte, že se výchozí předplatné Azure změnilo na předplatné, které az account setjste zadali .

Vytvoření instančního objektu služby

Automatizované nástroje, které nasazují nebo používají služby Azure , jako je Terraform, by měly mít vždy omezená oprávnění. Místo toho, aby se aplikace přihlašovaly jako plně privilegovaný uživatel, Azure nabízí instanční objekty.

Nejběžnějším vzorem je interaktivní přihlášení k Azure, vytvoření instančního objektu, otestování instančního objektu a následné použití instančního objektu pro budoucí ověřování (interaktivně nebo z vašich skriptů).

  1. Pokud chcete vytvořit instanční objekt, přihlaste se k Azure. Po ověření v Azure prostřednictvím účtu Microsoft se sem vraťte.

  2. Pokud vytváříte instanční objekt z Git Bash, nastavte proměnnou MSYS_NO_PATHCONV prostředí. (Tento krok není nutný, pokud používáte Cloud Shell.)

    export MSYS_NO_PATHCONV=1

    Klíčové body:

    • Proměnnou MSYS_NO_PATHCONV prostředí můžete nastavit globálně (pro všechny terminálové relace) nebo místně (pouze pro aktuální relaci). Vzhledem k tomu, že vytvoření instančního objektu není něco, co často děláte, ukázka nastaví hodnotu pro aktuální relaci. Pokud chcete tuto proměnnou prostředí nastavit globálně, přidejte toto nastavení do ~/.bashrc souboru.

  3. Pokud chcete vytvořit instanční objekt, spusťte příkaz az ad sp create-for-rbac.

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

    Klíčové body:

    • Parametr můžete nahradit <service-principal-name> vlastním názvem vašeho prostředí nebo ho úplně vynechat. Pokud parametr vynecháte, vygeneruje se hlavní název služby na základě aktuálního data a času.
    • Po úspěšném dokončení se az ad sp create-for-rbac zobrazí několik hodnot. Hodnoty appIda tenant hodnoty passwordse používají v dalším kroku.
    • Heslo nelze načíst, pokud dojde ke ztrátě. Heslo byste proto měli uložit na bezpečném místě. Pokud heslo zapomenete, můžete resetovat přihlašovací údaje instančního objektu.
    • V tomto článku se používá instanční objekt s rolí Přispěvatel . Další informace o rolích řízení přístupu na základě role (RBAC) najdete v tématu RBAC: Předdefinované role.
    • Výstup z vytvoření instančního objektu zahrnuje citlivé přihlašovací údaje. Ujistěte se, že tyto přihlašovací údaje nezahrnete do kódu, nebo zkontrolujte přihlašovací údaje do správy zdrojového kódu.
    • Další informace o možnostech při vytváření instančního objektu pomocí Azure CLI najdete v článku Vytvoření instančního objektu Azure pomocí Azure CLI.

Zadání přihlašovacích údajů instančního objektu v proměnných prostředí

Po vytvoření instančního objektu můžete zadat jeho přihlašovací údaje k Terraformu prostřednictvím proměnných prostředí.

  1. ~/.bashrc Upravte soubor přidáním následujících proměnných prostředí.

    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. Pokud chcete spustit ~/.bashrc skript, spusťte source ~/.bashrc (nebo jeho zkrácený ekvivalent . ~/.bashrc). Můžete také ukončit a znovu otevřít Cloud Shell, aby se skript spustil automaticky.

    . ~/.bashrc

  3. Po nastavení proměnných prostředí můžete jejich hodnoty ověřit následujícím způsobem:

    printenv | grep ^ARM*

Klíčové body:

  • Stejně jako u jakékoli proměnné prostředí použijte pro přístup k hodnotě předplatného Azure z skriptu Terraformu následující syntaxi: ${env.<environment_variable>} Pokud například chcete získat přístup k hodnotě ARM_SUBSCRIPTION_ID , zadejte ${env.ARM_SUBSCRIPTION_ID}.
  • Vytvoření a použití plánů provádění Terraformu provádí změny v předplatném Azure přidruženém k instančnímu objektu. Tento fakt může být někdy matoucí, pokud jste přihlášení k jednomu předplatnému Azure a proměnné prostředí odkazují na druhé předplatné Azure. Podívejme se na následující příklad, který vysvětlujeme. Řekněme, že máte dvě předplatná Azure: SubA a SubB. Pokud je aktuální předplatné Azure SubA (určeno prostřednictvím az account show), zatímco proměnné prostředí odkazují na SubB, všechny změny provedené Terraformem jsou v SubB. Proto byste se museli přihlásit ke svému předplatnému SubB, abyste mohli zobrazit změny spuštěním příkazů Azure CLI nebo příkazů Azure PowerShellu.

Zadání přihlašovacích údajů instančního objektu v bloku zprostředkovatele Terraformu

Blok zprostředkovatele Azure definuje syntaxi, která umožňuje zadat ověřovací informace vašeho předplatného 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

Upozornění

Možnost zadat přihlašovací údaje předplatného Azure v konfiguračním souboru Terraformu může být praktická – zejména při testování. Nedoporučuje se ale ukládat přihlašovací údaje do prostého textového souboru, který můžou zobrazit nevěrní jednotlivci.

Implementace kódu Terraformu

Poznámka:

Vzorový kód pro tento článek se nachází v úložišti GitHubu Azure Terraformu. Můžete zobrazit soubor protokolu obsahující výsledky testu z aktuálních a předchozích verzí Terraformu.

Další články a ukázkový kód ukazující použití Terraformu ke správě prostředků Azure

  1. Vytvořte adresář, pomocí něhož můžete otestovat ukázkový kód Terraformu a nastavit ho jako aktuální adresář.

  2. Vytvořte soubor s názvem providers.tf a vložte následující kód:

    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. Vytvořte soubor s názvem ssh.tf a vložte následující kód:

    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. Vytvořte soubor s názvem main.tf a vložte následující kód:

    # 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. Vytvořte soubor s názvem variables.tf a vložte následující kód:

    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. Vytvořte soubor s názvem outputs.tf a vložte následující kód:

    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
}

Inicializace Terraformu

Spuštěním inicializace nasazení Terraformu spusťte inicializaci terraformu. Tento příkaz stáhne poskytovatele Azure potřebného ke správě prostředků Azure.

terraform init -upgrade

Klíčové body:

  • Parametr -upgrade upgraduje potřebné moduly plug-in zprostředkovatele na nejnovější verzi, která splňuje omezení verzí konfigurace.

Vytvoření plánu provádění Terraformu

Spuštěním plánu terraformu vytvořte plán provádění.

terraform plan -out main.tfplan

Klíčové body:

  • Příkaz terraform plan vytvoří plán provádění, ale nespustí ho. Místo toho určuje, jaké akce jsou nezbytné k vytvoření konfigurace zadané v konfiguračních souborech. Tento model umožňuje ověřit, jestli plán provádění odpovídá vašim očekáváním, než provede jakékoli změny skutečných prostředků.
  • Volitelný -out parametr umožňuje zadat výstupní soubor pro plán. Použití parametru -out zajišťuje, že plán, který jste zkontrolovali, je přesně to, co se použije.

Použití plánu provádění Terraformu

Spuštění terraformu platí pro použití plánu provádění na cloudovou infrastrukturu.

terraform apply main.tfplan

Klíčové body:

  • terraform apply Ukázkový příkaz předpokládá, že jste dříve spustili terraform plan -out main.tfplan.
  • Pokud jste pro -out parametr zadali jiný název souboru, použijte stejný název souboru při volání terraform apply.
  • Pokud jste parametr nepoužíli -out , zavolejte terraform apply bez parametrů.

Ověření výsledků

  1. Pomocí následujícího příkazu získejte název skupiny prostředků Azure.

    resource_group_name=$(terraform output -raw resource_group_name)

  2. Pomocí příkazu az aks list zobrazte název nového clusteru Kubernetes.

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

  3. Získejte konfiguraci Kubernetes ze stavu Terraformu a uložte ji do souboru, který kubectl může číst pomocí následujícího příkazu.

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

  4. Pomocí následujícího příkazu ověřte, že předchozí příkaz nepřidal znak ASCII EOT.

    cat ./azurek8s

    Klíčové body:

    • Pokud se zobrazí << EOT na začátku a EOT na konci, odeberte tyto znaky ze souboru. V opačném případě se může zobrazit následující chybová zpráva: error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context

  5. Nastavte proměnnou prostředí, aby kubectl bylo možné získat správnou konfiguraci pomocí následujícího příkazu.

    export KUBECONFIG=./azurek8s

  6. Pomocí příkazu ověřte stav clusteru kubectl get nodes .

    kubectl get nodes

Klíčové body:

  • Při vytváření clusteru AKS bylo monitorování povoleno zachytávat metriky stavu pro uzly clusteru i pody. Tyto metriky stavu jsou k dispozici na webu Azure Portal. Další informace o monitorování stavu clusteru najdete v tématu Monitorování stavu služby Azure Kubernetes Service.
  • Několik klíčových hodnot klasifikovaných jako výstup při použití plánu provádění Terraformu. Výstupem je například adresa hostitele, uživatelské jméno clusteru AKS a heslo clusteru AKS.

Nasazení aplikace

K nasazení aplikace použijete soubor manifestu k vytvoření všech objektů potřebných ke spuštění aplikace AKS Store. Soubor manifestu Kubernetes definuje požadovaný stav clusteru, například které image kontejneru se mají spustit. Manifest zahrnuje následující nasazení a služby Kubernetes:

Snímek obrazovky s ukázkovou architekturou Azure Storu

  • Store front: Webová aplikace pro zákazníky k zobrazení produktů a objednávání.
  • Produktová služba: Zobrazuje informace o produktu.
  • Objednávka: Objednávky.
  • Rabbit MQ: Fronta zpráv pro frontu objednávek.

Poznámka:

Nedoporučujeme spouštět stavové kontejnery, jako je Rabbit MQ, bez trvalého úložiště pro produkční prostředí. Tady se používají pro zjednodušení, ale doporučujeme používat spravované služby, jako je Azure CosmosDB nebo Azure Service Bus.

  1. Vytvořte soubor s názvem aks-store-quickstart.yaml a zkopírujte ho v následujícím manifestu:

    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

    Rozpis souborů manifestu YAML najdete v tématu Nasazení a manifesty YAML.

    Pokud soubor YAML vytvoříte a uložíte místně, můžete soubor manifestu nahrát do výchozího adresáře v CloudShellu tak , že vyberete tlačítko Nahrát/Stáhnout soubory a vyberete soubor z místního systému souborů.

  2. Nasaďte aplikaci pomocí kubectl apply příkazu a zadejte název manifestu YAML.

    kubectl apply -f aks-store-quickstart.yaml

    Následující příklad výstupu ukazuje nasazení a služby:

    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

Testování aplikace

Když se aplikace spustí, služba Kubernetes zveřejní front-end aplikace na internetu. Dokončení tohoto procesu může trvat několik minut.

  1. Pomocí příkazu zkontrolujte stav nasazených podů kubectl get pods . Než budete pokračovat, udělejte všechny pody Running .

    kubectl get pods

  2. Zkontrolujte veřejnou IP adresu pro aplikaci store-front. Sledujte průběh pomocí kubectl get service příkazu s argumentem --watch .

    kubectl get service store-front --watch

    Výstup EXTERNAL-IP pro store-front službu se zpočátku zobrazuje jako čekající:

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

  3. Jakmile se externí IP adresa změní z čekání na skutečnou kubectl veřejnou IP adresu, použijte CTRL-C k zastavení procesu sledování.

    Následující příklad výstupu ukazuje platnou veřejnou IP adresu přiřazenou službě:

    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. Otevřete webový prohlížeč na externí IP adresu vaší služby, abyste viděli aplikaci Azure Store v akci.

    Snímek obrazovky ukázkové aplikace AKS Store

Vyčištění prostředků

Odstranění prostředků AKS

Pokud už prostředky vytvořené přes Terraform nepotřebujete, proveďte následující kroky:

  1. Spusťte plán terraformu destroy a zadejte příznak.

    terraform plan -destroy -out main.destroy.tfplan

    Klíčové body:

    • Příkaz terraform plan vytvoří plán provádění, ale nespustí ho. Místo toho určuje, jaké akce jsou nezbytné k vytvoření konfigurace zadané v konfiguračních souborech. Tento model umožňuje ověřit, jestli plán provádění odpovídá vašim očekáváním, než provede jakékoli změny skutečných prostředků.
    • Volitelný -out parametr umožňuje zadat výstupní soubor pro plán. Použití parametru -out zajišťuje, že plán, který jste zkontrolovali, je přesně to, co se použije.

  2. Spuštění terraformu platí pro použití plánu provádění.

    terraform apply main.destroy.tfplan

Odstranění instančního objektu

  1. Pomocí následujícího příkazu získejte ID instančního objektu.

    sp=$(terraform output -raw sp)

  2. Pomocí příkazu az ad sp delete odstraňte instanční objekt.

    az ad sp delete --id $sp

Klonování šablony Azure Developer CLI

Azure Developer CLI umožňuje rychle stahovat ukázky z úložiště Azure-Samples . V našem rychlém startu aks-store-demo si stáhnete aplikaci. Další informace o obecných případech použití najdete v přehleduazd.

  1. Naklonujte ukázkovou šablonu úložiště AKS z úložiště Azure-Samples pomocí azd init příkazu s parametrem --template .

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

  2. Zadejte název prostředí pro váš projekt, který používá pouze alfanumerické znaky a spojovníky, například aks-terraform-1.

    Enter a new environment name: aks-terraform-1

Přihlaste se ke svému účtu Azure Cloud.

Šablona azd obsahuje veškerý kód potřebný k vytvoření služeb, ale abyste mohli hostovat aplikaci v AKS, musíte se přihlásit ke svému účtu Azure.

  1. Přihlaste se ke svému účtu pomocí azd auth login příkazu.

    azd auth login

  2. Zkopírujte kód zařízení, který se zobrazí ve výstupu, a stisknutím klávesy Enter se přihlaste.

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

    Důležité

    Pokud používáte virtuální počítač mimo síť nebo GitHub Codespace, některé zásady zabezpečení Azure způsobují konflikty při přihlašování pomocí azd auth login. Pokud zde narazíte na problém, můžete postupovat podle zadaného alternativního řešení ověřování azd, které zahrnuje použití curl požadavku na adresu URL místního hostitele, na kterou jste byli přesměrováni po spuštění azd auth login.

  3. Ověřte se pomocí svých přihlašovacích údajů na přihlašovací stránce vaší organizace.

  4. Ověřte, že se pokoušíte připojit z Azure CLI.

  5. Ověřte zprávu "Ověření kódu zařízení bylo dokončeno. Přihlášení k Azure." se zobrazí v původním terminálu.

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

Alternativní řešení ověřování azd

Toto alternativní řešení vyžaduje, abyste měli nainstalované Rozhraní příkazového řádku Azure.

  1. Otevřete okno terminálu a přihlaste se pomocí Azure CLI pomocí az login příkazu s parametrem nastaveným --scope na https://graph.microsoft.com/.default.

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

    Pokud chcete vytvořit přístupový token prohlížeče, měli byste být přesměrováni na ověřovací stránku na nové kartě, jak je znázorněno v následujícím příkladu:

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

  2. Zkopírujte adresu URL místního hostitele webové stránky, kterou jste dostali po pokusu o přihlášení .azd auth login

  3. V novém okně terminálu se přihlaste pomocí následujícího curl požadavku. Nezapomeňte zástupný symbol nahradit <localhost> adresou URL místního hostitele, kterou jste zkopírovali v předchozím kroku.

    curl <localhost>

    Úspěšné přihlášení vypíše webovou stránku HTML, jak je znázorněno v následujícím příkladu:

    <!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. Zavřete aktuální terminál a otevřete původní terminál. Měl by se zobrazit seznam JSON vašich předplatných.

  5. id Zkopírujte pole předplatného, které chcete použít.

  6. Nastavte své předplatné pomocí az account set příkazu.

    az account set --subscription <subscription_id>

Vytvoření a nasazení prostředků pro cluster

K nasazení aplikace použijete azd up příkaz k vytvoření všech objektů potřebných ke spuštění aplikace AKS Store.

  • Soubor azure.yaml definuje požadovaný stav clusteru, například které image kontejneru se mají načíst, a zahrnuje následující nasazení a služby Kubernetes:

Diagram znázorňující ukázkovou architekturu Azure Store

  • Store front: Webová aplikace pro zákazníky k zobrazení produktů a objednávání.
  • Produktová služba: Zobrazuje informace o produktu.
  • Objednávka: Objednávky.
  • Rabbit MQ: Fronta zpráv pro frontu objednávek.

Poznámka:

Nedoporučujeme spouštět stavové kontejnery, jako je Rabbit MQ, bez trvalého úložiště pro produkční prostředí. Tady se používají pro zjednodušení, ale doporučujeme používat spravované služby, jako je Azure Cosmos DB nebo Azure Service Bus.

Nasazení prostředků aplikace

Šablona azd pro tento rychlý start vytvoří novou skupinu prostředků s clusterem AKS a službou Azure Key Vault. Trezor klíčů ukládá tajné kódy klienta a spouští služby v pets oboru názvů.

  1. Pomocí příkazu vytvořte všechny prostředky azd up aplikace.

    azd up

    azd up spustí všechna připojení v rámci azd-hooks složky k předběžné registraci, zřízení a nasazení aplikačních služeb.

    Přizpůsobte háky pro přidání vlastního azd kódu do fází pracovního postupu. Další informace najdete v referenčních informacích o azd hácích .

  2. Vyberte předplatné Azure pro využití fakturace.

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

  3. Vyberte oblast, do které chcete aplikaci nasadit.

    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 automaticky spustí předvizi a poprovision hooky, aby se vytvořily prostředky pro vaši aplikaci. Dokončení tohoto procesu může trvat několik minut. Po dokončení by se měl zobrazit výstup podobný následujícímu příkladu:

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

Generování plánů Terraformu

V šabloně /infra/terraform Azure Developer obsahuje složka veškerý kód použitý k vygenerování plánu Terraformu.

Terraform nasazuje a spouští příkazy v terraform apply rámci azdkroku zřizování. Po dokončení by se měl zobrazit výstup podobný následujícímu příkladu:

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

Testování aplikace

Když se aplikace spustí, služba Kubernetes zveřejní front-end aplikace na internetu. Dokončení tohoto procesu může trvat několik minut.

  1. Nastavte obor názvů jako ukázkový obor názvů pets pomocí kubectl set-context příkazu.

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

  2. Pomocí příkazu zkontrolujte stav nasazených podů kubectl get pods . Než budete pokračovat, ujistěte se, že jsou Running všechny pody.

    kubectl get pods

  3. Pomocí příkazu --watch s argumentem zkontrolujte veřejnou IP adresu pro aplikaci store-front a sledujte průběhkubectl get service.

    kubectl get service store-front --watch

    Výstup EXTERNAL-IP pro store-front službu se zpočátku zobrazuje jako čekající:

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

  4. Jakmile se externí IP adresa změní z čekání na skutečnou kubectl veřejnou IP adresu, použijte CTRL-C k zastavení procesu sledování.

    Následující ukázkový výstup ukazuje platnou veřejnou IP adresu přiřazenou službě:

    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. Otevřete webový prohlížeč na externí IP adresu vaší služby, abyste viděli aplikaci Azure Store v akci.

    Snímek obrazovky ukázkové aplikace AKS Store

Odstranění clusteru

Po dokončení tohoto rychlého startu vyčistěte nepotřebné prostředky, abyste se vyhnuli poplatkům za Azure.

  1. Pomocí příkazu odstraňte všechny prostředky vytvořené v rychlém startu azd down .

    azd down

  2. Potvrďte své rozhodnutí odebrat všechny použité prostředky z předplatného zadáním y a stisknutím klávesy Enter.

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

  3. Pokud je to možné, povolte vyprázdnění opakovaně používat proměnné rychlého startu zadáním y a stisknutím klávesy 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.

Řešení potíží s Terraformem v Azure

Řešení běžných problémů při používání Terraformu v Azure

Další kroky

V tomto rychlém startu jste nasadili cluster Kubernetes a pak jste do něj nasadili jednoduchou vícekontenerovou aplikaci. Tato ukázková aplikace slouží jenom pro ukázkové účely a nepředstavuje všechny osvědčené postupy pro aplikace Kubernetes. Pokyny k vytváření úplných řešení pomocí AKS pro produkční prostředí najdete v pokynech k řešení AKS.

Pokud chcete získat další informace o AKS a projít si kompletní příklad nasazení kódu na nasazení, pokračujte kurzem clusteru Kubernetes.

Přečtěte si další informace o používání AKS.