Udostępnij za pośrednictwem


Szybki start: wdrażanie klastra usługi Azure Kubernetes Service (AKS) przy użyciu narzędzia Terraform

Azure Kubernetes Service (AKS) to zarządzana usługa platformy Kubernetes, która umożliwia szybkie wdrażanie klastrów i zarządzanie nimi. W ramach tego przewodnika Szybki start wykonasz następujące czynności:

  • Wdrażanie klastra usługi AKS przy użyciu narzędzia Terraform.
  • Uruchom przykładową aplikację z wieloma kontenerami z grupą mikrousług i frontonów internetowych symulujących scenariusz sprzedaży detalicznej.

Uwaga

Aby rozpocząć szybkie aprowizowanie klastra usługi AKS, ten artykuł zawiera kroki wdrażania klastra z ustawieniami domyślnymi tylko do celów ewaluacyjnych. Przed wdrożeniem klastra gotowego do produkcji zalecamy zapoznanie się z naszą architekturą referencyjną punktu odniesienia, aby wziąć pod uwagę, jak jest ona zgodna z wymaganiami biznesowymi.

Zanim rozpoczniesz

  • W tym przewodniku Szybki start założono, że masz podstawową wiedzę na temat pojęć związanych z rozwiązaniem Kubernetes. Aby uzyskać więcej informacji, zobacz temat Kubernetes core concepts for Azure Kubernetes Service (AKS) (Kubernetes — podstawowe pojęcia dotyczące usługi Azure Kubernetes Service (AKS)).
  • Potrzebujesz konta platformy Azure z aktywną subskrypcją. Jeśli go nie masz, utwórz bezpłatne konto.
  • Postępuj zgodnie z instrukcjami na podstawie interfejsu wiersza polecenia.

Uwaga

Pula węzłów systemu Linux platformy Azure jest teraz ogólnie dostępna. Aby dowiedzieć się więcej o korzyściach i krokach wdrażania, zobacz Wprowadzenie do hosta kontenera systemu Linux platformy Azure dla usługi AKS.

Zaloguj się do konta platformy Azure

Najpierw zaloguj się do konta platformy Azure i uwierzytelnij się przy użyciu jednej z metod opisanych w poniższej sekcji.

Narzędzie Terraform obsługuje tylko uwierzytelnianie na platformie Azure przy użyciu interfejsu wiersza polecenia platformy Azure. Uwierzytelnianie przy użyciu programu Azure PowerShell nie jest obsługiwane. W związku z tym podczas wykonywania pracy narzędzia Terraform możesz użyć modułu Azure PowerShell, ale najpierw musisz uwierzytelnić się na platformie Azure.

Implementowanie kodu narzędzia Terraform

Uwaga

Przykładowy kod tego artykułu znajduje się w repozytorium GitHub programu Azure Terraform. Możesz wyświetlić plik dziennika zawierający wyniki testu z bieżących i poprzednich wersji programu Terraform.

Zobacz więcej artykułów i przykładowego kodu pokazującego, jak zarządzać zasobami platformy Azure za pomocą narzędzia Terraform

  1. Utwórz katalog, którego można użyć do przetestowania przykładowego kodu narzędzia Terraform i utworzenia go w bieżącym katalogu.

  2. Utwórz plik o nazwie providers.tf i wstaw następujący 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. Utwórz plik o nazwie ssh.tf i wstaw następujący 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 = azapi_resource_action.ssh_public_key_gen.output.publicKey
    }
    
  4. Utwórz plik o nazwie main.tf i wstaw następujący 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 = azapi_resource_action.ssh_public_key_gen.output.publicKey
        }
      }
      network_profile {
        network_plugin    = "kubenet"
        load_balancer_sku = "standard"
      }
    }
    
  5. Utwórz plik o nazwie variables.tf i wstaw następujący 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. Utwórz plik o nazwie outputs.tf i wstaw następujący 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
    }
    

Inicjowanie narzędzia Terraform

Uruchom narzędzie terraform init , aby zainicjować wdrożenie narzędzia Terraform. To polecenie pobiera dostawcę platformy Azure wymaganego do zarządzania zasobami platformy Azure.

terraform init -upgrade

Kluczowe punkty:

  • Parametr -upgrade uaktualnia niezbędne wtyczki dostawcy do najnowszej wersji, która jest zgodna z ograniczeniami wersji konfiguracji.

Tworzenie planu wykonania programu Terraform

