Um die Suche zu vereinfachen und die Dokumentation zu verbessern, teilen wir die Dokumentation der 1. Generation und der 2. Generation in separate Gruppen ein.

HTTP-Cloud Run Functions-Funktion mit Java erstellen und bereitstellen

In diesem Leitfaden wird der Schreibvorgang für eine Cloud Run Functions-Funktion mit der Java-Laufzeit beschrieben. Es gibt zwei Arten von Cloud Run-Funktionen:

Eine HTTP-Funktion, die Sie über Standard-HTTP-Anfragen aufrufen.
Eine ereignisgesteuerte Funktion, die durch Ereignisse in Ihrer Cloud-Infrastruktur ausgelöst wird, z. B. Nachrichten in einem Pub/Sub-Thema oder Änderungen in einem Cloud Storage-Bucket.

In diesem Dokument wird gezeigt, wie Sie eine einfache HTTP-Funktion mit Maven oder Gradle erstellen.

Weitere Informationen finden Sie unter HTTP-Funktionen schreiben und Ereignisgesteuerte Funktionen schreiben.

Vorbereitung

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

Installieren und initialisieren Sie das Google Cloud SDK.
Hinweis: Benötigen Sie eine Eingabeaufforderung? Sie können die Cloud Shell verwenden. Cloud Shell ist eine Befehlszeilenumgebung, in der die Google Cloud CLI bereits enthalten ist und daher nicht installiert werden muss. Die Google Cloud CLI ist außerdem auf den virtuellen Maschinen von Google Compute Engine vorinstalliert.
Aktualisieren und installieren Sie gcloud-Komponenten mit dem folgenden Befehl.
```
gcloud components update
```
Bereiten Sie die Entwicklungsumgebung vor.

Zum Einrichtungsleitfaden für Java

Funktion erstellen

In diesem Abschnitt wird beschrieben, wie Sie eine Funktion erstellen.

Maven

Erstellen Sie in Ihrem lokalen System ein Verzeichnis für den Funktionscode:

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

Erstellen Sie die Projektstruktur, die das Quellverzeichnis und die Quelldatei enthält.

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

Fügen Sie der HelloWorld.java-Datei diesen Inhalt hinzu:


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

Diese Beispielfunktion gibt die Begrüßung "Hello World!" aus.

Gradle

Erstellen Sie in Ihrem lokalen System ein Verzeichnis für den Funktionscode:

Linux oder Mac OS X:

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

Windows:

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

Erstellen Sie die Projektstruktur, die das Quellverzeichnis und die Quelldatei enthält.

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

Fügen Sie der HelloWorld.java-Datei diesen Inhalt hinzu:


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

Diese Beispielfunktion gibt die Begrüßung „Hello World!“ aus.

Abhängigkeiten angeben

Im nächsten Schritt werden die Abhängigkeiten eingerichtet:

Maven

Wechseln Sie in das Verzeichnis helloworld, das Sie oben erstellt haben, und erstellen Sie eine pom.xml-Datei:

 cd ~/helloworld
 touch pom.xml

Zum Verwalten von Abhängigkeiten mithilfe von Maven geben Sie die Abhängigkeiten im Abschnitt <dependencies> der Datei pom.xml Ihres Projekts an. Kopieren Sie für diese Übung die folgenden Inhalte in die Datei 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>

Unter helloworld finden Sie ein vollständiges Beispiel, das auf Maven basiert.

Gradle

Wechseln Sie in das Verzeichnis helloworld-gradle, das Sie oben erstellt haben, und erstellen Sie eine build.gradle-Datei:

 cd ~/helloworld-gradle
 touch build.gradle

Zum Verwalten von Abhängigkeiten mithilfe von Gradle geben Sie die Abhängigkeiten in der Datei build.gradle Ihres Projekts an. Kopieren Sie für diese Übung die folgenden Inhalte in die Datei build.gradle. Beachten Sie, dass die Datei build.gradle eine benutzerdefinierte Aufgabe enthält, damit Sie Funktionen lokal ausführen können.

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

