Cloud Functions a été renommé Cloud Run Functions. Pour en savoir plus, consultez l'article de blog sur Cloud Run Functions.

Créer et déployer une fonction Cloud Run HTTP avec Java

Ce guide vous accompagne tout au long du processus d'écriture d'une fonction Cloud Run à l'aide de l'environnement d'exécution Java. Il existe deux types de fonctions Cloud Run :

Les fonctions HTTP, que vous appelez à partir des requêtes HTTP standards.
Les fonctions pilotées et déclenchées par des événements dans votre infrastructure cloud tels que les messages sur un sujet Pub/Sub ou les modifications apportées à un bucket Cloud Storage.

Ce document explique comment créer une fonction HTTP simple et la compiler à l'aide de Maven ou de Gradle.

Pour en savoir plus, consultez les sections Écrire des fonctions HTTP et Écrire des fonctions pilotées par des événements.

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 Cloud Functions, Cloud Build, Artifact Registry, Cloud Run, and Cloud Logging APIs.

Enable the APIs

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 Cloud Functions, Cloud Build, Artifact Registry, Cloud Run, and Cloud Logging APIs.

Enable the APIs

Téléchargez, installez et initialisez le SDK Google Cloud.
Note: Need a command prompt? Vous pouvez utiliser Cloud Shell. Cloud Shell est un environnement de ligne de commande qui inclut Google Cloud CLI. Vous n'avez donc pas besoin de l'installer. Google Cloud CLI est également préinstallé sur les machines virtuelles Google Compute Engine.
Mettez à jour et installez les composants gcloud à l'aide de la commande suivante.
```
gcloud components update
```
Préparez votre environnement de développement.

Accéder au guide de configuration Java

Créer une fonction

Cette section décrit comment créer une fonction.

Maven

Créez un répertoire sur votre système local pour le code de fonction :

Linux ou Mac OS X :
```
 mkdir ~/helloworld
 cd ~/helloworld
```
Windows :
```
 mkdir %HOMEPATH%\helloworld
 cd %HOMEPATH%\helloworld
```

Créez la structure de projet 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

Ajoutez le contenu suivant au fichier HelloWorld.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!");
  }
}

Cet exemple de fonction renvoie le message d'accueil "Hello World!".

Gradle

Créez un répertoire sur votre système local pour le code de fonction :

Linux ou Mac OS X :

 mkdir ~/helloworld-gradle
 cd ~/helloworld-gradle

Windows :

 mkdir %HOMEPATH%\helloworld-gradle
 cd %HOMEPATH%\helloworld-gradle

Créez la structure de projet qui doit contenir le répertoire source et le fichier source.
```
 mkdir -p src/main/java/functions
 touch src/main/java/functions/HelloWorld.java
```

Ajoutez le contenu suivant au fichier HelloWorld.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!");
  }
}

Cet exemple de fonction renvoie le message d'accueil "Hello World!".

Spécifier des dépendances

L'étape suivante consiste à configurer les dépendances :

Maven

Accédez au répertoire helloworld que vous avez créé ci-dessus, puis créez un fichier pom.xml :

 cd ~/helloworld
 touch pom.xml

Pour gérer les dépendances à l'aide de Maven, spécifiez-les dans la section <dependencies> du fichier pom.xml de votre projet. Pour cet exercice, copiez le contenu suivant dans votre fichier pom.xml.

<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>
  <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>
  </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>
    </plugins>
  </build>
</project>

Consultez la page Helloworld pour obtenir un exemple complet basé sur Maven.

Gradle

Accédez au répertoire helloworld-gradle que vous avez créé ci-dessus, puis créez un fichier build.gradle :

 cd ~/helloworld-gradle
 touch build.gradle

Pour gérer les dépendances à l'aide de Gradle, spécifiez-les dans le fichier build.gradle de votre projet. Pour cet exercice, copiez le contenu suivant dans votre fichier build.gradle. Notez que ce fichier build.gradle inclut une tâche personnalisée pour vous aider à exécuter des fonctions localement.

apply plugin: 'java'

repositories {
  jcenter()
  mavenCentral()
}
configurations {
    invoker
}

dependencies {
  // Every function needs this dependency to get the Functions Framework API.
  compileOnly 'com.google.cloud.functions:functions-framework-api:1.1.0'

  // To run function locally using Functions Framework's local invoker
  invoker 'com.google.cloud.functions.invoker:java-function-invoker:1.3.1'

  // These dependencies are only used by the tests.
  testImplementation 'com.google.cloud.functions:functions-framework-api:1.1.0'
  testImplementation 'junit:junit:4.13.2'
  testImplementation 'com.google.truth:truth:1.4.0'
  testImplementation 'org.mockito:mockito-core:5.10.0'

}

