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

Questa pagina è stata tradotta dall'API Cloud Translation.

Migrazione al plug-in Gradle basato su gcloud CLI

Se in precedenza utilizzavi il plug-in basato su Java App Engine SDK (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 sull'interfaccia a riga di comando gcloud

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

Utilizza le stesse credenziali di autenticazione di tutte le altre gcloud CLI generati dal comando gcloud auth login standard flusso di lavoro.
Supporta l'ambiente flessibile di App Engine.
Aggiorna automaticamente il server di sviluppo locale nell'ambito della configurazione Flusso di aggiornamento della gcloud CLI.
Supporta il deployment del servizio App Engine (cron, code, dos, invio) di archiviazione, indipendentemente dal servizio.

Differenze significative

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

Dipendenza gcloud CLI: Il vecchio plug-in viene eseguito senza dipendenze specifiche dell'ambiente locale, oltre a Java, ma il nuovo plug-in richiede l'utilizzo del gcloud CLI installato.
Nessuna generazione del documento di rilevamento di Endpoints: Il nuovo plug-in non genera documenti di rilevamento di Endpoints, disponibile in un plug-in separato. Esecuzione degli endpoint non richiede più di generare questo file in un passaggio di build come server ora lo genera in fase di runtime. Dovresti usare il nuovo plug-in solo se hai bisogno per generare librerie client come iOS o Android. Scopri di più sulle i nuovi plug-in esaminando la documentazione sulla migrazione a Endpoints Frameworks per App Engine guida.
Il formato file EAR non è più supportato: Il nuovo plug-in non supporta più 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 interfaccia a riga di comando gcloud.
Il miglioramento del 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 il passaggio Plug-in basato su gcloud CLI. Guarda un esempio di Stackoverflow.
Android Studio non è supportato: Puoi impostare il progetto Android Studio in modo che utilizzi il nuovo plug-in, ma il supporto per il server di sviluppo e il deployment di App Engine di Android Studio non funziona con questo nuovo plug-in. Per eseguire ed eseguire il deployment dell'app, devi invocare direttamente Gradle.

L'utilizzo di file di configurazione XML è supportato, ma non YAML.

Migrazione al nuovo plug-in

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

Aggiungi il nuovo plug-in a classpath dei file build.gradle Sezione buildscript:

buildscript {
    repositories {
        mavenCentral()
    }

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

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

Migrazione di configurazioni multiservizio basate su EAR

Il nuovo plug-in non supporta la pacchettizzazione EAR. Supporta invece l'esecuzione di più servizi localmente senza alcuna procedura di imballaggio speciale.

Per eseguire la migrazione del progetto Gradle basato su EAR:

Scegli un servizio principale che sarà responsabile dell'esecuzione del resto del i servizi di machine learning. Devi selezionare il servizio predefinito, ma può essere uno qualsiasi dei che vengono eseguiti insieme.

Nella configurazione 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 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
}

Comandi Gradle basati su SDK App Engine e comandi Gradle basati sull'interfaccia a riga di comando gcloud

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

Azione	Basato su SDK 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 dell'applicazione predefinita.	`appengine:set_default_version`	gcloud app services set-traffic o gcloud app version migrate
Aggiorna i 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`
Aggiorna le definizioni delle code delle attività dell'applicazione.	`appengine:update_queues`	`appengineDeployQueue`
Aggiorna gli indici Datastore.	`appengine:update_indexes`	`appengineDeployIndex`
Elimina gli indici inutilizzati dall'applicazione.	`appengine:vacuum_indexes`	Pulizia degli indici datastore gcloud
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 version 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 test e deployment la tua applicazione.