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

  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. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  4. Enable the Cloud Functions, Cloud Build, Artifact Registry, Cloud Run, and Cloud Logging APIs.

    Enable the APIs

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

    Go to project selector

  6. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  7. Enable the Cloud Functions, Cloud Build, Artifact Registry, Cloud Run, and Cloud Logging APIs.

    Enable the APIs

  8. Installieren und initialisieren Sie das Google Cloud SDK.
  9. Aktualisieren und installieren Sie gcloud-Komponenten mit dem folgenden Befehl.
    gcloud components update
  10. Bereiten Sie die Entwicklungsumgebung vor.

    Zum Einrichtungsleitfaden für Java

Funktion erstellen

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

Maven

  1. 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
    
  2. 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
    
  3. 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

  1. 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
    
  2. 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
    
  3. 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-gradle 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

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

  2. Starten Sie die Funktion mit dem folgenden Befehl:

    mvn function:run
    
  3. 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

  1. Führen Sie den folgenden Befehl aus, um zu prüfen, ob Ihre Funktion erstellt wird:

    gradle build
    
  2. Starten Sie die Funktion mit dem folgenden Befehl:

    gradle runFunction -Prun.functionTarget=functions.HelloWorld
    
  3. 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

  1. 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).

  2. Rufen Sie diese URL in Ihrem Browser auf: Die Funktion gibt die Nachricht „Hello World!“ zurück.

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.