Rychlý start: Nasazení clusteru Azure Kubernetes Service (AKS) pomocí Azure PowerShellu

Azure Kubernetes Service (AKS) je spravovaná služba Kubernetes, která umožňuje rychle nasazovat a spravovat clustery. V tomto rychlém startu:

  • Nasazení clusteru AKS pomocí Azure PowerShellu
  • Spusťte ukázkovou vícekontenerovou aplikaci se skupinou mikroslužeb a webových front-endů simulujících scénář maloobchodního prodeje.

Poznámka:

Pokud chcete začít rychle zřizovat cluster AKS, najdete v tomto článku postup nasazení clusteru s výchozím nastavením pouze pro účely vyhodnocení. Před nasazením clusteru připraveného pro produkční prostředí doporučujeme seznámit se s naší referenční architekturou podle směrného plánu a zvážit, jak je v souladu s vašimi obchodními požadavky.

Než začnete

Tento článek předpokládá základní znalosti konceptů Kubernetes. Další informace najdete v tématu Základní koncepty Kubernetes pro Službu Azure Kubernetes Service (AKS).

Vytvoření skupiny zdrojů

Skupina prostředků Azure je logická skupina, ve které se nasazují a spravují prostředky Azure. Při vytváření skupiny prostředků se zobrazí výzva k zadání umístění. Toto umístění je umístění úložiště metadat vaší skupiny prostředků a místo, kde vaše prostředky běží v Azure, pokud během vytváření prostředků nezadáte jinou oblast.

Následující příklad vytvoří skupinu prostředků myResourceGroup v umístění eastus.

  • Vytvořte skupinu prostředků pomocí rutiny New-AzResourceGroup .

    New-AzResourceGroup -Name myResourceGroup -Location eastus
    

    Následující příklad výstupu se podobá úspěšnému vytvoření skupiny prostředků:

    ResourceGroupName : myResourceGroup
    Location          : eastus
    ProvisioningState : Succeeded
    Tags              :
    ResourceId        : /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup
    

Vytvoření clusteru AKS

K vytvoření clusteru AKS použijte rutinu New-AzAksCluster . Následující příklad vytvoří cluster myAKSCluster s jedním uzlem a povolí spravovanou identitu přiřazenou systémem.

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

Po několika minutách se příkaz dokončí a vrátí informace o clusteru.

Poznámka:

Při vytváření clusteru AKS se automaticky vytvoří druhá skupina prostředků pro uložení prostředků AKS. Další informace najdete v tématu Proč se v AKS vytvářejí dvě skupiny prostředků?

Připojení ke clusteru

Ke správě clusteru Kubernetes použijte klienta příkazového řádku Kubernetes kubectl. kubectl je už nainstalovaný, pokud používáte Azure Cloud Shell. Pokud chcete nainstalovat kubectl místně, zavolejte rutinu Install-AzAksCliTool .

  1. Nakonfigurujte kubectl připojení ke clusteru Kubernetes pomocí rutiny Import-AzAksCredential . Tento příkaz stáhne přihlašovací údaje a nakonfiguruje rozhraní příkazového řádku Kubernetes tak, aby je používalo.

    Import-AzAksCredential -ResourceGroupName myResourceGroup -Name myAKSCluster
    
  2. Pomocí příkazu kubectl get ověřte připojení ke clusteru. Tento příkaz vrátí seznam uzlů clusteru.

    kubectl get nodes
    

    Následující příklad výstupu ukazuje jeden uzel vytvořený v předchozích krocích. Ujistěte se, že je stav uzlu Připravený.

    NAME                                STATUS   ROLES   AGE     VERSION
    aks-nodepool1-11853318-vmss000000   Ready    agent   2m26s   v1.27.7
    

Nasazení aplikace

K nasazení aplikace použijete soubor manifestu k vytvoření všech objektů potřebných ke spuštění aplikace AKS Store. Soubor manifestu Kubernetes definuje požadovaný stav clusteru, například které image kontejneru se mají spustit. Manifest zahrnuje následující nasazení a služby Kubernetes:

Screenshot of Azure Store sample architecture.

  • Store front: Webová aplikace pro zákazníky k zobrazení produktů a objednávání.
  • Produktová služba: Zobrazuje informace o produktu.
  • Objednávka: Objednávky.
  • Rabbit MQ: Fronta zpráv pro frontu objednávek.

Poznámka:

Nedoporučujeme spouštět stavové kontejnery, jako je Rabbit MQ, bez trvalého úložiště pro produkční prostředí. Tady se používají pro zjednodušení, ale doporučujeme používat spravované služby, jako je Azure CosmosDB nebo Azure Service Bus.

  1. Vytvořte soubor s názvem aks-store-quickstart.yaml a zkopírujte ho v následujícím manifestu:

    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
    

    Rozpis souborů manifestu YAML najdete v tématu Nasazení a manifesty YAML.

    Pokud soubor YAML vytvoříte a uložíte místně, můžete soubor manifestu nahrát do výchozího adresáře v CloudShellu tak , že vyberete tlačítko Nahrát/Stáhnout soubory a vyberete soubor z místního systému souborů.

  2. Nasaďte aplikaci pomocí příkazu kubectl apply a zadejte název manifestu YAML.

    kubectl apply -f aks-store-quickstart.yaml
    

    Následující příklad výstupu ukazuje nasazení a služby:

    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
    

Testování aplikace

Když se aplikace spustí, služba Kubernetes zveřejní front-end aplikace na internetu. Dokončení tohoto procesu může trvat několik minut.

  1. Pomocí příkazu kubectl get pods zkontrolujte stav nasazených podů. Než budete pokračovat, udělejte všechny pody Running .

    kubectl get pods
    
  2. Zkontrolujte veřejnou IP adresu pro aplikaci store-front. Sledujte průběh pomocí příkazu kubectl get service s argumentem --watch .

    kubectl get service store-front --watch
    

    Výstup EXTERNAL-IP pro store-front službu se zpočátku zobrazuje jako čekající:

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
    store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m
    
  3. Jakmile se externí IP adresa změní z čekání na skutečnou kubectl veřejnou IP adresu, použijte CTRL-C k zastavení procesu sledování.

    Následující příklad výstupu ukazuje platnou veřejnou IP adresu přiřazenou službě:

    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. Otevřete webový prohlížeč na externí IP adresu vaší služby, abyste viděli aplikaci Azure Store v akci.

    Screenshot of AKS Store sample application.

Odstranění clusteru

Pokud nechcete projít kurzem AKS, vyčistěte nepotřebné prostředky, abyste se vyhnuli poplatkům za Azure. Odeberte skupinu prostředků, službu kontejneru a všechny související prostředky voláním rutiny Remove-AzResourceGroup .

Remove-AzResourceGroup -Name myResourceGroup

Poznámka:

Cluster AKS byl vytvořen se spravovanou identitou přiřazenou systémem (výchozí možnost identity použitá v tomto rychlém startu), identita se spravuje platformou a nevyžaduje odebrání.

Další kroky

V tomto rychlém startu jste nasadili cluster Kubernetes a pak jste do něj nasadili jednoduchou vícekontenerovou aplikaci. Tato ukázková aplikace slouží jenom pro ukázkové účely a nepředstavuje všechny osvědčené postupy pro aplikace Kubernetes. Pokyny k vytváření úplných řešení pomocí AKS pro produkční prostředí najdete v pokynech k řešení AKS.

Pokud chcete získat další informace o AKS a projít si kompletní příklad nasazení kódu na nasazení, pokračujte kurzem clusteru Kubernetes.