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

In deze quickstart gebruikt u de Azure CLI om een Azure Kubernetes Service (AKS)-cluster te maken dat Azure Container Linux (ACL) uitvoert als het knooppuntbesturingssysteem (OS). Nadat u het cluster hebt geïmplementeerd, maakt u er verbinding mee met behulp van kubectl en controleert u of de ACL-knooppunten worden uitgevoerd zoals verwacht.

Overwegingen en beperkingen

Voordat u begint, bekijk de volgende overwegingen en beperkingen voor ACL:

Prerequisites

Opmerking

U kunt Azure Cloud Shell of een lokale installatie van de Azure CLI gebruiken om de opdrachten in deze quickstart uit te voeren.

Registreer de resourceprovider Microsoft.ContainerService

Mogelijk moet u resourceproviders registreren in uw Azure-abonnement. 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 az provider register opdracht.

az provider register --namespace Microsoft.ContainerService

Een brongroep maken

Een Azure-resourcegroep is een logische groep waarin Azure-resources worden geïmplementeerd en beheerd. Wanneer u een resourcegroep maakt, moet u een locatie opgeven. Deze locatie is:

  • De opslaglocatie van de metagegevens van de resourcegroep.
  • Waar uw resources worden uitgevoerd in Azure als u geen andere regio opgeeft bij het maken van een resource.

Maak een resourcegroep met behulp van de az group create opdracht. In het volgende voorbeeld worden omgevingsvariabelen ingesteld voor de naam van de resourcegroep, regio en AKS-clusternaam en wordt vervolgens een resourcegroep op de opgegeven locatie gemaakt. U kunt de waarden van de omgevingsvariabelen vervangen door uw eigen voorkeursnamen en regio.

export MY_RESOURCE_GROUP_NAME="myACLResourceGroup"
export REGION="westus"
export MY_AKS_CLUSTER_NAME="myACLCluster"

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

Voorbeelduitvoer:

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

Een ACL-cluster maken

Maak een AKS-cluster met de opdracht az aks create en de parameter --os-sku AzureContainerLinux om het AKS-cluster te implementeren met een ACL-installatiekopie.

az aks create \
  --resource-group $MY_RESOURCE_GROUP_NAME \
  --name $MY_AKS_CLUSTER_NAME \
  --os-sku AzureContainerLinux \
  --node-count 3 \
  --generate-ssh-keys

Na enkele minuten is de opdracht voltooid en retourneert deze informatie over het cluster in JSON-indeling.

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. Met 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.
  • Rabbit MQ: Berichtensysteem voor een bestelwachtrij.

Opmerking

We raden aan om stateful containers, zoals RabbitMQ, niet te gebruiken zonder permanente opslag voor productie. Deze worden hier gebruikt 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 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
---
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

  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: $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

echo "http://$IP_ADDRESS"

Het cluster verwijderen

Als u niet van plan bent om door de zelfstudies te gaan, moet u onnodige resources opschonen om Azure kosten 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 --yes --no-wait

Verwante inhoud

Zie Wat is Azure Container Linux (ACL) voor Azure Kubernetes Service (AKS)? voor meer informatie over ACL voor AKS.

  • Last updated on