Diese Seite wurde von der Cloud Translation API übersetzt.

Anwendung aus vorhandenen Ressourcen erstellen

In dieser Kurzanleitung erfahren Sie, wie Sie vorhandene Google Cloud Ressourcen in einer App Hub-Anwendung organisieren, indem Sie sie als Dienste registrieren. Zuerst stellen Sie Beispielkomponenten bereit, mit denen Sie dann eine globale Webanwendung in App Hub definieren.

Diese Kurzanleitung richtet sich an Nutzer, die ihre vorhandene Infrastruktur verwenden möchten, um durch das Gruppieren von Google Cloud Ressourcen in logischen Anwendungen mehr Transparenz und operative Kontrolle zu erhalten.

Hinweise

Führen Sie vor Beginn dieser Kurzanleitung die folgenden Schritte aus:

Wählen Sie Ihr Anwendungs-Setup-Modell aus. In dieser Kurzanleitung wird davon ausgegangen, dass Sie eine Grenze für die Anwendungsverwaltung auf Ordnerebene definiert haben. Außerdem wird eine Anwendung mit dem Verwaltungsprojekt des Ordners erstellt. Weitere Informationen zur Ressourcenkonfiguration finden Sie im App Hub-Ressourcenmodell.
Notieren Sie sich die Projekt-ID des Verwaltungsprojekts, die in diesem Dokument verwendet wird. Weitere Informationen finden Sie unter Projektname, ‑nummer und ‑ID ermitteln.
Prüfen Sie, ob die folgenden APIs im Verwaltungsprojekt aktiviert sind. Wenn Sie ein Verwaltungsprojekt einrichten, werden die meisten APIs, die Sie für diese Kurzanleitung benötigen, automatisch aktiviert.
- Compute Engine API (compute.googleapis.com)
- Infrastructure Manager API (config.googleapis.com)
APIs aktivieren

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Verwaltungsprojekt zuzuweisen, damit Sie die nötigen Berechtigungen zum Aktivieren der erforderlichen APIs und zum Erstellen einer Beispielanwendung aus vorhandenen Ressourcen haben:

So aktivieren Sie die erforderlichen APIs: Service Usage Admin (roles/serviceusage.serviceUsageAdmin)
So erhalten Sie vollen Zugriff auf die erforderlichen Dienste:
- App Hub-Administrator (roles/apphub.admin)
- Cloud Run-Administrator (roles/run.admin)
- Compute-Administrator (roles/compute.admin)
- Cloud Infrastructure Manager-Administrator (roles/config.admin)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Beispielkomponenten für die Anwendung bereitstellen

Sie müssen zuerst eine Reihe von Beispielressourcen Google Cloud bereitstellen, die Sie später verwenden, um eine globale Anwendung in App Hub zu definieren, indem Sie sie als Anwendungskomponenten registrieren:

Ein Cloud Run-Dienst, der als Backend-Dienst der Anwendung fungiert.
Ein globaler externer Application Load Balancer, der als Frontend-Dienst der Anwendung fungiert, indem er Traffic als Weiterleitungsregel an den Cloud Run-Dienst weiterleitet.

So stellen Sie diese Ressourcen bereit:

gcloud

Legen Sie die erforderlichen Umgebungsvariablen fest:
```
export PROJECT_ID="PROJECT_ID"
export REGION="REGION"
```
Ersetzen Sie Folgendes:
- PROJECT_ID: die ID Ihres Verwaltungsprojekts.
- REGION: Die von Ihnen ausgewählte Region für Ressourcen, z. B. us-central1.

Beispiel-Cloud Run-Dienst mit dem Namen hello-run bereitstellen:

gcloud run deploy hello-run \
    --image=us-docker.pkg.dev/cloudrun/container/hello \
    --allow-unauthenticated \
    --region=${REGION} \
    --project=${PROJECT_ID}

Globalen externen Application Load Balancer erstellen Dieser Vorgang umfasst folgende Schritte:

Erstellen Sie eine serverlose Netzwerk-Endpunktgruppe (NEG) mit dem Namen hello-run-neg:

gcloud compute network-endpoint-groups create hello-run-neg \
    --region=${REGION} \
    --network-endpoint-type=serverless \
    --cloud-run-service=hello-run \
    --project=${PROJECT_ID}

Die NEG fungiert als Backend für den Load-Balancer und verweist auf Ihren hello-run-Dienst.

Erstellen Sie einen Backend-Dienst, um zu verwalten, wie Traffic an die NEG verteilt wird:

