Déployer des services à partir du code source

Cette page explique comment déployer un nouveau service ou une nouvelle révision de service sur Cloud Run directement à partir du code source à l'aide d'une seule commande de gcloud CLI, gcloud run deploy avec l'option --source. Pour obtenir un exemple de déploiement d'un service Hello World, consultez la section Déployer à partir de guides de démarrage rapides sources.

Vous pouvez utiliser cette fonctionnalité de deux manières différentes :

Notez que les déploiements sources utilisent Artifact Registry pour stocker les conteneurs créés. Si votre projet ne dispose pas encore d'un dépôt Artifact Registry portant le nom cloud-run-source-deploy dans la région où vous effectuez le déploiement, cette fonctionnalité crée automatiquement un dépôt Artifact Registry nommé cloud-run-source-deploy.

Si un Dockerfile est présent dans le répertoire du code source, le code source importé est créé à l'aide de ce Dockerfile. Si le Dockerfile n'est pas présent dans le répertoire du code source, les packs de création Google Cloud détectent automatiquement le langage que vous utilisez et extrait les dépendances du code pour créer une image de conteneur prête pour la production, à l'aide d'une image de base sécurisée et gérée par Google

Par défaut, les correctifs de sécurité ne sont appliqués que lorsque le service Cloud Run est déployé. Lorsque vous activez les mises à jour de sécurité automatiques pour un service, celui-ci reçoit automatiquement des correctifs sans temps d'arrêt. En savoir plus sur la configuration des mises à jour de sécurité

Avant de commencer

  • Assurez-vous d'avoir configuré un nouveau projet pour Cloud Run, comme décrit sur la page de configuration.

  • Si vous êtes soumis à une règle d'administration de restriction de domaine limitant les appels non authentifiés pour votre projet, vous devez accéder au service déployé comme décrit dans la section Tester les services privés.

  • 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

    Une fois l'API Cloud Run Admin activée, le compte de service Compute Engine par défaut est créé automatiquement.

Rôles requis

Pour déployer à partir de la source, vous ou votre administrateur devez attribuer les rôles IAM suivants au compte déployeur.

Cliquez ici pour afficher les rôles requis pour le compte déployeur

Pour obtenir les autorisations nécessaires pour compiler et déployer à partir de la source, demandez à votre administrateur de vous accorder les rôles IAM suivants :

Pour obtenir la liste des rôles et des autorisations IAM associés à Cloud Run, consultez les sections Rôles IAM Cloud Run et Autorisations IAM Cloud Run. Si votre service Cloud Run communique avec des APIGoogle Cloud , telles que les bibliothèques clientes Cloud, consultez le guide de configuration de l'identité du service. Pour en savoir plus sur l'attribution de rôles, consultez les pages Autorisations de déploiement et Gérer les accès.

Langues disponibles

En plus des sources avec un Dockerfile, le déploiement à partir de la source accepte les langages suivants à l'aide des buildpacks de Google Cloud :

Environnement d'exécution Déploiement de la source Configuration du buildpack
Go Déployer un service Go Configurer les buildpacks Go
Node.js Déployer un service Node.js Configurer les buildpacks Node.js
Python Déployer un service Python Configurer les buildpacks Python
Java 
(y compris Kotlin, Groovy et Scala)		 Déployer un service Java Configurer les buildpacks Java
.NET Déployer un service .NET Configurer les buildpacks .NET
Ruby Déployer un service Ruby Configurer les buildpacks Ruby
PHP Déployer un service PHP Configurer les buildpacks PHP

Pour en savoir plus sur les versions de langages acceptées,

Déployer à partir d'une source avec compilation

Cette section explique comment utiliser les packs de création Google Cloud et Cloud Build pour créer automatiquement des images de conteneurs à partir de votre code source sans avoir à installer Docker sur votre machine ni configurer des packs de création ou Cloud Build.

