Freigeben über

Zugreifen auf Kubernetes-Ressourcen mit dem Azure-Portal

  • Artikel

In diesem Artikel erfahren Sie, wie Sie mithilfe des Azure-Portals auf Ihre Azure Kubernetes Service (AKS)-Ressourcen zugreifen und diese verwalten.

Voraussetzungen

Um Kubernetes-Ressourcen im Azure-Portal anzuzeigen, benötigen Sie einen AKS-Cluster. Jeder Cluster wird unterstützt, aber wenn Sie die Microsoft Entra Integration verwenden, muss Ihr Cluster die von AKS verwaltete Microsoft Entra Integration verwenden. Wenn Ihr Cluster Legacy-Microsoft Entra ID verwendet, können Sie ein Upgrade Ihres Clusters im Portal oder mithilfe der Azure CLI durchführen. Sie können auch das Azure-Portal verwenden, um einen neuen AKS-Cluster zu erstellen.

Anzeigen von Kubernetes-Ressourcen

  1. Navigieren Sie im Azure-Portal zur AKS-Clusterressource.

  2. Wählen Sie im Dienstmenü Kubernetes-Ressourcen aus. Die Liste der Kubernetes-Ressourcen zeigt die folgenden Kategorien an:

    • Namespaces zeigen Informationen zu den Namespaces Ihres Clusters an.
    • Workloads zeigt Informationen zu Bereitstellungen, Pods, Replikatgruppen, StatefulSets, Daemongruppen, Aufträgen und cron-Aufträgen an, die auf Ihrem Cluster bereitgestellt wurden.
    • Dienste und Eingänge zeigt alle Dienst- und Eingangsressourcen Ihres Clusters an.
    • Storage zeigt Ihre Azure-Speicher Klassen und persistenten Volumeinformationen an.
    • Unter Konfiguration werden die ConfigMaps und Geheimnisse Ihres Clusters angezeigt.
    • Benutzerdefinierte Ressourcen zeigen alle benutzerdefinierten Ressourcen an, die in Ihrem Cluster bereitgestellt werden.
    • Ereignisse zeigen alle Ereignisse im Zusammenhang mit Ihrem Cluster an.
    • Mit Skriptausführung können Sie über die Azure-API Befehle wie kubectl und helm remote für Ihren Cluster aufrufen, ohne eine direkte Verbindung mit dem Cluster herzustellen.

    Screenshot der Kubernetes-Ressourcen, die im Azure-Portal angezeigt werden.

Bereitstellen einer Beispielanwendung

In diesem Abschnitt stellen wir die Azure Store-Anwendung über die AKS-Schnellstartanleitung bereit.

Herstellen einer Clusterverbindung

Um die Azure Store-Anwendung bereitzustellen, müssen Sie eine Verbindung mit Ihrem AKS-Cluster herstellen. Führen Sie die folgenden Schritte aus, um mithilfe des Azure-Portals eine Verbindung mit Ihrem Cluster herzustellen:

  1. Wählen Sie auf der Seite Übersicht Ihres AKS-Clusters Verbinden aus.
  2. Befolgen Sie die Anweisungen zum Herstellen einer Verbindung mit Ihrem Cluster mithilfe des Befehls Cloud Shell, Azure CLI oder Skriptausführung.

Bereitstellen der Azure Store-Anwendung

  1. Wählen Sie in der Liste Kubernetes-Ressourcen die Option Dienste und Eingänge aus.

  2. Wählen Sie Erstellen>Ein YAML anwenden aus.

  3. Koperien und fügen Sie den folgenden YAML-Code in den Editor ein:

    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

  4. Wählen Sie Hinzufügen.

    Nachdem die Anwendung die Bereitstellung abgeschlossen hat, werden die folgenden Dienste in der Liste Dienste angezeigt:

    • order-service
    • product-service
    • rabbitmq
    • store-front

    Screenshot der Azure Store-Anwendungsdienste, die im Azure-Portal angezeigt werden.

Überwachen von Bereitstellungserkenntnissen

