Quickstart: Een AKS-cluster (Azure Kubernetes Service) implementeren met Flatcar Container Linux voor AKS (preview) met behulp van Azure CLI

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:

• Een AKS-cluster maken met Flatcar Container Linux voor AKS (preview).
• 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.

Opmerking

Dit artikel bevat 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.

• Als u geen Azure-account hebt, maak dan een gratis account aan voordat u begint.

• Gebruik de Bash-omgeving in Azure Cloud Shell. Zie Aan de slag met Azure Cloud Shell voor meer informatie.

  

• Als je de voorkeur geeft aan het lokaal uitvoeren van CLI-referentiecommando's, installeer dan de Azure CLI. Als je op Windows of macOS werkt, overweeg dan om Azure CLI in een Docker-container uit te voeren. Voor meer informatie, zie Hoe u de Azure CLI in een Docker-container kunt uitvoeren.

  • Als u een lokale installatie gebruikt, meldt u zich aan bij Azure CLI met de opdracht az login. Om het authenticatieproces te voltooien, volgt u de stappen die op uw terminal worden weergegeven. Zie Verifiëren bij Azure met behulp van Azure CLI voor andere aanmeldingsopties.

  • Wanneer u daarom wordt gevraagd, installeer de Azure CLI-extensie bij het eerste gebruik. Zie Extensies gebruiken en beheren met de Azure CLIvoor meer informatie over extensies.

  • Voer az version uit om de geïnstalleerde versie en de afhankelijke bibliotheken te vinden. Voer az upgrade uit om naar de nieuwste versie te upgraden.

• 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 az account set opdracht. Zie Azure-abonnementen beheren - Azure CLI voor meer informatie.
• Afhankelijk van uw Azure-abonnement moet u mogelijk een verhoging van het vCPU-quotum aanvragen. Zie Vm-family vCPU-quota verhogen voor meer informatie.

De leveranciers van bronnen registreren

Mogelijk moet u resourceproviders registreren in uw Azure-abonnement. Bijvoorbeeld is Microsoft.ContainerService vereist.

Controleer de registratiestatus met behulp van de az provider show opdracht.

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

Registreer indien nodig de resourceprovider met behulp van de opdracht az provider register .

az provider register --namespace Microsoft.ContainerService

Extensie installeren aks-preview

Belangrijk

AKS preview-functies zijn beschikbaar op selfservice, opt-in basis. Previews worden geleverd 'zoals het is' en 'voor zover beschikbaar' en zijn uitgesloten van de serviceovereenkomsten en beperkte garantie. AKS-previews worden gedeeltelijk gedekt door klantondersteuning naar best vermogen. Zodoende zijn deze functies niet bedoeld voor productiegebruik. Zie de volgende ondersteuningsartikelen voor meer informatie:

• Ondersteuningsbeleid voor AKS
• Veelgestelde vragen over ondersteuning voor Azure

1. Installeer de aks-preview Azure CLI-extensie met behulp van de az extension add opdracht.

   az extension add --name aks-preview
   

2. Werk bij naar de nieuwste versie van de extensie met behulp van de az extension update opdracht. Flatcar Container Linux vereist minimaal 18.0.0b42.

   az extension update --name aks-preview
   

Registreer functiekenmerk AKSFlatcarPreview

1. Registreer de AKSFlatcarPreview functievlag met behulp van de az feature register opdracht.

   az feature register --namespace "Microsoft.ContainerService" --name "AKSFlatcarPreview"
   

2. Controleer de registratiestatus met behulp van de az feature show opdracht. Het duurt enkele minuten voordat de status Geregistreerd wordt weergegeven.

   az feature show --namespace Microsoft.ContainerService --name AKSFlatcarPreview
   

3. Wanneer de status Geregistreerd aangeeft, vernieuwt u de registratie van de Microsoft.ContainerService-resourceprovider met behulp van de az provider register-opdracht.

   az provider register --namespace Microsoft.ContainerService
   

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="westus"
export MY_AKS_CLUSTER_NAME="myAKSCluster$RANDOM_ID"

De waarde van de RANDOM_ID variabele is een alfanumerieke waarde van zes tekens die is toegevoegd aan de resourcegroep en de clusternaam, zodat de namen uniek zijn. Gebruik de echo opdracht om variabele waarden weer te geven, zoals echo $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

Voorbeelduitvoer:

{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/myAKSResourceGroup<randomIDValue>",
  "location": "westus",
  "managedBy": null,
  "name": "myAKSResourceGroup<randomIDValue>",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Een AKS-cluster maken

• Maak een AKS-cluster met behulp van de opdracht az aks create. 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 \
  --os-sku flatcar \
  --node-count 1 \
  --generate-ssh-keys

Opmerking

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 om verbinding te maken met uw Kubernetes-cluster met behulp van het az aks get-credentials commando. Bij deze opdracht worden inloggegevens gedownload en wordt de Kubernetes CLI geconfigureerd om deze te gebruiken.

   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 kubectl get opdracht. 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:

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

Opmerking

We raden u niet aan stateful containers te draaien, zoals RabbitMQ, zonder blijvende opslag voor productie. We gebruiken het hier voor het gemak, maar we raden u aan beheerde services te gebruiken, zoals Azure Cosmos DB of Azure Service Bus.

1. Maak een bestand met de naam aks-store-quickstart.yaml en kopieer het 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 Cloud Shell 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
   

   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 gereed 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 afwachting:

   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 van pending in een openbaar IP-adres, gebruikt u CTRL-C 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.

   

Het cluster verwijderen

Als u niet van plan bent om de AKS-zelfstudie te doorlopen, moet u overbodige resources opschonen om Azure-factureringskosten te voorkomen.

• Verwijder de resourcegroep, containerservice en alle gerelateerde resources met behulp van de az group delete opdracht.

  az group delete --name $MY_RESOURCE_GROUP_NAME
  

  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 uitvoeren, gaat u verder met de zelfstudie over het Kubernetes-cluster.

AKS-handleiding