How to use the docker build – progress= plain command?

In the context of DevOps, you can get more detailed output during the time of building the docker by using the docker build – progress= plain or even docker build – progress== tty command. Here are the steps given:-

Using docker build – progress= plain
Docker build –progress=plain -t your_image_name .

This option would provide you with a more verbose output in a plain text format which would show you each step of the building process explicitly.

Using docker build – progress== tty

Docker build –progress=tty -t your_image_name .

This option would Mimic a terminal-like progress output which can be more informative and easier so that you can interpret for the complex builds.

Interpreting the verbose output

Step-by-step progress

You should look for detailed logs for each build step, including which stage of the docker file is being processed.

Dependencies issues

You should check for warnings or even errors that are related to dependencies not being found or installed correctly.

Build failures

You can identify any specific command or even stages where the build process fails and you can investigate the corresponding error message.

Here is an example of Java-based code given of how you can interact with the docker by using the docker java API. This example would focus on building a docker image and capturing verbose output during the time building the process:-

Import com.github.dockerjava.api.DockerClient;
Import com.github.dockerjava.api.command.BuildImageCmd;
Import com.github.dockerjava.api.model.BuildResponseItem;
Import com.github.dockerjava.core.DockerClientBuilder;
Import com.github.dockerjava.core.command.BuildImageResultCallback;
Import com.github.dockerjava.core.command.LogContainerResultCallback;
Import com.github.dockerjava.core.command.WaitContainerResultCallback;
Import com.github.dockerjava.core.command.PullImageResultCallback;
Import org.apache.commons.io.IOUtils;
Import java.io.File;
Import java.io.FileInputStream;
Import java.io.IOException;

Public class DockerBuildExample {
    Public static void main(String[] args) throws IOException {
        // Initialize Docker client
        DockerClient dockerClient = DockerClientBuilder.getInstance().build();
        // Dockerfile path
        File dockerfile = new File(“path/to/your/Dockerfile”);
        // Image name and tag
        String imageName = “your_image_name”;
        String imageTag = “latest”;
        // Read Dockerfile content
        FileInputStream dockerfileInputStream = new FileInputStream(dockerfile);
        String dockerfileContent = IOUtils.toString(dockerfileInputStream, “UTF-8”);
        dockerfileInputStream.close();
        // Build Docker image
        BuildImageCmd buildImageCmd = dockerClient.buildImageCmd()
                .withDockerfile(dockerfileContent.getBytes())
                .withTags(new String[]{imageName + “:” + imageTag})
                .withProgressMessageHandler(message -> {
                    // Handle progress messages if needed
                    System.out.println(“Build progress: “ + message);
                });
        // Execute build and capture verbose output
        buildImageCmd.exec(new BuildImageResultCallback() {
            @Override
            Public void onNext(BuildResponseItem item) {
                // Handle each build step output
                System.out.println(“Build step: “ + item.getStream());
            }
        }).awaitImageId();
        // Print completion message
        System.out.println(“Docker image build completed.”);
        // Optionally, you can pull the built image to verify
        dockerClient.pullImageCmd(imageName)
                .withTag(imageTag)
                .exec(new PullImageResultCallback())
                .awaitSuccess();
        // Clean up: Remove the built image (if needed)
        dockerClient.removeImageCmd(imageName + “:” + imageTag).exec();
    }
}
Here is a python based approach given:-
Import docker
# Initialize Docker client

Client = docker.from_env()
# Path to Dockerfile’s directory
Dockerfile_path = ‘/path/to/your/dockerfile_directory’
# Image name and tag
Image_name = ‘your_image_name:latest’
# Build Docker image with verbose output
Print(“Building Docker image…”)
Image, logs = client.images.build(path=dockerfile_path, tag=image_name, rm=True, nocache=True)
# Print build logs

For log in logs:
    If ‘stream’ in log:
        Print(log[‘stream’].strip())
Print(f”Image ‘{image_name}’ built successfully.”)