Nota: la fine del supporto di Java 8 è stata raggiunta il 31 gennaio 2024. Le applicazioni Java 8 esistenti continueranno a essere eseguite e a ricevere traffico. Tuttavia, App Engine potrebbe bloccare il rideployment delle applicazioni che utilizzano i runtime dopo la data di fine del supporto. Ti consigliamo di eseguire la migrazione all'ultima versione di Java supportata.

Migrazione al plug-in Gradle basato sulla gcloud CLI

Se in precedenza hai utilizzato il plug-in basato su SDK Java App Engine (com.google.appengine.appengine-gradle) e vuoi passare al nuovo Google Cloud CLI, esegui la migrazione al plug-in basato su gcloud CLI (com.google.cloud.tools.appengine-gradle).

Vantaggi del plug-in basato su gcloud CLI

L'upgrade al nuovo plug-in offre i seguenti vantaggi:

Utilizza le stesse credenziali di autenticazione di tutti gli altri comandi basati sulla gcloud CLI, prodotti dal flusso gcloud auth login standard.
Supporta l'ambiente flessibile di App Engine.
Aggiorna automaticamente il server di sviluppo locale come parte del flusso di aggiornamento standard gcloud CLI.
Supporta il deployment delle configurazioni dei servizi App Engine (cron, code, dos, invio) indipendentemente dal servizio.

Differenze rilevanti

Prima di eseguire la migrazione, tieni presente queste importanti differenze:

Dipendenza gcloud CLI: Il vecchio plug-in viene eseguito senza dipendenze specifiche dell'ambiente locale, oltre a Java, ma il nuovo plug-in richiede che tu abbia installato gcloud CLI.
Nessuna generazione di documenti di rilevamento degli endpoint: Il nuovo plug-in non genera documenti di rilevamento di Endpoints, una funzionalità disponibile in un plug-in separato. L'esecuzione del backend di endpoint non richiede più la generazione di questo file in un passaggio di build poiché il server ora lo genera in fase di runtime. Dovresti usare il nuovo plug-in solo se hai bisogno di generare librerie client come iOS o Android. Scopri di più sui nuovi plug-in, consulta la guida Migrazione a Endpoints Frameworks per App Engine.
Il formato file EAR non è più supportato: Il nuovo plug-in non supporta più il formato file EAR per l'esecuzione e il deployment di più servizi contemporaneamente.
Nuovo comando di deployment: Il plug-in precedente chiama il comando appcfg per eseguire il deployment delle applicazioni, mentre il nuovo plug-in esegue il deployment utilizzando la nuova interfaccia a riga di comando gcloud.
Il miglioramento Datanucleus JPA/JDO deve essere configurato manualmente: Se il tuo progetto utilizza il miglioramento Datanucleus JPA/JDO di gradle-appengine-plugin, devi configurare manualmente il miglioramento Datanucleus dopo essere passato al plug-in basato su gcloud CLI. Esamina un esempio da Stackoverflow.
Android Studio non è supportato: Puoi cambiare il tuo progetto Android Studio per utilizzare il nuovo plug-in, ma il server di sviluppo e il supporto per il deployment di Android Studio App Engine non funzionano con questo nuovo plug-in. Per eseguire ed eseguire il deployment dell'app, devi richiamare Gradle direttamente.

È supportato l'utilizzo di file di configurazione XML, ma non di YAML.

Migrazione al nuovo plug-in

Rimuovi la vecchia configurazione gradle-appengine-plugin e le importazioni dal file build.gradle.

Aggiungi il nuovo plug-in a classpath della sezione buildscript del file build.gradle:

buildscript {
    repositories {
        mavenCentral()
    }

    dependencies {
        classpath 'com.google.cloud.tools:appengine-gradle-plugin:2.0.1'
    }
}

