How to use docker image import command to create images

Introduction

In this lab, you will learn how to use the docker image import command to create Docker images from various sources. You will explore importing images directly from a remote URL, importing from a local tarball using standard input, importing from a local tarball with a commit message, and importing from a local directory with new configurations.

Through hands-on exercises, you will gain practical experience in using the docker image import command's different options and understand how to verify the imported images. This lab will equip you with the skills to efficiently create Docker images from existing tarballs or directories, providing flexibility in your Docker workflow.

Skills Graph

Import an image from a remote URL

In this step, you will learn how to import a Docker image directly from a remote URL. This is useful when you have an image tarball hosted on a web server and want to load it into your Docker environment without manually downloading it first.

First, let's use the curl command to download a sample image tarball from a remote URL. We will use a publicly available image tarball for demonstration purposes.

curl -o ~/project/alpine.tar https://labex.io/images/alpine.tar

This command downloads the image tarball from the specified URL and saves it as alpine.tar in your ~/project directory. The -o flag specifies the output file name and location.

Next, we will use the docker image import command to import this tarball into your Docker environment. The import command can take a URL or a file path as input. When using a URL, Docker downloads the content directly and imports it.

docker image import https://labex.io/images/alpine.tar

This command imports the image from the remote URL. Docker will download the tarball and create a new image from its contents. By default, the imported image will have no repository or tag.

To verify that the image has been imported, you can list the available images using the docker images command.

docker images

You should see an image with <none> for both REPOSITORY and TAG, and a recent CREATED time. This is the image you just imported.

You can also import the image and give it a repository and tag during the import process. This is done by adding the desired repository and tag after the URL.

docker image import https://labex.io/images/alpine.tar alpine:latest

This command imports the same image but tags it as alpine:latest.

Now, list the images again to see the newly tagged image.

docker images

You should now see an image with the repository alpine and tag latest.

Import an image from a local tarball using STDIN

In the previous step, you learned how to import a Docker image from a remote URL. In this step, you will learn how to import a Docker image from a local tarball file using standard input (STDIN). This method is useful when you have a local image tarball and want to pipe its content directly to the docker image import command.

First, ensure you have the alpine.tar file in your ~/project directory from the previous step. If not, you can download it again using curl:

curl -o ~/project/alpine.tar https://labex.io/images/alpine.tar

Now, we will use the cat command to read the content of the alpine.tar file and pipe it to the docker image import command. The - argument for docker image import tells it to read from STDIN.

cat ~/project/alpine.tar | docker image import -

This command reads the alpine.tar file and sends its content as input to the docker image import command. Docker then imports the image from the received data. Similar to importing from a URL without specifying a tag, the imported image will have no repository or tag by default.

To verify that the image has been imported, list the available images:

docker images

You should see another image with <none> for REPOSITORY and TAG.

You can also specify a repository and tag when importing from STDIN. The syntax is similar to importing from a URL.

cat ~/project/alpine.tar | docker image import - alpine:stdin

This command imports the image from STDIN and tags it as alpine:stdin.

List the images again to confirm the new tag:

docker images

You should now see an image with the repository alpine and tag stdin.

Using STDIN is a flexible way to import images, especially when chaining commands or working with compressed tarballs where you might decompress and import in one go.

Import an image from a local tarball with a commit message

In the previous steps, you imported images from a URL and STDIN. In this step, you will learn how to import an image from a local tarball file and add a commit message during the import process. Adding a commit message can help you document the origin or purpose of the imported image.

First, make sure you have the alpine.tar file in your ~/project directory. If not, download it:

curl -o ~/project/alpine.tar https://labex.io/images/alpine.tar

Now, we will use the docker image import command with the -m flag to add a commit message. We will also specify the local file path as the source.

docker image import -m "Imported alpine base image" ~/project/alpine.tar alpine:commit

In this command:

• -m "Imported alpine base image" adds the specified commit message to the image history.
• ~/project/alpine.tar is the path to the local tarball file.
• alpine:commit is the desired repository and tag for the imported image.

After executing this command, Docker will import the image from the local tarball and apply the commit message.

To verify the import and the commit message, you can inspect the image using the docker image history command.

docker image history alpine:commit

This command shows the history of the alpine:commit image. You should see an entry with the commit message "Imported alpine base image" in the COMMENT column.

You can also list the images to confirm the new tag:

docker images

You should see an image with the repository alpine and tag commit.

Adding commit messages is a good practice for tracking the changes and origin of your Docker images, especially when importing from external sources.

Import an image from a local directory with new configurations

In the previous steps, you imported images from tarball files. In this step, you will learn how to import an image from a local directory and apply new configurations during the import process. This is useful when you have a filesystem snapshot in a directory and want to turn it into a Docker image with specific settings like the command to run.

First, let's create a simple directory structure and a file that will be included in our image.

mkdir ~/project/myimage
echo "Hello, Docker!" > ~/project/myimage/hello.txt

This creates a directory named myimage inside your ~/project directory and a file named hello.txt within it containing the text "Hello, Docker!".

Now, we will use the docker image import command to import the content of the ~/project/myimage directory. We will also use the -c flag to specify configuration changes for the image. In this case, we will set the CMD instruction, which defines the default command to execute when a container is started from this image.

docker image import -c 'CMD ["/bin/cat", "/hello.txt"]' ~/project/myimage myimage:latest

In this command:

• -c 'CMD ["/bin/cat", "/hello.txt"]' sets the default command for the image to /bin/cat /hello.txt. The -c flag allows you to apply Dockerfile instructions like CMD, ENTRYPOINT, ENV, EXPOSE, LABEL, ONBUILD, STOPSIGNAL, USER, and WORKDIR.
• ~/project/myimage is the path to the local directory containing the filesystem content.
• myimage:latest is the desired repository and tag for the imported image.

After executing this command, Docker will create a new image based on the content of the ~/project/myimage directory and apply the specified CMD configuration.

To verify the import and the configuration, you can list the images:

docker images

You should see an image with the repository myimage and tag latest.

Now, let's run a container from this image to see if the CMD instruction is applied correctly.

docker run myimage:latest

This command starts a container from the myimage:latest image. Because we set the CMD to /bin/cat /hello.txt, the container should execute this command and print the content of the hello.txt file, which is "Hello, Docker!".

You should see "Hello, Docker!" printed to your terminal. This confirms that the directory content was imported and the CMD configuration was applied successfully.

Summary

In this lab, we learned how to use the docker image import command to create Docker images from various sources. We began by importing an image directly from a remote URL, demonstrating how to load an image tarball hosted online without manual download. This involved using curl to download a sample tarball and then the docker image import command with the URL as input, showing how to import with and without specifying a repository and tag.

The subsequent steps, though not fully detailed in the provided content, would likely cover importing images from local tarball files using STDIN, importing with a commit message for better tracking, and importing from a local directory while applying new configurations. These steps would further illustrate the flexibility and different use cases of the docker image import command for creating and managing Docker images.