Seite „GKE-Anwendungen“ in der Cloud Console verwenden

In dieser Anleitung wird die Verwendung der Seite Anwendungen von Google Kubernetes Engine (GKE) in der Google Cloud Console beschrieben.

Wenn Sie Kubernetes für viele Anwendungen und Ressourcen verwenden, kann es schwierig sein, die verschiedenen Komponenten einer Anwendung zu identifizieren und zu verfolgen. Wenn Sie in jedem Namespace mehrere Anwendungen bereitstellen, kann es schwierig sein zu wissen, welche Ressourcen zu welcher Anwendung gehören. Außerdem müssen Sie häufig an mehreren Stellen nach Dokumentation und Metadaten suchen, die beschreiben, was die Anwendungen sind, wer die Inhaber sind und wie sie mit den Diensten interagieren können.

GKE unterstützt beim Lösen dieser Probleme mit der Seite Anwendungen:

Eine unvollständige Ansicht der Seite „Anwendungen“, auf der eine Liste mit Anwendungen sowie unterschiedlichen Attributen angezeigt wird.

Die Seite Anwendungen ist eine unabhängige Ressource innerhalb Ihrer Architektur, die Metadaten zu Ihrem System beschreibt. Auf dieser Seite können Sie Ihre Ressourcen visuell organisieren, ohne die Architektur zu ändern. Durch das Definieren von Werten in einer YAML-Datei können Sie alle Ihre Anwendungsressourcen gruppieren und wichtige Metadaten für Ihr Betriebsteam einschließen. Das Erstellen, Ändern und Löschen der YAML-Datei hat keine Auswirkungen auf vorhandene Ressourcen. Sie können also ohne Auswirkungen auf Ihr System sofort mit Ressourcen arbeiten.

In dieser Anleitung wird gezeigt, wie Sie die Kubernetes-Anwendungsressource für eine Anwendung implementieren und benutzerdefinierte Metadaten hinzufügen, um die Verwaltung der Anwendung in GKE zu organisieren und zu vereinfachen.

Diese Anleitung richtet sich an Entwickler, die Anwendungen zur Ausführung in GKE erstellen. Es wird davon ausgegangen, dass Sie mit den grundlegenden Kubernetes-Konzepten vertraut sind und Erfahrung mit der Erstellung von YAML-Dateien für Kubernetes-Ressourcen haben.

Ziele

  • Einführung in die Kubernetes-Anwendungsressource
  • Kubernetes-Anwendungsressource zu einer vorhandenen Architektur hinzufügen
  • Benutzerdefinierte Informationen zu einer Anwendung über die Cloud Console erstellen und anzeigen lassen

Kosten

In dieser Anleitung werden die folgenden kostenpflichtigen Komponenten von Google Cloud verwendet:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss dieser Anleitung können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweis

  1. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  2. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

  3. Compute Engine and Kubernetes Engine APIs aktivieren.

    Aktivieren Sie die APIs

  4. Aktivieren Sie Cloud Shell in der Cloud Console.

    Cloud Shell aktivieren

    Die Befehle für diese Anleitung werden in Cloud Shell oder im Cloud Shell-Editor ausgeführt.

Umgebung vorbereiten

  1. Legen Sie in Cloud Shell die Umgebungsvariablen für Ihre Projekt-ID fest:

    export PROJECT_ID=PROJECT_ID
    gcloud config set core/project $PROJECT_ID
    gcloud config set compute/zone us-central1-c
    

    Ersetzen Sie PROJECT_ID durch Ihre Google Cloud-Projekt-ID.

  2. Erstellen Sie einen GKE-Cluster.

    gcloud container clusters create sample-cluster
    

    Im Rahmen dieser Anleitung führen Sie Anwendungen in einem GKE-Standardcluster aus.

Beispielanwendungen installieren

