Environnement d'exécution Java 8

L'environnement d'exécution Java 8 n'inclut aucun framework de service Web. Votre application doit seulement écouter et répondre sur le port 8080. L'exemple de code présenté ici montre comment vous pouvez ajouter votre propre framework, tel que Spring Boot, à l'environnement d'exécution Java 8.

Prérequis

Avant de commencer à développer, téléchargez la dernière version de Google Cloud CLI ou mettez à jour gcloud CLI vers la version actuelle :
```
gcloud components update
```
Pour déployer à l'aide de Maven, vous devez ajouter le plug-in App Engine Maven à votre fichier pom.xml :
```
<plugin>
   <groupId>com.google.cloud.tools</groupId>
   <artifactId>appengine-maven-plugin</artifactId>
   <version>2.7.0</version>
</plugin>
```
D'autres options de déploiement incluent l'utilisation de la commande gcloud app deploy ou du plug-in App Engine Gradle.
Suivez les instructions concernant votre framework d'application pour configurer le build d'un fichier JAR exécutable. Ce fichierJAR exécutable doit être exécuté via java -jar app.jar. Pour obtenir un exemple, consultez la documentation de Spring Boot.

Organiser vos fichiers

La hiérarchie de vos fichiers de développement devrait se présenter comme suit :

MyDir/
  pom.xml
  [index.yaml]
  [cron.yaml]
  [dispatch.yaml]
  src/main/
    appengine/
      app.yaml
    docker/
      Dockerfile
    java/
      com.example.mycode/
        MyCode.java

`app.yaml`

Veuillez indiquer un fichier app.yaml. Définissez un fichier qui ressemble aux lignes suivantes :

runtime: java
env: flex

En spécifiant runtime: java, l'image d'exécution gcr.io/google-appengine/openjdk:8 est sélectionnée automatiquement lorsque vous déployez un fichier JAR (*.jar).

Pour sélectionner une version du JDK, utilisez le champ runtime_config.jdk.

runtime: java
env: flex
runtime_config:
  jdk: openjdk8

Vous trouverez d'autres paramètres app.yaml dans la section Utiliser app.yaml.

Fichiers facultatifs

Les fichiers de configuration suivants sont facultatifs :

Placez ces fichiers au premier niveau de MyDir. Si vous utilisez l'un de ces fichiers, vous devez le déployer séparément à l'aide de la commande gcloud app deploy.

Point d'entrée par défaut

Le point d'entrée de l'image OpenJDK 8 est docker-entrypoint.bash, qui traite les arguments de ligne de commande transmis pour rechercher une alternative exécutable ou des arguments pour la commande par défaut (java).

Si le premier argument de l'image n'est pas un exécutable, la commande java est ajoutée implicitement. Exemple :

$ docker run openjdk -jar /usr/share/someapplication.jar

Si le premier argument de l'image est un exécutable, tel que bash, la commande s'exécute.

Par exemple, vous pouvez exécuter une interface système à l'aide des lignes suivantes :

> docker run -it --rm openjdk bash
root@c7b35e88ff93:/#

Variables d'environnement

Utilisez la clé env_variables dans le fichier app.yaml pour définir les variables d'environnement. Exemple :

env_variables:
   MY_VAR_COLOR: 'blue'

Le tableau suivant répertorie les variables d'environnement que vous pouvez utiliser pour activer, désactiver ou configurer des fonctionnalités.

