gcloud

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

   Activate Cloud Shell

   At the bottom of the Google Cloud console, aCloud 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. Change to your source directory. The source directory uses a Dockerfile ifpresent, although it's not required.

3. Build and deploy your service:

   gcloudrundeploySERVICE--source.

   ReplaceSERVICE with the name you want for yourservice.

4. Respond to any prompts to install required APIs by respondingy whenprompted. You only need to do this once for a project. Respond to otherprompts by supplying the platform and region, if you haven't set defaultsfor these as described in thesetup page.

5. Wait for the build and deploy to complete. When finished,Cloud Run displays a success message.

After deployment, this service revision serves 100%of traffic.

Cloud Code

To deploy from source usingCloud Code, read theIntelliJ andVisual Studio Code guides.

Gemini CLI

Use the/deploy command in theGemini CLItool to deploy a Cloud Run service fromsource code.

To use the Gemini CLI with theCloud Run extension,follow these steps:

1. Install the latest version of theGemini CLIin one of the following development environments:

   • Terminal
   • Cloud Shell
   • VS Code using Gemini Code Assist agent mode (see the"VS Code" tab)

2. Install the Cloud Run extension:

   geminiextensionsinstallhttps://github.com/GoogleCloudPlatform/cloud-run-mcp

3. Sign in to the Google Cloud CLI:

   gcloudauthlogin

4. Set up Application Default Credentials:

   gcloudauthapplication-defaultlogin

5. Change to your source code directory.

6. Launch the Gemini CLI:

   gemini

7. Build and deploy your service:

   /deploy

   • If you are prompted to provide the Google Cloud project, enteryour project name.
   • If you are prompted to select a tool, selectdeploy_local_folder.

8. Wait for the build and deploy to complete. When finished,Cloud Run displays a success message.

MCP

To deploy a Cloud Run service from source codefrom a Model Context Protocol (MCP) client, install theCloud Run Model Context Protocol (MCP) server.

Installation instructions vary depending on the MCP client. Often, theyrequire adding the following lines to the settings JSON file:

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

Compose

Preview — Cloud Run Compose deploy

This feature is subject to the "Pre-GA Offerings Terms" in the General Service Terms section of theService Specific Terms. Pre-GA features are available "as is" and might have limited support. For more information, see thelaunch stage descriptions.

You can store yourCompose Specification inaYAML file and then deploy it from source code as a Cloud Runservice using a single gcloud command.

1. Change to your source directory. The source directory uses a Dockerfileif present, although it's not required.

2. In your project directory, create acompose.yaml file with yourservice definitions.

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

   You can also specify more configuration options such as environmentvariables, secrets, and volume mounts.

3. To deploy the services, run thegcloud beta run compose up command:

   gcloud beta run compose up compose.yaml

4. Respondy to any prompts to install required components or to enableAPIs.

5. Optional:Make your service publicif you want to allow unauthenticated access to the service.

After deployment, the Cloud Run service URL is displayed. Copythis URL and paste it into your browser to view the running container. You candisable the default authentication from the Google Cloud console.

gcloud

To deploy a local source directory, use the--no-build flag to tell thedeploy command to bypass the Cloud Build step:

gcloud beta run deploySERVICE_NAME \  --sourceAPPLICATION_PATH \  --no-build \  --base-image=BASE_IMAGE \  --command=COMMAND \  --args=ARG

Replace the following:

• SERVICE_NAME: the name of your Cloud Runservice.
• APPLICATION_PATH: the location of your applicationon the local file system.
• BASE_IMAGE: theruntime base imageyou want to use for your application. For example,us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/nodejs24.
• COMMAND: the command that the container starts up with.
• ARG: an argument you send to thecontainer command. If you use multiple arguments, specify each on its ownline.

YAML

You can store your service specification in a YAML file and then deploy itusing the gcloud CLI or the Google Cloud consoleservice.yamleditor.