In dieser Anleitung simulieren Sie mehrere Anwendungen, die im selben Namespace ausgeführt werden. Dazu verwenden Sie eine einfache Nginx-Beispielanwendung und die Beispielanwendung „Bank of Anthos”.

  1. Installieren Sie in Cloud Shell die Nginx-Beispielanwendung:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes/website/master/content/en/examples/application/web/web.yaml
    

    Mit diesem Befehl werden eine StatefulSet-Ressource namens web und ein Dienst namens nginx erstellt. In der Cloud Console können Sie diese Ressourcen auf den Seiten GKE-Arbeitslasten und Services und Ingress ansehen.

  2. Klonen Sie das GitHub-Repository, das die Beispielanwendung „Bank of Anthos“ enthält:

    git clone https://github.com/GoogleCloudPlatform/bank-of-anthos.git
    cd bank-of-anthos
    
  3. Generieren Sie einen SSH-Schlüssel und speichern Sie ihn als Kubernetes Secret:

    openssl genrsa -out jwtRS256.key 4096
    openssl rsa -in jwtRS256.key -outform PEM -pubout -out jwtRS256.key.pub
    kubectl create secret generic jwt-key --from-file=./jwtRS256.key --from-file=./jwtRS256.key.pub
    

    Für die Beispielanwendung „Bank of Anthos“ ist ein SSH-Schlüssel erforderlich.

  4. Stellen Sie die Beispielanwendung in Ihrem Cluster bereit:

    kubectl apply -f kubernetes-manifests
    

    Nach kurzer Zeit können Sie die Anwendungsressourcen auf den folgenden Seiten in der Cloud Console aufrufen:

    Wichtige Hinweise:

    • Die Ressourcen für die Beispielanwendungen Nginx und Bank of Anthos sind miteinander verbunden.
    • Auf der Seite Anwendungen werden noch keine Ressourcen angezeigt. Sie füllen die Seite Anwendungen in späteren Schritten aus.

GKE vorbereiten

Die Ressourcen, die auf der Seite Anwendungen angezeigt werden, werden mit dem Ressourcentyp der Kubernetes-Anwendung angegeben. Dieser entspricht einer benutzerdefinierten Ressourcendefinition, die vom Open-Source-Projekt Kubernetes bereitgestellt wird. Standardmäßig ist die Anwendungs-CRD nicht in Kubernetes aktiviert. Manche Dienste in GKE, wie Marketplace und Anwendungsbereitstellung, installieren die Anwendungs-CRD. Wenn Sie keinen dieser Dienste verwenden, ist die Anwendungs-CRD nicht standardmäßig verfügbar.

So installieren Sie die Anwendungs-CRD:

  1. Wenden Sie in Cloud Shell die Anwendungs-CRD einmal auf jeden Cluster an:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/application/master/deploy/kube-app-manager-aio.yaml
    
  2. Optional: Rufen Sie nach Abschluss des Befehls die Anwendungs-CRD im Cluster auf:

    kubectl get crd
    

    Die folgende Ausgabe enthält eine Liste der installierten CRDs, einschließlich applications.app.k8s.io:

    NAME                                    CREATED AT
    applications.app.k8s.io                 2020-07-24T19:32:20Z
    backendconfigs.cloud.google.com         2020-07-24T19:28:40Z
    managedcertificates.networking.gke.io   2020-07-24T19:28:57Z
    scalingpolicies.scalingpolicy.kope.io   2020-07-24T19:28:57Z
    updateinfos.nodemanagement.gke.io       2020-07-24T19:28:57Z
    

Anwendungsressourcen einbeziehen

Nachdem die Anwendungs-CRD im Cluster verfügbar ist, wird nun eine Instanz der Anwendungsressource erstellt und bereitgestellt.

Da die Anwendungsressource eine Kubernetes-Ressource ist, hat sie eine ähnliche Struktur wie andere Kubernetes-Ressourcen, einschließlich Feldern und Optionen für apiVersion, kind, metadata und spec:

apiVersion: app.k8s.io/v1beta1
kind: Application
metadata:
  name: ...
spec:
   ...

In den folgenden Abschnitten arbeiten Sie mit verschiedenen Feldern und Optionen, die in der Anwendungsressource verfügbar sind.

Basisanwendungsressource erstellen

