Java 8 è deprecato. Non potrai eseguire il deployment di applicazioni Java 8, anche se la tua organizzazione ha utilizzato in precedenza una policy dell'organizzazione per riattivare i deployment di runtime legacy. Le tue applicazioni Java 8 esistenti continueranno a essere eseguite e a ricevere traffico. Ti consigliamo di eseguire la migrazione all'ultima versione supportata di Java.

Migrazione al plug-in Gradle basato sull'interfaccia a riga di comando gcloud

Se in precedenza utilizzavi il plug-in basato su Java App Engine SDK (com.google.appengine.appengine-gradle) e vuoi passare alla nuova 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 su gcloud CLI, che vengono prodotte dal flusso standard gcloud auth login.
Supporta l'ambiente flessibile di App Engine.
Aggiorna automaticamente il server di sviluppo locale nell'ambito del flusso di aggiornamento standard di gcloud CLI.
Supporta il deployment delle configurazioni del servizio App Engine (cron, code, dos, dispatch), indipendentemente dal tuo servizio.

Differenze notevoli

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

Dipendenza da gcloud CLI: Il vecchio plug-in viene eseguito senza dipendenze specifiche dall'ambiente locale, oltre a Java, ma il nuovo plug-in richiede l'installazione di gcloud CLI.
Nessuna generazione del documento di rilevamento di Endpoints: Il nuovo plug-in non genera documenti di rilevamento degli endpoint, una funzionalità disponibile in un plug-in separato. L'esecuzione del backend Endpoints non richiede più la generazione di questo file in un passaggio di build, poiché ora il server lo genera in fase di runtime. Devi utilizzare il nuovo plug-in solo se devi generare librerie client, ad esempio per iOS o Android. Scopri di più sui nuovi plug-in consultando 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 vecchio plug-in chiama il comando appcfg per eseguire il deployment delle applicazioni, mentre il nuovo plug-in esegue il deployment utilizzando la nuova gcloud CLI.
Il miglioramento JPA/JDO Datanucleus deve essere configurato manualmente: Se il tuo progetto utilizza il miglioramento JPA/JDO Datanucleus di gradle-appengine-plugin, devi configurare manualmente il miglioramento Datanucleus dopo il passaggio al plug-in basato su gcloud CLI. Vedi un esempio di Stack Overflow.
Android Studio non è supportato: Puoi passare al nuovo plug-in per il tuo progetto Android Studio, 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.

L'utilizzo dei file di configurazione XML è supportato, ma non quello dei file 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 radice del servizio, esegui questo comando per verificare di poter eseguire l'app localmente:
```
gradle appengineRun
```
Nella sezione buildscript del file build.gradle, configura la distribuzione specificando l'ID progetto e la versione:
```
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 radice del servizio, esegui questo comando per verificare di poter eseguire il deployment dell'applicazione:
```
gradle appengineDeploy
```

Migrazione di configurazioni multi-servizio basate su EAR

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

Per eseguire la migrazione del progetto Gradle basato su EAR:

Scegli un servizio principale che sarà responsabile dell'esecuzione degli altri servizi. Devi selezionare il servizio predefinito, ma può essere uno qualsiasi dei servizi 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.

Una struttura di progetto di esempio:

../{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 esempio di build.gradle buildscript:

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
}

Comandi Gradle basati su gcloud CLI e su App Engine SDK

La seguente tabella mostra i diversi modi in cui richiami il plug-in Gradle, a seconda che utilizzi il plug-in Gradle basato sull'SDK App Engine o il plug-in Gradle basato sulla CLI gcloud.

Azione	Basato sull'SDK di App Engine	Basato su gcloud CLI
Esegui l'app localmente	`appengine:devserver`	`appengineRun`
Esegui il deployment di una nuova app, versione o servizio.	`appengine:update`	`appengineDeploy`
Imposta la versione predefinita dell'applicazione.	`appengine:set_default_version`	gcloud app services set-traffic o gcloud app versions migrate
Aggiorna i cron job dell'applicazione.	`appengine:update_cron`	`appengineDeployCron`
Aggiorna la configurazione di distribuzione delle applicazioni.	`appengine:update_dispatch`	`appengineDeployDispatch`
Aggiorna la configurazione della protezione DoS dell'applicazione.	`appengine:update_dos`	`appengineDeployDos`
Aggiorna le definizioni della coda di attività dell'applicazione.	`appengine:update_queues`	`appengineDeployQueue`
Aggiorna gli indici Datastore.	`appengine:update_indexes`	`appengineDeployIndex`
Elimina gli indici inutilizzati dall'applicazione.	`appengine:vacuum_indexes`	gcloud datastore indexes cleanup
Avvia la versione del modulo specificata.	`appengine:start_module_version`	gcloud app versions start
Arresta la versione del modulo specificata.	`appengine:stop_module_version`	gcloud app versions stop
Esegui il rollback di un aggiornamento in corso.	`appengine:rollback`	gcloud app versions start, gcloud app versions stop

Passaggi successivi

Ora che hai eseguito correttamente la migrazione al nuovo plug-in, puoi testare e implementare la tua applicazione.

Migrazione al plug-in Gradle basato sull'interfaccia a riga di comando gcloud Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.