Rychlý start: Nasazení clusteru Azure Kubernetes Service (AKS) pomocí šablony ARM

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

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

Šablona Azure Resource Manageru je soubor JSON (JavaScript Object Notation), který definuje infrastrukturu a konfiguraci projektu. Tato šablona používá deklarativní syntaxi. Popíšete zamýšlené nasazení, aniž byste museli psát posloupnost programovacích příkazů pro vytvoření nasazení.

Než začnete

Tento článek 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 ještě nemáte předplatné Azure, vytvořte si bezplatný účet Azure před tím, než začnete.

• Ujistěte se, že identita, kterou používáte 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).

• Pokud chcete nasadit šablonu ARM, potřebujete přístup k zápisu k prostředkům, které nasazujete, a přístup ke všem operacím s typem Microsoft.Resources/deployments prostředku. Pokud chcete například nasadit virtuální počítač, potřebujete Microsoft.Compute/virtualMachines/write a Microsoft.Resources/deployments/* oprávnění. Seznam rolí a oprávnění najdete v tématu Předdefinované role Azure.

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

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řipojujete pomocí páru klíčů SSH (veřejný a privátní). Vytvoření páru klíčů SSH:

1. https://shell.azure.com V prohlížeči otevřete Cloud Shell.

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

   # Create an SSH key pair using Azure CLI
   az sshkey create --name "mySSHKey" --resource-group "myResourceGroup"
   
   # or
   
   # Create an SSH key pair using ssh-keygen
   ssh-keygen -t rsa -b 4096
   

3. Pokud chcete šablonu nasadit, musíte zadat veřejný klíč z páru SSH. Pokud chcete načíst veřejný klíč, zavolejte az sshkey show:

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

Ve výchozím nastavení se soubory klíčů SSH vytvoří v adresáři ~/.ssh . Spuštěním az sshkey create příkazu nebo ssh-keygen příkazu přepíšete všechny existující páry klíčů SSH se stejným názvem.

Další informace o vytváření klíčů SSH najdete v tématu Vytvoření a správa klíčů SSH pro ověřování v Azure.

Kontrola šablony

Šablona použitá v tomto rychlém startu je jednou z šablon pro rychlý start Azure.

{
  "$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": "2024-02-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",
            "mode": "System"
          }
        ],
        "linuxProfile": {
          "adminUsername": "[parameters('linuxAdminUsername')]",
          "ssh": {
            "publicKeys": [
              {
                "keyData": "[parameters('sshRSAPublicKey')]"
              }
            ]
          }
        }
      }
    }
  ],
  "outputs": {
    "controlPlaneFQDN": {
      "type": "string",
      "value": "[reference(resourceId('Microsoft.ContainerService/managedClusters', parameters('clusterName')), '2024-02-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.

   

2. Na stránce Základy 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 a nakonfigurujte následující parametry šablony:

   • Předplatné: Vyberte předplatné Azure.
   • Skupina prostředků: Vyberte Vytvořit nový. Zadejte jedinečný název skupiny prostředků, například myResourceGroup, a pak vyberte OK.
   • 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

Ke správě clusteru Kubernetes použijte klienta příkazového řádku Kubernetes kubectl.

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ávka: Objednávky.
• Rabbit MQ: Fronta zpráv pro frontu objednávek.

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

1. Pomocí příkazu kubectl get pods zkontrolujte stav nasazených podů. Než budete pokračovat, udělejte všechny pody Running .

   kubectl get pods
   

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

3. Jakmile se externí IP adresa změní z čekání na skutečnou kubectl veřejnou IP adresu, použijte CTRL-C 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, abyste viděli aplikaci Azure Store v akci.

   

Odstranění clusteru

Pokud nechcete projít kurzem AKS, vyčistěte nepotřebné prostředky, abyste se vyhnuli poplatkům za Azure.

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

Remove-AzResourceGroup -Name myResourceGroup

Další kroky

V tomto rychlém startu jste nasadili cluster Kubernetes a pak jste do něj 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.

Pokud chcete získat další informace o AKS a projít si kompletní příklad nasazení kódu na nasazení, pokračujte kurzem clusteru Kubernetes.