Dienste aus Quellcode bereitstellen

Auf dieser Seite wird beschrieben, wie Sie einen neuen Dienst oder eine neue Dienstüberarbeitung in Cloud Run direkt aus dem Quellcode mithilfe eines einzelnen gcloud CLI-Befehls gcloud run deploy mit dem Flag --source bereitstellen. Eine Beispiel-Schritt-für-Schritt-Anleitung für die Bereitstellung eines Hello World-Dienstes finden Sie unter Kurzanleitungen für die Bereitstellung aus der Quelle.

Es gibt zwei verschiedene Möglichkeiten, diese Funktion zu nutzen:

Beachten Sie, dass Quellbereitstellungen Artifact Registry zum Speichern von erstellten Containern verwenden. Wenn Ihr Projekt noch kein Artifact Registry-Repository mit dem Namen cloud-run-source-deploy in der Region hat, in der Sie die Bereitstellung durchführen, erstellt dieses Feature automatisch ein Artifact Registry-Repository mit dem Namen cloud-run-source-deploy.

Wenn im Quellcodeverzeichnis ein Dockerfile vorhanden ist, wird der hochgeladene Quellcode mit diesem Dockerfile erstellt. Wenn im Quellcodeverzeichnis kein Dockerfile vorhanden ist, erkennt Google Cloud-Buildpacks die von Ihnen verwendete Sprache automatisch und ruft die Abhängigkeiten des Codes ab, um ein produktionsfähiges Container-Image zu erstellen, wobei ein von Google verwaltetes sicheres Basis-Image verwendet wird.

Standardmäßig werden Sicherheitskorrekturen nur angewendet, wenn der Cloud Run-Dienst bereitgestellt wird. Wenn Sie automatische Sicherheitsupdates für einen Dienst aktivieren, erhält dieser Dienst automatisch und ohne Ausfallzeit Patches. Weitere Informationen zum Konfigurieren von Sicherheitsupdates

Hinweise

  • Prüfen Sie, ob Sie ein neues Projekt für Cloud Run eingerichtet haben, wie auf der Seite Einrichtung beschrieben.

  • Wenn Sie einer Domaineinschränkung zur Organisation nicht eingeschränkter Aufrufe für Ihr Projekt unterliegen, müssen Sie auf Ihren bereitgestellten Dienst zugreifen, wie unter Private Dienste testen beschrieben.

  • Enable the Cloud Run Admin API.

    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 API

    Nachdem die Cloud Run Admin API aktiviert wurde, wird das Compute Engine-Standarddienstkonto automatisch erstellt.

Erforderliche Rollen

Wenn Sie aus der Quelle bereitstellen möchten, müssen Sie oder Ihr Administrator dem Bereitstellerkonto die folgenden IAM-Rollen zuweisen.

Klicken, um die erforderlichen Rollen für das Bereitstellerkonto aufzurufen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen und Bereitstellen aus der Quelle benötigen:

Eine Liste der IAM-Rollen und -Berechtigungen im Zusammenhang mit Cloud Run finden Sie unter IAM-Rollen für Cloud Run und IAM-Berechtigungen für Cloud Run. Wenn Ihr Cloud Run-Dienst mitGoogle Cloud -APIs wie Cloud-Clientbibliotheken verknüpft ist, lesen Sie die Konfigurationsanleitung für Dienstidentitäten. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Bereitstellungsberechtigungen und Zugriff verwalten.

Unterstützte Sprachen

Zusätzlich zu den Quellen bei einem Dockerfile wird die Bereitstellung aus der Quelle in den folgenden Sprachen mit Buildpacks von Google Cloud unterstützt:

Laufzeit Quellbereitstellung Buildpack-Konfiguration
Go Go-Dienst bereitstellen Go-Buildpacks konfigurieren
Node.js Node.js-Dienst bereitstellen Node.js-Buildpacks konfigurieren
Python Python-Dienst bereitstellen Python-Buildpacks konfigurieren
Java 
(einschließlich Kotlin, Groovy, Scala)		 Java-Dienst bereitstellen Java-Buildpacks konfigurieren
.NET .NET-Dienst bereitstellen .NET-Buildpacks konfigurieren
Ruby Ruby-Dienst bereitstellen Ruby-Buildpacks konfigurieren
PHP PHP-Dienst bereitstellen PHP-Buildpacks konfigurieren

