A Docker Remote API client library written in Kotlin Multiplatform using Ktor.

• Kotlin Multiplatform: Supports JVM, Linux X64, and NodeJS.
• Ktor Client: Leverages the power of Ktor for network requests, providing flexible engine support.
• Type Safety: Data models are generated from the official Docker OpenAPI specification (v1.51).
• Coroutines & Flow: First-class support for asynchronous operations and streaming (logs, stats) via Kotlin Coroutines and Flow.
• Unix Domain Sockets: Built-in support for connecting via /var/run/docker.sock.

• [x] JVM
• [x] Linux X64
• [x] NodeJS

Add dependency to your build.gradle.kts:

dependencies {
    implementation("dev.limebeck.libs:docker-client:0.0.5")
}

• Container: Manage containers (create, list, start, stop, etc.).
• Image: Manage images (pull, list, delete, etc.).
• Network: Manage networks (create, list, connect, etc.).
• Volume: Manage volumes (create, list, delete, etc.).
• Exec: Run commands inside containers.
• System: System-level operations (ping, version, auth, etc.).

• Swarm
• Node
• Service
• Task
• Secret
• Config
• Plugin

By default, the client is configured to connect via the local Unix socket:

val dockerClient = DockerClient()

Custom configuration using DockerClientConfig:

val config = DockerClientConfig(
    json = Json { ignoreUnknownKeys = true },
    connectionConfig = DockerClientConfig.ConnectionConfig.SocketConnection("/var/run/docker.sock"),
)
val dockerClient = DockerClient(config)

The library provides a DSL-like access to various parts of the Docker API.

val containers = dockerClient.containers.getList().getOrNull()
containers?.forEach { println(it.names) }

val createdContainer = dockerClient.containers.create(
    name = "my-container",
    config = ContainerConfig(
        image = "bash",
        cmd = listOf("-c", "while true; do date; sleep 2; done")
    )
).getOrThrow()

dockerClient.containers.start(createdContainer.id).getOrThrow()

val logsFlow = dockerClient.containers.getLogs(
    id = createdContainer.id,
    parameters = ContainerLogsParameters(
        follow = true,
        stdout = true,
        stderr = true
    )
).getOrThrow()

logsFlow.collect { logLine ->
    println("${logLine.type}: ${logLine.line}")
}

If you need to use an endpoint that is not yet implemented, you can easily extend the client:

val DockerClient.myCustomApi by ::MyCustom.api()

class MyCustom(val dockerClient: DockerClient) {
    suspend fun getCustomInfo(): Result<MyCustomResponse, ErrorResponse> = with(dockerClient) {
        return client.get("/my/custom/endpoint").parse()
    }
}

• Primarily tested on Linux (due to Unix socket dependency).
• Only Unix sockets are supported for now.

• lib: The main module containing the Docker client implementation and generated models.
• specs: Contains the Docker API OpenAPI specification.
• sample/terminalApp: A sample console application using the library.
• sample/htmxDashboard: A sample web dashboard using Ktor and HTMX to monitor containers.

Terminal App:

./gradlew :sample:terminalApp:runDebugExecutableLinuxX64

HTMX Dashboard:

./gradlew :sample:htmxDashboard:runDebugExecutableLinuxX64

The project uses OpenAPI Generator to create data models. When building the project, models are automatically generated into the lib/build/generated/openapi directory.

To build the project:

./gradlew build

Contributions are welcome! Please feel free to submit a Pull Request.

This project is licensed under the MIT License – see the LICENSE file for details.