Sie können die Anwendungsressource zu vorhandenen Ressourcen hinzufügen. In dieser Anleitung beginnen Sie mit einer leeren Ressource und füllen die einzelnen Abschnitte aus.

  1. Erstellen und bearbeiten Sie in Cloud Shell eine application.yaml-Datei im Verzeichnis kubernetes-manifests:

    touch kubernetes-manifests/application.yaml
    edit kubernetes-manifests/application.yaml
    

    Der Cloud Shell-Editor wird geöffnet und zeigt eine leere Datei an.

  2. Fügen Sie die folgenden Zeilen hinzu, um die erste Anwendung zu definieren:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
    
  3. Wählen Sie in der Cloud Shell-Menüleiste Terminal öffnen aus.

  4. Wenden Sie in Cloud Shell die Ressource an:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  5. Rufen Sie in der Cloud Console die Seite Anmeldedaten auf.

    Wechseln Sie zu „Anwendungen“

    Auf der Seite Anwendungen werden die hinzugefügten Ressourcen angezeigt:

    Die Anwendung Bank of Anthos ist in der Liste der Anwendungen aufgeführt.

Ressourcen komponentenweise einfügen

Auf der Seite Anwendungen wird die Bank of Anthos-Anwendung angezeigt. Wenn Sieim Feld Name aufBank-of-anthos klicken, werden allgemeine Informationen zur Anwendung angezeigt:

Anwendungsdetails umfassen den Cluster, den Namespace und das Erstellungsdatum.

Sie können verschiedene Komponenten hinzufügen, die in der Cloud Console angezeigt werden. Wenn Sie beispielsweise Dienste, Deployments und StatefulSets aufrufen möchten, bearbeiten Sie den Abschnitt componentKinds der application.yaml-Definition:

spec:
  componentKinds:
    - group: v1
      kind: Service
    - group: apps
      kind: Deployment
    - group: v1
      kind: StatefulSet

In den folgenden Schritten fügen Sie der Komponentendefinition von Bank of Anthos diese Komponenten hinzu:

  1. Wählen Sie in der Cloud Shell-Menüleiste Editor öffnen aus.

  2. Überschreiben Sie im Cloud Shell-Editor den Inhalt der Datei kubernetes-manifests/application.yaml durch Folgendes:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
    spec:
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    

    Durch Hinzufügen des Abschnitts spec werden der Anwendungsdefinition Service, Deployment und StatefulSet hinzugefügt.

  3. Wenden Sie in Cloud Shell die Ressource an:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  4. Rufen Sie in der Cloud Console die Detailseite der Anwendung „Bank of Anthos“ auf.

    Zur Seite „Bank of Anthos”

    Die Komponenten eines bestimmten Typs werden angezeigt:

    Die Liste der Details enthält Komponententypen wie „Service” und „Deployment”.

Ressourcen mit Selektoren filtern

An dieser Stelle in der Anleitung umfasst die Liste der Komponenten alle Ressourcen für beide Beispielanwendungen für den definierten Satz an Komponenten aus dem gesamten Namespace. Das folgende Diagramm zeigt beispielsweise den Dienst nginx aus der Nginx-Beispielanwendung und das transactionhistory-Deployment von der Bank of Anthos-Beispielanwendung:

Die Liste der Komponenten wird von allen Anwendungen im Namespace generiert.

Wenn Sie möchten, dass nur die Ressourcen für eine Anwendung angezeigt werden, z. B. für die Bank of Anthos-Anwendung, können Sie Selektoren verwenden, um bestimmte Ressourcen zu identifizieren. In den folgenden Schritten fügen Sie Ihrer Ressource ein Label hinzu, um zu erfahren, wie Selektoren funktionieren:

  1. Öffnen Sie in Cloud Shell die Datei frontend.yaml:

    edit kubernetes-manifests/frontend.yaml
    
  2. Fügen Sie im Cloud Shell-Editor den folgenden label-Eintrag nach Zeile 18 ein:

    labels:
        app.kubernetes.io/name: "bank-of-anthos"
    

    Der Abschnitt metadata sieht so aus:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: frontend
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
    

    Die fertige application.yaml-Datei sieht so aus:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
      selector:
        matchLabels:
         app.kubernetes.io/name: "bank-of-anthos"
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    
  3. Wenden Sie in Cloud Shell die Ressourcen an:

    kubectl apply -f kubernetes-manifests/
    
  4. Rufen Sie in der Cloud Console die Detailseite der Anwendung „Bank of Anthos“ auf.

    Zur Seite „Bank of Anthos”

    Es wird nur die Ressource angezeigt, die einem bestimmten Label entspricht:

    In der Komponentenliste wird die Deployment-Ressource angezeigt.