Nella root del servizio, esegui questo comando per verificare di poter eseguire la tua app in locale:
```
gradle appengineRun
```
Nella sezione buildscript del file build.gradle, configura il deployment specificando l'ID e la versione del progetto:
```
appengine {
    deploy {
        version = 'v1'
        project = "your GCP project ID"
    }
}
```
I nuovi strumenti ignorano gli elementi dell'applicazione e della versione nel file appengine-web.xml.
Nella root del servizio, esegui questo comando per verificare di poter eseguire il deployment dell'applicazione:
```
gradle appengineDeploy
```

Migrazione delle configurazioni multi-servizio basate su EAR

Il nuovo plug-in non supporta i pacchetti EAR. Supporta invece l'esecuzione locale di più servizi senza passaggi di pacchettizzazione speciali.

Per eseguire la migrazione del tuo progetto Gradle basato su EAR:

Scegli un servizio principale responsabile dell'esecuzione del resto dei servizi. Devi selezionare il servizio predefinito, che può però essere uno qualsiasi dei servizi che vengono eseguiti insieme.

Nella configurazione di appengine, modifica la voce run.services in modo da includere tutti i servizi che devono essere eseguiti dal server di sviluppo locale.

Esempio di struttura di un progetto:

../{projectRoot}/
  build.gradle
  settings.gradle (includes default-service & secondary-service)
       {your-default-service}/build.gradle {includes appengine-gradle-plugin}
          ….
       {your-default-service}/src/main/webapp/WEB-INF/appengine-web.xml
       {your-secondary-service}build.gradle {includes appengine-gradle-plugin}
          ….
       {your-secondary-service}/src/main/webapp/WEB-INF/appengine-web.xml

Un buildscript build.gradle di esempio:

appengine {
    run {
        // configure the app to point to the right service directories
        services = [
                projectAsService(project),
                projectAsService(":another-module")
        ]
    }
}

// helper method to obtain correct directory and set up dependencies
def getExplodedAppDir(Project serverProject) {
    // if not 'this' module, then do some setup.
    if (serverProject != project) {
        // make sure we evaluate other modules first so we get the right value
        evaluationDependsOn(serverProject.path)
        // make sure we build "run" depends on the other modules exploding wars
        project.tasks.appengineRun.dependsOn serverProject.tasks.explodeWar
    }
    return serverProject.tasks.explodeWar.explodedAppDirectory
}

Confronto tra i comandi Gradle basati su SDK di App Engine e gcloud CLI

La tabella seguente mostra i diversi modi in cui viene richiamato il plug-in Gradle, a seconda che utilizzi il plug-in Gradle basato su SDK App Engine o il plug-in Gradle gcloud CLI-based.

Azione	Basato su SDK di App Engine	gcloud basato su interfaccia a riga di comando
Esegui l'app localmente	`appengine:devserver`	`appengineRun`
Eseguire il deployment di una nuova app, una nuova versione o un nuovo servizio.	`appengine:update`	`appengineDeploy`
Imposta la versione predefinita dell'applicazione.	`appengine:set_default_version`	gcloud app services set-traffic o gcloud app version migration
Aggiornamento dei cron job dell'applicazione.	`appengine:update_cron`	`appengineDeployCron`
Aggiorna la configurazione di invio dell'applicazione.	`appengine:update_dispatch`	`appengineDeployDispatch`
Aggiorna la configurazione della protezione DoS dell'applicazione.	`appengine:update_dos`	`appengineDeployDos`
Aggiornare le definizioni delle coda di attività delle applicazioni.	`appengine:update_queues`	`appengineDeployQueue`
Aggiorna indici Datastore.	`appengine:update_indexes`	`appengineDeployIndex`
Elimina gli indici inutilizzati dall'applicazione.	`appengine:vacuum_indexes`	Pulizia degli indici del datastore gcloud
Avvia la versione del modulo specificata.	`appengine:start_module_version`	Inizio delle versioni dell'app gcloud
Arresta la versione del modulo specificata.	`appengine:stop_module_version`	arresto delle versioni dell'app gcloud
Esegui il rollback di un aggiornamento in corso.	`appengine:rollback`	gcloud app version start, gcloud app version stop

Passaggi successivi

Ora che hai eseguito correttamente la migrazione al nuovo plug-in, puoi testare ed deploy dell'applicazione.