DOCKER In ONE VIDEO For Beginners: Basic to Advance Tutorial 🔥 [HINDI] | MPrashant

Summary

The video is a practical Docker tutorial that moves from basic concepts to building, running, sharing, and coordinating containers. It uses a React web app and several Python and database examples to demonstrate the ideas.

Core Concepts

• Docker is a platform for packaging and running applications in containers.
• A container is an isolated environment containing an application and the files, libraries, dependencies, and configuration it needs.
• A Dockerfile is a text file describing how to build an image.
• An image is a packaged template used to create containers. One image can be used to run multiple containers.
• A container is a running instance of an image.
• A registry is a place to store and distribute images. Docker Hub is a public example; organizations may use private registries.

The key benefit is portability: developers can package an application and its runtime requirements so it behaves more consistently across machines.

Docker Compared with Virtual Machines

The presenter describes containers as generally lighter and faster to start than virtual machines because they package the application and its dependencies rather than a complete guest operating system. Containers also make it easier to share and run multiple isolated application environments—including different software versions—on one machine.

Typical Docker Workflow

1. Write a Dockerfile describing the application’s base image, working directory, files, dependencies, and startup command.
2. Build an image from the Dockerfile.
3. Run the image to create a container.
4. Map ports if the application must be reached from outside the container.
5. Optionally publish the image to a registry so another machine or team can download and run it.

Installation and Verification

The tutorial demonstrates Docker installation on Windows, macOS, and Linux.

• Windows: Check WSL 2 and hardware virtualization, install Docker Desktop, and restart if prompted.
• macOS: Install and start Docker Desktop.
• Linux: Follow the Docker Engine installation instructions for a Red Hat-based distribution, including setting up the repository and installing the packages.

After installation, verify that Docker is running. The tutorial uses terminal commands such as docker -v and docker ps.

Building and Running an Application

The main build example uses a React application. The presenter creates a project, runs it locally, and then packages it in a Docker image.

A typical Dockerfile in the demonstration uses these instructions:

• FROM node:20 — choose a base image and version.
• WORKDIR /myapp — set the working directory inside the image.
• COPY . . — copy project files into that directory.
• RUN npm install — install the project’s dependencies while building the image.
• EXPOSE 3000 — document the application’s container port.
• CMD ["npm", "start"] — specify the command used when the container starts.

The corresponding workflow includes:

• Build from the directory containing the Dockerfile with docker build ..
• Add a meaningful name and version tag with docker build -t my-web-app:01 ..
• View local images with docker image ls.
• Run a container with docker run.
• Publish the application port to the host with docker run -p 3000:3000 .... The host-side port can differ, such as with -p 3001:3000.
• Run in the background with detached mode (-d).
• Assign a recognizable container name with --name.
• Use docker ps to see running containers and docker ps -a to see all containers.
• Stop and remove containers with docker stop and docker rm. The --rm option removes a container automatically when it exits.

The examples show that one image can power multiple containers, but each host port can only be bound to one container at a time. Containers can also run different tagged versions of the same application side by side.

Prebuilt Images and Interactive Containers

Docker Hub provides prebuilt images for commonly used software, such as Node.js, Python, MySQL, and Nginx. The tutorial demonstrates pulling an image with docker pull and running it with docker run.

For a Python program that needs to accept terminal input, the presenter uses interactive mode (-i and -t, commonly written together as -it). This lets the user interact with the program inside the container.

Sharing Images with Docker Hub

The tutorial demonstrates publishing a custom image:

1. Create a Docker Hub account and repository.
2. Log in from the terminal with docker login.
3. Tag the local image with the repository name and a version.
4. Push it with docker push.
5. On another machine, pull the image and run it.

The presenter notes that public repositories allow others to access images, while private repositories restrict access. Meaningful names and version tags make images easier to identify and manage. Docker can also tag an existing image with another name or version.

Data Persistence: Volumes and Bind Mounts

A container’s internal filesystem is not a reliable place to keep data that must survive after the container is removed. The tutorial demonstrates this with a Python program that stores names in a file.

• Docker volume: A named storage area managed by Docker. Mount it into a container at the directory where the application reads or writes data. The data can persist even when the container stops or is replaced.
• Bind mount: Mount a specific file or directory from the host machine into the container. This is useful when the container needs access to host files or when code changes during development should immediately appear inside the container.
• Volumes can be listed and inspected with Docker’s volume commands.
• The tutorial also introduces .dockerignore, which excludes files and directories from the build context so they are not copied into the image.

Connecting Applications and Databases

The tutorial illustrates three communication patterns:

• A containerized application can call an external API over the network.
• A container can connect to a database running on the host machine. The presenter uses host.docker.internal in the example instead of treating localhost inside the container as the host.
• An application and database can each run in their own containers and communicate over a Docker network.

The multi-container example initially connects to a MySQL container by its IP address, then introduces a Docker network as a better approach. When both containers share a network, the application can address the database by its container name, avoiding the need to hard-code the container IP.

Docker Compose

Docker Compose uses a YAML configuration file to define and manage one or more services. It helps replace long, repetitive docker run commands with a reusable configuration.

A Compose file can specify:

• Which image to use or where to build a custom image.
• Environment variables, such as database credentials and database name.
• Container names.
• Port mappings.
• Networks and volumes.
• Dependencies between services.

The tutorial combines a Python application and a MySQL database in one Compose project. It demonstrates starting and stopping services with docker compose up and docker compose down, and running services in detached mode. Services in the same Compose project are connected to a shared network by default, allowing them to communicate using service or container names.

The presenter also explains that depends_on can express service dependencies, but a database process starting does not necessarily mean it is ready to accept connections. A health check can test readiness, and the dependency can be configured to wait for a healthy service. The Compose configuration is also used to demonstrate port binding and a bind mount.

Main Lessons

• Package application code and its runtime requirements together to make deployment more consistent.
• Treat images as reusable templates and containers as running instances.
• Map ports to expose containerized services to the host.
• Use named volumes for data that must persist; use bind mounts when connecting containers to host files, especially during development.
• Use Docker networks and service names for communication between containers.
• Use image tags to identify versions and Docker Hub or another registry to share images.
• Use Docker Compose to define and operate multi-container applications in a repeatable way.

Speakers and Sources Featured

• Speaker: M Prashant, the tutorial presenter.
• Sources and tools referenced: Docker Hub; official Docker documentation, including installation and Compose documentation; Docker Desktop; Visual Studio Code; React and Node.js; Python; MySQL; and Nginx.