Var. env.	Description	Type	Par défaut
`TMPDIR`	Répertoire temporaire	nom de répertoire
`JAVA_TMP_OPTS`	Arguments JVM du répertoire temporaire	arguments JVM	`-Djava.io.tmpdir=${TMPDIR}`
`GAE_MEMORY_MB`	Mémoire disponible	taille	Défini par Google App Engine ou `/proc/meminfo`-400M
`HEAP_SIZE_RATIO`	Mémoire pour le segment de mémoire	pourcentage	80
`HEAP_SIZE_MB`	Segment de mémoire disponible	taille	`${HEAP_SIZE_RATIO}` % sur `${GAE_MEMORY_MB}`
`JAVA_HEAP_OPTS`	Arguments JVM du tas de mémoire	arguments JVM	`-Xms${HEAP_SIZE_MB}M -Xmx${HEAP_SIZE_MB}M`
`JAVA_GC_OPTS`	Arguments JVM de Google Cloud	Arguments JVM	`-XX:+UseG1GC` plus configuration
`JAVA_USER_OPTS`	Autres arguments JVM	arguments JVM
`JAVA_OPTS`	Arguments JVM	arguments JVM	Voir ci-dessous
`SHUTDOWN_LOGGING_THREAD_DUMP`	Vidage du thread d'arrêt	booléen	`false`
`SHUTDOWN_LOGGING_HEAP_INFO`	Informations relatives au segment de mémoire d'arrêt	booléen	`false`
`SHUTDOWN_LOGGING_SAMPLE_THRESHOLD`	Échantillonnage d'arrêt	pourcentage	100

Si ces variables ne sont pas définies explicitement, JAVA_OPTS est défini par défaut sur JAVA_OPTS:=-showversion \ ${JAVA_TMP_OPTS} \ ${DBG_AGENT} \ ${JAVA_HEAP_OPTS} \ ${JAVA_GC_OPTS} \ ${JAVA_USER_OPTS} :

La ligne de commande exécutée est effective (où $@ sont les arguments passés au point d'entrée de Docker) :

java $JAVA_OPTS "$@"

Tester en local

Vous pouvez créer votre application à l'aide de la commande suivante :

mvn package

Et l'exécuter à l'aide de la ligne de commande java :

java -jar target/myjar.jar

Vous pouvez aussi suivre les instructions relatives au framework de votre application sur la manière d'exécuter l'application en local.

Lorsque vous testez une application dans votre environnement local, vous préférez peut-être utiliser les services cloud émulés de Google, plutôt que ses services cloud distants. Il existe des émulateurs pour Cloud Datastore, Cloud Pub/Sub et Cloud Bigtable. Utilisez la commande gcloud pour les démarrer avant de lancer votre application :

gcloud beta emulators datastore start
gcloud beta emulators pubsub start
gcloud beta emulators bigtable start

Déployer l'application

Une fois les configurations terminées, vous pouvez utiliser Google Cloud CLI pour déployer ce répertoire contenant le fichier app.yaml et le fichier JAR en utilisant la commande suivante :

gcloud app deploy app.yaml

Si vous utilisez l'un des fichiers de configuration facultatifs (index.yaml, cron.yaml et dispatch.yaml), veillez à les déployer séparément à l'aide de la commande gcloud. Exemple :

gcloud app deploy cron.yaml

Maven

Utilisez Maven pour déployer votre application, à l'aide de la commande suivante :

mvn package appengine:deploy -Dapp.deploy.projectId=PROJECT_ID

Remplacez PROJECT_ID par l'ID de votre projet Google Cloud. Si votre ID de projet est déjà inclus dans le fichier pom.xml, vous n'avez pas besoin d'inclure la propriété -Dapp.deploy.projectId dans la commande que vous exécutez.

Gradle

Utilisez Gradle pour déployer votre application, à l'aide de la commande suivante :

gradle appengineDeploy

Personnaliser l'environnement d'exécution Java 8

Vous n'avez pas besoin d'un fichier Dockerfile pour déployer votre application dans l'environnement d'exécution Java 8. Toutefois, si votre application nécessite une configuration supplémentaire, vous pouvez explicitement fournir un fichier Docker pour personnaliser l'environnement d'exécution Java.

Si vous souhaitez utiliser l'image comme base d'un environnement d'exécution personnalisé, vous pouvez spécifier l'élément runtime: custom dans votre fichier app.yaml, puis écrire le fichier Dockerfile comme suit :

FROM gcr.io/google-appengine/openjdk:8
COPY your-application.jar $APP_DESTINATION

Ces lignes ajoutent le fichier JAR au bon endroit dans le conteneur Docker.

Vous pouvez ajouter des instructions supplémentaires au fichier Dockerfile pour personnaliser l'environnement d'exécution Java. Pour en savoir plus, consultez la page Créer des environnements d'exécution personnalisés.