Struct bollard::Docker

pub struct Docker { /* fields omitted */ }

---

Docker

The main interface for calling the Docker API. Construct a new Docker instance using one of the connect methods:

• Docker::connect_with_http_defaults
• Docker::connect_with_named_pipe_defaults
• Docker::connect_with_ssl_defaults
• Docker::connect_with_unix_defaults
• Docker::connect_with_local_defaults

Implementations

impl Docker

pub async fn list_containers<'de, T>(
    &self,
    options: Option<ListContainersOptions<T>>
) -> Result<Vec<ContainerSummaryInner>, Error> where
    T: Into<String> + Eq + Hash + Serialize, 

---

List Containers

Returns a list of containers.

Arguments

• Optional ListContainersOptions struct.

Returns

• Vector of ContainerSummaryInner, wrapped in a Future.

Examples

use bollard::container::ListContainersOptions;

use std::collections::HashMap;
use std::default::Default;

let mut filters = HashMap::new();
filters.insert("health", vec!["unhealthy"]);

let options = Some(ListContainersOptions{
    all: true,
    filters,
    ..Default::default()
});

docker.list_containers(options);

pub async fn create_container<T, Z>(
    &self,
    options: Option<CreateContainerOptions<T>>,
    config: Config<Z>
) -> Result<ContainerCreateResponse, Error> where
    T: Into<String> + Serialize,
    Z: Into<String> + Hash + Eq + Serialize, 

---

Create Container

Prepares a container for a subsequent start operation.

Arguments

• Optional Create Container Options struct.
• Container Config struct.

Returns

• ContainerCreateResponse, wrapped in a Future.

Examples

use bollard::container::{CreateContainerOptions, Config};

use std::default::Default;

let options = Some(CreateContainerOptions{
    name: "my-new-container",
});

let config = Config {
    image: Some("hello-world"),
    cmd: Some(vec!["/hello"]),
    ..Default::default()
};

docker.create_container(options, config);

pub async fn start_container<T>(
    &self,
    container_name: &str,
    options: Option<StartContainerOptions<T>>
) -> Result<(), Error> where
    T: Into<String> + Serialize, 

---

Start Container

Starts a container, after preparing it with the Create Container API.

Arguments

• Container name as a string slice.
• Optional Start Container Options struct.

Returns

• unit type (), wrapped in a Future.

Examples

use bollard::container::StartContainerOptions;

docker.start_container("hello-world", None::<StartContainerOptions<String>>);

pub async fn stop_container(
    &self,
    container_name: &str,
    options: Option<StopContainerOptions>
) -> Result<(), Error>

---

Stop Container

Stops a container.

Arguments

• Container name as string slice.
• Optional Stop Container Options struct.

Returns

• unit type (), wrapped in a Future.

Examples

use bollard::container::StopContainerOptions;

let options = Some(StopContainerOptions{
    t: 30,
});

docker.stop_container("hello-world", options);

pub async fn remove_container(
    &self,
    container_name: &str,
    options: Option<RemoveContainerOptions>
) -> Result<(), Error>

---

Remove Container

Remove a container.

Arguments

• Container name as a string slice.
• Optional Remove Container Options struct.

Returns

• unit type (), wrapped in a Future.

Examples

use bollard::container::RemoveContainerOptions;

use std::default::Default;

let options = Some(RemoveContainerOptions{
    force: true,
    ..Default::default()
});

docker.remove_container("hello-world", options);

pub fn wait_container<T>(
    &self,
    container_name: &str,
    options: Option<WaitContainerOptions<T>>
) -> impl Stream<Item = Result<ContainerWaitResponse, Error>> where
    T: Into<String> + Serialize, 

---

Wait Container

Wait for a container to stop. This is a non-blocking operation, the resulting stream will end when the container stops.

Arguments

• Container name as string slice.
• Optional Wait Container Options struct.

Returns

• ContainerWaitResponse, wrapped in a Stream.

Examples

use bollard::container::WaitContainerOptions;

let options = Some(WaitContainerOptions{
    condition: "not-running",
});

docker.wait_container("hello-world", options);

pub async fn restart_container(
    &self,
    container_name: &str,
    options: Option<RestartContainerOptions>
) -> Result<(), Error>

---

Restart Container

Restart a container.

Arguments

• Container name as string slice.
• Optional Restart Container Options struct.

Returns

• unit type (), wrapped in a Future.

Examples

use bollard::container::RestartContainerOptions;

let options = Some(RestartContainerOptions{
    t: 30,
});

docker.restart_container("postgres", options);

pub async fn inspect_container(
    &self,
    container_name: &str,
    options: Option<InspectContainerOptions>
) -> Result<ContainerInspectResponse, Error>

---

Inspect Container

Inspect a container.

Arguments

• Container name as a string slice.
• Optional Inspect Container Options struct.

Returns

• ContainerInspectResponse, wrapped in a Future.

Examples

use bollard::container::InspectContainerOptions;

let options = Some(InspectContainerOptions{
    size: false,
});

docker.inspect_container("hello-world", options);

pub async fn top_processes<T>(
    &self,
    container_name: &str,
    options: Option<TopOptions<T>>
) -> Result<ContainerTopResponse, Error> where
    T: Into<String> + Serialize, 

---

Top Processes

