Freigeben über


Schnellstart: Bereitstellen eines Clusters für den Azure Linux-Containerhost für AKS mithilfe der Azure CLI

Führen Sie erste Schritte mit dem Azure Linux-Containerhost mithilfe der Azure CLI aus, um einen Cluster für den Azure Linux-Containerhost für AKS bereitzustellen. Nach der Installation der erforderlichen Komponenten erstellen Sie eine Ressourcengruppe und einen AKS-Cluster, stellen eine Verbindung mit dem Cluster her und führen eine Beispielanwendung mit mehreren Containern im Cluster aus.

Voraussetzungen

Erstellen einer Ressourcengruppe

Eine Azure-Ressourcengruppe ist eine logische Gruppe, in der Azure-Ressourcen bereitgestellt und verwaltet werden. Beim Erstellen einer Ressourcengruppe muss ein Standort angegeben werden. Bei diesem Speicherort handelt es sich um Folgendes:

  • Speicherort der Metadaten der Ressourcengruppe
  • Ausführungsort für Ihre Ressourcen in Azure, sofern Sie bei der Ressourcenerstellung keine andere Region angeben.

Erstellen Sie mit dem Befehl az group create eine Ressourcengruppe.

export RANDOM_ID="$(openssl rand -hex 3)"
export MY_RESOURCE_GROUP_NAME="myAzureLinuxResourceGroup$RANDOM_ID"
export REGION="westeurope"

az group create --name $MY_RESOURCE_GROUP_NAME --location $REGION

Ergebnisse:

