Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/fussybeaver/bollard/llms.txt

Use this file to discover all available pages before exploring further.

The network API lets you create and manage user-defined Docker networks, attach containers to them, and clean up unused networks. All methods are on the Docker struct. Options builders are in bollard::query_parameters; request body structs are in bollard::models.

​
Methods

​
list_networks

pub async fn list_networks(
    &self,
    options: Option<ListNetworksOptions>,
) -> Result<Vec<Network>, Error>
Returns a list of all networks on the daemon. Options: ListNetworksOptionsBuilder
FieldTypeDescription
filters&HashMap<&str, Vec<&str>>Filter by driver, id, label, name, scope, type.
Returns: Vec<Network> 
use bollard::Docker;
use bollard::query_parameters::ListNetworksOptionsBuilder;
use std::collections::HashMap;

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

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

let options = ListNetworksOptionsBuilder::default()
    .filters(&filters)
    .build();

let networks = docker.list_networks(Some(options)).await.unwrap();
for net in &networks {
    println!("Network: {:?} driver={:?}", net.name, net.driver);
}

​
create_network

pub async fn create_network(
    &self,
    config: NetworkCreateRequest,
) -> Result<NetworkCreateResponse, Error>
Creates a new user-defined network. Config: bollard::models::NetworkCreateRequest
FieldTypeDescription
nameStringNetwork name (required).
driverOption<String>Network driver (e.g. "bridge", "overlay"). Defaults to "bridge".
ipamOption<Ipam>Custom IPAM configuration (subnets, gateways).
optionsOption<HashMap<String, String>>Driver-specific options.
labelsOption<HashMap<String, String>>Labels to apply to the network.
attachableOption<bool>Allow containers to attach to this network manually.
ingressOption<bool>Create a swarm routing-mesh network.
enable_ipv6Option<bool>Enable IPv6 on this network.
Returns: NetworkCreateResponse — contains id: Option<String> and warning: Option<String>. 
use bollard::Docker;
use bollard::models::NetworkCreateRequest;

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

let config = NetworkCreateRequest {
    name: String::from("my-app-network"),
    ..Default::default()
};

let response = docker.create_network(config).await.unwrap();
println!("Created network ID: {:?}", response.id);

​
inspect_network

pub async fn inspect_network(
    &self,
    network_name: &str,
    options: Option<InspectNetworkOptions>,
) -> Result<NetworkInspect, Error>
Returns detailed information about a network including connected containers and IPAM configuration. Options: InspectNetworkOptionsBuilder
FieldTypeDescription
verboseboolInclude detailed task and service information for swarm networks.
scope&strFilter containers attached at the given scope ("local", "swarm", "global").
Returns: NetworkInspect 
use bollard::Docker;
use bollard::query_parameters::InspectNetworkOptionsBuilder;

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

let options = InspectNetworkOptionsBuilder::default()
    .verbose(true)
    .scope("local")
    .build();

let network = docker.inspect_network("my-app-network", Some(options)).await.unwrap();
println!("Driver: {:?}", network.driver);
println!("Containers: {:?}", network.containers);

​
remove_network

pub async fn remove_network(&self, network_name: &str) -> Result<(), Error>
Removes a network by name or ID. The network must have no active endpoints (containers must be disconnected first). Returns: () 
docker.remove_network("my-app-network").await.unwrap();

​
connect_network

pub async fn connect_network(
    &self,
    network_name: &str,
    config: NetworkConnectRequest,
) -> Result<(), Error>
Connects a running container to a network. Config: bollard::models::NetworkConnectRequest
FieldTypeDescription
containerStringContainer name or ID to connect.
endpoint_configOption<EndpointSettings>Endpoint configuration including IP address assignment and aliases.
Returns: () 
use bollard::Docker;
use bollard::models::{NetworkConnectRequest, EndpointSettings, EndpointIpamConfig};

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

let config = NetworkConnectRequest {
    container: String::from("my-container"),
    endpoint_config: Some(EndpointSettings {
        ipam_config: Some(EndpointIpamConfig {
            ipv4_address: Some(String::from("172.24.56.89")),
            ..Default::default()
        }),
        ..Default::default()
    }),
};

docker.connect_network("my-app-network", config).await.unwrap();

​
disconnect_network

pub async fn disconnect_network(
    &self,
    network_name: &str,
    config: NetworkDisconnectRequest,
) -> Result<(), Error>
Disconnects a container from a network. Config: bollard::models::NetworkDisconnectRequest
FieldTypeDescription
containerStringContainer name or ID to disconnect.
forceOption<bool>Force disconnection even if the container is not running.
Returns: () 
use bollard::Docker;
use bollard::models::NetworkDisconnectRequest;

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

let config = NetworkDisconnectRequest {
    container: String::from("my-container"),
    force: Some(true),
};

docker.disconnect_network("my-app-network", config).await.unwrap();

​
prune_networks

pub async fn prune_networks(
    &self,
    options: Option<PruneNetworksOptions>,
) -> Result<NetworkPruneResponse, Error>
Removes all unused networks (networks with no connected containers). Options: PruneNetworksOptionsBuilder
FieldTypeDescription
filters&HashMap<&str, Vec<&str>>Filter by until, label.
Returns: NetworkPruneResponse — contains networks_deleted: Option<Vec<String>>.

​
Network Lifecycle Example

use bollard::Docker;
use bollard::models::{NetworkCreateRequest, NetworkConnectRequest, NetworkDisconnectRequest};

#[tokio::main]
async fn main() {
    let docker = Docker::connect_with_socket_defaults().unwrap();

    // 1. Create a bridge network
    let net = docker
        .create_network(NetworkCreateRequest {
            name: String::from("demo-net"),
            ..Default::default()
        })
        .await
        .unwrap();
    println!("Network ID: {:?}", net.id);

    // 2. Connect a container
    docker
        .connect_network(
            "demo-net",
            NetworkConnectRequest {
                container: String::from("my-container"),
                endpoint_config: None,
            },
        )
        .await
        .unwrap();

    // 3. Disconnect the container
    docker
        .disconnect_network(
            "demo-net",
            NetworkDisconnectRequest {
                container: String::from("my-container"),
                force: Some(false),
            },
        )
        .await
        .unwrap();

    // 4. Remove the network
    docker.remove_network("demo-net").await.unwrap();
    println!("Network removed");
}
Network names are resolved by the daemon and can be either names or full/short IDs. Using the full ID is safest in automated workflows to avoid ambiguity.

Build docs developers (and LLMs) love

Get started for freeTalk to us