List processes running inside a container.

Arguments

• Container name as string slice.
• Optional Top Options struct.

Returns

• ContainerTopResponse, wrapped in a Future.

Examples

use bollard::container::TopOptions;

let options = Some(TopOptions{
    ps_args: "aux",
});

docker.top_processes("fussybeaver/uhttpd", options);

pub fn logs<T>(
    &self,
    container_name: &str,
    options: Option<LogsOptions<T>>
) -> impl Stream<Item = Result<LogOutput, Error>> where
    T: Into<String> + Serialize, 

---

Logs

Get container logs.

Arguments

• Container name as string slice.
• Optional Logs Options struct.

Returns

• Log Output enum, wrapped in a Stream.

Examples

use bollard::container::LogsOptions;

use std::default::Default;

let options = Some(LogsOptions::<String>{
    stdout: true,
    ..Default::default()
});

docker.logs("hello-world", options);

pub async fn container_changes(
    &self,
    container_name: &str
) -> Result<Option<Vec<ContainerChangeResponseItem>>, Error>

---

Container Changes

Get changes on a container’s filesystem.

Arguments

• Container name as string slice.

Returns

• An Option of Vector of Container Change Response Item structs, wrapped in a Future.

Examples

docker.container_changes("hello-world");

pub fn stats(
    &self,
    container_name: &str,
    options: Option<StatsOptions>
) -> impl Stream<Item = Result<Stats, Error>>

---

Stats

Get container stats based on resource usage.

Arguments

• Container name as string slice.
• Optional Stats Options struct.

Returns

• Stats struct, wrapped in a Stream.

Examples

use bollard::container::StatsOptions;

let options = Some(StatsOptions{
    stream: false,
    one_shot: true,
});

docker.stats("hello-world", options);

pub async fn kill_container<T>(
    &self,
    container_name: &str,
    options: Option<KillContainerOptions<T>>
) -> Result<(), Error> where
    T: Into<String> + Serialize, 

---

Kill Container

Kill a container.

Arguments

• Container name as string slice.
• Optional Kill Container Options struct.

Returns

• unit type (), wrapped in a Future.

Examples

use bollard::container::KillContainerOptions;

let options = Some(KillContainerOptions{
    signal: "SIGINT",
});

docker.kill_container("postgres", options);

pub async fn update_container<T>(
    &self,
    container_name: &str,
    config: UpdateContainerOptions<T>
) -> Result<(), Error> where
    T: Into<String> + Eq + Hash + Serialize, 

---

Update Container

Update a container.

Arguments

• Container name as string slice.
• Update Container Options struct.

Returns

• unit type (), wrapped in a Future.

Examples

use bollard::container::UpdateContainerOptions;
use std::default::Default;

let config = UpdateContainerOptions::<String> {
    memory: Some(314572800),
    memory_swap: Some(314572800),
    ..Default::default()
};

docker.update_container("postgres", config);

pub async fn rename_container<T>(
    &self,
    container_name: &str,
    options: RenameContainerOptions<T>
) -> Result<(), Error> where
    T: Into<String> + Serialize, 

---

Rename Container

Rename a container.

Arguments

• Container name as string slice.
• Rename Container Options struct

Returns

• unit type (), wrapped in a Future.

Examples

use bollard::container::RenameContainerOptions;

let required = RenameContainerOptions {
    name: "my_new_container_name"
};

docker.rename_container("hello-world", required);

pub async fn pause_container(&self, container_name: &str) -> Result<(), Error>

---

Pause Container

Use the cgroups freezer to suspend all processes in a container.

Arguments

• Container name as a string slice.

Returns

• unit type (), wrapped in a Future.

Examples

docker.pause_container("postgres");

pub async fn unpause_container(&self, container_name: &str) -> Result<(), Error>

---

Unpause Container

Resume a container which has been paused.

Arguments

• Container name as a string slice.

Returns

• unit type (), wrapped in a Future.

Examples

docker.unpause_container("postgres");

pub async fn prune_containers<T>(
    &self,
    options: Option<PruneContainersOptions<T>>
) -> Result<ContainerPruneResponse, Error> where
    T: Into<String> + Eq + Hash + Serialize, 

---

Prune Containers

Delete stopped containers.

Arguments

• Optional Prune Containers Options struct.

Returns

• Container Prune Response struct, wrapped in a Future.

Examples

use bollard::container::PruneContainersOptions;

use std::collections::HashMap;

let mut filters = HashMap::new();
filters.insert("until", vec!["10m"]);

let options = Some(PruneContainersOptions{
    filters
});

docker.prune_containers(options);

pub async fn upload_to_container<T>(
    &self,
    container_name: &str,
    options: Option<UploadToContainerOptions<T>>,
    tar: Body
) -> Result<(), Error> where
    T: Into<String> + Serialize, 

---

Upload To Container

Upload a tar archive to be extracted to a path in the filesystem of container id.

Arguments

• Optional Upload To Container Options struct.

Returns

• unit type (), wrapped in a Future.

Examples

use bollard::container::UploadToContainerOptions;

use std::default::Default;
use std::fs::File;
use std::io::Read;

let options = Some(UploadToContainerOptions{
    path: "/opt",
    ..Default::default()
});

