Node.js-Anwendungen von Heroku zu Cloud Run migrieren

Last reviewed 2023-10-01 UTC

In dieser Anleitung erfahren Sie, wie Sie Node.js-Webanwendungen, die auf Heroku ausgeführt werden, zu Cloud Run in Google Cloud migrieren. Diese Anleitung richtet sich an Architekten und Produktinhaber, die ihre Anwendungen von Heroku zu verwalteten Diensten in Google Cloud migrieren möchten.

Cloud Run ist eine verwaltete Computing-Plattform, mit der Sie zustandslose Container ausführen können, die über HTTP-Anfragen aufgerufen werden. Es basiert auf der Open-Source-Plattform Knative, die eine plattformübergreifende Portierbarkeit bietet und Container-Workflows sowie Standards für Continuous Delivery unterstützt. Die Cloud Run-Plattform ist gut in die Google Cloud-Produktsuite integriert und erleichtert die Entwicklung von portablen, skalierbaren und stabilen Anwendungen.

In dieser Anleitung erfahren Sie, wie Sie eine Anwendung zu Google Cloud migrieren, die in Node.js geschrieben ist und Heroku Postgres als unterstützenden Dienst in Heroku verwendet. Die Webanwendung ist containerisiert und wird in Cloud Run gehostet. Sie verwendet Cloud SQL for PostgreSQL als Persistenzschicht.

In dieser Anleitung verwenden Sie die einfache Anwendung Tasks, mit der Sie Aufgaben erstellen und sie sich ansehen können. Diese Aufgaben werden in der aktuellen Bereitstellung der Anwendung auf Heroku in Heroku Postgres gespeichert.

In dieser Anleitung wird davon ausgegangen, dass Sie mit den grundlegenden Funktionen von Heroku vertraut sind und ein Heroku-Konto oder Zugriff auf eines haben. Außerdem wird davon ausgegangen, dass Sie mit Cloud Run, Cloud SQL, Docker und Node.js vertraut sind.

Ziele

Erstellen Sie ein Docker-Image, um die Anwendung in Cloud Run bereitzustellen.
Erstellen Sie eine Cloud SQL for PostgreSQL-Instanz, die nach der Migration zu Google Cloud als Back-End dient.
Untersuchen Sie den Node.js-Code, um zu verstehen, wie Cloud Run eine Verbindung zu Cloud SQL herstellt und welche Codeänderungen (falls erforderlich) für die Migration von Heroku zu Cloud Run erforderlich sind.
Migrieren Sie Daten von Heroku Postgres zu Cloud SQL for PostgreSQL.
Stellen Sie die Anwendung für Cloud Run bereit.
Testen Sie die bereitgestellte Anwendung.

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.

Möglicherweise werden Ihnen auch die Ressourcen in Rechnung gestellt, die Sie in Heroku verwenden.

Vorbereitung

Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

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

Zur Projektauswahl

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Cloud SQL, Cloud Build, Cloud Run, Container Registry, Service Networking, Serverless VPC Access APIs aktivieren.

Aktivieren Sie die APIs

Prüfen Sie, ob Sie die folgenden Rollen für das Projekt haben: Cloud Run > Cloud Run Admin, Cloud Storage > Storage Admin, Cloud SQL > Cloud SQL Admin, Compute Engine > Compute Network Admin, Resource Manager > Project IAM Admin, Cloud Build > Cloud Build Editor, Serverless VPC Access > Serverless VPC Access Admin, Logging > Logs Viewer, Service Accounts > Service Account Admin, Service Accounts > Service Account User, and Service Usage > Service Usage Consumer

Auf Rollen prüfen

Öffnen Sie in der Google Cloud Console die Seite IAM.
IAM aufrufen
Wählen Sie das Projekt aus.
Suchen Sie in der Spalte Hauptkonto die Zeile mit Ihrer E-Mail-Adresse.

Ist Ihre E-Mail-Adresse nicht in dieser Spalte enthalten, haben Sie keine Rollen.
Prüfen Sie in der Spalte Rolle der Zeile mit Ihrer E-Mail-Adresse, ob die Liste der Rollen die erforderlichen Rollen enthält.

Rollen zuweisen

