Rychlý start: Nasazení clusteru Azure Kubernetes Service (AKS) pomocí Azure CLI

Azure Kubernetes Service (AKS) je spravovaná služba Kubernetes, která umožňuje rychle nasazovat a spravovat clustery. V tomto rychlém startu se naučíte:

Nasaďte cluster AKS s výchozím nastavením pomocí Azure CLI.
Nasaďte ukázkovou vícekontenerovou aplikaci se skupinou mikroslužeb a webových front-endů, které simulují scénář maloobchodního prodeje.

Note

Tento článek obsahuje postup nasazení clusteru 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.

Pokud chcete nasadit jenom cluster Azure Kubernetes Service, výběrem možnosti Nasadit do Azure otevřete prohlížeč na webu Azure Portal a vyberte Spustit všechny kroky.

Než začnete

Tento rychlý start předpokládá základní znalosti konceptů Kubernetes. Další informace najdete v tématu Základní koncepty Kubernetes pro Službu Azure Kubernetes Service (AKS).

Pokud nemáte účet Azure, vytvořte si bezplatný účet před tím, než začnete.

Použijte prostředí Bash v Azure Cloud Shellu. Další informace najdete v tématu Začínáme s Azure Cloud Shellem.
Pokud dáváte přednost místnímu spouštění referenčních příkazů rozhraní příkazového řádku, nainstalujte Azure CLI. Pokud používáte Windows nebo macOS, zvažte spuštění Azure CLI v kontejneru Docker. Další informace najdete v tématu Jak spustit Azure CLI v kontejneru Dockeru.
- Pokud používáte místní instalaci, přihlaste se k Azure CLI pomocí příkazu az login. Pokud chcete dokončit proces ověřování, postupujte podle kroků zobrazených na terminálu. Další možnosti přihlášení najdete v tématu Ověřování v Azure pomocí Azure CLI.
- Po zobrazení výzvy nainstalujte rozšíření Azure CLI při prvním použití. Další informace o rozšířeních najdete v tématu Použití a správa rozšíření pomocí Azure CLI.
- Spuštěním příkazu az version zjistěte verzi a závislé knihovny, které jsou nainstalované. Pokud chcete upgradovat na nejnovější verzi, spusťte az upgrade.

Ujistěte se, že identita, kterou používáte k vytvoření clusteru, má odpovídající minimální oprávnění. Další informace o přístupu a identitě pro AKS najdete v tématu Možnosti přístupu a identit pro Službu Azure Kubernetes Service (AKS).
Pokud máte více předplatných Azure, vyberte odpovídající ID předplatného, ve kterém se mají prostředky fakturovat pomocí příkazu az account set . Další informace najdete v tématu Správa předplatných Azure – Azure CLI.
V závislosti na vašem předplatném Azure možná budete muset požádat o navýšení kvóty vCPU. Další informace najdete v tématu Zvýšení kvót vCPU pro skupiny virtuálních strojů.

Registrace poskytovatelů prostředků

Možná budete muset ve svém předplatném Azure zaregistrovat poskytovatele prostředků. Vyžaduje se například Microsoft.ContainerService .

Spuštěním následujícího příkazu zkontrolujte stav registrace.

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

V případě potřeby zaregistrujte poskytovatele prostředků.

az provider register --namespace Microsoft.ContainerService

Definování proměnných prostředí

Během tohoto rychlého startu definujte následující proměnné prostředí k použití.

export RANDOM_STRING=$(printf '%05d%05d' "$RANDOM" "$RANDOM")
export RESOURCE_GROUP="myAKSResourceGroup$RANDOM_STRING"
export CLUSTER_NAME="myAKSCluster$RANDOM_STRING"
export USER_NP='userpool1'
export LOCATION="westus"

Proměnná RANDOM_STRING ukládá náhodný 10místný řetězec. Hodnoty proměnných RESOURCE_GROUP a CLUSTER_NAME jsou zřetězeny s hodnotou RANDOM_STRING pro vytvoření jedinečných názvů. Uloží USER_NP název fondu uzlů v uživatelském režimu. Proměnná LOCATION má hodnotu westus2. Tyto hodnoty proměnných můžete použít nebo si vytvořit vlastní. echo Pomocí příkazu zobrazte hodnoty proměnných, jako je echo $RANDOM_STRING.

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ů se zobrazí výzva k zadání 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.

Vytvořte skupinu prostředků pomocí příkazu az group create .

az group create --name $RESOURCE_GROUP --location $LOCATION

Výsledek vypadá jako v následujícím příkladu.

{
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/myAKSResourceGroup<randomStringValue>",
  "location": "westus",
  "managedBy": null,
  "name": "myAKSResourceGroup<randomStringValue>",
  "properties": {
    "provisioningState": "Succeeded"
  },
  "tags": null,
  "type": "Microsoft.Resources/resourceGroups"
}

Vytvoření clusteru AKS

Vytvořte cluster AKS pomocí příkazu az aks create . Následující příklad vytvoří cluster s jedním uzlem a povolí spravovanou identitu přiřazenou systémem.

az aks create \
  --resource-group $RESOURCE_GROUP \
  --name $CLUSTER_NAME \
  --node-count 1 \
  --generate-ssh-keys

Když vytvoříte nový cluster, AKS automaticky vytvoří druhou skupinu prostředků pro uložení prostředků AKS. Další informace najdete v tématu Proč se v AKS vytvářejí dvě skupiny prostředků?

Cluster v tomto příkladu určuje počet uzlů jako jeden, aby se ušetřil čas a prostředky. V produkčním prostředí se doporučuje počet uzlů tři nebo více. Výchozí az aks create hodnota je tři uzly, pokud nezadáte počet uzlů.

Přidat fond uzlů uživatelského režimu

Aplikace by se měly spouštět ve fondech uzlů uživatelského režimu místo výchozího fondu uzlů režimu systému. Fondy uzlů uživatelů poskytují lepší izolaci a flexibilitu pro úlohy aplikací. Přidejte do clusteru uživatelský fond uzlů pomocí příkazu az aks nodepool add.

az aks nodepool add \
  --resource-group $RESOURCE_GROUP \
  --cluster-name $CLUSTER_NAME \
  --name $USER_NP \
  --node-count 1 \
  --mode User

Stejně jako u clusteru jsme zadali jeden uzel, ale výchozí hodnota je tři uzly, pokud nezadáte počet uzlů.

Po vytvoření fondu uzlů uživatele můžete pomocí příkazu az aks nodepool list ověřit, jestli má váš cluster fond systémových uzlů a fond uzlů uživatele.

az aks nodepool list \
  --resource-group $RESOURCE_GROUP \
  --cluster-name $CLUSTER_NAME \
  --query "[].{Count:count, Mode:mode, NodePool:name, ResourceGroup:resourceGroup}"

[
  {
    "Count": 1,
    "Mode": "System",
    "NodePool": "nodepool1",
    "ResourceGroup": "myAKSResourceGroup1234554321"
  },
  {
    "Count": 1,
    "Mode": "User",
    "NodePool": "userpool1",
    "ResourceGroup": "myAKSResourceGroup1234554321"
  }
]

Připojení ke clusteru

Ke správě clusteru Kubernetes použijte klienta příkazového řádku Kubernetes kubectl. kubectl je už nainstalovaný, pokud používáte Azure Cloud Shell. K místní instalaci kubectl použijte příkaz az aks install-cli .