let mut file = File::open("tarball.tar.gz").unwrap();
let mut contents = Vec::new();
file.read_to_end(&mut contents).unwrap();

docker.upload_to_container("my-container", options, contents.into());

pub fn download_from_container<T>(
    &self,
    container_name: &str,
    options: Option<DownloadFromContainerOptions<T>>
) -> impl Stream<Item = Result<Bytes, Error>> where
    T: Into<String> + Serialize, 

---

Download From Container

Get a tar archive of a resource in the filesystem of container id.

Arguments

• Download From Container Options struct.

Returns

• Tar archive compressed with one of the following algorithms: identity (no compression), gzip, bzip2, xz. Hyper Body.

Examples

use bollard::container::DownloadFromContainerOptions;

let options = Some(DownloadFromContainerOptions{
    path: "/opt",
});

docker.download_from_container("my-container", options);

impl Docker

A Docker implementation typed to connect to a secure HTTPS connection using the rustls library.

pub fn connect_with_ssl_defaults() -> Result<Docker, Error>

Connect using secure HTTPS using defaults that are signalled by environment variables.

Defaults

• The connection url is sourced from the DOCKER_HOST environment variable.
• The certificate directory is sourced from the DOCKER_CERT_PATH environment variable.
• Certificates are named key.pem, cert.pem and ca.pem to indicate the private key, the server certificate and the certificate chain respectively.
• The number of threads used for the HTTP connection pool defaults to 1.
• The request timeout defaults to 2 minutes.

Examples

use bollard::Docker;

use futures_util::future::TryFutureExt;

let connection = Docker::connect_with_ssl_defaults().unwrap();
connection.ping()
  .map_ok(|_| Ok::<_, ()>(println!("Connected!")));

pub fn connect_with_ssl(
    addr: &str,
    ssl_key: &Path,
    ssl_cert: &Path,
    ssl_ca: &Path,
    timeout: u64,
    client_version: &ClientVersion
) -> Result<Docker, Error>

Connect using secure HTTPS.

Arguments

• addr: the connection url.
• ssl_key: the private key path.
• ssl_cert: the server certificate path.
• ssl_ca: the certificate chain path.
• timeout: the read/write timeout (seconds) to use for every hyper connection
• client_version: the client version to communicate with the server.

Examples

use bollard::{API_DEFAULT_VERSION, Docker};

use std::path::Path;

use futures_util::future::TryFutureExt;

let connection = Docker::connect_with_ssl(
    "tcp://localhost:2375/",
    Path::new("/certs/key.pem"),
    Path::new("/certs/cert.pem"),
    Path::new("/certs/ca.pem"),
    120,
    API_DEFAULT_VERSION).unwrap();
connection.ping()
  .map_ok(|_| Ok::<_, ()>(println!("Connected!")));

impl Docker

A Docker implementation typed to connect to an unsecure Http connection.

pub fn connect_with_http_defaults() -> Result<Docker, Error>

Connect using unsecured HTTP using defaults that are signalled by environment variables.

Defaults

• The connection url is sourced from the DOCKER_HOST environment variable, and defaults to localhost:2375.
• The number of threads used for the HTTP connection pool defaults to 1.
• The request timeout defaults to 2 minutes.

Examples

use bollard::Docker;

use futures_util::future::TryFutureExt;

let connection = Docker::connect_with_http_defaults().unwrap();
connection.ping()
  .map_ok(|_| Ok::<_, ()>(println!("Connected!")));

pub fn connect_with_http(
    addr: &str,
    timeout: u64,
    client_version: &ClientVersion
) -> Result<Docker, Error>

Connect using unsecured HTTP.

Arguments

• addr: connection url including scheme and port.
• timeout: the read/write timeout (seconds) to use for every hyper connection
• client_version: the client version to communicate with the server.

Examples

use bollard::{API_DEFAULT_VERSION, Docker};

use futures_util::future::TryFutureExt;

let connection = Docker::connect_with_http(
                   "http://my-custom-docker-server:2735", 4, API_DEFAULT_VERSION)
                   .unwrap();
connection.ping()
  .map_ok(|_| Ok::<_, ()>(println!("Connected!")));

pub fn connect_with_socket_defaults() -> Result<Docker, Error>

Connect using to either a Unix socket or a Windows named pipe using defaults common to the standard docker configuration.

Defaults

• The unix socket location defaults to /var/run/docker.sock. The windows named pipe location defaults to //./pipe/docker_engine.
• The request timeout defaults to 2 minutes.

Examples

use bollard::Docker;

use futures_util::future::TryFutureExt;

let connection = Docker::connect_with_socket_defaults().unwrap();
connection.ping().map_ok(|_| Ok::<_, ()>(println!("Connected!")));

pub fn connect_with_socket(
    path: &str,
    timeout: u64,
    client_version: &ClientVersion
) -> Result<Docker, Error>

Connect using a Unix socket or a Windows named pipe.

Arguments

• path: connection unix socket path or windows named pipe path.
• timeout: the read/write timeout (seconds) to use for every hyper connection
• client_version: the client version to communicate with the server.

Examples

use bollard::{API_DEFAULT_VERSION, Docker};

use futures_util::future::TryFutureExt;