Mit kustomize auf alle Ressourcen Labels anwenden

Das manuelle Anwenden von Labels auf alle Ressourcen in einer Anwendung kann mühsam sein. In den folgenden Schritten wird gezeigt, wie Sie mit kustomize Labels zu allen Ressourcen effizient hinzufügen:

  1. Laden Sie in Cloud Shell kustomize herunter:

    curl -s "https://raw.githubusercontent.com/\
    kubernetes-sigs/kustomize/master/hack/install_kustomize.sh" | bash
    
  2. Erstellen und bearbeiten Sie eine kustomization.yaml-Datei:

    touch kubernetes-manifests/kustomization.yaml
    edit kubernetes-manifests/kustomization.yaml
    
  3. Fügen Sie im Cloud Shell-Editor die folgenden Zeilen zu kustomization.yaml hinzu:

    apiVersion: kustomize.config.k8s.io/v1beta1
    kind: Kustomization
    
    resources:
    - accounts-db.yaml
    - application.yaml
    - balance-reader.yaml
    - config.yaml
    - contacts.yaml
    - frontend.yaml
    - ledger-db.yaml
    - ledger-writer.yaml
    - loadgenerator.yaml
    - transaction-history.yaml
    - userservice.yaml
    
    commonLabels:
        app.kubernetes.io/name: "bank-of-anthos"
    

    In dieser kustomization.yaml-Definition geben Sie an, auf welche Ressourcen die Änderungen angewendet werden sollen und welche Änderungen vorgenommen werden sollen. In diesem Fall geben Sie an, dass alle Ressourcen das gemeinsame Label app.kubernetes.io/name: "bank-of-anthos" haben sollen.

  4. Löschen Sie in Cloud Shell die alten Ressourcen:

    kubectl delete -f kubernetes-manifests/
    

    Die alten Ressourcen müssen gelöscht werden, bevor Sie die neuen Ressourcen, die in kustomization.yaml angegeben sind, anwenden können.

  5. Wenden Sie die Ressourcen mit dem Flag kustomize anstelle des Flags file an:

    ./kustomize build kubernetes-manifests/ | kubectl apply -f -
    
  6. Rufen Sie in der Cloud Console die Detailseite der Anwendung „Bank of Anthos“ auf.

    Zur Seite „Bank of Anthos”

    Auf der Detailseite werden die Ressourcen für die Beispielanwendung „Bank of Anthos“ und keine Ressourcen aus der Nginx-Beispielanwendung angezeigt:

    Es werden nur die Bank of Anthos-Komponenten wie StatefulSet angezeigt.

Nützliche Metadaten in der Anzeige hinzufügen

Sie können benutzerdefinierte Metadaten für eine Anwendung in der Cloud Console anzeigen lassen. Sie können angeben, wofür die Anwendung zuständig ist, wer sie besitzt, wo weitere Informationen zu finden sind und wie man sich anmelden kann. Diese Art von Informationen ist für verschiedene Anwendungsfälle nützlich, z. B. wenn Sie mehrere Anwendungen innerhalb Ihrer Organisation betreiben.

In den folgenden Abschnitten werden einige Metadaten beschrieben, die Sie hinzufügen können.

Beschreibung und Dokumentation hinzufügen

Sie können eine Beschreibung und Links hinzufügen, die im Bereich Anwendungsinfo angezeigt werden. Klicken Sie auf der Seite Details auf Infofeld ansehen, um auf dieses Feld zuzugreifen.

Damit Informationen in diesem Feld angezeigt werden, definieren Sie im Abschnitt descriptor der Datei application.yaml Elemente wie description und links.

descriptor:
    description:
    links:
    - description:
      url:

