Quickstart: Deploy a Cloud Run function using the gcloud CLI

This page shows you how to deploy an HTTP Cloud Run function using the gcloud CLI.

Before you begin

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

Install the Google Cloud CLI.

Note:If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update .

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity .

To initialize the gcloud CLI, run the following command:

gcloud  
init

Create or select a Google Cloud project .

Roles required to select or create a project

Select a project : Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project : To create a project, you need the Project Creator role ( roles/resourcemanager.projectCreator ), which contains the resourcemanager.projects.create permission. Learn how to grant roles .

Create a Google Cloud project:
```
gcloud projects create PROJECT_ID 
```
Replace PROJECT_ID with a name for the Google Cloud project you are creating.
Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID 
```
Replace PROJECT_ID with your Google Cloud project name.

If you're using an existing project for this guide, verify that you have the permissions required to complete this guide . If you created a new project, then you already have the required permissions.

Verify that billing is enabled for your Google Cloud project .

Enable the Artifact Registry, Cloud Build, Cloud Run Admin API, and Cloud Logging APIs:

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 .

gcloud  
services  
 enable 
  
artifactregistry.googleapis.com  
 cloudbuild.googleapis.com  
 run.googleapis.com  
 logging.googleapis.com

Install the Google Cloud CLI.

Note:If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update .

If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity .

To initialize the gcloud CLI, run the following command:

gcloud  
init

Create or select a Google Cloud project .

Roles required to select or create a project

Select a project : Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project : To create a project, you need the Project Creator role ( roles/resourcemanager.projectCreator ), which contains the resourcemanager.projects.create permission. Learn how to grant roles .

Create a Google Cloud project:
```
gcloud projects create PROJECT_ID 
```
Replace PROJECT_ID with a name for the Google Cloud project you are creating.
Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID 
```
Replace PROJECT_ID with your Google Cloud project name.

Verify that billing is enabled for your Google Cloud project .

Enable the Artifact Registry, Cloud Build, Cloud Run Admin API, and Cloud Logging APIs:

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 .

gcloud  
services  
 enable 
  
artifactregistry.googleapis.com  
 cloudbuild.googleapis.com  
 run.googleapis.com  
 logging.googleapis.com

To set the default project for your Cloud Run service:
```
  
gcloud  
config  
 set 
  
project  
 PROJECT_ID 
```
Replace PROJECT_ID with the name of the project you created for this quickstart.
If you are under a domain restriction organization policy restricting unauthenticated invocations for your project, you will need to access your deployed service as described under Testing private services .
Review Cloud Run pricing or estimate costs with the pricing calculator .

Required roles

To get the permissions that you need to complete this quickstart, ask your administrator to grant you the following IAM roles:

Cloud Run Source Developer ( roles/run.sourceDeveloper ) on the project
Service Account User ( roles/iam.serviceAccountUser ) on the service identity
Logs Viewer ( roles/logging.viewer ) on the project

For more information about granting roles, see Manage access to projects, folders, and organizations .

You might also be able to get the required permissions through custom roles or other predefined roles .

Grant the Cloud Build service account access to your project

Cloud Build automatically uses the Compute Engine default service account as the default Cloud Build service account to build your source code and Cloud Run resource, unless you override this behavior.

For Cloud Build to build your sources, grant the Cloud Build service account the Cloud Run Builder ( roles/run.builder ) role on your project:

gcloud  
projects  
add-iam-policy-binding  
 PROJECT_ID 
  
 \ 
  
--member = 
serviceAccount: SERVICE_ACCOUNT_EMAIL_ADDRESS 
  
 \ 
  
--role = 
roles/run.builder

Replace PROJECT_ID with your Google Cloud project ID and SERVICE_ACCOUNT_EMAIL_ADDRESS with the email address of the Cloud Build service account. If you're using the Compute Engine default service account as the Cloud Build service account, then use the following format for the service account email address:

 PROJECT_NUMBER 
-compute@developer.gserviceaccount.com

Replace PROJECT_NUMBER with your Google Cloud project number.

For detailed instructions on how to find your project ID, and project number, see Creating and managing projects .

Granting the Cloud Run builder role takes a couple of minutes to propagate .

Write the sample function

To write an application, follow these steps:

Node.js

Create a new directory named helloworld and change directory into it:
```
 mkdir helloworld
   cd helloworld 
```