let connection = Docker::connect_with_socket("/var/run/docker.sock", 120, API_DEFAULT_VERSION).unwrap();
connection.ping().map_ok(|_| Ok::<_, ()>(println!("Connected!")));

impl Docker

A Docker implementation typed to connect to a Unix socket.

pub fn connect_with_unix_defaults() -> Result<Docker, Error>

Connect using a Unix socket using defaults common to the standard docker configuration.

Defaults

• The socket location defaults to /var/run/docker.sock.
• The request timeout defaults to 2 minutes.

Examples

use bollard::Docker;

use futures_util::future::TryFutureExt;

let connection = Docker::connect_with_unix_defaults().unwrap();
connection.ping().map_ok(|_| Ok::<_, ()>(println!("Connected!")));

pub fn connect_with_unix(
    path: &str,
    timeout: u64,
    client_version: &ClientVersion
) -> Result<Docker, Error>

Connect using a Unix socket.

Arguments

• addr: connection socket path.
• timeout: the read/write timeout (seconds) to use for every hyper connection
• client_version: the client version to communicate with the server.

Examples

use bollard::{API_DEFAULT_VERSION, Docker};

use futures_util::future::TryFutureExt;

let connection = Docker::connect_with_unix("/var/run/docker.sock", 120, API_DEFAULT_VERSION).unwrap();
connection.ping().map_ok(|_| Ok::<_, ()>(println!("Connected!")));

impl Docker

A Docker implementation that wraps away which local implementation we are calling.

pub fn connect_with_local_defaults() -> Result<Docker, Error>

Connect using the local machine connection method with default arguments.

This is a simple wrapper over the OS specific handlers:

• Unix: Docker::connect_with_unix_defaults
• Windows: Docker::connect_with_named_pipe_defaults

pub fn connect_with_local(
    addr: &str,
    timeout: u64,
    client_version: &ClientVersion
) -> Result<Docker, Error>

Connect using the local machine connection method with supplied arguments.

This is a simple wrapper over the OS specific handlers:

• Unix: Docker::connect_with_unix
• Windows: Docker::connect_with_named_pipe

impl Docker

pub fn client_version(&self) -> ClientVersion

Return the currently set client version.

pub async fn negotiate_version(self) -> Result<Self, Error>

Check with the server for a supported version, and downgrade the client version if appropriate.

Examples:

    use bollard::Docker;

    let docker = Docker::connect_with_http_defaults().unwrap();
    async move {
        &docker.negotiate_version().await.unwrap().version();
    };

impl Docker

pub async fn create_exec<T>(
    &self,
    container_name: &str,
    config: CreateExecOptions<T>
) -> Result<CreateExecResults, Error> where
    T: Into<String> + Serialize, 

---

Create Exec

Run a command inside a running container.

Arguments

• Container name as string slice.
• Create Exec Options struct.

Returns

• A Create Exec Results struct, wrapped in a Future.

Examples

use bollard::exec::CreateExecOptions;

use std::default::Default;

let config = CreateExecOptions {
    cmd: Some(vec!["ps", "-ef"]),
    attach_stdout: Some(true),
    ..Default::default()
};

docker.create_exec("hello-world", config);

pub async fn start_exec(
    &self,
    exec_id: &str,
    config: Option<StartExecOptions>
) -> Result<StartExecResults, Error>

---

Start Exec

Starts a previously set up exec instance. If detach is true, this endpoint returns immediately after starting the command.

Arguments

• The ID of the previously created exec configuration.

Returns

• Log Output enum, wrapped in a Stream.

Examples

async {
    let message = docker.create_exec("hello-world", config).await.unwrap();
    use bollard::exec::StartExecOptions;
    docker.start_exec(&message.id, None::<StartExecOptions>);
};

pub async fn inspect_exec(
    &self,
    exec_id: &str
) -> Result<ExecInspectResponse, Error>

---

Inspect Exec

Return low-level information about an exec instance.

Arguments

• The ID of the previously created exec configuration.

Returns

• An Exec Inspect Response struct, wrapped in a Future.

Examples

async {
    let message = docker.create_exec("hello-world", config).await.unwrap();
    docker.inspect_exec(&message.id);
};

pub async fn resize_exec(
    &self,
    exec_id: &str,
    options: ResizeExecOptions
) -> Result<(), Error>

---

Resize Exec

Resize the TTY session used by an exec instance. This endpoint only works if tty was specified as part of creating and starting the exec instance.

Arguments

• The ID of the previously created exec configuration.
• Resize Exec Options struct.

Examples

async {
    let message = docker.create_exec("hello-world", config).await.unwrap();
    docker.resize_exec(&message.id, ResizeExecOptions {
        width: 80,
        height: 60
    });
};

impl Docker

pub async fn list_images<T>(
    &self,
    options: Option<ListImagesOptions<T>>
) -> Result<Vec<ImageSummary>, Error> where
    T: Into<String> + Eq + Hash + Serialize, 

---

List Images

Returns a list of images on the server. Note that it uses a different, smaller representation of an image than inspecting a single image

Arguments

• An optional List Images Options struct.

Returns

• Vector of API Images, wrapped in a Future.

Examples

use bollard::image::ListImagesOptions;

use std::collections::HashMap;
use std::default::Default;

let mut filters = HashMap::new();
filters.insert("dangling", vec!["true"]);