So aktualisieren Sie den Abschnitt descriptor:

  1. Überschreiben Sie im Cloud Shell-Editor den Inhalt der Datei application.yaml durch Folgendes:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
      selector:
        matchLabels:
         app.kubernetes.io/name: "bank-of-anthos"
    
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    
      descriptor:
        description: |-
            This application simulates a bank's payment processing network using
            [Anthos](/anthos/).
            Bank of Anthos allows users to create artificial accounts and
            simulate transactions between accounts. Bank of Anthos was developed
            to create an end-to-end sample demonstrating Anthos best practices.
    
        links:
        - description: 'About Anthos on GCP'
          url: /anthos/
        - description: 'Bank of Anthos GitHub Repository'
          url: https://github.com/GoogleCloudPlatform/bank-of-anthos
    
  2. Stellen Sie in Cloud Shell die Anwendungsressource bereit:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  3. Rufen Sie in der Cloud Console die Detailseite der Anwendung „Bank of Anthos“ auf.

    Zur Seite „Bank of Anthos”

  4. Klicken Sie auf Infofeld ansehen, um die Änderungen zu überprüfen.

    Im Bereich App-Info werden eine Beschreibung und eine Liste von Dokumenten angezeigt:

    Die Dokumente in der Liste sind als Hyperlink formatiert.

Softwaretyp einschließen

Auf der Seite Anwendungen wird das Feld Software für den Softwaretyp in der Liste der Anwendungen angezeigt. Sie können dieses Feld anpassen, um Ihre Anwendungen entsprechend Ihren Anforderungen zu organisieren und zu kategorisieren. Beispielsweise könnten Sie angeben, dass die Software intern oder extern ist. Wenn Sie mehrere Anwendungen haben, die auf einem gemeinsam genutzten Basistyp erstellt wurden, können Sie auch angeben, welcher Basistyp eine Anwendung implementiert.

Wenn Sie dem Softwaretyp eine benutzerdefinierte Beschreibung hinzufügen möchten, verwenden Sie das Feld type im Abschnitt descriptor der Datei application.yaml:

 descriptor:
    type: External App

Sie können den Wert für type in der Cloud Console als Hyperlink anzeigen lassen. Die URL für den Hyperlink wird mit dem ersten Eintrag aus dem Abschnitt links angegeben. In den folgenden Schritten aktualisieren Sie den Abschnitt links so:

    links:
    - description: 'Bank of Anthos GitHub Repository'
      url: https://github.com/GoogleCloudPlatform/bank-of-anthos
  1. Überschreiben Sie im Cloud Shell-Editor den Inhalt von application.yaml durch Folgendes:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
      selector:
        matchLabels:
         app.kubernetes.io/name: "bank-of-anthos"
    
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    
      descriptor:
        type: External App
    
        description: |-
            This application simulates a bank's payment processing network using [Anthos](/anthos/).
            Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.
    
        links:
        - description: 'About Anthos on GCP'
          url: /anthos/
        - description: 'Bank of Anthos GitHub Repository'
          url: https://github.com/GoogleCloudPlatform/bank-of-anthos
    
  2. Stellen Sie in Cloud Shell die Anwendungsressource bereit:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  3. Rufen Sie in der Cloud Console die Seite Anmeldedaten auf.

    Wechseln Sie zu „Anwendungen“

    Externe App wird im Feld Software angezeigt:

    Der Softwaretyp „Externe App“ ist als Hyperlink formatiert.

Anwendungsversion einschließen

Die Hauptseite für Anwendungen enthält ein Feld für die Version. In der Praxis wird der Wert für dieses Feld programmatisch aktualisiert, um auf die bereitgestellte Version zu verweisen.

Fügen Sie das Feld version unter descriptor wie im folgenden Beispiel in das Feld „Version“ ein:

  descriptor:
    type: External App
    version: "2.3.2"