Create a package.json file in the helloworld directory to specify Node.js dependencies:

  { 
  
 "name" 
 : 
  
 "nodejs-docs-samples-functions-hello-world-get" 
 , 
  
 "version" 
 : 
  
 "0.0.1" 
 , 
  
 "private" 
 : 
  
 true 
 , 
  
 "license" 
 : 
  
 "Apache-2.0" 
 , 
  
 "author" 
 : 
  
 "Google Inc." 
 , 
  
 "repository" 
 : 
  
 { 
  
 "type" 
 : 
  
 "git" 
 , 
  
 "url" 
 : 
  
 "https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git" 
  
 }, 
  
 "engines" 
 : 
  
 { 
  
 "node" 
 : 
  
 ">=16.0.0" 
  
 }, 
  
 "scripts" 
 : 
  
 { 
  
 "test" 
 : 
  
 "c8 mocha -p -j 2 test/*.test.js --timeout=6000 --exit" 
  
 }, 
  
 "dependencies" 
 : 
  
 { 
  
 "@google-cloud/functions-framework" 
 : 
  
 "^3.1.0" 
  
 }, 
  
 "devDependencies" 
 : 
  
 { 
  
 "c8" 
 : 
  
 "^10.0.0" 
 , 
  
 "gaxios" 
 : 
  
 "^6.0.0" 
 , 
  
 "mocha" 
 : 
  
 "^10.0.0" 
 , 
  
 "wait-port" 
 : 
  
 "^1.0.4" 
  
 } 
 }

Create an index.js file in the helloworld directory with the following Node.js sample:

  const 
  
 functions 
  
 = 
  
 require 
 ( 
 '@google-cloud/functions-framework' 
 ); 
 // Register an HTTP function with the Functions Framework that will be executed 
 // when you make an HTTP request to the deployed function's endpoint. 
 functions 
 . 
 http 
 ( 
 'helloGET' 
 , 
  
 ( 
 req 
 , 
  
 res 
 ) 
  
 = 
>  
 { 
  
 res 
 . 
 send 
 ( 
 'Hello World!' 
 ); 
 });

Python

Create a new directory named helloworld and change directory into it:
```
 mkdir helloworld
   cd helloworld 
```

Create a requirements.txt file in the helloworld directory, to specify Python dependencies:

  functions 
 - 
 framework 
 == 
 3.9.2 
 flask 
 == 
 3.0.3 
 google 
 - 
 cloud 
 - 
 error 
 - 
 reporting 
 == 
 1.11.1 
 MarkupSafe 
 == 
 2.1.3

This adds packages needed by the sample.

Create a main.py file in the helloworld directory with the following Python sample:

  import 
  
 functions_framework 
 @functions_framework 
 . 
 http 
 def 
  
 hello_get 
 ( 
 request 
 ): 
  
 """HTTP Cloud Function. 
 Args: 
 request (flask.Request): The request object. 
 <https://flask.palletsprojects.com/en/1.1.x/api/#incoming-request-data> 
 Returns: 
 The response text, or any set of values that can be turned into a 
 Response object using `make_response` 
 <https://flask.palletsprojects.com/en/1.1.x/api/#flask.make_response>. 
 Note: 
 For more information on how Flask integrates with Cloud 
 Functions, see the `Writing HTTP functions` page. 
 <https://cloud.google.com/functions/docs/writing/http#http_frameworks> 
 """ 
 return 
 "Hello World!"

Go

Create a new directory named helloworld and change directory into it:
```
 mkdir helloworld
   cd helloworld 
```

Create a go.mod file to declare the go module :

  module 
  
 github 
 . 
 com 
 / 
 GoogleCloudPlatform 
 / 
 golang 
 - 
 samples 
 / 
 functions 
 / 
 functionsv2 
 / 
 helloworld 
 go 
  
 1.24.0 
 require 
  
 github 
 . 
 com 
 / 
 GoogleCloudPlatform 
 / 
 functions 
 - 
 framework 
 - 
 go 
  
 v1 
 .8.1 
 require 
  
 ( 
  
 github 
 . 
 com 
 / 
 cloudevents 
 / 
 sdk 
 - 
 go 
 / 
 v2 
  
 v2 
 .15.2 
  
 // indirect 
  
 github 
 . 
 com 
 / 
 google 
 / 
 go 
 - 
 cmp 
  
 v0 
 .6.0 
  
 // indirect 
  
 github 
 . 
 com 
 / 
 google 
 / 
 uuid 
  
 v1 
 .6.0 
  
 // indirect 
  
 github 
 . 
 com 
 / 
 json 
 - 
 iterator 
 / 
 go 
  
 v1 
 .1.12 
  
 // indirect 
  
 github 
 . 
 com 
 / 
 modern 
 - 
 go 
 / 
 concurrent 
  
 v0 
 .0.0 
 - 
 20180306012644 
 - 
 bacd9c7ef1dd 
  
 // indirect 
  
 github 
 . 
 com 
 / 
 modern 
 - 
 go 
 / 
 reflect2 
  
 v1 
 .0.2 
  
 // indirect 
  
 github 
 . 
 com 
 / 
 stretchr 
 / 
 testify 
  
 v1 
 .10.0 
  
 // indirect 
  
 go 
 . 
 uber 
 . 
 org 
 / 
 multierr 
  
 v1 
 .11.0 
  
 // indirect 
  
 go 
 . 
 uber 
 . 
 org 
 / 
 zap 
  
 v1 
 .27.0 
  
 // indirect 
  
 golang 
 . 
 org 
 / 
 x 
 / 
 time 
  
 v0 
 .9.0 
  
 // indirect 
 )

