Erstellen von Kubernetes-Clustern mit Azure CLI

Gilt für: AKS auf Azure Local

In diesem Artikel wird beschrieben, wie Kubernetes-Cluster in Azure Local mit Azure CLI erstellt werden. Der folgende Workflow wird verwendet:

1. Erstellen Sie einen Kubernetes-Cluster in Azure Local mit Azure CLI. Der Cluster ist standardmäßig mit Azure Arc verbunden.
2. Beim Erstellen des Clusters stellen Sie eine Microsoft Entra-Gruppe bereit, die die Liste der Microsoft Entra-Benutzer mit Kubernetes-Clusteradministratorzugriff enthält.
3. Greifen Sie mithilfe von Kubectl und Ihrer Microsoft Entra-ID auf den Cluster zu.
4. Führen Sie eine Beispielanwendung mit mehreren Containern im Cluster aus, die ein Web-Front-End und eine Redis-Instanz enthält.

Bevor Sie beginnen

• Bevor Sie beginnen, stellen Sie sicher, dass Sie über die folgenden Details von Ihrem lokalen Infrastrukturadministrator verfügen:
  • Azure-Abonnement-ID – Die Azure-Abonnement-ID , in der Azure Local für die Bereitstellung und Registrierung verwendet wird.
  • Benutzerdefinierte Standort-ID – Azure Resource Manager-ID des benutzerdefinierten Speicherorts. Der benutzerdefinierte Speicherort wird während der Azure Local Cluster-Bereitstellung konfiguriert. Ihr Infrastrukturadministrator sollte Ihnen die Resource-Manager-ID des benutzerdefinierten Standorts geben. Dieser Parameter ist erforderlich, um Kubernetes-Cluster zu erstellen. Sie können auch die Ressourcen-Manager-ID mit az customlocation show --name "<custom location name>" --resource-group <azure resource group> --query "id" -o tsv erhalten, wenn der Infrastrukturadministrator einen benutzerdefinierten Standortnamen und einen Ressourcengruppennamen bereitstellt.
  • Netzwerk-ID – Azure Resource Manager-ID des logischen Azure-Netzwerks, das mit diesen Schritten erstellt wurde. Ihr Administrator sollte Ihnen die ID des logischen Netzwerks geben. Dieser Parameter ist erforderlich, um Kubernetes-Cluster zu erstellen. Sie können auch die Azure Resource Manager-ID az stack-hci-vm network lnet show --name "<lnet name>" --resource-group <azure resource group> --query "id" -o tsv abrufen, wenn Sie die Ressourcengruppe kennen, in der das logische Netzwerk erstellt wurde.
• Sie können die Schritte in diesem Artikel auf einem lokalen Entwicklungscomputer ausführen, um einen Kubernetes-Cluster in Ihrer lokalen Azure-Remotebereitstellung zu erstellen. Stellen Sie sicher, dass Sie die neueste Version von Az CLI auf Ihrem Entwicklungscomputer haben. Sie können sich auch dafür entscheiden, Ihre Az CLI-Version mit az upgradezu aktualisieren.
• Um von überall aus eine Verbindung mit dem Kubernetes-Cluster herzustellen, erstellen Sie eine Microsoft Entra-Gruppe, und fügen Sie ihr Mitglieder hinzu. Alle Mitglieder in der Microsoft Entra-Gruppe haben Clusteradministratorzugriff auf den Cluster. Stellen Sie sicher, dass Sie sich selbst als Mitglied zur Microsoft Entra-Gruppe hinzufügen. Wenn Sie sich nicht selbst hinzufügen, können Sie nicht mithilfe von Kubectl auf den Kubernetes-Cluster zugreifen. Weitere Informationen zum Erstellen von Microsoft Entra-Gruppen und zum Hinzufügen von Benutzern finden Sie unter Verwalten von Microsoft Entra-Gruppen und Gruppenmitgliedschaften.
• Laden Sie Kubectl auf Ihrem Entwicklungscomputer herunter, und installieren Sie es. Mit dem Befehlszeilentool Kubernetes, Kubectl, können Sie Befehle für Kubernetes-Cluster ausführen. Sie können Kubectl verwenden, um Anwendungen bereitzustellen, Clusterressourcen zu prüfen und zu verwalten und Protokolle anzuzeigen.

Installieren der Azure CLI-Erweiterung