Limites

  • La fonctionnalité de déploiement à partir de la source utilise Artifact Registry et Cloud Build. Cette fonctionnalité n'est donc disponible que dans les régions compatibles avec Artifact Registry et Cloud Build.
  • Le déploiement à partir de la source est une fonctionnalité pratique qui ne permet pas une personnalisation complète de la compilation. Pour mieux contrôler l'image de conteneur, créez-la à l'aide de Cloud Build, par exemple en utilisant gcloud builds submit, puis déployez l'image de conteneur en utilisant, par exemple, gcloud run deploy --image.
  • Le déploiement d'une source avec les packs de création Google Cloud définit la date de la dernière modification des fichiers sources sur le 1er janvier 1980. Il s'agit du comportement par défaut des packs de création, qui est conçu pour être compatible avec les compilations reproductibles. Selon votre framework de langage, cela peut affecter la mise en cache des fichiers statiques côté navigateur. Si votre application est affectée par cela, nous vous recommandons de désactiver les en-têtes HTTP etag et Last-Modified dans votre application.
  • Le déploiement à partir de la source avec les packs de création de Google Cloud utilise toujours gcr.io/buildpacks/builder:latest. Si votre configuration de langage ou de système d'exploitation préférée n'est pas disponible dans latest, utilisez un compilateur spécifique pour créer une image d'application à l'aide de votre compilateur préféré.

  • Vous pouvez déployer votre service à partir de la source à l'aide de Kotlin et d'autres langages JVM tels que Java. La langue que vous utilisez doit respecter les règles suivantes :

    • Vous pouvez compiler l'application à l'aide de Maven ou de Gradle.
    • Le fichier de compilation contient tous les plug-ins requis pour produire les classes.

Avant de déployer avec build

Avant de déployer à partir de la source avec compilation :

  • Suivez les étapes de la section Avant de commencer.

  • 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

Rôles requis

Pour déployer à partir de la source avec compilation, vous ou votre administrateur devez accorder les rôles IAM suivants au compte de service Cloud Build.

Cliquez ici pour afficher les rôles requis pour le compte de service Cloud Build

Cloud Build utilise automatiquement le compte de service Compute Engine par défaut comme compte de service Cloud Build par défaut pour compiler votre code source et votre ressource Cloud Run, sauf si vous modifiez ce comportement. Pour que Cloud Build puisse créer vos sources, demandez à votre administrateur d'accorder le rôle Créateur Cloud Run (roles/run.builder) au compte de service Compute Engine par défaut sur votre projet :

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

Remplacez PROJECT_NUMBER par le numéro de votre projet Google Cloudet PROJECT_ID par l'ID de votre projet Google Cloud. Pour obtenir des instructions détaillées sur la recherche de votre ID et de votre numéro de projet, consultez la section Créer et gérer des projets.

L'attribution du rôle "Compte de service Cloud Run" au compte de service Compute Engine par défaut prend quelques minutes à se propager.

Pour obtenir la liste des rôles et des autorisations IAM associés à Cloud Run, consultez les sections Rôles IAM Cloud Run et Autorisations IAM Cloud Run. Si votre service Cloud Run communique avec des APIGoogle Cloud , telles que les bibliothèques clientes Cloud, consultez le guide de configuration de l'identité du service. Pour en savoir plus sur l'attribution de rôles, consultez les pages Autorisations de déploiement et Gérer les accès.

Déployer avec build

