Snabbstart: Distribuera ett AKS-kluster (Azure Kubernetes Service) med Bicep Kubernetes-tillägget (förhandsversion)

Artikel
08/08/2024

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 Bicep Kubernetes-tillägget (förhandsversion).
Kör ett exempelprogram med flera containrar med en grupp mikrotjänster och webbklientdelar som simulerar ett detaljhandelsscenario.

Viktigt!

Bicep Kubernetes-tillägget är för närvarande i förhandsversion. Du kan aktivera funktionen från Bicep-konfigurationsfilen genom att lägga till:

{
 "experimentalFeaturesEnabled": {
   "extensibility": true,
 }
}

Kommentar

För att komma igång med att snabbt etablera ett AKS-kluster innehåller den här artikeln steg för att distribuera ett kluster med standardinställningar endast i utvärderingssyfte. Innan du distribuerar ett produktionsklart kluster rekommenderar vi att du bekantar dig med vår referensarkitektur för baslinje för att överväga hur det överensstämmer med dina affärskrav.

Innan du börjar

Den här snabbstarten förutsätter grundläggande kunskaper om Kubernetes-begrepp. Mer information finns i Viktiga koncept för Azure Kubernetes Service (AKS).

Om du inte har en Azure-prenumeration skapar du ett kostnadsfritt Azure-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).

Bicep är ett domänspecifikt språk (DSL) som använder deklarativ syntax för att distribuera Azure-resurser. Det ger koncis syntax, tillförlitlig typsäkerhet och stöd för återanvändning av kod. Bicep erbjuder den bästa redigeringsupplevelsen för dina infrastruktur-som-kod-lösningar i Azure.