Öffnen Sie in der Google Cloud Console die Seite IAM.
IAM aufrufen
Wählen Sie das Projekt aus.
Klicken Sie auf Zugriff erlauben.
Geben Sie in das Feld Neue Hauptkonten Ihre E-Mail-Adresse ein.
Wählen Sie in der Liste Rolle auswählen eine Rolle aus.
Wenn Sie weitere Rollen hinzufügen möchten, klicken Sie auf Weitere Rolle hinzufügen und fügen Sie weitere Rollen hinzu.
Klicken Sie auf Speichern.

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

Zur Projektauswahl

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Cloud SQL, Cloud Build, Cloud Run, Container Registry, Service Networking, Serverless VPC Access APIs aktivieren.

Aktivieren Sie die APIs

Auf Rollen prüfen

Öffnen Sie in der Google Cloud Console die Seite IAM.
IAM aufrufen
Wählen Sie das Projekt aus.
Suchen Sie in der Spalte Hauptkonto die Zeile mit Ihrer E-Mail-Adresse.

Ist Ihre E-Mail-Adresse nicht in dieser Spalte enthalten, haben Sie keine Rollen.
Prüfen Sie in der Spalte Rolle der Zeile mit Ihrer E-Mail-Adresse, ob die Liste der Rollen die erforderlichen Rollen enthält.

Rollen zuweisen

Öffnen Sie in der Google Cloud Console die Seite IAM.
IAM aufrufen
Wählen Sie das Projekt aus.
Klicken Sie auf Zugriff erlauben.
Geben Sie in das Feld Neue Hauptkonten Ihre E-Mail-Adresse ein.
Wählen Sie in der Liste Rolle auswählen eine Rolle aus.
Wenn Sie weitere Rollen hinzufügen möchten, klicken Sie auf Weitere Rolle hinzufügen und fügen Sie weitere Rollen hinzu.
Klicken Sie auf Speichern.

Umgebung einrichten

Cloud Shell öffnen

Zu Cloud Shell
Legen Sie in Cloud Shell Umgebungsvariablen und Standardwerte für die in dieser Anleitung verwendete Google Cloud CLI fest.
```
gcloud config set project PROJECT_ID
gcloud config set run/region us-central1
```
Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID.

Architektur

In den folgenden Abbildungen werden die Architektur der Webanwendung in Heroku (wie vorgegeben) und ihr Architekturlayout in Google Cloud (das Sie erstellen werden) beschrieben.

Die Anwendung Tasks, die derzeit in Heroku bereitgestellt wird, besteht aus einem oder mehreren Web-Dynos. Web-Dynos können HTTP-Traffic empfangen und darauf reagieren. Worker-Dynos eignen sich im Gegensatz dazu besser für Hintergrundjobs und zeitgesteuerte Aufgaben. Die Anwendung stellt mithilfe der Vorlagenbibliothek Mustache für Node.js eine Indexseite bereit, die in einer Postgres-Datenbank gespeicherte Aufgaben anzeigt.

Sie können über eine HTTPS-URL auf die Anwendung zugreifen. Mit einer /tasks-Route zu dieser URL können Sie neue Aufgaben erstellen.

In Google Cloud wird Cloud Run als serverlose Plattform zum Bereitstellen der Anwendung Tasks verwendet. Cloud Run wurde für die Ausführung zustandsloser, anfragengesteuerter Container entwickelt. Cloud Run ist besonders geeignet, wenn Ihr verwalteter Dienst Containeranwendungen unterstützt, die automatisch skaliert werden – auch auf null, wenn sie keinen Traffic verarbeiten.

In Heroku verwendete Komponenten denen in Google Cloud zuordnen

In der folgenden Tabelle sind die Komponenten der Heroku-Plattform denen in Google Cloud zugeordnet. Mit dieser Zuordnung können Sie die in dieser Anleitung beschriebene Architektur von Heroku in Google Cloud übertragen.

