How to use docker context import command to import a context

Introduction

In this lab, you will learn how to effectively use the docker context import command. We will begin by creating and exporting a Docker context to a file, demonstrating how to package your context configurations.

Following the export, you will practice importing this context back into Docker, both from the exported file and directly from standard input. Finally, you will verify that the imported context is correctly recognized and available for use within your Docker environment.

Skills Graph

Create and export a Docker context

In this step, we will learn how to create a Docker context and export it to a file. A Docker context is a way to manage connections to different Docker daemons. By default, Docker connects to the local daemon. However, you can create contexts to connect to remote daemons or other environments like Docker Swarm or Kubernetes.

First, let's create a new Docker context named my-context. We will configure this context to connect to the default local Docker daemon.

docker context create my-context --docker "host=unix:///var/run/docker.sock"

This command creates a new context named my-context and specifies the Docker host to be the default Unix socket for the local daemon.

Next, we will export this newly created context to a file named my-context.tar.gz.

docker context export my-context -o ~/project/my-context.tar.gz

This command exports the my-context to a tar.gz file located in your ~/project directory. The -o flag specifies the output file path.

You can verify that the file has been created by listing the contents of the ~/project directory.

ls ~/project/

You should see my-context.tar.gz listed in the output.

Import the exported context from a file

In the previous step, we exported a Docker context to a file named my-context.tar.gz. In this step, we will import this context back into Docker from the file.

Before importing, let's first remove the existing my-context to simulate importing a context that doesn't currently exist.

docker context rm my-context

This command removes the Docker context named my-context. You can verify that it's removed by listing the contexts again.

docker context ls

You should no longer see my-context in the list.

Now, let's import the context from the file ~/project/my-context.tar.gz.

docker context import my-context-from-file ~/project/my-context.tar.gz

This command imports the context from the specified file and names the imported context my-context-from-file.

After the import is complete, you can list the Docker contexts again to see the newly imported context.

docker context ls

You should now see my-context-from-file in the list of contexts.

Import the exported context from stdin

In the previous step, we imported a Docker context from a file. Another way to import a context is by piping the exported context data directly to the docker context import command via standard input (stdin). This is useful when you want to import a context without saving it to a file first.

First, let's remove the context we imported in the previous step to avoid conflicts.

docker context rm my-context-from-file

Now, we will use the cat command to read the content of the my-context.tar.gz file and pipe it to the docker context import command.

cat ~/project/my-context.tar.gz | docker context import my-context-from-stdin -

In this command, cat ~/project/my-context.tar.gz reads the content of the file. The pipe symbol | sends the output of the cat command as input to the docker context import command. The - at the end of the docker context import command tells it to read the context data from standard input. We are naming the imported context my-context-from-stdin.

After the command finishes, you can list the Docker contexts to verify that the context has been imported from stdin.

docker context ls

You should now see my-context-from-stdin in the list of contexts.

Verify the imported context

In the previous steps, we created, exported, and then imported a Docker context using two different methods: from a file and from standard input. In this final step, we will verify that the imported context is functional and can be used to interact with the Docker daemon.

First, let's list the available contexts to confirm that both my-context-from-file and my-context-from-stdin are present.

docker context ls

You should see both contexts listed in the output.

Now, let's switch to the context we imported from standard input, my-context-from-stdin.

docker context use my-context-from-stdin

This command sets the current Docker context to my-context-from-stdin. Any subsequent Docker commands will now use this context to connect to the Docker daemon.

To verify that the context is working correctly, let's run a simple Docker command, such as listing the running containers. Since we are connecting to the local Docker daemon, this command should show the same output as running docker ps without specifying a context.

docker ps

If the context is configured correctly, this command should execute successfully and display the list of running containers (if any).

Finally, let's switch back to the default context.

docker context use default

This command switches the current Docker context back to the default local daemon.

Summary

In this lab, we learned how to manage Docker contexts by creating, exporting, and importing them. We began by creating a new Docker context named my-context configured to connect to the local daemon and then exported this context to a tar.gz file.

Following the export, we practiced importing the context back into Docker. We first removed the original context to simulate importing a new one and then successfully imported the context from the previously created file using the docker context import command, giving it a new name to distinguish it.