Opzioni di deployment Java

Hai due opzioni per il deployment di una funzione Java:

Esegui il deployment dall'origine

Il codice sorgente della funzione deve trovarsi nella posizione abituale per i progetti Maven (src/main/java). Le funzioni di esempio in questo documento si trovano direttamente in src/main/java, senza dichiarazione di pacchetto nel file del codice sorgente .java. Per del codice più complesso, probabilmente introdurrai un pacchetto. Se il pacchetto è com.example, la gerarchia sarà simile alla seguente:

myfunction/
├─ pom.xml
├─ src
    ├─main
        ├─ java
            ├─ com
                ├─ example
                    ├─ MyFunction.java

Utilizza il comando seguente per eseguire il deployment di una funzione HTTP:

gcloud functions deploy $name --trigger-http --no-gen2 \
    --entry-point $function_class --runtime java17

Dove:

  • $name è un nome descrittivo arbitrario che sarà il nome della funzione una volta eseguito il deployment. $namepuò contenere solo lettere, numeri, trattini bassi e trattini.
  • $function_class è il nome completo della tua classe (ad esempio, com.example.MyFunction o semplicemente MyFunction se non utilizzi un pacchetto).

Utilizza il seguente comando per eseguire il deployment di una funzione basata su eventi:

gcloud functions deploy $name --no-gen2 --entry-point $function_class \
    --trigger-resource $resource_name \
    --trigger-event $event_name \
    --runtime java17

Dove:

  • $name è un nome descrittivo arbitrario che sarà il nome della funzione una volta eseguito il deployment.
  • $function_class è il nome completo della tua classe (ad esempio, com.example.MyFunction o semplicemente MyFunction se non utilizzi un pacchetto).
  • $resource_name e $event_name sono specifici per gli eventi che attivano la tua funzione. Esempi di risorse ed eventi supportati sono Google Cloud Pub/Sub e Google Cloud Storage.

Quando esegui il deployment di una funzione dall'origine, Google Cloud CLI carica la directory di origine (e tutto il suo contenuto) in Google Cloud per la creazione. Per evitare di inviare file non necessari, puoi utilizzare il file .gcloudignore. Modifica il file .gcloudignore per ignorare le directory comuni come .git e target/. Ad esempio, un file .gcloudignore potrebbe contenere quanto segue:

.git
target
build
.idea

Esegui il deployment da un file JAR

Puoi eseguire il deployment di un file JAR preconfigurato che contiene la funzione. Ciò è utile soprattutto se devi eseguire il deployment di una funzione che utilizza dipendenze da un repository di artefatti privato a cui non è possibile accedere dalla pipeline di build di Google Cloud durante la creazione dall'origine. Il file JAR può essere un uber JAR che contiene la classe della funzione e tutte le relative classi di dipendenza, oppure un thin JAR che contiene voci Class-Path per i JAR di dipendenza nel file META-INF/MANIFEST.MF.

Crea ed esegui il deployment di un uber JAR

Un uber JAR è un file JAR che contiene le classi delle funzioni e tutte le relative dipendenze. Puoi creare un uber JAR con Maven e Gradle. Per eseguire il deployment di un uber JAR, questo deve essere l'unico file JAR nella propria directory, ad esempio:

my-function-deployment/
 ├─ my-function-with-all-dependencies.jar

Puoi copiare il file in questa struttura di directory oppure utilizzare i plug-in per Maven e Gradle per generare la directory di deployment corretta.

Maven

Utilizza il plug-in Maven Shade per creare un uber JAR. Configura il tuo pom.xml con il plug-in Shade:

<?xml version="1.0" encoding="UTF-8"?>
<project ...>
  ...
  <build>
    ...
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-shade-plugin</artifactId>
        <executions>
          <execution>
            <phase>package</phase>
            <goals><goal>shade</goal></goals>
            <configuration>
              <outputFile>${project.build.directory}/deployment/${build.finalName}.jar</outputFile>
              <transformers>
                <!-- This may be needed if you need to shade a signed JAR -->
                <transformer implementation="org.apache.maven.plugins.shade.resource.DontIncludeResourceTransformer">
                  <resource>.SF</resource>
                  <resource>.DSA</resource>
                  <resource>.RSA</resource>
                </transformer>
                <!-- This is needed if you have dependencies that use Service Loader. Most Google Cloud client libraries does. -->
                <transformer implementation=
       "org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
              </transformers>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

Crea il file uber JAR:

mvn package

Quindi esegui il deployment con il seguente comando:

gcloud functions deploy jar-example \
    --entry-point=Example \
    --no-gen2 \
    --runtime=java17 \
    --trigger-http \
    --source=target/deployment

