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

  • Artykuł

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.

Scenariusze uwierzytelniania programu Terraform i platformy Azure

Narzędzie Terraform obsługuje tylko uwierzytelnianie na platformie Azure za pośrednictwem 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 przy użyciu interfejsu wiersza polecenia platformy Azure.

W tym artykule wyjaśniono, jak uwierzytelnić narzędzie Terraform na platformie Azure w następujących scenariuszach. Aby uzyskać więcej informacji na temat opcji uwierzytelniania programu Terraform na platformie Azure, zobacz Uwierzytelnianie przy użyciu interfejsu wiersza polecenia platformy Azure.

Uwierzytelnianie na platformie Azure za pośrednictwem konta Microsoft

Konto Microsoft to nazwa użytkownika (skojarzona z adresem e-mail i jego poświadczeniami), która służy do logowania się do usługi firmy Microsoft — na przykład platformy Azure. Konto Microsoft może być skojarzone z co najmniej jedną subskrypcją platformy Azure, z jedną z tych subskrypcji jest domyślna.

W poniższych krokach pokazano, jak to zrobić:

  • Logowanie do platformy Azure interaktywnie przy użyciu konta Microsoft
  • Wyświetlanie listy skojarzonych subskrypcji platformy Azure konta (w tym domyślnych)
  • Ustaw bieżącą subskrypcję.

  1. Otwórz wiersz polecenia, który ma dostęp do interfejsu wiersza polecenia platformy Azure.

  2. Uruchom polecenie az login bez żadnych parametrów i postępuj zgodnie z instrukcjami, aby zalogować się do platformy Azure.

    az login

    Kluczowe punkty:

    • Po pomyślnym zalogowaniu az login zostanie wyświetlona lista subskrypcji platformy Azure skojarzonych z zalogowanym kontem Microsoft, w tym domyślną subskrypcją.

  3. Aby potwierdzić bieżącą subskrypcję platformy Azure, uruchom polecenie az account show.

    az account show

  4. Aby wyświetlić wszystkie nazwy i identyfikatory subskrypcji platformy Azure dla określonego konta Microsoft, uruchom polecenie az account list.

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

    Kluczowe punkty:

    • Zastąp <microsoft_account_email> symbol zastępczy adresem e-mail konta Microsoft, którego subskrypcje platformy Azure chcesz wyświetlić.
    • W przypadku konta na żywo — takiego jak Hotmail lub Outlook — może być konieczne określenie w pełni kwalifikowanego adresu e-mail. Jeśli na przykład adres e-mail to admin@hotmail.com, może być konieczne zastąpienie symbolu zastępczego symbolem live.com#admin@hotmail.com.

  5. Aby użyć określonej subskrypcji platformy Azure, uruchom polecenie az account set.

    az account set --subscription "<subscription_id_or_subscription_name>"

    Kluczowe punkty:

    • <subscription_id_or_subscription_name> Zastąp symbol zastępczy identyfikatorem lub nazwą subskrypcji, której chcesz użyć.
    • Wywołanie az account set nie wyświetla wyników przełączania się do określonej subskrypcji platformy Azure. Możesz jednak użyć az account show polecenia , aby potwierdzić, że bieżąca subskrypcja platformy Azure uległa zmianie.
    • Jeśli uruchomisz az account list polecenie z poprzedniego kroku, zobaczysz, że domyślna subskrypcja platformy Azure została zmieniona na subskrypcję określoną za pomocą az account setpolecenia .

Tworzenie jednostki usługi

Zautomatyzowane narzędzia do wdrażania lub używania usług platformy Azure , takich jak Terraform, powinny zawsze mieć ograniczone uprawnienia. Zamiast logowania się do aplikacji jako w pełni uprzywilejowany użytkownik, platforma Azure oferuje nazwy głównej usługi.

