Utilizzo di Gradle e del plug-in App Engine

Puoi usare Gradle, un sistema di automazione flessibile delle build, dichiarativo e utilizzato per automatizzare creazione, test, pubblicazione e deployment. In questa pagina viene spiegato come utilizzare Gradle con un progetto App Engine nell'ambiente standard.

Prima di iniziare

Installa e configura i seguenti prerequisiti:

Configurazione e convalida del progetto Google Cloud

Devi configurare il progetto Google Cloud e installare gcloud CLI:

  1. Usa la console Google Cloud per creare e configurare il tuo progetto Google Cloud:

    Vai ad App Engine

    1. Seleziona o crea un nuovo progetto Google Cloud.
    2. Segui le istruzioni per assicurarti che un'applicazione App Engine esiste e la fatturazione è abilitata:
      1. Se devi creare un'applicazione App Engine per il tuo progetto, ti viene chiesto di selezionare la regione in cui vuoi che si trovi l'applicazione.
      2. Segui le istruzioni per creare un nuovo account di fatturazione o seleziona un account esistente.
    3. La Dashboard si apre dopo che l'applicazione App Engine ha e la fatturazione è stata abilitata nel progetto.

  2. Non è necessario installare l'interfaccia a riga di comando gcloud perché il plug-in installa automaticamente l'SDK quando necessario.

Creazione di un nuovo progetto Gradle

Puoi creare un nuovo progetto Gradle da zero utilizzando la shell. In alternativa, per provare il plug-in, puoi scaricare, eseguire localmente e implementare il progetto Hello World.

  1. Crea ed entra in una nuova directory.

  2. Per inizializzare un nuovo progetto:

    gradle init --type java-library;
mkdir -p src/main/webapp/WEB-INF;
rm src/main/java/Library.java src/test/java/LibraryTest.java

  3. Aggiungi quanto segue al file build.gradle per aggiungere attività Gradle di App Engine, repository Maven, il plug-in Gradle di App Engine, le dipendenze e la configurazione delle attività:

    buildscript {    // Configuration for building
  repositories {
    jcenter()    // Bintray's repository - a fast Maven Central mirror & more
    mavenCentral()
  }
  dependencies {
    classpath 'com.google.cloud.tools:appengine-gradle-plugin:2.5.0' // If a newer version is available, use it
  }
}

repositories {   // repositories for Jar's you access in your code
  maven {
    url 'https://oss.sonatype.org/content/repositories/snapshots' // SNAPSHOT repository (if needed)
  }
  mavenCentral()
  jcenter()
}

apply plugin: 'java'                              // standard Java tasks
apply plugin: 'war'                               // standard Web Archive plugin
apply plugin: 'com.google.cloud.tools.appengine'  // App Engine tasks

dependencies {
  implementation 'com.google.appengine:appengine-api-1.0-sdk:+'  // Latest App Engine Api's
  providedCompile 'javax.servlet:javax.servlet-api:3.1.0'

  implementation 'jstl:jstl:1.2'

// Add your dependencies here.
//  implementation 'com.google.cloud:google-cloud:+'   // Latest Cloud API's http://googlecloudplatform.github.io/google-cloud-java

  testImplementation 'junit:junit:4.13.2'
  testImplementation 'com.google.truth:truth:1.1.5'
  testImplementation 'org.mockito:mockito-core:4.11.0'

  testImplementation 'com.google.appengine:appengine-testing:+'
  testImplementation 'com.google.appengine:appengine-api-stubs:+'
  testImplementation 'com.google.appengine:appengine-tools-sdk:+'
}

// Always run unit tests
appengineDeploy.dependsOn test
appengineStage.dependsOn test

appengine {  // App Engine tasks configuration
  deploy {   // deploy configuration
    projectId = System.getenv('GOOGLE_CLOUD_PROJECT')
    version = '1'
  }
}