{
  "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/$MY_RESOURCE_GROUP_NAMExxxxxx",
  "location": "$REGION",
  "managedBy": null,
  "name": "$MY_RESOURCE_GROUP_NAME",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Erstellen eines Azure Linux-Containerhostclusters

Erstellen Sie einen AKS-Cluster mithilfe des Befehls az aks create mit dem Parameter --os-sku, um den AKS-Cluster mit einem Azure Linux-Image bereitzustellen.

export MY_AZ_CLUSTER_NAME="myAzureLinuxCluster$RANDOM_ID"

az aks create --name $MY_AZ_CLUSTER_NAME --resource-group $MY_RESOURCE_GROUP_NAME --os-sku AzureLinux

Nach wenigen Minuten ist die Ausführung des Befehls abgeschlossen, und es werden Informationen zum Cluster im JSON-Format zurückgegeben.

Herstellen einer Verbindung mit dem Cluster

Verwenden Sie zum Verwalten eines Kubernetes-Clusters den Kubernetes-Befehlszeilenclient kubectl. kubectl ist bei Verwendung von Azure Cloud Shell bereits installiert. Um kubectl lokal zu installieren, verwenden Sie den Befehl az aks install-cli.

  1. Mit dem Befehl az aks get-credentials können Sie kubectl für die Verbindungsherstellung mit Ihrem Kubernetes-Cluster konfigurieren. Mit diesem Befehl werden die Anmeldeinformationen heruntergeladen und die Kubernetes-CLI für ihre Verwendung konfiguriert.

    az aks get-credentials --resource-group $MY_RESOURCE_GROUP_NAME --name $MY_AZ_CLUSTER_NAME
    
  2. Überprüfen Sie die Verbindung mit dem Cluster mithilfe des Befehls kubectl get. Dieser Befehl gibt eine Liste der Clusterknoten zurück.

    kubectl get nodes
    

Bereitstellen der Anwendung

Zum Bereitstellen der Anwendung verwenden Sie eine Manifestdatei, um alle Objekte zu erstellen, die für die Ausführung der AKS Store-Anwendungerforderlich sind. Eine Kubernetes-Manifestdatei definiert den gewünschten Zustand (Desired State) eines Clusters – also beispielsweise, welche Containerimages ausgeführt werden sollen. Das Manifest umfasst die folgenden Kubernetes-Bereitstellungen und -Dienste:

Screenshot: Beispielarchitektur für einen Azure-Store.

  • Store Front: Webanwendung für Kund*innen zum Anzeigen von Produkten und Aufgeben von Bestellungen
  • Product Service: zeigt Produktinformationen an.
  • Order Service: dient der Aufgabe von Bestellungen.
  • Rabbit MQ: Nachrichtenwarteschlange für eine Bestellwarteschlange

Hinweis

Zustandsbehaftete Container wie Rabbit MQ sollten nicht ohne permanenten Speicher für die Produktion ausgeführt werden. Sie werden hier der Einfachheit halber verwendet, jedoch sollten verwaltete Dienste wie Azure CosmosDB oder Azure Service Bus verwendet werden.

  1. Erstellen Sie eine Datei namens aks-store-quickstart.yaml, und fügen Sie das folgende Manifest ein:

    apiVersion: apps/v1
    kind: StatefulSet
    metadata:
      name: rabbitmq
    spec:
      serviceName: rabbitmq
      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
            startupProbe:
              httpGet:
                path: /health
                port: 3000
              failureThreshold: 5
              initialDelaySeconds: 20
              periodSeconds: 10
            readinessProbe:
              httpGet:
                path: /health
                port: 3000
              failureThreshold: 3
              initialDelaySeconds: 3
              periodSeconds: 5
            livenessProbe:
              httpGet:
                path: /health
                port: 3000
              failureThreshold: 5
              initialDelaySeconds: 3
              periodSeconds: 3
          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
            env: 
            - name: AI_SERVICE_URL
              value: "http://ai-service:5001/"
            resources:
              requests:
                cpu: 1m
                memory: 1Mi
              limits:
                cpu: 2m
                memory: 20Mi
            readinessProbe:
              httpGet:
                path: /health
                port: 3002
              failureThreshold: 3
              initialDelaySeconds: 3
              periodSeconds: 5
            livenessProbe:
              httpGet:
                path: /health
                port: 3002
              failureThreshold: 5
              initialDelaySeconds: 3
              periodSeconds: 3
    ---
    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
            startupProbe:
              httpGet:
                path: /health
                port: 8080
              failureThreshold: 3
              initialDelaySeconds: 5
              periodSeconds: 5
            readinessProbe:
              httpGet:
                path: /health
                port: 8080
              failureThreshold: 3
              initialDelaySeconds: 3
              periodSeconds: 3
            livenessProbe:
              httpGet:
                path: /health
                port: 8080
              failureThreshold: 5
              initialDelaySeconds: 3
              periodSeconds: 3
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: store-front
    spec:
      ports:
      - port: 80
        targetPort: 8080
      selector:
        app: store-front
      type: LoadBalancer
    

    Wenn Sie die YAML-Datei lokal erstellen und speichern, können Sie die Manifestdatei in Ihr Standardverzeichnis in CloudShell hochladen, indem Sie die Schaltfläche Dateien hochladen/herunterladen auswählen und die Datei aus Ihrem lokalen Dateisystem auswählen.

  2. Stellen Sie die Anwendung über den Befehl „kubectl apply“ bereit, und geben Sie den Namen Ihres YAML-Manifests an.

    kubectl apply -f aks-store-quickstart.yaml
    

Testen der App

Sie können überprüfen, ob die Anwendung ausgeführt wird, indem Sie die öffentliche IP-Adresse oder die Anwendungs-URL aufrufen.

Rufen Sie die Anwendungs-URL mit den folgenden Befehlen ab:

runtime="5 minutes"
endtime=$(date -ud "$runtime" +%s)
while [[ $(date -u +%s) -le $endtime ]]
do
   STATUS=$(kubectl get pods -l app=store-front -o 'jsonpath={..status.conditions[?(@.type=="Ready")].status}')
   echo $STATUS
   if [ "$STATUS" == 'True' ]
   then
      export IP_ADDRESS=$(kubectl get service store-front --output 'jsonpath={..status.loadBalancer.ingress[0].ip}')
      echo "Service IP Address: $IP_ADDRESS"
      break
   else
      sleep 10
   fi
done
curl $IP_ADDRESS

Ergebnisse:

<!doctype html>
<html lang="">
   <head>
      <meta charset="utf-8">
      <meta http-equiv="X-UA-Compatible" content="IE=edge">
      <meta name="viewport" content="width=device-width,initial-scale=1">
      <link rel="icon" href="/favicon.ico">
      <title>store-front</title>
      <script defer="defer" src="/js/chunk-vendors.df69ae47.js"></script>
      <script defer="defer" src="/js/app.7e8cfbb2.js"></script>
      <link href="/css/app.a5dc49f6.css" rel="stylesheet">
   </head>
   <body>
      <div id="app"></div>
   </body>
</html>
echo "You can now visit your web server at $IP_ADDRESS"

Löschen des Clusters

Wenn Sie sie nicht mehr benötigen, können Sie unnötige Ressourcen bereinigen, um Azure-Gebühren zu vermeiden. Sie können die Ressourcengruppe, den Containerdienst und alle zugehörigen Ressourcen mithilfe des Befehls az group delete entfernen.

Nächste Schritte

In dieser Schnellstartanleitung haben Sie einen Azure Linux-Containerhostcluster bereitgestellt. Weitere Informationen zum Azure Linux-Containerhost und ein vollständiges Beispiel für die Clusterbereitstellung und -verwaltung finden Sie im Tutorial zum Azure Linux-Containerhost.