Rychlý start: Nasazení kontejneru Azure Linuxu (ACL) pro cluster AKS pomocí šablony ARM

Začněte se službou Azure Container Linux (ACL) pro AKS nasazením clusteru AKS pomocí šablony Azure Resource Manager (ARM).

V tomto rychlém startu se naučíte:

  • Vytvořte cluster AKS pomocí ACL pro AKS.
  • Nasaďte cluster pomocí šablony ARM.
  • Spusťte ukázkovou vícekontenerovou aplikaci se skupinou mikroslužeb a webových front-endů simulujících scénář maloobchodního prodeje.

Note

Pokud chcete začít rychle zřizovat cluster AKS, najdete v tomto článku postup nasazení clusteru s výchozím nastavením pouze pro účely vyhodnocení. Před nasazením clusteru připraveného pro produkční prostředí doporučujeme seznámit se s naší referenční architekturou podle směrného plánu a zvážit, jak je v souladu s vašimi obchodními požadavky.

Important

Pokud používáte Azure Container Linux (ACL) v AKS, zkontrolujte následující aspekty a omezení:

Předpoklady

Po nasazení clusteru ze šablony můžete k připojení ke clusteru použít Azure CLI nebo Azure PowerShell a nasadit ukázkovou aplikaci.

Registrace požadovaných poskytovatelů prostředků

Možná budete muset zaregistrovat požadované poskytovatele prostředků, například Microsoft.ContainerService ve vašem předplatném Azure.

Kontrola stavu registrace

Pomocí příkazu zkontrolujte stav az provider show registrace.

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

Registrace poskytovatele prostředků

V případě potřeby pomocí příkazu Microsoft.ContainerService zaregistrujte poskytovatele prostředků az provider register.

az provider register --namespace Microsoft.ContainerService

Vytvoření páru klíčů SSH

Pokud chcete vytvořit cluster AKS pomocí šablony ARM, zadejte veřejný klíč SSH. Pokud tento prostředek potřebujete, postupujte podle kroků v této části. V opačném případě přejděte do části Kontrola šablony .

Pro přístup k uzlům AKS se připojíte pomocí páru klíčů SSH (veřejný a privátní), který vygenerujete pomocí ssh-keygen příkazu. Ve výchozím nastavení jsou tyto soubory vytvořeny v adresáři ~/.ssh . Spuštěním příkazu ssh-keygen přepíšete jakýkoli pár klíčů SSH se stejným názvem, který už v daném umístění existuje. Další informace o vytváření klíčů SSH najdete v tématu Vytvoření a správa klíčů SSH pro ověřování v Azure.

  1. Přejděte na https://shell.azure.com a otevřete Cloud Shell v prohlížeči.

  2. Vytvořte skupinu prostředků pomocí příkazu az group create. Následující příklad vytvoří skupinu prostředků s názvem myResourceGroup v oblasti Východní USA:

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

  3. Vytvořte pár klíčů SSH pomocí příkazu az sshkey create nebo ssh-keygen.

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

    Nebo vytvořte pár klíčů SSH pomocí ssh-keygen:

    ssh-keygen -t rsa -b 4096

  4. Pokud chcete šablonu nasadit, musíte zadat veřejný klíč z páru SSH. Načtěte veřejný klíč pomocí az sshkey show příkazu.

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

Kontrola šablony

Následující nasazení používá šablonu ARM z 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]"
    }
  }
}

Typ prostředku definovaný v šabloně ARM je Microsoft.ContainerService/managedClusters.

Další ukázky AKS najdete na webu šablon rychlých startů AKS.

Nasazení šablony

  1. Výběrem možnosti Nasadit do Azure se přihlaste a otevřete šablonu.

    Tlačítko pro nasazení šablony Resource Manageru do Azure

  2. Nakonfigurujte parametry šablony na stránce Vlastní nasazení . Pro účely tohoto rychlého startu ponechte výchozí hodnoty pro velikost disku operačního systému GB, počet agentů, velikost virtuálního počítače agenta a typ operačního systému. Zadejte vlastní hodnoty pro následující parametry:

    • Předplatné: Vyberte předplatné Azure.
    • Skupina prostředků: Vyberte možnost Vytvořit nový. Zadejte jedinečný název skupiny prostředků, například myResourceGroup, a pak vyberte OK.
    • SKU operačního systému: Zadejte AzureContainerLinux. Pokud skladovou položku operačního systému neaktualizujete, výchozí hodnota je Ubuntu.
    • Umístění: Vyberte umístění, například USA – východ.
    • Název clusteru: Zadejte jedinečný název clusteru AKS, například myAKSCluster.
    • Předpona DNS: Zadejte jedinečnou předponu DNS pro váš cluster, například myakscluster.
    • Uživatelské jméno správce Linuxu: Zadejte uživatelské jméno pro připojení pomocí SSH, například azureuser.
    • Zdroj veřejného klíče SSH: Vyberte Použít existující veřejný klíč.
    • Název páru klíčů: Zkopírujte a vložte veřejnou část páru klíčů SSH (ve výchozím nastavení obsah ~/.ssh/id_rsa.pub).

  3. Vyberte Zkontrolovat a vytvořit>Vytvořit.

