Questa pagina è stata tradotta dall'API Cloud Translation.

Ambiente di runtime Java 11/17

Il runtime Java è lo stack software responsabile dell'installazione del codice del servizio web e delle sue dipendenze e per l'esecuzione del servizio.

Per specificare Java 11/17 per l'ambiente standard di App Engine, dichiara il runtime nel file app.yaml. Ad esempio:

Java 17

runtime: java17

Java 11

runtime: java11

Prima di iniziare

Scarica l'ultima versione di Google Cloud CLI o aggiorna gcloud CLI alla versione attuale:
```
gcloud components update
```
Per eseguire il deployment utilizzando Maven, dovrai aggiungere il plug-in Maven per App Engine al file pom.xml:
```
<plugin>
   <groupId>com.google.cloud.tools</groupId>
   <artifactId>appengine-maven-plugin</artifactId>
   <version>2.4.4</version>
</plugin>
```
Altre opzioni per il deployment includono l'utilizzo del comando gcloud app deploy o del plug-in Gradle di App Engine.
Segui le istruzioni del framework dell'applicazione per configurare la build di un file JAR eseguibile.

Compatibilità con i framework

Con i runtime Java 11/17 di App Engine, puoi eseguire il deployment di file JAR eseguibili. I runtime non includono alcun framework di pubblicazione web, ovvero non è limitato a utilizzare framework o librerie basati su servlet. Utilizza le dipendenze native o gli stack di rete, ad esempio Netty Library.

Sono presenti hello world esempi che utilizzano framework web Java diffusi nel repository GitHub di Google Cloud:

Non sei limitato a questi framework e ti invitiamo a provare quello che preferisci, come Grails, Blade, Play!, Vaadin o jHipster.

Esegui il deployment dei progetti di origine Maven nei runtime Java 11/17

Puoi eseguire il deployment del tuo progetto Maven come codice sorgente e fare in modo che venga creato e sottoposto a deployment utilizzando i buildpack di Google Cloud.

Per eseguire il deployment di un progetto di progetto Maven come codice sorgente, vai alla directory di primo livello del progetto e digita:

gcloud app deploy pom.xml

I log di build e deployment verranno trasmessi in streaming e potrai consultare i log dettagliati nella sezione Cronologia di Cloud Build all'interno della console Cloud.

Utilizzo dei file eseguibili GraalVM

Il runtime Java dell'ambiente standard di App Engine supporta le esecuzioni di immagini native di GraalVM. Dopo aver compilato l'app Java 11/17 in un'immagine nativa di GraalVM, puoi utilizzare l'impostazione entrypoint nel file app.yaml per indirizzare all'eseguibile.

Ad esempio, un eseguibile con il nome file myexecutable potrebbe avere il seguente file di configurazione app.yaml:

runtime: java17 # or another supported runtime
entrypoint: ./myexecutable

Le librerie client di Google Cloud possono essere utilizzate per compilare le applicazioni come un'immagine nativa di GraalVM. Per maggiori informazioni, consulta la documentazione su come compilare le immagini native.

Versione Java

I runtime Java 11/17 utilizzano la release stabile più recente della versione specificata nel file app.yaml. App Engine si aggiorna automaticamente alla nuova versione di patch, ma non aggiornerà automaticamente la versione secondaria.

Ad esempio, è possibile eseguire il deployment dell'applicazione su Java 11.0.4 e aggiornarla automaticamente alla versione Java 11.0.5 in un deployment successivo della piattaforma gestita, ma non verrà aggiornata automaticamente in Java 12.

L'ambiente Open JDK del runtime

App Engine esegue le app Java 11/17 in un container protetto da gVisor su una distribuzione Ubuntu Linux aggiornata e dal relativo openjdk-11-jdk per Java 11 o openjdk-17-jdk per il runtime Java 17.

Java 11 viene eseguito su Ubuntu 18.04
Java 17 viene eseguito su Ubuntu 22.04