// Register a "runFunction" task to run the function locally
tasks.register("runFunction", JavaExec) {
  main = 'com.google.cloud.functions.invoker.runner.Invoker'
  classpath(configurations.invoker)
  inputs.files(configurations.runtimeClasspath, sourceSets.main.output)
  args(
    '--target', project.findProperty('run.functionTarget') ?: '',
    '--port', project.findProperty('run.port') ?: 8080
  )
  doFirst {
    args('--classpath', files(configurations.runtimeClasspath, sourceSets.main.output).asPath)
  }
}

Vous trouverez un exemple complet basé sur Gradle dans le fichier helloworld-gradle.

Créer et tester votre fonction localement

Avant de déployer la fonction, vous pouvez la créer et la tester localement :

Maven

Exécutez la commande suivante pour vérifier que votre fonction est créée :
```
mvn compile
```
Une autre option consiste à utiliser la commande mvn package pour compiler votre code Java, exécuter des tests et empaqueter le code dans un fichier JAR dans le répertoire cible. Pour en savoir plus sur le cycle de vie des builds Maven, cliquez ici.
Démarrez votre fonction à l'aide de la commande suivante :
```
mvn function:run
```
Testez votre fonction en accédant à http://localhost:8080 dans un navigateur ou en exécutant curl localhost:8080 à partir d'une autre fenêtre.

Pour en savoir plus, consultez la section Envoyer des requêtes aux fonctions locales.

Gradle

Exécutez la commande suivante pour vérifier que votre fonction est créée :
```
gradle build
```

Démarrez votre fonction à l'aide de la commande suivante :

gradle runFunction -Prun.functionTarget=functions.HelloWorld

Testez votre fonction en accédant à http://localhost:8080 dans un navigateur ou en exécutant curl localhost:8080 à partir d'une autre fenêtre.

Pour en savoir plus, consultez la section Envoyer des requêtes aux fonctions locales.

Déployer la fonction

Pour déployer votre fonction, exécutez la commande suivante dans le répertoire helloworld (si vous utilisez maven) ou dans le répertoire helloworld-gradle (pour gradle) :

  gcloud functions deploy java-http-function \
    --gen2 \
    --entry-point=functions.HelloWorld \
    --runtime=java17 \
    --region=REGION \
    --source=. \
    --trigger-http \
    --allow-unauthenticated

Remplacez REGION par le nom de la région Google Cloud dans laquelle vous souhaitez déployer votre fonction (par exemple, us-west1).

L'option facultative --allow-unauthenticated vous permet d'accéder à votre fonction sans authentification.

java-http-function est le nom enregistré par lequel votre fonction est identifiée dans la console Google Cloud, et --entry-point spécifie le nom de classe complet de votre fonction (FQN).

Tester la fonction déployée

Une fois la fonction déployée, notez la propriété uri à partir du résultat de la commande gcloud functions deploy ou récupérez-la à l'aide de la commande suivante :
```
gcloud functions describe java-http-function \
  --region=REGION
```
Remplacez REGION par le nom de la région Google Cloud dans laquelle vous avez déployé votre fonction (par exemple, us-west1).
Accédez à cette URL dans votre navigateur. La fonction renvoie un message "Hello World!".

Remarque : Vous pouvez également trouver cette URL dans la console Google Cloud. Accédez à la page Présentation de Cloud Run Functions et cliquez sur le nom de votre fonction pour ouvrir la page Informations sur la fonction. Ouvrez l'onglet TRIGGER pour afficher l'URL de votre fonction.

Afficher les journaux de votre fonction

Afficher les journaux à l'aide de l'outil de ligne de commande

Vous pouvez consulter les journaux de votre fonction à l'aide de l'interface utilisateur Cloud Logging ou de Google Cloud CLI.

Pour afficher les journaux de votre fonction à l'aide de gcloud CLI, exécutez la commande logs read :

    gcloud functions logs read \
      --gen2 \
      --limit=10 \
      --region=REGION \
      java-http-function

Remplacez REGION par le nom de la région Google Cloud dans laquelle vous avez déployé votre fonction (par exemple, us-west1).

Le résultat se présente comme suit :

LEVEL: I
NAME: my-first-function
TIME_UTC: 2023-05-29 23:09:57.708
LOG:

LEVEL: I
NAME: my-first-function
TIME_UTC: 2023-05-29 23:05:53.257
LOG: Default STARTUP TCP probe succeeded after 1 attempt for container "my--first--function-1" on port 8080.

LEVEL:
NAME: my-first-function
TIME_UTC: 2023-05-29 23:05:53.248
LOG: 2023-05-29 23:05:53.248:INFO:oejs.Server:main: Started @892ms

Afficher les journaux à l'aide du tableau de bord de journalisation

Pour afficher les journaux de votre fonction à l'aide du tableau de bord de journalisation, ouvrez la page Page de présentation de Cloud Run Functions et cliquez sur le nom de votre fonction dans la liste, puis sur l'onglet Journaux.