Utilizzo di Gradle e del plug-in App Engine

Puoi utilizzare Gradle, un sistema di automazione della build flessibile, dichiarativo e utilizzato per automatizzare la creazione, il test, la pubblicazione e il deployment. Questa pagina spiega 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 tuo progetto Google Cloud e installare gcloud CLI:

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

    Vai ad App Engine

    1. Seleziona o crea un nuovo progetto Google Cloud .
    2. Segui le istruzioni per assicurarti che esista un'applicazione App Engine e che la fatturazione sia 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 App Engine.
      2. Segui le istruzioni per creare un nuovo account di fatturazione o selezionarne uno esistente.
    3. La dashboard si apre dopo la creazione dell'applicazione App Engine e l'attivazione della fatturazione nel progetto.

  2. Non è necessario installare gcloud CLI 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 e inserisci 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, repository Maven, il plug-in Gradle di App Engine, dipendenze e 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.

Scaricare l'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 campione 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 durante l'esecuzione in locale, imposta le credenziali predefinite dell'applicazione eseguendo:

    gcloud auth application-default login

  2. Passa alla radice della directory dell'applicazione.

  3. Durante la fase di sviluppo, puoi eseguire e testare la tua applicazione in qualsiasi momento nel 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 vedi un messaggio simile a questo:

    :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. Visualizza 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 abilitare il debug sulla JVM sottostante, ad esempio:

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

Abilita il ricaricamento rapido dell'applicazione

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

  • Devi indicare al server locale di cercare modifiche:

    appengine {
  run {
    automaticRestart = true
  }
}

  • Mentre l'app è in esecuzione, esegui l'attività explodeWar per copiare le modifiche direttamente nell'app estratta e propagarle nell'applicazione in esecuzione.

Deployment dell'applicazione

Per eseguire il deployment dell'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à e proprietà Gradle di App Engine.

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 Attività e proprietà di Gradle di App Engine.

Passaggi successivi