In den folgenden Schritten fügen Sie ein Feld für die Anwendungsversion hinzu.

  1. Überschreiben Sie im Cloud Shell-Editor den Inhalt der Datei application.yaml durch Folgendes:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
      selector:
        matchLabels:
         app.kubernetes.io/name: "bank-of-anthos"
    
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    
      descriptor:
        type: External App
    
        version: "2.3.2"
    
        description: |-
            This application simulates a bank's payment processing network using [Anthos](/anthos/).
            Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.
    
        links:
        - description: 'About Anthos on GCP'
          url: /anthos/
        - description: 'Bank of Anthos GitHub Repository'
          url: https://github.com/GoogleCloudPlatform/bank-of-anthos
    
  2. Stellen Sie in Cloud Shell die Anwendungsressource bereit:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  3. Rufen Sie in der Cloud Console die Seite Anmeldedaten auf.

    Wechseln Sie zu „Anwendungen“

    Das Feld Version für die Bank of Anthos-Anwendung zeigt 2.3.2 an:

    Die Anwendungsdetails umfassen die Felder für den Softwaretyp und die Version.

Informationen zum Administrator hinzufügen

In diesem Schritt fügen Sie dem Hauptabschnitt der Seite Anwendungen benutzerdefinierten statischen Text hinzu. Geben Sie diese Details im Abschnitt info der Datei application.yaml so an:

  info:
  - name: LABEL
    value: STRING

Wenn Sie statische Werte hinzufügen möchten, geben Sie Details zu LABEL und STRING im Abschnitt info an. Sie können beispielsweise Owner für name und John Smith für value eingeben.

  1. Überschreiben Sie im Cloud Shell-Editor den Inhalt von application.yaml durch Folgendes:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
      selector:
        matchLabels:
         app.kubernetes.io/name: "bank-of-anthos"
    
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    
      descriptor:
        type: External App
    
        version: "2.3.2"
    
        description: |-
            This application simulates a bank's payment processing network using [Anthos](/anthos/).
            Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.
    
        links:
        - description: 'About Anthos on GCP'
          url: /anthos/
        - description: 'Bank of Anthos GitHub Repository'
          url: https://github.com/GoogleCloudPlatform/bank-of-anthos
    
      info:
      - name: Owner
        value: John Smith
    
  2. Stellen Sie in Cloud Shell die Anwendungsressource bereit:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  3. Rufen Sie in der Cloud Console die Detailseite der Anwendung „Bank of Anthos“ auf.

    Zur Seite „Bank of Anthos”

    Auf der Detailseite ist der Inhaber der Bank of Anthos-Anwendung enthalten:

    Max Mustermann wird als Inhaber angegeben.

Anwendungsendpunkt freigeben

Zusätzlich zu statischen Werten können Sie dynamische Werte aus dem Deployment selbst verfügbar machen. In den folgenden Schritten wird die IP-Adresse des Load-Balancers angezeigt, sodass jeder Nutzer, der die Seite mit den Anwendungsdetails aufruft, direkt auf die Anwendung zugreifen kann.

Verwenden Sie die Spezifikation serviceRef, um diesen Wert anzuzeigen. Weitere gültige Spezifikationen sind: configMapKeyRef ,ingressRef undsecretKeyRef auf Ihrem Mobilgerät.

In der Spezifikation serviceRef fügen Sie diese dynamischen Werte mithilfe des Typs Reference hinzu. Für diese Anleitung entspricht die Spezifikation für serviceRef Folgendem:

 info:
  - name: LABEL
    type: Reference
    valueFrom:
      serviceRef:
        name: SERVICE_NAME
        fieldPath: DATA_LOCATION

Die folgenden Werte können ersetzt werden:

  • LABEL: Ein Label, das eine bestimmte Referenzinstanz beschreibt, z. B. App Frontend URL
  • SERVICE_NAME: Der Name, der den Service$mdash identifiziert, z. B. frontend
  • DATA_LOCATION: der Standort der Daten im Dienst, z. B. status.loadBalancer.ingress[0].ip

Die Spezifikationen serviceRef und ingressRef unterstützen auch das Element path. Wenn für die URL pfadbezogene Details erforderlich sind, geben Sie diese im Feld path an:

 info:
  - name: LABEL
    type: Reference
    valueFrom:
      serviceRef:
        name: SERVICE_NAME
        fieldPath: DATA_LOCATION
        path: /wp-admin

Die IP-Adresse und der Pfad des Endpunkts sind verkettet, z. B. 35.202.90.0/wp-admin.