Uruchom plan terraform, aby utworzyć plan wykonania.

terraform plan -out main.tfplan

Kluczowe punkty:

  • Polecenie terraform plan tworzy plan wykonania, ale nie wykonuje go. Zamiast tego określa, jakie akcje są niezbędne do utworzenia konfiguracji określonej w plikach konfiguracji. Ten wzorzec umożliwia sprawdzenie, czy plan wykonania jest zgodny z oczekiwaniami przed wprowadzeniem jakichkolwiek zmian w rzeczywistych zasobach.
  • Opcjonalny -out parametr umożliwia określenie pliku wyjściowego dla planu. Użycie parametru -out gwarantuje, że sprawdzony plan jest dokładnie tym, co jest stosowane.

Stosowanie planu wykonywania narzędzia Terraform

Uruchom narzędzie terraform, aby zastosować plan wykonania do infrastruktury chmury.

terraform apply main.tfplan

Kluczowe punkty:

  • Przykładowe terraform apply polecenie zakłada, że wcześniej uruchomiono terraform plan -out main.tfplanpolecenie .
  • Jeśli określono inną nazwę pliku parametru -out , użyj tej samej nazwy pliku w wywołaniu metody terraform apply.
  • Jeśli parametr nie został użyty, wywołaj metodę -out terraform apply bez żadnych parametrów.

Weryfikowanie wyników

  1. Pobierz nazwę grupy zasobów platformy Azure przy użyciu następującego polecenia.

    resource_group_name=$(terraform output -raw resource_group_name)
    
  2. Wyświetl nazwę nowego klastra Kubernetes przy użyciu polecenia az aks list .

    az aks list \
      --resource-group $resource_group_name \
      --query "[].{\"K8s cluster name\":name}" \
      --output table
    
  3. Pobierz konfigurację platformy Kubernetes ze stanu narzędzia Terraform i zapisz ją w pliku, który kubectl można odczytać przy użyciu następującego polecenia.

    echo "$(terraform output kube_config)" > ./azurek8s
    
  4. Sprawdź, czy poprzednie polecenie nie dodało znaku EOT ASCII przy użyciu następującego polecenia.

    cat ./azurek8s
    

    Kluczowe punkty:

    • Jeśli zobaczysz << EOT na początku i EOT na końcu, usuń te znaki z pliku. W przeciwnym razie może zostać wyświetlony następujący komunikat o błędzie: error: error loading config file "./azurek8s": yaml: line 2: mapping values are not allowed in this context
  5. Ustaw zmienną środowiskową, aby kubectl można było pobrać poprawną konfigurację przy użyciu następującego polecenia.

    export KUBECONFIG=./azurek8s
    
  6. Sprawdź kondycję klastra przy użyciu kubectl get nodes polecenia .

    kubectl get nodes
    

Kluczowe punkty:

  • Po utworzeniu klastra usługi AKS włączono monitorowanie w celu przechwytywania metryk kondycji zarówno dla węzłów klastra, jak i zasobników. Te metryki kondycji są dostępne w witrynie Azure Portal. Aby uzyskać więcej informacji dotyczących monitorowania kondycji kontenera, zobacz Monitorowanie kondycji usługi Azure Kubernetes Service.
  • Kilka wartości kluczy sklasyfikowanych jako dane wyjściowe podczas stosowania planu wykonywania narzędzia Terraform. Na przykład adres hosta, nazwa użytkownika klastra usługi AKS i hasło klastra usługi AKS są danymi wyjściowymi.

Wdrażanie aplikacji

Aby wdrożyć aplikację, należy użyć pliku manifestu, aby utworzyć wszystkie obiekty wymagane do uruchomienia aplikacji sklepu AKS. Plik manifestu kubernetes definiuje żądany stan klastra, taki jak obrazy kontenerów do uruchomienia. Manifest obejmuje następujące wdrożenia i usługi Kubernetes:

Zrzut ekranu przedstawiający przykładową architekturę sklepu Azure Store.

  • Front sklepu: aplikacja internetowa dla klientów do wyświetlania produktów i składania zamówień.
  • Usługa produktu: wyświetla informacje o produkcie.
  • Usługa zamawiania: umieszcza zamówienia.
  • Rabbit MQ: kolejka komunikatów dla kolejki zamówień.

Uwaga

