Questa pagina è stata tradotta dall'API Cloud Translation.

Il runtime Java

Il runtime Java è lo stack software responsabile dell'installazione del codice e delle dipendenze dell'applicazione e dell'esecuzione dell'applicazione nell'ambiente flessibile.

Le versioni 11 e successive sono basate su buildpacks, che richiede la scelta di un sistema operativo nel file app.yaml. Ad esempio, per utilizzare Java 21, devi specificare Ubuntu 22 come sistema operativo.
Il runtime Java 8 / Jetty 9 fornisce a OpenJDK 8 ed Eclipse Jetty 9 il supporto per la specifica Servlet Java 3.1. L'immagine Jetty eredita dall'immagine OpenJDK.

Per l'elenco completo delle versioni Java supportate e delle versioni di Ubuntu corrispondenti, consulta la pianificazione del supporto per l'esecuzione.

Prerequisiti

Per utilizzare il runtime Java:

Devi installare gcloud CLI versione 420.0.0 o successiva. Puoi aggiornare gli strumenti dell'interfaccia a riga di comando eseguendo il comando gcloud components update. Per visualizzare la versione installata, puoi eseguire il comando gcloud version.
Per eseguire il deployment utilizzando Maven, devi aggiungere il plug-in Maven di App Engine a pom.xml:
```
<plugin>
   <groupId>com.google.cloud.tools</groupId>
   <artifactId>appengine-maven-plugin</artifactId>
   <version>2.7.0</version>
</plugin>
```
Altre opzioni per il deployment includono il comando gcloud app deploy o il plug-in Gradle di App Engine.

Organizzazione dei file

La struttura ad albero di origine dovrebbe avere l'aspetto seguente:

MyDir/
  [pom.xml]
  [build.gradle]
  [index.yaml]
  [cron.yaml]
  [dispatch.yaml]
  src/main/
    appengine/
      app.yaml
    docker/
      [Dockerfile]
    java/
      com.example.mycode/
        MyCode.java
    webapp/
      [index.html]
      [jsp.jsp]
      WEB-INF/
        [web.xml]

Scegli una versione Java

Nuove versioni di runtime

Per il runtime Java versione 11 e successive, devi includere le impostazioni runtime_config e operating_system nel file app.yaml per specificare un sistema operativo.

Se vuoi, puoi specificare una versione del runtime includendo l'impostazione runtime_version nel file app.yaml. Per impostazione predefinita, se l'impostazione runtime_version non è specificata viene utilizzata la versione più recente di Java.

Esempi

Per specificare Java 21 su Ubuntu 22:

runtime: java
env: flex

runtime_config:
    operating_system: "ubuntu22"
    runtime_version: "21"

Per specificare la versione più recente di Java supportata su Ubuntu 22:

  runtime: java
  env: flex

  runtime_config:
      operating_system: "ubuntu22"

Versioni di runtime precedenti

Per Java 8, specifica le impostazioni runtime_config e jdk nel file app.yaml.

Java 8 supporta:

Il runtime Eclipse Jetty 9 ed esegue Jetty 9 utilizzando Servlet 3.1.
Il tuo codice server in ascolto sulla porta 8080 come parte della tua applicazione. Questa funzionalità consente di utilizzare framework di microservizi come SparkJava e Spring-Boot.

Esempi

Specificare la versione 9 di Jetty (impostazione predefinita / facoltativa):
```
  runtime_config:
    jdk: openjdk8
    server: jetty9
```
Specifica della versione 8 di Java:
```
  runtime_config:
    jdk: openjdk8
```

Esempio di app.yaml per Java 8:

runtime: java
env: flex

handlers:
- url: /.*
  script: this field is required, but ignored

Vedi pom.xml per configurare Maven e build.gradle per configurare Gradle.

File facoltativi

Questi file di configurazione sono facoltativi:

Posiziona questi file al livello superiore di MyDir. Se utilizzi questi file, devi eseguirne il deployment separatamente con il comando gcloud app deploy.

web.xml è facoltativo ed è necessario solo se non utilizzi le annotazioni Servlet 3.x.

Nella directory webapp/ puoi inserire contenuti web statici, oltre alle tue pagine JavaServer. Jetty 9, che l'ambiente flessibile di App Engine utilizza come container Servlet, utilizza Apache Jasper come implementazione JSP predefinita e include tag JSTL.

Il file Dockerfile è facoltativo e viene utilizzato per personalizzare il runtime Java.

Attivazione della compressione gzip

Il gestore gzip è in bundle con Jetty, ma non è attivato per impostazione predefinita. Per attivare questo modulo, imposta la variabile di ambiente, JETTY_MODULES_ENABLE=gzip, nel file app.yaml:

env_variables:
  JETTY_MODULES_ENABLE: 'gzip'