Vytvoření clusteru AKS bude trvat několik minut. Než přejdete k dalšímu kroku, počkejte, než se cluster úspěšně nasadí.

Připojení ke clusteru

Pro správu Kubernetes clusteru použijte příkazový řádkový klient Kubernetes, kubectl. Pokud používáte Azure Cloud Shell, kubectl je už nainstalovaný.

Pokud chcete nainstalovat a spustit kubectl místně, použijte az aks install-cli příkaz.

  1. Nakonfigurujte kubectl pro připojení ke svému Kubernetes clusteru pomocí příkazu az aks get-credentials. Tento příkaz stahuje přihlašovací údaje a konfiguruje Kubernetes CLI pro jejich použití.

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

  2. Ověřte připojení k vašemu clusteru pomocí příkazu kubectl get. Tento příkaz vrátí seznam uzlů clusteru.

    kubectl get nodes

    Následující příklad výstupu ukazuje tři uzly vytvořené v předchozích krocích. Ujistěte se, že je stav uzlu připravený:

    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

Nasazení aplikace

K nasazení aplikace použijete soubor manifestu k vytvoření všech objektů potřebných ke spuštění aplikace AKS Store. Soubor manifestu Kubernetes definuje požadovaný stav clusteru, například které image kontejneru se mají spustit. Manifest zahrnuje následující nasazení a služby Kubernetes:

Screenshot ukázkové architektury Azure Store.

  • Store front: Webová aplikace pro zákazníky k zobrazení produktů a objednávání.
  • Produktová služba: Zobrazuje informace o produktu.
  • Služba objednávek: Vyřizuje objednávky.
  • Rabbit MQ: Systém zpráv pro správu fronty objednávek.

Note

Nedoporučujeme spouštět stavové kontejnery, jako je Rabbit MQ, bez trvalého úložiště pro produkční prostředí. Tady se používají pro zjednodušení, ale doporučujeme používat spravované služby, jako je Azure Cosmos DB nebo Azure Service Bus.

  1. Vytvořte soubor s názvem aks-store-quickstart.yaml a zkopírujte ho v následujícím manifestu:

    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

    Rozpis souborů manifestu YAML najdete v tématu Nasazení a manifesty YAML.

    Pokud soubor YAML vytvoříte a uložíte místně, můžete soubor manifestu nahrát do výchozího adresáře v CloudShellu tak, že vyberete tlačítko Nahrát/Stáhnout soubory a vyberete soubor z místního systému souborů.

  2. Nasaďte aplikaci pomocí kubectl apply příkazu a zadejte název manifestu YAML.

    kubectl apply -f aks-store-quickstart.yaml

    Následující příklad výstupu ukazuje nasazení a služby:

    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

Testování aplikace

  1. Pomocí příkazu zkontrolujte stav nasazených podů kubectl get pods . Ujistěte se, že všechny pody jsou Running, než budete pokračovat.

    kubectl get pods

  2. Zkontrolujte veřejnou IP adresu pro aplikaci store-front. Sledujte průběh pomocí kubectl get service příkazu s argumentem --watch .

    kubectl get service store-front --watch

    Výstup EXTERNAL-IP pro store-front službu se zpočátku zobrazuje jako čekající:

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

  3. Jakmile se externí IP adresa změní z čekání na skutečnou CTRL-C veřejnou IP adresu, použijte kubectl k zastavení procesu sledování.

    Následující příklad výstupu ukazuje platnou veřejnou IP adresu přiřazenou službě:

    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. Otevřete webový prohlížeč na externí IP adresu vaší služby a podívejte se na aplikaci Azure Store v akci:

    Snímek obrazovky ukázkové aplikace AKS Store

Odstranění clusteru

Pokud nemáte v plánu projít kurz AKS, vyčistěte nepotřebné prostředky, abyste se vyhnuli poplatkům za Azure.

Pomocí příkazu az group delete odeberte skupinu prostředků, službu kontejneru a všechny související prostředky.

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

Note

Cluster AKS byl vytvořen se spravovanou identitou přiřazenou systémem, což je výchozí možnost identity použitá v tomto rychlém startu. Platforma spravuje tuto identitu, takže ji nemusíte ručně odebírat.

Související obsah

V tomto rychlém startu jste nasadili cluster AKS s ACL pro AKS pomocí šablony ARM. Další informace o Azure Container Linux (ACL) pro AKS najdete zde: Azure Container Linux (ACL) for Azure Kubernetes Service (AKS).

  • Poslední aktualizace v