Interact with the Docker Engine Remote API swiftly, enabling container management, system information retrieval, network creation, and log streaming through a simplified client interface.
docker-kotlin allows you to interact with the Docker Engine Remote API.
dependencies {
implementation("me.devnatan:docker-kotlin:0.15.0")
}
[!NOTE] Docker Kotlin currently supports JVM runtime only. Native platform support (Linux, macOS, Windows, etc.) is under active development in #209.
If you attempt to use Docker Kotlin on native targets before this work is complete, you'll encounter
NotImplementedError. We're working hard to bring full multiplatform support soon!
Use DockerKotlin { ... } to create a new Docker client instance with the default settings. Default settings are based on the
current platform or environment variables, e.g.: socket path will be set to DOCKER_HOST
if present otherwise unix://var/run/docker.sock if the current platform is Unix-like.
val client = DockerClient {
// this: DockerClientConfigBuilder
}
val version: SystemVersion = client.system.version()
val containerId = client.containers.create("busybox:latest") {
// Only if your container doesn't already expose this port
exposedPort(80u)
hostConfig {
portBindings(80u) {
add(PortBinding("0.0.0.0", 8080u))
}
}
}
client.containers.start(containerId)
val createdContainerId = client.containers.create("busybox:latest") {
// Only if your container doesn't already expose this port
exposedPort(80u)
hostConfig {
portBindings(80u)
}
}
client.containers.start(createdContainerId)
// Inspect the container to retrieve the auto-assigned ports
val container = testClient.containers.inspect(createdContainerId)
val ports = container.networkSettings.ports
val containers: List<Container> = client.containers.list()
val result = client.containers.logs(containerId) {
stdout = true
stderr = true
} as ContainerLogsResult.Complete
println(result.output)
val result = client.containers.logs(containerId) {
stdout = true
stderr = true
follow = true
} as ContainerLogsResult.Stream
result.output.collect { frame ->
println(frame.value)
}
val result = client.containers.logs(containerId, demux = true) {
stdout = true
stderr = true
} as ContainerLogsResult.CompleteDemuxed
println("STDOUT: ${result.stdout}")
println("STDERR: ${result.stderr}")
val result = client.containers.logs(containerId) {
stdout = true
tail = "100"
}
val result = client.containers.logs(containerId) {
stdout = true
timestamps = true
}
val result = client.containers.logs(containerId) {
stdout = true
since = "10m" // last 10 minutes
// or: since = "1609459200" // Unix timestamp
}
client.containers.logsAsFlow(containerId) {
stdout = true
stderr = true
follow = true
}.collect { frame ->
val prefix = if (frame.stream == Stream.StdErr) "[ERR]" else "[OUT]"
print("$prefix ${frame.value}")
}
val networkId: String = client.networks.create {
name = "octopus-net"
driver = "overlay"
}
val networks = client.networks.list()
client.networks.connect(networkId, containerId)
val execId = client.exec.create(containerId) {
command = listOf("echo", "Hello, Docker!")
attachStdout = true
}
when (
val result = client.exec.start(execId, ExecStartOptions())
) {
is ExecStartResult.Complete -> println(result.output)
else -> error("Unexpected result")
}
val execId = client.exec.create(containerId) {
command = listOf("sh", "-c", "for i in 1 2 3; do echo line \$i; sleep 1; done")
attachStdout = true
}
val result = client.exec.start(execId) { stream = true }
when (result) {
is ExecStartResult.Stream -> {
result.output.collect { chunk ->
print(chunk)
}
}
else -> error("Unexpected result")
}
val execId = client.exec.create(containerId) {
command = listOf("sh", "-c", "echo stdout; echo stderr >&2")
attachStdout = true
attachStderr = true
}
when (
val result = client.exec.start(execId) { demux = true }
) {
is ExecStartResult.CompleteDemuxed -> {
println("STDOUT: ${result.output.stdout}")
println()
}
-> error()
}
val execId = client.exec.create(containerId) {
command = listOf("false")
}
client.exec.start(execId) { detach = true }
val execInfo = client.exec.inspect(execId)
println("Exit code: ${execInfo.exitCode}") // Exit code: 1
client.containers.copyFileFrom(
container = containerId,
sourcePath = "/var/log/app.log",
destinationPath = "/tmp/app.log"
)
client.containers.copyFileTo(
container = "bailarina-caputina",
sourcePath = "/home/user/config.json",
destinationPath = "/app/config/"
)
client.containers.copyDirectoryFrom(
container = "knoten",
sourcePath = "/app/logs",
destinationPath = "/tmp/container-logs"
)
client.containers.copyDirectoryTo(
container = "globson",
sourcePath = "/home/user/configs",
destinationPath = "/app/"
)
client.containers.copyTo(
container = "tapioca",
destinationPath = "/app/data",
tarArchive = myTarArchive
) {
path = "/app/data"
noOverwriteDirNonDir = true // Don't overwrite if types mismatch
copyUIDGID = true // Preserve UID/GID
}
// Get raw tar archive from container
val result = client.containers.copyFrom(containerId, "/app/config")
val tarData = result.archiveData
// Archive info including file metadata
val stats = result.stat
docker-kotlin is licensed under the MIT license.
Surfaced from shared tags and platforms — no rankings paid for.