Nie zalecamy uruchamiania kontenerów stanowych, takich jak Rabbit MQ, bez trwałego przechowywania w środowisku produkcyjnym. Są one używane tutaj dla uproszczenia, ale zalecamy korzystanie z usług zarządzanych, takich jak Azure CosmosDB lub Azure Service Bus.

  1. Utwórz plik o nazwie aks-store-quickstart.yaml i skopiuj go w następującym manifeście:

    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
    

    Aby uzyskać podział plików manifestu YAML, zobacz Wdrożenia i manifesty YAML.

    Jeśli tworzysz i zapisujesz plik YAML lokalnie, możesz przekazać plik manifestu do katalogu domyślnego w programie CloudShell, wybierając przycisk Przekaż/Pobierz pliki i wybierając plik z lokalnego systemu plików.

  2. Wdróż aplikację przy użyciu kubectl apply polecenia i określ nazwę manifestu YAML.

    kubectl apply -f aks-store-quickstart.yaml
    

    W poniższych przykładowych danych wyjściowych przedstawiono wdrożenia i usługi:

    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
    

Testowanie aplikacji

Podczas uruchamiania aplikacji usługa Kubernetes uwidacznia fronton aplikacji w Internecie. Ten proces może potrwać kilka minut.

  1. Sprawdź stan wdrożonych zasobników przy użyciu kubectl get pods polecenia . Przed kontynuowaniem wykonaj wszystkie zasobniki Running .

    kubectl get pods
    
  2. Sprawdź publiczny adres IP aplikacji frontonu sklepu. Monitoruj postęp za pomocą kubectl get service polecenia z argumentem --watch .

    kubectl get service store-front --watch
    

    Dane wyjściowe EXTERNAL-IP dla store-front usługi początkowo są wyświetlane jako oczekujące:

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
    store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m
    
  3. Gdy adres EXTERNAL-IP zmieni się z oczekujące na rzeczywisty publiczny adres IP, użyj polecenia CTRL-C , aby zatrzymać proces obserwacjikubectl.

    Następujące przykładowe dane wyjściowe przedstawiają prawidłowy publiczny adres IP przypisany do usługi:

    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. Otwórz przeglądarkę internetową na zewnętrzny adres IP usługi, aby zobaczyć działanie aplikacji ze Sklepu Azure.

    Zrzut ekranu przedstawiający przykładową aplikację sklepu AKS Store.

Czyszczenie zasobów

Usuwanie zasobów usługi AKS

Jeśli zasoby utworzone za pomocą narzędzia Terraform nie są już potrzebne, wykonaj następujące czynności:

  1. Uruchom plan terraform i określ flagę destroy .

    terraform plan -destroy -out main.destroy.tfplan
    

    Kluczowe punkty:

    • Polecenie terraform plan tworzy plan wykonania, ale nie wykonuje go. Zamiast tego określa, jakie akcje są niezbędne do utworzenia konfiguracji określonej w plikach konfiguracji. Ten wzorzec umożliwia sprawdzenie, czy plan wykonania jest zgodny z oczekiwaniami przed wprowadzeniem jakichkolwiek zmian w rzeczywistych zasobach.
    • Opcjonalny -out parametr umożliwia określenie pliku wyjściowego dla planu. Użycie parametru -out gwarantuje, że sprawdzony plan jest dokładnie tym, co jest stosowane.
  2. Uruchom narzędzie terraform zastosuj, aby zastosować plan wykonania.

    terraform apply main.destroy.tfplan
    

Usuwanie jednostki usługi

  1. Pobierz identyfikator jednostki usługi przy użyciu następującego polecenia.

    sp=$(terraform output -raw sp)
    
  2. Usuń jednostkę usługi przy użyciu polecenia az ad sp delete .

    az ad sp delete --id $sp
    

Klonowanie szablonu interfejsu wiersza polecenia dla deweloperów platformy Azure

Interfejs wiersza polecenia dla deweloperów platformy Azure umożliwia szybkie pobieranie przykładów z repozytorium Azure-Samples . W naszym przewodniku Szybki start pobierzesz aplikację aks-store-demo . Aby uzyskać więcej informacji na temat ogólnych przypadków użycia, zobacz azd omówienie.

  1. Sklonuj szablon demonstracyjny magazynu usługi AKS z repozytorium Azure-Samples przy użyciu azd init polecenia z parametrem --template .

    azd init --template Azure-Samples/aks-store-demo
    
  2. Wprowadź nazwę środowiska dla projektu, która używa tylko znaków alfanumerycznych i łączników, takich jak aks-terraform-1.

    Enter a new environment name: aks-terraform-1
    