Weitere Informationen zu unterstützten Sprachversionen

Aus Quelle mit Build bereitstellen

In diesem Abschnitt wird beschrieben, wie Sie Google Cloud-Buildpacks und Cloud Build verwenden, um automatisch Container-Images aus Ihrem Quellcode zu erstellen, ohne Docker auf Ihrem Computer installieren oder Buildpacks oder Cloud Build einrichten zu müssen.

Beschränkungen

  • Da die Bereitstellung aus der Quelle Artifact Registry und Cloud Build verwendet, ist dieses Feature nur in von Artifact Registry und Cloud Build unterstützten Regionen verfügbar.
  • Die Bereitstellung aus der Quelle ist eine praktische Funktion, die keine vollständige Anpassung des Builds zulässt. Für eine bessere Kontrolle erstellen Sie das Container-Image mit Cloud Build, z. B. mit gcloud builds submit, und stellen dann das Container-Image bereit, z. B. mit gcloud run deploy --image.
  • Bei der Bereitstellung aus der Quelle mit Google Cloud Buildpacks wird das Datum der letzten Änderung der Quelldateien auf den 1. Januar 1980 festgelegt. Dies ist das Standardverhalten von Buildpacks und wurde entwickelt, um reproduzierbare Builds zu unterstützen. Je nach Sprachframework kann sich dies auf das browserseitige Caching statischer Dateien auswirken. Wenn Ihre Anwendung davon betroffen ist, empfiehlt Google, die HTTP-Header etag und Last-Modified in Ihrer Anwendung zu deaktivieren.
  • Für die Bereitstellung aus der Quelle mit Google Cloud Buildpacks wird immer gcr.io/buildpacks/builder:latest verwendet. Wenn Ihre bevorzugte Sprache oder Betriebssystemkonfiguration in latest nicht verfügbar ist, verwenden Sie einen bestimmten Builder, um ein Anwendungs-Image mit Ihrem bevorzugten Builder zu erstellen.

  • Sie können Ihren Dienst aus der Quelle mit Kotlin und anderen JVM-Sprachen wie Java bereitstellen. Die Sprache, die Sie verwenden, muss den folgenden Regeln entsprechen:

    • Sie können die Anwendung mit Maven oder Gradle erstellen.
    • Die Build-Datei enthält alle Plug-ins, die für Produktklassen erforderlich sind.

Vor der Bereitstellung mit Build

Bevor Sie die Bereitstellung aus der Quelle mit Build durchführen:

  • Folgen Sie der Anleitung unter Vorbereitung.

  • Enable the Cloud Build API.

    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 API

Erforderliche Rollen

Wenn Sie die Bereitstellung aus der Quelle mit Build durchführen möchten, müssen Sie oder Ihr Administrator dem Cloud Build-Dienstkonto die folgenden IAM-Rollen zuweisen.

Klicken, um die erforderlichen Rollen für das Cloud Build-Dienstkonto aufzurufen

Cloud Build verwendet automatisch das Compute Engine-Standarddienstkonto als Standard-Cloud Build-Dienstkonto zum Erstellen Ihres Quellcodes und Ihrer Cloud Run-Ressource, sofern Sie dieses Verhalten nicht überschreiben. Damit Cloud Build Ihre Quellen erstellen kann, bitten Sie Ihren Administrator, dem Compute Engine-Standarddienstkonto in Ihrem Projekt die Rolle Cloud Run Builder (roles/run.builder) zuzuweisen:

  gcloud projects add-iam-policy-binding PROJECT_ID \
      --member=serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com \
      --role=roles/run.builder

Ersetzen Sie PROJECT_NUMBER durch Ihre Google CloudProjektnummer und PROJECT_ID durch Ihre Google CloudProjekt-ID. Eine detaillierte Anleitung zum Ermitteln der Projekt-ID und der Projektnummer finden Sie unter Projekte erstellen und verwalten.