gcloud compute backend-services create hello-backend-service \
    --global \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --project=${PROJECT_ID}

Fügen Sie dem Backend-Dienst das serverlose NEG hinzu:

gcloud compute backend-services add-backend hello-backend-service \
    --global \
    --network-endpoint-group=hello-run-neg \
    --network-endpoint-group-region=${REGION} \
    --project=${PROJECT_ID}

Erstellen Sie eine URL-Zuordnung, um eingehende Anfragen an den Backend-Dienst weiterzuleiten:

gcloud compute url-maps create hello-url-map \
    --default-service=hello-backend-service \
    --project=${PROJECT_ID}

Erstellen Sie einen HTTP-Proxy, um Anfragen zu empfangen und mithilfe der URL-Zuordnung weiterzuleiten:

gcloud compute target-http-proxies create hello-http-proxy \
    --url-map=hello-url-map \
    --project=${PROJECT_ID}

So erstellen Sie eine globale Weiterleitungsregel:

gcloud compute forwarding-rules create hello-forwarding-rule \
    --global \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --target-http-proxy=hello-http-proxy \
    --ports=80 \
    --project=${PROJECT_ID}

Diese Weiterleitungsregel stellt eine öffentliche IP-Adresse und einen Port zum Verarbeiten eingehender Nutzeranfragen bereit und leitet sie an den Proxy weiter.

Terraform

Erstellen Sie eine main.tf-Datei und fügen Sie den folgenden Code hinzu:

# Provider configuration
provider "google" {
  project = "PROJECT_ID"
}

# Cloud Run service
resource "google_cloud_run_v2_service" "default" {
  name     = "hello-run"
  location = "REGION"
  template {
    containers {
      image = "us-docker.pkg.dev/cloudrun/container/hello"
    }
  }
}

# Allow unauthenticated access to the Cloud Run service
resource "google_cloud_run_v2_service_iam_member" "noauth" {
  project  = google_cloud_run_v2_service.default.project
  location = google_cloud_run_v2_service.default.location
  name     = google_cloud_run_v2_service.default.name
  role     = "roles/run.invoker"
  member   = "allUsers"
}

Ersetzen Sie Folgendes:

PROJECT_ID: die ID Ihres Verwaltungsprojekts.
REGION: Die von Ihnen ausgewählte Region für Ressourcen, z. B. us-central1.

In diesem Block wird der Google Cloud Anbieter definiert und ein öffentlicher Cloud Run-Dienst mit einem hello-world-Beispielcontainer-Image konfiguriert. Sie enthält auch eine IAM-Richtlinienbindung, um nicht authentifizierte Aufrufe zuzulassen, wodurch der Dienst öffentlich zugänglich wird.

Fügen Sie Ihrer main.tf-Datei den folgenden Code hinzu, um den globalen externen Application Load Balancer zu erstellen:

# Serverless NEG for the Cloud Run service
resource "google_compute_region_network_endpoint_group" "serverless_neg" {
  name                  = "hello-run-neg"
  network_endpoint_type = "SERVERLESS"
  region                = "REGION"
  cloud_run {
    service = google_cloud_run_v2_service.default.name
  }
}

# Global external backend service
resource "google_compute_backend_service" "default" {
  name                            = "hello-backend-service"
  protocol                        = "HTTP"
  load_balancing_scheme           = "EXTERNAL_MANAGED"
  backend {
    group = google_compute_region_network_endpoint_group.serverless_neg.id
  }
}

# URL map to route requests to the backend service
resource "google_compute_url_map" "default" {
  name            = "hello-url-map"
  default_service = google_compute_backend_service.default.id
}

# HTTP proxy to route requests to the URL map
resource "google_compute_target_http_proxy" "default" {
  name    = "hello-http-proxy"
  url_map = google_compute_url_map.default.id
}

# Global forwarding rule to handle incoming requests
resource "google_compute_global_forwarding_rule" "default" {
  name       = "hello-forwarding-rule"
  target     = google_compute_target_http_proxy.default.id
  port_range = "80"
}

In diesem Block werden die folgenden Komponenten definiert:

Eine serverlose Netzwerk-Endpunktgruppe (NEG), die als Back-End für den Load-Balancer dient und auf den Cloud Run-Dienst verweist.
Ein Back-End-Dienst, der Traffic an die serverlose NEG weiterleitet.
Eine URL-Zuordnung, um eingehende Anfragen an den Backend-Dienst weiterzuleiten.
Ein HTTP-Proxy, der Anfragen empfängt und sie mithilfe der URL-Zuordnung weiterleitet.
Eine globale Weiterleitungsregel, die eine öffentliche IP-Adresse und einen Port für die Verarbeitung eingehender Nutzeranfragen bereitstellt und diese an den Proxy weiterleitet.

