Building a Docker Image Cleaner Tool in Go

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setup
  4. Creating the Docker Image Cleaner Tool

  5. Conclusion

Introduction

In this tutorial, we will learn how to build a Docker Image Cleaner Tool in Go. This tool will help you identify and delete unused Docker images on your local machine, freeing up disk space and improving system performance. By the end of this tutorial, you will have a working script that can be easily executed to clean up your Docker images.

Prerequisites

To follow along with this tutorial, make sure you have the following prerequisites:

  • Basic knowledge of Go programming language
  • Docker installed on your machine

Setup

Before we begin, let’s make sure we have the necessary Go packages installed. Open your terminal and execute the following commands:

go get -u github.com/docker/docker
go get -u github.com/docker/go-connections

These commands will install the required Go packages (docker and go-connections) for interacting with Docker.

Creating the Docker Image Cleaner Tool

Let’s start by creating a new Go file named cleaner.go. Open your favorite text editor and create the file with the following content:

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/docker/docker/api/types"
	"github.com/docker/docker/client"
)

func main() {
	cli, err := client.NewClientWithOpts(client.FromEnv)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Starting Docker Image Cleaner...")

	// Get a list of all Docker images
	images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
	if err != nil {
		log.Fatal(err)
	}

	// Collect unused images older than 7 days
	var unusedImages []string
	for _, image := range images {
		if len(image.RepoTags) == 0 {
			unusedImages = append(unusedImages, image.ID)
		}
	}

	fmt.Printf("Found %d unused Docker images\n", len(unusedImages))

	// Delete unused images
	for _, imageID := range unusedImages {
		_, err := cli.ImageRemove(context.Background(), imageID, types.ImageRemoveOptions{
			Force:         true,
			PruneChildren: true,
		})
		if err != nil {
			log.Printf("Failed to remove image %s: %v", imageID, err)
		} else {
			log.Printf("Image %s removed successfully", imageID)
		}
	}

	fmt.Println("Docker Image Cleaner finished!")
}

Let’s go through the code step by step:

  1. We import the required Go packages for interacting with Docker, including docker and go-connections.
  2. We define the main function as the entry point of our script.
  3. Inside the main function, we create a new Docker client using client.NewClientWithOpts(client.FromEnv).
  4. We print a starting message to indicate that the Docker Image Cleaner is running.
  5. We use cli.ImageList to retrieve a list of all Docker images on the local machine.
  6. We iterate through the images list and collect the IDs of unused images (images without any RepoTags). These are images that are no longer associated with any tags.
  7. We print the number of unused Docker images found.
  8. We iterate through the list of unused image IDs and use cli.ImageRemove to delete each image. We set the Force flag to true to forcibly remove the image and PruneChildren flag to true to remove any child images if present.

  9. If an image removal fails, we log the error. Otherwise, we log a success message.

  10. Finally, we print a completion message to indicate that the Docker Image Cleaner has finished.

    Save the cleaner.go file.

    To build and run the Docker Image Cleaner tool, execute the following command in your terminal:

    go build cleaner.go
./cleaner

    The Docker Image Cleaner tool will now scan your local machine for unused Docker images and delete them. You should see output indicating the progress of the tool and the results of image removal.

Conclusion

In this tutorial, we have learned how to build a Docker Image Cleaner Tool in Go. We used the Docker client package to interact with Docker and retrieve a list of images. We then identified unused images and removed them from the local machine. This tool can be helpful in managing disk space and optimizing the performance of your Docker environment.

Remember to regularly clean up your Docker images to free up disk space and keep your machine running smoothly.

Published:

Related Articles