let options = Some(ListImagesOptions{
  all: true,
  filters,
  ..Default::default()
});

docker.list_images(options);

pub fn create_image<T>(
    &self,
    options: Option<CreateImageOptions<T>>,
    root_fs: Option<Body>,
    credentials: Option<DockerCredentials>
) -> impl Stream<Item = Result<CreateImageInfo, Error>> where
    T: Into<String> + Serialize, 

---

Create Image

Create an image by either pulling it from a registry or importing it.

Arguments

• An optional Create Image Options struct.
• An optional request body consisting of a tar or tar.gz archive with the root file system for the image. If this argument is used, the value of the from_src option must be “-”.

Returns

• Build Info, wrapped in an asynchronous Stream.

Examples

use bollard::image::CreateImageOptions;

use std::default::Default;

let options = Some(CreateImageOptions{
  from_image: "hello-world",
  ..Default::default()
});

docker.create_image(options, None, None);

// do some other work while the image is pulled from the docker hub...

Unsupported

• Import from tarball

pub async fn inspect_image(&self, image_name: &str) -> Result<Image, Error>

---

Inspect Image

Return low-level information about an image.

Arguments

• Image name as a string slice.

Returns

• Image, wrapped in a Future.

Examples

use std::default::Default;

docker.inspect_image("hello-world");

pub async fn prune_images<T>(
    &self,
    options: Option<PruneImagesOptions<T>>
) -> Result<ImagePruneResponse, Error> where
    T: Into<String> + Eq + Hash + Serialize, 

---

Prune Images

Delete unused images.

Arguments

• An optional Prune Images Options struct.

Returns

• a Prune Image Response, wrapped in a Future.

Examples

use bollard::image::PruneImagesOptions;

use std::collections::HashMap;

let mut filters = HashMap::new();
filters.insert("until", vec!["10m"]);

let options = Some(PruneImagesOptions {
  filters
});

docker.prune_images(options);

pub async fn image_history(
    &self,
    image_name: &str
) -> Result<Vec<HistoryResponseItem>, Error>

---

Image History

Return parent layers of an image.

Arguments

• Image name as a string slice.

Returns

• Vector of History Response Item, wrapped in a Future.

Examples

docker.image_history("hello-world");

pub async fn search_images<T>(
    &self,
    options: SearchImagesOptions<T>
) -> Result<Vec<ImageSearchResponseItem>, Error> where
    T: Into<String> + Eq + Hash + Serialize, 

---

Search Images

Search for an image on Docker Hub.

Arguments

• Search Image Options struct.

Returns

• Vector of Image Search Response Item results, wrapped in a Future.

Examples

use bollard::image::SearchImagesOptions;
use std::default::Default;
use std::collections::HashMap;

let mut filters = HashMap::new();
filters.insert("until", vec!["10m"]);

let search_options = SearchImagesOptions {
    term: "hello-world",
    filters,
    ..Default::default()
};

docker.search_images(search_options);

pub async fn remove_image(
    &self,
    image_name: &str,
    options: Option<RemoveImageOptions>,
    credentials: Option<DockerCredentials>
) -> Result<Vec<ImageDeleteResponseItem>, Error>

---

Remove Image

Remove an image, along with any untagged parent images that were referenced by that image.

Arguments

• Image name as a string slice.
• An optional Remove Image Options struct.

Returns

• Vector of Image Delete Response Item, wrapped in a Future.

Examples

use bollard::image::RemoveImageOptions;
use std::default::Default;

let remove_options = Some(RemoveImageOptions {
    force: true,
    ..Default::default()
});

docker.remove_image("hello-world", remove_options, None);

pub async fn tag_image<T>(
    &self,
    image_name: &str,
    options: Option<TagImageOptions<T>>
) -> Result<(), Error> where
    T: Into<String> + Serialize, 

---

Tag Image

Tag an image so that it becomes part of a repository.

Arguments

• Image name as a string slice.
• Optional Tag Image Options struct.

Returns

• unit type (), wrapped in a Future.

Examples

use bollard::image::TagImageOptions;
use std::default::Default;

let tag_options = Some(TagImageOptions {
    tag: "v1.0.1",
    ..Default::default()
});

docker.tag_image("hello-world", tag_options);

pub fn push_image<T>(
    &self,
    image_name: &str,
    options: Option<PushImageOptions<T>>,
    credentials: Option<DockerCredentials>
) -> impl Stream<Item = Result<PushImageInfo, Error>> where
    T: Into<String> + Serialize, 

---

Push Image

Push an image to a registry.

Arguments

• Image name as a string slice.
• Optional Push Image Options struct.
• Optional Docker Credentials struct.

Returns

• unit type (), wrapped in a Future.

Examples

use bollard::auth::DockerCredentials;
use bollard::image::PushImageOptions;

use std::default::Default;

let push_options = Some(PushImageOptions {
    tag: "v1.0.1",
});

let credentials = Some(DockerCredentials {
    username: Some("Jack".to_string()),
    password: Some("myverysecretpassword".to_string()),
    ..Default::default()
});

docker.push_image("hello-world", push_options, credentials);

pub async fn commit_container<T, Z>(
    &self,
    options: CommitContainerOptions<T>,
    config: Config<Z>
) -> Result<Commit, Error> where
    T: Into<String> + Serialize,
    Z: Into<String> + Eq + Hash + Serialize, 

