Udostępnij za pośrednictwem


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

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 szablonu usługi Azure Resource Manager.
  • Uruchom przykładową aplikację z wieloma kontenerami z grupą mikrousług i frontonów internetowych symulujących scenariusz sprzedaży detalicznej.

Szablon usługi Azure Resource Manager to plik JavaScript Object Notation (JSON), który definiuje infrastrukturę i konfigurację projektu. W szablonie używana jest składnia deklaratywna. Możesz opisać zamierzone wdrożenie bez konieczności pisania sekwencji poleceń programowania w celu utworzenia wdrożenia.

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)).

Po wdrożeniu klastra z szablonu możesz użyć interfejsu wiersza polecenia platformy Azure lub programu Azure PowerShell, aby nawiązać połączenie z klastrem i wdrożyć przykładową aplikację.

Ten artykuł wymaga interfejsu wiersza polecenia platformy Azure w wersji 2.0.64 lub nowszej. Jeśli używasz usługi Azure Cloud Shell, najnowsza wersja jest już tam zainstalowana.

Tworzenie pary kluczy SSH

Aby utworzyć klaster usługi AKS przy użyciu szablonu usługi ARM, należy podać klucz publiczny SSH. Jeśli potrzebujesz tego zasobu, wykonaj kroki opisane w tej sekcji. W przeciwnym razie przejdź do sekcji Przeglądanie szablonu .

Aby uzyskać dostęp do węzłów usługi AKS, należy nawiązać połączenie przy użyciu pary kluczy SSH (publicznej i prywatnej). Aby utworzyć parę kluczy SSH:

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

  2. Utwórz parę kluczy SSH przy użyciu polecenia az sshkey create lub ssh-keygen polecenia .

    # Create an SSH key pair using Azure CLI
    az sshkey create --name "mySSHKey" --resource-group "myResourceGroup"
    
    # or
    
    # Create an SSH key pair using ssh-keygen
    ssh-keygen -t rsa -b 4096
    
  3. Aby wdrożyć szablon, należy podać klucz publiczny z pary SSH. Aby pobrać klucz publiczny, wywołaj polecenie az sshkey show:

    az sshkey show --name "mySSHKey" --resource-group "myResourceGroup" --query "publicKey"
    

Domyślnie pliki kluczy SSH są tworzone w katalogu ~/.ssh . az sshkey create Uruchomienie polecenia or ssh-keygen spowoduje zastąpienie istniejącej pary kluczy SSH o tej samej nazwie.

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

Przegląd szablonu

Szablon używany w tym przewodniku Szybki start jest jednym z szablonów szybkiego startu platformy Azure.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "metadata": {
    "_generator": {
      "name": "bicep",
      "version": "0.26.170.59819",
      "templateHash": "14823542069333410776"
    }
  },
  "parameters": {
    "clusterName": {
      "type": "string",
      "defaultValue": "aks101cluster",
      "metadata": {
        "description": "The name of the Managed Cluster resource."
      }
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]",
      "metadata": {
        "description": "The location of the Managed Cluster resource."
      }
    },
    "dnsPrefix": {
      "type": "string",
      "metadata": {
        "description": "Optional DNS prefix to use with hosted Kubernetes API server FQDN."
      }
    },
    "osDiskSizeGB": {
      "type": "int",
      "defaultValue": 0,
      "minValue": 0,
      "maxValue": 1023,
      "metadata": {
        "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."
      }
    },
    "agentCount": {
      "type": "int",
      "defaultValue": 3,
      "minValue": 1,
      "maxValue": 50,
      "metadata": {
        "description": "The number of nodes for the cluster."
      }
    },
    "agentVMSize": {
      "type": "string",
      "defaultValue": "standard_d2s_v3",
      "metadata": {
        "description": "The size of the Virtual Machine."
      }
    },
    "linuxAdminUsername": {
      "type": "string",
      "metadata": {
        "description": "User name for the Linux Virtual Machines."
      }
    },
    "sshRSAPublicKey": {
      "type": "string",
      "metadata": {
        "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'"
      }
    }
  },
  "resources": [
    {
      "type": "Microsoft.ContainerService/managedClusters",
      "apiVersion": "2024-02-01",
      "name": "[parameters('clusterName')]",
      "location": "[parameters('location')]",
      "identity": {
        "type": "SystemAssigned"
      },
      "properties": {
        "dnsPrefix": "[parameters('dnsPrefix')]",
        "agentPoolProfiles": [
          {
            "name": "agentpool",
            "osDiskSizeGB": "[parameters('osDiskSizeGB')]",
            "count": "[parameters('agentCount')]",
            "vmSize": "[parameters('agentVMSize')]",
            "osType": "Linux",
            "mode": "System"
          }
        ],
        "linuxProfile": {
          "adminUsername": "[parameters('linuxAdminUsername')]",
          "ssh": {
            "publicKeys": [
              {
                "keyData": "[parameters('sshRSAPublicKey')]"
              }
            ]
          }
        }
      }
    }
  ],
  "outputs": {
    "controlPlaneFQDN": {
      "type": "string",
      "value": "[reference(resourceId('Microsoft.ContainerService/managedClusters', parameters('clusterName')), '2024-02-01').fqdn]"
    }
  }
}

