Bollard Containers API: Complete Methods Reference

pub async fn list_containers(
    &self,
    options: Option<ListContainersOptions>,
) -> Result<Vec<ContainerSummary>, Error>

use bollard::Docker;
use bollard::query_parameters::ListContainersOptionsBuilder;
use std::collections::HashMap;

let docker = Docker::connect_with_socket_defaults().unwrap();

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

let options = ListContainersOptionsBuilder::default()
    .all(true)
    .filters(&filters)
    .build();

let containers = docker.list_containers(Some(options)).await.unwrap();

pub async fn create_container(
    &self,
    options: Option<CreateContainerOptions>,
    config: ContainerCreateBody,
) -> Result<ContainerCreateResponse, Error>

use bollard::Docker;
use bollard::query_parameters::CreateContainerOptionsBuilder;
use bollard::models::ContainerCreateBody;

let docker = Docker::connect_with_socket_defaults().unwrap();

let options = CreateContainerOptionsBuilder::default()
    .name("my-container")
    .build();

let config = ContainerCreateBody {
    image: Some("alpine:latest".to_string()),
    cmd: Some(vec!["echo".to_string(), "hello".to_string()]),
    ..Default::default()
};

let response = docker.create_container(Some(options), config).await.unwrap();
println!("Created container ID: {}", response.id);

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

docker.start_container("my-container", None).await.unwrap();

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

use bollard::Docker;
use futures_util::StreamExt;

let docker = Docker::connect_with_socket_defaults().unwrap();

let mut stream = docker.wait_container("my-container", None);
if let Some(result) = stream.next().await {
    match result {
        Ok(resp) => println!("Exit code: {}", resp.status_code),
        Err(e)   => eprintln!("Wait error: {e}"),
    }
}

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

use bollard::query_parameters::StopContainerOptionsBuilder;

let options = StopContainerOptionsBuilder::default().t(30).build();
docker.stop_container("my-container", Some(options)).await.unwrap();

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

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

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

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

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

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

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

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

pub async fn attach_container(
    &self,
    container_name: &str,
    options: Option<AttachContainerOptions>,
) -> Result<AttachContainerResults, Error>

pub struct AttachContainerResults {
    pub output: Pin<Box<dyn Stream<Item = Result<LogOutput, Error>> + Send>>,
    pub input: Pin<Box<dyn AsyncWrite + Send>>,
}

pub async fn attach_container_websocket(
    &self,
    container_name: &str,
    options: Option<AttachContainerOptions>,
) -> Result<AttachContainerResults, Error>

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

pub async fn top_processes(
    &self,
    container_name: &str,
    options: Option<TopOptions>,
) -> Result<ContainerTopResponse, Error>

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

use bollard::Docker;
use bollard::query_parameters::LogsOptionsBuilder;
use futures_util::StreamExt;

let docker = Docker::connect_with_socket_defaults().unwrap();

let options = LogsOptionsBuilder::default()
    .stdout(true)
    .stderr(true)
    .tail("50")
    .build();

let mut stream = docker.logs("my-container", Some(options));
while let Some(item) = stream.next().await {
    match item {
        Ok(log) => print!("{log}"),
        Err(e)  => eprintln!("Log error: {e}"),
    }
}

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

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

pub async fn prune_containers(
    &self,
    options: Option<PruneContainersOptions>,
) -> Result<ContainerPruneResponse, Error>

pub async fn upload_to_container(
    &self,
    container_name: &str,
    options: Option<UploadToContainerOptions>,
    tar: BodyType,
) -> Result<(), Error>

#[deprecated(since = "0.19.0", note = "Use upload_to_container")]
pub async fn upload_to_container_streaming(
    &self,
    container_name: &str,
    options: Option<UploadToContainerOptions>,
    tar: impl Stream<Item = Bytes> + Send + 'static,
) -> Result<(), Error>

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

use bollard::Docker;
use bollard::query_parameters::DownloadFromContainerOptionsBuilder;
use futures_util::TryStreamExt;

let docker = Docker::connect_with_socket_defaults().unwrap();

let options = DownloadFromContainerOptionsBuilder::default()
    .path("/opt")
    .build();

let bytes: Vec<_> = docker
    .download_from_container("my-container", Some(options))
    .try_collect()
    .await
    .unwrap();
println!("Downloaded {} chunks", bytes.len());

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

use bollard::Docker;
use futures_util::TryStreamExt;
use tokio::io::AsyncWriteExt;

let docker = Docker::connect_with_socket_defaults().unwrap();

let chunks: Vec<_> = docker
    .export_container("my-container")
    .try_collect()
    .await
    .unwrap();

let mut file = tokio::fs::File::create("container.tar").await.unwrap();
for chunk in chunks {
    file.write_all(&chunk).await.unwrap();
}

pub async fn get_container_archive_info(
    &self,
    container_name: &str,
    options: Option<ContainerArchiveInfoOptions>,
) -> Result<PathStatResponse, Error>

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

pub async fn list_checkpoints(
    &self,
    container_name: &str,
    options: Option<ListCheckpointsOptions>,
) -> Result<Vec<Checkpoint>, Error>

pub async fn delete_checkpoint(
    &self,
    container_name: &str,
    checkpoint_id: &str,
    options: Option<DeleteCheckpointOptions>,
) -> Result<(), Error>

pub enum LogOutput {
    StdErr { message: Bytes },
    StdOut { message: Bytes },
    StdIn  { message: Bytes },
    Console { message: Bytes },
}