Cette page a été traduite par l'API Cloud Translation.

Guide de démarrage rapide : déployer une fonction sur Cloud Run à l'aide de gcloud CLI

Cette page explique comment utiliser Cloud Run pour déployer une fonction HTTP à l'aide de la gcloud CLI.

Avant de commencer

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.

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

Go to project selector

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

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

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

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

gcloud components
      update

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

Go to project selector

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

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

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

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

gcloud components
      update

Pour définir le projet par défaut pour votre service Cloud Run :
```
 gcloud config set project PROJECT_ID
```
Remplacez PROJECT_ID par le nom du projet que vous avez créé pour ce guide de démarrage rapide.
Si vous êtes soumis à une règle d'administration de restriction de domaine limitant les appels non authentifiés pour votre projet, vous devez accéder au service déployé comme décrit dans la section Tester les services privés.
Pour que Cloud Build puisse créer vos sources, attribuez le rôle Compte de service Cloud Build au compte de service Compute Engine par défaut en exécutant la commande suivante :
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:PROJECT_NUMBER-compute@developer.gserviceaccount.com \
    --role=roles/cloudbuild.builds.builder
```
Remplacez PROJECT_NUMBER par votre numéro de projet Google Cloud et PROJECT_ID par votre ID de projet Google Cloud. Pour obtenir des instructions détaillées sur la recherche de votre ID et de votre numéro de projet, consultez la section Créer et gérer des projets.

L'propagation de l'attribution du rôle "Compte de service Cloud Build" au compte de service Compute Engine par défaut prend quelques minutes.
Remarque :
La contrainte liée aux règles d'administration iam.automaticIamGrantsForDefaultServiceAccounts empêche l'attribution automatique du rôle "Éditeur" aux comptes de service par défaut. Si vous avez créé votre organisation après le 3 mai 2024, cette contrainte est appliquée par défaut.

Nous vous recommandons vivement d'appliquer cette contrainte pour désactiver l'attribution automatique de rôles. Si vous désactivez l'attribution automatique de rôles, vous devez choisir les rôles à attribuer aux comptes de service par défaut, puis attribuer ces rôles vous-même.

Si le compte de service par défaut dispose déjà du rôle Éditeur, nous vous recommandons de le remplacer par des rôles moins permissifs. Pour modifier les rôles du compte de service en toute sécurité, utilisez Policy Simulator pour voir l'impact de la modification, puis attribuez et révoquez les rôles appropriés.

Écrire l'exemple de fonction

Pour écrire une application, procédez comme suit:

Node.js

Créez un répertoire nommé helloworld et modifiez les sous-répertoires comme suit :
```
   mkdir helloworld
   cd helloworld
```

Créez un fichier package.json dans le répertoire helloworld pour spécifier les dépendances 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"
  }
}

Créez un fichier index.js dans le répertoire helloworld avec l'exemple Node.js suivant:

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

Créez un répertoire nommé helloworld et modifiez les sous-répertoires comme suit :
```
   mkdir helloworld
   cd helloworld
```
Créez un fichier requirements.txt dans le répertoire helloworld pour spécifier les dépendances Python:
```
functions-framework==3.5.0
flask==3.0.3
google-cloud-error-reporting==1.9.1
MarkupSafe==2.1.3
```
Cela ajoute les packages requis par l'exemple.

Créez un fichier main.py dans le répertoire helloworld avec l'exemple Python suivant:

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

Créez un répertoire nommé helloworld et modifiez les sous-répertoires comme suit :
```
   mkdir helloworld
   cd helloworld
```

Initialisez un fichier go.mod pour déclarer le module go :

module github.com/GoogleCloudPlatform/golang-samples/functions/functionsv2/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
)

Créez un fichier hello_http.go dans le répertoire helloworld avec l'exemple de code Go suivant:


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

Créez un répertoire nommé helloworld et modifiez les sous-répertoires comme suit :
```
   mkdir helloworld
   cd helloworld
```

Créez la structure de projet suivante qui doit contenir le répertoire source et le fichier source :

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

Remplacez le fichier HelloWorld.java par l'exemple de code Java suivant:


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

Créez un fichier pom.xml dans le répertoire helloworld et ajoutez les dépendances Java suivantes:

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

Créez un répertoire nommé helloworld et modifiez les sous-répertoires comme suit :
```
   mkdir helloworld
   cd helloworld
```

Créez un fichier nommé app.rb et collez-y le code suivant :

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

Créez un fichier nommé Gemfile et copiez-y les éléments suivants :

source "https://rubygems.org"

gem "functions_framework", "~> 1.4"

Si vous n'avez pas installé Bundler 2.0 ou une version ultérieure, installez Bundler.
Générez un fichier Gemfile.lock en exécutant :
```
bundle install
```

PHP

Créez un répertoire nommé helloworld et modifiez les sous-répertoires comme suit :
```
   mkdir helloworld
   cd helloworld
```

Créez un fichier nommé index.php et collez-y le code suivant :


use Psr\Http\Message\ServerRequestInterface;

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

Si vous n'utilisez pas Cloud Shell, créez un fichier composer.json et collez-y le code suivant:

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

Installez le SDK .NET Core 6.0. Ce guide de démarrage rapide ne fonctionne que pour la version 6 de .NET.
À partir de la console, créez un projet Web vide à l'aide de la commande dotnet.
```
dotnet new web -o helloworld-csharp
```
Placez-vous dans le répertoire helloworld-csharp :

Remplacez l'exemple de code dans le fichier de projet helloworld-csharp.csproj par le code suivant:

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

Remplacez l'exemple de code dans le fichier Program.cs par le code suivant:


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

Déployer la fonction

Important : Dans ce guide de démarrage rapide, nous partons du principe que vous disposez de rôles de propriétaire ou d'éditeur dans le projet que vous utilisez pour les besoins du guide de démarrage rapide. Sinon, reportez-vous au rôle Développeur source Cloud Run afin de connaître les autorisations requises pour déployer une ressource Cloud Run depuis la source.

Pour déployer votre fonction Cloud Run, procédez comme suit:

Déployez la fonction en exécutant la commande suivante dans le répertoire contenant l'exemple de code: