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, nonché dell'esecuzione dell'applicazione nell'ambiente flessibile.

La versione 11 e successive sono create utilizzando buildpacks, che richiede la scelta un sistema operativo nel file app.yaml. Ad esempio, per 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 Java Servlet 3.1. Il molo eredita dall'immagine OpenJDK.

Per l'elenco completo delle versioni Java supportate e della relativa versione di Ubuntu, consulta la pianificazione del supporto del runtime.

Prerequisiti

Per utilizzare il runtime Java:

Devi installare gcloud CLI versione 420.0.0 o successive. Puoi aggiornare gli strumenti dell'interfaccia a riga di comando eseguendo gcloud components update . Per visualizzare la versione installata, puoi eseguire Comando gcloud version.
Per eseguire il deployment tramite Maven, dovrai aggiungere Plug-in Maven per App Engine sul tuo 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 plug-in Gradle di App Engine.

Organizzare i file

La struttura dell'albero di origine dovrebbe essere simile alla 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 di Java

Nuove versioni del runtime

Per Java runtime versione 11 e successive, devi includere il parametro Impostazioni di runtime_config e operating_system in app.yaml da specificare di un sistema operativo.

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

Esempi

Per specificare Java 21 su Ubuntu 22:

runtime: java
env: flex

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

Per specificare l'ultima versione di Java supportata su Ubuntu 22:

  runtime: java
  env: flex

  runtime_config:
      operating_system: "ubuntu22"

Versioni precedenti del runtime

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

Java 8 supporta:

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

Esempi

Specificare la versione 9 di Jetty (predefinita / facoltativa):

  runtime_config:
    jdk: openjdk8
    server: jetty9

Specifica della versione Java 8:
```
  runtime_config:
    jdk: openjdk8
```

Esempio di app.yaml per Java 8:

runtime: java
env: flex

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

Consulta pom.xml per la configurazione di Maven e build.gradle per la configurazione di Gradle.

File facoltativi

Questi file di configurazione sono facoltativi:

Posiziona questi file al livello superiore di MyDir. Se utilizzi uno di 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.

Puoi inserire contenuti web statici, nonché le tue pagine JavaServer, nella directory webapp/. Jetty 9, che l'ambiente flessibile di App Engine utilizza come contenitore Servlet, utilizza Apache Jasper come implementazione JSP predefinita e include le taglib JSTL.

Il file Dockerfile è facoltativo ed è utilizzato per personalizzare Java runtime.

Attivazione della compressione gzip

L'handler gzip è incluso in Jetty, ma non è attivato per impostazione predefinita. A attiva questo modulo, imposta la variabile di ambiente JETTY_MODULES_ENABLE=gzip nel file app.yaml:

env_variables:
  JETTY_MODULES_ENABLE: 'gzip'

Utilizzo della guida rapida

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

Variabili di ambiente

Puoi impostare le seguenti variabili di ambiente facoltative specifiche per il runtime di 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. ambiente	Maven Prop	Valore/commento
`JETTY_PROPERTIES`		Elenco separato da virgole di `name=value` coppie aggiunto a `$JETTY_ARGS`
`JETTY_MODULES_ENABLE`		Elenco separato da virgole di moduli da attivare aggiungendoli a `$JETTY_ARGS`
`JETTY_MODULES_DISABLE`		Elenco separato da virgole di moduli da disattivare rimuovendoli da `$JETTY_BASE/start.d`
`JETTY_ARGS`		Argomenti passati all'elemento `start.jar` del molo. Eventuali argomenti utilizzati per la configurazione del molo personalizzato devono essere passati qui.
`JAVA_OPTS`		Argomenti di runtime JVM

Cloud Logging avanzato (beta)

Quando esegui l'applicazione nell'ambiente flessibile App Engine, puoi configurare Java Util logging per inviare i 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 come segue:

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 il test nel tuo ambiente locale, potresti utilizzare Google Cloud emulato anziché dai servizi Google Cloud remoti. Puoi utilizzare le seguenti opzioni 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 in locale, utilizza il comando Maven:

mvn jetty:run-exploded

Gradle

Segui le istruzioni per la creazione di un nuovo progetto Gradle per aggiungere il plug-in Gradle Gretty al tuo 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), esegui il deployment separatamente con il comando gcloud. Ad esempio:

gcloud app deploy cron.yaml

Maven

Utilizza 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 tuo file pom.xml specifica già il tuo ID progetto, non devi includere la proprietà -Dapp.deploy.projectId nel comando eseguito.

Gradle

Utilizza Gradle per eseguire il deployment dell'app:

gradle appengineDeploy

Personalizzazione del runtime Java 8 / Jetty 9

Non è necessario un Dockerfile per eseguire il deployment dell'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 direttive aggiuntive al Dockerfile per personalizzare il runtime Java. Consulta: Creazione di runtime personalizzati.

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