Szybki start: wdrażanie klastra Azure Container Linux (ACL) w usłudze Azure Kubernetes Service (AKS) przy użyciu szablonu ARM

W tym przewodniku Szybki start użyjesz szablonu Azure Resource Manager (ARM) do utworzenia klastra Azure Kubernetes Service (AKS) z systemem Azure Container Linux (ACL) jako systemu operacyjnego węzła. Po zainstalowaniu wymagań wstępnych należy utworzyć parę kluczy SSH, przejrzeć szablon, wdrożyć szablon i nawiązać połączenie z klastrem.

zagadnienia i ograniczenia dotyczące Azure Container Linux (ACL)

Przed rozpoczęciem zapoznaj się z następującymi kwestiami i ograniczeniami dotyczącymi ACL:

Wymagania wstępne

Note

Możesz użyć usługi Azure Cloud Shell lub lokalnej instalacji interfejsu wiersza polecenia Azure, aby uruchomić polecenia w ramach tego przewodnika Szybki start.

  • Jeśli korzystasz z Azure CLI lokalnie, instaluj Azure CLI. Jeśli korzystasz z systemu Windows lub macOS, rozważ uruchomienie Azure CLI w kontenerze Docker. Aby uzyskać więcej informacji, zobacz Jak uruchomić Azure CLI w kontenerze Docker.
  • Jeśli używasz instalacji lokalnej, zaloguj się do Azure CLI przy użyciu polecenia az login. Aby zakończyć proces uwierzytelniania, wykonaj kroki wyświetlane na Twoim terminalu. Aby uzyskać inne opcje logowania, zobacz Zaloguj się za pomocą Azure CLI.
  • Jeśli zostanie wyświetlony monit, zainstaluj rozszerzenie interfejsu wiersza polecenia platformy Azure podczas pierwszego użycia. Aby uzyskać więcej informacji na temat rozszerzeń, zobacz Korzystanie z rozszerzeń w interfejsie wiersza polecenia platformy Azure.
  • Azure Container Linux wymaga Azure CLI w wersji 2.86.0 lub nowszej. Użyj polecenia az version, aby znaleźć zainstalowaną wersję Azure CLI i biblioteki zależne. Aby przeprowadzić uaktualnienie do najnowszej wersji, użyj az upgrade polecenia .
  • Jeśli nie masz jeszcze zainstalowanego narzędzia kubectl, zainstaluj go za pomocą Azure CLI przy użyciu polecenia az aks install-cli lub postępuj zgodnie z instrukcjami upstream.
  • Aby utworzyć klaster usługi AKS przy użyciu szablonu usługi ARM, musisz podać klucz publiczny SSH. Jeśli potrzebujesz tego zasobu, przejdź do sekcji Tworzenie pary kluczy SSH , aby wygenerować jeden przed wdrożeniem szablonu. Jeśli masz już parę kluczy SSH, możesz przejść do sekcji Przeglądanie szablonu .
  • Tożsamość używana do tworzenia klastra musi mieć odpowiednie minimalne uprawnienia. Aby uzyskać więcej informacji na temat dostępu i tożsamości dla usługi AKS, zobacz Opcje dostępu i tożsamości dla usługi Azure Kubernetes Service (AKS).
  • Aby wdrożyć szablon ARM, musisz mieć uprawnienia do zapisu do wdrażanych zasobów oraz dostęp do wszystkich operacji na typie zasobu Microsoft.Resources/deployments. Aby na przykład wdrożyć maszynę wirtualną (VM), potrzebujesz uprawnień Microsoft.Compute/virtualMachines/write oraz Microsoft.Resources/deployments/*. Aby zapoznać się z listą ról i uprawnień, zobacz wbudowane role w Azure.

Tworzenie pary kluczy SSH

Aby uzyskać dostęp do węzłów usługi AKS, należy nawiązać połączenie przy użyciu pary kluczy SSH (publicznej i prywatnej), która jest generowana przy użyciu ssh-keygen polecenia . Domyślnie te pliki są tworzone w katalogu ~/.ssh . ssh-keygen Uruchomienie polecenia zastępuje dowolną parę kluczy SSH o tej samej nazwie już istniejącej w danej lokalizacji.

  1. Przejdź do witryny , https://shell.azure.com aby otworzyć usługę Cloud Shell w przeglądarce.

  2. Uruchom polecenie ssh-keygen. Poniższy przykład tworzy parę kluczy SSH przy użyciu szyfrowania RSA i długości bitu 4096:

    ssh-keygen -t rsa -b 4096

Aby uzyskać więcej informacji na temat tworzenia kluczy SSH, zobacz Tworzenie kluczy SSH i zarządzanie nimi na potrzeby uwierzytelniania na platformie Azure.

Przegląd szablonu

W poniższym wdrożeniu użyto szablonu ARM z Azure Quickstart Templates:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "clusterName": {
      "type": "string",
      "defaultValue": "aclakscluster",
      "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. Specifying 0 applies 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."
      }
    }
  },
  "resources": [
    {
      "type": "Microsoft.ContainerService/managedClusters",
      "apiVersion": "2026-03-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",
            "osSKU": "AzureContainerLinux",
            "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]"
    }
  }
}

Typ zasobu zdefiniowany w szablonie usługi ARM to Microsoft.ContainerService/managedClusters.

Wdrażanie szablonu

  1. Wybierz pozycję Wdróż na platformie Azure , aby zalogować się i otworzyć szablon.

    Przycisk wdrażania szablonu usługi Resource Manager na platformie Azure.

  2. Na stronie Podstawowe pozostaw wartości domyślne rozmiaru dysku systemu operacyjnego GB, liczba agentów, rozmiar maszyny wirtualnej agenta i typ systemu operacyjnego oraz skonfiguruj następujące parametry szablonu:

    • Subskrypcja: wybierz subskrypcję platformy Azure.
    • Grupa zasobów: wybierz pozycję Utwórz nową. Wprowadź unikatową nazwę grupy zasobów, taką jak myACLResourceGroup, a następnie wybierz przycisk OK.
    • SKU systemu operacyjnego: Określ AzureContainerLinux.
    • Lokalizacja: wybierz lokalizację, na przykład Zachodnie stany USA.
    • Nazwa klastra: wprowadź unikatową nazwę klastra usługi AKS, taką jak myACLCluster.
    • Prefiks DNS: wprowadź unikatowy prefiks DNS dla klastra, taki jak myaclcluster.
    • Nazwa użytkownika administratora systemu Linux: wprowadź nazwę użytkownika, aby nawiązać połączenie przy użyciu protokołu SSH, na przykład azureuser.
    • Źródło klucza publicznego SSH: wybierz pozycję Użyj istniejącego klucza publicznego.
    • Nazwa pary kluczy: Skopiuj i wklej publicznączęść pary kluczy SSH (domyślnie zawartość pliku ~/.ssh/id_rsa.pub).

  3. Wybierz Przejrzyj + Utwórz>Utwórz.

    Utworzenie klastra AKS może potrwać kilka minut. Poczekaj na zakończenie wdrożenia przed nawiązaniem połączenia z klastrem.

Połącz się z klastrem

Aby zarządzać klastrem Kubernetes, użyj klienta wiersza polecenia kubernetes kubectl. kubectl jest już zainstalowany, jeśli używasz usługi Azure Cloud Shell. Aby zainstalować kubectl lokalnie, użyj az aks install-cli polecenia .

  1. Skonfiguruj kubectl, aby nawiązać połączenie z klastrem Kubernetes za pomocą polecenia az aks get-credentials. To polecenie pobiera poświadczenia i konfiguruje Kubernetes CLI do ich użycia.

    az aks get-credentials --resource-group myACLResourceGroup --name myACLCluster

  2. Zweryfikuj połączenie z klastrem, używając polecenia kubectl get. Ta komenda zwraca listę węzłów klastra.

    kubectl get nodes

    W poniższych przykładowych danych wyjściowych przedstawiono trzy węzły utworzone w poprzednich krokach. Upewnij się, że stan węzła to Gotowe:

    NAME                       STATUS   ROLES   AGE     VERSION
aks-agentpool-12345678-0   Ready    agent   6m44s   v1.34.0
aks-agentpool-12345678-1   Ready    agent   6m46s   v1.34.0
aks-agentpool-12345678-2   Ready    agent   6m45s   v1.34.0

Usuwanie klastra

Jeśli nie potrzebujesz już zasobów utworzonych w tym przewodniku Szybki start, możesz je usunąć, aby uniknąć opłat za platformę Azure.

Usuń grupę zasobów Azure i wszystkie powiązane zasoby przy użyciu polecenia az group delete:

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

Treści powiązane

W tym przewodniku Szybki start wdrożono klaster AKS oparty na Azure Container Linux (ACL) przy użyciu szablonu ARM. Aby dowiedzieć się więcej o ACL, zapoznaj się z następującymi materiałami:

  • Last updated on