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

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

• 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

• Tento rychlý start předpokládá základní znalosti konceptů Kubernetes. Další informace najdete v tématu Základní koncepty Kubernetes pro Službu Azure Kubernetes Service (AKS).
• Potřebujete účet Azure s aktivním předplatným. Pokud ho nemáte, vytvořte si účet zdarma.
• Postupujte podle pokynů rozhraní příkazového řádku.

• Další informace o vytvoření fondu uzlů Windows Serveru najdete v tématu Vytvoření clusteru AKS, který podporuje kontejnery Windows Serveru.

Důležité

Od 30. listopadu 2025 už AKS nebude podporovat ani poskytovat aktualizace zabezpečení pro Azure Linux 2.0. Od 31. března 2026 se image uzlů odeberou a nebudete moct škálovat fondy uzlů. Migrujte na podporovanou verzi Azure Linuxu buď aktualizací fondů uzlů na podporovanou verzi Kubernetes, nebo migrací na osSku AzureLinux3. Další informace najdete v tématu [Vyřazení z provozu] Uzel poolů Azure Linux 2.0 v AKS.

• Nainstalujte a konfigurujte Terraform.
• Stáhněte si kubectl.
• Vytvořte náhodnou hodnotu pro název skupiny prostředků Azure pomocí random_pet.
• Vytvořte skupinu prostředků Azure pomocí azurerm_resource_group.
• Přejděte ke konfiguraci poskytovatele AzureRM a získejte ID objektu Azure pomocí azurerm_client_config.
• Vytvořte cluster Kubernetes pomocí azurerm_kubernetes_cluster.
• Vytvořte prostředek azapi_resource AzAPI.
• Vytvořte prostředek AzAPI pro vygenerování páru klíčů SSH pomocí azapi_resource_action.

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.

Terraform podporuje ověřování pouze v Azure pomocí Azure CLI. Ověřování pomocí Azure PowerShellu se nepodporuje. Modul Azure PowerShell můžete proto použít při práci s Terraformem, ale musíte se nejprve ověřit v Azure.

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 = 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 = 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
   }
   

Inicializujte Terraform

Spusťte terraform init k inicializaci nasazení 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 k zachycení metrik stavu pro uzly i pody clusteru. 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:

• Store front: Webová aplikace pro zákazníky k zobrazení produktů a objednávání.
• Produktová služba: Zobrazuje informace o produktu.
• Objednávková služba: Zajišťuje zadávání objednávek.
• 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 . Ujistěte se, že všechny pody jsou Running , než budete pokračovat.

   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 CTRL-C veřejnou IP adresu, použijte kubectl 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.

   

Uvolnění zdrojů

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 terraform plan a zadejte příznak destroy.

   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. Spusťte terraform apply pro aplikaci plánu provádění.

   terraform apply main.destroy.tfplan
   

Odstranit službu principal

1. Pomocí následujícího příkazu získejte ID služebního principálu.

   sp=$(terraform output -raw sp)
   

2. Pomocí příkazu az ad sp delete odstraňte principál služby.

   az ad sp delete --id $sp
   

• Nainstalujte Azure Developer CLI (AZD)
• Nainstalujte a konfigurujte Terraform.
• Kód aplikace použitý v úložišti Azure-Samples/aks-store-demo si můžete prohlédnout.

Klonování šablony Azure Developer CLI

Azure Developer CLI umožňuje rychle stahovat ukázky z úložiště Azure-Samples . V naší příručce pro rychlý start si stáhnete aplikaci aks-store-demo. 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

Tento postup vyžaduje, abyste měli nainstalované Azure CLI.

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
   

   Měli byste být přesměrováni na ověřovací stránku na nové kartě, abyste si vytvořili přístupový token prohlížeče, 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řte a nasaďte prostředky pro svůj 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:

• Store front: Webová aplikace pro zákazníky k zobrazení produktů a objednávání.
• Produktová služba: Zobrazuje informace o produktu.
• Objednávková služba: Zajišťuje zadávání objednávek.
• 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 azd up vytvořte všechny prostředky aplikace.

   azd up
   

   azd up spustí všechny hooky uvnitř složky azd-hooks pro předběžnou 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

Složka ve vaší šabloně Azure Developer obsahuje veškerý kód použitý k vygenerování plánu Terraformu.

Terraform nasazuje a spouští příkazy pomocí terraform apply jako součást kroku zřizování azd. 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 použitím příkazu kubectl set-context.

   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. Zkontrolujte veřejnou IP adresu pro aplikaci store-front pomocí příkazu kubectl get service s argumentem a sledujte průběh pomocí --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
   

4. Jakmile se externí IP adresa změní z čekání na skutečnou CTRL-C veřejnou IP adresu, použijte kubectl 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.

   

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. Umožněte opětovné použití proměnných rychlého startu při vyprázdnění 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 od kódu po nasazení, pokračujte tutoriálem o clusteru Kubernetes.

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