Rövid útmutató: Azure Kubernetes Service- (AKS-) fürt üzembe helyezése ARM-sablonnal

Az Azure Kubernetes Service (AKS) egy felügyelt Kubernetes-szolgáltatás, amely lehetővé teszi a fürtök gyors üzembe helyezését és kezelését. Ebben a rövid útmutatóban a következőket hajtja végre:

  • AKS-fürt üzembe helyezése Azure Resource Manager-sablonnal.
  • Többtárolós mintaalkalmazás futtatása mikroszolgáltatások és webes kezelőfelületek egy kiskereskedelmi forgatókönyvet szimuláló csoportjával.

Az Azure Resource Manager-sablon egy JavaScript Object Notation (JSON) fájl, amely meghatározza a projekt infrastruktúráját és konfigurációját. A sablon deklaratív szintaxist használ. Az üzembe helyezés létrehozásához szükséges programozási parancsok sorozatának megírása nélkül írhatja le a tervezett üzembe helyezést.

Feljegyzés

Az AKS-fürtök gyors üzembe helyezésének megkezdéséhez ez a cikk a csak kiértékelési célokra alapértelmezett beállításokkal rendelkező fürtök üzembe helyezésének lépéseit tartalmazza. Az éles üzemre kész fürtök üzembe helyezése előtt javasoljuk, hogy ismerkedjen meg az alapszintű referenciaarchitektúrával, és gondolja át, hogyan igazodik az üzleti követelményekhez.

Mielőtt elkezdené