Create an hello_http.go file in the helloworld directory with the following Go code sample:

  // Package helloworld provides a set of Cloud Functions samples. 
 package 
  
 helloworld 
 import 
  
 ( 
  
 "fmt" 
  
 "net/http" 
  
 "github.com/GoogleCloudPlatform/functions-framework-go/functions" 
 ) 
 func 
  
 init 
 () 
  
 { 
  
 functions 
 . 
 HTTP 
 ( 
 "HelloGet" 
 , 
  
 helloGet 
 ) 
 } 
 // helloGet is an HTTP Cloud Function. 
 func 
  
 helloGet 
 ( 
 w 
  
 http 
 . 
 ResponseWriter 
 , 
  
 r 
  
 * 
 http 
 . 
 Request 
 ) 
  
 { 
  
 fmt 
 . 
 Fprint 
 ( 
 w 
 , 
  
 "Hello, World!" 
 ) 
 }

Java

Create a new directory named helloworld and change directory into it:
```
 mkdir helloworld
   cd helloworld 
```

Create the following project structure to contain the source directory and source file:

 mkdir -p ~/helloworld/src/main/java/functions
touch ~/helloworld/src/main/java/functions/HelloWorld.java

Update the HelloWorld.java file with the following Java code sample:

  package 
  
 functions 
 ; 
 import 
  
 com.google.cloud.functions.HttpFunction 
 ; 
 import 
  
 com.google.cloud.functions.HttpRequest 
 ; 
 import 
  
 com.google.cloud.functions.HttpResponse 
 ; 
 import 
  
 java.io.BufferedWriter 
 ; 
 import 
  
 java.io.IOException 
 ; 
 public 
  
 class 
 HelloWorld 
  
 implements 
  
 HttpFunction 
  
 { 
  
 // Simple function to return "Hello World" 
  
 @Override 
  
 public 
  
 void 
  
 service 
 ( 
 HttpRequest 
  
 request 
 , 
  
 HttpResponse 
  
 response 
 ) 
  
 throws 
  
 IOException 
  
 { 
  
 BufferedWriter 
  
 writer 
  
 = 
  
 response 
 . 
 getWriter 
 (); 
  
 writer 
 . 
 write 
 ( 
 "Hello World!" 
 ); 
  
 } 
 }

Create a pom.xml file in the helloworld directory, and add the following Java dependencies:

 < ? 
 xml 
  
 version 
 = 
 "1.0" 
  
 encoding 
 = 
 "UTF-8" 
 ? 
>

< !-- 
  
 Copyright 
  
 2020 
  
 Google 
  
 LLC 
  
 Licensed 
  
 under 
  
 the 
  
 Apache 
  
 License 
 , 
  
 Version 
  
 2.0 
  
 ( 
 the 
  
 "License" 
 ); 
  
 you 
  
 may 
  
 not 
  
 use 
  
 this 
  
 file 
  
 except 
  
 in 
  
 compliance 
  
 with 
  
 the 
  
 License 
 . 
  
 You 
  
 may 
  
 obtain 
  
 a 
  
 copy 
  
 of 
  
 the 
  
 License 
  
 at 
  
 http 
 : 
 //www.apache.org/licenses/LICENSE-2.0 
  
 Unless 
  
 required 
  
 by 
  
 applicable 
  
 law 
  
 or 
  
 agreed 
  
 to 
  
 in 
  
 writing 
 , 
  
 software 
  
 distributed 
  
 under 
  
 the 
  
 License 
  
 is 
  
 distributed 
  
 on 
  
 an 
  
 "AS IS" 
  
 BASIS 
 , 
  
 WITHOUT 
  
 WARRANTIES 
  
 OR 
  
 CONDITIONS 
  
 OF 
  
 ANY 
  
 KIND 
 , 
  
 either 
  
 express 
  
 or 
  
 implied 
 . 
  
 See 
  
 the 
  
 License 
  
 for 
  
 the 
  
 specific 
  
 language 
  
 governing 
  
 permissions 
  
 and 
  
 limitations 
  
 under 
  
 the 
  
 License 
 . 
 -- 
