Gyorsútmutató: Azure Kubernetes Service-szolgáltatás (AKS) fürt üzembe helyezése az Azure CLI használatával

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. Ezen rövid útmutató segítségével megtanulhatja a következőket:

• AKS-fürt üzembe helyezése az Azure CLI használatával.
• Futtasson egy többtárolós mintaalkalmazást mikroszolgáltatások és webes kezelőfelületek egy csoportjával, amely egy kiskereskedelmi forgatókönyvet szimulál.

Note

Ez a cikk egy olyan fürt üzembe helyezésének lépéseit tartalmazza, amely csak kiértékelési célokra használja az alapértelmezett beállításokat. 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 hozzákezdene

A rövid útmutató feltételezi, hogy rendelkezik a Kubernetes használatára vonatkozó alapvető ismeretekkel. További információkért tekintse meg az Azure Kubernetes Service (AKS) Kubernetes alapfogalmait.

• Ha még nem rendelkezik Azure-fiókkal, első lépésként hozzon létre egy ingyenes fiókot.

• Használja a Bash-környezetet az Azure Cloud Shellben. További információ: Az Azure Cloud Shell használatának első lépései.

  

• Ha a CLI referencia parancsokat helyben szeretnéd futtatni, telepítsd az Azure CLI-t. Ha Windows vagy macOS rendszeren fut, fontolja meg az Azure CLI-t egy Docker-konténerben futtatni. További információkért lásd: Az Azure CLI használata Docker-konténerben.

  • Ha egy helyileg telepített verziót használ, jelentkezzen be az Azure CLI-be az az login parancs futtatásával. Az azonosítási folyamat befejezéséhez kövesse a terminálján megjelenő lépéseket. További bejelentkezési lehetőségekért lásd: Hitelesítés az Azure-ba az Azure CLI használatával.

  • Amikor megjelenik a felszólítás, az első használatkor telepítse az Azure CLI bővítményt. További információ a bővítményekről: Bővítmények használata és kezelése az Azure CLI-vel.

  • Futtasd a az version parancsot, hogy megtudd a telepített verziót és függő könyvtárakat. A legújabb verzióra való frissítéshez futtassa a az upgrade parancsot.

• Győződjön meg arról, hogy az identitás, amit a klaszter létrehozásához használ, rendelkezik a szükséges minimális jogosultságokkal. Az AKS-hez való hozzáféréssel és identitással kapcsolatos további információkért lásd az Azure Kubernetes Service (AKS) hozzáférési és identitásbeállításait.
• Ha több Azure-előfizetéssel rendelkezik, válassza ki a megfelelő előfizetés-azonosítót, amelyben az erőforrásokat az az account set paranccsal kell számlázni. További információ: Azure-előfizetések kezelése – Azure CLI.
• Az Azure-előfizetésétől függően előfordulhat, hogy vCPU-kvótanövelést kell kérnie. További információ: VM-családi vCPU-kvóták növelése.

Erőforrás-szolgáltatók regisztrálása

Előfordulhat, hogy erőforrás-szolgáltatókat kell regisztrálnia az Azure-előfizetésében. Például szükség van a Microsoft.ContainerService-re.

Futtassa a következő parancsot a regisztrációs állapot ellenőrzéséhez.

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

Szükség esetén regisztrálja az erőforrás-szolgáltatót.

az provider register --namespace Microsoft.ContainerService

Környezeti változók definiálása

A rövid útmutató során a következő környezeti változók definiálhatók.

export RANDOM_ID="$(openssl rand -hex 3)"
export MY_RESOURCE_GROUP_NAME="myAKSResourceGroup$RANDOM_ID"
export REGION="westus"
export MY_AKS_CLUSTER_NAME="myAKSCluster$RANDOM_ID"
export MY_DNS_LABEL="mydnslabel$RANDOM_ID"

A RANDOM_ID változó értéke egy hat karakterből álló alfanumerikus érték, amely az erőforráscsoporthoz és a fürt nevéhez hozzáfűződik, hogy a nevek egyediek legyenek. Az echo parancs használatával megtekintheti a változóértékeket, mint a echo $RANDOM_ID.

Erőforráscsoport létrehozása