Gradle

Utilizza il plug-in Shadow per Gradle. Configura il plug-in nel file build.gradle:

buildscript {
   repositories {
       jcenter()
   }
   dependencies {
       ...
       classpath "com.github.jengelman.gradle.plugins:shadow:5.2.0"
   }
}

plugins {
   id 'java'
   ...
}
sourceCompatibility = '17.0'
targetCompatibility = '17.0'
apply plugin: 'com.github.johnrengelman.shadow'

shadowJar {
   mergeServiceFiles()
}
...

Ora puoi eseguire Gradle con il comando shadowJar:

gradle shadowJar

Quindi esegui il deployment con il seguente comando:

gcloud functions deploy jar-example \
   --entry-point=Example \
   --no-gen2 \
   --runtime=java17 \
   --trigger-http \
   --source=build/libs

Crea ed esegui il deployment di un thin JAR con dipendenze esterne

Puoi creare ed eseguire il deployment di un file thin JAR anziché di un uber JAR. Un thin JAR è un file JAR che contiene solo le classi delle funzioni senza le dipendenze incorporate nello stesso file JAR. Poiché le dipendenze sono comunque necessarie per il deployment, devi eseguire la configurazione nel modo seguente:

  • Le dipendenze devono trovarsi in una sottodirectory relativa al file JAR da implementare.
  • Il file JAR deve contenere un file META-INF/MANIFEST.MF che include un attributo Class-Path il cui valore elenca i percorsi delle dipendenze richieste.

Ad esempio, il file JAR my-function.jar ha un file META-INF/MANIFEST.MF con due dipendenze nella directory libs/ (un elenco separato da spazi di percorsi relativi):

Manifest-Version: 1.0
Class-Path: libs/dep1.jar libs/dep2.jar

La directory di deployment deve contenere il file JAR della funzione principale, nonché una sottodirectory con le due dipendenze da cui dipende la funzione:

function-deployment/
├─ my-function.jar
├─ libs
       ├─ dep1.jar
       ├─ dep2.jar

Puoi creare un thin JAR con Maven e Gradle:

Maven

Utilizza il plug-in Maven JAR per configurare automaticamente MANIFEST.MF con i percorsi delle dipendenze, quindi utilizza il plug-in Maven Dependency per copiare le dipendenze.

<?xml version="1.0" encoding="UTF-8"?>
<project ...>
  ...
  <build>
    ...
    <plugins>
      <plugin>
        <artifactId>maven-jar-plugin</artifactId>
        <configuration>
          <archive>
            <manifest>
              <addClasspath>true</addClasspath>
              <classpathPrefix>libs/</classpathPrefix>
            </manifest>
          </archive>
        </configuration>
      </plugin>
      <plugin>
        <artifactId>maven-dependency-plugin</artifactId>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>copy-dependencies</goal>
            </goals>
            <configuration>
              <overWriteReleases>false</overWriteReleases>
              <includeScope>runtime</includeScope>
              <outputDirectory>${project.build.directory}/libs</outputDirectory>
            </configuration>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <artifactId>maven-resources-plugin</artifactId>
        <executions>
          <execution>
            <id>copy-resources</id>
            <phase>package</phase>
            <goals><goal>copy-resources</goal></goals>
            <configuration>
              <outputDirectory>${project.build.directory}/deployment</outputDirectory>
              <resources>
                <resource>
                  <directory>${project.build.directory}</directory>
                  <includes>
                    <include>${build.finalName}.jar</include>
                    <include>libs/**</include>
                  </includes>
                  <filtering>false</filtering>
                </resource>
              </resources>
            </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

Crea il thin JAR:

mvn package

Quindi esegui il deployment con il seguente comando:

gcloud functions deploy jar-example \
    --entry-point=Example \
    --no-gen2 \
    --runtime=java17 \
    --trigger-http \
    --source=target/deployment

Gradle

Aggiorna il file di progetto build.gradle per aggiungere una nuova attività per recuperare le dipendenze:

dependencies {
   // API available at compilation only, but provided at runtime
   compileOnly 'com.google.cloud.functions:functions-framework-api:1.0.1'
   // dependencies needed by the function
   // ...
}

jar {
 manifest {
   attributes(
     "Class-Path": provider {
         configurations.runtimeClasspath
           .collect { "libs/${it.name}" }.join(' ')
     }
   )
 }
}

task prepareDeployment(type: Copy) {
 into("${buildDir}/deployment")
 into('.') {
   from jar
 }
 into('libs') {
   from configurations.runtimeClasspath
 }
}