Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Ambiente di runtime Java

Il runtime Java è lo stack software che installa il codice del servizio web e le relative dipendenze ed esegue il servizio.

Dichiara il runtime Java per l'ambiente standard di App Engine nel file app.yaml. Ad esempio:

runtime: javaVERSION

Dove VERSION è il numero di versione MAJOR di Java. Ad esempio, per utilizzare l'ultima versione di Java, Java 25, specifica 25.

Per altre versioni di Java supportate e la versione di Ubuntu corrispondente alla tua versione di Java, consulta la pianificazione del supporto del runtime.

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, devi aggiungere il plug-in Maven di App Engine al file pom.xml:
```
<plugin>
   <groupId>com.google.cloud.tools</groupId>
   <artifactId>appengine-maven-plugin</artifactId>
   <version>2.8.1</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 per il framework dell'applicazione per configurare la build di un file JAR eseguibile.

Compatibilità del framework

Con il runtime Java di App Engine, puoi eseguire il deployment di file JAR eseguibili. I runtime non includono alcun framework di pubblicazione web, il che significa che non sei limitato all'utilizzo di framework o librerie basati su servlet. Utilizza le dipendenze native o gli stack di rete, come la libreria Netty.

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

Eseguire il deployment dei progetti di origine Maven nel runtime Java

Puoi eseguire il deployment del progetto Maven come codice sorgente e farlo creare ed eseguire il deployment utilizzando i buildpack di Google Cloud.

Per eseguire il deployment di un 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 visualizzare i log dettagliati nella sezione della cronologia di Cloud Build nella Google Cloud console.

Utilizzare gli eseguibili GraalVM

Il runtime Java dell'ambiente standard di App Engine supporta gli eseguibili delle immagini native di GraalVM. Dopo aver compilato l'app Java in un'immagine nativa di GraalVM, puoi utilizzare l'impostazione entrypoint nel file app.yaml per puntare all'eseguibile.

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

runtime: 25 # or another supported runtime version.
entrypoint: ./myexecutable

Google Cloud Le librerie client possono essere utilizzate per compilare le applicazioni come immagine nativa di GraalVM. Per saperne di più, consulta la documentazione su come compilare le immagini native.

Versione di Java

L'ultima versione di Java supportata è la 25. Il runtime Java utilizza l'ultima release stabile della versione specificata nel file app.yaml. App Engine esegue automaticamente l'aggiornamento alle nuove versioni di patch release, ma non esegue automaticamente l'aggiornamento della versione secondaria.

Ad esempio, la tua applicazione potrebbe essere sottoposta a deployment in Java 21.0.4 e aggiornata automaticamente alla versione Java 21.0.5 in un deployment successivo della piattaforma gestita, ma non verrà aggiornata automaticamente a Java 22.

Per scoprire come eseguire l'upgrade della versione di Java, consulta Eseguire l'upgrade di un'applicazione esistente.

L'ambiente OpenJDK del runtime

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

Per le versioni di Ubuntu supportate per la tua versione di Java, consulta la pianificazione del supporto del runtime.

App Engine gestisce l'immagine di base e aggiorna il pacchetto OpenJDK 17 e OpenJDK 21, senza richiedere il nuovo deployment dell'app.

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

Release di Java di App Engine

Tutti gli artefatti rilasciati che iniziano con la versione 2.x.x utilizzano il meccanismo di release open source. Per maggiori dettagli, consulta il repository GitHub.

Dipendenze

Per saperne di più sulla dichiarazione e sulla gestione delle dipendenze, consulta Specifica delle dipendenze.

Avvio dell'applicazione

Framework come Spring Boot, Micronaut e Ktor creano un 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: java25 # or another supported runtime
entrypoint: java -Xmx64m -jar YOUR-ARTIFACT.jar

Dove il JAR dell'applicazione YOUR-ARTIFACT.jar di esempio deve:

Trovarsi nella directory root con il file app.yaml.
Contenere una voce Main-Class nel file di metadati META-INF/MANIFEST.MF.
Facoltativamente, contenere una voce Class-Path con un elenco di percorsi relativi ad altri JAR dipendenti. Questi verranno caricati automaticamente con l'applicazione.

Affinché la tua 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 PORT variabile di ambiente viene impostato dinamicamente 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 impacchettare l'applicazione come un file JAR sottile che contiene solo il codice dell'applicazione e le dipendenze dirette. Quando esegui il deployment dell'applicazione, il plug-in App Engine caricherà solo i file modificati, anziché l'intero pacchetto uber JAR.

Assicurati di utilizzare la variabile di ambiente PORT

Se nei file di log dell'app vengono visualizzati avvisi relativi alla porta 8080 e a NGINX, significa che il server web dell'app è in ascolto sulla porta predefinita 8080. In questo modo, App Engine non può utilizzare il livello NGINX per comprimere le risposte HTTP. Ti consigliamo di configurare il server web in modo che risponda alle richieste HTTP sulla porta specificata dalla variabile di ambiente PORT, in genere 8081. Ad esempio:

/*
 * 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 Java 8 e l'ultima versione di Java supportata, consulta Eseguire la migrazione da Java 8 al runtime Java più recente.

Variabili di ambiente

Le seguenti variabili di ambiente sono impostate dal runtime:

Variabile di ambiente	Descrizione
`GAE_APPLICATION`	L'ID dell'applicazione App Engine. Questo ID è preceduto da "`region code`~" ad esempio "e~" per le applicazioni di cui è stato eseguito il deployment in Europa.
`GAE_DEPLOYMENT_ID`	L'ID del deployment corrente.
`GAE_ENV`	L'ambiente App Engine. Impostato 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 servizio.
`GOOGLE_CLOUD_PROJECT`	L' Google Cloud ID progetto associato all'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 variabili di ambiente aggiuntive nel file app.yaml file, ma i valori sopra riportati non possono essere sostituiti, ad eccezione di NODE_ENV.

HTTPS e proxy di forwarding

App Engine termina le connessioni HTTPS nel bilanciatore del carico e inoltra le richieste all'applicazione. Alcune applicazioni devono determinare l'IP e il protocollo della richiesta originale. L'indirizzo IP dell'utente è disponibile nell'intestazione standard X-Forwarded-For. Le applicazioni che richiedono queste informazioni devono configurare il framework web in modo che consideri attendibile il proxy.

Accesso al filesystem

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

Server di metadati

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

Puoi accedere al server di 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.

La tabella seguente elenca gli endpoint in cui puoi effettuare richieste HTTP per metadati specifici:

Endpoint dei metadati	Descrizione
`/computeMetadata/v1/project/numeric-project-id`	Il numero di 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 del account di servizio predefinito assegnato al progetto.
`/computeMetadata/v1/instance/service-accounts/default/`	Elenca tutti i service account predefiniti per il progetto.
`/computeMetadata/v1/instance/service-accounts/default/scopes`	Elenca tutti gli ambiti supportati per i service account predefiniti.
`/computeMetadata/v1/instance/service-accounts/default/token`	Restituisce il token di autenticazione che può essere utilizzato per autenticare l'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.