Guida rapida

Jetty può velocizzare l'ora di avvio dell'applicazione eseguendo la scansione preliminare dei suoi contenuti e generando file di configurazione. Se usi un'immagine estesa, puoi attivare la guida rapida eseguendo /scripts/jetty/quickstart.sh nel tuo Dockerfile, dopo l'aggiunta dell'applicazione WAR.

Variabili di ambiente

Puoi impostare le seguenti variabili di ambiente facoltative specifiche per il runtime Java 8/Jetty 9. Puoi anche impostare le variabili di ambiente OpenJDK 8.

Per impostare le variabili di ambiente, utilizza la chiave env_variables nel file app.yaml.

Var. amb.	Prop Maven	Valore/Commento
`JETTY_PROPERTIES`		Elenco separato da virgole di `name=value` coppie aggiunte a `$JETTY_ARGS`
`JETTY_MODULES_ENABLE`		Elenco separato da virgole di moduli da abilitare aggiungendoli a `$JETTY_ARGS`
`JETTY_MODULES_DISABLE`		Elenco separato da virgole di moduli da disabilitare rimuovendoli da `$JETTY_BASE/start.d`
`JETTY_ARGS`		Argomenti passati al molo `start.jar`. Tutti gli argomenti utilizzati per la configurazione del molo personalizzato devono essere passati qui.
`JAVA_OPTS`		Argomenti di runtime JVM

Cloud Logging avanzato (beta)

Durante l'esecuzione nell'ambiente flessibile di App Engine, puoi configurare Util Logging di Java per inviare log a Cloud Logging impostando la variabile di ambiente JETTY_ARGS. Ad esempio:

 env_variables:
   JETTY_ARGS: -Djava.util.logging.config.file=WEB-INF/logging.properties

Devi fornire un file logging.properties che configuri un LoggingHandler nel modo seguente:

handlers=com.google.cloud.logging.LoggingHandler

# Optional configuration
.level=INFO
com.google.cloud.logging.LoggingHandler.level=FINE
com.google.cloud.logging.LoggingHandler.log=gae_app.log
com.google.cloud.logging.LoggingHandler.formatter=java.util.logging.SimpleFormatter
java.util.logging.SimpleFormatter.format=%3$s: %5$s%6$s

Test locale

Durante i test nel tuo ambiente locale, puoi utilizzare servizi Google Cloud emulati anziché servizi Google Cloud remoti. Puoi usare i seguenti emulatori:

Usa il comando gcloud per avviarle prima di eseguire l'app:

gcloud beta emulators datastore start
gcloud beta emulators pubsub start
gcloud beta emulators bigtable start

Maven

Aggiungi queste righe al file pom.xml Maven per aggiungere il plug-in Maven Jetty 9:

<plugin>
  <groupId>org.eclipse.jetty</groupId>
  <artifactId>jetty-maven-plugin</artifactId>
  <version>9.4.2.v20170220</version>
</plugin>

Per eseguire l'app localmente, utilizza il comando Maven:

mvn jetty:run-exploded

Gradle

Segui le istruzioni per creare un nuovo progetto Gradle per aggiungere il plug-in Gretty Gradle a build.gradle e utilizza il comando:

gradle jettyRun

Deployment dell'app

Per inizializzare Google Cloud CLI, esegui:

gcloud init

Dopo aver completato le configurazioni, puoi utilizzare Google Cloud CLI per eseguire il deployment di questa directory contenente i file app.yaml e WAR utilizzando:

gcloud app deploy app.yaml

Se utilizzi uno dei file di configurazione facoltativi (index.yaml, cron.yaml e dispatch.yaml), eseguine il deployment separatamente con il comando gcloud. Ad esempio:

gcloud app deploy cron.yaml

Maven

Usa Maven per eseguire il deployment della tua app:

mvn package appengine:deploy -Dapp.deploy.projectId=PROJECT_ID

Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud. Se il file pom.xml specifica già il tuo ID progetto, non è necessario includere la proprietà -Dapp.deploy.projectId nel comando che esegui.

Gradle

Utilizza Gradle per eseguire il deployment della tua app:

gradle appengineDeploy

Personalizzazione del runtime Java 8 / Jetty 9

Non è necessario un Dockerfile per eseguire il deployment della tua app nel runtime Java 8/Jetty 9. Se la tua app richiede una configurazione aggiuntiva, puoi fornire esplicitamente un Dockerfile per personalizzare il runtime Java. Il Dockerfile deve includere l'immagine di base. Puoi aggiungere ulteriori istruzioni al Dockerfile per personalizzare il runtime Java. Consulta la pagina Creazione di runtime personalizzati.

In questo caso, your-application.war è il nome del file WAR creato nella directory target/ (maven) o build/staged-app/ (gradle).