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 tym przewodniku Szybki start:

  • Wdrażanie klastra usługi AKS przy użyciu Azure Resource Manager szablonu.
  • Uruchamianie aplikacji z wieloma kontenerami z frontonie internetowym i wystąpieniem usługi Redis w klastrze.

Obraz przedstawiający przechodzenie do aplikacji Azure Vote

Szablon usługi ARM to plik w formacie JavaScript Object Notation (JSON) definiujący infrastrukturę i konfigurację projektu. W szablonie używana jest składnia deklaratywna. W składni deklaratywnej opisujesz rozwiązanie, które chcesz wdrożyć, bez konieczności pisania sekwencji poleceń programistycznych służących do tworzenia takiego wdrożenia.

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 Podstawowe pojęcia dotyczące usługi Azure Kubernetes Service (AKS).

Jeśli Twoje środowisko spełnia wymagania wstępne i masz doświadczenie w korzystaniu z szablonów ARM, wybierz przycisk Wdróż na platformie Azure. Szablon zostanie otwarty w witrynie Azure Portal.

Wdrażanie na platformie Azure

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem Utwórz bezpłatne konto .

Wymagania wstępne

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

  • Aby utworzyć klaster usługi AKS przy użyciu Resource Manager szablonu, należy podać klucz publiczny SSH. Jeśli potrzebujesz tego zasobu, zobacz następującą sekcję: W przeciwnym razie przejdź do sekcji Przeglądanie szablonu.

Tworzenie pary kluczy SSH

Aby uzyskać dostęp do węzłów usługi AKS, połącz się przy użyciu pary kluczy SSH (publicznej i prywatnej), która jest generowana przy użyciu ssh-keygen polecenia . Domyślnie te pliki są tworzone w katalogu ~/.ssh. Uruchomienie polecenia spowoduje zastąpienie dowolnej pary kluczy SSH o takiej ssh-keygen samej nazwie, która już istnieje w danej lokalizacji.

  1. Przejdź do https://shell.azure.com strony , Cloud Shell w przeglądarce.

  2. Uruchom polecenie ssh-keygen. Poniższy przykład tworzy parę kluczy SSH przy użyciu szyfrowania RSA i długości bitowej 2048:

    ssh-keygen -t rsa -b 2048
    

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

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.4.412.5873",
      "templateHash": "14640985186631737095"
    }
  },
  "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,
      "maxValue": 1023,
      "minValue": 0,
      "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,
      "maxValue": 50,
      "minValue": 1,
      "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'"
      }
    }
  },
  "functions": [],
  "resources": [
    {
      "type": "Microsoft.ContainerService/managedClusters",
      "apiVersion": "2020-09-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'))).fqdn]"
    }
  }
}

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

Wdrożenie szablonu

  1. Wybierz poniższy przycisk, aby zalogować się do platformy Azure i otworzyć szablon.

    Wdrażanie na platformie Azure

  2. Wybierz lub wprowadź następujące wartości.

    W tym przewodniku Szybki start pozostaw wartości domyślne dla pól Rozmiar dysku systemu operacyjnego GB, Liczba agentów, Rozmiar maszyny wirtualnej agenta, Typ systemu operacyjnego i Wersja platformy Kubernetes. Podaj własne wartości dla następujących parametrów 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ę, taką jak Wschodnie usa.
    • Nazwa klastra: wprowadź unikatową nazwę klastra usługi AKS, taką jak myAKSCluster.
    • Prefiks DNS: wprowadź unikatowy prefiks DNS klastra, taki jak myakscluster.
    • Nazwa użytkownika administratora systemu Linux: wprowadź nazwę użytkownika, aby nawiązać połączenie przy użyciu połączenia 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).

    Resource Manager, aby utworzyć Azure Kubernetes Service klastra w portalu

  3. Wybierz pozycję Przejrzyj i utwórz.

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

Weryfikowanie wdrożenia

Łączenie z klastrem

Aby zarządzać klastrem Kubernetes, użyj klienta wiersza polecenia Kubernetes, kubectl. kubectl program jest już zainstalowany, jeśli używasz Azure Cloud Shell.

  1. Zainstaluj kubectl lokalnie przy użyciu polecenia az aks install-cli:

    az aks install-cli
    
  2. Skonfiguruj, kubectl aby nawiązać połączenie z klastrem Kubernetes za pomocą 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
    
  3. Sprawdź połączenie z klastrem przy użyciu polecenia kubectl get. To polecenie zwraca listę węzłów klastra.

    kubectl get nodes
    

    Dane wyjściowe pokazują węzły utworzone w poprzednich krokach. Upewnij się, że stan wszystkich węzłów to Gotowe:

    NAME                       STATUS   ROLES   AGE     VERSION
    aks-agentpool-41324942-0   Ready    agent   6m44s   v1.12.6    
    aks-agentpool-41324942-1   Ready    agent   6m46s   v1.12.6
    aks-agentpool-41324942-2   Ready    agent   6m45s   v1.12.6
    

Uruchamianie aplikacji

Plik manifestu kubernetes definiuje żądany stan klastra, na przykład obrazy kontenerów do uruchomienia.