>

< project 
  
 xmlns 
 = 
 "http://maven.apache.org/POM/4.0.0" 
  
 xmlns 
 : 
 xsi 
 = 
 "http://www.w3.org/2001/XMLSchema-instance" 
  
 xsi 
 : 
 schemaLocation 
 = 
 "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" 
>  
< modelVersion>4 
 .0.0 
< / 
 modelVersion 
>  
< groupId>com 
 . 
 example 
 . 
 functions 
< / 
 groupId 
>  
< artifactId>functions 
 - 
 hello 
 - 
 world 
< / 
 artifactId 
>  
< version>1 
 .0.0 
 - 
 SNAPSHOT 
< / 
 version 
>  
< parent 
>  
< groupId>com 
 . 
 google 
 . 
 cloud 
 . 
 samples 
< / 
 groupId 
>  
< artifactId>shared 
 - 
 configuration 
< / 
 artifactId 
>  
< version>1 
 .2.0 
< / 
 version 
>  
< / 
 parent 
>  
< dependencyManagement 
>  
< dependencies 
>  
< dependency 
>  
< artifactId>libraries 
 - 
 bom 
< / 
 artifactId 
>  
< groupId>com 
 . 
 google 
 . 
 cloud 
< / 
 groupId 
>  
< scope>import 
< / 
 scope 
>  
< type>pom 
< / 
 type 
>  
< version>26 
 .32.0 
< / 
 version 
>  
< / 
 dependency 
>  
< / 
 dependencies 
>  
< / 
 dependencyManagement 
>  
< properties 
>  
< maven 
 . 
 compiler 
 . 
 target>11 
< / 
 maven 
 . 
 compiler 
 . 
 target 
>  
< maven 
 . 
 compiler 
 . 
 source>11 
< / 
 maven 
 . 
 compiler 
 . 
 source 
>  
< / 
 properties 
>  
< dependencies 
>  
< !-- 
  
 Required 
  
 for 
  
 Function 
  
 primitives 
  
 -- 
>  
< dependency 
>  
< groupId>com 
 . 
 google 
 . 
 cloud 
 . 
 functions 
< / 
 groupId 
>  
< artifactId>functions 
 - 
 framework 
 - 
 api 
< / 
 artifactId 
>  
< version>1 
 .1.0 
< / 
 version 
>  
< scope>provided 
< / 
 scope 
>  
< / 
 dependency 
>  
< !-- 
  
 The 
  
 following 
  
 dependencies 
  
 are 
  
 only 
  
 required 
  
 for 
  
 testing 
  
 -- 
>  
< dependency 
>  
< groupId>com 
 . 
 google 
 . 
 truth 
< / 
 groupId 
>  
< artifactId>truth 
< / 
 artifactId 
>  
< version>1 
 .4.0 
< / 
 version 
>  
< scope>test 
< / 
 scope 
>  
< / 
 dependency 
>  
< dependency 
>  
< groupId>com 
 . 
 google 
 . 
 guava 
< / 
 groupId 
>  
< artifactId>guava 
 - 
 testlib 
< / 
 artifactId 
>  
< scope>test 
< / 
 scope 
>  
< / 
 dependency 
>  
< dependency 
>  
< groupId>org 
 . 
 mockito 
< / 
 groupId 
>  
< artifactId>mockito 
 - 
 core 
< / 
 artifactId 
>  
< version>5 
 .10.0 
< / 
 version 
>  
< scope>test 
< / 
 scope 
>  
< / 
 dependency 
>  
< / 
 dependencies 
>  
< build 
>  
< plugins 
>  
< plugin 
>  
< !-- 
  
 Google 
  
 Cloud 
  
 Functions 
  
 Framework 
  
 Maven 
  
 plugin 
  
 This 
  
 plugin 
  
 allows 
  
 you 
  
 to 
  
 run 
  
 Cloud 
  
 Functions 
  
 Java 
  
 code 
  
 locally 
 . 
  
 Use 
  
 the 
  
 following 
  
 terminal 
  
 command 
  
 to 
  
 run 
  
 a 
  
 given 
  
 function 
  
 locally 
 : 
  
 mvn 
  
 function 
 : 
 run 
  
 - 
 Drun 
 . 
 functionTarget 
 = 
 your 
 . 
 package 
 . 
 yourFunction 
  
 -- 
