Struct bollard::Docker [−][src]
pub struct Docker { /* fields omitted */ }
Expand description
Docker
The main interface for calling the Docker API. Construct a new Docker instance using one of the connect methods:
Implementations
pub async fn list_containers<'de, T>(
&self,
options: Option<ListContainersOptions<T>>
) -> Result<Vec<ContainerSummaryInner>, Error> where
T: Into<String> + Eq + Hash + Serialize,
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);
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);
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>
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>
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,
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>
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>
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,
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);
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>
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");
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);
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);
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,
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);
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");
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,
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);
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());
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);
A Docker implementation typed to connect to a secure HTTPS connection using the rustls
library.
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
andca.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!")));
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 connectionclient_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!")));
A Docker implementation typed to connect to an unsecure Http connection.
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 tolocalhost: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>
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 connectionclient_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!")));
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>
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 connectionclient_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!")));
A Docker implementation typed to connect to a Unix socket.
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 hasunix
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!")));
pub fn connect_with_unix(
path: &str,
timeout: u64,
client_version: &ClientVersion
) -> Result<Docker, Error>
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 connectionclient_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!")));
A Docker implementation that wraps away which local implementation we are calling.
Connect using the local machine connection method with default arguments.
This is a simple wrapper over the OS specific handlers:
pub fn connect_with_local(
addr: &str,
timeout: u64,
client_version: &ClientVersion
) -> Result<Docker, Error>
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
Return the currently set client version.
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();
};
pub async fn create_exec<T>(
&self,
container_name: &str,
config: CreateExecOptions<T>
) -> Result<CreateExecResults, Error> where
T: Into<String> + Serialize,
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>
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>);
};
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>
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
});
};
pub async fn list_images<T>(
&self,
options: Option<ListImagesOptions<T>>
) -> Result<Vec<ImageSummary>, Error> where
T: Into<String> + Eq + Hash + Serialize,
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,
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
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,
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>
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,
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>
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);
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,
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);
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);
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()));
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>>
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 {
// ...
}
};
pub async fn create_network<T>(
&self,
config: CreateNetworkOptions<T>
) -> Result<NetworkCreateResponse, Error> where
T: Into<String> + Eq + Hash + Serialize,
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);
Remove a Network
Arguments
- Network name as a string slice.
Returns
- unit type
()
, wrapped in a Future.
Examples
docker.remove_network("my_network_name");
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));
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));
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,
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,
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));
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>
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>
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);
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>
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
};
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(),
}));
Get data usage information
Show docker disk usage
Returns
- System Data Usage Response, wrapped in a Future.
Examples
docker.df();
pub async fn list_volumes<T>(
&self,
options: Option<ListVolumesOptions<T>>
) -> Result<VolumeListResponse, Error> where
T: Into<String> + Eq + Hash + Serialize,
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));
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);
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>
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,
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
Auto Trait Implementations
impl !RefUnwindSafe for Docker
impl !UnwindSafe for Docker
Blanket Implementations
Mutably borrows from an owned value. Read more
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more