Notice: Over the next few months, we're reorganizing the App Engine documentation site to make it easier to find content and better align with the rest of Google Cloud products. The same content will be available, but the navigation will now match the rest of the Cloud products. If you have feedback or questions as you navigate the site, click Send Feedback.

The Java 8 / Jetty 9 runtime

Stay organized with collections Save and categorize content based on your preferences.

The Java 8 / Jetty 9 runtime provides OpenJDK 8 and Eclipse Jetty 9 with support for the Java Servlet 3.1 Specification. For information about the specific Jetty version in this runtime, view the Jetty properties in the GitHub project for the runtime's image.


  • Download the latest version of the Google Cloud CLI or update your gcloud CLI to the current version:

    gcloud components update
  • To deploy using Maven, you will need to add the App Engine Maven Plugin to your pom.xml:


    Other options for deploying include the gcloud app deploy command or the App Engine Gradle plugin.

Organizing your files

Your source tree should look like this:



An app.yaml file is required. Define a file that looks like this:

runtime: java
env: flex

- url: /.*
  script: this field is required, but ignored

The runtime image is automatically selected when you deploy a WAR (*.war file).

If you want to use this image as a base for a custom runtime, you can specify runtime: custom in your app.yaml file and then write the Dockerfile like this:

ADD your-application.war $APP_DESTINATION

These lines add the WAR in the correct location for the Docker container.

Other app.yaml settings are described in Using app.yaml.

pom.xml is for configuring Maven and build.gradle is for configuring Gradle.

Optional files

These configuration files are optional:

Place these files at the top level of MyDir. If you use any these files, you must deploy them separately with the gcloud app deploy command.

web.xml is optional and only needed if you are not using Servlet 3.x annotations.

You can place static web content, as well as your JavaServer pages, in your webapp/ directory. Jetty 9, which the App Engine flexible environment uses as its Servlet container, uses Apache Jasper as the default JSP implementation and includes JSTL taglibs.

The Dockerfile file is optional and used to customize the Java runtime.

Enabling gzip compression

The gzip handler is bundled with Jetty but not activated by default. To activate this module, set the environment variable, JETTY_MODULES_ENABLE=gzip, in the app.yaml file:


Using Quickstart

Jetty can speed up the start time of your application by pre-scanning its content and generating configuration files. If you are using an extended image you can activate quickstart by executing /scripts/jetty/ in your Dockerfile, after the application WAR is added.

ADD your-application.war $JETTY_BASE/webapps/root.war

# generate quickstart-web.xml
RUN /scripts/jetty/

Environment variables

You can set the following optional environment variables that are specific to the Java 8/Jetty 9 runtime. You can set OpenJDK 8 environment variables as well.

To set environment variables, use the env_variables key in the app.yaml file.

Env Var Maven Prop Value/Comment
JETTY_PROPERTIES Comma separated list of name=value pairs appended to $JETTY_ARGS
JETTY_MODULES_ENABLE Comma separated list of modules to enable by appending to $JETTY_ARGS
JETTY_MODULES_DISABLE Comma separated list of modules to disable by removing from $JETTY_BASE/start.d
JETTY_ARGS Arguments passed to jetty's start.jar. Any arguments used for custom jetty configuration should be passed here.
JAVA_OPTS JVM runtime arguments

Enhanced Cloud Logging (Beta)

When running on the App Engine flex environment, you can configure Java Util Logging to send logs to Cloud Logging by setting the JETTY_ARGS environment variable. For example:

   JETTY_ARGS: -Djava.util.logging.config.file=WEB-INF/

You must provide a file that configures a LoggingHandler as follows:

# Optional configuration
java.util.logging.SimpleFormatter.format=%3$s: %5$s%6$s

Local testing

When testing in your local environment, you may use emulated Google cloud services, rather than remote Google cloud services. You can use the following emulators:

Use the gcloud command to start them before you run your app:

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


Add these lines in your maven pom.xml file to add the Jetty 9 Maven Plugin:


To run your app locally, use the Maven command:

mvn jetty:run-exploded


Follow the Creating a new Gradle project instructions to add the Gretty Gradle plugin to your build.gradle, and use the command:

gradle jettyRun

Deploying your app

To initialize the Google Cloud CLI, run:

gcloud init

After completing the configurations, you can use the Google Cloud CLI to deploy this directory containing the app.yaml and WAR files using:

gcloud app deploy app.yaml

If you are using any of the optional configuration files (index.yaml, cron.yaml, and dispatch.yaml) deploy them separately with the gcloud command. For example:

gcloud app deploy cron.yaml


Use Maven to deploy your app:

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

Replace PROJECT_ID with the ID of your Cloud project. If your pom.xml file already specifies your project ID, you don't need to include the -Dapp.deploy.projectId property in the command you run.


Use Gradle to deploy your app:

gradle appengineDeploy

Customizing the Java 8 / Jetty 9 runtime

You don't need a Dockerfile to deploy your app into the Java 8/Jetty 9 runtime. If your app requires additional configuration, you can explicitly provide a Dockerfile to customize the Java runtime. The Dockerfile must include the base image You can add additional directives to the Dockerfile to customize the Java runtime. See Building Custom Runtimes.

Your Dockerfile should begin like this:

ADD your-application.war $APP_DESTINATION

In this case, your-application.war is the name of the built WAR file in your target/ directory (maven), or build/staged-app/ (gradle).