1. Create a storage bucket to hold your application:

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

   Replace the following:

   • BUCKET_NAME: the name you want to give your bucket, subject tonaming requirements. For example,my-bucket.
   • BUCKET_LOCATION: thelocation of your bucket. For example,US.

2. Create an archive with your application source using either zip or tar,for example:

   tar -cvzfARCHIVE_NAMEAPPLICATION_PATH

   Replace the following:

   • ARCHIVE_NAME: the name of the archive tocreate. For example,app.tar.gz.
   • APPLICATION_PATH: the location of yourapplication on the local file system. For example,~/my-application.To archive the current working directory, set this value to*.

3. Upload your application archive to Cloud Storage:

   gcloud storage cpARCHIVE_NAME gs://BUCKET_NAME

   Replace the following:

   • ARCHIVE_NAME: the local path to the archive youcreated previously. For example,app.tar.gz.
   • BUCKET_NAME: the name of the bucket you createdpreviously. For example,my-bucket.

4. Create a newservice.yaml file with the following content:

   apiVersion: serving.knative.dev/v2kind: Servicemetadata: name:SERVICE_NAMEspec: 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

   Replace the following:

   • SERVICE_NAME: the name of your Cloud Runservice. Service names must be 49 characters or less and must be uniqueper region and project.
   • BUCKET_NAME: the name of the bucket you createdpreviously. For example,my-bucket.
   • ARCHIVE_NAME: the local path to the archive youcreated previously. For example,app.tar.gz.
   • BASE_IMAGE: the runtime base image you want touse for your application. For example,us-central1-docker.pkg.dev/serverless-runtimes/google-24-full/runtimes/nodejs24.
   • COMMAND: the command that the container isto start up with.
   • ARG1: the argument you are sending to thecontainer command. If you use multiple arguments, specify each on itsown line, for example, as shown,ARG-N.

5. Deploy the new service:

   gcloud run services replace service.yaml

REST API

REST API:

curl -H "Content-Type: application/json" \-H "Authorization: BearerACCESS_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

Node.js

Create a Node.js service:

1. Create a new directory namedhelloworld and change directoryinto it:

   mkdir helloworldcd helloworld

2. Create apackage.json file with the following contents:

   {"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. In the same directory, create aindex.js file, and copy the followinglines into it:

   importexpressfrom'express';constapp=express();app.get('/',(req,res)=>{constname=process.env.NAME||'World';res.send(`Hello${name}!`);});constport=parseInt(process.env.PORT)||8080;app.listen(port,()=>{console.log(`helloworld: listening on port${port}`);});

   This code creates a basic web server that listens on the port defined by thePORT environment variable.

4. In yourhelloworld directory, run the following command to install the service dependencies locally:

   npm install

5. In yourhelloworld directory, deploy the service using the--no-build flag, which tells thedeploy command to skip theCloud Build step:

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

   Replace the following:

   • REGION: the region where your service is deployed.

Python

Create a Python service:

1. Create a new directory namedhelloworld and change directoryinto it:

   mkdirhelloworldcdhelloworld

2. Create a file namedmain.py and paste the following code into it:

   importosfromflaskimportFlaskapp=Flask(__name__)@app.route("/")defhello_world():"""Example Hello World route."""name=os.environ.get("NAME","World")returnf"Hello{name}!"if__name__=="__main__":app.run(debug=True,host="0.0.0.0",port=int(os.environ.get("PORT",8080)))

   This code responds to requests with our "Hello World" greeting. HTTPhandling is done by a Gunicorn web server in the container. Whendirectly invoked for local use, this code creates a basic web server thatlistens on the port defined by thePORT environment variable.

3. Create a file namedrequirements.txt and paste the following code into it:

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

   This code adds packages needed by the sample.

4. Vendor the dependencies:

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

5. Deploy the service using the gcloud CLI. The--no-build flag tells thedeploy command to bypass the Cloud Build step:

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

ReplaceREGION with the region where your service is deployed.