Delen via

Quickstart: Een AKS-cluster (Azure Kubernetes Service) implementeren met Flatcar Container Linux voor AKS (preview) met behulp van een ARM-sjabloon

Azure Kubernetes Service (AKS) is een beheerde Kubernetes-service waarmee u snel clusters kunt implementeren en beheren. In deze snelstart, gaat u het volgende doen:

  • Een AKS-cluster maken met Flatcar Container Linux voor AKS (preview).
  • Implementeer een AKS-cluster met behulp van een Azure Resource Manager-sjabloon.
  • Voer een voorbeeldtoepassing met meerdere containers uit met een groep microservices en webfront-ends die een retailscenario simuleren.

Een Azure Resource Manager-sjabloon is een JSON-bestand (JavaScript Object Notation) dat de infrastructuur en configuratie voor uw project definieert. De sjabloon maakt gebruik van declaratieve syntaxis. U beschrijft de beoogde implementatie zonder de reeks programmeeropdrachten te schrijven om de implementatie te maken.

Opmerking

Om snel aan de slag te gaan met het snel inrichten van een AKS-cluster, bevat dit artikel stappen voor het implementeren van een cluster met alleen standaardinstellingen voor evaluatiedoeleinden. Voordat u een cluster implementeert dat gereed is voor productie, raden we u aan vertrouwd te raken met de referentiearchitectuur van de basislijn om na te gaan hoe dit overeenkomt met uw bedrijfsvereisten.

Voordat u begint

In dit artikel wordt ervan uitgegaan dat u basiskennis hebt van Kubernetes-concepten. Zie Kubernetes-kernconcepten voor Azure Kubernetes Service (AKS) voor meer informatie.

Nadat u het cluster vanuit de sjabloon hebt geïmplementeerd, kunt u Azure CLI of Azure PowerShell gebruiken om verbinding te maken met het cluster en de voorbeeldtoepassing te implementeren.

De leveranciers van bronnen registreren

Mogelijk moet u resourceproviders registreren in uw Azure-abonnement. Bijvoorbeeld is Microsoft.ContainerService vereist.

Controleer de registratiestatus met behulp van de az provider show opdracht.

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

Registreer indien nodig de resourceprovider met behulp van de opdracht az provider register .

az provider register --namespace Microsoft.ContainerService

Extensie installeren aks-preview

Belangrijk

AKS preview-functies zijn beschikbaar op selfservice, opt-in basis. Previews worden geleverd 'zoals het is' en 'voor zover beschikbaar' en zijn uitgesloten van de serviceovereenkomsten en beperkte garantie. AKS-previews worden gedeeltelijk gedekt door klantondersteuning naar best vermogen. Zodoende zijn deze functies niet bedoeld voor productiegebruik. Zie de volgende ondersteuningsartikelen voor meer informatie:

  1. Installeer de aks-preview Azure CLI-extensie met behulp van de az extension add opdracht.

    az extension add --name aks-preview

  2. Werk bij naar de nieuwste versie van de extensie met behulp van de az extension update opdracht. Flatcar Container Linux vereist minimaal 18.0.0b42.

    az extension update --name aks-preview

Registreer functiekenmerk AKSFlatcarPreview

  1. Registreer de AKSFlatcarPreview functievlag met behulp van de az feature register opdracht.

    az feature register --namespace "Microsoft.ContainerService" --name "AKSFlatcarPreview"

  2. Controleer de registratiestatus met behulp van de az feature show opdracht. Het duurt enkele minuten voordat de status Geregistreerd wordt weergegeven.

    az feature show --namespace Microsoft.ContainerService --name AKSFlatcarPreview

  3. Wanneer de status Geregistreerd aangeeft, vernieuwt u de registratie van de Microsoft.ContainerService-resourceprovider met behulp van de az provider register-opdracht.

    az provider register --namespace Microsoft.ContainerService

Een SSH-sleutelpaar maken

Als u een AKS-cluster wilt maken met behulp van een ARM-sjabloon, geeft u een openbare SSH-sleutel op. Als u deze resource nodig hebt, volgt u de stappen in deze sectie. Sla anders over naar de sectie sjabloon controleren.