Zaloguj się do konta usługi Azure Cloud

Szablon azd zawiera cały kod potrzebny do utworzenia usług, ale musisz zalogować się do konta platformy Azure, aby hostować aplikację w usłudze AKS.

  1. Zaloguj się do swojego konta przy użyciu azd auth login polecenia .

    azd auth login
    
  2. Skopiuj kod urządzenia wyświetlany w danych wyjściowych i naciśnij Enter, aby się zalogować.

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

    Ważne

    Jeśli używasz maszyny wirtualnej poza siecią lub usługi GitHub Codespace, niektóre zasady zabezpieczeń platformy Azure powodują konflikty podczas logowania się przy azd auth loginużyciu usługi . Jeśli napotkasz problem w tym miejscu, możesz wykonać podane obejście uwierzytelniania azd, które obejmuje użycie curl żądania do adresu URL hosta lokalnego, do którego nastąpiło przekierowanie po uruchomieniu azd auth loginpolecenia .

  3. Uwierzytelnij się przy użyciu poświadczeń na stronie logowania organizacji.

  4. Upewnij się, że próbujesz nawiązać połączenie z poziomu interfejsu wiersza polecenia platformy Azure.

  5. Sprawdź komunikat "Ukończono uwierzytelnianie kodu urządzenia. Zalogowano się na platformie Azure. Pojawi się w oryginalnym terminalu.

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

obejście uwierzytelniania azd

To obejście wymaga zainstalowania interfejsu wiersza polecenia platformy Azure.

  1. Otwórz okno terminalu i zaloguj się przy użyciu interfejsu wiersza polecenia platformy Azure przy użyciu az login polecenia z parametrem ustawionym --scope na https://graph.microsoft.com/.default.

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

    Należy przekierować do strony uwierzytelniania na nowej karcie, aby utworzyć token dostępu przeglądarki, jak pokazano w poniższym przykładzie:

    https://login.microsoftonline.com/organizations/oauth2/v2.0/authorize?clientid=<your_client_id>.
    
  2. Skopiuj adres URL hosta lokalnego odebranej strony internetowej po próbie zalogowania się przy użyciu polecenia azd auth login.

  3. W nowym oknie terminalu użyj następującego curl żądania, aby się zalogować. Upewnij się, że symbol zastępczy został zastąpiony <localhost> adresem URL hosta lokalnego skopiowany w poprzednim kroku.

    curl <localhost>
    

    Pomyślne zalogowanie zwraca stronę internetową HTML, jak pokazano w poniższym przykładzie:

    <!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. Zamknij bieżący terminal i otwórz oryginalny terminal. Powinna zostać wyświetlona lista JSON subskrypcji.

  5. id Skopiuj pole subskrypcji, której chcesz użyć.

  6. Ustaw subskrypcję przy użyciu az account set polecenia .

    az account set --subscription <subscription_id>
    

Tworzenie i wdrażanie zasobów dla klastra

Aby wdrożyć aplikację, użyj azd up polecenia , aby utworzyć wszystkie obiekty wymagane do uruchomienia aplikacji sklepu AKS.

  • Plik azure.yaml definiuje żądany stan klastra, taki jak obrazy kontenerów do pobrania i obejmuje następujące wdrożenia i usługi Kubernetes:

Diagram przedstawiający przykładową architekturę sklepu Azure Store.

  • Front sklepu: aplikacja internetowa dla klientów do wyświetlania produktów i składania zamówień.
  • Usługa produktu: wyświetla informacje o produkcie.
  • Usługa zamawiania: umieszcza zamówienia.
  • Rabbit MQ: kolejka komunikatów dla kolejki zamówień.

Uwaga

Nie zalecamy uruchamiania kontenerów stanowych, takich jak Rabbit MQ, bez trwałego przechowywania w środowisku produkcyjnym. Są one używane tutaj dla uproszczenia, ale zalecamy korzystanie z usług zarządzanych, takich jak Azure Cosmos DB lub Azure Service Bus.

Wdrażanie zasobów aplikacji