Komponente	Heroku-Plattform	Google Cloud
Container	Dynos: Heroku verwendet das Containermodell, um Heroku-Anwendungen zu erstellen und zu skalieren. Diese Linux-Container werden als Dynos bezeichnet und können auf eine von Ihnen angegebene Anzahl skaliert werden, um Ressourcenanforderungen für Ihre Heroku-Anwendung zu unterstützen. Je nach Speicher- und CPU-Anforderungen der Anwendung können Sie aus verschiedenen Dyno-Typen auswählen.	Cloud Run-Container: Google Cloud unterstützt das Ausführen von containerisierten Arbeitslasten in zustandslosen Containern, die in einer vollständig verwalteten Umgebung oder in GKE-Clustern (Google Kubernetes Engine) ausgeführt werden können.
Webanwendung	Heroku-Anwendung: Dynos sind die Bausteine der Heroku-Anwendungen. Anwendungen bestehen in der Regel aus einem oder mehreren Dyno-Typen, normalerweise aus einer Kombination aus Web- und Worker-Dynos.	Cloud Run-Dienst: Eine Webanwendung kann als Cloud Run-Dienst modelliert werden. Jeder Dienst erhält seinen eigenen HTTPS-Endpunkt und kann je nach Traffic zu Ihrem Dienstendpunkt automatisch von 0 bis N vertikal skaliert werden.
Datenbank	Heroku Postgres ist die Database-as-a-Service (DaaS) von Heroku, die auf PostgreSQL basiert.	Cloud SQL ist ein verwalteter Datenbankdienst für relationale Datenbanken in Google Cloud.

Beispiel-Webanwendung Tasks in Heroku bereitstellen

In den folgenden Abschnitten wird gezeigt, wie Sie die Befehlszeile (CLI) für Heroku einrichten, das GitHub-Quell-Repository klonen und die Anwendung in Heroku bereitstellen.

Befehlszeile für Heroku einrichten

In dieser Anleitung wird die Heroku-Befehlszeile in Cloud Shell ausgeführt und muss mit einem Heroku API-Schlüssel authentifiziert werden. Bei der Ausführung in Cloud Shell kann sich die Heroku-Befehlszeile nicht mit einem Passwort oder einer webbasierten Authentifizierung authentifizieren.

Wenn Sie das Beispiel auf einem lokalen Terminal ausführen, können Sie eine beliebige Authentifizierungsmethode der Heroku-Befehlszeile verwenden. Wenn Sie die Anleitung auf einem lokalen Terminal ausführen, müssen Sie auch die Google Cloud CLI, git und Docker installieren.

Melden Sie sich in der Webkonsole für Heroku an und kopieren Sie auf der Seite mit den Kontoeinstellungen den Wert Ihres API-Schlüssels.
Installieren Sie die Heroku-Befehlszeile in Cloud Shell:
Authentifizieren Sie die Heroku-Befehlszeile in Cloud Shell: Wenn Sie zur Eingabe Ihres Passworts aufgefordert werden, geben Sie den Wert Ihres API-Schlüssels ein, den Sie aus der Heroku-Konsole kopiert haben, und nicht das Passwort, mit dem Sie sich in der Console anmelden.
```
heroku login --interactive
```

Quell-Repository klonen

Klonen Sie in Cloud Shell das GitHub-Repository der Beispielanwendung Tasks:

git clone https://github.com/GoogleCloudPlatform/migrate-webapp-heroku-to-cloudrun-node.git

Wechseln Sie in das Verzeichnis, das durch das Klonen des Repositorys erstellt wurde:
```
cd migrate-webapp-heroku-to-cloudrun-node
```
Das Verzeichnis enthält die folgenden Dateien:
- Ein Node.js-Skript mit dem Namen index.js und dem Code für die von der Webanwendung bereitgestellten Routen.
- package.json- und package-lock.json-Dateien, die die Abhängigkeiten der Webanwendung beschreiben. Sie müssen diese Abhängigkeiten installieren, damit die Anwendung ausgeführt werden kann.
- Eine Procfile-Datei, die den Befehl angibt, der von der Anwendung beim Start ausgeführt wird. Erstellen Sie eine Procfile-Datei, um die Anwendung in Heroku bereitzustellen.
- Ein views-Verzeichnis mit dem HTML-Inhalt, der von der Webanwendung auf der Route "/" bereitgestellt wird.
- Eine .gitignore-Datei.

Anwendung in Heroku bereitstellen

Erstellen Sie in Cloud Shell eine Heroku-Anwendung:
```
heroku create
```
Notieren Sie sich den für die Anwendung erstellten Namen. Sie benötigen diesen Wert im nächsten Schritt.
Erstellen Sie eine Umgebungsvariable für den Namen der Heroku-Anwendung:
```
export APP_NAME=APP_NAME
```
Ersetzen Sie APP_NAME durch den Anwendungsnamen, der vom Befehl heroku create zurückgegeben wird.
Fügen Sie das Heroku Postgres-Add-on hinzu, um eine PostgreSQL-Datenbank bereitzustellen:
```
heroku addons:create heroku-postgresql:mini
```