Voor toegang tot AKS-knooppunten maakt u verbinding met behulp van een SSH-sleutelpaar (openbaar en privé). Een SSH-sleutelpaar maken:

  1. Ga naar https://shell.azure.com om Cloud Shell in uw browser te openen.

  2. Maak een resourcegroep met de opdracht az group create.

    az group create \
  --name myResourceGroup \
  --location eastus

  3. Maak een SSH-sleutelpaar met behulp van de opdracht az sshkey create of de ssh-keygen opdracht.

    az sshkey create --name mySSHKey --resource-group myResourceGroup

    Of maak een SSH-sleutelpaar met behulp van ssh-keygen

    ssh-keygen -t rsa -b 4096

  4. Als u de sjabloon wilt implementeren, moet u de openbare sleutel van het SSH-paar opgeven. Haal de openbare sleutel op met behulp van de az sshkey show opdracht.

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

    Standaard worden de SSH-sleutelbestanden gemaakt in de map ~/.ssh . Het uitvoeren van de az sshkey create- of ssh-keygen-opdracht overschrijft elk bestaand SSH-sleutelpaar met dezelfde naam.

    Zie SSH-sleutels maken en beheren voor verificatie in Azure voor meer informatie over het maken van SSH-sleutels.

De sjabloon controleren

De sjabloon die in deze quickstart wordt gebruikt, komt uit Azure-snelstartsjablonen.

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

Het resourcetype dat is gedefinieerd in de ARM-sjabloon is Microsoft.ContainerService/managedClusters.

Zie de site AKS-quickstartsjablonen voor meer AKS-voorbeelden.

De sjabloon implementeren

  1. Selecteer Implementeren in Azure om u aan te melden en een sjabloon te openen.

    Knop voor het implementeren van de Resource Manager-sjabloon in Azure.

  2. Laat op de pagina Basisinformatie de standaardwaarden staan voor de schijfgrootte van het besturingssysteem, het aantal agents, de grootte van de agent-VM en het type besturingssysteem en configureert u de volgende sjabloonparameters:

    • Abonnement: Selecteer een Azure-abonnement.
    • Resourcegroep: Selecteer Nieuw maken. Voer een unieke naam in voor de resourcegroep, zoals myResourceGroup, en selecteer VERVOLGENS OK.
    • OS-SKU: geef flatcar op als u de SKU van het besturingssysteem niet bijwerkt, de standaardwaarde is Ubuntu.
    • Locatie: Selecteer een locatie, zoals VS - oost.
    • Clusternaam: Voer een unieke naam in voor het AKS-cluster, zoals myAKSCluster.
    • DNS-voorvoegsel: voer een uniek DNS-voorvoegsel in voor uw cluster, zoals myakscluster.
    • Gebruikersnaam voor Linux-beheerder: voer een gebruikersnaam in om verbinding te maken met behulp van SSH, zoals azureuser.
    • Openbare SSH-sleutelbron: selecteer Bestaande openbare sleutel gebruiken.
    • Naam van sleutelpaar: kopieer en plak het openbare deel van uw SSH-sleutelpaar (standaard de inhoud van ~/.ssh/id_rsa.pub).

  3. Selecteer Beoordelen en maken>Maken.

Het duurt enkele minuten om het AKS-cluster te maken. Wacht totdat het cluster met succes is geïmplementeerd voordat u met de volgende stap verdergaat.

Verbinding maken met het cluster

Als u een Kubernetes-cluster wilt beheren, gebruikt u de Kubernetes-opdrachtregelclient kubectl.

Als u Azure Cloud Shell gebruikt, is kubectl al geïnstalleerd. Gebruik de kubectl opdracht om lokaal te installeren en uit te voerenaz aks install-cli.

  1. Configureer kubectl om verbinding te maken met uw Kubernetes-cluster met behulp van het az aks get-credentials commando. Bij deze opdracht worden inloggegevens gedownload en wordt de Kubernetes CLI geconfigureerd om deze te gebruiken.

    az aks get-credentials \
  --resource-group myResourceGroup \
  --name myAKSCluster

  2. Controleer de verbinding met uw cluster met behulp van de kubectl get opdracht. Met deze opdracht wordt een lijst met de clusterknooppunten geretourneerd.

    kubectl get nodes

    In de volgende voorbeelduitvoer ziet u de drie knooppunten die in de vorige stappen zijn gemaakt. Zorg ervoor dat de status van het knooppunt gereed is:

    NAME                                STATUS   ROLES   AGE   VERSION
