Best way to delete created image

[mu88]

Hello,

First of all, thank you for this amazing project 👏🏻

Within a NUnit test, I want to achieve the following:

1. Build a unique Docker image (i.e. one image per test run) of my app using the .NET SDK Container Building Tools (i.e. no Dockerfile).
2. Spawn a container of my app and execute a health check.
3. When running locally and in case the health check succeeds, remove the built Docker image of #1.

I want to execute #3 to not leave any remnants in case there are no errors. Otherwise, I end up with 50 Docker images when executing the test 50 times (in case it succeeds).
However, in case there are errors, I don't want the built image to be deleted, so I can reproduce what went wrong (via the unique tag).

I wrote some code which at least handles the happy case (i.e. remove the built image):

Expand to see my code

[Category("System")]
public class SystemTests
{
    private CancellationTokenSource _cancellationTokenSource;
    private CancellationToken _cancellationToken;
    private DockerClient _dockerClient;
    private string _tempVersion;

    [SetUp]
    public void Setup()
    {
        _cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromMinutes(1));
        _cancellationToken = _cancellationTokenSource.Token;
        _dockerClient = new DockerClientConfiguration().CreateClient();
        _tempVersion = GenerateContainerImageTag();
    }

    [TearDown]
    public async Task Teardown()
    {
        if (!string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("GITHUB_ACTIONS")))
        {
            return; // no need to clean up on GitHub Actions runners
        }

        var dockerImageIds = (await _dockerClient.Images.ListImagesAsync(new ImagesListParameters(), _cancellationToken))
                             .Where(image => image.RepoTags.Any(tag => tag.Contains(_tempVersion, StringComparison.Ordinal)))
                             .Select(image => image.ID)
                             .Distinct(StringComparer.Ordinal);

        foreach (var dockerImageId in dockerImageIds)
        {
            var runningContainerIds = (await _dockerClient.Containers.ListContainersAsync(new ContainersListParameters(), _cancellationToken))
                                      .Where(container => string.Equals(container.ImageID, dockerImageId, StringComparison.Ordinal))
                                      .Select(container => container.ID)
                                      .Distinct(StringComparer.Ordinal);
            foreach (var runningContainerId in runningContainerIds)
            {
                await _dockerClient.Containers.StopContainerAsync(runningContainerId, new ContainerStopParameters(), _cancellationToken);
                await _dockerClient.Containers.RemoveContainerAsync(runningContainerId, new ContainerRemoveParameters { Force = true }, _cancellationToken);
            }

            await _dockerClient.Images.DeleteImageAsync(dockerImageId, new ImageDeleteParameters { Force = true }, _cancellationToken);
        }

        _dockerClient.Dispose();
        _cancellationTokenSource.Dispose();
    }

    [Test]
    public async Task AppRunningInDocker_ShouldBeHealthy()
    {
        // Arrange
        var containerImageTag = GenerateContainerImageTag();
        await BuildDockerImageOfAppAsync(containerImageTag, _cancellationToken);
        var container = await StartAppContainerAsync(containerImageTag, _cancellationToken);
        var httpClient = new HttpClient { BaseAddress = GetAppBaseAddress(container) };

        // Act
        var healthCheckResponse = await httpClient.GetAsync("healthz", _cancellationToken);

        // Assert
        healthCheckResponse.IsSuccessStatusCode.Should().BeTrue();
    }

    private static async Task<IContainer> StartAppContainerAsync(string imageTag, CancellationToken cancellationToken)
    {
        var network = new NetworkBuilder().Build();
        await network.CreateAsync(cancellationToken);

        var container = new ContainerBuilder($"myapp:{imageTag}-chiseled")
                        .WithNetwork(network)
                        .WithPortBinding(8080, true)
                        .WithWaitStrategy(Wait.ForUnixContainer().UntilMessageIsLogged("Content root path: /app", s => s.WithTimeout(TimeSpan.FromSeconds(30))))
                        .Build();

        await container.StartAsync(cancellationToken);

        return container;
    }

    private static async Task BuildDockerImageOfAppAsync(string containerImageTag, CancellationToken cancellationToken)
    {
        var rootDirectory = GetRootPath();
        var projectFile = Path.Join(rootDirectory, "src", "MyCompany.MyApp", "MyCompany.MyApp.csproj");

        var process = new Process
        {
            StartInfo = new ProcessStartInfo
            {
                FileName = "dotnet",
                Arguments = $"publish {projectFile} --os linux --arch amd64 /t:PublishContainer /p:ContainerImageTag={containerImageTag}",
                UseShellExecute = false,
                RedirectStandardOutput = true,
                CreateNoWindow = true
            }
        };

        process.Start();
        while (await process.StandardOutput.ReadLineAsync(cancellationToken) is { } line)
        {
            Console.WriteLine(line);
        }

        await process.WaitForExitAsync(cancellationToken);
        process.ExitCode.Should().Be(0);
    }

    private static Uri GetAppBaseAddress(IContainer container) => new($"http://{container.Hostname}:{container.GetMappedPublicPort(8080)}");

    private static string GetRootPath() => Directory.GetParent(Environment.CurrentDirectory)?.Parent?.Parent?.Parent?.Parent?.FullName ?? throw new NullReferenceException();

    private static string GenerateContainerImageTag() => $"system-test-{DateTimeOffset.UtcNow.ToUnixTimeSeconds()}";
}

While that works nicely, it feels to me that I now "compete" with the Testcontainers runtime for my app container's state handling - instead of letting Testcontainers handle the shutdown of my app's container, I do this so that I can remove the image.
Therefore, I'm wondering whether Testcontainers offers a smarter solution instead of my rather manual approach 🤔

I appreciate your help!

[HofmeisterAn]

If your Dockerfile (image build) is small, doesn't have many layers, and doesn't rely heavily on BuildKit features, you can use the Testcontainers' image builder. You can configure it that the resource reaper (Ryuk) also cleans up intermediate layers and deletes the image. I usually don't recommend this because of limitations in the Docker Engine API (we can't take advantage of BuildKit).

There are two other approaches. If you build the image as shown in your example (it looks a bit unconventional), you can use ResourceReaper.DefaultSessionId and label the image accordingly. In that case, the image will be cleaned up by the resource reaper instance that Testcontainers maintain.

The other approach is to slightly change how you build the image and start your own resource reaper instance that specifically takes care of cleaning up the image.

[mu88]

Okay, thank you very much, I will give it a try