Typ zasobu zdefiniowany w szablonie usługi ARM to Microsoft.ContainerService/managedClusters.

Aby uzyskać więcej przykładów usługi AKS, zobacz witrynę szablonów szybkiego startu usługi AKS.

Wdrażanie szablonu

  1. Wybierz pozycję Wdróż na platformie Azure , aby zalogować się i otworzyć szablon.

    Przycisk wdrażania szablonu usługi Resource Manager na platformie Azure.

  2. Na stronie Podstawowe pozostaw wartości domyślne rozmiaru dysku systemu operacyjnego GB, liczba agentów, rozmiar maszyny wirtualnej agenta i typ systemu operacyjnego oraz skonfiguruj następujące parametry szablonu:

    • Subskrypcja: wybierz subskrypcję platformy Azure.
    • Grupa zasobów: wybierz pozycję Utwórz nową. Wprowadź unikatową nazwę grupy zasobów, taką jak myResourceGroup, a następnie wybierz przycisk OK.
    • Lokalizacja: wybierz lokalizację, na przykład Wschodnie stany USA.
    • 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.
    • Źródło klucza publicznego SSH: wybierz pozycję Użyj istniejącego klucza publicznego.
    • Nazwa pary kluczy: Skopiuj i wklej publiczną część pary kluczy SSH (domyślnie zawartość pliku ~/.ssh/id_rsa.pub).
  3. Wybierz pozycję Przeglądanie + tworzenie>Utwórz.

Utworzenie klastra AKS może potrwać kilka minut. Przed przejściem do następnego kroku poczekaj na pomyślne wdrożenie klastra.

Łączenie z klastrem

Aby zarządzać klastrem Kubernetes, użyj klienta wiersza polecenia kubernetes kubectl.

Jeśli korzystasz z usługi Azure Cloud Shell, narzędzie kubectl jest już zainstalowane. Aby zainstalować i uruchomić kubectl lokalnie, wywołaj polecenie az aks install-cli .

  1. Skonfiguruj, kubectl aby nawiązać połączenie z klastrem Kubernetes przy użyciu polecenia az aks get-credentials . To polecenie powoduje pobranie poświadczeń i zastosowanie ich w konfiguracji interfejsu wiersza polecenia Kubernetes.

    az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
    
  2. Sprawdź połączenie z klastrem przy użyciu polecenia kubectl get . To polecenie zwraca listę węzłów klastra.

    kubectl get nodes
    

    W poniższych przykładowych danych wyjściowych przedstawiono trzy węzły utworzone w poprzednich krokach. Upewnij się, że stan węzła to Gotowe.

    NAME                                STATUS   ROLES   AGE   VERSION
    aks-agentpool-27442051-vmss000000   Ready    agent   10m   v1.27.7
    aks-agentpool-27442051-vmss000001   Ready    agent   10m   v1.27.7
    aks-agentpool-27442051-vmss000002   Ready    agent   11m   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:

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

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

    kubectl get pods
    
  2. 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
    
  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.

Usuwanie klastra

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 polecenie az group delete .

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

Uwaga

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

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.