Najczęstszym wzorcem jest interakcyjne logowanie się do platformy Azure, tworzenie jednostki usługi, testowanie jednostki usługi, a następnie używanie tej jednostki usługi do przyszłego uwierzytelniania (interaktywnie lub ze skryptów).

  1. Aby utworzyć jednostkę usługi, zaloguj się na platformie Azure. Po uwierzytelnieniu na platformie Azure za pośrednictwem konta Microsoft wróć tutaj.

  2. Jeśli tworzysz jednostkę usługi na podstawie powłoki Git Bash, ustaw zmienną MSYS_NO_PATHCONV środowiskową. (Ten krok nie jest konieczny, jeśli używasz usługi Cloud Shell).

    export MSYS_NO_PATHCONV=1

    Kluczowe punkty:

    • Zmienną MSYS_NO_PATHCONV środowiskową można ustawić globalnie (dla wszystkich sesji terminalu) lub lokalnie (tylko dla bieżącej sesji). Ponieważ tworzenie jednostki usługi nie jest często czymś, co robisz, przykład ustawia wartość bieżącej sesji. Aby ustawić tę zmienną środowiskową globalnie, dodaj ustawienie do ~/.bashrc pliku.

  3. Aby utworzyć jednostkę usługi, uruchom polecenie az ad sp create-for-rbac.

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

    Kluczowe punkty:

    • Możesz zastąpić <service-principal-name> element nazwą niestandardową środowiska lub całkowicie pominąć parametr . Jeśli pominięto parametr, nazwa główna usługi jest generowana na podstawie bieżącej daty i godziny.
    • Po pomyślnym zakończeniu az ad sp create-for-rbac zostanie wyświetlonych kilka wartości. Wartości appId, passwordi tenant są używane w następnym kroku.
    • Nie można pobrać hasła, jeśli zostanie utracone. W związku z tym należy przechowywać hasło w bezpiecznym miejscu. Jeśli zapomnisz hasło, możesz zresetować poświadczenia jednostki usługi.
    • W tym artykule jest używana jednostka usługi z rolą Współautor . Aby uzyskać więcej informacji na temat ról kontroli dostępu opartej na rolach (RBAC), zobacz Kontrola dostępu oparta na rolach: role wbudowane.
    • Dane wyjściowe z tworzenia jednostki usługi zawierają poufne poświadczenia. Upewnij się, że nie dołączysz tych poświadczeń do kodu lub sprawdź poświadczenia w kontroli źródła.
    • Aby uzyskać więcej informacji na temat opcji tworzenia jednostki usługi przy użyciu interfejsu wiersza polecenia platformy Azure, zobacz artykuł Tworzenie jednostki usługi platformy Azure przy użyciu interfejsu wiersza polecenia platformy Azure.

Określanie poświadczeń jednostki usługi w zmiennych środowiskowych

Po utworzeniu jednostki usługi można określić jego poświadczenia w programie Terraform za pomocą zmiennych środowiskowych.

  1. Edytuj plik, ~/.bashrc dodając następujące zmienne środowiskowe.

    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. Aby wykonać ~/.bashrc skrypt, uruchom polecenie source ~/.bashrc (lub jego skrócony odpowiednik . ~/.bashrc). Możesz również zamknąć i ponownie otworzyć usługę Cloud Shell, aby skrypt był uruchamiany automatycznie.

    . ~/.bashrc

  3. Po ustawieniu zmiennych środowiskowych można zweryfikować ich wartości w następujący sposób:

    printenv | grep ^ARM*

Kluczowe punkty:

  • Podobnie jak w przypadku dowolnej zmiennej środowiskowej, aby uzyskać dostęp do wartości subskrypcji platformy Azure z poziomu skryptu programu Terraform, użyj następującej składni: ${env.<environment_variable>}. Aby na przykład uzyskać dostęp do ARM_SUBSCRIPTION_ID wartości, określ wartość ${env.ARM_SUBSCRIPTION_ID}.
  • Tworzenie i stosowanie planów wykonywania programu Terraform powoduje zmiany w subskrypcji platformy Azure skojarzonej z jednostką usługi. Ten fakt może czasami być mylący, jeśli logujesz się do jednej subskrypcji platformy Azure, a zmienne środowiskowe wskazują drugą subskrypcję platformy Azure. Przyjrzyjmy się poniższemu przykładowi, aby wyjaśnić. Załóżmy, że masz dwie subskrypcje platformy Azure: SubA i SubB. Jeśli bieżąca subskrypcja platformy Azure to SubA (określona za pośrednictwem az account show), podczas gdy zmienne środowiskowe wskazują subB, wszelkie zmiany wprowadzone przez narzędzie Terraform są w podb. W związku z tym należy zalogować się do subskrypcji SubB, aby uruchomić polecenia interfejsu wiersza polecenia platformy Azure lub polecenia programu Azure PowerShell, aby wyświetlić zmiany.

Określanie poświadczeń jednostki usługi w bloku dostawcy programu Terraform

Blok dostawcy platformy Azure definiuje składnię, która umożliwia określenie informacji o uwierzytelnianiu subskrypcji platformy 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

Uwaga

Możliwość określenia poświadczeń subskrypcji platformy Azure w pliku konfiguracji programu Terraform może być wygodna — szczególnie podczas testowania. Jednak nie zaleca się przechowywania poświadczeń w pliku zwykłego tekstu, który może być wyświetlany przez osoby nieuwierzyte.

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 = jsondecode(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 = jsondecode(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ę -outterraform 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 klawisz 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 klawisz 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 klawisz 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.

Dowiedz się więcej o korzystaniu z usługi AKS.