or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

container.mddocker-client.mdimage.mdindex.mdplugin.mdswarm.mdvolume-network.md
tile.json

volume-network.mddocs/

Volume and Network Operations

Docker volume and network management capabilities including creation, inspection, removal, and connection management. Volume and network instances are obtained through Docker client factory methods.

Volume Operations

Volume Instance

Volume objects represent Docker volumes for persistent data storage.

/**
 * Volume instance representing a Docker volume
 */
class Volume {
  /** Volume name */
  name: string;
  /** Docker modem instance for API communication */
  modem: any;
  
  constructor(modem: any, name: string);
}

Usage Examples:

const Docker = require('dockerode');
const docker = new Docker();

// Get volume instance by name
const volume = docker.getVolume('my-volume');

Volume Management

Core volume operations for inspection and removal.

/**
 * Get volume details and configuration
 * @param opts - Inspection options
 * @param callback - Optional callback
 * @returns Promise resolving to volume details
 */
inspect(opts?: VolumeInspectOptions, callback?: Function): Promise<VolumeInspectInfo>;

/**
 * Remove volume
 * @param opts - Remove options
 * @param callback - Optional callback
 * @returns Promise resolving to remove result
 */
remove(opts?: VolumeRemoveOptions, callback?: Function): Promise<object>;

interface VolumeInspectOptions {
  /** AbortSignal for request cancellation */
  abortSignal?: AbortSignal;
}

interface VolumeRemoveOptions {
  /** Force removal of volume */
  force?: boolean;
  /** AbortSignal for request cancellation */
  abortSignal?: AbortSignal;
}

interface VolumeInspectInfo {
  CreatedAt: string;
  Driver: string;
  Labels: { [key: string]: string };
  Mountpoint: string;
  Name: string;
  Options: { [key: string]: string };
  Scope: string;
  Status?: { [key: string]: any };
  UsageData?: {
    RefCount: number;
    Size: number;
  };
}

Usage Examples:

// Get volume details
const volumeInfo = await volume.inspect();
console.log(`Volume name: ${volumeInfo.Name}`);
console.log(`Driver: ${volumeInfo.Driver}`);
console.log(`Mountpoint: ${volumeInfo.Mountpoint}`);
console.log(`Created: ${volumeInfo.CreatedAt}`);

if (volumeInfo.UsageData) {
  console.log(`Size: ${volumeInfo.UsageData.Size} bytes`);
  console.log(`Reference count: ${volumeInfo.UsageData.RefCount}`);
}

// Remove volume
await volume.remove({ force: true });

Volume Creation and Management (Docker Client)

Volume creation and listing operations available on the Docker client.

/**
 * Create a new volume (available on Docker client)
 * @param opts - Volume creation options
 * @param callback - Optional callback
 * @returns Promise resolving to Volume instance
 */
docker.createVolume(opts?: VolumeCreateOptions, callback?: Function): Promise<Volume>;

/**
 * List volumes with filtering options (available on Docker client)
 * @param opts - Filtering and query options
 * @param callback - Optional callback
 * @returns Promise resolving to volumes response
 */
docker.listVolumes(opts?: ListVolumesOptions, callback?: Function): Promise<VolumeListResponse>;

/**
 * Remove unused volumes (available on Docker client)
 * @param opts - Prune options
 * @param callback - Optional callback
 * @returns Promise resolving to pruned volumes info
 */
docker.pruneVolumes(opts?: PruneVolumesOptions, callback?: Function): Promise<VolumesPruneResponse>;

interface VolumeCreateOptions {
  /** Volume name */
  Name?: string;
  /** Volume driver name */
  Driver?: string;
  /** Driver-specific options */
  DriverOpts?: { [key: string]: string };
  /** Volume labels */
  Labels?: { [key: string]: string };
  /** AbortSignal for request cancellation */
  abortSignal?: AbortSignal;
}

interface ListVolumesOptions {
  /** Volume filters */
  filters?: {
    /** Filter by driver */
    driver?: string[];
    /** Filter by label */
    label?: string[];
    /** Filter by name */
    name?: string[];
    /** Filter by dangling status */
    dangling?: boolean[];
  };
  /** AbortSignal for request cancellation */
  abortSignal?: AbortSignal;
}

interface VolumeListResponse {
  Volumes: VolumeInspectInfo[];
  Warnings: string[];
}

interface PruneVolumesOptions {
  /** Prune filters */
  filters?: {
    /** Filter by label */
    label?: string[];
  };
  /** AbortSignal for request cancellation */
  abortSignal?: AbortSignal;
}

interface VolumesPruneResponse {
  VolumesDeleted: string[];
  SpaceReclaimed: number;
}

Usage Examples:

// Create volume
const volume = await docker.createVolume({
  Name: 'my-app-data',
  Driver: 'local',
  Labels: {
    'com.example.app': 'my-app',
    'com.example.environment': 'production'
  }
});

// List all volumes
const volumeList = await docker.listVolumes();
volumeList.Volumes.forEach(vol => {
  console.log(`${vol.Name}: ${vol.Driver} (${vol.Mountpoint})`);
});

// List volumes with filtering
const filteredVolumes = await docker.listVolumes({
  filters: {
    dangling: [false],
    label: ['com.example.app=my-app']
  }
});

// Remove unused volumes
const pruneResult = await docker.pruneVolumes();
console.log(`Removed volumes: ${pruneResult.VolumesDeleted.join(', ')}`);
console.log(`Space reclaimed: ${pruneResult.SpaceReclaimed} bytes`);

Network Operations

Network Instance

Network objects represent Docker networks for container connectivity.

/**
 * Network instance representing a Docker network
 */
class Network {
  /** Network ID */
  id: string;
  /** Docker modem instance for API communication */
  modem: any;
  
  constructor(modem: any, id: string);
}

Usage Examples:

const Docker = require('dockerode');
const docker = new Docker();

// Get network instance by ID or name
const network = docker.getNetwork('my-network');
const networkById = docker.getNetwork('3c7b2c5e8f9a...');

Network Management

Core network operations for inspection, removal, and connection management.

/**
 * Get network details and configuration
 * @param opts - Inspection options
 * @param callback - Optional callback
 * @returns Promise resolving to network details
 */
inspect(opts?: NetworkInspectOptions, callback?: Function): Promise<NetworkInspectInfo>;

/**
 * Remove network
 * @param opts - Remove options
 * @param callback - Optional callback
 * @returns Promise resolving to remove result
 */
remove(opts?: NetworkRemoveOptions, callback?: Function): Promise<object>;

/**
 * Connect container to network
 * @param opts - Connection options
 * @param callback - Optional callback
 * @returns Promise resolving to connect result
 */
connect(opts: NetworkConnectOptions, callback?: Function): Promise<object>;

/**
 * Disconnect container from network
 * @param opts - Disconnection options
 * @param callback - Optional callback
 * @returns Promise resolving to disconnect result
 */
disconnect(opts: NetworkDisconnectOptions, callback?: Function): Promise<object>;

interface NetworkInspectOptions {
  /** Include verbose information */
  verbose?: boolean;
  /** Include task details in swarm services */
  scope?: string;
  /** AbortSignal for request cancellation */
  abortSignal?: AbortSignal;
}

interface NetworkRemoveOptions {
  /** AbortSignal for request cancellation */
  abortSignal?: AbortSignal;
}

interface NetworkConnectOptions {
  /** Container to connect */
  Container: string;
  /** Endpoint configuration */
  EndpointConfig?: EndpointSettings;
  /** AbortSignal for request cancellation */
  abortSignal?: AbortSignal;
}

interface NetworkDisconnectOptions {
  /** Container to disconnect */
  Container: string;
  /** Force disconnection */
  Force?: boolean;
  /** AbortSignal for request cancellation */
  abortSignal?: AbortSignal;
}

interface NetworkInspectInfo {
  Name: string;
  Id: string;
  Created: string;
  Scope: string;
  Driver: string;
  EnableIPv6: boolean;
  IPAM: IPAM;
  Internal: boolean;
  Attachable: boolean;
  Ingress: boolean;
  ConfigFrom: {
    Network: string;
  };
  ConfigOnly: boolean;
  Containers: { [containerId: string]: NetworkContainer };
  Options: { [key: string]: string };
  Labels: { [key: string]: string };
}

interface IPAM {
  Driver: string;
  Options: { [key: string]: string };
  Config: IPAMConfig[];
}

interface IPAMConfig {
  Subnet: string;
  IPRange?: string;
  Gateway?: string;
  AuxiliaryAddresses?: { [key: string]: string };
}

interface NetworkContainer {
  Name: string;
  EndpointID: string;
  MacAddress: string;
  IPv4Address: string;
  IPv6Address: string;
}

interface EndpointSettings {
  /** IP address assignment mode */
  IPAMConfig?: {
    /** Static IPv4 address */
    IPv4Address?: string;
    /** Static IPv6 address */
    IPv6Address?: string;
    /** Additional IP addresses */
    LinkLocalIPs?: string[];
  };
  /** Network aliases */
  Aliases?: string[];
  /** Network ID */
  NetworkID?: string;
  /** Endpoint ID */
  EndpointID?: string;
  /** Gateway address */
  Gateway?: string;
  /** IP address */
  IPAddress?: string;
  /** IP prefix length */
  IPPrefixLen?: number;
  /** IPv6 gateway */
  IPv6Gateway?: string;
  /** Global IPv6 address */
  GlobalIPv6Address?: string;
  /** Global IPv6 prefix length */
  GlobalIPv6PrefixLen?: number;
  /** MAC address */
  MacAddress?: string;
  /** Driver options */
  DriverOpts?: { [key: string]: string };
}

Usage Examples:

// Get network details
const networkInfo = await network.inspect();
console.log(`Network name: ${networkInfo.Name}`);
console.log(`Driver: ${networkInfo.Driver}`);
console.log(`Subnet: ${networkInfo.IPAM.Config[0]?.Subnet}`);

// List connected containers
Object.entries(networkInfo.Containers).forEach(([id, container]) => {
  console.log(`Container ${container.Name}: ${container.IPv4Address}`);
});

// Connect container to network
await network.connect({
  Container: 'my-container',
  EndpointConfig: {
    IPAMConfig: {
      IPv4Address: '172.20.0.100'
    },
    Aliases: ['web-server']
  }
});

// Disconnect container from network
await network.disconnect({
  Container: 'my-container',
  Force: false
});

// Remove network
await network.remove();

Network Creation and Management (Docker Client)

Network creation and listing operations available on the Docker client.

/**
 * Create a new network (available on Docker client)
 * @param opts - Network creation options
 * @param callback - Optional callback
 * @returns Promise resolving to Network instance
 */
docker.createNetwork(opts: NetworkCreateOptions, callback?: Function): Promise<Network>;

/**
 * List networks with filtering options (available on Docker client)
 * @param opts - Filtering and query options
 * @param callback - Optional callback
 * @returns Promise resolving to network list
 */
docker.listNetworks(opts?: ListNetworksOptions, callback?: Function): Promise<NetworkInfo[]>;

/**
 * Remove unused networks (available on Docker client)
 * @param opts - Prune options
 * @param callback - Optional callback
 * @returns Promise resolving to pruned networks info
 */
docker.pruneNetworks(opts?: PruneNetworksOptions, callback?: Function): Promise<NetworksPruneResponse>;

interface NetworkCreateOptions {
  /** Network name */
  Name: string;
  /** Check for duplicate networks */
  CheckDuplicate?: boolean;
  /** Network driver */
  Driver?: string;
  /** Enable IPv6 */
  EnableIPv6?: boolean;
  /** IPAM configuration */
  IPAM?: {
    Driver?: string;
    Config?: IPAMConfig[];
    Options?: { [key: string]: string };
  };
  /** Internal network */
  Internal?: boolean;
  /** Attachable in swarm mode */
  Attachable?: boolean;
  /** Ingress network */
  Ingress?: boolean;
  /** Configuration only network */
  ConfigOnly?: boolean;
  /** Copy configuration from network */
  ConfigFrom?: {
    Network: string;
  };
  /** Driver options */
  Options?: { [key: string]: string };
  /** Network labels */
  Labels?: { [key: string]: string };
  /** AbortSignal for request cancellation */
  abortSignal?: AbortSignal;
}

interface ListNetworksOptions {
  /** Network filters */
  filters?: {
    /** Filter by driver */
    driver?: string[];
    /** Filter by ID */
    id?: string[];
    /** Filter by label */
    label?: string[];
    /** Filter by name */
    name?: string[];
    /** Filter by scope */
    scope?: string[];
    /** Filter by type */
    type?: string[];
  };
  /** AbortSignal for request cancellation */
  abortSignal?: AbortSignal;
}

interface NetworkInfo {
  Name: string;
  Id: string;
  Created: string;
  Scope: string;
  Driver: string;
  EnableIPv6: boolean;
  IPAM: IPAM;
  Internal: boolean;
  Attachable: boolean;
  Ingress: boolean;
  ConfigFrom: {
    Network: string;
  };
  ConfigOnly: boolean;
  Options: { [key: string]: string };
  Labels: { [key: string]: string };
}

interface PruneNetworksOptions {
  /** Prune filters */
  filters?: {
    /** Filter by created time */
    until?: string[];
    /** Filter by label */
    label?: string[];
  };
  /** AbortSignal for request cancellation */
  abortSignal?: AbortSignal;
}

interface NetworksPruneResponse {
  NetworksDeleted: string[];
}

Usage Examples:

// Create custom bridge network
const network = await docker.createNetwork({
  Name: 'my-app-network',
  Driver: 'bridge',
  IPAM: {
    Config: [{
      Subnet: '172.20.0.0/16',
      Gateway: '172.20.0.1'
    }]
  },
  Labels: {
    'com.example.app': 'my-app',
    'com.example.environment': 'production'
  }
});

// Create overlay network for swarm
const swarmNetwork = await docker.createNetwork({
  Name: 'my-overlay-network',
  Driver: 'overlay',
  Attachable: true,
  Labels: {
    'com.example.type': 'overlay'
  }
});

// List all networks
const networks = await docker.listNetworks();
networks.forEach(net => {
  console.log(`${net.Name}: ${net.Driver} (${net.Scope})`);
});

// List networks with filtering
const filteredNetworks = await docker.listNetworks({
  filters: {
    driver: ['bridge'],
    label: ['com.example.app=my-app']
  }
});

// Remove unused networks
const pruneResult = await docker.pruneNetworks();
console.log(`Removed networks: ${pruneResult.NetworksDeleted.join(', ')}`);

Advanced Network Usage

Common network usage patterns and configurations.

Usage Examples:

// Create container with custom network
const container = await docker.createContainer({
  Image: 'nginx:latest',
  name: 'web-server',
  NetworkingConfig: {
    EndpointsConfig: {
      'my-app-network': {
        IPAMConfig: {
          IPv4Address: '172.20.0.10'
        },
        Aliases: ['web']
      }
    }
  }
});

// Connect existing container to multiple networks
const existingContainer = docker.getContainer('existing-container');
const network1 = docker.getNetwork('network1');
const network2 = docker.getNetwork('network2');

await network1.connect({
  Container: 'existing-container',
  EndpointConfig: {
    Aliases: ['service1']
  }
});

await network2.connect({
  Container: 'existing-container',
  EndpointConfig: {
    Aliases: ['service2']
  }
});

// Inspect network to see connected containers
const networkDetails = await network.inspect();
console.log('Connected containers:');
Object.entries(networkDetails.Containers).forEach(([id, container]) => {
  console.log(`- ${container.Name}: ${container.IPv4Address}`);
});