Develop with Docker Engine SDKs

Docker provides an API for interacting with the Docker daemon (called the Docker Engine API), as well as SDKs for Go and Python. The SDKs allow you to build and scale Docker apps and solutions quickly and easily. If Go or Python don't work for you, you can use the Docker Engine API directly.

The Docker Engine API is a RESTful API accessed by an HTTP client such as wget or curl, or the HTTP library which is part of most modern programming languages.

Install the SDKs

Use the following commands to install the Go or Python SDK. Both SDKs can be installed and coexist together.

Go SDK

$ go get github.com/docker/docker/client

The client requires a recent version of Go. Run go version and ensure that you are running a currently supported version of Go

Read the full Docker Engine Go SDK referenceopen_in_new.

Python SDK

Read the full Docker Engine Python SDK referenceopen_in_new.

View the API reference

You can view the reference for the latest version of the API or choose a specific version.

Versioned API and SDK

The version of the Docker Engine API you should use depends upon the version of your Docker daemon and Docker client. Refer to the versioned API and SDK section in the API documentation for details.

SDK and API quickstart

Use the following guidelines to choose the SDK or API version to use in your code:

  • If you're starting a new project, use the latest version, but use API version negotiation or specify the version you are using. This helps prevent surprises.
  • If you need a new feature, update your code to use at least the minimum version that supports the feature, and prefer the latest version you can use.
  • Otherwise, continue to use the version that your code is already using.

As an example, the docker run command can be easily implemented using the Docker API directly, or using the Python or Go SDK.


package main

import (
	"context"
	"io"
	"os"

	"github.com/docker/docker/api/types"
	"github.com/docker/docker/api/types/container"
	"github.com/docker/docker/client"
	"github.com/docker/docker/pkg/stdcopy"
)

func main() {
    ctx := context.Background()
    cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
    if err != nil {
        panic(err)
    }
    defer cli.Close()

    reader, err := cli.ImagePull(ctx, "docker.io/library/alpine", types.ImagePullOptions{})
    if err != nil {
        panic(err)
    }
    io.Copy(os.Stdout, reader)

    resp, err := cli.ContainerCreate(ctx, &container.Config{
        Image: "alpine",
        Cmd:   []string{"echo", "hello world"},
    }, nil, nil, nil, "")
    if err != nil {
        panic(err)
    }

    if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
        panic(err)
    }

    statusCh, errCh := cli.ContainerWait(ctx, resp.ID, container.WaitConditionNotRunning)
    select {
    case err := <-errCh:
        if err != nil {
            panic(err)
        }
    case <-statusCh:
    }

    out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
    if err != nil {
        panic(err)
    }

    stdcopy.StdCopy(os.Stdout, os.Stderr, out)
}
import docker
client = docker.from_env()
print(client.containers.run("alpine", ["echo", "hello", "world"]))
$ curl --unix-socket /var/run/docker.sock -H "Content-Type: application/json" \
  -d '{"Image": "alpine", "Cmd": ["echo", "hello world"]}' \
  -X POST http://localhost/v1.43/containers/create
{"Id":"1c6594faf5","Warnings":null}

$ curl --unix-socket /var/run/docker.sock -X POST http://localhost/v1.43/containers/1c6594faf5/start

$ curl --unix-socket /var/run/docker.sock -X POST http://localhost/v1.43/containers/1c6594faf5/wait
{"StatusCode":0}

$ curl --unix-socket /var/run/docker.sock "http://localhost/v1.43/containers/1c6594faf5/logs?stdout=1"
hello world

When using cURL to connect over a Unix socket, the hostname is not important. The examples above use localhost, but any hostname would work.

Using cURL 7.47.0 or below?

The examples above assume you are using cURL 7.50.0 or above. Older versions of cURL used a non-standard URL notationopen_in_new when using a socket connection.

If you are using an older version of cURL, use http:/<API version>/ instead, for example, http:/v1.43/containers/1c6594faf5/start


For more examples, take a look at the SDK examples.

Unofficial libraries

There are a number of community supported libraries available for other languages. They have not been tested by Docker, so if you run into any issues, file them with the library maintainers.

LanguageLibrary
Clibdockeropen_in_new
C#Docker.DotNetopen_in_new
C++lasote/docker_clientopen_in_new
Clojureclj-docker-clientopen_in_new
Clojurecontajnersopen_in_new
Dartbwu_dockeropen_in_new
Erlangerldockeropen_in_new
Gradlegradle-docker-pluginopen_in_new
Groovydocker-clientopen_in_new
Haskelldocker-hsopen_in_new
HTML (Web Components)docker-elementsopen_in_new
Javadocker-clientopen_in_new
Javadocker-javaopen_in_new
Javadocker-java-apiopen_in_new
Javajockeropen_in_new
NodeJSdockerodeopen_in_new
NodeJSharbor-masteropen_in_new
PerlEixo::Dockeropen_in_new
PHPDocker-PHPopen_in_new
Rubydocker-apiopen_in_new
Rustdocker-rustopen_in_new
Rustshipliftopen_in_new
Scalatugboatopen_in_new
Scalareactive-dockeropen_in_new
Swiftdocker-client-swiftopen_in_new