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
impl Docker
sourcepub async fn list_containers<'de, T>(
&self,
options: Option<ListContainersOptions<T>>
) -> Result<Vec<ContainerSummary>, Error>where
T: Into<String> + Eq + Hash + Serialize,
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
- Optional ListContainersOptions struct.
Returns
- Vector of ContainerSummary, 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);
sourcepub 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,
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",
platform: None,
});
let config = Config {
image: Some("hello-world"),
cmd: Some(vec!["/hello"]),
..Default::default()
};
docker.create_container(options, config);
sourcepub async fn start_container<T>(
&self,
container_name: &str,
options: Option<StartContainerOptions<T>>
) -> Result<(), Error>where
T: Into<String> + Serialize,
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>>);
sourcepub 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);
sourcepub 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);
sourcepub 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);
sourcepub async fn attach_container<T>(
&self,
container_name: &str,
options: Option<AttachContainerOptions<T>>
) -> Result<AttachContainerResults, Error>where
T: Into<String> + Serialize + Default,
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
- Container name as string slice.
- Optional Attach Container Options struct.
Returns
- AttachContainerResults wrapped in a Future.
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);
sourcepub async fn resize_container_tty(
&self,
container_name: &str,
options: ResizeContainerTtyOptions
) -> Result<(), Error>
pub async fn resize_container_tty(
&self,
container_name: &str,
options: ResizeContainerTtyOptions
) -> Result<(), Error>
Resize container tty
Resize the container’s TTY.
Arguments
- Container name as string slice.
- Resize Container Tty Options struct.
Examples
use bollard::container::ResizeContainerTtyOptions;
let options = ResizeContainerTtyOptions {
width: 50,
height: 20,
};
docker.resize_container_tty("hello-world", options);
sourcepub 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);
sourcepub 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);
sourcepub 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);
sourcepub fn logs<T>(
&self,
container_name: &str,
options: Option<LogsOptions<T>>
) -> impl Stream<Item = Result<LogOutput, Error>>where
T: Into<String> + Serialize,
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);
sourcepub 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");
sourcepub fn stats(
&self,
container_name: &str,
options: Option<StatsOptions>
) -> impl Stream<Item = Result<Stats, Error>>
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);
sourcepub async fn kill_container<T>(
&self,
container_name: &str,
options: Option<KillContainerOptions<T>>
) -> Result<(), Error>where
T: Into<String> + Serialize,
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);
sourcepub async fn update_container<T>(
&self,
container_name: &str,
config: UpdateContainerOptions<T>
) -> Result<(), Error>where
T: Into<String> + Eq + Hash + Serialize,
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);
sourcepub 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);
sourcepub async fn pause_container(&self, container_name: &str) -> Result<(), Error>
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");
sourcepub async fn unpause_container(&self, container_name: &str) -> Result<(), Error>
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");
sourcepub 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);
sourcepub async fn upload_to_container<T>(
&self,
container_name: &str,
options: Option<UploadToContainerOptions<T>>,
tar: Body
) -> Result<(), Error>where
T: Into<String> + Serialize,
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());
sourcepub fn download_from_container<T>(
&self,
container_name: &str,
options: Option<DownloadFromContainerOptions<T>>
) -> impl Stream<Item = Result<Bytes, Error>>where
T: Into<String> + Serialize,
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);
source§impl Docker
impl Docker
A Docker implementation typed to connect to a secure HTTPS connection using the rustls
library.
sourcepub fn connect_with_ssl_defaults() -> Result<Docker, Error>
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
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!")));
sourcepub fn connect_with_ssl(
addr: &str,
ssl_key: &Path,
ssl_cert: &Path,
ssl_ca: &Path,
timeout: u64,
client_version: &ClientVersion
) -> Result<Docker, Error>
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 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!")));
source§impl Docker
impl Docker
A Docker implementation typed to connect to an unsecure Http connection.
sourcepub fn connect_with_http_defaults() -> Result<Docker, Error>
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 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!")));
sourcepub 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!")));
sourcepub fn connect_with_socket_defaults() -> Result<Docker, Error>
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!")));
sourcepub 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!")));
source§impl Docker
impl Docker
A Docker implementation typed to connect to a Unix socket.
sourcepub fn connect_with_unix_defaults() -> Result<Docker, Error>
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 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!")));
sourcepub 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!")));
source§impl Docker
impl Docker
A Docker implementation that wraps away which local implementation we are calling.
sourcepub fn connect_with_local_defaults() -> Result<Docker, Error>
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:
sourcepub 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
source§impl Docker
impl Docker
sourcepub fn with_timeout(self, timeout: Duration) -> Self
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.
sourcepub fn timeout(&self) -> Duration
pub fn timeout(&self) -> Duration
Get the current timeout.
This timeout is shared by all requests to the Docker Engine API.
sourcepub fn set_timeout(&mut self, timeout: Duration)
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
impl Docker
sourcepub fn client_version(&self) -> ClientVersion
pub fn client_version(&self) -> ClientVersion
Return the currently set client version.
sourcepub async fn negotiate_version(self) -> Result<Self, Error>
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
impl Docker
sourcepub 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);
sourcepub 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>);
};
sourcepub async fn inspect_exec(
&self,
exec_id: &str
) -> Result<ExecInspectResponse, Error>
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);
};
sourcepub 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
});
};
source§impl Docker
impl Docker
sourcepub 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);
sourcepub 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
- Create Image 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
sourcepub async fn inspect_image(
&self,
image_name: &str
) -> Result<ImageInspect, Error>
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
- ImageInspect, wrapped in a Future.
Examples
use std::default::Default;
docker.inspect_image("hello-world");
sourcepub 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);
sourcepub 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");
sourcepub 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);
sourcepub 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);
sourcepub async fn tag_image<T>(
&self,
image_name: &str,
options: Option<TagImageOptions<T>>
) -> Result<(), Error>where
T: Into<String> + Serialize,
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);
sourcepub 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);
sourcepub 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,
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);
sourcepub 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,
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
- 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()));
sourcepub fn export_image(
&self,
image_name: &str
) -> impl Stream<Item = Result<Bytes, Error>>
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
sourcepub 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 {
// ...
}
};
source§impl Docker
impl Docker
sourcepub 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);
sourcepub async fn remove_network(&self, network_name: &str) -> Result<(), Error>
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");
sourcepub async fn inspect_network<T>(
&self,
network_name: &str,
options: Option<InspectNetworkOptions<T>>
) -> Result<Network, Error>where
T: Into<String> + Serialize,
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));
sourcepub async fn list_networks<T>(
&self,
options: Option<ListNetworksOptions<T>>
) -> Result<Vec<Network>, Error>where
T: Into<String> + Eq + Hash + Serialize,
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));
sourcepub async fn connect_network<T>(
&self,
network_name: &str,
config: ConnectNetworkOptions<T>
) -> Result<(), Error>where
T: Into<String> + Eq + Hash + Serialize,
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);
sourcepub 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);
sourcepub 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));
source§impl Docker
impl Docker
sourcepub async fn list_secrets<T>(
&self,
options: Option<ListSecretsOptions<T>>
) -> Result<Vec<Secret>, Error>where
T: Into<String> + Eq + Hash + Serialize,
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
- Optional ListSecretsOptions struct.
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);
sourcepub async fn create_secret(
&self,
secret_spec: SecretSpec
) -> Result<IdResponse, Error>
pub async fn create_secret(
&self,
secret_spec: SecretSpec
) -> Result<IdResponse, Error>
Create Secret
Create new secret on the docker swarm.
Arguments
- SecretSpec struct.
Returns
- A IdResponse wrapped in a Future.
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);
sourcepub async fn inspect_secret(&self, secret_id: &str) -> Result<Secret, Error>
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");
sourcepub async fn delete_secret(&self, secret_id: &str) -> Result<(), Error>
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");
sourcepub async fn update_secret(
&self,
secret_id: &str,
secret_spec: SecretSpec,
options: UpdateSecretOptions
) -> Result<(), Error>
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
- Secret id or name as a string slice.
- SecretSpec struct.
- UpdateSecretOptions struct.
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
impl Docker
sourcepub async fn list_services<T>(
&self,
options: Option<ListServicesOptions<T>>
) -> Result<Vec<Service>, Error>where
T: Into<String> + Eq + Hash + Serialize,
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);
sourcepub 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);
sourcepub 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);
sourcepub async fn delete_service(&self, service_name: &str) -> Result<(), Error>
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");
sourcepub 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
};
source§impl Docker
impl Docker
sourcepub async fn info(&self) -> Result<SystemInfo, Error>
pub async fn info(&self) -> Result<SystemInfo, Error>
sourcepub fn events<T>(
&self,
options: Option<EventsOptions<T>>
) -> impl Stream<Item = Result<EventMessage, Error>>where
T: Into<String> + Eq + Hash + Serialize,
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
- System Events Response, wrapped in a Stream.
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(),
}));
sourcepub async fn df(&self) -> Result<SystemDataUsageResponse, Error>
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();
source§impl Docker
impl Docker
sourcepub 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));
sourcepub async fn create_volume<T>(
&self,
config: CreateVolumeOptions<T>
) -> Result<Volume, Error>where
T: Into<String> + Eq + Hash + Serialize,
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);
sourcepub async fn inspect_volume(&self, volume_name: &str) -> Result<Volume, Error>
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");
sourcepub 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));
sourcepub 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));