Ez a cikk a Kubernetes-fogalmak alapszintű megértését feltételezi. További információkért tekintse meg az Azure Kubernetes Service (AKS) Kubernetes alapfogalmait.

  • Ha nem rendelkezik Azure-előfizetéssel, első lépésként hozzon létre egy ingyenes Azure-fiókot.

  • Győződjön meg arról, hogy a fürt létrehozásához használt identitás rendelkezik a megfelelő minimális engedélyekkel. Az AKS-hez való hozzáféréssel és identitással kapcsolatos további részletekért tekintse meg az Azure Kubernetes Service (AKS) hozzáféréssel és identitással kapcsolatos lehetőségeit.

  • ARM-sablon üzembe helyezéséhez írási hozzáférést kell adnia az üzembe helyezendő erőforrásokhoz, és hozzá kell férnie az Microsoft.Resources/deployments erőforrástípus összes műveletéhez. Egy virtuális gép üzembe helyezéséhez például szükség van rá és Microsoft.Resources/deployments/* engedélyekreMicrosoft.Compute/virtualMachines/write. A szerepkörök és engedélyek listáját megtalálja a Beépített Azure-szerepkörök című cikkben.

Miután telepítette a fürtöt a sablonból, az Azure CLI vagy az Azure PowerShell használatával csatlakozhat a fürthöz, és üzembe helyezheti a mintaalkalmazást.

Ez a cikk az Azure CLI 2.0.64-es vagy újabb verzióját igényli. Az Azure Cloud Shell használata esetén a legújabb verzió már telepítve van.

SSH-kulcs létrehozása

Ha ARM-sablonnal szeretne AKS-fürtöt létrehozni, adjon meg egy nyilvános SSH-kulcsot. Ha szüksége van erre az erőforrásra, kövesse az ebben a szakaszban leírt lépéseket. Ellenkező esetben ugorjon a Sablon áttekintése szakaszra.

Az AKS-csomópontok eléréséhez SSH-kulcspár (nyilvános és privát) használatával csatlakozik. SSH-kulcspár létrehozása:

  1. Nyissa meg a https://shell.azure.com Cloud Shellt a böngészőben.

  2. Hozzon létre egy SSH-kulcspárt az az sshkey create paranccsal vagy a ssh-keygen paranccsal.

    # 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. A sablon üzembe helyezéséhez meg kell adnia a nyilvános kulcsot az SSH-párból. A nyilvános kulcs lekéréséhez hívja meg az sshkey show-t:

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

Alapértelmezés szerint az SSH-kulcsfájlok a ~/.ssh könyvtárban jönnek létre. A parancs futtatása ssh-keygen felülírja a az sshkey create meglévő SSH-kulcspárokat ugyanazzal a névvel.

További információ az SSH-kulcsok létrehozásáról: SSH-kulcsok létrehozása és kezelése az Azure-ban történő hitelesítéshez.

A sablon áttekintése

Az ebben a gyorsútmutatóban használt sablon az Azure-gyorssablonok közül származik.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "metadata": {
    "_generator": {
      "name": "bicep",
      "version": "0.9.1.41621",
      "templateHash": "2637152180661081755"
    }
  },
  "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,
      "maxValue": 1023,
      "minValue": 0,
      "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,
      "maxValue": 50,
      "minValue": 1,
      "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": "2022-05-02-preview",
      "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'))).fqdn]"
    }
  }
}

Az ARM-sablonban definiált erőforrástípus a Microsoft.ContainerService/managedClusters.

További AKS-mintákért tekintse meg az AKS rövid útmutatósablonok webhelyét.

A sablon üzembe helyezése

  1. A bejelentkezéshez és a sablon megnyitásához válassza az Üzembe helyezés az Azure-ban lehetőséget.

    Button to deploy the Resource Manager template to Azure.

  2. Az Alapszintű beállítások lapon hagyja meg az operációs rendszer lemezméretének GB-jának, ügynökszámának, ügynök virtuálisgép-méretének és operációsrendszer-típusának alapértelmezett értékeit, és konfigurálja a következő sablonparamétereket:

    • Előfizetés: válasszon ki egy Azure-előfizetést.
    • Erőforráscsoport: Válassza az Új létrehozása lehetőséget. Adjon meg egy egyedi nevet az erőforráscsoportnak(például myResourceGroup), majd válassza az OK gombot.
    • Hely: Válasszon ki egy helyet, például az USA keleti régióját.
    • Fürt neve: Adjon meg egy egyedi nevet az AKS-fürtnek, például a myAKSClusternek.
    • DNS-előtag: Adjon meg egy egyedi DNS-előtagot a fürthöz, például a myaksclustert.
    • Linux Rendszergazda felhasználónév: Adjon meg egy felhasználónevet az SSH használatával való csatlakozáshoz, például az azureuserhez.
    • SSH nyilvános kulcs forrása: Válassza a Meglévő nyilvános kulcs használata lehetőséget.
    • Kulcspár neve: Másolja és illessze be az SSH-kulcspár nyilvános részét (alapértelmezés szerint a ~/.ssh/id_rsa.pub tartalma).
  3. Válassza a Felülvizsgálat + létrehozás>Létrehozás lehetőséget.

Az AKS-fürt létrehozása eltarthat néhány percig. Várja meg, amíg a fürt sikeresen üzembe lesz helyezve, mielőtt továbblép a következő lépésre.

Csatlakozás a fürthöz

Kubernetes-fürt kezeléséhez használja a Kubernetes parancssori ügyfelet, a kubectl-et.

Ha az Azure Cloud Shellt használja, kubectl már telepítve van. A helyi telepítéshez és futtatáshoz kubectl hívja meg az az aks install-cli parancsot.

  1. Konfigurálja kubectl a Kubernetes-fürthöz való csatlakozást az az aks get-credentials paranccsal. Ez a parancs letölti a hitelesítő adatokat, és konfigurálja a Kubernetes parancssori felületét a használatukhoz.

    az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
    
  2. Ellenőrizze a fürthöz való kapcsolatot a kubectl get paranccsal. Ez a parancs a fürtcsomópontok listáját adja vissza.

    kubectl get nodes
    

    Az alábbi példakimenet az előző lépésekben létrehozott három csomópontot mutatja be. Győződjön meg arról, hogy a csomópont állapota kész.

    NAME                                STATUS   ROLES   AGE   VERSION
    aks-agentpool-27442051-vmss000000   Ready    agent   10m   v1.27.7
    aks-agentpool-27442051-vmss000001   Ready    agent   10m   v1.27.7
    aks-agentpool-27442051-vmss000002   Ready    agent   11m   v1.27.7
    

Az alkalmazás üzembe helyezése

Az alkalmazás üzembe helyezéséhez egy jegyzékfájl használatával hozza létre az AKS Store-alkalmazás futtatásához szükséges összes objektumot. A Kubernetes-jegyzékfájl meghatározza a fürt kívánt állapotát, például hogy mely tárolólemezképeket kell futtatni. A jegyzék a következő Kubernetes-üzemelő példányokat és szolgáltatásokat tartalmazza:

Screenshot of Azure Store sample architecture.

  • Áruházi előtér: Webalkalmazás az ügyfelek számára termékek megtekintésére és megrendelések leadására.
  • Termékszolgáltatás: A termékinformációkat jeleníti meg.
  • Rendelési szolgáltatás: Rendeléseket rendel.
  • Nyúl MQ: Üzenetsor rendelési üzenetsorhoz.

Feljegyzés

Nem javasoljuk az állapotalapú tárolók( például a Rabbit MQ) futtatását az éles környezetben tartós tárolás nélkül. Ezeket itt az egyszerűség kedvéért használjuk, de olyan felügyelt szolgáltatások használatát javasoljuk, mint az Azure CosmosDB vagy az Azure Service Bus.

  1. Hozzon létre egy fájlt, aks-store-quickstart.yaml és másolja a következő jegyzékbe:

    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
    

    A YAML-jegyzékfájlok lebontásához tekintse meg az üzembe helyezéseket és a YAML-jegyzékeket.

    Ha helyileg hozza létre és menti a YAML-fájlt, feltöltheti a jegyzékfájlt az alapértelmezett könyvtárba a CloudShellben a Fájlok feltöltése/letöltése gombra kattintva, majd kiválasztva a fájlt a helyi fájlrendszerből.

  2. Telepítse az alkalmazást a kubectl Apply paranccsal, és adja meg a YAML-jegyzék nevét.

    kubectl apply -f aks-store-quickstart.yaml
    

    Az alábbi példakimenet az üzemelő példányokat és szolgáltatásokat mutatja be:

    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
    

Az alkalmazás tesztelése

  1. Ellenőrizze az üzembe helyezett podok állapotát a kubectl get pods paranccsal. Az összes podot a folytatás előtt készítse Running el.

    kubectl get pods
    
  2. Ellenőrizze, hogy van-e nyilvános IP-cím az áruházi előtéralkalmazáshoz. Figyelje a folyamatot a kubectl get service paranccsal az --watch argumentummal.

    kubectl get service store-front --watch
    

    A szolgáltatás KÜLSŐ-IP-kimenetestore-front kezdetben függőben lévőként jelenik meg:

    NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
    store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m
    
  3. Ha a külső IP-cím függőben lévőrőltényleges nyilvános IP-címre változik, állítsa CTRL-C le a kubectl figyelés folyamatát.

    Az alábbi példakimenet a szolgáltatáshoz rendelt érvényes nyilvános IP-címet jeleníti meg:

    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. Nyisson meg egy webböngészőt a szolgáltatás külső IP-címére az Azure Store-alkalmazás működés közbeni megtekintéséhez.

    Screenshot of AKS Store sample application.

A fürt törlése

Ha nem tervezi végigvezetni az AKS-oktatóanyagot, törölje a felesleges erőforrásokat az Azure-díjak elkerülése érdekében.

Távolítsa el az erőforráscsoportot, a tárolószolgáltatást és az összes kapcsolódó erőforrást az az csoporttörlés parancs meghívásával.

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

Feljegyzés

Az AKS-fürt egy rendszer által hozzárendelt felügyelt identitással lett létrehozva, amely az ebben a rövid útmutatóban használt alapértelmezett identitásbeállítás. A platform kezeli ezt az identitást, így önnek nem kell manuálisan eltávolítania.

Következő lépések

Ebben a rövid útmutatóban üzembe helyezett egy Kubernetes-fürtöt, majd üzembe helyezett egy egyszerű többtárolós alkalmazást. Ez a mintaalkalmazás csak bemutató célokra készült, és nem képviseli a Kubernetes-alkalmazások ajánlott eljárásait. Az éles AKS-sel való teljes megoldások létrehozásáról az AKS-megoldásokkal kapcsolatos útmutatást talál.

Ha többet szeretne megtudni az AKS-ről, és végig szeretne járni egy teljes kód–üzembe helyezési példán, folytassa a Kubernetes-fürt oktatóanyagával.