Utiliser Gradle et le plug-in App Engine

Grâce à Gradle, un système d’automatisation de compilation flexible et déclaratif, vous pouvez automatiser la compilation, les tests, la publication et le déploiement. Cette page vous explique comment utiliser Gradle avec un projet App Engine dans l'environnement standard.

Avant de commencer

Installez et configurez les composants requis suivants :

Configuration et validation de votre projet Google Cloud

Vous devez configurer votre projet Google Cloud et installer la gcloud CLI :

  1. Utilisez la console Google Cloud pour créer et configurer votre projet Google Cloud :

    Accéder à App Engine

    1. Sélectionnez ou créez un projet Google Cloud.
    2. Suivez les instructions pour vous assurer qu'une application App Engine existe et que la facturation est activée :
      1. Si vous devez créer une application App Engine pour votre projet, vous êtes invité à sélectionner la région dans laquelle vous souhaitez placer cette application.
      2. Suivez les instructions pour créer un compte de facturation ou sélectionner un compte existant.
    3. Le tableau de bord s'affiche une fois l'application App Engine créée et la facturation activée dans votre projet.

  2. Vous n'avez pas besoin d'installer la gcloud CLI, car le plug-in installe automatiquement le SDK si nécessaire.

Créer un projet Gradle

Vous pouvez créer entièrement un projet Gradle à l'aide de l'interface système. Pour essayer le plug-in, vous pouvez également télécharger, exécuter en local et déployer le projet Hello World.

  1. Créez un répertoire, puis accédez-y.

  2. Pour initialiser un nouveau projet :

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

  3. Insérez les lignes suivantes dans le fichier build.gradle afin d'ajouter des tâches Gradle pour App Engine, des dépôts Maven, le plug-in Gradle pour App Engine, des dépendances et la configuration des tâches :

    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. Vous devez également ajouter les fichiers suivants à votre projet, à l'aide d'un éditeur de texte ou d'un environnement de développement intégré (IDE) :

Pour découvrir une présentation du projet Java App Engine, consultez les fichiers de configuration.

Télécharger l'application Hello World

  1. Clonez le dépôt de l'exemple d'application Hello World sur votre ordinateur :

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

    Vous pouvez également télécharger l'exemple en tant que fichier zip et l'extraire.

  2. Accédez au répertoire qui contient l'exemple de code :

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

Tester votre application avec un serveur de développement

  1. Pour accéder aux ressources Google de votre projet lors de l'exécution en local, définissez les identifiants par défaut de l'application en exécutant la commande suivante :

    gcloud auth application-default login

  2. Accédez à la racine du répertoire de votre application.

  3. À tout moment pendant la phase de développement, vous pouvez exécuter et tester votre application sur le serveur de développement en appelant Gradle, à l'aide de la commande suivante :

    gradle appengineRun

    Vous pouvez également exécuter Gradle sans l’installer à l’aide du wrapper Gradle.

  4. Attendez que le serveur démarre. Une fois le serveur démarré et votre application en cours d'exécution, un message semblable à celui-ci s'affiche :

    :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. Accédez à l'adresse http://127.0.0.1:8080 pour afficher l'exécution de votre application.

Déboguer votre application sur un serveur de développement

Pour déboguer une application en cours d'exécution localement, définissez la propriété jvmFlags pour activer le débogage sur la machine virtuelle Java (JVM) sous-jacente, par exemple :

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

Activer le hot reload de l'application

Le rechargement à chaud permet de mettre à jour une ou plusieurs classes dans une application en cours d'exécution sans arrêter l'environnement. Pour activer le rechargement à chaud, procédez comme suit :

  • Vous devez demander au serveur local de rechercher les modifications, à l'aide des lignes suivantes :

    appengine {
  run {
    automaticRestart = true
  }
}

  • Pendant l'exécution de votre application, exécutez la tâche explodeWar pour copier les modifications directement dans l'application éclatée, puis les appliquer dans l'application en cours d'exécution.

Déployer l'application

Pour déployer votre application, procédez comme suit :

gradle appengineDeploy

La tâche appengineDeploy et toutes les autres tâches Gradle sont associées à des propriétés que vous pouvez utiliser. Pour obtenir la liste complète des tâches et des propriétés disponibles, consultez la page Tâches et propriétés Gradle pour App Engine.

Utiliser le wrapper Gradle

Gradle fournit un mécanisme permettant de télécharger et exécuter la version requise de Gradle sans l'installer :

Linux/macOS

./gradlew appengineRun

Windows

gradlew.bat appengineRun

Pour en savoir plus sur Gradle, consultez la page Tâches et propriétés Gradle pour App Engine.

Étapes suivantes