---

Commit Container

Create a new image from a container.

Arguments

• Commit Container Options struct.
• Container Config struct.

Returns

• Commit, wrapped in a Future.

Examples

use bollard::image::CommitContainerOptions;
use bollard::container::Config;

use std::default::Default;

let options = CommitContainerOptions{
    container: "my-running-container",
    pause: true,
    ..Default::default()
};

let config = Config::<String> {
    ..Default::default()
};

docker.commit_container(options, config);

pub fn build_image<T>(
    &self,
    options: BuildImageOptions<T>,
    credentials: Option<HashMap<String, DockerCredentials>>,
    tar: Option<Body>
) -> impl Stream<Item = Result<BuildInfo, Error>> where
    T: Into<String> + Eq + Hash + Serialize, 

---

Build Image

Build an image from a tar archive with a Dockerfile in it.

The Dockerfile specifies how the image is built from the tar archive. It is typically in the archive’s root, but can be at a different path or have a different name by specifying the dockerfile parameter.

Arguments

• Build Image Options struct.
• Optional Docker Credentials struct.
• Tar archive compressed with one of the following algorithms: identity (no compression), gzip, bzip2, xz. Optional Hyper Body.

Returns

• Create Image Info, wrapped in an asynchronous Stream.

Examples

use bollard::image::BuildImageOptions;
use bollard::container::Config;

use std::default::Default;
use std::fs::File;
use std::io::Read;

let options = BuildImageOptions{
    dockerfile: "Dockerfile",
    t: "my-image",
    rm: true,
    ..Default::default()
};

let mut file = File::open("tarball.tar.gz").unwrap();
let mut contents = Vec::new();
file.read_to_end(&mut contents).unwrap();

docker.build_image(options, None, Some(contents.into()));

pub fn export_image(
    &self,
    image_name: &str
) -> impl Stream<Item = Result<Bytes, Error>>

---

Export Image

Get a tarball containing all images and metadata for a repository.

The root of the resulting tar file will contain the file “mainifest.json”. If the export is of an image repository, rather than a signle image, there will also be a repositories file with a JSON description of the exported image repositories. Additionally, each layer of all exported images will have a sub directory in the archive containing the filesystem of the layer.

See the Docker API documentation for more information.

Arguments

• The image_name string can refer to an individual image and tag (e.g. alpine:latest), an individual image by I

Returns

• An uncompressed TAR archive

pub fn import_image(
    &self,
    options: ImportImageOptions,
    root_fs: Body,
    credentials: Option<HashMap<String, DockerCredentials>>
) -> impl Stream<Item = Result<BuildInfo, Error>>

---

Import Image

Load a set of images and tags into a repository.

For details on the format, see the export image endpoint.

Arguments

• Image Import Options struct.

Returns

• Build Info, wrapped in an asynchronous Stream.

Examples

use bollard::image::ImportImageOptions;
use bollard::errors::Error;

use std::default::Default;
use futures_util::stream::StreamExt;
use tokio::fs::File;
use tokio::io::AsyncWriteExt;
use tokio_util::codec;

let options = ImportImageOptions{
    ..Default::default()
};

async move {
    let mut file = File::open("tarball.tar.gz").await.unwrap();

    let byte_stream = codec::FramedRead::new(file, codec::BytesCodec::new()).map(|r| {
        let bytes = r.unwrap().freeze();
        Ok::<_, Error>(bytes)
    });
    let body = hyper::Body::wrap_stream(byte_stream);
    let mut stream = docker
        .import_image(
            ImportImageOptions {
                ..Default::default()
            },
            body,
            None,
        );

    while let Some(response) = stream.next().await {
        // ...
    }
};

impl Docker

pub async fn create_network<T>(
    &self,
    config: CreateNetworkOptions<T>
) -> Result<NetworkCreateResponse, Error> where
    T: Into<String> + Eq + Hash + Serialize, 

---

Create Network

Create a new network.

Arguments

• Create Network Options struct.

Returns

• A Network Create Response struct, wrapped in a Future.

Examples

use bollard::network::CreateNetworkOptions;

use std::default::Default;

let config = CreateNetworkOptions {
    name: "certs",
    ..Default::default()
};

docker.create_network(config);

pub async fn remove_network(&self, network_name: &str) -> Result<(), Error>

---

Remove a Network

Arguments

• Network name as a string slice.

Returns

• unit type (), wrapped in a Future.

Examples

docker.remove_network("my_network_name");

pub async fn inspect_network<T>(
    &self,
    network_name: &str,
    options: Option<InspectNetworkOptions<T>>
) -> Result<Network, Error> where
    T: Into<String> + Serialize, 

---

Inspect a Network

Arguments

• Network name as a string slice.

Returns

• A Models struct, wrapped in a Future.

Examples

use bollard::network::InspectNetworkOptions;

use std::default::Default;

let config = InspectNetworkOptions {
    verbose: true,
    scope: "global"
};

docker.inspect_network("my_network_name", Some(config));

pub async fn list_networks<T>(
    &self,
    options: Option<ListNetworksOptions<T>>
) -> Result<Vec<Network>, Error> where
    T: Into<String> + Eq + Hash + Serialize, 

---

