Diese Seite wurde von der Cloud Translation API übersetzt.

Anwendung aus vorhandenen Ressourcen erstellen

In dieser Kurzanleitung erfahren Sie, wie Sie vorhandene Google Cloud Dienste in einer App Hub-Anwendung organisieren. Zuerst stellen Sie eine Beispielkonfiguration bereit, mit der Sie eine globale Webanwendung definieren, indem Sie ihre Komponenten als Anwendung in App Hub registrieren.

Dieser Ansatz ist für Nutzer gedacht, die ihre vorhandene Infrastruktur verwenden möchten, um durch Gruppieren von Ressourcen in logischen Anwendungen mehr Transparenz und operative Kontrolle zu erhalten.

Hinweise

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

App Hub mit einem für Apps aktivierten Ordner einrichten

Hinweis :In diesem Schnellstart wird eine App Hub-Anwendung in einem einzelnen Google Cloud -Projekt erstellt, dem Verwaltungsprojekt im für die Verwaltung von Anwendungen konfigurierten Ordner.
Notieren Sie sich die Projekt-ID des Verwaltungsprojekts, die in diesem Dokument verwendet wird.
Prüfen Sie, ob die folgenden APIs im Verwaltungsprojekt aktiviert sind. Wenn Sie einen Ordner mit aktivierten Apps konfigurieren, 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, um die Berechtigungen zu erhalten, die Sie zum Aktivieren der erforderlichen APIs und zum Erstellen einer Beispielanwendung aus vorhandenen Ressourcen benötigen:

So aktivieren Sie die erforderlichen APIs: Service Usage-Administrator (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.

Ressourcen für die Anwendung bereitstellen

Sie müssen zuerst eine Reihe von Beispielressourcen bereitstellen, die Sie später verwenden, um eine globale Anwendung in App Hub zu definieren:

Ein Cloud Run-Dienst, der als Backend der Anwendung fungiert.
Ein globaler externer Application Load Balancer, der 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 Back-End 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 Back-End-Dienst das serverlose NEG als Back-End 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 sie 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"
}

Dieser Block definiert die folgenden Komponenten:

Eine serverlose Netzwerk-Endpunktgruppe (NEG), die als Backend 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 App Hub in einer Anwendung zu gruppieren:

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 für Ihre Dienste und Arbeitslasten 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 application.tf den folgenden Code 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 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 registriert. Mit diesem Schritt wird die Verknüpfung zwischen Ihrer Infrastruktur und der Anwendung, die Sie in App Hub definiert haben, erstellt.

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 -Dienste 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 Anwendungsauswahl Ihre my-global-app-Anwendung aus. Auf der Seite wird eine Zusammenfassung des Zustands Ihrer Anwendung angezeigt. Weitere Informationen finden Sie unter Cloud Hub – Übersicht.
Detaillierte Dashboards in Application Monitoring ansehen:
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 -Console 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 Anwendungstelemetrie ansehen.

Bereinigen

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

Dienste und Arbeitslasten 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 die Bereitstellung aller von Ihnen erstellten Ressourcen aufzuheben.
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

Ressourcen für die Anwendung bereitstellen

gcloud

Terraform

Anwendung in App Hub definieren

Console

gcloud

Terraform

Optional: Neue Anwendung überwachen

Bereinigen

Nächste Schritte