Guida rapida: esegui il deployment di una funzione Cloud Run utilizzando gcloud CLI

Questa pagina mostra come eseguire il deployment di una funzione Cloud Run HTTP utilizzando la gcloud CLI.

Prima di iniziare

  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. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

  7. To initialize the gcloud CLI, run the following command: 

    gcloud init

  8. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

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

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

    Enable the APIs

  11. Install the Google Cloud CLI.

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

  13. To initialize the gcloud CLI, run the following command: 

    gcloud init
  14. Per impostare il progetto predefinito per il servizio Cloud Run: 
     gcloud config set project PROJECT_ID
     Sostituisci PROJECT_ID con il nome del progetto che hai creato per questa guida rapida.

  15. Se il tuo progetto è soggetto a un criterio dell'organizzazione che limita le invocazioni non autenticate, dovrai accedere al servizio di cui è stato eseguito il deployment come descritto in Testare i servizi privati.

  16. Concedi all'account di servizio Cloud Build il seguente ruolo IAM.

    Fai clic per visualizzare i ruoli richiesti per l'account di servizio Cloud Build

    Cloud Build utilizza automaticamente l'account di servizio predefinito di Compute Engine come account di servizio Cloud Build predefinito per compilare il codice sorgente e la risorsa Cloud Run, a meno che tu non sostituisca questo comportamento. Affinché Cloud Build possa compilare le origini, chiedi all'amministratore di concedere il ruolo Cloud Run Builder (roles/run.builder) all'account di servizio predefinito di Compute Engine nel tuo progetto:

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

    Sostituisci PROJECT_NUMBER con il numero Google Cloud del progetto e PROJECT_ID con l'ID Google Cloud del progetto. Per istruzioni dettagliate su come trovare l'ID progetto e il numero del progetto, consulta Creazione e gestione dei progetti.

    La propagazione del ruolo del compilatore Cloud Run all'account di servizio predefinito di Compute Engine richiede un paio di minuti.

Scrivi la funzione di esempio

Per scrivere un'applicazione:

Node.js

  1. Crea una nuova directory denominata helloworld e cambia directory:

       mkdir helloworld
   cd helloworld

  2. Crea un file package.json nella directory helloworld per specificare le dipendenze Node.js:

    {
  "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. Crea un file index.js nella directory helloworld con il seguente esempio Node.js:

    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. Crea una nuova directory denominata helloworld e cambia directory:

       mkdir helloworld
   cd helloworld

  2. Crea un file requirements.txt nella directory helloworld per specificare le dipendenze Python:

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

    Vengono aggiunti i pacchetti necessari per il Sample.

  3. Crea un file main.py nella directory helloworld con il seguente esempio Python:

    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!"

Vai

  1. Crea una nuova directory denominata helloworld e cambia directory:

       mkdir helloworld
   cd helloworld

  2. Crea un file go.mod per dichiarare il modulo Go:

    module github.com/GoogleCloudPlatform/golang-samples/functions/functionsv2/helloworld

go 1.23.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
)

  3. Crea un file hello_http.go nella directory helloworld con il seguente esempio di codice Go:

    
// 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. Crea una nuova directory denominata helloworld e cambia directory:

       mkdir helloworld
   cd helloworld

  2. Crea la seguente struttura del progetto per contenere la directory di origine e il file di origine:

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

  3. Aggiorna il file HelloWorld.java con il seguente esempio di codice Java:

    
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. Crea un file pom.xml nella directory helloworld e aggiungi le seguenti dipendenze Java:

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

  1. Crea una nuova directory denominata helloworld e cambia directory:

       mkdir helloworld
   cd helloworld

  2. Crea un file denominato app.rb e incolla il seguente codice:

    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

  3. Crea un file denominato Gemfile e copia al suo interno quanto riportato di seguito:

    source "https://rubygems.org"

gem "functions_framework", "~> 1.4"

  4. Se non hai installato Bundler 2.0 o versioni successive, installa Bundler.

  5. Genera un file Gemfile.lock eseguendo:

    bundle install

PHP

  1. Crea una nuova directory denominata helloworld e cambia directory:

       mkdir helloworld
   cd helloworld

  2. Crea un file denominato index.php e incolla il seguente codice:

    
use Psr\Http\Message\ServerRequestInterface;

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

  3. Se non utilizzi Cloud Shell, crea un file composer.json e incolla il seguente codice:

    {
    "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

  1. Installa l'SDK.NET.

  2. Dalla console, crea un nuovo progetto web vuoto utilizzando il comando dotnet.

    dotnet new web -o helloworld-csharp

  3. Cambia la directory in helloworld-csharp:

  4. Sostituisci il codice campione nel file del progetto helloworld-csharp.csproj con quanto segue:

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

  5. Sostituisci il codice campione nel file Program.cs con il seguente:

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

esegui il deployment della funzione

Importante:questa guida rapida presuppone che tu disponga dei ruoli di proprietario o editor nel progetto che stai utilizzando per la guida rapida. In caso contrario, consulta il ruolo Sviluppatore di origini Cloud Run per le autorizzazioni necessarie per eseguire il deployment di una risorsa Cloud Run dall'origine.

Per eseguire il deployment della funzione Cloud Run:

  1. Esegui il deployment della funzione eseguendo il seguente comando nella directory che contiene il codice campione:

    Node.js 

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

    Sostituisci REGION con la regione Google Clouddel servizio in cui vuoi eseguire il deployment della funzione. Ad esempio: europe-west1.

    Python 

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

    Sostituisci REGION con la regione Google Clouddel servizio in cui vuoi eseguire il deployment della funzione. Ad esempio: europe-west1.

    Vai 

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

    Sostituisci REGION con la regione Google Clouddel servizio in cui vuoi eseguire il deployment della funzione. Ad esempio: europe-west1.

    Java

    Esegui questo comando nella directory contenente il file pom.xml:

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

    Sostituisci REGION con la regione Google Clouddel servizio in cui vuoi eseguire il deployment della funzione. Ad esempio: europe-west1.

    Ruby 

    gcloud run deploy ruby-http-function \
       --source . \
       --function hello_get \
       --base-image ruby34 \
       --region REGION \
       --allow-unauthenticated

    Sostituisci REGION con la regione Google Clouddel servizio in cui vuoi eseguire il deployment della funzione. Ad esempio: europe-west1.

    PHP 

    gcloud run deploy php-http-function \
       --source . \
       --function helloGet \
       --base-image php84 \
       --region REGION \
       --allow-unauthenticated

    Sostituisci REGION con la regione Google Clouddel servizio in cui vuoi eseguire il deployment della funzione. Ad esempio: europe-west1.

    .NET 

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

    Sostituisci REGION con la regione Google Clouddel servizio in cui vuoi eseguire il deployment della funzione. Ad esempio: europe-west1.

  2. Al termine del deployment, Google Cloud CLI mostra un URL in cui è in esecuzione il servizio. Apri l'URL nel browser per visualizzare l'output della funzione.

Esegui la pulizia

Sebbene non siano previsti addebiti per Cloud Run quando il servizio non è in uso, ti potrebbero comunque essere addebitati i costi di archiviazione dell'immagine container in Artifact Registry. Per evitare addebiti, puoi eliminare l'immagine del contenitore o il Google Cloud progetto. L'eliminazione del progetto Google Cloud interrompe la fatturazione per tutte le risorse utilizzate al suo interno.

  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.

Passaggi successivi