W tym przewodniku Szybki start użyjemy manifestu do utworzenia wszystkich obiektów potrzebnych do uruchomienia aplikacji Azure Vote. Ten manifest zawiera dwa wdrożenia rozwiązania Kubernetes:

  • Przykładowe aplikacje języka Python do głosowania na platformie Azure.
  • Wystąpienie usługi Redis.

Tworzone są również dwie usługi Kubernetes:

  • Wewnętrzna usługa dla wystąpienia usługi Redis.
  • Zewnętrzna usługa do uzyskiwania dostępu do aplikacji Azure Vote z Internetu.
  1. Utwórz plik o nazwie azure-vote.yaml.

    • Jeśli używasz tego Azure Cloud Shell, ten plik można utworzyć przy użyciu lub tak, jakby pracować vi nano w systemie wirtualnym lub fizycznym
  2. Skopiuj następującą definicję YAML:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: azure-vote-back
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: azure-vote-back
      template:
        metadata:
          labels:
            app: azure-vote-back
        spec:
          nodeSelector:
            "kubernetes.io/os": linux
          containers:
          - name: azure-vote-back
            image: mcr.microsoft.com/oss/bitnami/redis:6.0.8
            env:
            - name: ALLOW_EMPTY_PASSWORD
              value: "yes"
            resources:
              requests:
                cpu: 100m
                memory: 128Mi
              limits:
                cpu: 250m
                memory: 256Mi
            ports:
            - containerPort: 6379
              name: redis
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: azure-vote-back
    spec:
      ports:
      - port: 6379
      selector:
        app: azure-vote-back
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: azure-vote-front
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: azure-vote-front
      template:
        metadata:
          labels:
            app: azure-vote-front
        spec:
          nodeSelector:
            "kubernetes.io/os": linux
          containers:
          - name: azure-vote-front
            image: mcr.microsoft.com/azuredocs/azure-vote-front:v1
            resources:
              requests:
                cpu: 100m
                memory: 128Mi
              limits:
                cpu: 250m
                memory: 256Mi
            ports:
            - containerPort: 80
            env:
            - name: REDIS
              value: "azure-vote-back"
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: azure-vote-front
    spec:
      type: LoadBalancer
      ports:
      - port: 80
      selector:
        app: azure-vote-front
    
  3. Wdróż aplikację przy użyciu polecenia kubectl apply i podaj nazwę manifestu YAML:

    kubectl apply -f azure-vote.yaml
    

    Dane wyjściowe pokazują pomyślnie utworzone wdrożenia i usługi:

    deployment "azure-vote-back" created
    service "azure-vote-back" created
    deployment "azure-vote-front" created
    service "azure-vote-front" created
    

Testowanie aplikacji

Podczas uruchamiania aplikacji usługa Kubernetes uwidacznia fronton aplikacji w Internecie. Ten proces może potrwać kilka minut.

Monitoruj postęp za pomocą polecenia kubectl get service z --watch argumentem .

kubectl get service azure-vote-front --watch

Dane wyjściowe EXTERNAL-IP dla usługi początkowo będą azure-vote-front wyświetlane jako oczekujące.

NAME               TYPE           CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
azure-vote-front   LoadBalancer   10.0.37.27   <pending>     80:30572/TCP   6s

Gdy adres EXTERNAL-IP zmieni się z oczekujące na rzeczywisty publiczny adres IP, użyj , CTRL-C aby zatrzymać proces kubectl obejrzyj. Następujące przykładowe dane wyjściowe przedstawiają prawidłowy publiczny adres IP przypisany do usługi:

azure-vote-front   LoadBalancer   10.0.37.27   52.179.23.131   80:30572/TCP   2m

Aby wyświetlić działającą aplikację Azure Vote, otwórz zewnętrzny adres IP usługi w przeglądarce internetowej.

Obraz przedstawiający przechodzenie do aplikacji Azure Vote

Czyszczenie zasobów

Aby uniknąć opłat za platformę Azure, wyczyść niepotrzebne zasoby. Usuń grupę zasobów, usługę kontenera i wszystkie powiązane zasoby za pomocą polecenia az group delete.

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

Uwaga

Po usunięciu klastra jednostka usługi Azure Active Directory używana przez klaster usługi AKS nie jest usuwana. Aby sprawdzić, jak usunąć jednostkę usługi, zobacz AKS service principal considerations and deletion (Uwagi dotyczące jednostki usługi AKS i jej usuwanie).

Jeśli używasz tożsamości zarządzanej, tożsamość jest zarządzana przez platformę i nie wymaga usunięcia.

Uzyskiwanie kodu

Wcześniej istniejące obrazy kontenerów zostały użyte w tym przewodniku Szybki start do utworzenia wdrożenia kubernetes. Powiązany kod aplikacji, plik dockerfile i plik manifestu kubernetes są dostępne na GitHub.

Następne kroki

W tym przewodniku Szybki start wdrożono klaster Kubernetes, a następnie wdrożono w nim aplikację z wieloma kontenerami. Uzyskaj dostęp do internetowego pulpitu nawigacyjnego usługi Kubernetes dla klastra usługi AKS.

Aby dowiedzieć się więcej o usłudze AKS i poznać dokładnie proces od kompletnego kodu do wdrożenia, przejdź do samouczka dotyczącego klastra Kubernetes.