Diese Seite wurde von der Cloud Translation API übersetzt.

Seite „GKE-Anwendungen“ in der Google Cloud-Console verwenden

In dieser Anleitung wird die Verwendung der Seite Anwendungen von Google Kubernetes Engine (GKE) in der Google Cloud -Konsole 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 dieGoogle Cloud -Konsole erstellen und anzeigen lassen

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

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 der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweise

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
- Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Verify that billing is enabled for your Google Cloud project.
Enable the Compute Engine and Kubernetes Engine APIs.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the APIs
In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

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 dabei PROJECT_ID durch die ID Ihres Projekts in Google Cloud .
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 Google Cloud Console können Sie diese Ressourcen auf den Seiten GKE-Arbeitslasten und Dienste 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 Google Cloud Console aufrufen:
  - Seite „Arbeitslasten“
  - Seite Dienste & Ingress
  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 Google Cloud Console die Seite Anwendungen auf.
  
  Wechseln Sie zu „Anwendungen“
  
  Auf der Seite Anwendungen werden die hinzugefügten Ressourcen angezeigt:
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:

Sie können verschiedene Komponenten hinzufügen, die in derGoogle Cloud -Konsole 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 Google Cloud Console die Detailseite der Anwendung „Bank of Anthos“ auf.
  
  Zur Seite „Bank of Anthos”
  
  Die Komponenten eines bestimmten Typs werden angezeigt:
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:

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 Google 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:
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 Google 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:
Nützliche Metadaten in der Anzeige hinzufügen

Sie können benutzerdefinierte Metadaten für eine Anwendung in derGoogle 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 Google 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:
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 derGoogle 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 Google Cloud Console die Seite Anwendungen auf.
  
  Wechseln Sie zu „Anwendungen“
  
  Externe App wird im Feld Software angezeigt:
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 Google Cloud Console die Seite Anwendungen auf.
  
  Wechseln Sie zu „Anwendungen“
  
  Das Feld Version für die Bank of Anthos-Anwendung zeigt 2.3.2 an:
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 Google 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:
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 Google 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:
Anmeldedaten angeben

Wie bereits erwähnt, können Sie Kubernetes Secrets über das Element secretKeyRef über dieGoogle Cloud -Konsole 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
  Hinweis :Dieses Secret wird in der Anwendung nicht verwendet. Sie erstellen sie zu Demonstrationszwecken in dieser Anleitung.
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 Google 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 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 Google Cloud Console die Seite Anwendungen auf.
  
  Wechseln Sie zu „Anwendungen“
  
  Ein Logo wird in der Liste der Anwendungen angezeigt:
5. Rufen Sie in der Google Cloud Console die Detailseite der Anwendung „Bank of Anthos“ auf.
  
  Zur Seite „Bank of Anthos”
  
  Ein Logo wird in der Kopfzeile der Detailseite 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 Google Cloud Projekt löschen, das Sie für diese Anleitung erstellt haben.

Projekt löschen
1. In the Google Cloud console, go to the Manage resources page.
  Go to Manage resources
2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.
Nächste Schritte
- Sehen Sie weitere Beispiele für application.yaml-Dateien imKubernetes-Ordner desclick-to-deploy GitHub-Repository an. Suchen Sie nach anderen application.yaml-Dateien unter chart/<application>/templates/ für die verschiedenen Anwendungen, z. B. wie in dieser Datei dargestellt.
- Verwenden Sie Marketplace-Bereitstellungen für Google Click-to-Deploy-Lösungen für GKE.
- Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center

Seite „GKE-Anwendungen“ in der Google Cloud-Console verwenden Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Ziele

Kosten

Hinweise

Umgebung vorbereiten

Beispielanwendungen installieren

GKE vorbereiten

Anwendungsressourcen einbeziehen

Basisanwendungsressource erstellen

Ressourcen komponentenweise einfügen

Ressourcen mit Selektoren filtern

Mit kustomize auf alle Ressourcen Labels anwenden

Nützliche Metadaten in der Anzeige hinzufügen

Beschreibung und Dokumentation hinzufügen

Softwaretyp einschließen

Anwendungsversion einschließen

Informationen zum Administrator hinzufügen

Anwendungsendpunkt freigeben

Anmeldedaten angeben

Symbol für Anwendung hinzufügen

Bereinigen

Projekt löschen

Nächste Schritte

Seite „GKE-Anwendungen“ in der Google Cloud-Console verwenden

Mit `kustomize` auf alle Ressourcen Labels anwenden