>  
< groupId>com 
 . 
 google 
 . 
 cloud 
 . 
 functions 
< / 
 groupId 
>  
< artifactId>function 
 - 
 maven 
 - 
 plugin 
< / 
 artifactId 
>  
< version>0 
 .11.0 
< / 
 version 
>  
< configuration 
>  
< functionTarget>functions 
 . 
 HelloWorld 
< / 
 functionTarget 
>  
< / 
 configuration 
>  
< / 
 plugin 
>  
< plugin 
>  
< groupId>org 
 . 
 apache 
 . 
 maven 
 . 
 plugins 
< / 
 groupId 
>  
< artifactId>maven 
 - 
 surefire 
 - 
 plugin 
< / 
 artifactId 
>  
< !-- 
  
 version 
  
 3.0.0 
 - 
 M4 
  
 does 
  
 not 
  
 load 
  
 JUnit5 
  
 correctly 
  
 -- 
>  
< !-- 
  
 see 
  
 https 
 : 
 //issues.apache.org/jira/browse/SUREFIRE-1750 -- 
>  
< version>3 
 .2.5 
< / 
 version 
>  
< configuration 
>  
< includes 
>  
< include 
> **/* 
 Test 
 . 
 java 
< / 
 include 
>  
< / 
 includes 
>  
< skipTests>$ 
 { 
 skipTests 
 } 
< / 
 skipTests 
>  
< reportNameSuffix>sponge_log 
< / 
 reportNameSuffix 
>  
< trimStackTrace>false 
< / 
 trimStackTrace 
>  
< / 
 configuration 
>  
< / 
 plugin 
>  
< / 
 plugins 
>  
< / 
 build 
>
< / 
 project 
>

Ruby

Create a new directory named helloworld and change directory into it:
```
 mkdir helloworld
   cd helloworld 
```

Create a file named app.rb and paste the following code into it:

  require 
  
 "functions_framework" 
 FunctionsFramework 
 . 
 http 
  
 "hello_get" 
  
 do 
  
 | 
 _request 
 | 
  
 # The request parameter is a Rack::Request object. 
  
 # See https://www.rubydoc.info/gems/rack/Rack/Request 
  
 # Return the response body as a string. 
  
 # You can also return a Rack::Response object, a Rack response array, or 
  
 # a hash which will be JSON-encoded into a response. 
  
 "Hello World!" 
 end

Create a file named Gemfile and copy the following into it:

  source 
  
 "https://rubygems.org" 
 gem 
  
 "base64" 
 , 
  
 "~> 0.2" 
 gem 
  
 "functions_framework" 
 , 
  
 "~> 1.4"

If you don't have Bundler 2.0 or greater installed, install Bundler .
Generate a Gemfile.lock file by running:
```
 bundle install 
```

PHP

Create a new directory named helloworld and change directory into it:
```
 mkdir helloworld
   cd helloworld 
```

Create a file named index.php and paste the following code into it:

  use Psr\Http\Message\ServerRequestInterface; 
 function helloGet(ServerRequestInterface $request): string 
 { 
 return 'Hello, World!' . PHP_EOL; 
 }

If you aren't using Cloud Shell, create a composer.json file and paste the following code into it:

  { 
 "require": { 
 "google/cloud-functions-framework": "^1.0" 
 }, 
 "scripts": { 
 "start": [ 
 "Composer\\Config::disableProcessTimeout", 
 "FUNCTION_TARGET=helloGet php -S localhost:${PORT:-8080} vendor/google/cloud-functions-framework/router.php" 
 ] 
 } 
 }

.NET

Install .NET SDK .
From the console, create a new empty web project using the dotnet command.
```
 dotnet new web -o helloworld-csharp 
```
Change directory to helloworld-csharp :

Replace the sample code in the project file helloworld-csharp.csproj with the following:

 <Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Google.Cloud.Functions.Hosting" Version="3.0.1" />
  </ItemGroup>
</Project>

Replace the sample code in Program.cs file with the following:

 using Google.Cloud.Functions.Framework;
using Microsoft.AspNetCore.Http;
using System.Threading.Tasks;

namespace HelloWorld;

public class Function : IHttpFunction
{
    public async Task HandleAsync(HttpContext context)
    {
        await context.Response.WriteAsync("Hello World!", context.RequestAborted);
    }
}

Deploy the function

To deploy your Cloud Run function, follow these steps:

Deploy the function by running the following command in the directory that contains the sample code: