Struct bollard::Docker

source · 
pub struct Docker { /* private fields */ }
Expand description

§Docker

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

Implementations§

source§

impl Docker

source

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

§List Containers

Returns a list of containers.

§Arguments
§Returns
§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);
source

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
§Returns
§Examples
use bollard::container::{CreateContainerOptions, Config};

use std::default::Default;

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

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

docker.create_container(options, config);
source

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
§Returns
  • unit type (), wrapped in a Future.
§Examples
use bollard::container::StartContainerOptions;

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

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

§Stop Container

Stops a container.

§Arguments
§Returns
  • unit type (), wrapped in a Future.
§Examples
use bollard::container::StopContainerOptions;

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

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

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

§Remove Container

Remove a container.

§Arguments
§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);
source

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
§Returns
§Examples

use bollard::container::WaitContainerOptions;

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

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

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

§Attach Container

Attach to a container to read its output or send it input. You can attach to the same container multiple times and you can reattach to containers that have been detached.

§Arguments
§Returns
§Examples

use bollard::container::AttachContainerOptions;

let options = Some(AttachContainerOptions::<String>{
    stdin: Some(true),
    stdout: Some(true),
    stderr: Some(true),
    stream: Some(true),
    logs: Some(true),
    detach_keys: Some("ctrl-c".to_string()),
});

docker.attach_container("hello-world", options);
source

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

§Resize container tty

Resize the container’s TTY.

§Arguments
§Examples

use bollard::container::ResizeContainerTtyOptions;

let options = ResizeContainerTtyOptions {
    width: 50,
    height: 20,
};

docker.resize_container_tty("hello-world", options);
source

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

§Restart Container

Restart a container.

§Arguments
§Returns
  • unit type (), wrapped in a Future.
§Examples

use bollard::container::RestartContainerOptions;

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

docker.restart_container("postgres", options);
source

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

§Inspect Container

Inspect a container.

§Arguments
§Returns
§Examples
use bollard::container::InspectContainerOptions;

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

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

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
§Examples
use bollard::container::TopOptions;

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

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

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
§Examples

use bollard::container::LogsOptions;

use std::default::Default;

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

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

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
§Examples

docker.container_changes("hello-world");
source

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
§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);
source

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
§Returns
  • unit type (), wrapped in a Future.
§Examples

use bollard::container::KillContainerOptions;

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

docker.kill_container("postgres", options);
source

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
§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);
source

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
§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);
source

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");
source

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");
source

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
§Returns
§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);
source

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
§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());
source

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
§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);
source§

impl Docker

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

source

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!")));
source

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!")));
source

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!")));
source

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!")));
source§

impl Docker

A Docker implementation typed to connect to a Unix socket.

source

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 the value of DEFAULT_SOCKET env if its set and the URL has unix scheme; otherwise /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!")));
source

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!")));
source§

impl Docker

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

source

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:

source

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:

source§

impl Docker

source

pub fn with_timeout(self, timeout: Duration) -> Self

Set the request timeout.

This timeout is shared by all requests to the Docker Engine API.

By default, 2 minutes.

source

pub fn timeout(&self) -> Duration

Get the current timeout.

This timeout is shared by all requests to the Docker Engine API.

source

pub fn set_timeout(&mut self, timeout: Duration)

Set the request timeout.

This timeout is shared by all requests to the Docker Engine API.

By default, 2 minutes.

source§

impl Docker

source

pub fn client_version(&self) -> ClientVersion

Return the currently set client version.

source

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();
    };
source§

impl Docker

source

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
§Returns
§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);
source

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
§Examples



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

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
§Examples



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

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
§Examples
async {
    let message = docker.create_exec("hello-world", config).await.unwrap();
    docker.resize_exec(&message.id, ResizeExecOptions {
        width: 80,
        height: 60
    });
};
source§

impl Docker

source

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
§Returns
§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);
source

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
§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
source

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

§Inspect Image

Return low-level information about an image.

§Arguments
  • Image name as a string slice.
§Returns
§Examples

use std::default::Default;

docker.inspect_image("hello-world");
source

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
§Returns
§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);
source

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
§Examples

docker.image_history("hello-world");
source

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
§Returns
§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);
source

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
§Returns
§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);
source

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
§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);
source

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
§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);
source

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
§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);
source

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.

By default, the call to build specifies using BuilderV1, the first generation builder in docker daemon.

§Arguments
§Returns
§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()));
source

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
source

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
§Returns
§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 {
        // ...
    }
};
source§

impl Docker

source

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
§Returns
§Examples

use bollard::network::CreateNetworkOptions;

use std::default::Default;

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

docker.create_network(config);
source

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");
source

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));
source

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
§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));
source

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
§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);
source

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

§Disconnect Network
§Arguments
§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);
source

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
§Returns
§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));
source§

impl Docker

source

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

§List Secrets

Returns a list of secrets.

§Arguments
§Returns
  • Vector of Secret, wrapped in a Future.
§Examples
use bollard::secret::ListSecretsOptions;

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

let mut filters = HashMap::new();
filters.insert("label", vec!["secret-label=label-value"]);

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

docker.list_secrets(options);
source

pub async fn create_secret( &self, secret_spec: SecretSpec, ) -> Result<IdResponse, Error>

§Create Secret

Create new secret on the docker swarm.

§Arguments
§Returns
§Examples
use bollard::secret::SecretSpec;

use base64;

let secret_spec = SecretSpec {
    name: Some(String::from("secret-name")),
    data: Some(base64::engine::general_purpose::STANDARD.encode("secret-data")),
    ..Default::default()
};

docker.create_secret(secret_spec);
source

pub async fn inspect_secret(&self, secret_id: &str) -> Result<Secret, Error>

§Inspect Secret

Inspect a secret.

§Arguments
  • Secret id or name as a string slice.
§Returns
  • Secret, wrapped in a Future.
§Examples

docker.inspect_secret("secret-id");
docker.inspect_secret("secret-name");
source

pub async fn delete_secret(&self, secret_id: &str) -> Result<(), Error>

§Delete Secret

Delete a secret, fails when more than one service use that secret..

§Arguments
  • Secret id or name as a string slice.
§Returns
  • unit type (), wrapped in a Future.
§Examples

docker.delete_secret("secret-id");
docker.delete_secret("secret-name");
source

pub async fn update_secret( &self, secret_id: &str, secret_spec: SecretSpec, options: UpdateSecretOptions, ) -> Result<(), Error>

§Update Secret

Update an existing secret, fails when more than one service use that secret or trying update data.

§Arguments
§Returns
  • unit type (), wrapped in a Future.
§Examples

use std::collections::HashMap;
use bollard::secret::UpdateSecretOptions;

let result = async move {
    let existing = docker.inspect_secret("my-secret").await?;
    let version = existing.version.unwrap().index.unwrap();
    let mut spec = existing.spec.unwrap().clone();

    let mut labels = HashMap::new();
    labels.insert(String::from("secret-label"), String::from("label-value"));
    spec.labels = Some(labels.clone());

    let options = UpdateSecretOptions { version };

    docker.update_secret("my-secret", spec, options).await
};
source§

impl Docker

source

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
§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);
source

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
§Returns
§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);
source

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

§Inspect Service

Inspect a service.

§Arguments
§Returns
§Examples
use bollard::service::InspectServiceOptions;

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

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

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");
source

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
§Returns
§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
};
source§

impl Docker

source

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
§Examples
docker.version();
source

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();
source

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();
source

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

§Events

Stream real-time events from the server.

§Returns
§Examples
use bollard::system::EventsOptions;
use time::{Duration, OffsetDateTime};
use std::collections::HashMap;


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

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

§Get data usage information

Show docker disk usage

§Returns
§Examples
docker.df();
source§

impl Docker

source

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

§List volumes
§Arguments
§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));
source

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
§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);
source

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");
source

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
§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));
source

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
§Returns
§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§

source§

impl Clone for Docker

source§

fn clone(&self) -> Docker

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for Docker

source§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl Freeze for Docker

§

impl !RefUnwindSafe for Docker

§

impl Send for Docker

§

impl Sync for Docker

§

impl Unpin for Docker

§

impl !UnwindSafe for Docker

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

impl<T> ErasedDestructor for T
where T: 'static,

source§

impl<T> MaybeSendSync for T