Szybki start: wdrażanie klastra usługi Azure Kubernetes Service (AKS) przy użyciu programu Azure PowerShell

Artykuł
12/13/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 programu Azure PowerShell.
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 artykule przyjęto założenie, że podstawowa wiedza na temat pojęć związanych z platformą 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)).

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto platformy Azure.
Aby ułatwić korzystanie, wypróbuj środowisko programu PowerShell w usłudze Azure Cloud Shell. Aby uzyskać więcej informacji, zobacz Szybki start dotyczący usługi Azure Cloud Shell.

Jeśli chcesz używać programu PowerShell lokalnie, zainstaluj moduł Az programu PowerShell i połącz się z kontem platformy Azure przy użyciu polecenia cmdlet Connect-AzAccount . Upewnij się, że uruchamiasz polecenia z uprawnieniami administracyjnymi. Aby uzyskać więcej informacji, zobacz Instalowanie programu Azure PowerShell.
Upewnij się, że tożsamość używana do utworzenia klastra ma odpowiednie minimalne uprawnienia. Aby uzyskać więcej informacji na temat dostępu i tożsamości dla usługi AKS, zobacz Opcje dostępu i tożsamości dla usługi Azure Kubernetes Service (AKS).
Jeśli masz więcej niż jedną subskrypcję platformy Azure, ustaw subskrypcję, której chcesz użyć na potrzeby przewodnika Szybki start, wywołując polecenie cmdlet Set-AzContext . Aby uzyskać więcej informacji, zobacz Zarządzanie subskrypcjami platformy Azure przy użyciu programu Azure PowerShell.

Tworzenie grupy zasobów

Grupa zasobów platformy Azure to grupa logiczna, w której zasoby platformy Azure są wdrażane i zarządzane. Podczas tworzenia grupy zasobów zostanie wyświetlony monit o określenie lokalizacji. Ta lokalizacja to lokalizacja magazynu metadanych grupy zasobów i lokalizacja, w której zasoby są uruchamiane na platformie Azure, jeśli nie określisz innego regionu podczas tworzenia zasobów.

W poniższym przykładzie tworzona jest grupa zasobów o nazwie myResourceGroup w lokalizacji eastus.

Utwórz grupę zasobów przy użyciu New-AzResourceGroup polecenia cmdlet .

New-AzResourceGroup -Name myResourceGroup -Location eastus

Następujące przykładowe dane wyjściowe przypominają pomyślne utworzenie grupy zasobów:

ResourceGroupName : myResourceGroup
Location          : eastus
ProvisioningState : Succeeded
Tags              :
ResourceId        : /subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/myResourceGroup

Tworzenie klastra AKS

Aby utworzyć klaster usługi AKS, użyj New-AzAksCluster polecenia cmdlet . Poniższy przykład tworzy klaster o nazwie myAKSCluster z jednym węzłem i włącza tożsamość zarządzaną przypisaną przez system.

New-AzAksCluster -ResourceGroupName myResourceGroup `
    -Name myAKSCluster `
    -NodeCount 1 `
    -EnableManagedIdentity `
    -GenerateSshKey

Po kilku minutach polecenie zostanie ukończone i zwrócone informacje o klastrze.

Uwaga

Podczas tworzenia klastra usługi AKS zostanie automatycznie utworzona druga grupa zasobów o nazwie grupa zasobów węzła do przechowywania zasobów usługi AKS. Aby uzyskać więcej informacji, zobacz Grupa zasobów węzła. Po usunięciu grupy zasobów klastra usługi AKS grupa zasobów węzła zostanie również usunięta. Zostanie również wyświetlona grupa zasobów NetworkWatcherRG utworzona domyślnie. Ta grupa zasobów jest używana przez usługę Azure Network Watcher do przechowywania danych monitorowania. Możesz bezpiecznie zignorować tę grupę zasobów. Aby uzyskać więcej informacji, zobacz Włączanie lub wyłączanie usługi Azure Network Watcher.

Łączenie z klastrem

Aby zarządzać klastrem Kubernetes, użyj klienta wiersza polecenia kubernetes kubectl. kubectl program jest już zainstalowany, jeśli używasz usługi Azure Cloud Shell. Aby zainstalować kubectl lokalnie, wywołaj polecenie Install-AzAksCliTool cmdlet .

Skonfiguruj, kubectl aby nawiązać połączenie z klastrem Import-AzAksCredential Kubernetes przy użyciu polecenia cmdlet . To polecenie powoduje pobranie poświadczeń i zastosowanie ich w konfiguracji interfejsu wiersza polecenia Kubernetes.
```
Import-AzAksCredential -ResourceGroupName myResourceGroup -Name myAKSCluster
```
Sprawdź połączenie z klastrem kubectl get przy użyciu polecenia . To polecenie zwraca listę węzłów klastra.
```
kubectl get nodes
```
Poniższe przykładowe dane wyjściowe zawierają jeden węzeł utworzony w poprzednich krokach. Upewnij się, że stan węzła to Gotowe.
```
NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-11853318-vmss000000   Ready    agent   2m26s   v1.27.7
```

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 polecenia kubectl apply 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 polecenia kubectl get pods . Przed kontynuowaniem wykonaj wszystkie zasobniki Running .
```
kubectl get pods
```
Sprawdź publiczny adres IP aplikacji frontonu sklepu. Monitoruj postęp przy użyciu polecenia kubectl get service za pomocą argumentu --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.

Usuwanie zasobów

Jeśli nie planujesz przechodzenia przez samouczek usługi AKS, wyczyść niepotrzebne zasoby, aby uniknąć opłat za platformę Azure. Usuń grupę zasobów, usługę kontenera i wszystkie powiązane zasoby, wywołując Remove-AzResourceGroup polecenie cmdlet .

Remove-AzResourceGroup -Name myResourceGroup

Uwaga

Klaster usługi AKS został utworzony przy użyciu tożsamości zarządzanej przypisanej przez system (domyślna opcja tożsamości używana w tym przewodniku Szybki start), tożsamość jest zarządzana przez platformę i nie wymaga usunięcia.

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.

Samouczek usługi AKS

Udostępnij za pośrednictwem

Szybki start: wdrażanie klastra usługi Azure Kubernetes Service (AKS) przy użyciu programu Azure PowerShell

Zanim rozpoczniesz

Tworzenie grupy zasobów

Tworzenie klastra AKS

Łączenie z klastrem

Wdrażanie aplikacji

Testowanie aplikacji

Usuwanie zasobów

Następne kroki

Dodatkowe zasoby