Zugreifen auf Kubernetes-Ressourcen mit dem Azure-Portal

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 linken Menü 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.

   

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

   

Ü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 linken Menü 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 linken Menü Ihrer AKS-Clusterressource Workloads aus.
2. Wählen Sie eine Bereitstellung aus der Liste aus, um Bereitstellungseinblicke anzuzeigen, z. B. CPU und Arbeitsspeicherauslastung.

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.

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).