Prüfen Sie, ob das Add-on erfolgreich hinzugefügt wurde:

heroku addons

Wenn das Postgres-Add-on erfolgreich hinzugefügt wurde, erhalten Sie eine Meldung wie die folgende:

Add-on               Plan     Price       State
-----------------    -----    --------    -----
heroku-postgresql    mini     5$/month    created

Stellen Sie die Anwendung in Heroku bereit:
```
git push heroku master
```
Führen Sie den folgenden Befehl aus, um den Wert von DATABASE_URL zu bestätigen.
```
heroku config
```
Notieren Sie den abgerufenen Wert für DATABASE_URL. Sie benötigen diesen Wert im nächsten Schritt.
Führen Sie einen Docker-Container aus.
```
docker run -it --rm postgres psql "DATABASE_URL"
```
Ersetzen Sie DATABASE_URL durch die Heroku Postgres-URI, den Sie im vorherigen Schritt notiert haben.
Erstellen Sie im Docker-Container die Tabelle TASKS mit dem folgenden Befehl:
```
CREATE TABLE TASKS
(DESCRIPTION TEXT NOT NULL);
```
Schließen Sie den Container:
```
exit
```
Rufen Sie in Cloud Shell die Web-URL für die Heroku-Anwendung ab. Führen Sie dazu den folgenden Befehl aus:
```
heroku info
```
Öffnen Sie die Web-URL in einem Browserfenster. Die Anwendung sieht wie im folgenden Screenshot aus (Ihre Version enthält allerdings nicht die hier aufgelisteten Aufgaben):
Erstellen Sie im Browser Beispielaufgaben in Ihrer Anwendung. Die Aufgaben müssen aus der Datenbank abgerufen werden und auf der Benutzeroberfläche sichtbar sein.

Webanwendungscode für die Migration zu Cloud Run vorbereiten

In diesem Abschnitt werden die Schritte beschrieben, die Sie ausführen müssen, um Ihre Webanwendung für die Bereitstellung in Cloud Run vorzubereiten.

Docker-Container in Container Registry erstellen und veröffentlichen

Sie benötigen ein Docker-Image, um den Anwendungscontainer zu erstellen und ihn in Cloud Run ausführen zu können. Sie können den Container manuell oder mit Buildpacks erstellen.

Container manuell erstellen

Erstellen Sie in Cloud Shell ein Dockerfile in dem Verzeichnis, das durch das Klonen des Repositorys für diese Anleitung erstellt wurde:

cat <<"EOF" > Dockerfile
# Use the official Node image.
# https://hub.docker.com/_/node
FROM node:10-alpine

# Create and change to the app directory.
WORKDIR /app

# Copying this separately prevents re-running npm install on every code change.
COPY package*.json ./
RUN npm install

# Copy local code to the container image.
COPY . /app

# Configure and document the service HTTP port.
ENV PORT 8080
EXPOSE $PORT

# Run the web service on container startup.
CMD ["npm", "start"]
EOF

Erstellen Sie den Container mit Cloud Build und veröffentlichen Sie das Image in Container Registry:

gcloud builds submit --tag gcr.io/PROJECT_ID/APP_NAME:1 \
  --gcs-log-dir=gs://PROJECT_ID_cloudbuild

Erstellen Sie eine Umgebungsvariable, die den Namen des von Ihnen erstellten Docker-Images enthält:
```
export IMAGE_NAME="gcr.io/PROJECT_ID/APP_NAME:1"
```

Container mit Buildpacks erstellen

Installieren Sie die pack-Befehlszeile in Cloud Shell:
Legen Sie für die pack-Befehlszeile fest, dass standardmäßig der Heroku-Builder verwendet wird:
```
pack config default-builder heroku/buildpacks:22
```
Erstellen Sie eine Umgebungsvariable für den Namen des Docker-Images:
```
export IMAGE_NAME=gcr.io/PROJECT_ID/APP_NAME:1
```
Erstellen Sie das Image mit dem pack-Befehl und übertragen Sie das Image per Push in Container Registry oder veröffentlichen Sie es dort:
```
pack build --publish $IMAGE_NAME
```