App Engine mantiene l'immagine di base e aggiorna il pacchetto OpenJDK 11 e OpenJDK 17, senza che tu debba eseguire nuovamente il deployment dell'app.

L'app di cui hai eseguito il deployment si trova nella directory /workspace del runtime. È accessibile anche tramite un link simbolico all'indirizzo /srv.

Release Java di App Engine

Tutti gli artefatti rilasciati che iniziano con la versione 2.x.x utilizzano il meccanismo di rilascio dell'open source. Gli elementi rilasciati che iniziano con la versione 1.9.9xx o precedente utilizzano il sistema di compilazione interno. Per ulteriori dettagli, consulta il repository GitHub.

Dipendenze

Per saperne di più sulla dichiarazione e sulla gestione delle dipendenze, consulta la sezione Specificare le dipendenze.

Avvio dell'applicazione

Framework come Spring Boot, Micronaut e Ktor creano un'immagine uber JAR eseguibile per impostazione predefinita. Se il file di build Maven o Gradle produce un Uber JAR eseguibile, il runtime avvia l'applicazione eseguendo un'applicazione Uber JAR.

In alternativa, App Engine utilizzerà i contenuti del campo facoltativo entrypoint nel file app.yaml. Ad esempio:

runtime: java17 # or another supported runtime
entrypoint: java -Xmx64m -jar YOUR-ARTIFACT.jar

Dove deve essere creato l'esempio di jar dell'applicazione YOUR-ARTIFACT.jar:

Essere nella directory principale con il file app.yaml.
Contengono una voce Main-Class nel file di metadati META-INF/MANIFEST.MF.
Facoltativamente, contiene una voce Class-Path con un elenco di percorsi relativi ad altri jar dipendenti. che verranno caricati automaticamente con l'applicazione.

Perché l'app riceva richieste HTTP, il punto di ingresso deve avviare un server web in ascolto sulla porta specificata dalla variabile di ambiente PORT. Il valore della variabile di ambiente PORT viene impostato in modo dinamico dall'ambiente di pubblicazione di App Engine. Questo valore non può essere impostato nella sezione env_variables del file app.yaml.

Con un punto di ingresso personalizzato, puoi creare e pacchettizzare la tua applicazione come file JAR sottile che contiene solo il codice dell'applicazione e le dipendenze dirette. Quando esegui il deployment della tua applicazione, il plug-in App Engine carica solo i file che sono stati modificati, anziché l'intero pacchetto JAR Uber.

Assicurati di utilizzare la variabile di ambiente PORT

Se nei file di log dell'app vengono visualizzati avvisi sulla porta 8080 e NGINX, il server web dell'app è in ascolto sulla porta 8080 predefinita. Questo impedisce ad App Engine di utilizzare il suo livello NGINX per comprimere le risposte HTTP. Ti consigliamo di configurare il server web per rispondere alle richieste HTTP sulla porta specificata dalla variabile di ambiente PORT, in genere 8081. Ad esempio:

appengine-java11/http-server/src/main/java/com/example/appengine/Main.java

Visualizza su GitHub

