Initial commit

Author: miguno

Dockerfile

@@ -0,0 +1,18 @@
+# Multi-stage build setup (https://docs.docker.com/develop/develop-images/multistage-build/)
+
+# Stage 1 (to create a "build" image, ~140MB)
+FROM openjdk:8-jdk-alpine3.7 AS builder
+RUN java -version
+
+COPY . /usr/src/myapp/
+WORKDIR /usr/src/myapp/
+RUN apk --no-cache add maven && mvn --version
+RUN mvn package
+
+# Stage 2 (to create a downsized "container executable", ~87MB)
+FROM openjdk:8-jre-alpine3.7
+WORKDIR /root/
+COPY --from=builder /usr/src/myapp/target/app.jar .
+
+EXPOSE 8123
+ENTRYPOINT ["java", "-jar", "./app.jar"]

README.md

@@ -0,0 +1,56 @@
+# Tutorial: Create a Docker image for a Java application
+
+A template project to create a Docker image for a Java application.
+The example application exposes an HTTP endpoint.
+
+The Docker build uses a [multi-stage build setup](https://docs.docker.com/develop/develop-images/multistage-build/)
+to minimize the size of the generated Docker image.
+
+
+# Usage and Demo
+
+**Step 1:** Create the Docker image `miguno/java-docker-build:latest` according to [Dockerfile](Dockerfile).
+This step uses Maven to build, test, and package the Java application according to [pom.xml](pom.xml).
+
+```shell
+# This may take a few minutes.
+$ ./build_image.sh
+```
+
+> Example output:
+>
+> ```
+> Building image 'miguno/java-docker-build:latest'
+> ...
+> Successfully tagged miguno/java-docker-build:latest
+> ```
+
+**Step 2:** Start a container for the Docker image.
+
+```shell
+$ ./run_image.sh
+```
+
+> Example output:
+>
+> ```
+> Starting container for image 'miguno/java-docker-build:latest', exposing port 8123/tcp
+> ...
+> Endpoint is available at http://0.0.0.0:8123/status
+> ```
+
+**Step 3:** Open another terminal and access the example API endpoint.
+
+```shell
+$ curl http://localhost:8123/status
+{"status": "idle"}
+```
+
+
+# Notes
+
+You can also build, test, and package the Java application locally (without Docker) if you have Maven installed.
+
+```shell
+$ mvn package
+```

build_image.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+declare -r IMAGE_NAME="miguno/java-docker-build"
+declare -r IMAGE_TAG="latest"
+
+echo "Building image '$IMAGE_NAME:$IMAGE_TAG'"
+docker build -t $IMAGE_NAME:$IMAGE_TAG .

pom.xml

@@ -0,0 +1,107 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>com.miguno</groupId>
+  <artifactId>java-docker-build</artifactId>
+  <packaging>jar</packaging>
+  <version>1.0.0-SNAPSHOT</version>
+  <name>java-docker-build</name>
+
+  <licenses>
+    <license>
+      <name>Apache License 2.0</name>
+      <url>http://www.apache.org/licenses/LICENSE-2.0.html</url>
+      <distribution>repo</distribution>
+    </license>
+  </licenses>
+
+  <properties>
+    <java.version>8</java.version>
+    <jersey.version>2.27</jersey.version>
+    <junit.version>4.12</junit.version>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+
+  <dependencyManagement>
+    <dependencies>
+      <dependency>
+        <groupId>org.glassfish.jersey</groupId>
+        <artifactId>jersey-bom</artifactId>
+        <version>${jersey.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
+    </dependencies>
+  </dependencyManagement>
+
+  <dependencies>
+
+    <dependency>
+      <groupId>org.glassfish.jersey.containers</groupId>
+      <artifactId>jersey-container-grizzly2-http</artifactId>
+    </dependency>
+
+    <dependency>
+      <groupId>org.glassfish.jersey.inject</groupId>
+      <artifactId>jersey-hk2</artifactId>
+      <exclusions>
+        <exclusion>
+          <groupId>javax.inject</groupId>
+          <artifactId>javax.inject</artifactId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>${junit.version}</version>
+      <scope>test</scope>
+    </dependency>
+
+  </dependencies>
+
+  <build>
+    <plugins>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.7.0</version>
+        <configuration>
+          <source>${java.version}</source>
+          <target>${java.version}</target>
+        </configuration>
+      </plugin>
+
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-shade-plugin</artifactId>
+        <version>3.1.1</version>
+        <configuration>
+          <finalName>app</finalName>
+        </configuration>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>shade</goal>
+            </goals>
+            <configuration>
+              <transformers>
+                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                  <mainClass>com.miguno.App</mainClass>
+                </transformer>
+              </transformers>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+
+    </plugins>
+  </build>
+
+</project>

run_image.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+declare -r IMAGE_NAME="miguno/java-docker-build"
+declare -r IMAGE_TAG="latest"
+declare -r APP_PORT="8123"
+
+echo "Starting container for image '$IMAGE_NAME:$IMAGE_TAG', exposing port $APP_PORT/tcp"
+docker run -p $APP_PORT:$APP_PORT $IMAGE_NAME:$IMAGE_TAG
+

src/main/java/com/miguno/App.java

@@ -0,0 +1,31 @@
+package com.miguno;
+
+import org.glassfish.grizzly.http.server.HttpServer;
+import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory;
+import org.glassfish.jersey.server.ResourceConfig;
+
+import java.net.URI;
+
+public class App {
+
+  protected static final String BASE_URI = "http://0.0.0.0:8123/";
+
+  /**
+   * Starts Grizzly HTTP server exposing JAX-RS resources defined in this application.
+   */
+  protected static HttpServer startServer() {
+    // create a resource config that scans for JAX-RS resources and providers in com.miguno package
+    final ResourceConfig rc = new ResourceConfig().packages("com.miguno");
+
+    // create and start a new instance of grizzly http server
+    // exposing the Jersey application at BASE_URI
+    return GrizzlyHttpServerFactory.createHttpServer(URI.create(BASE_URI), rc);
+  }
+
+  public static void main(String[] args) {
+    startServer();
+    System.out.println(String.format("Jersey app started with WADL available at %sapplication.wadl", BASE_URI));
+    System.out.println(String.format("Endpoint is available at %sstatus", BASE_URI));
+  }
+}
+

src/main/java/com/miguno/Status.java

@@ -0,0 +1,16 @@
+package com.miguno;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+
+@Path("status")
+public class Status {
+
+  @GET
+  @Produces(MediaType.APPLICATION_JSON)
+  public String statusInformation() {
+    return "{\"status\": \"idle\"}\n";
+  }
+}

src/test/java/com/miguno/StatusTest.java

@@ -0,0 +1,36 @@
+package com.miguno;
+
+import org.glassfish.grizzly.http.server.HttpServer;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.client.WebTarget;
+
+import static org.junit.Assert.assertEquals;
+
+public class StatusTest {
+
+  private HttpServer server;
+  private WebTarget target;
+
+  @Before
+  public void setUp() {
+    server = App.startServer();
+    Client c = ClientBuilder.newClient();
+    target = c.target(App.BASE_URI);
+  }
+
+  @After
+  public void tearDown() {
+    server.shutdownNow();
+  }
+
+  @Test
+  public void shouldReceiveIdleStatus() {
+    String responseMsg = target.path("status").request().get(String.class);
+    assertEquals("{\"status\": \"idle\"}\n", responseMsg);
+  }
+}