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

Ga aan de slag met Azure ACL (Container Linux) voor AKS door een AKS-cluster te implementeren met behulp van de Azure CLI.

In deze snelstart leert u de volgende zaken:

Maak een AKS-cluster met behulp van ACL voor AKS.
Implementeer het cluster met behulp van 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.

Important

Als u Azure ACL (Container Linux) op AKS gebruikt, controleert u de volgende overwegingen en beperkingen:

ACL is algemeen beschikbaar vanaf AKS v1.34.
ACL vereist vertrouwde start met beveiligd opstarten en vTPM. Niet-vertrouwde opstartvarianten zijn niet beschikbaar.
ACL op Arm64 vereist op Cobalt gebaseerde SKU's (v6) om compatibiliteit met Trusted Launch te ondersteunen.
NodeImage en None zijn de enige ondersteunde besturingssysteem-upgradekanalen. Unmanaged en SecurityPatch zijn niet compatibel met ACL vanwege de onveranderbare /usr map.
Artefactstreaming wordt niet ondersteund.
Pod Sandboxing wordt niet ondersteund.
Confidential Virtual Machines (CVM's) worden niet ondersteund.
Vm's van generatie 1 worden niet ondersteund.

Prerequisites

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 u liever CLI-referentieopdrachten lokaal uitvoert, installeert u 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 de Azure CLI met behulp van 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 hierom wordt gevraagd, installeert u de Azure CLI-extensie bij het eerste gebruik. Zie Extensies gebruiken en beheren met de Azure CLIvoor meer informatie over extensies.
- U hebt Azure CLI versie 2.86.0 of hoger nodig. Voer az version uit om de versie en afhankelijke bibliotheken te vinden die zijn geïnstalleerd. Als u wilt upgraden naar de nieuwste versie, voert u az upgrade uit.
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 vereiste resourceproviders registreren

Mogelijk moet u de vereiste resourceproviders registreren, zoals Microsoft.ContainerService in uw Azure-abonnement.

Registratiestatus controleren

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

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

De resource-aanbieder registreren

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

az provider register --namespace Microsoft.ContainerService

Omgevingsvariabelen definiëren

Definieer de volgende omgevingsvariabelen voor gebruik in deze quickstart. U kunt de waarden desgewenst vervangen door uw eigen aangepaste namen.

export RESOURCE_GROUP="myAKSResourceGroup"
export REGION="westus"
export CLUSTER_NAME="myAKSCluster"

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 $RESOURCE_GROUP \
  --location $REGION

Voorbeelduitvoer:

{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/myAKSResourceGroup",
  "location": "westus",
  "managedBy": null,
  "name": "myAKSResourceGroup",
  "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. De parameter --os-sku AzureContainerLinux configureert de systeemknooppuntpool om ACL te gebruiken als besturingssysteem voor de knooppunten. 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 $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --os-sku AzureContainerLinux \
  --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.

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 $RESOURCE_GROUP \
  --name $CLUSTER_NAME
```
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.

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.

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.

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
```
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
```
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 $RESOURCE_GROUP

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.

In deze quickstart hebt u een AKS-cluster met ACL voor AKS geïmplementeerd met behulp van Azure CLI. Zie Azure Container Linux (ACL) voor Azure Kubernetes Service (AKS) voor meer informatie over ACL voor AKS.

Feedback

Is deze pagina nuttig?

Last updated on 2026-06-03

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

Prerequisites

De vereiste resourceproviders registreren

Registratiestatus controleren

De resource-aanbieder registreren

Omgevingsvariabelen definiëren

Een brongroep maken

Een AKS-cluster maken

Verbinding maken met het cluster

De toepassing implementeren

De toepassing testen

Het cluster verwijderen

Verwante inhoud

Feedback

Aanvullende resources