Presentation from flatMap(Oslo) 2015-04-28.

1. Ship your Scala code often
and easy with Docker
Marcus Lönnberg
marcus@lonnberg.nu
github.com/marcuslonnberg
@lonnbergm

2. e-bokföring

4. Agenda
• Intro to Docker
• Building Docker images with sbt
• Manage Docker containers with Scala
• Docker.at(SpeedLedger)

6. Platform
Open source
Client - server
REST API
Immutable images
Container virtualization

7. Traditional VMs Docker

8. Docker image
Dockerfile
Container

9. Docker image
Dockerfile
Container
> docker build --tag=myimage
> docker run myimage

10. Live demo

11. Building and shipping Docker images
Machine 1
Dockerfile + files
Machine x
> docker pull myimage
> docker run myimage
Registry
> docker build --tag=myimage
> docker push myimage
Machine xMachine x

12. Building Docker images from sbt

13. Manually building a Scala application
as a Docker image
1. Produce a fat JAR
2. Define a Dockerfile
3. Build a Docker image

14. 0. Current sbt build
name := "fancy-service"
organization := "demo"
libraryDependencies ++= Seq(
"com.typesafe.akka" %% "akka-actor" % "2.3.9",
"io.spray" %% "spray-routing" % “1.3.3”,
...
)
build.sbt

15. 1. sbt-assembly gives us a fat JAR
project/plugins.sbt
> sbt assembly
…
[info] Packaging out/fancy-service.jar ...
…
[success] Total time: 6 s
addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.13.0")

16. 2. Define a Dockerfile
FROM ubuntu
RUN apt-get update
RUN apt-get install -y openjdk-8-jre-headless
COPY fancy-service.jar /app/fancy-service.jar
WORKDIR /app
ENTRYPOINT java -jar fancy-service.jar
EXPOSE 8080
Dockerfile

17. 2. Define a Dockerfile
FROM ubuntu
RUN apt-get update
RUN apt-get install -y openjdk-8
COPY fancy-service.jar
WORKDIR /app
ENTRYPOINT java -jar fancy-service.jar
EXPOSE 8080
Dockerfile
FROM java:8-jre
WORKDIR /app
EXPOSE 8080
ENTRYPOINT java -jar fancy-service.jar
COPY fancy-service.jar /app/fancy-service.jar
good

18. 3. Building a Docker image
> docker build -t demo/fancy-service .
Sending build context to Docker daemon
Step 0 : FROM java:8-jre
---> 028f36974b77
Step 1 : WORKDIR /app
---> fb8108515091
Step 2 : EXPOSE 8080
---> 9512be4df795
Step 3 : ENTRYPOINT java -jar fancy-service.jar
---> 839dd75f5a96
Step 4 : COPY fancy-service.jar /app/fancy-service.jar
---> 948eb875c3b1
Removing intermediate container f9eeb9406fc7
Successfully built 948eb875c3b1

19. sbt-docker

20. sbt-docker
addSbtPlugin("se.marcuslonnberg" % "sbt-docker" % "1.1.0")
project/plugins.sbt
enablePlugins(DockerPlugin)
build.sbt

21. Dockerfile DSL
def jarFile: File
def jarName: String
new Dockerfile {
from("java:8-jre")
workDir("/app")
expose(8080)
entryPointRaw(s"java -jar $jarName")
copy(jarFile, s"/app/$jarName")
}

22. Putting it all together
docker <<= docker.dependsOn(assembly)
dockerfile in docker := {
val jarFile = (assemblyOutputPath in assembly).value
val jarName = name.value + ".jar"
new Dockerfile {
from("java:8-jre")
workDir("/app")
expose(8080)
entryPointRaw(s"java -jar $jarName")
copy(jarFile, s"/app/$jarName")
}
}
build.sbt

23. Let’s build an image
> sbt docker
…
[info] Packaging out/fancy-service.jar ...
…
[info] Step 0 : FROM java:8-jre
[info] ---> 028f36974b77
…
[info] Successfully built 30c376822ced
[info] Tagging image 30c376822ced with name: demo/fancy-service:0.1-SNAPSHOT
[info] Tagging image 30c376822ced with name: demo/fancy-service:latest
[success] Total time: 20 s

24. Image names
imageNames in docker := Seq(
ImageName("demo/fancy-service:" + version.value),
ImageName("demo/fancy-service:latest")
)
build.sbt

25. Immutable Dockerfile
def jarFile: File
def jarName: String
Dockerfile.empty
.from("java:8-jre")
.workDir("/app")
.expose(8080)
.entryPointRaw(s"java -jar $jarName")
.copy(jarFile, s"/app/$jarName")

26. Build options
buildOptions in docker := BuildOptions(
cache = true,
removeIntermediateContainers = BuildOptions.Remove.OnSuccess,
pullBaseImage = BuildOptions.Pull.Always
)
build.sbt

27. sbt-docker
• Define Dockerfiles with a DSL
• Dynamically name your images
• Push images to a registry
github.com/marcuslonnberg/sbt-docker

28. Manage Docker containers
from Scala

29. REST API

30. REST API

31. scala-docker

32. Live coding

33. Docker.at(SpeedLedger)

34. Build pipeline
Dev machine
Build server
Test
Production
Registry
git repo
> git push
> sbt dockerBuildAndPush
> docker pull image
Dev machine

35. Tagging Docker images with git
imageNames in docker := Seq(
ImageName("demo/fancy-service:" + git.gitHeadCommit.value.get),
ImageName("demo/fancy-service:" + git.gitCurrentBranch.value)
)

36. Labels with build info
val labels = Map(
"build.commitId" -> git.gitHeadCommit.value.get,
"build.branch" -> git.gitCurrentBranch.value,
"build.appName" -> name.value,
"build.buildTime" -> Platform.currentTime.toString
)
new Dockerfile {
…
label(labels)
…
}
Docker >= 1.6

37. Internal sbt plugin
• Adds common libraries
• Generates build info
• Configures logging
• Adds monitoring
• Sets good runtime properties
• Defines a Dockerfile template

39. What we have learned
• Order instructions in Dockerfiles for fast builds
• Docker is very easy to use except for networking and
file persistence
• Define own base images but use official when ones exist
• Building tools around Docker is easy and fun

40. Links
• github.com/marcuslonnberg/sbt-docker
• github.com/marcuslonnberg/scala-docker
• github.com/sbt/sbt-assembly
• github.com/sbt/sbt-native-packager

41. Thank you!
marcus@lonnberg.nu
github.com/marcuslonnberg
@lonnbergm