aks-agentpool-38955149-vmss000000   Ready    <none>   5m53s   v1.32.7
aks-agentpool-38955149-vmss000001   Ready    <none>   6m31s   v1.32.7
aks-agentpool-238955149-vmss000002   Ready    <none>   6m35s   v1.32.7

De toepassing implementeren

Als u de toepassing wilt implementeren, gebruikt u een manifestbestand om alle objecten te maken die nodig zijn om de AKS Store-toepassing uit te voeren. Een Kubernetes-manifestbestand definieert de gewenste status van een cluster, zoals welke containerinstallatiekopieën moeten worden uitgevoerd. Het manifest bevat de volgende Kubernetes-implementaties en -services:

Schermopname van azure Store-voorbeeldarchitectuur.

  • Webwinkel: Webtoepassing voor klanten om producten te bekijken en bestellingen te plaatsen.
  • Productservice: toont productgegevens.
  • Orderservice: Orders plaatsen.
  • Rabbit MQ: Berichtensysteem voor een bestelwachtrij.

Opmerking

We raden aan om stateful containers, zoals RabbitMQ, niet te gebruiken zonder permanente opslag voor productie. Deze worden hier gebruikt voor het gemak, maar we raden u aan beheerde services te gebruiken, zoals Azure Cosmos DB of Azure Service Bus.

  1. Maak een bestand met de naam aks-store-quickstart.yaml en kopieer dit in het volgende 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

    Zie Implementaties en YAML-manifestmanifesten voor een uitsplitsing van YAML-manifestbestanden.

    Als u het YAML-bestand lokaal maakt en opslaat, kunt u het manifestbestand uploaden naar uw standaardmap in CloudShell door de knop Bestanden uploaden/downloaden te selecteren en het bestand in uw lokale bestandssysteem te selecteren.

  2. Implementeer de toepassing met behulp van de kubectl apply opdracht en geef de naam van uw YAML-manifest op.

    kubectl apply -f aks-store-quickstart.yaml

    In de volgende voorbeelduitvoer ziet u de implementaties en services:

    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

De toepassing testen

  1. Controleer de status van de geïmplementeerde pods met behulp van de kubectl get pods opdracht. Zorg ervoor dat alle pods Running zijn voordat u doorgaat.

    kubectl get pods

  2. Controleer op een openbaar IP-adres voor de store-front-toepassing. Bewaak de voortgang met behulp van de kubectl get service opdracht met het --watch argument.

    kubectl get service store-front --watch

    De uitvoer van het externe IP-adres voor de store-front service wordt in eerste instantie weergegeven als in afwachting:

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

  3. Zodra het EXTERNAL-IP-adres is gewijzigd van pending in een openbaar IP-adres, gebruikt u CTRL-C om het kubectl-controleproces te stoppen.

    In de volgende voorbeelduitvoer ziet u een geldig openbaar IP-adres dat aan de service is toegewezen:

    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. Open een webbrowser naar het externe IP-adres van uw service om de Azure Store-app in actie te zien:

    Schermopname van de AKS Store-voorbeeldtoepassing.

Het cluster verwijderen

Als u niet van plan bent om de AKS-zelfstudie te doorlopen, moet u overbodige resources opschonen om Azure-kosten te voorkomen.

  • Verwijder de resourcegroep, containerservice en alle gerelateerde resources met behulp van de az group delete opdracht.
az group delete --name myResourceGroup

Opmerking

Het AKS-cluster is gemaakt met een door het systeem toegewezen beheerde identiteit. Dit is de standaardidentiteitsoptie die in deze quickstart wordt gebruikt. Het platform beheert deze identiteit, zodat u deze niet handmatig hoeft te verwijderen.

Volgende stappen

In deze quickstart hebt u een Kubernetes-cluster geïmplementeerd en vervolgens een eenvoudige toepassing met meerdere containers erop geïmplementeerd. Deze voorbeeldtoepassing is alleen bedoeld voor demodoeleinden en vertegenwoordigt niet alle aanbevolen procedures voor Kubernetes-toepassingen. Zie de richtlijnen voor AKS-oplossingen voor meer informatie over het maken van volledige oplossingen met AKS voor productie.

Als u meer wilt weten over AKS en een volledig voorbeeld van code-naar-implementatie wilt doorlopen, gaat u verder met de zelfstudie over het Kubernetes-cluster.

AKS-handleiding

  • Last updated on