Sie können auch die Verwendung von HTTP oder HTTPS erzwingen. Verwenden Sie dazu das Feld protocol so:

 info:
  - name: LABEL
    type: Reference
    valueFrom:
      serviceRef:
        name: SERVICE_NAME
        fieldPath: DATA_LOCATION
        path: /wp-admin
        protocol: HTTPS

Diese Details ergeben die folgende URL:

https://35.202.90.0/wp-admin

In den folgenden Schritten geben Sie serviceRef für die IP-Adresse des Service-Load-Balancers für die Bank of Anthos-Anwendung frei:

  1. Überschreiben Sie im Cloud Shell-Editor den Inhalt der Datei application.yaml durch Folgendes:

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
      selector:
        matchLabels:
         app.kubernetes.io/name: "bank-of-anthos"
    
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    
      descriptor:
        type: External App
    
        version: "2.3.2"
    
        description: |-
            This application simulates a bank's payment processing network using [Anthos](/anthos/).
            Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.
    
        links:
        - description: 'About Anthos on GCP'
          url: /anthos/
        - description: 'Bank of Anthos GitHub Repository'
          url: https://github.com/GoogleCloudPlatform/bank-of-anthos
    
      info:
      - name: Owner
        value: John Smith
      - name: App Frontend URL
        type: Reference
        valueFrom:
          serviceRef:
            name: frontend
            fieldPath: status.loadBalancer.ingress[0].ip
            protocol: HTTPS
    
  2. Stellen Sie in Cloud Shell die Anwendungsressource bereit:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  3. Rufen Sie in der Cloud Console die Detailseite der Anwendung „Bank of Anthos“ auf.

    Zur Seite „Bank of Anthos”

    Die Detailseite enthält eine Endpunkt-IP-Adresse für die Anwendung der Bank of Anthos:

    Die IP-Adresse ist mit App Front-End URL gekennzeichnet.

Anmeldedaten angeben

Wie bereits erwähnt, können Sie Kubernetes Secrets über das Element secretKeyRef über die Cloud Console freigeben. In dieser Anleitung stellen Sie dem Operator einen Nutzernamen und ein Passwort bereit, damit er sich bei der Anwendung anmelden kann.

  1. Erstellen Sie in Cloud Shell das Secret:

    kubectl create secret generic boa-access --from-literal=boa-user=testuser --from-literal=boa-pass=password
    
  2. Überschreiben Sie im Cloud Shell-Editor den Inhalt der Datei application.yaml durch Folgendes: Diese Aktualisierung enthält Verweise auf den Nutzernamen und das Passwort in der Annotation secretKeyRef.

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
    spec:
      selector:
        matchLabels:
         app.kubernetes.io/name: "bank-of-anthos"
    
      componentKinds:
        - group: v1
          kind: Service
        - group: apps
          kind: Deployment
        - group: v1
          kind: StatefulSet
    
      descriptor:
        type: External App
    
        version: "2.3.2"
    
        description: |-
            This application simulates a bank's payment processing network using [Anthos](/anthos/).
            Bank of Anthos allows users to create artificial accounts and simulate transactions between accounts. Bank of Anthos was developed to create an end-to-end sample demonstrating Anthos best practices.
    
        links:
        - description: 'About Anthos on GCP'
          url: /anthos/
        - description: 'Bank of Anthos GitHub Repository'
          url: https://github.com/GoogleCloudPlatform/bank-of-anthos
    
      info:
      - name: Owner
        value: John Smith
      - name: App Frontend URL
        type: Reference
        valueFrom:
          serviceRef:
            name: frontend
            fieldPath: status.loadBalancer.ingress[0].ip
            protocol: HTTPS
      - name: TestUser username
        type: Reference
        valueFrom:
          secretKeyRef:
            name: boa-access
            key: boa-user
    
      - name: TestUser password
        type: Reference
        valueFrom:
          secretKeyRef:
            name: boa-access
            key: boa-pass
    
  3. Stellen Sie in Cloud Shell die Anwendungsressource bereit:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  4. Rufen Sie in der Cloud Console die Detailseite der Anwendung „Bank of Anthos“ auf.

    Zur Seite „Bank of Anthos”

  5. Klicken Sie auf Vorschau von Secret-Daten. Nutzername und Passwort werden offengelegt:

    Die Anwendungsdetails enthalten Links für den Zugriff auf Anmeldedaten.

