Managing Docker containers with Docker Exec

Imagine you have a web application running inside a Docker container, and users are reporting issues with the application. You need to investigate and troubleshoot the problem, but you don't want to stop or restart the container as it might disrupt the service for other users.

In this case, you can use docker exec to access the shell inside the running container and perform various debugging tasks.

 command allows you to run a new command or start an interactive shell session inside a running Docker container. It provides a way to inspect, modify, or troubleshoot the container's environment without having to stop or restart the container.

 command, you need to know the container ID or container name first. You can find the container ID or name using the 

 command, which lists all running containers.

I will be using Ubuntu OS in this article:

First, you need to find the container ID or name of the container running your web application. You can use the 

This will output a list of running containers with their container IDs and names.

To access the shell inside the running container, you can use the 

 flags (interactive mode and pseudo-TTY):

docker exec -it <container-name-or-id> /bin/bash

Here's what each part of the command means:

: The Docker command to execute a new command inside a running container.

), which allows you to interact with the container's shell.

: The command to be executed inside the container. In this case, we're starting the Bash shell. E.g

$ docker exec -it gracious_khayyam /bin/bash

let's assume that you're troubleshooting an issue with your application that interacts with the Redis database running inside this container. Here's how you can proceed:

You can inspect the Redis configuration file to ensure that the settings are correct for your application. Inside the container's shell, navigate to the Redis configuration file directory (usually 

) and open the configuration file (e.g., 

Review the configuration settings, such as the 

 address, port number, and any other application-specific settings. Ensure that the configuration matches your application's requirements.

If you're experiencing issues with Redis, it's a good idea to check the Redis logs for any error messages or warnings. The location of the Redis log file may vary depending on the Redis version and configuration, but it's often located in the 

This command will show the last 100 lines of the Redis log file, which can help you identify any issues or errors related to Redis.

To ensure that your application can connect to the Redis server running inside the container, you can use the 

apt-get update apt-get install redis-tools

Once installed, you can test the Redis connectivity by running the 

This will open the Redis command-line interface. From here, you can try running various Redis commands to test the connectivity and functionality of the Redis server.

 to access the shell inside the container, inspect the Redis configuration and logs, test connectivity, and troubleshoot any issues related to the Redis server running within the container.

Dive into our programming articles for insights and tips. Covering a range of topics, they're perfect for learners at any level eager to expand their knowledge.

Dive into our programming articles for insights and tips.

Articles

Using Docker Exec for Interactive Shell Access

Docker has fundamentally transformed the landscape of application packaging and deployment, offering developers a streamlined approach to managing dependencies and ensuring uniform functionality across diverse environments. While Docker excels in simplifying the deployment of single-container applications, the complexity escalates when orchestrating multiple containers that must collaborate seamlessly. This is precisely where Docker Compose shines. In this blog post, we delve into the intricacies of Docker Compose, unveiling its pivotal role in orchestrating multi-container applications. We'll explore its capabilities in depth and furnish you with practical examples to kickstart your journey into the world of container orchestration.

Here are some of the cases where you might need to develop multi-container apps using Docker Compose:

Consider creating a web application that requires a backend API server (made with Flask, Django, Node.js, etc.) and a database (such as MySQL, PostgreSQL, or MongoDB). Docker Compose enables you to create distinct containers for your backend service and database, ensuring that they interact easily while staying independent.

CI/CD Pipelines: Docker Compose may be used to describe the application environment for each pipeline step (e.g., build, test, and deploy). This guarantees that the same environment used for development and testing is also utilized for deployment, reducing the likelihood of difficulties developing as a result of environment changes.

In this example, we will use Docker Compose to build a Flask application that communicates with a Redis database. Docker Compose enables us to design and execute several container apps from a single configuration file.

Both Docker and Docker Compose is installed on your system.

Create a new directory for the project and navigate into it.

This Flask application connects to a Redis instance and increments a counter every time the root URL (

RUN pip install --no-cache-dir -r requirements.txt

This Dockerfile sets up a Python environment, installs the required dependencies, copies the application code, and starts the Flask app.

, maps port 5000 on the host to port 5000 in the container, and depends on the 

 service uses the official Redis Docker image.

Next step: Build and run the multi-container application using Docker Compose, in the same location where 

This command will build the Flask app image, pull the Redis image, and start both containers.

This command initiates the building process for the web service and pulls the redis:alpine image, starting both containers simultaneously. You'll observe the output of both services within your terminal. Next, open a web browser and visit 

. Here, you'll encounter a message reflecting the number of times the page has been visited, with the count increasing each time you refresh the page.

If everything runs correctly you will have this page,

Docker Compose Demystified: A Practical Guide to Multi-Container Application Management

Introducing Docker to your Django project can significantly enhance its scalability, portability, and ease of deployment. In this step-by-step guide, we will explore the process of Dockerizing a Django project, allowing you to encapsulate your application and its dependencies within lightweight, portable containers. A major compelling argument for utilizing Docker is that it entirely eliminates any concerns with local development setup. Instead of worrying about which software packages are installed or running a local database alongside a project, you use a Docker image that contains the complete project. Best of all, this can be shared in groups, which simplifies team growth. Let's dive in!

Let's make sure Docker and Docker Compose are installed on your machine before we start Dockerizing our Django app. On both the Mac and Windows operating systems, Docker automatically includes Docker Compose as an extra tool. However, Docker Compose requires a separate installation for Linux users. Once Docker is installed, you may accomplish this by using the command

We can verify that the right version of Docker is running once the installation is complete. Type the command 

Use Ctl+C to end the local server, and then enter docker run hello-world in the command window to verify the installation was successful. This is what you ought to see in response:

# Linux
$ cd ~/Django-docker-project
$ mkdir docker-djangov1

THEN:
$ python3 -m venv venv
$ source venv/bin/activate

(venv) $ django-admin startproject django_project .
(venv) $ python manage.py runserver

To Confirm everything worked by navigating to 

It's time to move to Docker now but before we deactivate and leave our virtual environment as we no longer need it, lets create requirements.txt which includes Django and packages that comes with it 

Think of Docker images as recipe cards for baking cakes. Each recipe card contains all the instructions and ingredients needed to bake a specific type of cake. Similarly, Docker images contain all the instructions and dependencies required to run a specific application. Just like you can use the same recipe card to bake multiple cakes, you can use the same Docker image to create multiple containers running the same application. This ensures consistency and reproducibility across different environments, much like how following a recipe ensures consistent results when baking cakes.

A Docker image is a read-only template that specifies how to build a Docker container. The image contains the instructions, whereas the container is the actual running instance of the image.

At the root of our project, we need to create a custom image for our Django project that includes Python, as well as our code and extra configuration information. To generate our image, we create a file called a 

with no extension, which outlines the procedures for creating and running the customized image.

It is advised that you create a.dockerignore file to prevent particular files and directories from being included in a Docker image. This optimizes image size and improves security by preventing sensitive information from being accidentally included. For example, we can disregard the local virtual environment (venv), .git directory, and .gitignore file. To create the .dockerignore file, open your text editor and add a new file named .dockerignore to the base directory, beside the current manage.py file.

We have provided detailed instructions for creating a custom image, but the construction process has not yet begun. To start the build, use the command docker build, followed by a period; 

  - this period refers to the Dockerfile in the current directory. Expect to see a lot of output during this procedure. I've posted the first two lines and the final one here for your convenience.

Now that our custom image is complete, we can run it as a container. To do this, we need a set of instructions saved in a file called docker-compose.yml. Using your choice text editor, create a 

file in the project-level directory, next to the Dockerfile. This file will contain the following code snippet.

We specify the services or containers, we wish to operate within our Docker host. While numerous services can operate at the same time, we'll focus on one called "web" for the time being. 

Within the "web" service, we specify the build context by setting the build option to look in the current directory for our Dockerfile. We'll utilize the default Django ports, configuring port mapping to expose port 8000 on the host and container. Additionally, we define the command to execute, which in this case, starts the local web server using the Django management command python manage.py runserver 0.0.0.0:8000.

Finally, we utilize the volumes option to automatically mount the Docker filesystem to our local computer's filesystem. This ensures that any changes made within the Docker container are automatically synced with the local filesystem, facilitating seamless development. For instance, if we modify the code within the Docker container, those changes will be reflected in the local filesystem.

To complete the process, we execute the command docker-compose up, initiating the Docker container. Expect to see a lengthy output stream on the command line, detailing the container setup and execution.

To confirm if everything is working go to

Django is now running purely within a Docker container.

 Before proceeding further, ensure that the currently running container is stopped. You can accomplish this by pressing "Control" and "c" simultaneously (Control+c) to stop the container. Additionally, type 

in your terminal. It's important to stop Docker containers when they are no longer in use, as they can consume a significant amount of system memory. Remember that Docker containers are designed to be stateless, so we utilize volumes to synchronize our code locally, allowing it to be preserved and easily accessed.

Dockerizing Django: A Step-by-Step Guide for Dockerizing Your Django Project

To understand the importance of Docker and its applications, we must first understand the concept of containers and the problems they solve.

 are completely isolated environments that are set up on top of an existing operating system to provide a virtual separation for the application running inside it from the outside world,  while 

is a software that helps us control the lifecycle of these containers.

A docker container holds all the parts your application needs to run code, libraries, or settings. It is like a mini operating system for your app.

Relax if the idea seems overwhelming. Let's make it simple by illustrating the concept of containers with a well-known and approachable example from daily life.

Let's say you are preparing to travel. All of your possessions are properly arranged and stored in your suitcase. To prevent them from becoming jumbled up or in the way of one another's space, every item is carefully packaged and kept apart from the others. Comparably, in the space of computing, containers function as separate bags that let you bundle and separate programs along with their dependencies. 

Containers protect software components so they function properly without interfering with other system components, just like each item in your luggage stays separate and undamaged.

, which require a separate operating system (OS) instance for each application, 

containers share the host OS kernel while maintaining isolation for the application's processes.

It is worth noting that docker is meant to operate natively on Linux distributions like Ubuntu or Redhat as containerization mostly depends on Linux operating system features. However, Docker may be used by Windows users by creating a virtual Linux system. This procedure is made easier by the Docker Windows Application, which installs a virtual machine and launches the Docker engine on top of it immediately.

What is Docker or the Docker Engine exactly?

Docker, or the Docker Engine, is a powerful containerization technology that allows developers to create, distribute, and execute programs in lightweight, portable containers. It is made up of multiple components, including the Docker Daemon, which controls container runtime, and the Docker Client, which offers a user interface for communicating with Docker. Docker facilitates software development, deployment, and scalability by isolating programs and their dependencies in containers. This makes it simpler to maintain consistency across diverse settings.

Docker or Docker Engine comprises three essential components within a client-server architecture:

 This is a background service, commonly referred to as dockerd, running on the server. It's responsible for managing Docker objects like images, containers, networks, and volumes.

 An interface provided by the Docker daemon, allowing programs and other Docker-related tools to communicate and interact with the Docker daemon process. This API enables various operations and functionalities of Docker.

Known simply as docker, the CLI is a user-friendly tool used to send commands to the Docker daemon. It provides a convenient way for users to manage Docker resources, execute container commands, and perform various operations using straightforward commands

 to run processes inside containers. For the time being, consider Docker images as necessary files required to install services within a Docker container. We'll go into more detail about them later.

Here's what makes containers stand out:
1.

 Compared to virtual machines (VMs), which need entire guest operating systems, containers are far lighter since they share the host operating system's kernel.

Because containers are self-contained, moving them between environments is simple and doesn't need thinking about compatibility problems.

 Applications don't interact with one another or the underlying host system since containers operate in isolation.

 Multiple containers can be spun up and down quickly, enabling elastic scaling based on demand.

 Using Docker, you can package apps and their dependencies into portable containers for easy deployment across many environments. This streamlines the deployment process.

Continuous Integration/Continuous Deployment (CI/CD): 

Docker allows software engineers to automate the build, test, and deployment procedures for their apps by integrating easily with continuous integration/continuous delivery pipelines.

The foundations of containers, containerization, Docker (including Docker Engine), and its client-server architecture have all been addressed in this article. We've also looked at the factors that led to Docker's current broad use in the software development space. 



Articles

Using Docker Exec for Interactive Shell Access

Docker Compose Demystified: A Practical Guide to Multi-Container Application Management

Dockerizing Django: A Step-by-Step Guide for Dockerizing Your Django Project

Introduction to Containers and Docker

Practice Frontend, Android and iOS by building real world projects.