Demystifying Docker - Part 1: Everything Developers Need to Know to Stay Ahead

Prerequisites

• There are no specific skills needed for this tutorial beyond a basic comfort with the command line and using a text editor
• Install Node.js (download here) and Docker Desktop (download here).
• Create an account on Docker Hub

Verify your setup:

• Run node -v to check Node.js version (ensure it's installed).
• Run docker --version to check the Docker version (this tutorial uses Docker 27.3.1).

What is Docker?

At its core, Docker simplifies how developers build, ship, and run applications by using containers. Think of a container as a "lightweight, portable box" that includes everything your app needs—code, dependencies, and configurations.

Here’s how others define Docker:

• Wikipedia: An open-source project that automates the deployment of software inside containers by providing abstraction and automation of OS-level virtualization.
• Docker Official Site: A platform for developing, shipping, and running applications, enabling fast and consistent software delivery.

?? Still unclear? Don’t worry. As we progress, you’ll have a definition that works for you!

Why Use Docker?

Let’s say you’ve built a cool Node.js project on your machine, and you want to share it with your friends. Simple, right? Not quite. Here’s why:

• Your project needs Node.js 19 and PostgreSQL, and you’re on Linux.
• Your friend Jack has PostgreSQL but Node.js 20 on Windows.
• Alex uses Linux but only has Node.js 16 and no PostgreSQL.

The Problem:

Different environments can lead to compatibility issues. Without Docker, your friends might struggle to run your project.

The Solution:

Docker allows you to package your app with everything it needs—Node.js, PostgreSQL, and even your OS — into a container. This container runs the same way, everywhere. Problem solved. ??

The Docker Advantage

Docker lets you create containers — lightweight, portable environments that include all your app’s dependencies. In our Node.js project example, Docker helps you:

• Standardize environments: Avoid “it works on my machine” issues.
• Simplify sharing: Your friends can run the container regardless of their setup.
• Save time: No more debugging environment issues!

Ready to dive in and create your first container? Let’s get started. ??

Let's play a bit with Docker

Note: Follow the steps and see the result. Don't worry we'll explore all the needed concepts later ??

• Open your Docker desktop app
• Create a folder for your app (e.g docker-flask-app)
• Add a Python script inside (app.py)

from flask import Flask

app = Flask(__name__)

@app.route("/")
def home():
    return "<h1>Hello, Docker!</h1>"

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)        

• Add a requirements.txt file

flask        

• In the same folder, create a file named Dockerfile with the following content:

FROM python:3.9-slim

WORKDIR /app

COPY . /app

RUN pip install -r requirements.txt

EXPOSE 5000

CMD ["python", "app.py"]        

P.s: We'll explore each line of commands later

• Open a terminal, navigate to the project directory, and run:

docker build -t flask-docker-app .        

Open your Docker Desktop app and go to the Images section, and you'll see an image

• Start a container from your image, and run the following code:

docker run --name flask-app -d -p 5000:5000 flask-docker-app        

Open your Docker Desktop app and go to the Containers section, and you'll see a container running on port 5000

• Open your browser and visit localhost:5000

Docker concepts every developer should know

What is a Dockerfile?

A Dockerfile is a text-based document that's used to create a container image. It provides instructions to the image builder on the commands to run, files to copy, startup command, and more.

Resource

A Dockerfile is a text-based instruction manual used to create Docker images. It tells Docker:

• What to do: Which commands to run?
• What to include: Files, dependencies, and configurations.
• How to start: The startup command for the application.

In our project:

1. We created a Dockerfile.
2. Built an Image from it using docker build.
3. Ran a Container from the image using docker run.

Docker Image

A container image is a standardized package that includes all of the files, binaries, libraries, and configurations to run a container. For a PostgreSQL image, that image will package the database binaries, config files, and other dependencies. For a Python web app, it'll include the Python runtime, your app code, and all of its dependencies.

Resource

A Docker Image is like a blueprint for creating containers. It includes:

• App code (e.g., your Flask app).
• Dependencies (e.g., Python runtime, libraries).
• Configurations (e.g., environment variables).

In the example project, we created an image via the command:

docker build -t flask-docker-app .        

Let's analyze each keyword here:

1. docker build → This is the Docker command to build an image from a Dockerfile. Docker reads the instructions in the Dockerfile to package your application into an image.
2. -t → This option assigns a name (or "tag") to the image being built
3. flask-docker-app → The name you’re giving to the image. This name helps you reference the image later when running it with docker run.
4. . (dot) → The dot (.) means "current directory." So Docker will look in the current folder for the Dockerfile and other resources to build the image.

Now, let's learn a few commands related to Docker Images:

• You can see all images by running

docker images        

• Want to remove an image:

docker rmi <IMAGE-ID> or <IMAGE_NAME>:<IMAGE-TAG>        

• How about removing all images:

docker rmi $(docker images -q)        

Docker Container

• Imagine you're developing a killer web app that has three main components - a React frontend, a Python API, and a PostgreSQL database. If you wanted to work on this project, you'd have to install Node, Python, and PostgreSQL.
• How do you make sure you have the same versions as the other developers on your team? Or your CI/CD system? Or what's used in production?
• Enter containers!

Simply put, containers are isolated processes for each of your app's components. Each component - the frontend React app, the Python API engine, and the database - runs in its own isolated environment, completely isolated from everything else on your machine.

Resource

A Docker Container is a running instance of an image. It:

• Runs your app in an isolated environment.
• Includes all dependencies for consistency across development, testing, and production.

Now, let's analyze how we ran our Image and created our final Container:

docker run --name flask-app -d -p 5000:5000 flask-docker-app        

1. docker run → This is the command to create and start a container from a Docker image.
2. --name flask-app → Assigns a custom name to the container for easier identification, flask-app is the name you’re giving to the container. Without this option, Docker would assign a random name.
3. -d → Detached mode: Runs the container in the background, so your terminal isn’t blocked.
4. -p 5000:5000 → Maps a port on the host machine to a port inside the container. The first 5000 refers to the host machine's port (your computer).The second 5000 refers to the container's port where the app is listening. This allows you to access the app running inside the container via https://localhost:5000 on your host machine.
5. flask-docker-app → The name of the Docker image to create the container from. This should match the name of the image built earlier using the docker build command.

Let's have a look at some commands to work with containers:

• You can see a list of running containers via the command:

docker ps        

• If you want to see all containers that are running and stopped, try this out:

docker ps -a        

• To stop a container that is running:

docker stop <CONTAINER-NAME>        

• To remove a container:

docker rm <CONTAINER-NAME>        

• Stop and remove the container in one command:

docker rm -f <CONTAINER-NAME>        

• Stop and remove all containers (running and stopped):

docker rm -f $(docker ps -aq)        

Let's imagine how they are connected to each other!

Pushing a Docker Image to Docker Hub

Step 1: Docker Hub requires images to be tagged with a repository name in this format:

<your-docker-hub-username>/<repository-name>:<tag>        

Note: If you haven't built an image yet, you can try this command to create an image that is ready to push:

docker build -t YOUR_DOCKER_USERNAME/flask-docker-app .        

Step 2: In the example project above, we built an image and we should tag our image with our Docker username by the following command:

docker tag flask-docker-app YOUR_DOCKER_USERNAME/flask-docker-app:latest        

Step 3: Now, our image is ready to get pushed to Docker Hub, let's do it

docker push YOUR_DOCKER_USERNAME/flask-app:latest        

Step 4: Verify the Image on the Docker Hub

Step 5: Navigate to your repository to confirm the image is uploaded.

Conclusion

I hope you found this article informative and helpful. If you have any thoughts, questions, or suggestions, feel free to share them in the comments below. This is the first part of a series on Docker, and I’ve aimed to cover the fundamental concepts with clear explanations and visuals.

To make learning easier, here’s a link where you can review and practice the basic Docker commands. Remember, practice is the key to mastering anything.

Don’t hesitate to experiment — create your own images and containers using your existing applications or even new ones. If you have any questions during your exploration, I’ll be happy to help in the comments.

Thank you for reading, and I look forward to hearing about your Docker journey. Let’s keep learning and growing together! ??