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 :

Configurer et valider votre projet GCP

Vous devez configurer votre projet GCP et installer le SDK Cloud :

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

    Accéder à App Engine

    1. Sélectionnez ou créez un projet GCP.
    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. Si vous devez activer la facturation pour votre projet, vous êtes invité à 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 le SDK Cloud, car le plug-in l'installe automatiquement 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. Ajoutez les éléments suivants à votre fichier build.gradle pour ajouter des tâches App Engine Gradle, des dépôts Maven, le plug-in App Engine Gradle, des dépendances et une 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:1.+'    // Latest 1.x.x release
      }
    }
    
    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 {
      compile 'com.google.appengine:appengine-api-1.0-sdk:+'  // Latest App Engine Api's
      providedCompile 'javax.servlet:javax.servlet-api:3.1.0'
    
      compile 'jstl:jstl:1.2'
    
    // Add your dependencies here.
    //  compile 'com.google.cloud:google-cloud:+'   // Latest Cloud API's http://googlecloudplatform.github.io/google-cloud-java
    
      testCompile 'junit:junit:4.12'
      testCompile 'com.google.truth:truth:0.33'
      testCompile 'org.mockito:mockito-all:1.10.19'
    
      testCompile 'com.google.appengine:appengine-testing:+'
      testCompile 'com.google.appengine:appengine-api-stubs:+'
      testCompile 'com.google.appengine:appengine-tools-sdk:+'
    }
    
    // Always run unit tests
    appengineDeploy.dependsOn test
    appengineStage.dependsOn test
    
    appengine {  // App Engine tasks configuration
      deploy {   // deploy configuration
    
      }
    }
    
    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 le guide de démarrage rapide.

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/getting-started-java.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 getting-started-java-master/appengine-standard-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 rechargement à chaud 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 votre application

Pour déployer votre application, exécutez la commande suivante :

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

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Environnement standard App Engine pour Java