How to use docker buildx history open command to view build details

Introduction

In this lab, you will learn how to use the docker buildx history open command to view detailed information about your Docker builds. You will begin by building a simple Docker image using a Dockerfile, which outlines the steps to create the image.

Following the image build, you will explore how to list the history of your builds. Finally, you will utilize the docker buildx history open command to open and inspect the details of a specific build directly within Docker Desktop, providing a visual and comprehensive overview of the build process.

Skills Graph

Build a simple Docker image

In this step, you will learn how to build a simple Docker image using a Dockerfile. A Dockerfile is a text document that contains all the commands a user could call on the command line to assemble an image. Docker can build images automatically by reading the instructions from a Dockerfile.

First, navigate to the ~/project directory, which is your working directory for this lab.

cd ~/project

Now, let's create a simple Dockerfile. We will create a file named Dockerfile in the ~/project directory.

nano Dockerfile

Inside the nano editor, paste the following content:

FROM ubuntu:latest
RUN apt-get update && apt-get install -y cowsay
CMD ["cowsay", "Hello, Docker!"]

Let's break down this Dockerfile:

• FROM ubuntu:latest: This instruction specifies the base image for our new image. We are starting with the latest version of the Ubuntu operating system.
• RUN apt-get update && apt-get install -y cowsay: This instruction executes commands during the image build process. We are updating the package list and installing the cowsay package, which is a simple program that displays text in a cow's speech bubble.
• CMD ["cowsay", "Hello, Docker!"]: This instruction provides the default command to execute when a container is started from this image. In this case, it will run the cowsay command with the argument "Hello, Docker!".

Save the file by pressing Ctrl + X, then Y, and Enter.

Now that we have our Dockerfile, we can build the Docker image. Use the docker build command. The -t flag is used to tag the image with a name and optionally a tag in the name:tag format. The . at the end of the command tells Docker to look for the Dockerfile in the current directory.

docker build -t my-cowsay-image:latest .

You will see output indicating that Docker is building the image layer by layer, executing the instructions in the Dockerfile. This process might take a few moments as it downloads the base image and installs the cowsay package.

Once the build is complete, you can verify that the image has been created by listing the available images using the docker images command.

docker images

You should see my-cowsay-image listed in the output.

Finally, let's run a container from the image we just built to see if it works as expected.

docker run my-cowsay-image:latest

You should see the output of the cowsay command:

 _______
< Hello, Docker! >
 -------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||

This confirms that our Docker image was built correctly and the default command is executing as intended.

List build history

In this step, you will learn how to view the history of a Docker image, which shows the layers that make up the image and the commands used to create each layer. This is useful for understanding how an image was built and for debugging.

We will use the docker history command followed by the image name or ID. In the previous step, we built an image named my-cowsay-image. Let's view its history.

docker history my-cowsay-image:latest

The output will show a table with several columns:

• IMAGE: The ID of the image layer.
• CREATED: The timestamp when the layer was created.
• CREATED BY: The command that created the layer.
• SIZE: The size of the layer.
• COMMENT: Any comment associated with the layer.

You will see entries corresponding to the instructions in our Dockerfile: the base Ubuntu image, the apt-get commands, and the CMD instruction. Each RUN instruction in a Dockerfile creates a new layer in the image.

Understanding the history helps you see how each instruction in your Dockerfile contributes to the final image. This is particularly helpful when optimizing image size or troubleshooting build issues.

For example, you can see the size added by each command, which can help identify large layers that might be unnecessary.

Let's try viewing the history of the base ubuntu:latest image that we used.

docker history ubuntu:latest

This will show the history of the official Ubuntu image, which is much longer and more complex than our simple image history. It demonstrates how base images are built from multiple layers.

The docker history command provides valuable insight into the composition of your Docker images.

Open a specific build in Docker Desktop

In this step, we will discuss how you would typically view the details of a specific image build using Docker Desktop. While the LabEx environment provides a command-line interface, Docker Desktop is a popular graphical tool that offers a more visual way to interact with Docker.

Note: Docker Desktop is a graphical application that runs on your local machine (Windows, macOS, or Linux with a desktop environment). The LabEx environment is a cloud-based virtual machine accessed via a web browser, which does not have a graphical desktop environment for running Docker Desktop. Therefore, you cannot directly "open a specific build in Docker Desktop" within this LabEx environment.

However, it's important to understand how this would be done in a typical development setup using Docker Desktop.

In Docker Desktop, you would navigate to the "Images" section. Here, you would see a list of all the Docker images on your system. You can find the image you built, my-cowsay-image:latest.

Clicking on the image name would open a detailed view of the image. This view typically includes:

• Overview: Basic information about the image, such as its size, creation date, and ID.
• Layers: A visual representation of the image layers, similar to the output of docker history but often with more detail and a graphical interface. You can inspect each layer to see the commands that were executed and the files that were added or modified.
• Tags: A list of tags associated with the image.
• Vulnerabilities: Information about any known security vulnerabilities in the image (if scanning is enabled).

This graphical interface in Docker Desktop makes it easier to explore the contents and history of an image compared to the command-line output, especially for complex images with many layers.

While you cannot perform this action in the current LabEx environment, understanding this capability of Docker Desktop is valuable for your overall Docker learning journey.

To complete this step in the LabEx environment, we will simply acknowledge the concept.

Summary

In this lab, you learned how to build a simple Docker image using a Dockerfile. You created a Dockerfile with instructions to use Ubuntu as the base image, install the cowsay package, and set the default command to run cowsay. You then used the docker build command to build the image and tag it.

Following the image build, you will explore how to list the build history using docker buildx history and then use the docker buildx history open command to view the details of a specific build directly within Docker Desktop, providing a visual interface to inspect the build process and its artifacts.