test {
  useJUnit()
  testLogging.showStandardStreams = true
  beforeTest { descriptor ->
     logger.lifecycle("test: " + descriptor + "  Running")
  }

  onOutput { descriptor, event ->
     logger.lifecycle("test: " + descriptor + ": " + event.message )
  }
  afterTest { descriptor, result ->
    logger.lifecycle("test: " + descriptor + ": " + result )
  }
}

group   = "com.example.appenginej8"        // Generated output GroupId
version = "1.0-SNAPSHOT"       // Version in generated output

sourceCompatibility = 1.8     // App Engine Flexible uses Java 8
targetCompatibility = 1.8     // App Engine Flexible uses Java 8

  4. Devi anche aggiungere i seguenti file al progetto utilizzando un editor di testo o un ambiente di sviluppo integrato (IDE):

Consulta File di configurazione per una panoramica di un progetto Java App Engine.

Download dell'app Hello World

  1. Clona il repository dell'app di esempio Hello World sulla tua macchina locale:

    git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git

    In alternativa, puoi scaricare il sample come file ZIP ed estrarlo.

  2. Passa alla directory che contiene il codice di esempio:

    cd java-docs-samples/appengine-java8/helloworld

Testare l'applicazione con il server di sviluppo

  1. Per accedere alle risorse Google dal tuo progetto quando vengono eseguite localmente: imposta le credenziali predefinite dell'applicazione eseguendo:

    gcloud auth application-default login

  2. Passa alla directory principale dell'applicazione.

  3. Durante la fase di sviluppo, puoi eseguire e testare l'applicazione in qualsiasi momento sul server di sviluppo richiamando Gradle:

    gradle appengineRun

    In alternativa, puoi eseguire Gradle senza installarlo utilizzando il wrapper Gradle.

  4. Attendi l'avvio del server. Il server viene avviato con l'applicazione in esecuzione quando visualizzi un messaggio simile al seguente:

    :compileJava
:processResources NO-SOURCE
:classes
:war
:explodeWar
:assemble
:appengineRun
2018-06-05 22:50:46.231:INFO::main: Logging initialized @321ms
Jun 06, 2018 2:50:49 AM com.google.appengine.tools.development.AbstractModule startup
INFO: Module instance default is running at http://localhost:8080/
Jun 06, 2018 2:50:49 AM com.google.appengine.tools.development.AbstractModule startup
INFO: The admin console is running at http://localhost:8080/_ah/admin
Jun 05, 2018 10:50:49 PM com.google.appengine.tools.development.DevAppServerImpl doStart
INFO: Dev App Server is now running

  5. Guarda la tua app in esecuzione su http://127.0.0.1:8080.

Debug sul server di sviluppo

Per eseguire il debug di un'applicazione in esecuzione in locale, imposta la proprietà jvmFlags per attivare il debug sulla JVM sottostante, ad esempio:

    appengine {
      run {
        jvmFlags = ['-Xdebug', '-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5005']
      }
    }

Attiva il ricaricamento a caldo dell'applicazione

Il ricaricamento a caldo è la possibilità di aggiornare uno o più classi di un'applicazione attualmente in esecuzione senza arrestare l'ambiente. Per attivare le notifiche a caldo ricarica:

  • Devi indicare al server locale di eseguire la scansione delle modifiche:

    appengine {
  run {
    automaticRestart = true
  }
}

  • Mentre l'app è in esecuzione, esegui l'attività explodeWar per copiare le modifiche direttamente nell'app esplosa e propagare le modifiche all'applicazione un'applicazione.

Deployment dell'applicazione

Per eseguire il deployment della tua applicazione:

gradle appengineDeploy

L'attività appengineDeploy e tutte le altre attività Gradle hanno proprietà associate che puoi utilizzare. Per un elenco completo di attività e proprietà, consulta Attività in Gradle di App Engine e Proprietà.

Utilizzo del wrapper Gradle

Gradle fornisce un meccanismo per scaricare ed eseguire la versione richiesta di Gradle senza installazione:

Linux/macOS

./gradlew appengineRun

Windows

gradlew.bat appengineRun

Ulteriori informazioni su Gradle sono disponibili in App Engine Gradle Attività e proprietà.

Passaggi successivi