sbt-docker alternatives and similar packages
Based on the "Sbt plugins" category.
Alternatively, view sbt-docker alternatives based on common mentions on social networks and blogs.
-
sbt-ensime
DISCONTINUED. Generates .ensime config files for SBT projects http://ensime.org/build_tools/sbt -
sbt-dependency-check
SBT Plugin for OWASP DependencyCheck. Monitor your dependencies and report if there are any publicly known vulnerabilities (e.g. CVEs). :rainbow: -
sbt-unidoc
sbt plugin to create a unified Scaladoc or Javadoc API document across multiple subprojects. -
sbt-classfinder
SBT plugin for retrieving runtime information about the classes and traits in a project
CodeRabbit: AI Code Reviews for Developers
Do you think we are missing an alternative of sbt-docker or a related project?
README
sbt-docker
sbt-docker is an sbt plugin that builds and pushes Docker images for your project.
Requirements
- sbt
- Docker
Setup
Add sbt-docker as a dependency in project/plugins.sbt
:
addSbtPlugin("se.marcuslonnberg" % "sbt-docker" % "1.8.2")
Getting started
Below are some documentation on the sbt tasks and settings in the plugin.
This blog post gives a good introduction to the basics of sbt-docker: Dockerizing your Scala apps with sbt-docker
Also, take a look at the [example projects](examples).
Usage
Start by enabling the plugin in your build.sbt
file:
enablePlugins(DockerPlugin)
This sets up some settings with default values and adds tasks such as docker
which builds a Docker image.
The only required setting that is left to define is docker / dockerfile
.
Artifacts
If you want your Dockerfile to contain one or several artifacts (such as JAR files) that your
project generates, then you must make the docker
task depend on the tasks that generate them.
It could for example be with the package
task or with tasks from plugins such as
sbt-assembly.
Defining a Dockerfile
In order to produce a Docker image a Dockerfile must be defined.
It should be defined at the docker / dockerfile
key.
There is a mutable and an immutable Dockerfile class available, both provides a DSL which resembles
the plain text Dockerfile format.
The mutable class is default and is used in the following examples.
Example with the sbt-assembly plugin:
docker / dockerfile := {
// The assembly task generates a fat JAR file
val artifact: File = assembly.value
val artifactTargetPath = s"/app/${artifact.name}"
new Dockerfile {
from("openjdk:8-jre")
add(artifact, artifactTargetPath)
entryPoint("java", "-jar", artifactTargetPath)
}
}
Example with sbt-native-packager:
enablePlugins(sbtdocker.DockerPlugin, JavaAppPackaging)
docker / dockerfile := {
val appDir: File = stage.value
val targetDir = "/app"
new Dockerfile {
from("openjdk:8-jre")
entryPoint(s"$targetDir/bin/${executableScriptName.value}")
copy(appDir, targetDir, chown = "daemon:daemon")
}
}
Example with the sbt package
task.
docker / dockerfile := {
val jarFile: File = (Compile / packageBin / sbt.Keys.`package`).value
val classpath = (Compile / managedClasspath).value
val mainclass = (Compile / packageBin / mainClass).value.getOrElse(sys.error("Expected exactly one main class"))
val jarTarget = s"/app/${jarFile.getName}"
// Make a colon separated classpath with the JAR file
val classpathString = classpath.files.map("/app/" + _.getName)
.mkString(":") + ":" + jarTarget
new Dockerfile {
// Base image
from("openjdk:8-jre")
// Add all files on the classpath
add(classpath.files, "/app/")
// Add the JAR file
add(jarFile, jarTarget)
// On launch run Java with the classpath and the main class
entryPoint("java", "-cp", classpathString, mainclass)
}
}
Example with a Dockerfile in the filesystem.
docker / dockerfile := NativeDockerfile(file("subdirectory") / "Dockerfile")
Have a look at [DockerfileExamples](examples/DockerfileExamples.scala) for different ways of defining a Dockerfile.
Building an image
To build an image use the docker
task.
Simply run sbt docker
from your prompt or docker
in the sbt console.
Pushing an image
An image that have already been built can be pushed with the dockerPush
task.
To both build and push an image use the dockerBuildAndPush
task.
The docker / imageNames
key is used to determine which image names to push.
Custom image names
You can specify the names / tags you want your image to get after a successful build with the docker / imageNames
key of type Seq[sbtdocker.ImageName]
.
Example:
docker / imageNames := Seq(
// Sets the latest tag
ImageName(s"${organization.value}/${name.value}:latest"),
// Sets a name with a tag that contains the project version
ImageName(
namespace = Some(organization.value),
repository = name.value,
tag = Some("v" + version.value)
)
)
Build options
Use the key docker / buildOptions
to set build options.
Example:
docker / buildOptions := BuildOptions(
cache = false,
removeIntermediateContainers = BuildOptions.Remove.Always,
pullBaseImage = BuildOptions.Pull.Always,
additionalArguments = Seq("--add-host", "127.0.0.1:12345", "--compress")
)
Build arguments
Use the key docker / dockerBuildArguments
to set build arguments.
Example:
docker / dockerBuildArguments := Map(
"KEY" -> "value",
"CREDENTIALS" -> sys.env("CREDENTIALS")
)
docker / dockerfile := {
new Dockerfile {
// ...
arg("KEY")
arg("CREDENTIALS")
env("KEY" -> "$KEY", "CREDENTIALS" -> "$CREDENTIALS")
// ...
}
}
BuildKit support
Images can be built with BuildKit by enabling it in the daemon configuration or by passing the environment variable DOCKER_BUILDKIT=1
to sbt.
Auto packaging JVM applications
If you have a standalone JVM application that you want a simple Docker image for.
Then you can use dockerAutoPackageJavaApplication(fromImage, exposedPorts, exposedVolumes, username)
which will setup some settings for you, including a Dockerfile.
Its very basic, so if you have more advanced needs then define your own Dockerfile.