Es dauert einige Minuten, bis die Zuweisung der Rolle „Cloud Run-Builder“ für das Compute Engine-Standarddienstkonto übertragen wurde.

Eine Liste der IAM-Rollen und -Berechtigungen im Zusammenhang mit Cloud Run finden Sie unter IAM-Rollen für Cloud Run und IAM-Berechtigungen für Cloud Run. Wenn Ihr Cloud Run-Dienst mitGoogle Cloud -APIs wie Cloud-Clientbibliotheken verknüpft ist, lesen Sie die Konfigurationsanleitung für Dienstidentitäten. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Bereitstellungsberechtigungen und Zugriff verwalten.

Mit Build bereitstellen

Wenn Sie aus dem Quellcode bereitstellen möchten, klicken Sie auf den Tab, um eine Anleitung zum Verwenden des gewünschten Tools zu erhalten.

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Wechseln Sie in Ihr Quellverzeichnis. Das Quellverzeichnis verwendet ein Dockerfile, falls vorhanden. Es ist jedoch nicht erforderlich.

  3. Dienst erstellen und bereitstellen:

    gcloud run deploy SERVICE --source .

    Ersetzen Sie SERVICE durch den gewünschten Dienstnamen.

  4. Beantworten Sie die Aufforderungen, die erforderlichen APIs zu installieren, indem Sie nach Aufforderung y antworten. Dies ist nur einmal für ein Projekt erforderlich. Antworten Sie auf andere Aufforderungen, indem Sie die Plattform und Region angeben, sofern Sie diese nicht wie auf der Einrichtungsseite beschrieben eingerichtet haben.

  5. Warten Sie, bis der Build und die Bereitstellung abgeschlossen sind. Nach Abschluss wird in Cloud Run eine Erfolgsmeldung angezeigt.

    6. Nach der Bereitstellung stellt diese Serviceüberarbeitung 100 % des Traffics bereit.

    Cloud Code

    Informationen zum Bereitstellen aus der Quelle mit Cloud Code finden Sie in den Anleitungen zu IntelliJ und Visual Studio Code.

    Gemini-Befehlszeile

    Verwenden Sie den Befehl /deploy im Tool Gemini CLI, um einen Cloud Run-Dienst aus dem Quellcode bereitzustellen.

    So verwenden Sie die Gemini CLI mit der Cloud Run-Erweiterung:

    1. Installieren Sie die aktuelle Version der Gemini CLI in einer der folgenden Entwicklungsumgebungen:

      • Terminal
      • Cloud Shell
      • VS Code mit dem Gemini Code Assist-Agent-Modus (siehe Tab „VS Code“)

    2. Cloud Run-Erweiterung installieren:

      gemini extensions install https://github.com/GoogleCloudPlatform/cloud-run-mcp

    3. Melden Sie sich in der Google Cloud CLI an:

      gcloud auth login

    4. Standardanmeldedaten für Anwendungen einrichten:

      gcloud auth application-default login

    5. Wechseln Sie in das Verzeichnis mit dem Quellcode.

    6. Starten Sie die Gemini CLI:

      gemini

    7. Erstellen Sie Ihren Dienst und stellen Sie ihn bereit:

      /deploy
      • Wenn Sie aufgefordert werden, das Google Cloud -Projekt anzugeben, geben Sie den Namen Ihres Projekts ein.
      • Wenn Sie aufgefordert werden, ein Tool auszuwählen, wählen Sie deploy_local_folder aus.

    8. Warten Sie, bis der Build und die Bereitstellung abgeschlossen sind. Nach Abschluss wird in Cloud Run eine Erfolgsmeldung angezeigt.

    MCP

    Wenn Sie einen Cloud Run-Dienst aus Quellcode von einem MCP-Client (Model Context Protocol) bereitstellen möchten, installieren Sie den Cloud Run-MCP-Server.

    Die Installationsanleitung variiert je nach MCP-Client. Häufig müssen Sie der JSON-Datei mit den Einstellungen die folgenden Zeilen hinzufügen:

    "mcpServers":{
  "cloud-run": {
    "command": "npx",
    "args": ["-y", "@google-cloud/cloud-run-mcp"]
  }
}

    Schreiben

    Sie können Ihre Compose-Spezifikation in einer YAML-Datei speichern und dann mit einem einzigen gcloud-Befehl aus dem Quellcode als Cloud Run-Dienst bereitstellen.

    1. Wechseln Sie in Ihr Quellverzeichnis. Das Quellverzeichnis verwendet ein Dockerfile, falls vorhanden. Es ist jedoch nicht erforderlich.

    2. Erstellen Sie in Ihrem Projektverzeichnis eine compose.yaml-Datei mit Ihren Dienstdefinitionen.

      services:
  web:
    build: .
    ports:
      - "8080:8080"

      Sie können auch weitere Konfigurationsoptionen angeben, z. B. Umgebungsvariablen, Secrets und Volume-Bereitstellungen.

    3. Führen Sie den Befehl gcloud beta run compose up aus, um die Dienste bereitzustellen:

      gcloud beta run compose up compose.yaml

    4. Antworten Sie mit y auf alle Aufforderungen, erforderliche Komponenten zu installieren oder APIs zu aktivieren.

    5. Optional: Veröffentlichen Sie Ihren Dienst, wenn Sie den nicht authentifizierten Zugriff auf den Dienst zulassen möchten.

    Nach der Bereitstellung wird die Cloud Run-Dienst-URL angezeigt. Kopieren Sie diese URL und fügen Sie sie in Ihren Browser ein, um den ausgeführten Container aufzurufen. Sie können die Standardauthentifizierung in der Google Cloud Console deaktivieren.

