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 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. Install the Google Cloud CLI.

  3. Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

  4. Per inizializzare gcloud CLI, esegui questo comando: 

    gcloud init

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

  6. Se utilizzi un progetto esistente per questa guida, verifica di disporre delle autorizzazioni necessarie per completare la guida. Se hai creato un nuovo progetto, disponi già delle autorizzazioni necessarie.

  7. Verify that billing is enabled for your Google Cloud project.

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

  9. Install the Google Cloud CLI.

  10. Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.

  11. Per inizializzare gcloud CLI, esegui questo comando: 

    gcloud init

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

  13. Se utilizzi un progetto esistente per questa guida, verifica di disporre delle autorizzazioni necessarie per completare la guida. Se hai creato un nuovo progetto, disponi già delle autorizzazioni necessarie.

  14. Verify that billing is enabled for your Google Cloud project.

  15. 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
  16. Per impostare il progetto predefinito per il tuo servizio Cloud Run: 
     gcloud config set project PROJECT_ID
     Sostituisci PROJECT_ID con il nome del progetto che hai creato per questa guida rapida.

  17. Se il tuo progetto è soggetto a un criterio dell'organizzazione con restrizioni di dominio che limitano le chiamate non autenticate, devi accedere al servizio di cui è stato eseguito il deployment come descritto in Test dei servizi privati.

  18. Consulta i prezzi di Cloud Run o stima i costi con il Calcolatore prezzi.

    19. Ruoli obbligatori

    Per ottenere le autorizzazioni necessarie per completare questa guida rapida, chiedi all'amministratore di concederti i seguenti ruoli IAM:

    Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

    Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

    Concedi al account di servizio Cloud Build l'accesso al tuo progetto

    Cloud Build utilizza automaticamente l'account di servizio predefinito di Compute Engine come account di servizio Cloud Build predefinito per creare il codice sorgente e la risorsa Cloud Run, a meno che tu non esegua l'override di questo comportamento.

    Affinché Cloud Build possa creare le tue origini, concedi all'account di servizio Cloud Build il ruolo Cloud Run Builder (roles/run.builder) nel tuo progetto:

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

    Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloude SERVICE_ACCOUNT_EMAIL_ADDRESS con l'indirizzo email del account di servizio Cloud Build. Se utilizzi il account di servizio predefinito di Compute Engine come account di servizio Cloud Build, utilizza il seguente formato per l'indirizzo email del account di servizio:

    PROJECT_NUMBER-compute@developer.gserviceaccount.com

    Sostituisci PROJECT_NUMBER con il numero del tuo progetto Google Cloud.

    Per istruzioni dettagliate su come trovare l'ID progetto e il numero di progetto, vedi Creazione e gestione dei progetti.

    La concessione del ruolo di builder Cloud Run richiede un paio di minuti per la propagazione.

    Scrivi la funzione di esempio

    Per scrivere una richiesta:

    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 di 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.9.2
flask==3.0.3
google-cloud-error-reporting==1.11.1
MarkupSafe==2.1.3

      In questo modo vengono aggiunti i pacchetti necessari per l'esempio.

    3. Crea un file main.py nella directory helloworld con il seguente esempio di 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.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
)

    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 "base64", "~> 0.2"
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. Passa alla directory helloworld-csharp:

    4. Sostituisci il codice campione nel file di progetto helloworld-csharp.csproj con il seguente:

      <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

    Per eseguire il deployment della funzione Cloud Run:

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

      Node.js 

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

      Sostituisci REGION con la regione del servizio in cui vuoi eseguire il deployment della funzione. Google CloudAd 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 go125 \
       --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 che contiene 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 il servizio è in esecuzione. Apri l'URL nel browser per visualizzare l'output della tua funzione.

    Esegui la pulizia

    Per evitare costi aggiuntivi al tuo account Google Cloud , elimina tutte le risorse che hai eseguito il deployment con questa guida rapida.

    Eliminare il repository

    Cloud Run non ti addebita costi quando il servizio di cui hai eseguito il deployment non è in uso. Tuttavia, potresti comunque pagare l'archiviazione dell'immagine container in Artifact Registry. Per eliminare i repository Artifact Registry, segui i passaggi descritti in Eliminare i repository nella documentazione di Artifact Registry.

    Eliminare il servizio

    I servizi Cloud Run non comportano costi finché non ricevono richieste. Per eliminare il servizio Cloud Run, segui uno di questi passaggi:

    Console

    Per eliminare un servizio:

    1. Nella console Google Cloud , vai alla pagina Servizi di Cloud Run:

      Vai a Cloud Run

    2. Individua il servizio che vuoi eliminare nell'elenco dei servizi e fai clic sulla relativa casella di controllo per selezionarlo.

    3. Fai clic su Elimina. Vengono eliminate tutte le revisioni del servizio.

    gcloud

    Per eliminare un servizio, esegui questo comando:

    gcloud run services delete SERVICE --region REGION

    Sostituisci quanto segue:

    • SERVICE: il nome del tuo servizio.
    • REGION: Google Cloud regione del servizio.

    Eliminare il progetto di test

    L'eliminazione del progetto Google Cloud interrompe la fatturazione per tutte le risorse al suo interno. Per rilasciare tutte le Google Cloud risorse nel tuo progetto:

      Delete a Google Cloud project:

      gcloud projects delete PROJECT_ID

    Passaggi successivi