If you like having a self-contained application as a deliverable for your project, the idea of putting your Spring applications in a Docker container might be appealing to you.

In this article, I will show you a simple way to make a docker image the output of your Gradle build, thanks to the gradle-docker plugin.

The code that we will build is a simple console application powered by Spring Boot that will periodically write Chuck Norris facts to the standard output. It is available on github and on Docker Hub.

Take a Spring boot application

You can easily generate a starter project with start.spring.io or with IntelliJ. We will create a gradle/groovy application with no Spring Boot starter to keep the code very simple.

Click on this link to generate the project!

Unzip it and open it in your favorite IDE. Since the application is going to loop forever, you can remove the generated test, which would loop forever too.

Add the following dependency to your build.gradle:

compile 'org.codehaus.groovy.modules.http-builder:http-builder:0.7.1'

Since we will use the JSONSlurper, the idiomatic way to parse JSON in groovy, we will need to the change the groovy dependency to groovy-all:

compile 'org.codehaus.groovy:groovy-all'

The code

The code is really simple:

package com.github.geowarin

import groovy.util.logging.Log4j
import groovyx.net.http.RESTClient
import org.apache.log4j.Level
import org.springframework.boot.CommandLineRunner
import org.springframework.stereotype.Component

class MainRunner implements CommandLineRunner {

    private static Random random = new Random();

    void run(String... args) throws Exception {
        while (true) {
            log.log(randomLevel(), randomMessage())
            sleep 3000

    private Level randomLevel() {
        switch (random.nextInt(3)) {
            case 0:
                return Level.DEBUG;
            case 1:
                return Level.INFO;
            case 2:
                return Level.ERROR;
                return Level.INFO;

    private String randomMessage() {
        def client = new RESTClient('http://api.icndb.com/jokes/')
        def response = client.get(path: 'random')

Build the docker image

Add the plugin repository to find the Docker plugin:

buildscript {
  ext {
    springBootVersion = '1.3.0.RELEASE'
  repositories {
  dependencies {
    classpath "se.transmode.gradle:gradle-docker:1.2" // <- Here

Apply the Docker plugin:

apply plugin: 'docker'

Finally, add the buildDocker task:

task buildDocker(type: Docker) {
  baseImage = 'develar/java:latest'
  push = project.hasProperty('push')
  tag = 'geowarin/sout-chuck-norris'
  addFile {
    from jar
    rename {'app.jar'}
  entryPoint(['java', '-Djava.security.egd=file:/dev/./urandom', '-jar', '/app.jar'])
  // exposePort(8080)


With this Docker plugin, every Docker instruction is available in the Gradle build so you don’t even have to write a Dockerfile.

In this task, we create an image called geowarin/sout-chuck-norris (change geowarin to your user name). It will contain only the jar produced by our build, which will be renamed to app.jar. Then, the entry point of the container is simply java -jar app.jar.

The advantage of using an entry point instead of a CMD is that we can append command line arguments to the docker run ... command and those will be passed to our application.

The downside is you cannot use docker exec ... bash to attach to the container.

We use Develar’s java 8 image. It is built on top of Alpine and weights less than 120MB.

You can now run ./gradlew buildDocker to create the docker image containing our project.

REPOSITORY                   TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
geowarin/sout-chuck-norris   latest              85ff1a728670        4 seconds ago       135.9 MB

Publish the image to the Docker hub

Create an account on the docker hub then use docker login to authenticate your client.

You can now run ./gradlew buildDocker -Ppush to publish your image to docker hub.

Once it is published, anyone can run you application. If the image is not available on their machine, it will be pulled from the docker hub.

$> docker run geowarin/sout-chuck-norris
Unable to find image 'geowarin/sout-chuck-norris:latest' locally
latest: Pulling from geowarin/sout-chuck-norris
09ef480f93cc: Verifying Checksum
a6fb0a3c9260: Download complete
Pulling repository docker.io/geowarin/sout-chuck-norris
914b85281644: Pulling dependent layers
914b85281644: Download complete
Status: Downloaded newer image for geowarin/sout-chuck-norris:latest

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 :: Spring Boot ::        (v1.3.1.RELEASE)

2016-01-12 16:54:19.089  INFO 1 --- [           main] c.g.geowarin.SoutChuckNorrisApplication  : Starting SoutChuckNorrisApplication on 05d1fedaba4d with PID 1 (/app.jar started by root in /)
2016-01-12 16:54:19.093  INFO 1 --- [           main] c.g.geowarin.SoutChuckNorrisApplication  : No active profile set, falling back to default profiles: default
2016-01-12 16:54:19.205  INFO 1 --- [           main] s.c.a.AnnotationConfigApplicationContext : Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@4533542a: startup date [Tue Jan 12 16:54:19 GMT 2016]; root of context hierarchy
2016-01-12 16:54:20.609  INFO 1 --- [           main] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
2016-01-12 16:54:21.456  INFO 1 --- [           main] com.github.geowarin.MainRunner           : Chuck Norris can download emails with his pick-up.


Spring boot producing runnable jars, it is fairly easy to embed them inside of a container.

As usual, do not hesitate to give me your feedback and to checkout the code on github!

Geoffroy Warin

Hello! I write codez

geowarin geowarin

Read more!