Die Möglichkeit, Secret-Daten freizugeben, kann für Ihre Betriebsteams eine hilfreiche Funktion sein. Die Möglichkeit, diese Secrets anzuzeigen, unterliegt jedoch den Zugriffsberechtigungen für die Identitäts- und Zugriffsverwaltung (IAM) für die GKE-Detailseite. Jeder mit der Berechtigung zum Aufrufen von Clustern kann auch Secrets ansehen. Daher ist es wichtig, dass Sie sorgfältig überlegen, was Sie freigeben.

Symbol für Anwendung hinzufügen

Damit sich Ihre Anwendung von anderen abhebt, können Sie ein Logo einfügen, das in der Liste der Anwendungen und auf Ihrer Detailseite angezeigt wird. Wenn Sie ein Logo einfügen möchten, geben Sie den Daten-URI des Bilds in der Annotation kubernetes-engine.cloud.google.com/icon an.

Die Konvertierung eines Bildes in einen Daten-URI wird in dieser Anleitung nicht behandelt. Eine Google-Suche nach „convert image to data uri” liefert jedoch verschiedene Dienstprogramme, mit denen Sie den Datenstring aus einem Bild erstellen können. Da der Daten-URI für das in diesem Abschnitt verwendete Bild so lang ist, kann es nicht sinnvoll sein, ihn in die Anleitung aufzunehmen. Der vollständige Daten-URI ist in der vollständigen Datei application.yaml enthalten. Der Daten-URI-String sollte so beginnen: data:image/png;base64,iVBORw0KGgoAAAANSUhEUg.... Er endet mit K5CYII=. Fügen Sie keine Anführungszeichen oder HTML-Zeichen ein.

Die vollständige application.yaml Datei ist zu Referenzzwecken als gist verfügbar.

Zum Hinzufügen eines Symbols aktualisieren Sie den metadata-Abschnitt von application.yaml:

  1. Kopieren Sie den folgenden Code:

    annotations:
      kubernetes-engine.cloud.google.com/icon: >-
        data:image/png;base64,DATA_URI
    

    Ersetzen Sie DATA_URI durch den String aus der abgeschlossenen Datei application.yaml, auf die zuvor verwiesen wurde.

  2. Fügen Sie im Cloud Shell-Editor den Code ein, den Sie nach dem Abschnitt labels im Abschnitt metadata von application.yaml kopiert haben.

    Dieser Abschnitt von application.yaml ähnelt dem folgenden, wobei DATA_URI den Daten-URI-Wert darstellt.

    apiVersion: app.k8s.io/v1beta1
    kind: Application
    metadata:
      name: "bank-of-anthos"
      labels:
        app.kubernetes.io/name: "bank-of-anthos"
      annotations:
        kubernetes-engine.cloud.google.com/icon: >-
          data:image/png;base64,DATA_URI
    spec:
    
  3. Stellen Sie in Cloud Shell die Anwendungsressource bereit:

    kubectl apply -f kubernetes-manifests/application.yaml
    
  4. Rufen Sie in der Cloud Console die Seite Anmeldedaten auf.

    Wechseln Sie zu „Anwendungen“

    Ein Logo wird in der Liste der Anwendungen angezeigt:

    Neben dem Anwendungsnamen wird in der Liste der Anwendungen ein Logo angezeigt.

  5. Rufen Sie in der Cloud Console die Detailseite der Anwendung „Bank of Anthos“ auf.

    Zur Seite „Bank of Anthos”

    Ein Logo wird in der Kopfzeile der Detailseite angezeigt:

    Ein Logo wird oben in der Liste der Anwendungsdetails angezeigt.

Bereinigen

Wenn Sie vermeiden möchten, dass Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen in Rechnung gestellt werden, können Sie das dafür erstellte Google Cloud-Projekt löschen.

Projekt löschen

  1. Wechseln Sie in der Cloud Console zur Seite Ressourcen verwalten.

    Zur Seite „Ressourcen verwalten“

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Nächste Schritte