Share via


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

Azure Kubernetes Service (AKS) is een beheerde Kubernetes-service waarmee u snel clusters kunt implementeren en beheren. In deze snelstart, gaat u het volgende doen:

  • Implementeer een AKS-cluster met behulp van Azure Portal.
  • 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.

Notitie

De Azure Linux-knooppuntgroep is nu algemeen beschikbaar (GA). Zie de inleiding tot de Azure Linux-containerhost voor AKS voor meer informatie over de voordelen en implementatiestappen.

Een AKS-cluster maken

  1. Meld u aan bij het Azure-portaal.

  2. Selecteer Een resource maken op de startpagina van Azure Portal.

  3. Selecteer Containers>Azure Kubernetes Service (AKS) in de sectie Categorieën.

  4. Configureer op het tabblad Basisbeginselen de volgende instellingen:

    • Onder Projectdetails:
      • Abonnement: Selecteer het Azure-abonnement dat u wilt gebruiken voor dit AKS-cluster.
      • Resourcegroep: Selecteer Nieuwe maken, voer een resourcegroepnaam in, zoals myResourceGroup, en selecteer vervolgens OK. Hoewel u een bestaande resourcegroep kunt selecteren voor test- of evaluatiedoeleinden, raden we u aan om een resourcegroep te maken om deze resources tijdelijk te hosten en te voorkomen dat dit van invloed is op uw productie- of ontwikkelworkloads.
    • Onder Clusterdetails:
      • Vooraf ingestelde clusterconfiguratie: Selecteer Dev/Test. Zie Voorinstellingen voor clusterconfiguraties in Azure Portal voor meer informatie over vooraf ingestelde configuraties.

        Notitie

        U kunt de vooraf ingestelde configuratie wijzigen bij het maken van uw cluster door voorinstellingen vergelijken te selecteren en een andere optie te kiezen. Schermopname van vooraf ingestelde opties voor AKS-cluster maken - portal.

      • Kubernetes-clusternaam: Voer een clusternaam in, zoals myAKSCluster.

      • Regio: Selecteer een regio, zoals VS - oost 2.

      • Beschikbaarheidszones: Selecteer Geen.

      • AKS-prijscategorie: Selecteer Gratis.

      • Laat de standaardwaarden voor de overige instellingen staan en selecteer Volgende.

        Schermopname die laat zien hoe u een AKS-cluster configureert in Azure Portal.

  5. Configureer op het tabblad Knooppuntgroepen de volgende instellingen:

    • Selecteer Knooppuntgroep toevoegen en voer de naam van een knooppuntgroep in, zoals nplinux.

    • Modus: Selecteer Gebruiker.

    • OS-SKU: Selecteer Ubuntu Linux.

    • Beschikbaarheidszones: Selecteer Geen.

    • Laat het selectievakje Azure Spot-exemplaren inschakelen uitgeschakeld.

    • Knooppuntgrootte: selecteer Een grootte kiezen. Selecteer op de pagina Een VM-grootte selecteren D2s_v3 en selecteer vervolgens Selecteren.

    • Laat de standaardwaarden voor de overige instellingen staan en selecteer Toevoegen.

      Schermopname van het maken van een knooppuntgroep met Ubuntu Linux.

  6. Selecteer Beoordelen en maken om validatie uit te voeren in de clusterconfiguratie. Nadat de validatie is voltooid, selecteert u Maken.

    Het duurt enkele minuten om het AKS-cluster te maken. Wanneer uw implementatie is voltooid, gaat u naar uw resource door Naar de resource te gaan of door naar de AKS-clusterresourcegroep te bladeren en de AKS-resource te selecteren.

Verbinding maken met het cluster

U gebruikt de Kubernetes-opdrachtregelclient, kubectl, om Kubernetes-clusters te beheren. kubectl is al geïnstalleerd als u Azure Cloud Shell gebruikt. Als u niet bekend bent met Cloud Shell, raadpleegt u Overzicht van Azure Cloud Shell.

Als u Cloud Shell gebruikt, opent u deze met de >_ knop boven aan Azure Portal. Als u PowerShell lokaal gebruikt, maakt u via de Connect-AzAccount opdracht verbinding met Azure. Als u Azure CLI lokaal gebruikt, maakt u verbinding met Azure via de az login opdracht.

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

    az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
    
  2. Controleer de verbinding met uw cluster met behulp van kubectl get een lijst met de clusterknooppunten.

    kubectl get nodes
    

    In de volgende voorbeelduitvoer ziet u het enkele knooppunt dat is gemaakt in de vorige stappen. Zorg ervoor dat de status van het knooppunt gereed is.

    NAME                                STATUS   ROLES   AGE       VERSION
    aks-nodepool1-31718369-0   Ready    agent    6m44s   v1.15.10
    

De toepassing implementeren

U gebruikt 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. Open in Cloud Shell een editor en maak een bestand met de naam aks-store-quickstart.yaml.

  2. Plak het volgende manifest in de editor:

    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
    

    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.

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

    In de volgende voorbeelduitvoer ziet u de implementaties en services:

    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
    

De toepassing testen

Wanneer de toepassing wordt uitgevoerd, maakt een Kubernetes-service de front-end van de toepassing beschikbaar op internet. Dit proces kan enkele minuten duren.

  1. Controleer de status van de geïmplementeerde pods met behulp van de kubectl get pods opdracht. Zorg ervoor dat alle pods zijn Running voordat u doorgaat.

    kubectl get pods
    
  2. Controleer op een openbaar IP-adres voor de store-front toepassing. Bewaak de voortgang met behulp van de kubectl get service opdracht met het --watch argument.

    kubectl get service store-front --watch
    

    De UITVOER VAN HET EXTERNE IP-adres voor de store-front service wordt in eerste instantie weergegeven als in behandeling:

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
    store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m
    

    Zodra het EXTERNAL-IP-adres is gewijzigd in een daadwerkelijk openbaar IP-adres, gebruikt CTRL-C u dit om het kubectl controleproces te stoppen.

    In de volgende voorbeelduitvoer ziet u een geldig openbaar IP-adres dat aan de service is toegewezen:

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)        AGE
    store-front   LoadBalancer   10.0.100.10   20.62.159.19   80:30025/TCP   4h5m
    
  3. Open een webbrowser naar het externe IP-adres van uw service om de Azure Store-app in actie te zien.

    Schermopname van de AKS Store-voorbeeldtoepassing.

Het cluster verwijderen

Als u niet van plan bent om de reeks AKS-zelfstudies te doorlopen, moet u onnodige resources opschonen om Azure-kosten te voorkomen.

  1. Navigeer in Azure Portal naar uw AKS-clusterresourcegroep.

  2. Selecteer Resourcegroep verwijderen.

  3. Voer de naam in van de resourcegroep die u wilt verwijderen en selecteer Vervolgens Verwijderen verwijderen>.

    Notitie

    Het AKS-cluster is gemaakt met een door het systeem toegewezen beheerde identiteit. Deze identiteit wordt beheerd door het platform en vereist geen verwijdering.

Volgende stappen

In deze quickstart hebt u een Kubernetes-cluster geïmplementeerd en vervolgens een eenvoudige toepassing met meerdere containers 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 doorloopt, gaat u verder met de reeks zelfstudies voor Kubernetes-clusters.