Über Quelle bereitstellen, ohne zu erstellen

Sie können Quellartefakte direkt in Cloud Run bereitstellen und den Cloud Build-Schritt umgehen. Anstatt ein Container-Image aus dem Quellcode zu erstellen, können Sie ein vorgefertigtes Archiv Ihrer Anwendung direkt in einen Cloud Storage-Bucket hochladen. Cloud Run nimmt dann dieses Archiv und führt es direkt auf einem Basis-Image aus. Dieser Ansatz führt zu deutlich schnelleren Bereitstellungszeiten.

Beschränkungen

Die Bereitstellung in der Quelle ohne Build wird nur für Folgendes unterstützt:

  • Cloud Run-Dienste
  • Unterstützte Runtimes (keine Dockerfile-Unterstützung).
  • Quellarchiv (.tar.gz) <= 250 MiB
  • Binärdateien (z. B. Go-Binärdateien) oder Skripts (z. B. Python-Skripts) müssen mit der x86-Architektur kompatibel sein.
  • Die Quelle muss in sich geschlossen sein und alle Abhängigkeiten müssen enthalten sein. Das Laufzeit-Basis-Image enthält nur das minimale Betriebssystem und einige Sprachbibliotheken.

Vor der Bereitstellung ohne Build

So verwenden Sie die Funktion „Ohne Build bereitstellen“:

  • Führen Sie die Schritte unter Vorbereitung aus.

  • Aktivieren Sie die Cloud Run API und die Cloud Storage API:

    gcloud services enable run.googleapis.com \
  storage.googleapis.com

  • Sie müssen die Anwendungsabhängigkeiten lokal installieren, bevor Sie die Anwendung bereitstellen, da sie nicht installiert werden (kein Build).

Ohne Build bereitstellen

In diesem Abschnitt wird beschrieben, wie Sie Ihr Artefakt direkt in Cloud Run bereitstellen, ohne es zu erstellen.

gcloud

Wenn Sie ein lokales Quellverzeichnis bereitstellen möchten, verwenden Sie das Flag --no-build, um dem Befehl deploy mitzuteilen, dass der Cloud Build-Schritt umgangen werden soll:

gcloud beta run deploy SERVICE_NAME \
  --source APPLICATION_PATH \
  --no-build \
  --base-image=BASE_IMAGE \
  --command=COMMAND \
  --args=ARG