Unter helloworld finden Sie ein vollständiges Beispiel, das auf Gradle basiert.

Funktion lokal erstellen und testen

Bevor Sie die Funktion bereitstellen, können Sie sie lokal erstellen und testen:

Maven

Führen Sie den folgenden Befehl aus, um zu prüfen, ob Ihre Funktion erstellt wird:
```
mvn compile
```
Eine weitere Option besteht darin, den Befehl mvn package zu verwenden, um Ihren Java-Code zu kompilieren, Tests auszuführen und den Code in einer JAR-Datei im Zielverzeichnis zu verpacken. Weitere Informationen zum Maven-Build-Lebenszyklus
Starten Sie die Funktion mit dem folgenden Befehl:
```
mvn function:run
```
Testen Sie Ihre Funktion. Rufen Sie dazu http://localhost:8080 in einem Browser auf oder führen Sie curl localhost:8080 in einem anderen Fenster aus.

Weitere Informationen finden Sie unter Anfragen an lokale Funktionen senden.

Gradle

Führen Sie den folgenden Befehl aus, um zu prüfen, ob Ihre Funktion erstellt wird:
```
gradle build
```

Starten Sie die Funktion mit dem folgenden Befehl:

gradle runFunction -Prun.functionTarget=functions.HelloWorld

Testen Sie Ihre Funktion. Rufen Sie dazu http://localhost:8080 in einem Browser auf oder führen Sie curl localhost:8080 in einem anderen Fenster aus.

Weitere Informationen finden Sie unter Anfragen an lokale Funktionen senden.

Funktion bereitstellen

Führen Sie den folgenden Befehl im Verzeichnis helloworld aus, wenn Sie maven verwenden, oder im Verzeichnis helloworld-gradle für Gradle, um die Funktion bereitzustellen:

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

Ersetzen Sie REGION durch den Namen der Google Cloud-Region, in der Sie die Funktion bereitstellen möchten (z. B. us-west1).

Mit dem optionalen Flag --allow-unauthenticated können Sie die Funktion ohne Authentifizierung aufrufen.

java-http-function ist der registrierte Name, mit dem die Funktion in der Google Cloud Console identifiziert wird. --entry-point gibt den vollständig qualifizierten Klassennamen (FQN) der Funktion an.

Bereitgestellte Funktion testen

Beachten Sie nach dem Bereitstellen der Funktion das Attribut uri in der Ausgabe des Befehls gcloud functions deploy oder rufen Sie es mit dem folgenden Befehl ab:
```
gcloud functions describe java-http-function \
  --region=REGION
```
Ersetzen Sie REGION durch den Namen der Google Cloud-Region, in der Sie die Funktion bereitgestellt haben (z. B. us-west1).
Rufen Sie diese URL in Ihrem Browser auf: Die Funktion gibt die Nachricht „Hello World!“ zurück.

Hinweis: Sie finden diese URL auch in der Google Cloud Console. Rufen Sie die Übersichtsseite zu Cloud Run Functions auf und klicken Sie auf den Namen der Funktion, um die Seite Funktionsdetails zu öffnen. Öffnen Sie den Tab TRIGGER, um die URL Ihrer Funktion zu sehen.

Logs der Funktion ansehen

Logs mit dem Befehlszeilentool ansehen

Sie können die Logs Ihrer Funktion über die Cloud Logging-UI oder die Google Cloud CLI prüfen.

Wenn Sie mit der gcloud CLI Logs für Ihre Funktion aufrufen möchten, verwenden Sie den Befehl logs read:

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

Ersetzen Sie REGION durch den Namen der Google Cloud-Region, in der Sie die Funktion bereitgestellt haben (z. B. us-west1).

Die Ausgabe sollte in etwa so aussehen:

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

Logs mit dem Logging-Dashboard ansehen

Um die Logs für Ihre Funktion mit dem Logging-Dashboard aufzurufen, öffnen Sie die Übersichtsseite zu Cloud Run Functions. Klicken Sie in der Liste auf den Namen Ihrer Funktion und dann auf den Tab Logs.