Snabbstart: Distribuera ett Azure Container Linux (ACL) för AKS-kluster med hjälp av en ARM-mall

Kom igång med Azure Container Linux (ACL) för AKS genom att distribuera ett AKS-kluster med hjälp av en Azure Resource Manager(ARM)-mall.

I den här snabbstarten lär du dig att:

  • Skapa ett AKS-kluster med hjälp av ACL för AKS.
  • Distribuera klustret med hjälp av en ARM-mall.
  • Kör ett exempelprogram med flera containrar med en grupp mikrotjänster och webbklientdelar som simulerar ett detaljhandelsscenario.

Note

För att komma igång med att snabbt etablera ett AKS-kluster innehåller den här artikeln steg för att distribuera ett kluster med standardinställningar endast i utvärderingssyfte. Innan du distribuerar ett produktionsklart kluster rekommenderar vi att du bekantar dig med vår referensarkitektur för baslinje för att överväga hur det överensstämmer med dina affärskrav.

Important

Om du använder Azure Container Linux (ACL) på AKS kontrollerar du att du granskar följande överväganden och begränsningar:

Förutsättningar

  • Den här artikeln förutsätter en grundläggande förståelse av Kubernetes-begrepp. Mer information finns i Kubernetes grundläggande begrepp för Azure Kubernetes Service (AKS).
  • Om du inte har något Azure-konto skapar du ett kostnadsfritt konto innan du börjar.
  • Kontrollera att den identitet som du använder för att skapa klustret har lämpliga minimibehörigheter. Mer information om åtkomst och identitet för AKS finns i Åtkomst- och identitetsalternativ för Azure Kubernetes Service (AKS).
  • För att distribuera en ARM-mall behöver du skrivåtkomst till de resurser som du distribuerar och åtkomst till alla åtgärder på resurstypen Microsoft.Resources/deployments. Till exempel, för att installera en virtuell dator behöver du Microsoft.Compute/virtualMachines/write och Microsoft.Resources/deployments/* behörigheter. Det finns en lista med roller och behörigheter i Inbyggda roller i Azure.

När du har distribuerat klustret från mallen kan du använda antingen Azure CLI eller Azure PowerShell för att ansluta till klustret och distribuera exempelprogrammet.

Registrera nödvändiga resursprovidrar

Du kan behöva registrera nödvändiga resursprovidrar, till exempel Microsoft.ContainerService i din Azure-prenumeration.

Kontrollera registreringsstatus

Kontrollera registreringsstatusen az provider show med kommandot .

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

Registrera resursprovidern

Om det behövs registrerar du resursprovidern Microsoft.ContainerService med hjälp av kommandot az provider register.

az provider register --namespace Microsoft.ContainerService

Skapa ett SSH-nyckelpar

Om du vill skapa ett AKS-kluster med hjälp av en ARM-mall anger du en offentlig SSH-nyckel. Om du behöver den här resursen följer du stegen i det här avsnittet. Annars går du vidare till avsnittet Granska mallen .

För att få åtkomst till AKS-noder ansluter du med ett SSH-nyckelpar (offentligt och privat) som du genererar med kommandot ssh-keygen . Som standard skapas dessa filer i katalogen ~/.ssh . ssh-keygen Kommandot skriver över alla SSH-nyckelpar med samma namn som redan finns på den angivna platsen. Mer information om hur du skapar SSH-nycklar finns i Skapa och hantera SSH-nycklar för autentisering i Azure.

  1. Gå till https://shell.azure.com för att öppna Cloud Shell i webbläsaren.

  2. Skapa en resursgrupp med kommandot az group create. I följande exempel skapas en resursgrupp med namnet myResourceGroup i regionen USA, östra :

    az group create \
  --name myResourceGroup \
  --location eastus

  3. Skapa ett SSH-nyckelpar med kommandot az sshkey create eller ssh-keygen kommandot .

    az sshkey create --name mySSHKey --resource-group myResourceGroup

    Eller skapa ett SSH-nyckelpar med hjälp av ssh-keygen:

    ssh-keygen -t rsa -b 4096

  4. Om du vill distribuera mallen måste du ange den offentliga nyckeln från SSH-paret. Hämta den offentliga nyckeln med kommandot az sshkey show .

    az sshkey show --name mySSHKey --resource-group myResourceGroup --query publicKey

Granska mallens layout

Följande distribution använder en ARM-mall från Azure Quickstart Templates:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "metadata": {
    "_generator": {
      "name": "bicep",
      "version": "0.26.170.59819",
      "templateHash": "14823542069333410776"
    }
  },
  "parameters": {
    "clusterName": {
      "type": "string",
      "defaultValue": "aks101cluster",
      "metadata": {
        "description": "The name of the Managed Cluster resource."
      }
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]",
      "metadata": {
        "description": "The location of the Managed Cluster resource."
      }
    },
    "dnsPrefix": {
      "type": "string",
      "metadata": {
        "description": "Optional DNS prefix to use with hosted Kubernetes API server FQDN."
      }
    },
    "osDiskSizeGB": {
      "type": "int",
      "defaultValue": 0,
      "minValue": 0,
      "maxValue": 1023,
      "metadata": {
        "description": "Disk size (in GB) to provision for each of the agent pool nodes. This value ranges from 0 to 1023. Specifying 0 will apply the default disk size for that agentVMSize."
      }
    },
    "agentCount": {
      "type": "int",
      "defaultValue": 3,
      "minValue": 1,
      "maxValue": 50,
      "metadata": {
        "description": "The number of nodes for the cluster."
      }
    },
    "agentVMSize": {
      "type": "string",
      "defaultValue": "standard_d2s_v3",
      "metadata": {
        "description": "The size of the Virtual Machine."
      }
    },
    "linuxAdminUsername": {
      "type": "string",
      "metadata": {
        "description": "User name for the Linux Virtual Machines."
      }
    },
    "sshRSAPublicKey": {
      "type": "string",
      "metadata": {
        "description": "Configure all linux machines with the SSH RSA public key string. Your key should include three parts, for example 'ssh-rsa AAAAB...snip...UcyupgH azureuser@linuxvm'"
      }
    }
  },
  "resources": [
    {
      "type": "Microsoft.ContainerService/managedClusters",
      "apiVersion": "2026-03-01",
      "name": "[parameters('clusterName')]",
      "location": "[parameters('location')]",
      "identity": {
        "type": "SystemAssigned"
      },
      "properties": {
        "dnsPrefix": "[parameters('dnsPrefix')]",
        "agentPoolProfiles": [
          {
            "name": "agentpool",
            "osDiskSizeGB": "[parameters('osDiskSizeGB')]",
            "count": "[parameters('agentCount')]",
            "vmSize": "[parameters('agentVMSize')]",
            "osType": "Linux",
            "osSKU": "AzureContainerLinux",
            "mode": "System"
          }
        ],
        "linuxProfile": {
          "adminUsername": "[parameters('linuxAdminUsername')]",
          "ssh": {
            "publicKeys": [
              {
                "keyData": "[parameters('sshRSAPublicKey')]"
              }
            ]
          }
        }
      }
    }
  ],
  "outputs": {
    "controlPlaneFQDN": {
      "type": "string",
      "value": "[reference(resourceId('Microsoft.ContainerService/managedClusters', parameters('clusterName')), '2026-03-01').fqdn]"
    }
  }
}

Resurstypen som definieras i ARM-mallen är Microsoft.ContainerService/managedClusters.

Fler AKS-exempel finns på webbplatsen för AKS-snabbstartsmallar .

Använd mallen

  1. Välj Distribuera till Azure för att logga in och öppna en mall.

    Button för att distribuera mallen Resource Manager till Azure.

  2. Konfigurera mallparametrarna på sidan Anpassad distribution . För den här snabbstarten lämnar du standardvärdena för OS Disk Size GB, Agent Count, Agent VM Size och OS Type. Ange dina egna värden för följande parametrar:

    • Prenumeration: Välj en Azure-prenumeration.
    • Resursgrupp: Välj Skapa ny. Ange ett unikt namn för resursgruppen, till exempel myResourceGroup, och välj sedan OK.
    • OS SKU: Ange AzureContainerLinux. Om du inte uppdaterar OS SKU är Ubuntustandardvärdet .
    • Plats: Välj en plats, till exempel USA, östra.
    • Klusternamn: Ange ett unikt namn för AKS-klustret, till exempel myAKSCluster.
    • DNS-prefix: Ange ett unikt DNS-prefix för klustret, till exempel myakscluster.
    • Användarnamn för Linux-administratör: Ange ett användarnamn för att ansluta med hjälp av SSH, till exempel azureuser.
    • Källa för offentlig SSH-nyckel: Välj Använd befintlig offentlig nyckel.
    • Nyckelparnamn: Kopiera och klistra in den offentliga delen av SSH-nyckelparet (som standard innehållet i ~/.ssh/id_rsa.pub).

  3. Välj Granska + skapa>Skapa.

Det tar några minuter att skapa AKS-klustret. Vänta tills klustret har framgångsrikt distribuerats innan du går vidare till nästa steg.

Anslut till klustret

Om du vill hantera ett Kubernetes-kluster använder du Kubernetes-kommandoradsklienten kubectl. Om du använder Azure Cloud Shell är kubectl redan installerat.

Om du vill installera och köra kubectl lokalt använder du az aks install-cli kommandot .

  1. Konfigurera kubectl för att ansluta till kubernetes-klustret med hjälp av az aks get-credentials kommandot . Det här kommandot laddar ned autentiseringsuppgifter och konfigurerar Kubernetes CLI för att använda dem.

    az aks get-credentials \
  --resource-group myResourceGroup \
  --name myAKSCluster

  2. Kontrollera anslutningen till klustret med hjälp av kubectl get kommandot . Det här kommandot returnerar en lista över klusternoderna.

    kubectl get nodes

    Följande exempelutdata visar de tre noder som skapades i föregående steg. Se till att nodens status är Ready:

    NAME                                STATUS   ROLES   AGE   VERSION
aks-agentpool-12345678-vmss000000   Ready    <none>   5m53s   v1.32.7
aks-agentpool-12345678-vmss000001   Ready    <none>   6m31s   v1.32.7
aks-agentpool-12345678-vmss000002   Ready    <none>   6m35s   v1.32.7

Distribuera programmet

För att distribuera programmet använder du en manifestfil för att skapa alla objekt som krävs för att köra AKS Store-programmet. En Kubernetes-manifestfil definierar ett klusters önskade tillstånd, till exempel vilka containeravbildningar som ska köras. Manifestet innehåller följande Kubernetes-distributioner och -tjänster:

Screenshot av Azure Store-exempelarkitektur.

  • Butiksfront: Webbprogram där kunder kan visa produkter och göra beställningar.
  • Produkttjänst: Visar produktinformation.
  • Ordertjänst: Gör beställningar.
  • Rabbit MQ: Meddelandekö för en beställningskö.

Note

Vi rekommenderar inte att du kör tillståndskänsliga containrar, till exempel RabbitMQ, utan beständig lagring för produktion. Dessa används här för enkelhetens skull, men vi rekommenderar att du använder hanterade tjänster, till exempel Azure Cosmos DB eller Azure Service Bus.

  1. Skapa en fil med namnet aks-store-quickstart.yaml och kopiera i följande manifest:

    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

    En uppdelning av YAML-manifestfiler finns i Distributioner och YAML-manifest.

    Om du skapar och sparar YAML-filen lokalt kan du ladda upp manifestfilen till standardkatalogen i CloudShell genom att välja knappen Ladda upp/ladda ned filer och välja filen från det lokala filsystemet.

  2. Distribuera programmet med kommandot kubectl apply och ange namnet på ditt YAML-manifest.

    kubectl apply -f aks-store-quickstart.yaml

    Följande exempelutdata visar distributioner och tjänster:

    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

Testa programmet

  1. Kontrollera statusen för de distribuerade poddarna med kommandot kubectl get pods . Kontrollera att alla pods är Running innan du fortsätter.

    kubectl get pods

  2. Sök efter en offentlig IP-adress för programmet store-front. Övervaka förloppet med kommandot kubectl get service med --watch argumentet .

    kubectl get service store-front --watch

    EXTERNAL-IP-utdata för store-front tjänsten visas inledningsvis som väntar:

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

  3. När DEN EXTERNA IP-adressen ändras från väntande till en faktisk offentlig IP-adress använder du CTRL-C för att stoppa kubectl bevakningsprocessen.

    Följande exempelutdata visar en giltig offentlig IP-adress som har tilldelats till tjänsten.

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)        AGE
store-front   LoadBalancer   10.0.100.10   20.62.159.19   80:30025/TCP   4h5m

  4. Öppna en webbläsare till tjänstens externa IP-adress för att se hur Azure Store-appen fungerar:

    Skärmbild av AKS Store-exempelprogrammet.

Ta bort klustret

Om du inte planerar att gå igenom AKS-handledningen, rensa bort onödiga resurser för att undvika Azure-avgifter.

Ta bort resursgruppen, containertjänsten och alla relaterade resurser med kommandot az group delete .

az group delete --name myResourceGroup --yes --no-wait

Note

AKS-klustret skapades med en systemtilldelad hanterad identitet, vilket är standardalternativet för identitet som används i den här snabbstarten. Plattformen hanterar den här identiteten, så du behöver inte ta bort den manuellt.

Relaterat innehåll

I den här snabbstarten distribuerade du ett AKS-kluster med ACL för AKS med hjälp av en ARM-mall. Mer information om ACL för AKS finns i Azure Container Linux (ACL) för Azure Kubernetes Service (AKS).

  • Last updated on