Opzioni di deployment Java

Hai due opzioni per eseguire il deployment di una funzione Java:

• Dalla fonte. Per una discussione generale su questo argomento, vedi Deployment dalla macchina locale.
• Da un file JAR predefinito.

Esegui il deployment dall'origine

Il codice sorgente della funzione deve essere nella posizione consueta per i progetti Maven (src/main/java). Le funzioni di esempio in questo documento si trovano direttamente in src/main/java, senza dichiarazione del pacchetto nel file sorgente .java. Per codice non banale, probabilmente dovresti introdurre un pacchetto. Se il pacchetto fosse com.example, la gerarchia sarebbe simile alla seguente:

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

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

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

Dove:

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

Utilizza questo comando per eseguire il deployment di una funzione in background:

gcloud functions deploy $name --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 del corso (ad esempio, com.example.MyFunction o solo MyFunction se non utilizzi un pacchetto).
• $resource_name e $event_name sono specifici per gli eventi che attivano la funzione in background. Esempi di risorse ed eventi supportati sono Google Cloud Pub/Sub e Google Cloud Storage.

Nota: per una discussione più dettagliata sul deployment delle funzioni HTTP e in background, vedi Deployment dalla macchina locale.

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

.git
target
build
.idea

Deployment da un JAR

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

Crea ed esegui il deployment di un JAR Uber

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

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

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

Maven

Utilizza il plug-in Maven Shade per creare un JAR Uber. 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>

Nota: alcune librerie (incluse le librerie client Java di Google Cloud) potrebbero utilizzare Service Loader per configurare le classi di implementazione dei servizi di runtime. È importante utilizzare Shade con ServicesResourceTransformer per conservare le informazioni sui servizi nella directory META-INF/services finale del pacchetto JAR. Al posto di Shade, puoi anche utilizzare il plug-in Assembly Maven.

Crea un Uber JAR:

mvn package

Quindi esegui il deployment con il seguente comando:

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

Gradle

Utilizza il plug-in Shadow per Gradle. Configura il plug-in nel tuo 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 \
   --runtime=java17 \
   --trigger-http \
   --source=build/libs

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

Puoi creare ed eseguire il deployment di un file JAR thin anziché di un JAR Uber. Un JAR thin è un file JAR che contiene solo le classi di funzione senza le dipendenze incorporate nello stesso file JAR. Poiché le dipendenze sono ancora necessarie per il deployment, devi configurare quanto segue:

• Le dipendenze devono trovarsi in una sottodirectory relativa al JAR di cui eseguire il deployment.
• JAR deve avere un file META-INF/MANIFEST.MF che includa un attributo Class-Path il cui valore elenca i percorsi di dipendenza richiesti.

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

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

La directory di deployment dovrebbe quindi contenere il file JAR delle funzioni principali, 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 JAR thin contemporaneamente 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>

Costruisci il JAR sottile:

mvn package

Quindi esegui il deployment con il seguente comando:

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

Gradle

Aggiorna il file di progetto build.gradle per aggiungere una nuova attività e 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
 }
}