Szybki start: wdrażanie systemu Azure Container Linux (ACL) dla klastra AKS przy użyciu szablonu ARM

Rozpocznij pracę z Azure Container Linux (ACL) dla usługi AKS, wdrażając klaster usługi AKS przy użyciu szablonu Azure Resource Manager (ARM), .

Z tego przewodnika Szybki start dowiesz się, jak wykonywać następujące zadania:

  • Utwórz klaster AKS przy użyciu ACL dla AKS.
  • Wdróż klaster za pomocą szablonu ARM.
  • Uruchom przykładową aplikację z wieloma kontenerami z grupą mikrousług i frontonów internetowych symulujących scenariusz sprzedaży detalicznej.

Note

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.

Ważna

Jeśli używasz Azure Container Linux (ACL) w usłudze AKS, zapoznaj się z następującymi zagadnieniami i ograniczeniami:

Wymagania wstępne

  • Artykuł zakłada podstawową znajomość pojęć związanych z Kubernetes. Aby uzyskać więcej informacji, zobacz Podstawowe pojęcia Kubernetes dla Azure Kubernetes Service (AKS).
  • Jeśli nie masz jeszcze konta platformy Azure, przed rozpoczęciem utwórz bezpłatne konto.
  • 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).
  • Aby wdrożyć szablon ARM, musisz mieć dostęp do zapisu do zasobów, które wdrażasz, oraz dostęp do wszystkich operacji na typie zasobu Microsoft.Resources/deployments. Na przykład do wdrożenia maszyny wirtualnej potrzebne są uprawnienia Microsoft.Compute/virtualMachines/write i Microsoft.Resources/deployments/*. Aby zapoznać się z listą ról i uprawnień, zobacz wbudowane role w Azure.

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

Rejestrowanie wymaganych dostawców zasobów

Może być konieczne zarejestrowanie wymaganych dostawców zasobów, takich jak Microsoft.ContainerService w ramach subskrypcji Azure.

Sprawdzanie stanu rejestracji

Sprawdź stan rejestracji przy użyciu az provider show polecenia .

az provider show --namespace Microsoft.ContainerService --query registrationState

Rejestrowanie dostawcy zasobów

W razie potrzeby zarejestruj dostawcę zasobów Microsoft.ContainerService przy użyciu polecenia az provider register.

az provider register --namespace Microsoft.ContainerService

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), która jest generowana przy użyciu ssh-keygen polecenia . Domyślnie te pliki są tworzone w katalogu ~/.ssh . ssh-keygen Uruchomienie polecenia zastępuje dowolną parę kluczy SSH o tej samej nazwie już istniejącej w danej lokalizacji. Aby uzyskać więcej informacji na temat tworzenia kluczy SSH, zobacz Tworzenie kluczy SSH i zarządzanie nimi na potrzeby uwierzytelniania na platformie Azure.

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

  2. Utwórz grupę zasobów przy użyciu polecenia az group create. Poniższy przykład tworzy grupę zasobów o nazwie myResourceGroup w regionie Wschodnie stany USA :

    az group create \
  --name myResourceGroup \
  --location eastus

  3. Utwórz parę kluczy SSH za pomocą polecenia az sshkey create lub ssh-keygen.

    az sshkey create --name mySSHKey --resource-group myResourceGroup

    Możesz też utworzyć parę kluczy SSH przy użyciu polecenia ssh-keygen:

    ssh-keygen -t rsa -b 4096

  4. Aby wdrożyć szablon, należy podać klucz publiczny z pary SSH. Pobierz klucz publiczny przy użyciu az sshkey show polecenia .

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

Przegląd szablonu

W poniższym wdrożeniu użyto szablonu ARM z Azure Quickstart Templates:

{
  "$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": "2026-03-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",
            "osSKU": "AzureContainerLinux",
            "mode": "System"
          }
        ],
        "linuxProfile": {
          "adminUsername": "[parameters('linuxAdminUsername')]",
          "ssh": {
            "publicKeys": [
              {
                "keyData": "[parameters('sshRSAPublicKey')]"
              }
            ]
          }
        }
      }
    }
  ],
  "outputs": {
    "controlPlaneFQDN": {
      "type": "string",
      "value": "[reference(resourceId('Microsoft.ContainerService/managedClusters', parameters('clusterName')), '2026-03-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. Skonfiguruj parametry szablonu na stronie Wdrożenie niestandardowe . W tym przewodniku Szybki start pozostaw domyślne wartości dla Rozmiar dysku systemu operacyjnego (GB), Liczba agentów, Rozmiar maszyny wirtualnej agenta i Typ systemu operacyjnego. Podaj własne wartości dla następujących parametrów:

    • 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.
    • SKU systemu operacyjnego: Określ AzureContainerLinux. Jeśli nie zaktualizujesz SKU systemu operacyjnego, domyślną wartością jest Ubuntu.
    • 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 Przejrzyj + Utwórz>Utwórz.

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

Połącz się 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, użyj az aks install-cli polecenia .

  1. Skonfiguruj kubectl, aby nawiązać połączenie z klastrem Kubernetes za pomocą polecenia az aks get-credentials. To polecenie pobiera poświadczenia i konfiguruje Kubernetes CLI do ich użycia.

    az aks get-credentials \
  --resource-group myResourceGroup \
  --name myAKSCluster

  2. Zweryfikuj połączenie z klastrem, używając polecenia kubectl get. Ta komenda 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-12345678-vmss000000   Ready    <none>   5m53s   v1.32.7
aks-agentpool-12345678-vmss000001   Ready    <none>   6m31s   v1.32.7
aks-agentpool-12345678-vmss000002   Ready    <none>   6m35s   v1.32.7

Wdrażanie aplikacji

Aby wdrożyć aplikację, należy użyć pliku manifestu, aby utworzyć wszystkie obiekty wymagane do uruchomienia aplikacji AKS Store. Plik manifestu Kubernetes definiuje pożą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ę 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 zamówień: składa zamówienia.
  • Rabbit MQ: system kolejkowania komunikatów dla kolejki zamówień.

Note

Nie zalecamy uruchamiania kontenerów stanowych, takich jak RabbitMQ, bez stałego przechowywania danych w środowisku produkcyjnym. Są one używane tutaj dla uproszczenia, ale zalecamy korzystanie z usług zarządzanych, takich jak Azure Cosmos DB 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 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

  1. Sprawdź stan wdrożonych zasobników za pomocą polecenia kubectl get pods. Upewnij się, że wszystkie zasobniki są Running przed kontynuowaniem.

    kubectl get pods

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

  3. Gdy adres EXTERNAL-IP zmieni się z oczekującego na rzeczywisty publiczny adres IP, użyj CTRL-C do zatrzymania procesu kubectl obserwacji.

    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 AKS, wyczyść niepotrzebne zasoby, aby uniknąć opłat Azure.

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

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

Note

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ą, więc nie trzeba jej ręcznie usuwać.

Treści powiązane

W tym przewodniku Szybki start wdrożono klaster AKS z ACL for AKS przy użyciu szablonu ARM. Aby dowiedzieć się więcej o usłudze Azure Container Linux (ACL) dla Azure Kubernetes Service (AKS), zobacz Azure Container Linux (ACL) dla Azure Kubernetes Service (AKS).

  • Last updated on