Aktivieren des Überwachungs-Add-Ons auf Ihrem AKS-Cluster

AKS-Cluster mit aktivierten Container Insights können im Azure-Portal auf verschiedene Bereitstellungserkenntnisse zugreifen. Wenn die Überwachung auf Ihrem Cluster nicht aktiviert ist, können Sie sie mit den folgenden Schritten aktivieren:

  1. Wählen Sie im Dienstmenü Ihrer AKS-Clusterressource die Option Überwachung>Insights>Konfigurieren der Überwachung aus.

  2. Wählen Sie auf der Seite Konfigurieren von Container Insights die Option Konfigurieren aus.

    Es kann einige Minuten dauern, bis die Überwachungslösung Daten bereitstellt und mit der Erfassung von Daten beginnt.

Anzeigen von Bereitstellungserkenntnissen

  1. Wählen Sie im Dienstmenü Ihrer AKS-Clusterressource Workloads aus.
  2. Wählen Sie eine Bereitstellung aus der Liste aus, um Bereitstellungseinblicke anzuzeigen, z. B. CPU und Arbeitsspeicherauslastung.

Hinweis

Sie können auch Überwachung>Insightsauswählen, um ausführlichere Informationen zu bestimmten Knoten und Containern anzuzeigen.

Bereinigen von Ressourcen

Wenn Sie die Azure Store-Anwendung nicht mehr benötigen, können Sie die Dienste löschen, um Azure-Kosten zu vermeiden.

  1. Wählen Sie in der Liste Kubernetes-Ressourcen die Option Dienste und Eingänge aus.
  2. Wählen Sie die Dienste aus, und klicken Sie dann auf Löschen.

Problembehandlung

Nicht autorisierter Zugriff

Um auf die Kubernetes-Ressourcen zuzugreifen, benötigen Sie Zugriff auf die AKS-Cluster-, Kubernetes-API- und Kubernetes-Objekte. Stellen Sie sicher, dass Sie entweder ein Clusteradministrator oder ein Benutzer mit den geeigneten Berechtigungen für den Zugriff auf den AKS-Cluster sind. Weitere Informationen finden Sie unter Zugriffs- und Identitätsoptionen für AKS.

Aktivieren der Ressourcenansicht

Bei vorhandenen Clustern müssen Sie möglicherweise die Kubernetes-Ressourcenansicht aktivieren.

Tipp

Sie können das AKS-Feature für vom API-Server autorisierte IP-Adressbereiche hinzufügen, um den Zugriff des API-Servers auf den öffentlichen Endpunkt der Firewall zu beschränken. Eine weitere Möglichkeit besteht darin, den --api-server-authorized-ip-ranges/-ApiServerAccessAuthorizedIpRange Zugriff auf einen lokalen Clientcomputer oder den IP-Adressbereich zu aktualisieren, über den Sie das Azure-Portal durchsuchen. Um diesen Zugriff zuzulassen, benötigen Sie die öffentliche IPv4-Adresse des Computers. Sie finden diese Adresse mithilfe der folgenden Azure CLI- oder Azure PowerShell-Befehle, oder Sie können in Ihrem Browser nach "Was ist meine IP-Adresse" suchen.

  1. Rufen Sie Ihre IP-Adresse mit dem folgenden Befehl ab:

    CURRENT_IP=$(dig +short myip.opendns.com @resolver1.opendns.com)

  2. Fügen Sie Ihre IP-Adresse mithilfe des az aks update Befehls mit dem --api-server-authorized-ip-ranges Parameter zur AKS-genehmigten Liste hinzu.

    az aks update --resource-group <resource-group-name> --name <aks-cluster-name> --api-server-authorized-ip-ranges $CURRENT_IP/32

Nächste Schritte

In diesem Artikel wurde gezeigt, wie Sie auf Kubernetes-Ressourcen über das Azure-Portal zugreifen. Weitere Informationen zu AKS finden Sie unter Grundlegende Konzepte für Azure Kubernetes Service (AKS).