Cloud SQL for PostgreSQL-Instanz erstellen

Sie erstellen eine Cloud SQL for PostgreSQL-Instanz, die als Back-End für die Webanwendung dient. In dieser Anleitung eignet sich PostgreSQL am besten, da die Beispielanwendung auf Heroku bereitgestellt wird und eine Postgres-Datenbank als Back-End verwendet. Die Migration von einem verwalteten Postgres-Dienst zu Cloud SQL for PostgreSQL erfordert für diese Anwendung keine Schemaänderungen.

Bereiten Sie Ihr Netzwerk für Cloud SQL mit einer privaten IP-Adresse vor.

gcloud compute addresses create google-managed-services-default \
  --global \
  --purpose=VPC_PEERING \
  --prefix-length=16 \
  --description="peering range for CloudSQL Private Service Access" \
  --network=default

gcloud services vpc-peerings connect \
  --service=servicenetworking.googleapis.com \
  --ranges=google-managed-services-default \
  --network=default \
  --project=PROJECT_ID

Erstellen Sie eine Umgebungsvariable mit dem Namen CLOUDSQL_DB_NAME, die den Namen der Datenbankinstanz enthält, die Sie im nächsten Schritt erstellen:
```
export CLOUDSQL_DB_NAME=tasks-db
```

Erstellen Sie die Datenbank:

gcloud sql instances create $CLOUDSQL_DB_NAME \
--cpu=1 \
--memory=4352Mib \
--database-version=POSTGRES_15 \
--region=us-central1 \
--network default \
--no-assign-ip

Die Initialisierung der Instanz kann einige Minuten dauern.

Legen Sie ein Passwort für den Postgres-Nutzer fest:
```
gcloud sql users set-password postgres \
    --instance=$CLOUDSQL_DB_NAME  \
    --password=POSTGRES_PASSWORD
```
Ersetzen Sie POSTGRES_PASSWORD durch das Passwort, das Sie für die Postgres-Datenbank verwenden möchten.

Daten aus Heroku Postgres in Cloud SQL importieren

Es gibt mehrere Migrationsmuster, mit denen Sie Daten zu Cloud SQL migrieren können. Normalerweise ist es am besten, Cloud SQL als Replikat für die zu migrierende Datenbank zu konfigurieren und Cloud SQL nach der Migration zur primären Instanz zu machen. Bei dieser Vorgehensweise ist keine oder nur eine geringe Ausfallzeit erforderlich. Heroku Postgres unterstützt keine externen Replikate (Follower). In dieser Anleitung verwenden Sie daher Open-Source-Tools, um das Schema der Anwendung zu migrieren.

Für die Anwendung Tasks in dieser Anleitung verwenden Sie das Dienstprogramm pg_dump, um Daten aus Heroku Postgres in einen Cloud Storage-Bucket zu exportieren und dann in Cloud SQL zu importieren. Dieses Dienstprogramm kann Daten zwischen einheitlichen Versionen übertragen oder auch, wenn die Version der Zieldatenbank neuer ist als die Quelldatenbank.

Rufen Sie in Cloud Shell die Anmeldedaten für Ihre Heroku Postgres-Datenbank ab, die an die Beispielanwendung angehängt ist. Sie benötigen diese Anmeldedaten im nächsten Schritt.
```
heroku pg:credentials:url
```
Dieser Befehl gibt den String mit den Verbindungsinformationen und die Verbindungs-URL für die Anwendung zurück. Der String mit den Verbindungsinformationen hat folgendes Format:
```
"dbname=DATABASE_NAME host=FQDN port=5432 user=USER_NAME password=PASSWORD_STRING sslmode=require"
```
Sie benötigen die im Verbindungsstring angezeigten Werte im nächsten Schritt.

Ein Beispiel für einen FQDN-Wert (voll qualifizierter Domainname) in einem Verbindungsinformationsstring finden Sie in der Heroku-Dokumentation.
Legen Sie Umgebungsvariablen auf Heroku-Werte fest, die Sie in den nachfolgenden Schritten verwenden:
```
export HEROKU_PG_DBNAME=DATABASE_NAME
export HEROKU_PG_HOST=FQDN
export HEROKU_PG_USER=USER_NAME
export HEROKU_PG_PASSWORD=PASSWORD_STRING
```
Ersetzen Sie Folgendes:
- DATABASE_NAME: der Datenbankname, der im Informationsstring angezeigt wird.
- FQDN: der im Informationsstring angezeigte FQDN.
- USER_NAME: der im Informationsstring angezeigte Nutzername.
- PASSWORD_STRING: der im Informationsstring angezeigte Passwortstring.

Erstellen Sie eine Sicherung Ihrer Heroku Postgres-Datenbank im SQL-Format:

docker run \
  -it --rm \
  -e PGPASSWORD=$HEROKU_PG_PASSWORD \
  -v $(pwd):/tmp \
  --entrypoint "pg_dump" \
  postgres \
  -Fp \
  --no-acl \
  --no-owner \
  -h $HEROKU_PG_HOST \
  -U $HEROKU_PG_USER \
  $HEROKU_PG_DBNAME > herokudump.sql

Erstellen Sie eine Umgebungsvariable, die den Namen Ihres Cloud Storage-Buckets enthält:
```
export PG_BACKUP_BUCKET=gs://PROJECT_ID-pg-backup-bucket
```

Erstellen Sie einen Cloud Storage-Bucket:

gcloud storage buckets create $PG_BACKUP_BUCKET \
  --location=us-central1 \
  --public-access-prevention \
  --uniform-bucket-level-access

Laden Sie die SQL-Datei in diesen Bucket hoch:

gcloud storage cp herokudump.sql $PG_BACKUP_BUCKET/herokudump.sql

Autorisieren Sie Ihre Cloud SQL-Instanz mit den erforderlichen Rollen zum Importieren der SQL-Datei aus dem Cloud Storage-Bucket:

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:$(gcloud sql instances describe $CLOUDSQL_DB_NAME --format='get("serviceAccountEmailAddress")') \
  --role=roles/storage.objectAdmin

gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:$(gcloud sql instances describe $CLOUDSQL_DB_NAME --format='get("serviceAccountEmailAddress")') \
  --role=roles/cloudsql.editor

Importieren Sie die SQL-Datei in die Cloud SQL-Instanz:

gcloud sql import sql $CLOUDSQL_DB_NAME $PG_BACKUP_BUCKET/herokudump.sql \
  --database=postgres \
  --user=postgres

Geben Sie bei Aufforderung do you want to continue (y/n) "y" ein.

So greift Cloud Run auf die Cloud SQL-Datenbank zu

So wie die in Heroku bereitgestellte Webanwendung eine Verbindung zur verwalteten Instanz von Heroku Postgres herstellen muss, benötigt Cloud Run Zugriff auf Cloud SQL, um Daten lesen und schreiben zu können.

Cloud Run kommuniziert mit Cloud SQL über den Cloud SQL-Proxy, der automatisch aktiviert und konfiguriert wird, wenn Sie den Container in Cloud Run bereitstellen. Für die Datenbank müssen keine externen IP-Adressen genehmigt werden, da die gesamte Kommunikation über eine sichere TCP-Verbindung des Proxys empfangen wird.

Ihr Code muss Datenbankvorgänge wie das Abrufen von Daten aus der Datenbank oder Schreiben in die Datenbank durch Aufrufen des Proxys über einen UNIX-Socket ausführen.

Da diese Webanwendung in Node.js geschrieben ist, verwenden Sie die Bibliothek pg-connection-string, um eine Datenbank-URL zu parsen und ein config-Objekt zu erstellen. Der Vorteil dieses Ansatzes besteht in der nahtlosen Verbindung zwischen den Back-End-Datenbanken in Heroku und Cloud Run.

Im nächsten Schritt übergeben Sie die Datenbank-URL als Umgebungsvariable, wenn Sie die Webanwendung bereitstellen.

Beispielanwendung für Cloud Run bereitstellen

Konfigurieren Sie in Cloud Shell den serverlosen VPC-Zugriff, um privaten Traffic von Cloud Run zu Cloud SQL zuzulassen:

gcloud compute networks subnets create serverless-connector-subnet \
--network=default \
--range=10.0.0.0/28 \
--region=us-central1

gcloud compute networks vpc-access connectors create serverless-connector \
--region=us-central1 \
--subnet=serverless-connector-subnet