Az Azure-erőforráscsoportok olyan logikai csoportok, amelyekben az Azure-erőforrások üzembe helyezése és kezelése történik. Erőforráscsoport létrehozásakor a rendszer kérni fogja, hogy adjon meg egy helyet. Ez a hely az erőforráscsoport metaadatainak tárolási helye, és ahol az erőforrások az Azure-ban futnak, ha nem ad meg egy másik régiót az erőforrás létrehozása során.

Hozzon létre egy erőforráscsoportot az az group create paranccsal.

az group create --name $MY_RESOURCE_GROUP_NAME --location $REGION

Az eredmény az alábbi példához hasonlóan néz ki.

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

AKS-fürt létrehozása

Hozzon létre egy AKS-fürtöt az az aks create paranccsal. Az alábbi példa egy egy csomóponttal rendelkező fürtöt hoz létre, és engedélyezi a rendszer által hozzárendelt felügyelt identitást.

az aks create \
  --resource-group $MY_RESOURCE_GROUP_NAME \
  --name $MY_AKS_CLUSTER_NAME \
  --node-count 1 \
  --generate-ssh-keys

Note

Új fürt létrehozásakor az AKS automatikusan létrehoz egy második erőforráscsoportot az AKS-erőforrások tárolásához. További információ: Miért jön létre két erőforráscsoport az AKS-sel?

Csatlakozzon a klaszterhez

A Kubernetes-fürt kezeléséhez használja a Kubernetes parancssori klienst, a kubectl-t. kubectl már telepítve van az Azure Cloud Shell használata esetén. A helyi telepítéshez kubectl használja az az aks install-cli parancsot.

1. Konfigurálja kubectl a Kubernetes-klaszterhez 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 $MY_RESOURCE_GROUP_NAME --name $MY_AKS_CLUSTER_NAME
   

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 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. Egy Kubernetes-manifeszt fájl meghatározza a fürt elvárt állapotát, például hogy mely konténerképeket kell futtatni. A manifest a következő Kubernetes üzembe helyezéseket és szolgáltatásokat tartalmazza:

• Á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.
• RabbitMQ: Üzenetsor egy rendelési sorhoz.

Note

Nem javasoljuk, hogy állapotalapú tárolókat futtasson, például RabbitMQállandó tárolás nélkül éles környezetben. 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 aks-store-quickstart.yaml nevű fájlt, és másolja a következő jegyzékbe.

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

   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, akkor feltöltheti a jegyzékfájlt az alapértelmezett könyvtárba a Cloud Shellben 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 alkalmazás tesztelése

A nyilvános IP-cím vagy az alkalmazás URL-címének megtekintésével ellenőrizheti, hogy az alkalmazás fut-e.

Kérje le az alkalmazás URL-címét a következő parancsokkal:

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

curl $IP_ADDRESS

Results:

<!doctype html>
<html lang="">
   <head>
      <meta charset="utf-8">
      <meta http-equiv="X-UA-Compatible" content="IE=edge">
      <meta name="viewport" content="width=device-width,initial-scale=1">
      <link rel="icon" href="/favicon.ico">
      <title>store-front</title>
      <script defer="defer" src="/js/chunk-vendors.df69ae47.js"></script>
      <script defer="defer" src="/js/app.7e8cfbb2.js"></script>
      <link href="/css/app.a5dc49f6.css" rel="stylesheet">
   </head>
   <body>
      <div id="app"></div>
   </body>
</html>

echo "You can now visit your web server at $IP_ADDRESS"

Az alkalmazás webhelyének megtekintéséhez nyisson meg egy böngészőt, és adja meg az IP-címet. A lap a következő példához hasonlóan néz ki.

Fürt törlése

Ha nem tervezi végigvezetni az AKS-oktatóanyagot, törölje a felesleges erőforrásokat az Azure számlázási költségeinek elkerülése érdekében. Az erőforráscsoportot, a tárolószolgáltatást és az összes kapcsolódó erőforrást az az group delete paranccsal távolíthatja el.

az group delete --name $MY_RESOURCE_GROUP_NAME

Az AKS-fürt egy rendszer által hozzárendelt felügyelt identitással lett létrehozva, amely az ebben a gyorsú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 gyors kezdőlépésben üzembe helyezett egy Kubernetes-fürtöt, majd üzembe helyezett egy egyszerű, többkonténeres 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 AKS teljes körű megoldások éles környezetben való létrehozására vonatkozó útmutatót az AKS megoldási útmutató tartalmaz.

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

AKS-oktatóanyag