Ersetzen Sie Folgendes:

  • SERVICE_NAME: Der Name Ihres Cloud Run-Dienstes.
  • APPLICATION_PATH: der Speicherort Ihrer Anwendung im lokalen Dateisystem.
  • BASE_IMAGE: Das Laufzeit-Basis-Image, das Sie für Ihre Anwendung verwenden möchten. Beispiel: us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/nodejs24.
  • COMMAND: Der Befehl, mit dem der Container gestartet wird.
  • ARG: Ein Argument, das Sie an den Containerbefehl senden. Wenn Sie mehrere Argumente verwenden, geben Sie jedes Argument in einer eigenen Zeile an.

YAML

Sie können Ihre Dienstspezifikation in einer YAML-Datei speichern und dann mit der gcloud CLI oder dem Google Cloud console-Editorservice.yaml bereitstellen.

  1. Erstellen Sie einen Storage-Bucket für Ihre Anwendung:

    gcloud storage buckets create gs://BUCKET_NAME --location=BUCKET_LOCATION

    Ersetzen Sie Folgendes:

    • BUCKET_NAME: Der Name, den Sie Ihrem Bucket zuweisen möchten. Beachten Sie dabei die Benennungsanforderungen. Beispiel: my-bucket
    • BUCKET_LOCATION: der Speicherort Ihres Buckets. Beispiel: US

  2. Erstellen Sie ein Archiv mit dem Quellcode Ihrer Anwendung im ZIP- oder TAR-Format, z. B.:

    tar -cvzf ARCHIVE_NAME APPLICATION_PATH

    Ersetzen Sie Folgendes:

    • ARCHIVE_NAME: Der Name des zu erstellenden Archivs. Beispiel: app.tar.gz.
    • APPLICATION_PATH: Der Speicherort Ihrer Anwendung im lokalen Dateisystem. Beispiel: ~/my-application. Wenn Sie das aktuelle Arbeitsverzeichnis archivieren möchten, setzen Sie diesen Wert auf *.

  3. Laden Sie das Anwendungsarchiv in Cloud Storage hoch:

    gcloud storage cp ARCHIVE_NAME gs://BUCKET_NAME

    Ersetzen Sie Folgendes:

    • ARCHIVE_NAME: der lokale Pfad zum Archiv, das Sie zuvor erstellt haben. Beispiel: app.tar.gz.
    • BUCKET_NAME: Der Name des Buckets, den Sie zuvor erstellt haben. Beispiel: my-bucket.

  4. Erstellen Sie eine neue Datei vom Typ service.yaml mit folgendem Inhalt:

    apiVersion: serving.knative.dev/v2
kind: Service
metadata:
 name: SERVICE_NAME
spec:
 template:
   metadata:
     annotations:
       run.googleapis.com/sources: '{"": "gs://BUCKET_NAME/ARCHIVE_NAME"}'
       run.googleapis.com/base-images: '{"": "BASE_IMAGE"}'
   spec:
     containers:
     - image: scratch
       command:
       - COMMAND
       args:
       - ARG1
       - ARG-N
     runtimeClassName: run.googleapis.com/linux-base-image-update

    Ersetzen Sie Folgendes:

    • SERVICE_NAME: Der Name Ihres Cloud Run-Dienstes. Dienstnamen dürfen maximal 49 Zeichen lang sein und pro Region und Projekt nur einmal vorkommen.
    • BUCKET_NAME: Der Name des Buckets, den Sie zuvor erstellt haben. Beispiel: my-bucket.
    • ARCHIVE_NAME: der lokale Pfad zum Archiv, das Sie zuvor erstellt haben. Beispiel: app.tar.gz
    • BASE_IMAGE: Das Basis-Image für die Laufzeit, das Sie für Ihre Anwendung verwenden möchten. Beispiel: us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/nodejs24
    • COMMAND: Der Befehl, mit dem der Container gestartet werden soll.
    • ARG1: das Argument, das Sie an den Containerbefehl senden. Wenn Sie mehrere Argumente verwenden, geben Sie jedes Argument in einer eigenen Zeile an, z. B. ARG-N.

  5. Stellen Sie den neuen Dienst bereit:

    gcloud run services replace service.yaml