Information om hur du konfigurerar din miljö för Bicep-utveckling finns i Installera Bicep-verktyg. När du har slutfört stegen har du Visual Studio Code och Bicep-tillägget. Du har också antingen den senaste Azure CLI-versionen eller den senaste Azure PowerShell-modulen.
Om du vill skapa ett AKS-kluster med en Bicep-fil anger du en offentlig SSH-nyckel. Om du behöver den här resursen kan du läsa följande avsnitt. Annars går du vidare till Granska Bicep-filen.
För att distribuera en Bicep-fil behöver du skrivåtkomst till de resurser som du distribuerar och åtkomst till alla åtgärder i Microsoft.Resources/deployments resurstypen. Om du till exempel vill distribuera en virtuell dator behöver Microsoft.Compute/virtualMachines/write du och Microsoft.Resources/deployments/* behörigheter. Det finns en lista med roller och behörigheter i Inbyggda roller i Azure.

Skapa ett SSH-nyckelpar

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

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

# Create an SSH key pair using Azure CLI
az sshkey create --name "mySSHKey" --resource-group "myResourceGroup"

# Create an SSH key pair using ssh-keygen
ssh-keygen -t rsa -b 4096

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

Granska Bicep-filen

Bicep-filen som används för att skapa ett AKS-kluster kommer från Azure-snabbstartsmallar. Fler AKS-exempel finns i AKS-snabbstartsmallar.

@description('The name of the Managed Cluster resource.')
param clusterName string = 'aks101cluster'

@description('The location of the Managed Cluster resource.')
param location string = resourceGroup().location

@description('Optional DNS prefix to use with hosted Kubernetes API server FQDN.')
param dnsPrefix string

@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.')
@minValue(0)
@maxValue(1023)
param osDiskSizeGB int = 0

@description('The number of nodes for the cluster.')
@minValue(1)
@maxValue(50)
param agentCount int = 3

@description('The size of the Virtual Machine.')
param agentVMSize string = 'standard_d2s_v3'

@description('User name for the Linux Virtual Machines.')
param linuxAdminUsername string

@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\'')
param sshRSAPublicKey string

resource aks 'Microsoft.ContainerService/managedClusters@2024-02-01' = {
  name: clusterName
  location: location
  identity: {
    type: 'SystemAssigned'
  }
  properties: {
    dnsPrefix: dnsPrefix
    agentPoolProfiles: [
      {
        name: 'agentpool'
        osDiskSizeGB: osDiskSizeGB
        count: agentCount
        vmSize: agentVMSize
        osType: 'Linux'
        mode: 'System'
      }
    ]
    linuxProfile: {
      adminUsername: linuxAdminUsername
      ssh: {
        publicKeys: [
          {
            keyData: sshRSAPublicKey
          }
        ]
      }
    }
  }
}

output controlPlaneFQDN string = aks.properties.fqdn

Resursen som definieras i Bicep-filen är Microsoft.ContainerService/managedClusters.

Spara en kopia av filen på main.bicep den lokala datorn.

Lägg till programdefinitionen

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 orderkö.

Kommentar

Vi rekommenderar inte att du kör tillståndskänsliga containrar, till exempel Rabbit MQ, utan beständig lagring för produktion. Dessa används här för enkelhetens skull, men vi rekommenderar att du använder hanterade tjänster, till exempel Azure CosmosDB eller Azure Service Bus.

Skapa en fil med namnet aks-store-quickstart.yaml i samma mapp som main.bicep 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.

Öppna main.bicep i Visual Studio Code.
Tryck på Ctrl+Skift+P för att öppna kommandopaletten.
Sök efter bicep och välj sedan Bicep: Importera Kubernetes Manifest.
Välj aks-store-quickstart.yaml i kommandotolken. Den här processen skapar en aks-store-quickstart.bicep fil i samma mapp.

Öppna main.bicep och lägg till följande Bicep i slutet av filen för att referera till den nyligen skapade aks-store-quickstart.bicep modulen:

module kubernetes './aks-store-quickstart.bicep' = {
  name: 'buildbicep-deploy'
  params: {
    kubeConfig: aks.listClusterAdminCredential().kubeconfigs[0].value
  }
}

Spara både main.bicep och aks-store-quickstart.bicep.

Skapa en Azure-resursgrupp med kommandot az group create .

az group create --name myResourceGroup --location eastus

Distribuera Bicep-filen med kommandot az deployment group create .

az deployment group create --resource-group myResourceGroup --template-file main.bicep --parameters clusterName=<cluster-name> dnsPrefix=<dns-previs> linuxAdminUsername=<linux-admin-username> sshRSAPublicKey='<ssh-key>'

Skapa en Azure-resursgrupp med cmdleten New-AzResourceGroup .

New-AzResourceGroup -Name myResourceGroup -Location eastus

Distribuera Bicep-filen med hjälp av cmdleten New-AzResourceGroupDeployment .

New-AzResourceGroupDeployment -ResourceGroupName myResourceGroup -TemplateFile ./main.bicep -clusterName=<cluster-name> -dnsPrefix=<dns-prefix> -linuxAdminUsername=<linux-admin-username> -sshRSAPublicKey="<ssh-key>"

Ange följande värden i kommandona:

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.
Offentlig SSH RSA-nyckel: Kopiera och klistra in den offentliga delen av SSH-nyckelparet (som standard innehållet i ~/.ssh/id_rsa.pub).

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

Verifiera Bicep-distributionen

Logga in på Azure-portalen.
Gå till AKS-klustret på menyn i Azure-portalen eller på sidan Start .
Under Kubernetes-resurser väljer du Tjänster och ingresser.
Leta upp tjänsten store-front och kopiera värdet för extern IP.
Ö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-självstudien rensar du onödiga resurser för att undvika Azure-avgifter.

Azure CLI
Azure PowerShell

Ta bort resursgruppen, containertjänsten och alla relaterade resurser med kommandot az group delete .

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

Ta bort resursgruppen, containertjänsten och alla relaterade resurser med cmdleten Remove-AzResourceGroup .

Remove-AzResourceGroup -Name myResourceGroup

Kommentar

AKS-klustret skapades med en systemtilldelad hanterad identitet, vilket är standardalternativet för identitet som används i den här snabbstarten. Plattformen hanterar den här identiteten så att du inte behöver ta bort den manuellt.

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.

Självstudiekurs om AKS

Dela via

Snabbstart: Distribuera ett AKS-kluster (Azure Kubernetes Service) med Bicep Kubernetes-tillägget (förhandsversion)

Innan du börjar

Skapa ett SSH-nyckelpar

Granska Bicep-filen

Lägg till programdefinitionen

Distribuera Bicep-filen

Verifiera Bicep-distributionen

Ta bort klustret

Nästa steg

Ytterligare resurser