Szablon azd dla tego przewodnika Szybki start tworzy nową grupę zasobów z klastrem usługi AKS i usługą Azure Key Vault. Magazyn kluczy przechowuje wpisy tajne klienta i uruchamia usługi w pets przestrzeni nazw.

  1. Utwórz wszystkie zasoby aplikacji przy użyciu azd up polecenia .

    azd up
    

    azd up uruchamia wszystkie haki wewnątrz azd-hooks folderu , aby wstępnie wyrejestrować, aprowizować i wdrożyć usługi aplikacji.

    Dostosowywanie punktów zaczepienia w celu dodania kodu niestandardowego azd do etapów przepływu pracy. Aby uzyskać więcej informacji, zobacz dokumentację azd punktów zaczepienia .

  2. Wybierz subskrypcję platformy Azure na potrzeby użycia rozliczeń.

    ? Select an Azure Subscription to use:  [Use arrows to move, type to filter]
    > 1. My Azure Subscription (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
    
  3. Wybierz region, w którym chcesz wdrożyć aplikację.

    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 automatycznie uruchamia wstępnie aprovision i postprovision hooks w celu utworzenia zasobów dla aplikacji. Ten proces może potrwać kilka minut. Po zakończeniu powinny zostać wyświetlone dane wyjściowe podobne do następującego przykładu:

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

Generowanie planów programu Terraform

W szablonie /infra/terraform dewelopera platformy Azure folder zawiera cały kod używany do generowania planu programu Terraform.

Narzędzie Terraform wdraża i uruchamia polecenia w terraform apply ramach azdkroku aprowizacji. Po zakończeniu powinny zostać wyświetlone dane wyjściowe podobne do następującego przykładu:

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

Testowanie aplikacji

Podczas uruchamiania aplikacji usługa Kubernetes uwidacznia fronton aplikacji w Internecie. Ten proces może potrwać kilka minut.

  1. Ustaw przestrzeń nazw jako przestrzeń nazw pets demonstracyjną kubectl set-context przy użyciu polecenia .

    kubectl config set-context --current --namespace=pets
    
  2. Sprawdź stan wdrożonych zasobników przy użyciu kubectl get pods polecenia . Przed kontynuowaniem upewnij się, że wszystkie zasobniki są Running gotowe.

    kubectl get pods
    
  3. Sprawdź publiczny adres IP aplikacji frontonu sklepu i monitoruj postęp przy użyciu kubectl get service polecenia z argumentem --watch .

    kubectl get service store-front --watch
    

    Dane wyjściowe EXTERNAL-IP dla store-front usługi początkowo są wyświetlane jako oczekujące:

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
    store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m
    
  4. Gdy adres EXTERNAL-IP zmieni się z oczekujące na rzeczywisty publiczny adres IP, użyj polecenia CTRL-C , aby zatrzymać proces obserwacjikubectl.

    Następujące przykładowe dane wyjściowe pokazują prawidłowy publiczny adres IP przypisany do usługi:

    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. Otwórz przeglądarkę internetową na zewnętrzny adres IP usługi, aby zobaczyć działanie aplikacji ze Sklepu Azure.

    Zrzut ekranu przedstawiający przykładową aplikację sklepu AKS Store.

Usuwanie klastra

Po zakończeniu pracy z przewodnikiem Szybki start wyczyść niepotrzebne zasoby, aby uniknąć opłat za platformę Azure.

  1. Usuń wszystkie zasoby utworzone w przewodniku Szybki start przy użyciu azd down polecenia .

    azd down
    
  2. Potwierdź decyzję o usunięciu wszystkich używanych zasobów z subskrypcji, wpisując y i naciskając Enter.

    ? Total resources to delete: 14, are you sure you want to continue? (y/N)
    
  3. Zezwól na ponowne użycie zmiennych szybkiego startu, jeśli ma to zastosowanie, wpisując y i naciskając 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.
    

Rozwiązywanie problemów z programem Terraform na platformie Azure

Rozwiązywanie typowych problemów podczas korzystania z programu Terraform na platformie Azure.

Następne kroki

W tym przewodniku Szybki start wdrożono klaster Kubernetes, a następnie wdrożono w nim prostą aplikację z wieloma kontenerami. Ta przykładowa aplikacja służy tylko do celów demonstracyjnych i nie reprezentuje wszystkich najlepszych rozwiązań dla aplikacji Kubernetes. Aby uzyskać wskazówki dotyczące tworzenia pełnych rozwiązań za pomocą usługi AKS dla środowiska produkcyjnego, zobacz Wskazówki dotyczące rozwiązania AKS.

Aby dowiedzieć się więcej na temat usługi AKS i zapoznać się z kompletnym przykładem kodu do wdrożenia, przejdź do samouczka dotyczącego klastra Kubernetes.