Führen Sie die folgenden Befehle aus, um die erforderlichen Azure CLI-Erweiterungen zu installieren.

az extension add -n aksarc --upgrade
az extension add -n customlocation --upgrade
az extension add -n stack-hci-vm --upgrade
az extension add -n connectedk8s --upgrade

Erstellen eines Kubernetes-Clusters

Verwenden Sie den Befehl "az aksarc create " zum Erstellen eines Kubernetes-Clusters in AKS Arc. Stellen Sie sicher, dass Sie sich bei Azure anmelden, bevor Sie diesen Befehl ausführen. Wenn Sie über mehrere Azure-Abonnements verfügen, wählen Sie mithilfe des Befehls az account set das entsprechende Abonnement ID aus. Mit dem az aksarc create Befehl wird empfohlen, das --validate Flag zu verwenden, das die eingabeparameter überprüft, die Sie verwenden möchten. Nachdem die Eingabeparameter überprüft wurden, können Sie den az aksarc create Befehl ohne das --validate Kennzeichen ausführen, um den Kubernetes-Cluster zu erstellen.

az aksarc create -n $aksclustername -g $resource_group --custom-location $customlocationID --vnet-ids $logicnetId --aad-admin-group-object-ids $aadgroupID --generate-ssh-keys 

Nach wenigen Minuten ist die Ausführung des Befehls abgeschlossen, und es werden Informationen zum Cluster im JSON-Format zurückgegeben.

Überlegungen

Beachten Sie beim Erstellen eines Clusters die folgenden Überlegungen:

• SSH-Schlüssel sind für die Fehlersuche und Protokollerfassung unerlässlich. Speichern Sie Ihre private Schlüsseldatei zur späteren Verwendung. Informationen zum Zugreifen auf Knoten finden Sie unter Herstellen einer Verbindung mit Windows- oder Linux-Workerknoten mit SSH.
• Sie können während der Clustererstellung einen bereits vorhandenen SSH-Schlüssel verwenden oder SSH-Schlüssel für einen AKS-Cluster konfigurieren . Wenn auf Ihrem lokalen Computer kein bereits vorhandener SSH-Schlüssel vorhanden ist, ist der --generate-ssh-keys Parameter erforderlich. Sie können auch den SSH-Zugriff einschränken, indem Sie die Dokumentation ausführen. Ausführliche Anweisungen finden Sie unter Erstellen und Speichern von SSH-Schlüsseln mit der Azure CLI oder im Azure-Portal.
• Wenn Sie während der Clustererstellung nicht einschließen --generate-ssh-keys und kein SSH-Schlüssel vorhanden ist, wird eine Fehlermeldung angezeigt. Wenn Sie bereits über einen SSH-Schlüssel auf Ihrem lokalen Computer verfügen, verwendet der AKS-Cluster ihn wieder. In diesem Fall macht es keinen Unterschied, ob Sie angeben --generate-ssh-keys oder nicht.
• Standardmäßig wird der SSH-Schlüssel unter ~/.ssh/id_rsa.pub gespeichert. Während der Clustererstellung können Sie einen alternativen Speicherort mithilfe des --ssh-key-value Parameters angeben.

Herstellen einer Verbindung mit dem Kubernetes-Cluster

Jetzt können Sie eine Verbindung mit Ihrem Kubernetes-Cluster herstellen, indem Sie den az connectedk8s proxy Befehl von Ihrem Entwicklungscomputer aus ausführen. Stellen Sie sicher, dass Sie sich bei Azure anmelden, bevor Sie diesen Befehl ausführen. Wenn Sie über mehrere Azure-Abonnements verfügen, wählen Sie mithilfe des Befehls az account set das entsprechende Abonnement ID aus.

Dieser Befehl lädt die Kubeconfig Ihres Kubernetes-Clusters auf Ihren Entwicklungscomputer herunter und öffnet einen Proxyverbindungskanal zu Ihrem lokalen Kubernetes-Cluster. Der Kanal ist so lange geöffnet, wie der Befehl ausgeführt wird. Führen Sie den Befehl so lange aus, wie Sie auf Ihren Cluster zugreifen möchten. Wenn das Fenster ausläuft, schließen Sie das CLI-Fenster, öffnen Sie ein neues Fenster, und führen Sie den Befehl erneut aus.

Sie müssen über Mitwirkendeberechtigungen für die Ressourcengruppe verfügen, die den Kubernetes-Cluster hosten, um den folgenden Befehl erfolgreich auszuführen:

