Snabbstart: Distribuera ett AKS-kluster (Azure Kubernetes Service) med hjälp av en ARM-mall

Azure Kubernetes Service (AKS) är en hanterad Kubernetes-tjänst som gör att du snabbt kan distribuera och hantera kluster. I den här snabbstarten kommer du att göra följande:

• Distribuera ett AKS-kluster med hjälp av en Azure Resource Manager-mall.
• Kör ett exempelprogram med flera containrar med en grupp mikrotjänster och webbklientdelar som simulerar ett detaljhandelsscenario.

En Azure Resource Manager-mall är en JSON-fil (JavaScript Object Notation) som definierar infrastrukturen och konfigurationen för projektet. Mallen använder deklarativ syntax. Du beskriver den avsedda distributionen utan att skriva sekvensen med programmeringskommandon för att skapa distributionen.

Innan du börjar

Den här artikeln förutsätter en grundläggande förståelse av Kubernetes-begrepp. Mer information finns i Viktiga koncept för Azure Kubernetes Service (AKS).

• Om du inte har något Azure-konto skapar du ett kostnadsfritt konto innan du börjar.

• Kontrollera att den identitet som du använder för att skapa klustret har lämpliga minimibehörigheter. Mer information om åtkomst och identitet för AKS finns i Åtkomst- och identitetsalternativ för Azure Kubernetes Service (AKS).

• För att distribuera en ARM-mall behöver du skrivåtkomst till de resurser som du distribuerar och åtkomst till alla åtgärder i Microsoft.Resources/deployments resurstypen. Till exempel, för att installera en virtuell dator behöver du Microsoft.Compute/virtualMachines/write och Microsoft.Resources/deployments/* behörigheter. Det finns en lista med roller och behörigheter i Inbyggda roller i Azure.

När du har distribuerat klustret från mallen kan du använda antingen Azure CLI eller Azure PowerShell för att ansluta till klustret och distribuera exempelprogrammet.

Skapa ett SSH-nyckelpar

Om du vill skapa ett AKS-kluster med hjälp av en ARM-mall anger du en offentlig SSH-nyckel. Om du behöver den här resursen följer du stegen i det här avsnittet. Annars går du vidare till avsnittet Granska mallen .

För att få åtkomst till AKS-noder ansluter du med ett SSH-nyckelpar (offentligt och privat). Så här skapar du ett SSH-nyckelpar:

1. Gå till https://shell.azure.com för att öppna Cloud Shell i webbläsaren.

2. Skapa ett SSH-nyckelpar med kommandot az sshkey create eller ssh-keygen kommandot .

   # 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. Om du vill distribuera mallen måste du ange den offentliga nyckeln från SSH-paret. Om du vill hämta den offentliga nyckeln anropar du az sshkey show:

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

Som standard skapas SSH-nyckelfilerna i katalogen ~/.ssh . az sshkey create Om du kör kommandot eller ssh-keygen skrivs alla befintliga SSH-nyckelpar över med samma namn.

Mer information om hur du skapar SSH-nycklar finns i Skapa och hantera SSH-nycklar för autentisering i Azure.

Granska mallen

Mallen som används i den här snabbstarten kommer från Azure-snabbstartsmallar.

{
  "$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]"
    }
  }
}

Resurstypen som definieras i ARM-mallen är Microsoft.ContainerService/managedClusters.

Fler AKS-exempel finns på webbplatsen för AKS-snabbstartsmallar .

Använd mallen

1. Välj Distribuera till Azure för att logga in och öppna en mall.

   

2. På sidan Grundläggande lämnar du standardvärdena för OS Disk Size GB, Agent Count, Agent VM Size och OS Type och konfigurerar följande mallparametrar:

   • Prenumeration: Välj en Azure-prenumeration.
   • Resursgrupp: Välj Skapa ny. Ange ett unikt namn för resursgruppen, till exempel myResourceGroup, och välj sedan OK.
   • Plats: Välj en plats, till exempel USA, östra.
   • Klusternamn: Ange ett unikt namn för AKS-klustret, till exempel myAKSCluster.
   • DNS-prefix: Ange ett unikt DNS-prefix för klustret, till exempel myakscluster.
   • Användarnamn för Linux-administratör: Ange ett användarnamn för att ansluta med hjälp av SSH, till exempel azureuser.
   • Källa för offentlig SSH-nyckel: Välj Använd befintlig offentlig nyckel.
   • Nyckelparnamn: Kopiera och klistra in den offentliga delen av SSH-nyckelparet (som standard innehållet i ~/.ssh/id_rsa.pub).

3. Välj Granska + skapa>Skapa.

Det tar några minuter att skapa AKS-klustret. Vänta tills klustret har framgångsrikt distribuerats innan du går vidare till nästa steg.

Anslut till klustret

Om du vill hantera ett Kubernetes-kluster använder du Kubernetes-kommandoradsklienten kubectl.

Distribuera programmet

För att distribuera programmet använder du en manifestfil för att skapa alla objekt som krävs för att köra AKS Store-programmet. En Kubernetes-manifestfil definierar ett klusters önskade tillstånd, till exempel vilka containeravbildningar som ska köras. Manifestet innehåller följande Kubernetes-distributioner och -tjänster:

• Butiksfront: Webbprogram där kunder kan visa produkter och göra beställningar.
• Produkttjänst: Visar produktinformation.
• Ordertjänst: Gör beställningar.
• Rabbit MQ: Meddelandekö för en beställningskö.

1. Skapa en fil med namnet aks-store-quickstart.yaml och kopiera i följande manifest:

   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
   

   En uppdelning av YAML-manifestfiler finns i Distributioner och YAML-manifest.

   Om du skapar och sparar YAML-filen lokalt kan du ladda upp manifestfilen till standardkatalogen i CloudShell genom att välja knappen Ladda upp/ladda ned filer och välja filen från det lokala filsystemet.

2. Distribuera programmet med kommandot kubectl apply och ange namnet på YAML-manifestet.

   kubectl apply -f aks-store-quickstart.yaml
   

   Följande exempelutdata visar distributioner och tjänster:

   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
   

Testa programmet

1. Kontrollera statusen för de distribuerade poddarna med kommandot kubectl get pods . Kontrollera att alla pods är Running innan du fortsätter.

   kubectl get pods
   

2. Sök efter en offentlig IP-adress för programmet store-front. Övervaka förloppet med hjälp av kommandot kubectl get service med --watch argumentet .

   kubectl get service store-front --watch
   

   EXTERNAL-IP-utdata för store-front tjänsten visas inledningsvis som väntar:

   NAME          TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
   store-front   LoadBalancer   10.0.100.10   <pending>     80:30025/TCP   4h4m
   

3. När DEN EXTERNA IP-adressen ändras från väntande till en faktisk offentlig IP-adress använder du CTRL-C för att stoppa kubectl bevakningsprocessen.

   Följande exempelutdata visar en giltig offentlig IP-adress som har tilldelats tjänsten:

   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. Öppna en webbläsare till tjänstens externa IP-adress för att se hur Azure Store-appen fungerar.

   

Ta bort klustret

Om du inte planerar att gå igenom AKS-handledningen, rensa bort onödiga resurser för att undvika Azure-avgifter.

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

Remove-AzResourceGroup -Name myResourceGroup

Nästa steg

I den här snabbstarten distribuerade du ett Kubernetes-kluster och distribuerade sedan ett enkelt program med flera containrar till det. Det här exempelprogrammet är endast i demosyfte och representerar inte alla metodtips för Kubernetes-program. Vägledning om hur du skapar fullständiga lösningar med AKS för produktion finns i AKS-lösningsvägledning.

Om du vill veta mer om AKS och gå igenom ett komplett exempel på kod-till-distribution fortsätter du till självstudiekursen för Kubernetes-klustret.