Struct podman_api::api::Images

pub struct Images<'podman> { /* private fields */ }

Handle for Podman Images.

Implementations

impl<'podman> Images<'podman>

pub fn new(podman: &'podman Podman) -> Self

Exports an interface for interacting with Podman Images.

pub fn get(&self, id: impl Into<Id>) -> Image<'podman>

Returns a reference to a set of operations available to a specific Image.

impl<'podman> Images<'podman>

pub async fn build(
    &self,
    opts: &ImageBuildOpts
) -> Result<LibpodImageBuildResponse>

Api Reference

Build an image from the given Dockerfile(s)

Examples:

async {
    use podman_api::Podman;
    use podman_api::opts::ImageBuildOpts;
    let podman = Podman::unix("/run/user/1000/podman/podman.sock");

    if let Err(e) = podman
        .images()
        .build(
            &ImageBuildOpts::builder()
                .remote("http://some.url.to/Dockerfile")
                .tag("myimage:1.0.0")
                .build(),
        )
        .await
    {
        eprintln!("{}", e);
    }
};

pub async fn list(
    &self,
    opts: &ImageListOpts
) -> Result<Vec<LibpodImageSummary>>

Api Reference

Returns a list of images.

Examples:

async {
    use podman_api::Podman;
    use podman_api::opts::{ImageListOpts, ImageListFilter};
    let podman = Podman::unix("/run/user/1000/podman/podman.sock");

    for image in podman
        .images()
        .list(
            &ImageListOpts::builder()
                .all(true)
                .filter([ImageListFilter::Dangling(true)])
                .build(),
        )
        .await
        .unwrap()
    {
        println!("{:?}", image);
    }
};

pub async fn pull(&self, opts: &PullOpts) -> Result<LibpodImagesPullReport>

Api Reference

Pull one or more images from a container registry.

Examples:

async {
    use podman_api::Podman;
    use podman_api::opts::PullOpts;
    let podman = Podman::unix("/run/user/1000/podman/podman.sock");

    if let Err(e) = podman
        .images()
        .pull(
            &PullOpts::builder()
                .reference("rockylinux/rockylinux:8")
                .build(),
        )
        .await
    {
        eprintln!("{}", e);
    }
};

pub async fn load(&self, image: impl AsRef<[u8]>) -> Result<ImageLoadReport>

Api Reference

Load an image (oci-archive or docker-archive) stream.

Examples:

async {
    use podman_api::Podman;
    let podman = Podman::unix("/run/user/1000/podman/podman.sock");

    let image = std::fs::read("image_archive").unwrap();

    match podman.images().load(&image).await {
        Ok(info) => println!("{:?}", info),
        Err(e) => eprintln!("{}", e),
    }
};

pub async fn import(
    &self,
    opts: &ImageImportOpts,
    image: impl AsRef<[u8]>
) -> Result<LibpodImagesPullReport>

Api Reference

Import a previously exported tarball as an image.

Examples:

async {
    use podman_api::Podman;
    use podman_api::opts::ImageImportOpts;
    let podman = Podman::unix("/run/user/1000/podman/podman.sock");

    let image = vec![0, 1];

    if let Err(e) = podman
        .images()
        .import(
            &ImageImportOpts::builder()
                .reference("rockylinux/rockylinux:8")
                .build(),
            image
        )
        .await
    {
        eprintln!("{}", e);
    }
};

pub async fn remove(
    &self,
    opts: &ImagesRemoveOpts
) -> Result<LibpodImagesRemoveReport>

Api Reference

Remove multiple images. To remove a single image use Image::delete or Image::remove.

Examples:

async {
    use podman_api::Podman;
    use podman_api::opts::ImagesRemoveOpts;
    let podman = Podman::unix("/run/user/1000/podman/podman.sock");

    match podman
        .images()
        .remove(&ImagesRemoveOpts::builder().all(true).force(true).build())
        .await
    {
        Ok(info) => println!("{:?}", info),
        Err(e) => eprintln!("{}", e),
    }
};

pub async fn prune(
    &self,
    opts: &ImagePruneOpts
) -> Result<Vec<ContainersPruneReport>>

Api Reference

Remove images that are not being used by a container.

Examples:

async {
    use podman_api::Podman;
    use podman_api::opts::ImagePruneOpts;
    let podman = Podman::unix("/run/user/1000/podman/podman.sock");

    match podman
        .images()
        .prune(
            &ImagePruneOpts::builder()
                .all(true)
                .build()
        ).await {
            Ok(report) => println!("{:?}", report),
            Err(e) => eprintln!("{}", e),
    }
};

pub async fn search(
    &self,
    opts: &ImageSearchOpts
) -> Result<Vec<LibpodImageSearchResponse>>

Api Reference

Search registries for images.

Examples:

async {
    use podman_api::Podman;
    use podman_api::opts::ImageSearchOpts;
    let podman = Podman::unix("/run/user/1000/podman/podman.sock");

    match podman
        .images()
        .search(
            &ImageSearchOpts::builder()
                .list_tags(true)
                .build()
        ).await {
            Ok(images) => println!("{:?}", images),
            Err(e) => eprintln!("{}", e),
    }
};

pub async fn export(&self, opts: &ImagesExportOpts) -> Result<Vec<u8>>

Api Reference

Export multiple images into a single object.

Examples:

async {
    use podman_api::Podman;
    use podman_api::opts::ImagesExportOpts;
    let podman = Podman::unix("/run/user/1000/podman/podman.sock");

    match podman
        .images()
        .export(
            &ImagesExportOpts::builder()
                .references(["alpine", "ubuntu"])
                .build()
        ).await {
            Ok(images) => { /* ... */ },
            Err(e) => eprintln!("{}", e),
    }
};

Trait Implementations

impl<'podman> Debug for Images<'podman>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.