List Networks

Arguments

• Optional List Network Options struct.

Returns

• A vector of Network struct, wrapped in a Future.

Examples

use bollard::network::ListNetworksOptions;

use std::collections::HashMap;

let mut list_networks_filters = HashMap::new();
list_networks_filters.insert("label", vec!["maintainer=some_maintainer"]);

let config = ListNetworksOptions {
    filters: list_networks_filters,
};

docker.list_networks(Some(config));

pub async fn connect_network<T>(
    &self,
    network_name: &str,
    config: ConnectNetworkOptions<T>
) -> Result<(), Error> where
    T: Into<String> + Eq + Hash + Serialize, 

---

Connect Network

Arguments

• A Connect Network Options struct.

Returns

• unit type (), wrapped in a Future.

Examples

use bollard::network::ConnectNetworkOptions;
use bollard::models::{EndpointSettings, EndpointIpamConfig};

use std::default::Default;

let config = ConnectNetworkOptions {
    container: "3613f73ba0e4",
    endpoint_config: EndpointSettings {
        ipam_config: Some(EndpointIpamConfig {
            ipv4_address: Some(String::from("172.24.56.89")),
            ipv6_address: Some(String::from("2001:db8::5689")),
            ..Default::default()
        }),
        ..Default::default()
    }
};

docker.connect_network("my_network_name", config);

pub async fn disconnect_network<T>(
    &self,
    network_name: &str,
    config: DisconnectNetworkOptions<T>
) -> Result<(), Error> where
    T: Into<String> + Serialize, 

---

Disconnect Network

Arguments

• A Disconnect Network Options struct.

Returns

• unit type (), wrapped in a Future.

Examples

use bollard::network::DisconnectNetworkOptions;

use std::default::Default;

let config = DisconnectNetworkOptions {
    container: "3613f73ba0e4",
    force: true
};

docker.disconnect_network("my_network_name", config);

pub async fn prune_networks<T>(
    &self,
    options: Option<PruneNetworksOptions<T>>
) -> Result<NetworkPruneResponse, Error> where
    T: Into<String> + Eq + Hash + Serialize, 

---

Prune Networks

Deletes networks which are unused.

Arguments

• A Prune Networks Options struct.

Returns

• A Network Prune Response struct.

Examples

use bollard::network::PruneNetworksOptions;

use std::collections::HashMap;

let mut filters = HashMap::new();
filters.insert("label", vec!["maintainer=some_maintainer"]);

let options = PruneNetworksOptions {
    filters,
};

docker.prune_networks(Some(options));

impl Docker

pub async fn list_services<T>(
    &self,
    options: Option<ListServicesOptions<T>>
) -> Result<Vec<Service>, Error> where
    T: Into<String> + Eq + Hash + Serialize, 

---

List Services

Returns a list of services.

Arguments

• Optional ListServicesOptions struct.

Returns

• Vector of Services, wrapped in a Future.

Examples

use bollard::service::ListServicesOptions;

use std::collections::HashMap;
use std::default::Default;

let mut filters = HashMap::new();
filters.insert("mode", vec!["global"]);

let options = Some(ListServicesOptions{
    filters,
    ..Default::default()
});

docker.list_services(options);

pub async fn create_service(
    &self,
    service_spec: ServiceSpec,
    credentials: Option<DockerCredentials>
) -> Result<ServiceCreateResponse, Error>

---

Create Service

Dispatch a new service on the docker swarm

Arguments

• ServiceSpec struct.
• Optional Docker Credentials struct.

Returns

• A Service Create Response struct, wrapped in a Future.

Examples

use bollard::service::{
    ServiceSpec,
    ServiceSpecMode,
    ServiceSpecModeReplicated,
    TaskSpec,
    TaskSpecContainerSpec
};

let service = ServiceSpec {
    name: Some(String::from("my-service")),
    mode: Some(ServiceSpecMode {
        replicated: Some(ServiceSpecModeReplicated {
            replicas: Some(2)
        }),
        ..Default::default()
    }),
    task_template: Some(TaskSpec {
        container_spec: Some(TaskSpecContainerSpec {
            image: Some(String::from("hello-world")),
            ..Default::default()
        }),
        ..Default::default()
    }),
    ..Default::default()
};
let credentials = None;

docker.create_service(service, credentials);

pub async fn inspect_service(
    &self,
    service_name: &str,
    options: Option<InspectServiceOptions>
) -> Result<Service, Error>

---

Inspect Service

Inspect a service.

Arguments

• Service name or id as a string slice.
• Optional Inspect Service Options struct.

Returns

• Service, wrapped in a Future.

Examples

use bollard::service::InspectServiceOptions;

let options = Some(InspectServiceOptions{
    insert_defaults: true,
});

docker.inspect_service("my-service", options);

pub async fn delete_service(&self, service_name: &str) -> Result<(), Error>

---

Delete Service

Delete a service.

Arguments

• Service name or id as a string slice.

Returns

• unit type (), wrapped in a Future.

Examples

docker.delete_service("my-service");

pub async fn update_service(
    &self,
    service_name: &str,
    service_spec: ServiceSpec,
    options: UpdateServiceOptions,
    credentials: Option<DockerCredentials>
) -> Result<ServiceUpdateResponse, Error>

---