REST API

REST API:

curl -H "Content-Type: application/json" \
-H "Authorization: Bearer ACCESS_TOKEN" \
-X POST \
-d '{"template": {"containers": [{"command": ["npm"], "args": ["start"], "image": "scratch", "baseImageUri": "google-22/nodejs22", "sourceCode": {"cloudStorageSource": {"bucket": "'GCS_BUCKET_NAME", "object":"ARCHIVE"}}}]}}' \
https://run.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/services?serviceId=SERVICE_NAME

Beispiele für die Bereitstellung aus dem Quellcode ohne Build

In diesem Abschnitt finden Sie Beispiele für die Bereitstellung aus dem Quellcode ohne Build.

Node.js

Node.js-Dienst erstellen:

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld und ersetzen Sie das aktuelle Verzeichnis durch dieses Verzeichnis:

    mkdir helloworld
cd helloworld

  2. Erstellen Sie eine package.json-Datei mit folgendem Inhalt:

    {
  "name": "helloworld",
  "description": "Simple hello world sample in Node",
  "version": "1.0.0",
  "private": true,
  "main": "index.js",
  "type": "module",
  "scripts": {
    "start": "node index.js"
  },
  "engines": {
    "node": ">=16.0.0"
  },
  "author": "Google LLC",
  "license": "Apache-2.0",
  "dependencies": {
    "express": "^4.17.1"
  }
}

  3. Erstellen Sie im selben Verzeichnis eine index.js-Datei und kopieren Sie die folgenden Zeilen hinein:

    import express from 'express';
const app = express();

app.get('/', (req, res) => {
  const name = process.env.NAME || 'World';
  res.send(`Hello ${name}!`);
});

const port = parseInt(process.env.PORT) || 8080;
app.listen(port, () => {
  console.log(`helloworld: listening on port ${port}`);
});

    Mit diesem Code wird ein einfacher Webserver erstellt, der den von der Umgebungsvariable PORT definierten Port überwacht.

  4. Führen Sie im Verzeichnis helloworld den folgenden Befehl aus, um die Dienstabhängigkeiten lokal zu installieren:

    npm install

  5. Stellen Sie den Dienst in Ihrem helloworld-Verzeichnis mit dem Flag --no-build bereit. Dadurch wird dem Befehl deploy mitgeteilt, dass der Cloud Build-Schritt übersprungen werden soll:

    gcloud beta run deploy helloworld \
 --source . \
 --region=REGION \
 --no-build \
 --base-image=nodejs24 \
 --command=node \
 --args=index.js

    Ersetzen Sie Folgendes:

    • REGION: die Region, in der Ihr Dienst bereitgestellt wird.

Python

Python-Dienst erstellen:

  1. Erstellen Sie ein neues Verzeichnis mit dem Namen helloworld und ersetzen Sie das aktuelle Verzeichnis durch dieses Verzeichnis:

    mkdir helloworld
cd helloworld

  2. Erstellen Sie eine Datei mit dem Namen main.py und fügen Sie den folgenden Code in diese ein:

    import os

from flask import Flask

app = Flask(__name__)


@app.route("/")
def hello_world():
    """Example Hello World route."""
    name = os.environ.get("NAME", "World")
    return f"Hello {name}!"


if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))

    Dieser Code antwortet auf Anfragen mit der Begrüßung „Hello World“. Die HTTP-Verarbeitung erfolgt über einen Gunicorn-Webserver im Container. Wenn dieser Code direkt für die lokale Verwendung aufgerufen wird, erstellt er einen einfachen Webserver, der den von der Umgebungsvariable PORT definierten Port überwacht.

  3. Erstellen Sie eine Datei mit dem Namen requirements.txt und fügen Sie den folgenden Code in diese ein:

    Flask==3.0.3