az connectedk8s proxy --name $aksclustername --resource-group $resource_group --file .\aks-arc-kube-config

Erwartete Ausgabe:

Proxy is listening on port 47011
Merged "aks-workload" as current context in .\\aks-arc-kube-config
Start sending kubectl requests on 'aks-workload' context using
kubeconfig at .\\aks-arc-kube-config
Press Ctrl+C to close proxy.

Lassen Sie diese Sitzung laufen und verbinden Sie sich mit Ihrem Kubernetes-Cluster über ein anderes Terminal oder eine Eingabeaufforderung. Stellen Sie sicher, dass Sie eine Verbindung mit Ihrem Kubernetes-Cluster herstellen können, indem Sie den Befehl "kubectl get" ausführen. Dieser Befehl gibt eine Liste der Clusterknoten zurück:

kubectl get node -A --kubeconfig .\aks-arc-kube-config

Das folgende Ausgabebeispiel zeigt den Knoten, der in den vorherigen Schritten erstellt wurde. Stellen Sie sicher, dass der Knotenstatus Bereit lautet:

NAME             STATUS ROLES                AGE VERSION
moc-l0ttdmaioew  Ready  control-plane,master 34m v1.24.11
moc-ls38tngowsl  Ready  <none>               32m v1.24.11

Bereitstellen Sie die Anwendung und den Lastverteiler

Eine Kubernetes-Manifestdatei definiert den gewünschten Zustand (Desired State) eines Clusters – also beispielsweise, welche Containerimages ausgeführt werden sollen.

Sie können ein Manifest verwenden, um alle Objekte zu erstellen, die zum Ausführen der Azure-Abstimmungsanwendung erforderlich sind. Dieses Manifest umfasst zwei Kubernetes-Bereitstellungen:

• Die Azure Vote-Python-Beispielanwendungen
• Eine Redis-Instanz

Zwei Kubernetes-Dienste werden ebenfalls erstellt:

• Ein interner Dienst für die Redis-Instanz
• Ein externer Dienst für den Zugriff auf die Azure Vote-Anwendung über das Internet

Erstellen Sie eine Datei namens "azure-vote.yaml", und kopieren Sie sie im folgenden Manifest:

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: <path to image>/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: <path to image>/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

Stellen Sie die Anwendung mithilfe des kubectl apply-Befehls bereit, und geben Sie den Namen Ihres YAML an:

kubectl apply -f azure-vote.yaml --kubeconfig .\\aks-arc-kube-config

Die folgende Beispielausgabe zeigt die erfolgreich erstellten Bereitstellungen und Dienste:

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

Stellen Sie einen MetalLB-Lastenausgleich bereit, damit er eine externe IP für das Anwendungs-Front-End zuweisen kann. Sie können diese Anweisungen befolgen , um die MetalLB-Erweiterung über das Azure-Portal bereitzustellen oder CLI zu verwenden.

Testen der Anwendung

Wenn die Anwendung ausgeführt wird, macht ein Kubernetes-Dienst das Anwendungs-Front-End im Internet verfügbar. Dieser Vorgang kann einige Minuten dauern.

Überwachen Sie den Fortschritt mithilfe des Befehls "kubectl get service" mit dem --watch Argument.

kubectl get service azure-vote-front --watch --kubeconfig .\aks-arc-kube-config

Die EXTERNAL-IP-Ausgabe für den Dienst azure-vote-front wird zunächst als Ausstehendangezeigt.

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

Sobald sich die EXTERNAL-IP-Adresse von ausstehend zu einer tatsächlichen öffentlichen IP-Adresse ändert, verwenden Sie STRG-C, um den kubectl-Watch-Prozess zu stoppen. Die folgende Beispielausgabe zeigt eine gültige öffentliche IP-Adresse, die dem Dienst zugewiesen ist:

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

Öffnen Sie die externe IP-Adresse Ihres Diensts in einem Webbrowser, um die Azure-Abstimmungs-App in Aktion zu sehen.

Löschen des Clusters

Führen Sie den az aksarc delete Befehl aus, um den erstellten Cluster zu bereinigen:

az aksarc delete --name $aksclustername --resource-group $resource_group

Nächste Schritte

• Fehlerbehebung und bekannte Probleme bei der Bereitstellung von Clustern aus Azure 6