Rychlý start: Nasazení hostitele kontejneru Azure Linux pro cluster AKS pomocí Azure PowerShellu

Začněte s Azure Linux Container Host pomocí nástroje Azure PowerShell k nasazení hostitele kontejnerů pro cluster AKS. Po instalaci požadavků vytvoříte skupinu prostředků, vytvoříte cluster AKS, připojíte se ke clusteru a spustíte v clusteru ukázkovou vícekontenerovou aplikaci.

Důležité

Od 30. listopadu 2025 už AKS nebude podporovat ani poskytovat aktualizace zabezpečení pro Azure Linux 2.0. Od 31. března 2026 se image uzlů odeberou a nebudete moct škálovat fondy uzlů. Migrujte na podporovanou verzi Azure Linuxu buď aktualizací fondů uzlů na podporovanou verzi Kubernetes, nebo migrací na osSku AzureLinux3. Další informace najdete v tématu [Vyřazení z provozu] Uzel poolů Azure Linux 2.0 v AKS.

Prerequisites

Pokud nemáte účet Azure, vytvořte si bezplatný účet před tím, než začnete.
Použijte prostředí PowerShellu v Azure Cloud Shellu. Další informace najdete v rychlém startu pro Azure Cloud Shell.
Pokud používáte PowerShell místně, nainstalujte Az PowerShell modul a připojte se k účtu Azure pomocí této rutiny Connect-AzAccount . Další informace o instalaci modulu Az PowerShell najdete v tématu Instalace Azure PowerShellu.
Identita, kterou použijete k vytvoření clusteru, má odpovídající minimální oprávnění. Další podrobnosti o přístupu a identitě pro AKS najdete v tématu Možnosti přístupu a identit pro Službu Azure Kubernetes Service (AKS).

Vytvoření skupiny zdrojů

Skupina prostředků Azure je logická skupina, ve které se nasazují a spravují prostředky Azure. Při vytváření skupiny prostředků musíte zadat umístění. Toto umístění je umístění úložiště metadat vaší skupiny prostředků a místo, kde vaše prostředky běží v Azure, pokud během vytváření prostředků nezadáte jinou oblast.

Následující příklad vytvoří skupinu prostředků s názvem testAzureLinuxResourceGroup v oblasti eastus.

Vytvořte skupinu prostředků pomocí příkazového modulu New-AzResourceGroup.

New-AzResourceGroup -Name testAzureLinuxResourceGroup -Location eastus

Výstup následujícího příkladu ukazuje úspěšné vytvoření skupiny prostředků:

ResourceGroupName : testAzureLinuxResourceGroup
Location          : eastus
ProvisioningState : Succeeded
Tags              :
ResourceId        : /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/testAzureLinuxResourceGroup

Note

Výše uvedený příklad používá eastus, ale clustery Azure Linux Container Host jsou k dispozici ve všech oblastech.

Vytvoření clusteru hostitelů kontejnerů Azure s Linuxem

Následující příklad vytvoří cluster s názvem testAzureLinuxCluster s jedním uzlem.

Vytvořte cluster AKS pomocí New-AzAksCluster cmdletu s příznakem -NodeOsSKU nastaveným na AzureLinux.
```
New-AzAksCluster -ResourceGroupName testAzureLinuxResourceGroup -Name testAzureLinuxCluster -NodeOsSKU AzureLinux
```
Po několika minutách se příkaz dokončí a vrátí informace o clusteru ve formátu JSON.

Připojení ke clusteru

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

Nainstalujte kubectl místně pomocí rutiny Install-AzAksCliTool .
```
Install-AzAksCliTool
```
Nakonfigurujte kubectl pro připojení ke clusteru Kubernetes pomocí rutiny Import-AzAksCredential. Tento příkaz stahuje přihlašovací údaje a konfiguruje Kubernetes CLI pro jejich použití.
```
Import-AzAksCredential -ResourceGroupName testAzureLinuxResourceGroup -Name testAzureLinuxCluster
```
Ověřte připojení k vašemu clusteru pomocí příkazu kubectl get. Tento příkaz vrátí seznam podů clusteru.
```
kubectl get pods --all-namespaces
```

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:

Store front: Webová aplikace pro zákazníky k zobrazení produktů a objednávání.
Produktová služba: Zobrazuje informace o produktu.
Objednávková služba: Vytváří objednávky.
Rabbit MQ: Fronta zpráv pro objednávkovou frontu.

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.

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

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ů.

Nasaďte aplikaci pomocí příkazu kubectl apply 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

Když se aplikace spustí, služba Kubernetes zveřejní front-end aplikace na internetu. Dokončení tohoto procesu může trvat několik minut.

Pomocí příkazu kubectl get pods zkontrolujte stav nasazených podů. Ujistěte se, že jsou všechny pody Running, než budete pokračovat.
```
kubectl get pods
```
Zkontrolujte veřejnou IP adresu pro aplikaci store-front. Sledujte průběh pomocí příkazu kubectl get service 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
```
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
```
Otevřete webový prohlížeč na externí IP adresu vaší služby, abyste viděli aplikaci Azure Store v akci.

Odstranění clusteru

Pokud nechcete pokračovat v následujících kurzech, odeberte vytvořené prostředky, abyste se vyhnuli poplatkům za Azure.

Pomocí rutiny RemoveAzResourceGroup odeberte skupinu prostředků a všechny související prostředky.
```
Remove-AzResourceGroup -Name testAzureLinuxResourceGroup
```

Další kroky

V tomto rychlém startu jste nasadili cluster Azure Linux Container Host AKS. Další informace o Azure Linux Container Host a projděte si kompletní příklad nasazení a správy clusteru, pokračujte k tutoriálu Azure Linux Container Host.

Kurz ke službě Azure Linux Container Host

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-09-11