Nakonfigurujte kubectl připojení ke clusteru Kubernetes pomocí příkazu az aks get-credentials . Tento příkaz stáhne přihlašovací údaje a nakonfiguruje rozhraní příkazového řádku Kubernetes tak, aby je používalo.
```
az aks get-credentials --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME
```
Pomocí příkazu kubectl get ověřte připojení ke clusteru. Tento příkaz vrátí seznam uzlů clusteru.
```
kubectl get nodes
```
```
NAME                                STATUS   ROLES    AGE     VERSION
aks-nodepool1-123456789-vmss000000   Ready    <none>   15m     v1.34.4
aks-userpool1-123456789-vmss000000   Ready    <none>   5m36s   v1.34.4
```
Existují dva uzly, nodepool1 je fond systémových uzlů vytvořený s clusterem a userpool1 je fond uzlů uživatele přidaný do clusteru.

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.
Služba objednávek: Zadává objednávky.
RabbitMQ: Fronta zpráv pro frontu objednávek.

Note

Nedoporučujeme spouštět stavové kontejnery, například RabbitMQbez trvalého úložiště pro produkční prostředí. Používáme ji zde 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. Nahraďte dva zástupné symboly <defaultPassword> vlastním heslem. Toto heslo se používá pro výchozího RabbitMQ uživatele instance.

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
        kubernetes.azure.com/mode: user
      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: "<defaultPassword>"
        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
        kubernetes.azure.com/mode: user
      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: "<defaultPassword>"
        - 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
        kubernetes.azure.com/mode: user
      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
        kubernetes.azure.com/mode: user
      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

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 Cloud Shellu 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
```
Spuštěním následujícího příkazu ověřte, že je aplikace nasazená ve fondu uzlů uživatele.
```
kubectl get pods -o wide
```
Ve výstupu se zobrazí, že na uzlu ve fondu uzlů uživatele běží rabbitmq, order-service, product-service a store-front.

Testování aplikace

Aplikaci můžete ověřit tak, že navštívíte veřejnou IP adresu nebo adresu URL aplikace.

Spuštěním následujících příkazů zobrazte adresu URL aplikace:

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

Výstup zobrazuje veřejnou IP adresu aplikace v zástupné <applicationIPAddress> sadě. Tuto IP adresu použijete k zobrazení aplikace v dalších krocích.

service IP Address: <applicationIPAddress>

Spuštěním následujícího příkazu odešlete požadavek na adresu URL aplikace. Nahraďte <applicationIPAddress> IP adresou služby.

curl <applicationIPAddress>

Příkaz vrátí výstup HTML, který zobrazí, že aplikace reaguje na požadavek.

<!doctype html>
<html lang="">
  <head>
    <meta charset="UTF-8" />
    <link rel="icon" href="/favicon.ico" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Contoso Pet Store</title>
    <script type="module" crossorigin src="/assets/index-CLiaTzSi.js"></script>
    <link rel="stylesheet" crossorigin href="/assets/index-Cv6jORyk.css">
  </head>
  <body>
    <div id="app"></div>
  </body>
</html>

Pokud chcete zobrazit web aplikace, otevřete prohlížeč a zadejte IP adresu služby. Stránka vypadá jako v následujícím příkladu.

Odstranění clusteru

Pokud nemáte v plánu kurz AKS, vyčistěte nepotřebné prostředky, abyste se vyhnuli poplatkům za fakturaci Azure. Pomocí příkazu az group delete můžete odebrat skupinu prostředků, službu kontejneru a všechny související prostředky.

az group delete --name $RESOURCE_GROUP --no-wait --yes

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ě odstraňovat.

Další kroky

V tomto rychlém startu jste nasadili cluster Kubernetes a pak nasadili jednoduchou vícekontenerovou aplikaci. Tato ukázková aplikace slouží jenom pro ukázkové účely a nepředstavuje všechny osvědčené postupy pro aplikace Kubernetes. Pokyny k vytváření úplných řešení pomocí AKS pro produkční prostředí najdete v pokynech k řešení AKS.

Chcete-li se dozvědět více o AKS a udělat úplný příklad od kódu po nasazení, pokračujte do kurzu clusteru Kubernetes.

Kurz K AKS

Váš názor

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

Last updated on 2026-04-22