gunicorn==23.0.0
Werkzeug==3.0.3

    Mit diesem Code werden für das Beispiel erforderliche Pakete hinzugefügt.

  4. Abhängigkeiten von Anbietern:

    pip3 install -r requirements.txt --target=./vendor

  5. Stellen Sie den Dienst mit der gcloud CLI bereit. Das Flag --no-build weist den Befehl deploy an, den Cloud Build-Schritt zu umgehen:

    gcloud beta run deploy helloworld \
  --source . \
  --region=REGION \
  --no-build \
  --base-image=python313 \
  --command=python \
  --args=main.py \
  --set-env-vars PYTHONPATH=./vendor

Ersetzen Sie REGION durch die Region, in der Ihr Dienst bereitgestellt wird.

Fehlerbehebung

In diesem Abschnitt finden Sie einige Tipps zur Fehlerbehebung bei der Bereitstellung aus der Quelle ohne Build.

Lokale Entwicklung

Die Bereitstellung aus dem Quellcode ohne Verwendung von Build funktioniert ähnlich wie das Einbinden Ihres Codes oder Ihrer ausführbaren Datei in das Basis-Image.

Beispiel:

  1. Kopieren Sie alle Inhalte:

    cp -R python/hello-world/ workspace

  2. Führen Sie das Basis-Image als Root-Nutzer mit der gemounteten Quelle aus. Optional können Sie -p 8080:8080 einfügen, wenn Sie curl von einem Hostcomputer aus ausführen müssen.

    docker run -it -v "LOCAL_PATH" -u 0 us-central1-docker.pkg.dev/serverless-runtimes/google-22-full/runtimes/python313 /bin/bash`

    Ersetzen Sie LOCAL_PATH durch den Speicherort Ihrer lokalen Quelldateien.

  3. Server ausführen:

    python main.py

Ausführungsprotokoll

Das Ausführungsprotokoll ist nützlich, um Bereitstellungsfehler zu beheben. Rufen Sie in der Google Cloud Console Observability > Logs auf.

Zugriff auf Cloud Storage verweigert

Wenn bei Ihrem Cloud Run-Dienst beim Zugriff auf Cloud Storage-Objekte Fehler vom Typ „Permission denied“ (Berechtigung verweigert) auftreten, müssen Sie Ihrem Cloud Run-Dienstkonto die Rolle roles/storage.objectViewer zuweisen:

gcloud projects add-iam-policy-binding PROJECT \
  --member="SERVICE_ACCOUNT" \
  --role="roles/storage.objectViewer"

Ersetzen Sie Folgendes:

  • PROJECT: Projekt-ID in Google Cloud .
  • SERVICE_ACCOUNT: Ihr Cloud Run-Dienstkonto. Beispiel: service-123@serverless-robot-staging.iam.gserviceaccount.com.

Build aus der Quelle automatisieren

Als Best Practice zur Vermeidung nicht versionierter Änderungen in der lokalen Quelle empfiehlt Google die Bereitstellung automatisch, wenn Änderungen per Push-Befehl an Ihr Git-Repository übertragen werden. Damit dies einfacher wird, können Sie eine kontinuierliche Bereitstellung mit Ihrem Cloud Run-Dienst verbinden und konfigurieren. Wenn Sie Ihre GitHub-Repositories mit Cloud Run verbinden, können Sie Builds konfigurieren und Ihre Repositories bereitstellen, ohne Dockerfiles schreiben oder Dateien erstellen zu müssen.

Wenn Sie automatisierte Builds konfigurieren möchten, richten Sie die Automatisierung wie auf der Seite für kontinuierliche Builds beschrieben ein. Achten Sie dabei darauf, dass Sie die Option zum Erstellen von Quellcode mit Buildpacks auswählen.

Nächste Schritte

Nachdem Sie einen Cloud Run-Dienst bereitgestellt haben, können Sie Folgendes tun:

Informationen zu den Konfigurationen für die Quellbereitstellung:

Mithilfe von Cloud Build-Triggern können Sie die Builds und Bereitstellungen Ihrer Cloud Run-Dienste automatisieren.