Show List
Tutorials > Docker > Docker architecture

Docker architecture

Docker is a popular containerization platform that allows developers to package and deploy their applications as lightweight, portable containers. Docker architecture is composed of several components that work together to create, manage, and run Docker containers.

The following are the main components of Docker architecture:

  • Docker Client - It is a command-line tool that allows users to interact with Docker. The Docker client communicates with the Docker daemon to create, run, and manage Docker containers.
  • Docker Daemon - It is a background process that runs on the host operating system and manages Docker containers. The Docker daemon listens for commands from the Docker client and manages the lifecycle of Docker containers.
  • Docker Images - Docker images are read-only templates that contain all the necessary files, libraries, and dependencies required to run an application. Docker images are created using a Dockerfile and can be stored in a Docker registry.
  • Docker Registry - Docker registry is a service that stores Docker images. It can be a public or private registry. The most popular public Docker registry is Docker Hub.
  • Docker Container - Docker container is an instance of a Docker image that is running as a process on the host operating system. Each Docker container is isolated from other containers and has its own file system, network, and resources.

Now let's look at some code examples to understand how these components work together:

  • Building a Docker image:

To build a Docker image, we need to create a Dockerfile. Here is an example of a simple Dockerfile that creates a Docker image for a Python web application:

bash
Copy code
# Use an official Python runtime as a parent image
FROM python:3.9-slim-buster

# Set the working directory to /app
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY . /app

# Install any needed packages specified in requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# Make port 80 available to the world outside this container
EXPOSE 80

# Define environment variable
ENV NAME World

# Run app.py when the container launches
CMD ["python", "app.py"]

To build the Docker image, we can use the following command:

Copy code
docker build -t myapp .

This command will build a Docker image named "myapp" from the Dockerfile in the current directory.

  • Running a Docker container:

To run a Docker container from the Docker image, we can use the following command:

css
Copy code
docker run -p 4000:80 myapp

This command will run a Docker container from the "myapp" image and map port 80 of the container to port 4000 of the host operating system. Now we can access the Python web application by visiting http://localhost:4000 in a web browser.

  • Pushing a Docker image to Docker Hub:

To push a Docker image to Docker Hub, we need to first create a Docker Hub account and login using the Docker client. Then, we can use the following commands to tag and push the Docker image to Docker Hub:

bash
Copy code
docker tag myapp username/myapp
docker push username/myapp

This will tag the "myapp" image with the username prefix and push it to Docker Hub.

  • Pulling a Docker image from Docker Hub:

To pull a Docker image from Docker Hub, we can use the following command:

bash
Copy code
docker pull username/myapp

This will pull the "myapp" image from Docker Hub to our local machine.

These are some of the basic examples of how the components of Docker architecture work together to create, manage, and run Docker containers.



Next: Docker Desktop Set Up

    Leave a Comment

  • captcha text