Pour déployer à partir du code source, cliquez sur l'onglet pour obtenir des instructions concernant l'utilisation de l'outil de votre choix.

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. Accédez à votre répertoire source. Le répertoire source utilise un Dockerfile s'il est présent, mais ce n'est pas obligatoire.

  3. Créez et déployez votre service :

    gcloud run deploy SERVICE --source .

    Remplacez SERVICE par le nom souhaité pour votre service.

  4. Répondez aux invites pour installer les API requises en répondant y lorsque vous y êtes invité. Vous ne devez procéder à cette opération qu'une fois par projet. Répondez aux autres invites en fournissant la plate-forme et la région, si vous n'avez pas défini les paramètres par défaut pour celles-ci, comme décrit sur la page de configuration.

  5. Attendez la fin de la compilation et du déploiement. Une fois l'opération terminée, Cloud Run affiche un message de réussite.

    6. Après le déploiement, cette révision de service diffuse 100 % du trafic.

    Cloud Code

    Pour déployer à partir de la source à l'aide de Cloud Code, consultez les guides IntelliJ et Visual Studio Code.

    CLI Gemini

    Utilisez la commande /deploy dans l'outil Gemini CLI pour déployer un service Cloud Run à partir du code source.

    Pour utiliser la Gemini CLI avec l'extension Cloud Run, procédez comme suit :

    1. Installez la dernière version de la Gemini CLI dans l'un des environnements de développement suivants :

      • Terminal
      • Cloud Shell
      • VS Code avec le mode Agent de Gemini Code Assist (voir l'onglet "VS Code")

    2. Installez l'extension Cloud Run :

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

    3. Connectez-vous à Google Cloud CLI :

      gcloud auth login

    4. Configurez les Identifiants par défaut de l'application :

      gcloud auth application-default login

    5. Accédez au répertoire de votre code source.

    6. Lancez la Gemini CLI :

      gemini

    7. Créez et déployez votre service :

      /deploy
      • Si vous êtes invité à fournir le projet Google Cloud , saisissez le nom de votre projet.
      • Si vous êtes invité à sélectionner un outil, choisissez deploy_local_folder.

    8. Attendez la fin de la compilation et du déploiement. Une fois l'opération terminée, Cloud Run affiche un message de réussite.

    MCP

    Pour déployer un service Cloud Run à partir du code source d'un client MCP (Model Context Protocol), installez le serveur Cloud Run Model Context Protocol (MCP).

    Les instructions d'installation varient en fonction du client MCP. Souvent, ils nécessitent d'ajouter les lignes suivantes au fichier JSON des paramètres :

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

    Nouveau message

    Vous pouvez stocker votre spécification Compose dans un fichier YAML, puis la déployer à partir du code source en tant que service Cloud Run à l'aide d'une seule commande gcloud.

    1. Accédez à votre répertoire source. Le répertoire source utilise un fichier Dockerfile s'il est présent, mais ce n'est pas obligatoire.

    2. Dans le répertoire de votre projet, créez un fichier compose.yaml avec vos définitions de service.

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

      Vous pouvez également spécifier d'autres options de configuration, telles que des variables d'environnement, des secrets et des montages de volumes.

    3. Pour déployer les services, exécutez la commande gcloud beta run compose up :

      gcloud beta run compose up compose.yaml

    4. Répondez y à toutes les invites pour installer les composants requis ou activer les API.

    5. Facultatif : Rendez votre service public si vous souhaitez autoriser un accès non authentifié à celui-ci.

    Une fois le déploiement terminé, l'URL du service Cloud Run s'affiche. Copiez cette URL et collez-la dans votre navigateur pour afficher le conteneur en cours d'exécution. Vous pouvez désactiver l'authentification par défaut depuis la console Google Cloud .

Déployer à partir de la source sans compilation

Vous pouvez déployer des artefacts sources directement dans Cloud Run, en ignorant l'étape Cloud Build. Au lieu de créer une image de conteneur à partir de la source, vous pouvez importer une archive pré-empaquetée de votre application directement dans un bucket Cloud Storage. Cloud Run prend ensuite cette archive et l'exécute directement sur une image de base. Cette approche permet de réduire considérablement les délais de déploiement.

Limites

Le déploiement vers la source sans compilation n'est compatible qu'avec les éléments suivants :

  • Services Cloud Run.
  • Environnements d'exécution compatibles (pas de compatibilité avec Dockerfile).
  • Archive source (.tar.gz) <= 250 Mio.
  • Le binaire (par exemple, le binaire Go) ou le script (par exemple, le script Python) doivent être compatibles avec l'architecture x86.
  • La source doit être autonome, avec toutes les dépendances incluses. L'image de base de l'environnement d'exécution ne contient que le système d'exploitation minimal et quelques bibliothèques de langage.

Avant de déployer sans compilation

Pour utiliser la fonctionnalité "Déployer sans compilation" :

  • Assurez-vous d'avoir suivi les étapes de la section Avant de commencer.

  • Activez les API Cloud Run et Cloud Storage :

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

  • Vous devez installer les dépendances de l'application localement avant le déploiement, car elles ne seront pas installées (aucune compilation).

Déployer sans compilation

Cette section explique comment déployer votre artefact directement sur Cloud Run sans utiliser de build.

gcloud

Pour déployer un répertoire source local, utilisez l'indicateur --no-build pour indiquer à la commande deploy d'ignorer l'étape Cloud Build :

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

Remplacez les éléments suivants :

  • SERVICE_NAME : nom de votre service Cloud Run.
  • APPLICATION_PATH : emplacement de votre application dans le système de fichiers local.
  • BASE_IMAGE : image de base de l'environnement d'exécution que vous souhaitez utiliser pour votre application. Exemple : us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/nodejs24.
  • COMMAND : commande avec laquelle le conteneur démarre.
  • ARG : argument que vous envoyez à la commande du conteneur. Si vous utilisez plusieurs arguments, spécifiez chacun d'eux sur une ligne distincte.

YAML

Vous pouvez stocker votre spécification de service dans un fichier YAML, puis la déployer à l'aide de gcloud CLI ou de l'éditeur de la console Google Cloud service.yaml.

  1. Créez un bucket de stockage pour héberger votre application :

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

    Remplacez les éléments suivants :

    • BUCKET_NAME : nom que vous souhaitez attribuer à votre bucket, soumis aux règles de dénomination. Par exemple, my-bucket.
    • BUCKET_LOCATION : emplacement de votre bucket. Par exemple, US.

  2. Créez une archive avec la source de votre application à l'aide de zip ou tar, par exemple :

    tar -cvzf ARCHIVE_NAME APPLICATION_PATH

    Remplacez les éléments suivants :

    • ARCHIVE_NAME : nom de l'archive à créer. Exemple :app.tar.gz
    • APPLICATION_PATH : emplacement de votre application dans le système de fichiers local. Exemple :~/my-application Pour archiver le répertoire de travail actuel, définissez cette valeur sur *.

  3. Importez l'archive de votre application dans Cloud Storage :

    gcloud storage cp ARCHIVE_NAME gs://BUCKET_NAME

    Remplacez les éléments suivants :

    • ARCHIVE_NAME : chemin d'accès local à l'archive que vous avez créée précédemment. Exemple :app.tar.gz
    • BUCKET_NAME : nom du bucket que vous avez créé précédemment. Exemple :my-bucket

  4. Créez un fichier service.yaml avec le contenu suivant :

    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

    Remplacez les éléments suivants :

    • SERVICE_NAME : nom de votre service Cloud Run. Les noms de service doivent comporter un maximum de 49 caractères et être uniques par région et par projet.
    • BUCKET_NAME : nom du bucket que vous avez créé précédemment. Exemple :my-bucket
    • ARCHIVE_NAME : chemin d'accès local à l'archive que vous avez créée précédemment. (par exemple, app.tar.gz).
    • BASE_IMAGE : image de base d'exécution que vous souhaitez utiliser pour votre application. Exemple : us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/nodejs24.
    • COMMAND : commande avec laquelle le conteneur doit démarrer.
    • ARG1 : argument à envoyer à la commande du conteneur. Si vous utilisez plusieurs arguments, spécifiez chacun d'eux sur une ligne distincte (par exemple, ARG-N).

  5. Déployez le nouveau service :

    gcloud run services replace service.yaml

API REST

API REST :

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

Exemples de déploiement à partir de la source sans compilation

Cette section présente des exemples de déploiement à partir de la source sans utiliser de compilation.

Node.js

Créez un service Node.js :

  1. Créez un répertoire nommé helloworld et modifiez les sous-répertoires comme suit :

    mkdir helloworld
cd helloworld

  2. Créez un fichier package.json avec le contenu suivant :

    {
  "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. Dans le même répertoire, créez un fichier index.js, puis copiez-y les lignes suivantes :

    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}`);
});

    Ce code crée un serveur Web de base qui écoute le port défini par la variable d'environnement PORT.

  4. Dans votre répertoire helloworld, exécutez la commande suivante pour installer les dépendances du service en local :

    npm install

  5. Dans votre répertoire helloworld, déployez le service à l'aide de l'indicateur --no-build, qui indique à la commande deploy d'ignorer l'étape Cloud Build :

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

    Remplacez les éléments suivants :

    • REGION : région dans laquelle votre service est déployé.

Python

Créez un service Python :

  1. Créez un répertoire nommé helloworld et modifiez les sous-répertoires comme suit :

    mkdir helloworld
cd helloworld

  2. Créez un fichier nommé main.py et collez-y le code suivant :

    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)))

    Ce code répond aux requêtes avec notre message d'accueil "Hello World!". Le traitement HTTP est effectué par un serveur Web Gunicorn dans le conteneur. Lorsqu'il est appelé directement en local, ce code crée un serveur Web de base qui écoute le port défini par la variable d'environnement PORT.

  3. Créez un fichier nommé requirements.txt et collez-y le code suivant :

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

    Ce code ajoute les packages requis par l'exemple.

  4. Effectuez un vendoring des dépendances :

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

  5. Déployez le service à l'aide de la gcloud CLI. L'option --no-build indique à la commande deploy de contourner l'étape Cloud Build :

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

Remplacez REGION par la région dans laquelle votre service est déployé.

Dépannage

Cette section fournit quelques conseils pour résoudre les problèmes de déploiement à partir de la source sans utiliser de compilation.

Développement local

Le déploiement à partir de la source sans utiliser de build fonctionne de la même manière que le montage de votre code ou de votre exécutable sur l'image de base.

Exemple :

  1. Créez une copie de l'intégralité du contenu :

    cp -R python/hello-world/ workspace

  2. Exécutez l'image de base en tant qu'utilisateur racine avec la source montée. Vous pouvez éventuellement inclure -p 8080:8080 si vous devez utiliser curl depuis une machine hôte.

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

    Remplacez LOCAL_PATH par l'emplacement de vos fichiers sources locaux.

  3. Exécutez le serveur :

    python main.py

Journal d'exécution

Le journal d'exécution est utile pour déboguer les échecs de déploiement. Dans la consoleGoogle Cloud , accédez à Observabilité > Journaux.

Autorisation refusée pour l'accès à Cloud Storage

Si votre service Cloud Run rencontre des erreurs "Autorisation refusée" lorsqu'il tente d'accéder à des objets Cloud Storage, vous devez attribuer le rôle roles/storage.objectViewer à votre compte de service Cloud Run :

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

Remplacez les éléments suivants :

  • PROJECT : ID de votre projet Google Cloud .
  • SERVICE_ACCOUNT : votre compte de service Cloud Run. Exemple :service-123@serverless-robot-staging.iam.gserviceaccount.com

Automatiser la compilation à partir de la source

Pour éviter les modifications non gérées dans la source locale, nous vous recommandons d'effectuer automatiquement le déploiement lorsque des modifications sont envoyées dans votre dépôt Git. Pour vous faciliter la tâche, vous pouvez connecter et configurer le déploiement continu sur votre service Cloud Run. En connectant vos dépôts GitHub à Cloud Run, vous pouvez configurer des compilations et déployer vos dépôts sans écrire de Dockerfile ni créer de fichiers.

Pour configurer des compilations automatiques, configurez l'automatisation comme indiqué sur la page des compilations continues en veillant à choisir l'option permettant de créer la source avec Buildpacks.

Étapes suivantes

Après avoir déployé un service Cloud Run, vous pouvez effectuer les opérations suivantes :

En savoir plus sur les configurations de déploiement de la source :

Vous pouvez automatiser la création et le déploiement de vos services Cloud Run avec les déclencheurs Cloud Build :