Initialisieren und wenden Sie die Terraform-Konfiguration an:
```
terraform init
terraform apply
```
Terraform stellt die Ressourcen in Ihrem Projekt bereit.

Anwendung in App Hub definieren

Nachdem Sie die Ressourcen als Weiterleitungsregel und Cloud Run-Dienst bereitgestellt haben, gehen Sie so vor, um sie in einer App Hub-Anwendung zu gruppieren, indem Sie sie als Dienste der Anwendung registrieren:

Console

So rufen Sie die Seite Anwendungen im App Hub auf:

Wechseln Sie zu „Anwendungen“
Klicken Sie auf Anwendung erstellen.
Wählen Sie als Anwendungsstandort Global aus.
Geben Sie my-global-app für den Anwendungsnamen ein und klicken Sie auf Weiter.
Optional können Sie einen Anzeigenamen, eine Kritikalität, eine Umgebung und Inhaber hinzufügen.
Klicken Sie auf Erstellen.
Klicken Sie auf dem Tab Dienste und Arbeitslasten auf Dienst/Arbeitslast registrieren.
Wählen Sie die Weiterleitungsregel aus, geben Sie ihr den Namen frontend-service und klicken Sie auf Registrieren.
Wählen Sie den Cloud Run-Dienst aus, geben Sie ihm den Namen backend-service und klicken Sie auf Registrieren.

gcloud

Anwendung erstellen:

gcloud apphub applications create my-global-app \
    --location=global \
    --display-name="My Global Application" \
    --project=${PROJECT_ID}

Ermitteln Sie die IDs für die Weiterleitungsregel und den Cloud Run-Dienst in der entsprechenden Region:

gcloud apphub discovered-services list \
    --location=global \
    --project=${PROJECT_ID}

gcloud apphub discovered-services list \
    --location=${REGION} \
    --project=${PROJECT_ID}

Notieren Sie sich die ID der Weiterleitungsregel und des Cloud Run-Dienstes.

Registrieren Sie die Weiterleitungsregel für die globale Anwendung:

gcloud apphub applications services create frontend-service \
    --application=my-global-app \
    --discovered-service=projects/${PROJECT_ID}/locations/global/discoveredServices/FRONTEND_ID \
    --display-name="Frontend Service" \
    --location=global \
    --project=${PROJECT_ID}

Ersetzen Sie FRONTEND_ID durch die ID der Weiterleitungsregel.

Registrieren Sie den Cloud Run-Dienst für die globale Anwendung:

gcloud apphub applications services create backend-service \
    --application=my-global-app \
    --discovered-service=projects/${PROJECT_ID}/locations/${REGION}/discoveredServices/BACKEND_ID \
    --display-name="Backend Service" \
    --location=global \
    --project=${PROJECT_ID}

Ersetzen Sie BACKEND_ID durch die ID des Cloud Run-Dienstes.

Terraform

Erstellen Sie eine application.tf-Datei und fügen Sie den folgenden Code hinzu:

# Application
resource "google_apphub_application" "my_global_app" {
  project        = "PROJECT_ID"
  location       = "global"
  application_id = "my-global-app"
  display_name   = "My Global Web App"
  description    = "A sample global web application."
  scope {
    type = "GLOBAL"
  }
  attributes {
    criticality {
      type = "MEDIUM"
    }
    environment {
      type = "DEVELOPMENT"
    }
    business_owners {
      display_name = "Example Business Owner"
      email        = "business-owner@example.com"
    }
    developer_owners {
      display_name = "Example Developer"
      email        = "dev-owner@example.com"
    }
    operator_owners {
      display_name = "Example Operator"
      email        = "operator-owner@example.com"
    }
  }
}

In diesem Block wird die Ressource google_apphub_application verwendet, um eine logische Gruppierung von Anwendungskomponenten zu erstellen.

In diesem Beispiel wird eine globale Anwendung erstellt und Attribute für Governance und Auffindbarkeit definiert, z. B. Wichtigkeit, Umgebung und Inhaber. Sie können diese Werte für Ihre Beispielkonfiguration ändern.

Fügen Sie den folgenden Code zu application.tf hinzu, um Ihre bereitgestellten Ressourcen zu ermitteln:

# Discover the forwarding rule
data "google_apphub_discovered_service" "frontend_service" {
  location = "global"
  service_uri = "//compute.googleapis.com/${google_compute_global_forwarding_rule.default.id}"
}

# Discover the Cloud Run service
data "google_apphub_discovered_service" "backend_service" {
  location    = "REGION"
  service_uri = "//run.googleapis.com/${google_cloud_run_v2_service.default.id}"
}

Mit den Datenquellen google_apphub_discovered_service werden die Ressourcennamen Ihrer vorhandenen Infrastruktur anhand ihrer URIs ermittelt. In diesem Schritt kann App Hub die spezifischen Ressourcen identifizieren, die Sie als Dienste registrieren möchten.

Fügen Sie den folgenden Code zu application.tf hinzu, um die erkannten Ressourcen zu registrieren:

# Register the forwarding rule as a service in the application
resource "google_apphub_service" "frontend" {
  project            = "PROJECT_ID"
  location           = "global"
  application_id     = google_apphub_application.my_global_app.application_id
  service_id         = "frontend-service"
  display_name       = "Frontend Service (LB)"
  discovered_service = data.google_apphub_discovered_service.frontend_service.name
}

# Register the Cloud Run service as a service in the application
resource "google_apphub_service" "backend" {
  project            = "PROJECT_ID"
  location           = "global"
  application_id     = google_apphub_application.my_global_app.application_id
  service_id         = "backend-service"
  display_name       = "Backend Service (Cloud Run)"
  discovered_service = data.google_apphub_discovered_service.backend_service.name
}

Mit den google_apphub_service-Ressourcen werden die erkannten Ressourcen in Ihrer Anwendung als Dienste registriert. In diesem Schritt wird Ihre Infrastruktur mit der Anwendung verknüpft, die Sie in App Hub definiert haben.

Initialisieren und wenden Sie die Terraform-Konfiguration an:
```
terraform init
terraform apply
```
Terraform registriert die Ressourcen für Ihre my-global-app-Anwendung in App Hub.

Optional: Neue Anwendung überwachen

Nachdem Sie Ihre Anwendung in App Hub definiert haben, können Sie integrierteGoogle Cloud -Produkte verwenden, um ihren Zustand und ihre Leistung zu überwachen:

Betriebsdaten in Cloud Hub ansehen:
1. Cloud Hub einrichten
2. Rufen Sie in der Google Cloud Console die Startseite von Cloud Hub auf.
  
  Zur Startseite
3. Wählen Sie in der App-Auswahl die my-global-app-App aus. Auf der Seite wird eine Zusammenfassung des Zustands Ihrer Anwendung angezeigt. Weitere Informationen finden Sie in der Cloud Hub-Übersicht.
Detaillierte Dashboards in Application Monitoring aufrufen:
1. Google Cloud Observability für das Anwendungsmonitoring einrichten
2. Rufen Sie in der Google Cloud Console die Seite Anwendungsmonitoring auf:
  Zu Anwendungsmonitoring
  
  Wenn Sie diese Seite über die Suchleiste suchen, wählen Sie das Ergebnis aus, dessen Zwischenüberschrift Monitoring ist.
3. Wählen Sie in der Projektauswahl der Google Cloud -Konsole das Verwaltungsprojekt aus.
  
  Auf der Seite Application Monitoring (Anwendungsmonitoring) werden vordefinierte Dashboards für Ihre Anwendung angezeigt. Weitere Informationen finden Sie unter Systemdiagnose und Leistung von Anwendungen überwachen.
  
  Eine ausführliche Anleitung zur Verwendung der vordefinierten Dashboards und zum Analysieren Ihrer Telemetriedaten finden Sie unter Anwendungstelemetriedaten ansehen.

Bereinigen

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud -Konto die auf dieser Seite verwendeten Ressourcen in Rechnung gestellt werden:

Dienste abmelden
Löschen Sie die globale Anwendung.
Wenn Sie Ihre Anwendung mit Terraform bereitgestellt haben, führen Sie terraform destroy im Verzeichnis mit Ihren Terraform-Dateien aus, um alle erstellten Ressourcen zu entfernen.
Optional: Wenn Sie für diese Kurzanleitung ein neues Projekt erstellt haben, löschen Sie das Projekt.

Anwendung aus vorhandenen Ressourcen erstellen

Hinweise

Erforderliche Rollen

Beispielkomponenten für die Anwendung bereitstellen

gcloud

Terraform

Anwendung in App Hub definieren

Console

gcloud

Terraform

Optional: Neue Anwendung überwachen

Bereinigen

Nächste Schritte