Delen via


Quickstart: Een AKS-cluster (Azure Kubernetes Service) implementeren met behulp van Azure CLI

Implementeren op Azure

Azure Kubernetes Service (AKS) is een beheerde Kubernetes-service waarmee u snel clusters kunt implementeren en beheren. In deze snelstart leert u de volgende zaken:

  • Implementeer een AKS-cluster met behulp van de Azure CLI.
  • Voer een voorbeeldtoepassing met meerdere containers uit met een groep microservices en webfront-ends die een retailscenario simuleren.

Notitie

Om snel aan de slag te gaan met het snel inrichten van een AKS-cluster, bevat dit artikel stappen voor het implementeren van een cluster met alleen standaardinstellingen voor evaluatiedoeleinden. Voordat u een cluster implementeert dat gereed is voor productie, raden we u aan vertrouwd te raken met de referentiearchitectuur van de basislijn om na te gaan hoe dit overeenkomt met uw bedrijfsvereisten.

Voordat u begint

In deze snelstart wordt ervan uitgegaan dat u een basisbegrip hebt van Kubernetes-concepten. Zie Kubernetes-kernconcepten voor Azure Kubernetes Service (AKS) voor meer informatie.

  • Voor dit artikel is versie 2.0.64 of hoger van Azure CLI vereist. Als u Azure Cloud Shell gebruikt, is de nieuwste versie daar al geïnstalleerd.
  • Zorg ervoor dat de identiteit die u gebruikt om uw cluster te maken de juiste minimale machtigingen heeft. Zie Toegangs- en identiteitsopties voor Azure Kubernetes Service (AKS) voor meer informatie over toegang en identiteit voor AKS.
  • Als u meerdere Azure-abonnementen hebt, selecteert u de juiste abonnements-id waarin de resources moeten worden gefactureerd met behulp van de opdracht az account set . Zie Azure-abonnementen beheren - Azure CLI voor meer informatie.

Omgevingsvariabelen definiëren

Definieer de volgende omgevingsvariabelen voor gebruik in deze quickstart:

export RANDOM_ID="$(openssl rand -hex 3)"
export MY_RESOURCE_GROUP_NAME="myAKSResourceGroup$RANDOM_ID"
export REGION="westeurope"
export MY_AKS_CLUSTER_NAME="myAKSCluster$RANDOM_ID"
export MY_DNS_LABEL="mydnslabel$RANDOM_ID"

Een brongroep maken

Een Azure-resourcegroep is een logische groep waarin Azure-resources worden geïmplementeerd en beheerd. Wanneer u een resourcegroep maakt, wordt u gevraagd een locatie op te geven. Deze locatie is de opslaglocatie van de metagegevens van uw resourcegroep en waar uw resources worden uitgevoerd in Azure als u geen andere regio opgeeft tijdens het maken van de resource.

Maak een resourcegroep met behulp van de az group create opdracht.

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

Resultaten:

{
  "id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myAKSResourceGroupxxxxxx",
  "location": "eastus",
  "managedBy": null,
  "name": "testResourceGroup",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Een AKS-cluster maken

Maak een AKS-cluster met behulp van de az aks create opdracht. In het volgende voorbeeld wordt een cluster met één knooppunt gemaakt en wordt een door het systeem toegewezen beheerde identiteit ingeschakeld.

az aks create \
    --resource-group $MY_RESOURCE_GROUP_NAME \
    --name $MY_AKS_CLUSTER_NAME \
    --node-count 1 \
    --generate-ssh-keys

Notitie

Wanneer u een nieuw cluster maakt, maakt AKS automatisch een tweede resourcegroep om de AKS-resources op te slaan. Zie voor meer informatie Waarom worden er twee resourcegroepen gemaakt met AKS?

Verbinding maken met het cluster

Als u een Kubernetes-cluster wilt beheren, gebruikt u de Kubernetes-opdrachtregelclient kubectl. kubectl is al geïnstalleerd als u Azure Cloud Shell gebruikt. Als u lokaal wilt installeren kubectl , gebruikt u de az aks install-cli opdracht.

  1. Configureer kubectl deze om verbinding te maken met uw Kubernetes-cluster met behulp van de opdracht az aks get-credentials . Bij deze opdracht worden referenties gedownload en wordt Kubernetes CLI geconfigureerd voor het gebruik van deze referenties.

    az aks get-credentials --resource-group $MY_RESOURCE_GROUP_NAME --name $MY_AKS_CLUSTER_NAME
    
  2. Controleer de verbinding met uw cluster met behulp van de opdracht kubectl get . Met deze opdracht wordt een lijst met de clusterknooppunten geretourneerd.

    kubectl get nodes
    

De toepassing implementeren

Als u de toepassing wilt implementeren, gebruikt u een manifestbestand om alle objecten te maken die nodig zijn om de AKS Store-toepassing uit te voeren. Een Kubernetes-manifestbestand definieert de gewenste status van een cluster, zoals welke containerinstallatiekopieën moeten worden uitgevoerd. Het manifest bevat de volgende Kubernetes-implementaties en -services:

Schermopname van azure Store-voorbeeldarchitectuur.

  • Webwinkel: Webtoepassing voor klanten om producten te bekijken en bestellingen te plaatsen.
  • Productservice: toont productgegevens.
  • Orderservice: Orders plaatsen.
  • Rabbit MQ: Berichtenwachtrij voor een orderwachtrij.

Notitie

Het is niet raadzaam stateful containers, zoals Rabbit MQ, uit te voeren zonder permanente opslag voor productie. Deze worden hier gebruikt voor het gemak, maar we raden u aan beheerde services te gebruiken, zoals Azure CosmosDB of Azure Service Bus.

  1. Maak een bestand met de naam aks-store-quickstart.yaml en kopieer dit in het volgende manifest:

    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
    

    Zie Implementaties en YAML-manifestmanifesten voor een uitsplitsing van YAML-manifestbestanden.

    Als u het YAML-bestand lokaal maakt en opslaat, kunt u het manifestbestand uploaden naar uw standaardmap in CloudShell door de knop Bestanden uploaden/downloaden te selecteren en het bestand in uw lokale bestandssysteem te selecteren.

  2. Implementeer de toepassing met behulp van de kubectl apply opdracht en geef de naam van uw YAML-manifest op.

    kubectl apply -f aks-store-quickstart.yaml
    

De toepassing testen

U kunt controleren of de toepassing wordt uitgevoerd door naar het openbare IP-adres of de toepassings-URL te gaan.

Haal de toepassings-URL op met behulp van de volgende opdrachten:

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

Resultaten:

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

Schermopname van de AKS Store-voorbeeldtoepassing.

Het cluster verwijderen

Als u niet van plan bent om de AKS-zelfstudie te doorlopen, moet u overbodige resources opschonen om Azure-kosten te voorkomen. U kunt de resourcegroep, containerservice en alle gerelateerde resources verwijderen met behulp van de az group delete opdracht.

Notitie

Het AKS-cluster is gemaakt met een door het systeem toegewezen beheerde identiteit. Dit is de standaardidentiteitsoptie die in deze quickstart wordt gebruikt. Het platform beheert deze identiteit, zodat u deze niet handmatig hoeft te verwijderen.

Volgende stappen

In deze quickstart hebt u een Kubernetes-cluster geïmplementeerd en vervolgens een eenvoudige toepassing met meerdere containers erop geïmplementeerd. Deze voorbeeldtoepassing is alleen bedoeld voor demodoeleinden en vertegenwoordigt niet alle aanbevolen procedures voor Kubernetes-toepassingen. Zie de richtlijnen voor AKS-oplossingen voor meer informatie over het maken van volledige oplossingen met AKS voor productie.

Als u meer wilt weten over AKS en een volledig voorbeeld van code-naar-implementatie wilt doorlopen, gaat u verder met de zelfstudie over het Kubernetes-cluster.