Delen via


Quickstart: Een Azure Linux-containerhost voor AKS-cluster implementeren met behulp van een ARM-sjabloon

Ga aan de slag met de Azure Linux Container Host met behulp van een ARM-sjabloon (Azure Resource Manager) om een Azure Linux Container Host-cluster te implementeren. Nadat u de vereisten hebt geïnstalleerd, maakt u een SSH-sleutelpaar, controleert u de sjabloon, implementeert u de sjabloon en valideert u deze en implementeert u vervolgens een toepassing.

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

Vereisten

  • Als u geen Azure-abonnement hebt, kunt u een gratis Azure-account maken voordat u begint.

  • Gebruik de Bash-omgeving in Azure Cloud Shell. Zie Azure Cloud Shell-snelstart: Bash voor meer informatie.

  • Installeer de Azure CLI, indien gewenst, om CLI-referentieopdrachten uit te voeren. Als u in Windows of macOS werkt, kunt u Azure CLI uitvoeren in een Docker-container. Zie De Azure CLI uitvoeren in een Docker-container voor meer informatie.

    • Als u een lokale installatie gebruikt, meldt u zich aan bij Azure CLI met behulp van de opdracht az login. Volg de stappen die worden weergegeven in de terminal, om het verificatieproces te voltooien. Raadpleeg Aanmelden bij Azure CLI voor aanvullende aanmeldingsopties.

    • Installeer de Azure CLI-extensie bij het eerste gebruik, wanneer u hierom wordt gevraagd. Raadpleeg Extensies gebruiken met Azure CLI voor meer informatie over extensies.

    • Voer az version uit om de geïnstalleerde versie en afhankelijke bibliotheken te vinden. Voer az upgrade uit om te upgraden naar de nieuwste versie.

  • Als u kubectl nog niet hebt geïnstalleerd, installeert u deze via Azure CLI met behulp van az aks install-cli de upstream-instructies of volgt u de upstream-instructies.

  • Als u een AKS-cluster wilt maken met behulp van een Resource Manager-sjabloon, geeft u een openbare SSH-sleutel op. Als u deze resource nodig hebt, raadpleegt u de volgende sectie; ga anders naar de sectie Sjabloon controleren.

  • De identiteit die u gebruikt om uw cluster te maken, heeft de juiste minimale machtigingen. Zie Toegangs- en identiteitsopties voor Azure Kubernetes Service (AKS) voor meer informatie over toegang en identiteit voor AKS.

  • Als u een Bicep-bestand of ARM-sjabloon wilt implementeren, hebt u schrijftoegang nodig voor de resources die u implementeert en moet u zijn gemachtigd om alle bewerkingen op het resourcetype Microsoft.Resources/deployments te kunnen uitvoeren. Als u bijvoorbeeld een virtuele machine wilt implementeren, hebt u de machtigingen Microsoft.Compute/virtualMachines/write en Microsoft.Resources/deployments/* nodig. Zie Ingebouwde Azure-rollen voor een lijst met rollen en machtigingen.

Een SSH-sleutelpaar maken

Voor toegang tot AKS-knooppunten maakt u verbinding met behulp van een SSH-sleutelpaar (openbaar en privé) dat u genereert met behulp van de ssh-keygen opdracht. Deze bestanden worden standaard gemaakt in de map ~/.ssh. Als u de ssh-keygen opdracht uitvoert, overschrijft u een SSH-sleutelpaar met dezelfde naam die al bestaat op de opgegeven locatie.

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

  2. Voer de opdracht ssh-keygen uit. In het volgende voorbeeld wordt een SSH-sleutelpaar gemaakt met RSA-versleuteling en een bitlengte van 4096:

    ssh-keygen -t rsa -b 4096
    

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

De sjabloon controleren

Voor de volgende implementatie wordt een ARM-sjabloon uit Azure-quickstartsjablonen gebruikt.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.1",
  "parameters": {
    "clusterName": {
      "type": "string",
      "defaultValue": "azurelinuxakscluster",
      "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_DS2_v2",
      "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'"
      }
    },
    "osType": {
      "type": "string",
      "defaultValue": "Linux",
      "allowedValues": [
        "Linux"
      ],
      "metadata": {
        "description": "The type of operating system."
      }
    },
    "osSKU": {
      "type": "string",
      "defaultValue": "AzureLinux",
      "allowedValues": [
        "AzureLinux",
        "Ubuntu"
      ],
      "metadata": {
        "description": "The Linux SKU to use."
      }
    }
  },
  "resources": [
    {
      "type": "Microsoft.ContainerService/managedClusters",
      "apiVersion": "2021-03-01",
      "name": "[parameters('clusterName')]",
      "location": "[parameters('location')]",
      "properties": {
        "dnsPrefix": "[parameters('dnsPrefix')]",
        "agentPoolProfiles": [
          {
            "name": "agentpool",
            "mode": "System",
            "osDiskSizeGB": "[parameters('osDiskSizeGB')]",
            "count": "[parameters('agentCount')]",
            "vmSize": "[parameters('agentVMSize')]",
            "osType": "[parameters('osType')]",
            "osSKU": "[parameters('osSKU')]",
            "storageProfile": "ManagedDisks"
          }
        ],
        "linuxProfile": {
          "adminUsername": "[parameters('linuxAdminUsername')]",
          "ssh": {
            "publicKeys": [
              {
                "keyData": "[parameters('sshRSAPublicKey')]"
              }
            ]
          }
        }
      },
      "identity": {
          "type": "SystemAssigned"
      }
    }
  ],
  "outputs": {
    "controlPlaneFQDN": {
      "type": "string",
      "value": "[reference(parameters('clusterName')).fqdn]"
    }
  }
}

Als u Azure Linux wilt toevoegen aan een bestaande ARM-sjabloon, moet u de apiVersion toevoegen "osSKU": "AzureLinux" en "mode": "System" agentPoolProfiles instellen op 2021-03-01 of hoger ("apiVersion": "2021-03-01").

De sjabloon implementeren

  1. Selecteer de volgende knop om u aan te melden bij Azure en een sjabloon te openen.

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

  2. Typ of selecteer de volgende waarden.

    Voor deze quickstart behoudt u de standaardwaarden voor besturingssysteemschijfgrootte (GB), aantal agenten, agentgrootte van de virtuele machine, type besturingssysteem en Kubernetes-versie. Geef uw eigen waarden op voor de volgende sjabloonparameters:

    • Subscription: selecteer een Azure-abonnement.
    • Resourcegroep: Selecteer Nieuwe maken. Voer een unieke naam in voor de resourcegroep, zoals testAzureLinuxResourceGroup en kies VERVOLGENS OK.
    • Locatie: Selecteer een locatie, zoals VS - oost.
    • Clusternaam: Voer een unieke naam in voor het AKS-cluster, zoals testAzureLinuxCluster.
    • DNS-voorvoegsel: voer een uniek DNS-voorvoegsel in voor uw cluster, zoals myAzureLinuxCluster.
    • Gebruikersnaam voor Linux-beheerder: voer een gebruikersnaam in om verbinding te maken met behulp van SSH, zoals azureUser.
    • Openbare SSH RSA-sleutel: kopieer en plak het openbare deel van uw SSH-sleutelpaar (standaard de inhoud van ~/.ssh/id_rsa.pub).

    Schermopname van de Resource Manager-sjabloon voor het maken van een Azure Kubernetes Service-cluster in de portal.

  3. Selecteer Controleren + maken.

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

De implementatie valideren

Verbinding maken met het cluster

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

  1. Lokaal installeren kubectl met behulp van de az aks install-cli opdracht:

    az aks install-cli
    
  2. Configureer kubectl deze om verbinding te maken met uw Kubernetes-cluster met behulp van de az aks get-credentials opdracht. Bij deze opdracht worden referenties gedownload en wordt Kubernetes CLI geconfigureerd voor het gebruik van deze referenties.

    az aks get-credentials --resource-group testAzureLinuxResourceGroup --name testAzureLinuxCluster
    
  3. 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 het volgende uitvoervoorbeeld 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-41324942-0   Ready    agent   6m44s   v1.12.6
    aks-agentpool-41324942-1   Ready    agent   6m46s   v1.12.6
    aks-agentpool-41324942-2   Ready    agent   6m45s   v1.12.6
    

De toepassing implementeren

Een Kubernetes-manifestbestand definieert de gewenste status van een cluster, zoals welke containerinstallatiekopieën moeten worden uitgevoerd.

In deze quickstart gebruikt u een manifest om alle objecten te maken die nodig zijn om de Azure Vote-toepassing uit te voeren. Dit manifest bevat twee Kubernetes-implementaties:

  • De Azure Vote Python-voorbeeldtoepassingen.
  • Een Redis-exemplaar.

Er worden ook twee Kubernetes-services gemaakt:

  • Een interne service voor het Redis-exemplaar.
  • Een externe service voor toegang tot de Azure Vote-toepassing vanaf internet.
  1. Maak een bestand met de naam azure-vote.yaml.

    • Als u De Azure Cloud Shell gebruikt, kan dit bestand worden gemaakt met behulp van code, viof nano alsof u aan een virtueel of fysiek systeem werkt
  2. Kopieer deze in de volgende YAML-definitie:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: azure-vote-back
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: azure-vote-back
      template:
        metadata:
          labels:
            app: azure-vote-back
        spec:
          nodeSelector:
            "kubernetes.io/os": linux
          containers:
          - name: azure-vote-back
            image: mcr.microsoft.com/oss/bitnami/redis:6.0.8
            env:
            - name: ALLOW_EMPTY_PASSWORD
              value: "yes"
            resources:
              requests:
                cpu: 100m
                memory: 128Mi
              limits:
                cpu: 250m
                memory: 256Mi
            ports:
            - containerPort: 6379
              name: redis
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: azure-vote-back
    spec:
      ports:
      - port: 6379
      selector:
        app: azure-vote-back
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: azure-vote-front
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: azure-vote-front
      template:
        metadata:
          labels:
            app: azure-vote-front
        spec:
          nodeSelector:
            "kubernetes.io/os": linux
          containers:
          - name: azure-vote-front
            image: mcr.microsoft.com/azuredocs/azure-vote-front:v1
            resources:
              requests:
                cpu: 100m
                memory: 128Mi
              limits:
                cpu: 250m
                memory: 256Mi
            ports:
            - containerPort: 80
            env:
            - name: REDIS
              value: "azure-vote-back"
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: azure-vote-front
    spec:
      type: LoadBalancer
      ports:
      - port: 80
      selector:
        app: azure-vote-front
    

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

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

    kubectl apply -f azure-vote.yaml
    

    Het volgende voorbeeld lijkt op uitvoer met de gemaakte implementaties en services:

    deployment "azure-vote-back" created
    service "azure-vote-back" created
    deployment "azure-vote-front" created
    service "azure-vote-front" created
    

De toepassing testen

Wanneer de toepassing wordt uitgevoerd, maakt een Kubernetes-service de front-end van de toepassing beschikbaar op internet. Dit proces kan enkele minuten duren.

Controleer de voortgang met behulp van de opdracht kubectl get service met het --watch argument.

kubectl get service azure-vote-front --watch

De UITVOER VAN HET EXTERNE IP-adres voor de azure-vote-front service wordt in eerste instantie weergegeven als in behandeling.

NAME               TYPE           CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
azure-vote-front   LoadBalancer   10.0.37.27   <pending>     80:30572/TCP   6s

Zodra het EXTERNAL-IP-adres is gewijzigd in een daadwerkelijk openbaar IP-adres, gebruikt CTRL-C u dit om het kubectl controleproces te stoppen. In de volgende voorbeelduitvoer ziet u een geldig openbaar IP-adres dat aan de service is toegewezen:

azure-vote-front   LoadBalancer   10.0.37.27   52.179.23.131   80:30572/TCP   2m

Open een webbrowser naar het externe IP-adres van uw service om de Azure Vote-app te zien.

Schermopname van bladeren naar azure Vote-voorbeeldtoepassing.

Het cluster verwijderen

Als u niet doorgaat met de volgende zelfstudies, om te voorkomen dat Azure-kosten onnodige resources opschonen. Gebruik de az group delete opdracht om de resourcegroep en alle gerelateerde resources te verwijderen.

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

Volgende stappen

In deze quickstart hebt u een Azure Linux Container Host-cluster geïmplementeerd. Als u meer wilt weten over de Azure Linux Container Host en een volledig voorbeeld van clusterimplementatie en -beheer doorloopt, gaat u verder met de zelfstudie over Azure Linux Container Host.