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

Artykuł
08/02/2024

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.

Aby dowiedzieć się więcej na temat tworzenia puli węzłów systemu Windows Server, zobacz Tworzenie klastra usługi AKS obsługującego kontenery systemu Windows Server.

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.

Zainstaluj i skonfiguruj rozwiązanie Terraform.
Pobierz plik kubectl.
Utwórz losową wartość dla nazwy grupy zasobów platformy Azure przy użyciu random_pet.
Utwórz grupę zasobów platformy Azure przy użyciu azurerm_resource_group.
Uzyskaj dostęp do konfiguracji dostawcy azureRM, aby uzyskać identyfikator obiektu platformy Azure przy użyciu azurerm_client_config.
Utwórz klaster Kubernetes przy użyciu azurerm_kubernetes_cluster.
Utwórz azapi_resource zasobu AzAPI.
Utwórz zasób AzAPI, aby wygenerować parę kluczy SSH przy użyciu azapi_resource_action.

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

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

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

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
}

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

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

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

Pobierz nazwę grupy zasobów platformy Azure przy użyciu następującego polecenia.
```
resource_group_name=$(terraform output -raw resource_group_name)
```

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

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
```
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
Ustaw zmienną środowiskową, aby kubectl można było pobrać poprawną konfigurację przy użyciu następującego polecenia.
```
export KUBECONFIG=./azurek8s
```
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:

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.

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.

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.

Sprawdź stan wdrożonych zasobników przy użyciu kubectl get pods polecenia . Przed kontynuowaniem wykonaj wszystkie zasobniki Running .
```
kubectl get pods
```
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
```
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
```
Otwórz przeglądarkę internetową na zewnętrzny adres IP usługi, aby zobaczyć działanie aplikacji ze Sklepu Azure.

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:

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.
Uruchom narzędzie terraform zastosuj, aby zastosować plan wykonania.
```
terraform apply main.destroy.tfplan
```

Usuwanie jednostki usługi

Pobierz identyfikator jednostki usługi przy użyciu następującego polecenia.
```
sp=$(terraform output -raw sp)
```
Usuń jednostkę usługi przy użyciu polecenia az ad sp delete .
```
az ad sp delete --id $sp
```

Instalowanie interfejsu wiersza polecenia dla deweloperów platformy Azure (AZD)
Zainstaluj i skonfiguruj rozwiązanie Terraform.
Możesz przejrzeć kod aplikacji używany w repozytorium Azure-Samples/aks-store-demo.

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.

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
```
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
```

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.

Zaloguj się do swojego konta przy użyciu azd auth login polecenia .
```
azd auth login
```
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 .
Uwierzytelnij się przy użyciu poświadczeń na stronie logowania organizacji.
Upewnij się, że próbujesz nawiązać połączenie z poziomu interfejsu wiersza polecenia platformy Azure.
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.

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>.
```
Skopiuj adres URL hosta lokalnego odebranej strony internetowej po próbie zalogowania się przy użyciu polecenia azd auth login.

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>

Zamknij bieżący terminal i otwórz oryginalny terminal. Powinna zostać wyświetlona lista JSON subskrypcji.
id Skopiuj pole subskrypcji, której chcesz użyć.
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:

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

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.

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 .

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)

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.

Ustaw przestrzeń nazw jako przestrzeń nazw pets demonstracyjną kubectl set-context przy użyciu polecenia .
```
kubectl config set-context --current --namespace=pets
```
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
```
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
```
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
```
Otwórz przeglądarkę internetową na zewnętrzny adres IP usługi, aby zobaczyć działanie aplikacji ze Sklepu Azure.

Usuwanie klastra

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

Usuń wszystkie zasoby utworzone w przewodniku Szybki start przy użyciu azd down polecenia .
```
azd down
```
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)
```

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.

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

Udostępnij za pośrednictwem

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

Zanim rozpoczniesz

Implementowanie kodu narzędzia Terraform

Inicjowanie narzędzia Terraform

Tworzenie planu wykonania programu Terraform

Stosowanie planu wykonywania narzędzia Terraform

Weryfikowanie wyników

Wdrażanie aplikacji

Testowanie aplikacji

Czyszczenie zasobów

Usuwanie zasobów usługi AKS

Usuwanie jednostki usługi

Klonowanie szablonu interfejsu wiersza polecenia dla deweloperów platformy Azure

obejście uwierzytelniania azd

Tworzenie i wdrażanie zasobów dla klastra

Wdrażanie zasobów aplikacji

Generowanie planów programu Terraform

Testowanie aplikacji

Usuwanie klastra

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

Następne kroki

Dodatkowe zasoby

Udostępnij za pośrednictwem

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

Zanim rozpoczniesz

Zaloguj się do konta platformy Azure

Implementowanie kodu narzędzia Terraform

Inicjowanie narzędzia Terraform

Tworzenie planu wykonania programu Terraform

Stosowanie planu wykonywania narzędzia Terraform

Weryfikowanie wyników

Wdrażanie aplikacji

Testowanie aplikacji

Czyszczenie zasobów

Usuwanie zasobów usługi AKS

Usuwanie jednostki usługi

Klonowanie szablonu interfejsu wiersza polecenia dla deweloperów platformy Azure

Zaloguj się do konta usługi Azure Cloud

obejście uwierzytelniania azd

Tworzenie i wdrażanie zasobów dla klastra

Wdrażanie zasobów aplikacji

Generowanie planów programu Terraform

Testowanie aplikacji

Usuwanie klastra

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

Następne kroki

Dodatkowe zasoby