Szybki start: wdrażanie klastra usługi Azure Kubernetes Service (AKS) przy użyciu rozszerzenia Bicep Kubernetes (wersja zapoznawcza)

Artykuł
04/03/2025

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:

Wdróż klaster AKS, używając rozszerzenia Bicep Kubernetes (wersja zapoznawcza).
Uruchom przykładową aplikację z wieloma kontenerami z grupą mikrousług i frontonów internetowych symulujących scenariusz sprzedaży detalicznej.

Ważne

Obecnie rozszerzenie Bicep Kubernetes jest w wersji zapoznawczej. Funkcję można włączyć, dodając do pliku konfiguracji Bicep:

{
 "experimentalFeaturesEnabled": {
   "extensibility": true,
 }
}

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

Ten przewodnik szybkiego startu zakłada, że masz podstawową wiedzę na temat pojęć związanych z 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.
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).

Bicep to język specyficzny dla domeny (DSL), który używa składni deklaratywnej do wdrażania zasobów platformy Azure. Zapewnia zwięzłą składnię, niezawodne bezpieczeństwo typów i obsługę ponownego użycia kodu. Bicep oferuje najlepsze środowisko tworzenia rozwiązań infrastruktury jako kodu na platformie Azure.

Aby skonfigurować środowisko na potrzeby programowania aplikacji Bicep, zobacz Instalowanie narzędzi Bicep. Po wykonaniu tych kroków masz program Visual Studio Code i rozszerzenie Bicep. Masz również najnowszą wersję interfejsu wiersza polecenia platformy Azure lub najnowszy moduł programu Azure PowerShell.
Aby utworzyć klaster usługi AKS przy użyciu pliku Bicep, należy podać klucz publiczny SSH. Jeśli potrzebujesz tego zasobu, zapoznaj się z następującą sekcją. W przeciwnym razie przejdź do przeglądu pliku Bicep.
Aby wdrożyć plik Bicep, potrzebujesz dostępu do zapisu w zasobach, które wdrażasz, oraz dostępu do wszystkich operacji na zasobie typu Microsoft.Resources/deployments. Na przykład, aby wdrożyć maszynę wirtualną, potrzebne są uprawnienia Microsoft.Compute/virtualMachines/write i Microsoft.Resources/deployments/*. Aby uzyskać listę ról i uprawnień, zobacz Role wbudowane platformy Azure.

Tworzenie pary kluczy SSH

Przejdź do witryny , https://shell.azure.com aby otworzyć usługę Cloud Shell w przeglądarce.

Utwórz parę kluczy SSH przy użyciu polecenia az sshkey create w interfejsie wiersza polecenia Azure CLI lub używając polecenia ssh-keygen.

# Create an SSH key pair using Azure CLI
az sshkey create --name "mySSHKey" --resource-group "myResourceGroup"

# Create an SSH key pair using ssh-keygen
ssh-keygen -t rsa -b 4096

Aby uzyskać więcej informacji na temat tworzenia kluczy SSH, zobacz Tworzenie kluczy SSH i zarządzanie nimi na potrzeby uwierzytelniania na platformie Azure.

Przejrzyj plik Bicep

Plik Bicep używany do tworzenia klastra AKS pochodzi z Azure Quickstart Templates. Aby uzyskać więcej przykładów usługi AKS, zobacz Szablony szybkiego startu usługi AKS.

@description('The name of the Managed Cluster resource.')
param clusterName string = 'aks101cluster'

@description('The location of the Managed Cluster resource.')
param location string = resourceGroup().location

@description('Optional DNS prefix to use with hosted Kubernetes API server FQDN.')
param dnsPrefix string

@description('Disk size (in GB) to provision for each of the agent pool nodes. This value ranges from 0 to 1023. Specifying 0 will apply the default disk size for that agentVMSize.')
@minValue(0)
@maxValue(1023)
param osDiskSizeGB int = 0

@description('The number of nodes for the cluster.')
@minValue(1)
@maxValue(50)
param agentCount int = 3

@description('The size of the Virtual Machine.')
param agentVMSize string = 'standard_d2s_v3'

@description('User name for the Linux Virtual Machines.')
param linuxAdminUsername string

@description('Configure all linux machines with the SSH RSA public key string. Your key should include three parts, for example \'ssh-rsa AAAAB...snip...UcyupgH azureuser@linuxvm\'')
param sshRSAPublicKey string

resource aks 'Microsoft.ContainerService/managedClusters@2024-02-01' = {
  name: clusterName
  location: location
  identity: {
    type: 'SystemAssigned'
  }
  properties: {
    dnsPrefix: dnsPrefix
    agentPoolProfiles: [
      {
        name: 'agentpool'
        osDiskSizeGB: osDiskSizeGB
        count: agentCount
        vmSize: agentVMSize
        osType: 'Linux'
        mode: 'System'
      }
    ]
    linuxProfile: {
      adminUsername: linuxAdminUsername
      ssh: {
        publicKeys: [
          {
            keyData: sshRSAPublicKey
          }
        ]
      }
    }
  }
}

output controlPlaneFQDN string = aks.properties.fqdn

Zasób zdefiniowany w pliku Bicep to Microsoft.ContainerService/managedClusters.

Zapisz kopię pliku jako main.bicep na komputerze lokalnym.

Dodawanie definicji 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: składa zamówienia.
Rabbit MQ: kolejka komunikatów dla kolejki zamówień.

Uwaga

Nie zalecamy uruchamiania kontenerów stanowych, takich jak przykładowo Rabbit MQ, bez trwałego miejsca do 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 w tym samym folderze co main.bicep 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.

Otwórz plik main.bicep w programie Visual Studio Code.
Naciśnij Ctrl+Shift+P , aby otworzyć paletę poleceń.
Wyszukaj bicep, a następnie wybierz Bicep: Importuj manifest Kubernetes.
Wybierz aks-store-quickstart.yaml z wiersza polecenia. Ten proces tworzy plik aks-store-quickstart.bicep w tym samym folderze.

Otwórz main.bicep plik i dodaj następujący kod Bicep na końcu pliku, aby odwołać się do nowo utworzonego aks-store-quickstart.bicep modułu:

module kubernetes './aks-store-quickstart.bicep' = {
  name: 'buildbicep-deploy'
  params: {
    kubeConfig: aks.listClusterAdminCredential().kubeconfigs[0].value
  }
}

Zapisz zarówno elementy , jak main.bicep i aks-store-quickstart.bicep.

Utwórz grupę zasobów platformy Azure przy użyciu polecenia az group create .
```
az group create --name myResourceGroup --location eastus
```

Wdróż plik Bicep używając polecenia az deployment group create.

az deployment group create --resource-group myResourceGroup --template-file main.bicep --parameters clusterName=<cluster-name> dnsPrefix=<dns-previs> linuxAdminUsername=<linux-admin-username> sshRSAPublicKey='<ssh-key>'

Utwórz grupę zasobów platformy Azure przy użyciu polecenia cmdlet New-AzResourceGroup .
```
New-AzResourceGroup -Name myResourceGroup -Location eastus
```

Wdróż plik Bicep przy użyciu cmdlet New-AzResourceGroupDeployment.

New-AzResourceGroupDeployment -ResourceGroupName myResourceGroup -TemplateFile ./main.bicep -clusterName=<cluster-name> -dnsPrefix=<dns-prefix> -linuxAdminUsername=<linux-admin-username> -sshRSAPublicKey="<ssh-key>"

Podaj następujące wartości w poleceniach:

Nazwa klastra: wprowadź unikatową nazwę klastra usługi AKS, taką jak myAKSCluster.
Prefiks DNS: wprowadź unikatowy prefiks DNS dla klastra, taki jak myakscluster.
Nazwa użytkownika administratora systemu Linux: wprowadź nazwę użytkownika, aby nawiązać połączenie przy użyciu protokołu SSH, na przykład azureuser.
Klucz publiczny SSH RSA: skopiuj i wklej publicznączęść pary kluczy SSH (domyślnie zawartość pliku ~/.ssh/id_rsa.pub).

Utworzenie klastra AKS może potrwać kilka minut. Poczekaj na pomyślne wdrożenie klastra, zanim przejdziesz do następnego kroku.

Zweryfikuj wdrożenie Bicep

Zaloguj się w witrynie Azure Portal.
W menu portalu Azure lub na stronie głównej przejdź do klastra AKS.
W obszarze Zasoby platformy Kubernetes wybierz pozycję Usługi i ruch przychodzący.
Znajdź usługę store-front i skopiuj wartość zewnętrznego adresu IP.
Otwórz przeglądarkę internetową na zewnętrzny adres IP usługi, aby zobaczyć działanie aplikacji ze Sklepu Azure.

Usuwanie klastra

Jeśli nie planujesz przechodzenia przez samouczek AKS, wyczyść niepotrzebne zasoby, aby uniknąć opłat w Azure.

Azure CLI
Azure PowerShell

Usuń grupę zasobów, usługę kontenera i wszystkie powiązane zasoby przy użyciu polecenia az group delete .

az group delete --name myResourceGroup --yes --no-wait

Usuń grupę zasobów, usługę kontenera i wszystkie powiązane zasoby przy użyciu polecenia cmdlet Remove-AzResourceGroup .

Remove-AzResourceGroup -Name myResourceGroup

Uwaga

Klaster usługi AKS został utworzony z użyciem tożsamości zarządzanej przypisanej przez system, która jest domyślną opcją tożsamości używaną w tym szybkim starcie. Platforma zarządza tą tożsamością, aby nie trzeba było jej ręcznie usuwać.

Następne kroki

W tym wprowadzeniu wdrożyłeś klaster Kubernetes i następnie wdrożyłeś prostą aplikację wielokontenerową. 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 AKS

Udostępnij za pośrednictwem

Szybki start: wdrażanie klastra usługi Azure Kubernetes Service (AKS) przy użyciu rozszerzenia Bicep Kubernetes (wersja zapoznawcza)

Zanim rozpoczniesz

Tworzenie pary kluczy SSH

Przejrzyj plik Bicep

Dodawanie definicji aplikacji

Wdróż plik Bicep

Zweryfikuj wdrożenie Bicep

Usuwanie klastra

Następne kroki

Dodatkowe zasoby