/*
 * Copyright 2019 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.example.appengine;

import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;

public class Main {

  public static void main(String[] args) throws IOException {
    // Create an instance of HttpServer bound to port defined by the
    // PORT environment variable when present, otherwise on 8080.
    int port = Integer.parseInt(System.getenv().getOrDefault("PORT", "8080"));
    HttpServer server = HttpServer.create(new InetSocketAddress(port), 0);

    // Set root URI path.
    server.createContext("/", (var t) -> {
      byte[] response = "Hello World!".getBytes();
      t.sendResponseHeaders(200, response.length);
      try (OutputStream os = t.getResponseBody()) {
        os.write(response);
      }
    });

    // Create a second URI path.
    server.createContext("/foo", (var t) -> {
      byte[] response = "Foo!".getBytes();
      t.sendResponseHeaders(200, response.length);
      try (OutputStream os = t.getResponseBody()) {
        os.write(response);
      }
    });

    server.start();
  }
}

Compatibilità con le versioni precedenti di Java

Per le differenze tra i runtime Java 8 e Java 11/17, consulta Differenze principali tra i runtime Java 8 e Java 11/17.

Variabili di ambiente

Le seguenti variabili di ambiente sono impostate dal runtime:

Variabile di ambiente	Descrizione
`GAE_APPLICATION`	L'ID della tua applicazione App Engine. Questo ID è preceduto da "`region code`~", ad esempio "e~" per le applicazioni implementate in Europa.
`GAE_DEPLOYMENT_ID`	L'ID del deployment attuale.
`GAE_ENV`	L'ambiente App Engine. Imposta su `standard`.
`GAE_INSTANCE`	L'ID dell'istanza su cui è attualmente in esecuzione il servizio.
`GAE_MEMORY_MB`	La quantità di memoria disponibile per il processo dell'applicazione, in MB.
`GAE_RUNTIME`	Il runtime specificato nel file `app.yaml`.
`GAE_SERVICE`	Il nome del servizio specificato nel file `app.yaml`. Se non viene specificato alcun nome del servizio, viene impostato su `default`.
`GAE_VERSION`	L'etichetta della versione attuale del tuo servizio.
`GOOGLE_CLOUD_PROJECT`	L'ID del progetto Cloud associato alla tua applicazione.
`PORT`	La porta che riceve le richieste HTTP.
`NODE_ENV` (disponibile solo nel runtime di Node.js)	Impostato su `production` quando viene eseguito il deployment del servizio.

Puoi definire ulteriori variabili di ambiente nel file app.yaml, ma non puoi eseguire l'override dei valori riportati sopra, ad eccezione di NODE_ENV.

HTTPS e proxy di forwarding

App Engine termina le connessioni HTTPS al bilanciatore del carico e inoltra le richieste alla tua applicazione. Alcune applicazioni devono determinare l'IP e il protocollo della richiesta originali. L'indirizzo IP dell'utente è disponibile nell'intestazione X-Forwarded-For standard. Le applicazioni che richiedono queste informazioni devono configurare il proprio framework web per considerare attendibile il proxy.

Accesso al file system

Il runtime include una directory /tmp scrivibile, con tutte le altre directory che hanno accesso di sola lettura. La scrittura in /tmp richiede la memoria di sistema.

Server di metadati

Ogni istanza della tua applicazione può utilizzare il server di metadati App Engine per eseguire query sulle informazioni relative all'istanza e al progetto.

Puoi accedere al server dei metadati tramite i seguenti endpoint:

http://metadata
http://metadata.google.internal

Le richieste inviate al server di metadati devono includere l'intestazione della richiesta Metadata-Flavor: Google. Questa intestazione indica che la richiesta è stata inviata con l'intenzione di recuperare i valori dei metadati.

Nella tabella seguente sono elencati gli endpoint in cui puoi inviare richieste HTTP per metadati specifici:

Endpoint metadati	Descrizione
`/computeMetadata/v1/project/numeric-project-id`	Il numero del progetto assegnato al progetto.
`/computeMetadata/v1/project/project-id`	L'ID progetto assegnato al progetto.
`/computeMetadata/v1/instance/region`	La regione in cui è in esecuzione l'istanza.
`/computeMetadata/v1/instance/service-accounts/default/aliases`
`/computeMetadata/v1/instance/service-accounts/default/email`	L'indirizzo email dell'account di servizio predefinito assegnato al tuo progetto.
`/computeMetadata/v1/instance/service-accounts/default/`	Elenca tutti gli account di servizio predefiniti per il tuo progetto.
`/computeMetadata/v1/instance/service-accounts/default/scopes`	Elenca tutti gli ambiti supportati per gli account di servizio predefiniti.
`/computeMetadata/v1/instance/service-accounts/default/token`	Restituisce il token di autenticazione che può essere utilizzato per autenticare la tua applicazione in altre API Google Cloud.

Ad esempio, per recuperare l'ID progetto, invia una richiesta a http://metadata.google.internal/computeMetadata/v1/project/project-id.