Erstellen Sie in Cloud Shell eine Umgebungsvariable, die den Verbindungsnamen der von Ihnen erstellten Cloud SQL-Instanz enthält:
```
export DB_CONN_NAME=$(gcloud sql instances describe $CLOUDSQL_DB_NAME --format='value(connectionName)')
```
Erstellen Sie eine Umgebungsvariable mit dem Namen DATABASE_URL, die den Verbindungsstring für die Verbindung zum Cloud SQL-Proxy über einen UNIX-Port enthält.
```
export DATABASE_URL="socket:/cloudsql/${DB_CONN_NAME}?db=postgres&user=postgres&password=POSTGRES_PASSWORD"
```

Erstellen Sie ein Dienstkonto für Cloud Run mit einer IAM-Rolle, um eine Verbindung zur Datenbank herzustellen:

gcloud iam service-accounts create sa-run-db-client

gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:sa-run-db-client@PROJECT_ID.iam.gserviceaccount.com \
    --role=roles/cloudsql.client

Stellen Sie die Webanwendung in Cloud Run bereit:
```
gcloud run deploy tasksapp-PROJECT_ID \
    --image=$IMAGE_NAME \
    --service-account=sa-run-db-client@PROJECT_ID.iam.gserviceaccount.com \
    --set-env-vars=DATABASE_URL=$DATABASE_URL \
    --add-cloudsql-instances $DB_CONN_NAME \
    --vpc-connector serverless-connector \
    --allow-unauthenticated
```
Der vorherige Befehl verknüpft auch Ihren Cloud Run-Container mit der von Ihnen erstellten Cloud SQL-Datenbankinstanz. Der Befehl legt eine Umgebungsvariable für Cloud Run fest, die auf den String DATABASE_URL verweist, den Sie im vorherigen Schritt erstellt haben.

Hinweis: Da diese Beispielaufgaben-App eine öffentlich zugängliche Webanwendung ist und das Flag --allow-unauthenticated verwendet, schlägt die Bereitstellung fehl, wenn Ihre Organisation die Organisationsrichtlinie „iam.allowedPolicyMemberDomains“ erzwingt. Deaktivieren Sie die Richtlinie für Ihr Anleitungsprojekt, um eine öffentlich zugängliche und nicht authentifizierte Cloud Run-Beispielanwendung bereitzustellen. Für eine echte Anwendung, die eine Authentifizierung von Endnutzern erfordert, finden Sie weitere Informationen unter Endnutzer authentifizieren.

Anwendung testen

Rufen Sie in Cloud Shell die URL ab, über den Cloud Run Traffic verarbeitet:
```
gcloud run services list
```
Sie können sich den Cloud Run-Dienst auch in der Google Cloud Console ansehen.
Rufen Sie die URL des Cloud Run-Diensts auf, um zu prüfen, ob Ihre Webanwendung HTTP-Anfragen akzeptiert.

Cloud Run erstellt oder startet einen neuen Container, wenn eine HTTP-Anfrage an den Bereitstellungsendpunkt gesendet wird und noch kein Container ausgeführt wird. Dies bedeutet, dass die Anfrage, die den Start eines neuen Containers auslöst, etwas länger dauern kann. Berücksichtigen Sie in Anbetracht dieser zusätzlichen Zeit die Anzahl der gleichzeitigen Anfragen, die Ihre Anwendung unterstützen kann, sowie etwaige Speicheranforderungen.

Für diese Anwendung verwenden Sie die Standardeinstellungen für die Gleichzeitigkeit, mit der ein Cloud Run-Dienst 80 Anfragen gleichzeitig über einen einzelnen Container verarbeiten kann.

Bereinigen

Führen Sie eine Bereinigung durch, um zu vermeiden, dass Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen in Rechnung gestellt werden. Sie können auch die für diese Anleitung in Heroku erstellten Ressourcen löschen.

Google Cloud-Projekt löschen

Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.
Zur Seite „Ressourcen verwalten“
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Heroku-Anwendung löschen

Führen Sie den folgenden Befehl aus, um die in Heroku und dem zugehörigen PostgreSQL-Add-on bereitgestellte Beispielanwendung zu löschen:

heroku apps:destroy -a APP_NAME

Nächste Schritte

Daten in Cloud SQL importieren
Cloud Run-Dokumentation
Referenzarchitekturen, Diagramme und Best Practices zu Google Cloud kennenlernen. Weitere Informationen zu Cloud Architecture Center