Quickstart: Deploy a function to Cloud Run using the gcloud CLI

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

Before you begin

  1. 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.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

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

    Enable the APIs

  5. Install the Google Cloud CLI.
  6. To initialize the gcloud CLI, run the following command:

    gcloud init
  7. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  8. Make sure that billing is enabled for your Google Cloud project.

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

    Enable the APIs

  10. Install the Google Cloud CLI.
  11. To initialize the gcloud CLI, run the following command:

    gcloud init
  12. 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.
  13. 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.

  14. For Cloud Build to be able to build your sources, grant the Cloud Build Service Account role to the Compute Engine default service account by running the following:

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

    Replace PROJECT_NUMBER with your Google Cloud project number, and PROJECT_ID with your Google Cloud project ID. For detailed instructions on how to find your project ID, and project number, see Creating and managing projects.

    Granting the Cloud Build Service Account role to the Compute Engine default service account takes a couple of minutes to propagate.

Write the sample function

To write an application, follow these steps:

Node.js

  1. Create a new directory named helloworld and change directory into it:

       mkdir helloworld
       cd helloworld
    

  2. 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"
      }
    }
    
  3. 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

  1. Create a new directory named helloworld and change directory into it:

       mkdir helloworld
       cd helloworld
    

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

    functions-framework==3.5.0
    flask==3.0.3
    google-cloud-error-reporting==1.9.1
    MarkupSafe==2.1.3
    

    This adds packages needed by the sample.

  3. 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

  1. Create a new directory named helloworld and change directory into it:

       mkdir helloworld
       cd helloworld
    

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

    module github.com/GoogleCloudPlatform/golang-samples/functions/helloworld
    
    go 1.21
    
    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
    	go.uber.org/multierr v1.11.0 // indirect
    	go.uber.org/zap v1.27.0 // indirect
    	golang.org/x/time v0.5.0 // indirect
    )
    

    You can create the go.mod file directly in the format as shown, or you can initialize it from the project directory with:

       go mod init github.com/GoogleCloudPlatform/golang-samples/functions/functionsv2/helloworld/go.mod
    
  3. 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

  1. Create a new directory named helloworld and change directory into it:

       mkdir helloworld
       cd helloworld
    

  2. 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
    
  3. 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!");
      }
    }
  4. 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>
    

.NET

  1. Install .NET SDK 6.0. This quickstart only works for .NET version 6.

  2. From the console, create a new empty web project using the dotnet command.

    dotnet new web -o helloworld-csharp
    
  3. Change directory to helloworld-csharp:

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

    <Project Sdk="Microsoft.NET.Sdk">
      <PropertyGroup>
        <OutputType>Exe</OutputType>
        <TargetFramework>net6.0</TargetFramework>
      </PropertyGroup>
    
      <ItemGroup>
        <PackageReference Include="Google.Cloud.Functions.Hosting" Version="2.2.1" />
      </ItemGroup>
    </Project>
  5. 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

Important: This quickstart assumes that you have owner or editor roles in the project you are using for the quickstart. Otherwise, refer to the Cloud Run Source Developer role for the required permissions for deploying a Cloud Run resource from source.

To deploy your Cloud Run function, follow these steps:

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

    Node.js

    gcloud beta run deploy nodejs-http-function \
          --source . \
          --function helloGET \
          --base-image nodejs20 \
          --region REGION \
          --allow-unauthenticated
    

    Replace REGION with the Google Cloud region of the service where you want to deploy your function. For example, us-central1.

    Python

    gcloud beta run deploy python-http-function \
          --source . \
          --function hello_get \
          --base-image python312 \
          --region REGION \
          --allow-unauthenticated
    

    Replace REGION with the Google Cloud region of the service where you want to deploy your function. For example, us-central1.

    Go

    gcloud beta run deploy go-http-function \
           --source . \
           --function HelloGet \
           --base-image go122 \
           --region REGION \
           --allow-unauthenticated
    

    Replace REGION with the Google Cloud region of the service where you want to deploy your function. For example, us-central1.

    Java

    Run the following command in the directory that contains the pom.xml file:

    gcloud beta run deploy java-http-function \
           --source . \
           --function functions.HelloWorld \
           --base-image java21 \
           --region REGION \
           --allow-unauthenticated
    

    Replace REGION with the Google Cloud region of the service where you want to deploy your function. For example, us-central1.

    .NET

    gcloud beta run deploy csharp-http-function \
          --source . \
          --function HelloWorld.Function \
          --base-image dotnet6 \
          --region REGION \
          --allow-unauthenticated
    

    Replace REGION with the Google Cloud region of the service where you want to deploy your function. For example, us-central1.

  2. When the deployment is complete, the Google Cloud CLI displays a URL where the service is running. Open the URL in your browser to see the output of your function.

To learn how to add Eventarc triggers to your function, see the Deploy a function guide for instructions.

Clean up

While Cloud Run does not charge when the service is not in use, you might still be charged for storing the container image in Artifact Registry. You can delete your container image or delete your Google Cloud project to avoid incurring charges. Deleting your Google Cloud project stops billing for all the resources used within that project.

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

What's next