Hello Podman using .NET

This article shows how to control Podman from .NET. Podman is a container engine, like Docker, that is available on Linux, Windows (using the Windows Subsystem for Linux), and macOS (using a Linux virtual machine). The Podman executable is command-line compatible with Docker, and Podman also supports the Docker HTTP API. Now .NET programmers can use Podman and Docker through the Docker.DotNet library.

Prerequisites

Make sure you have the latest version of .NET installed. On Fedora and on Red Hat Enterprise Linux version 8 or 9, the latest stable version can be installed from the default repositories:

$ sudo dnf install -y dotnet-sdk-6.0

If you are running another flavor of Linux, you can find installation instructions at Install .NET on Linux.

If you haven't already, install Podman using the documentation at Podman Installation Instructions. On Fedora and Red Hat Enterprise Linux you can install it with:

$ sudo dnf install -y podman

Enabling the Podman user socket

Docker uses a daemon that runs with elevated privileges. Podman doesn't have such a daemon. For greater security, everything is handled by the podman executable, which runs as the user who invokes it.

The HTTP API can be provided through a systemd socket. To enable it, run the following command:

$ systemctl --user enable --now podman.socket

This command creates a Unix domain socket at /run/user/{uid}/podman/podman.sock. When a message arrives at this socket, systemd runs podman to handle the API calls.

Using Podman from .NET

The Docker.DotNet library can be used to control Docker through its HTTP API. Because Podman supports that API, you can use the library with Podman, too.

Start by creating a console application and add a reference to the Docker.DotNet library:

$ dotnet new console -o PodmanDemo
$ cd PodmanDemo
$ dotnet add package Docker.DotNet

Now write a method that creates a DockerClient instance. Your client connects to Podman if podman.sock exists, and to Docker otherwise.

Replace the contents of Program.cs with the following CreateClient method:

using Docker.DotNet;
using Docker.DotNet.Models;
using System.Runtime.InteropServices;

DockerClient CreateClient()
{
    return new DockerClientConfiguration(new Uri(GetClientUri())).CreateClient();

    string GetClientUri()
    {
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
        {
            return "npipe://./pipe/docker_engine";
        }
        else
        {
            string podmanPath = $"/run/user/{geteuid()}/podman/podman.sock";
            if (File.Exists(podmanPath))
            {
                return $"unix:{podmanPath}";
            }

            return "unix:/var/run/docker.sock";
        }
    }

    [DllImport("libc")]
    static extern uint geteuid();
}

For this demo application, we'll pull the Red Hat .NET 6 UBI image and run the dotnet –version command in it. So add variables for the image and the command to the end of the file Program.cs:

var image = "registry.access.redhat.com/ubi8/dotnet-60:latest";
var command = new[] { "dotnet", "--version" };

Finally, add the code that pulls the image and executes the command in a container:

var client = CreateClient();

Console.WriteLine("Pull the image.");
await client.Images.CreateImageAsync(new()
{
    FromImage = image
}, authConfig: null, progress: new Progress<JSONMessage>());


Console.WriteLine("Create a container for running the command.");
var container = await client.Containers.CreateContainerAsync(new()
{
    Image = image,
    Cmd = command
});

try
{
    Console.WriteLine("Start the container.");
    await client.Containers.StartContainerAsync(container.ID, new());

    Console.WriteLine("Wait till the container terminates.");
    var waitResponse = await client.Containers.WaitContainerAsync(container.ID);
    int exitCode = (int)waitResponse.StatusCode;

    Console.WriteLine("Read the logs.");
    var logStream = await client.Containers.GetContainerLogsAsync(container.ID, tty: false, new()
    {
        ShowStdout = true,
        ShowStderr = true
    });
    (string stdout, string stderr) = await logStream.ReadOutputToEndAsync(default);

    Console.WriteLine("Output:");
    string output = (exitCode == 0 ? stdout : stderr).Trim();
    Console.WriteLine(output);

    return exitCode;
}
finally
{
    await client.Containers.RemoveContainerAsync(container.ID, new());
}

Now you can run the application:

$ dotnet run
Pull the image.
Create a container for running the command.
Start the container.
Wait till the container terminates.
Read the logs.
Output:
6.0.102

Conclusion

In this article, you've learned how to use .NET's Docker.DotNet library to work with containers on systems managing containers with either Docker or Podman.