Update Service

Update an existing service

Arguments

• Service name or id as a string slice.
• ServiceSpec struct.
• UpdateServiceOptions struct.
• Optional Docker Credentials struct.

Returns

• A Service Update Response struct, wrapped in a Future.

Examples

use bollard::service::{
    InspectServiceOptions,
    ServiceSpec,
    ServiceSpecMode,
    ServiceSpecModeReplicated,
    TaskSpec,
    TaskSpecContainerSpec,
    UpdateServiceOptions,
};

use std::collections::HashMap;
use std::default::Default;

let result = async move {
    let service_name = "my-service";
    let current_version = docker.inspect_service(
        service_name,
        None::<InspectServiceOptions>
    ).await?.version.unwrap().index.unwrap();
    let service = ServiceSpec {
        mode: Some(ServiceSpecMode {
            replicated: Some(ServiceSpecModeReplicated {
                replicas: Some(0)
            }),
            ..Default::default()
        }),
        ..Default::default()
    };
    let options = UpdateServiceOptions {
        version: current_version,
        ..Default::default()
    };
    let credentials = None;

    docker.update_service("my-service", service, options, credentials).await
};

impl Docker

pub async fn version(&self) -> Result<Version, Error>

---

Version

Returns the version of Docker that is running and various information about the system that Docker is running on.

Returns

• Version, wrapped in a Future.

Examples

docker.version();

pub async fn info(&self) -> Result<SystemInfo, Error>

---

Info

Returns Docker client and server information that is running.

Returns

• Info, wrapped in a Future.

Examples

docker.info();

pub async fn ping(&self) -> Result<String, Error>

---

Ping

This is a dummy endpoint you can use to test if the server is accessible.

Returns

• A String, wrapped in a Future.

Examples

docker.ping();

pub fn events<T>(
    &self,
    options: Option<EventsOptions<T>>
) -> impl Stream<Item = Result<SystemEventsResponse, Error>> where
    T: Into<String> + Eq + Hash + Serialize, 

---

Events

Stream real-time events from the server.

Returns

• System Events Response, wrapped in a Stream.

Examples

use bollard::system::EventsOptions;
use chrono::{Duration, Utc};
use std::collections::HashMap;


docker.events(Some(EventsOptions::<String> {
    since: Some(Utc::now() - Duration::minutes(20)),
    until: Some(Utc::now()),
    filters: HashMap::new(),
}));

pub async fn df(&self) -> Result<SystemDataUsageResponse, Error>

---

Get data usage information

Show docker disk usage

Returns

• System Data Usage Response, wrapped in a Future.

Examples

docker.df();

impl Docker

pub async fn list_volumes<T>(
    &self,
    options: Option<ListVolumesOptions<T>>
) -> Result<VolumeListResponse, Error> where
    T: Into<String> + Eq + Hash + Serialize, 

---

List volumes

Arguments

• List Volumes Options struct.

Returns

• A [Volume List Response]VolumeListResponse) struct, wrapped in a Future.

Examples

use bollard::volume::ListVolumesOptions;

use std::collections::HashMap;

let mut filters = HashMap::new();
filters.insert("dangling", vec!("1"));

let options = ListVolumesOptions {
    filters,
};

docker.list_volumes(Some(options));

pub async fn create_volume<T>(
    &self,
    config: CreateVolumeOptions<T>
) -> Result<Volume, Error> where
    T: Into<String> + Eq + Hash + Serialize, 

---

Create Volume

Create a new volume.

Arguments

• Create Volume Options struct.

Returns

• A Volume struct, wrapped in a Future.

Examples

use bollard::volume::CreateVolumeOptions;

use std::default::Default;

let config = CreateVolumeOptions {
    name: "certs",
    ..Default::default()
};

docker.create_volume(config);

pub async fn inspect_volume(&self, volume_name: &str) -> Result<Volume, Error>

---

Inspect a Volume

Arguments

• Volume name as a string slice.

Returns

• A Volume struct, wrapped in a Future.

Examples

docker.inspect_volume("my_volume_name");

pub async fn remove_volume(
    &self,
    volume_name: &str,
    options: Option<RemoveVolumeOptions>
) -> Result<(), Error>

---

Remove a Volume

Arguments

• Volume name as a string slice.

Arguments

• Remove Volume Options struct.

Returns

• unit type (), wrapped in a Future.

Examples

use bollard::volume::RemoveVolumeOptions;

let options = RemoveVolumeOptions {
    force: true,
};

docker.remove_volume("my_volume_name", Some(options));

pub async fn prune_volumes<T>(
    &self,
    options: Option<PruneVolumesOptions<T>>
) -> Result<VolumePruneResponse, Error> where
    T: Into<String> + Eq + Hash + Serialize, 

---

Prune Volumes

Delete unused volumes.

Arguments

• A Prune Volumes Options struct.

Returns

• A Volume Prune Response struct.

Examples

use bollard::volume::PruneVolumesOptions;

use std::collections::HashMap;

let mut filters = HashMap::new();
filters.insert("label", vec!["maintainer=some_maintainer"]);

let options = PruneVolumesOptions {
    filters,
};

docker.prune_volumes(Some(options));

Trait Implementations

impl Clone for Docker

fn clone(&self) -> Docker

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Docker

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.