Introduction

Welcome to “A Complete Beginner to Advanced Guide on Docker Engine 29.0.2”! In this foundational chapter, we embark on our journey into the world of Docker. If you’ve ever struggled with “it works on my machine” problems, inconsistent development environments, or complex deployment processes, Docker is here to revolutionize your workflow.

This chapter will introduce you to the core concepts of Docker, explain why it has become an indispensable tool for modern software development, guide you through its installation, and help you run your very first container. By the end of this chapter, you’ll have a solid understanding of what Docker is and how to get it up and running on your system.

Main Explanation

What is Docker?

Docker is an open-source platform that enables developers to automate the deployment, scaling, and management of applications within lightweight, portable, self-sufficient units called containers. Think of a container as a miniature, isolated operating system that packages an application and all its dependencies, ensuring it runs consistently across any environment.

At its heart is the Docker Engine, the client-server application that runs and manages containers. Docker Engine 29.0.2 refers to a specific version of this core technology, offering robust performance and features.

Why Docker? The Benefits

Docker addresses several common challenges in software development and deployment:

  • Consistency: Applications run the same way regardless of the underlying infrastructure (development, testing, production). This eliminates “it works on my machine” issues.
  • Isolation: Each container runs in isolation from others and from the host system. This means applications don’t interfere with each other, and you can run multiple versions of the same software side-by-side.
  • Portability: A Docker container can run on any machine that has Docker installed, be it a developer’s laptop, a server in a data center, or a cloud instance.
  • Efficiency: Containers share the host OS kernel, making them much lighter and faster to start than traditional virtual machines.
  • Scalability: Docker makes it easy to scale applications up or down by simply starting or stopping containers.
  • Version Control: Docker images can be versioned, allowing you to roll back to previous stable states easily.

Core Concepts

To understand Docker, it’s essential to grasp a few fundamental terms:

  • Images: A Docker image is a read-only template that contains an application, its dependencies, and instructions for how to run it. Images are built from a Dockerfile.
  • Containers: A container is a runnable instance of an image. When you run an image, it becomes a container. You can start, stop, move, or delete a container.
  • Dockerfile: A text file that contains all the commands a user could call on the command line to assemble an image. It’s essentially a blueprint for building Docker images.
  • Docker Engine: The core software that runs and manages Docker containers. It consists of a daemon (server), a REST API, and a CLI (client).
  • Docker Hub: A cloud-based registry service provided by Docker for finding and sharing Docker images. It’s like GitHub for Docker images.

Installing Docker

To begin, you need to install Docker Engine on your system. Docker provides a convenient tool called Docker Desktop which includes Docker Engine, Docker CLI client, Docker Compose, Kubernetes, and an easy-to-use graphical interface.

General Installation Steps (Refer to official Docker documentation for OS-specific instructions):

  1. Download Docker Desktop: Visit the official Docker website (docker.com/products/docker-desktop) and download the appropriate installer for your operating system (Windows, macOS, or Linux).
  2. Run the Installer: Follow the on-screen instructions to install Docker Desktop. This typically involves double-clicking the installer and accepting the default settings.
  3. Start Docker Desktop: Once installed, launch Docker Desktop. It might take a few moments for the Docker Engine to start up completely. You’ll usually see a Docker whale icon in your system tray or menu bar indicating it’s running.

Verifying Your Installation

After installation, open your terminal or command prompt and run the following commands to ensure Docker is correctly installed and running:

  1. Check Docker version:

    docker --version

    You should see output similar to Docker version 29.0.2, build ... (the build number will vary).

  2. Check Docker Engine information:

    docker info

    This command displays detailed information about your Docker installation, including the number of containers, images, and the operating system.

  3. Run a test container:

    docker run hello-world

    This command downloads a tiny “hello-world” image from Docker Hub (if not already present) and runs it in a new container. If successful, you’ll see a message confirming Docker is working correctly.

Examples

Let’s put our new Docker installation to the test with some basic commands.

Example 1: Running a Simple “Hello World” Container

This is often the first Docker command you’ll run. It demonstrates Docker’s ability to pull an image and execute it.

docker run hello-world

Expected Output:

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
... (download progress) ...
Digest: sha256:...
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (If you didn't already have it locally.)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output back to the Docker client, which
    sent it to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Example 2: Pulling an Image from Docker Hub

You can explicitly pull images without running them immediately. This is useful for pre-fetching images.

docker pull alpine

This command downloads the lightweight alpine Linux distribution image.

Example 3: Listing Downloaded Images

To see all the Docker images currently stored on your local machine:

docker images

Expected Output (will vary based on what you’ve pulled):

REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
alpine        latest    a0205830026b   2 weeks ago     7.27MB
hello-world   latest    bf756fb1ae65   7 months ago    13.3kB

Example 4: Listing All Containers (Running and Exited)

The hello-world container ran and then exited. To see it (and any other containers), use docker ps -a.

docker ps -a

Expected Output (will vary):

CONTAINER ID   IMAGE         COMMAND    CREATED         STATUS                      PORTS     NAMES
3b6c7d9e0f1a   hello-world   "/hello"   2 minutes ago   Exited (0) 2 minutes ago              jolly_mccarthy

Mini Challenge

Your challenge is to run a simple Nginx web server in a Docker container and verify it’s running.

Steps:

  1. Run an Nginx container, mapping port 80 of the container to port 8080 on your host machine. Give it a name, e.g., my-nginx-server. Hint: Use docker run -d -p 8080:80 --name my-nginx-server nginx
  2. Open your web browser and navigate to http://localhost:8080. You should see the Nginx welcome page.
  3. List your running containers to confirm my-nginx-server is active. Hint: Use docker ps
  4. Stop and remove the container once you’re done. Hint: Use docker stop my-nginx-server followed by docker rm my-nginx-server

Summary

In this chapter, we’ve laid the groundwork for our Docker journey. You’ve learned that Docker is a powerful platform for packaging and running applications in isolated containers, offering benefits like consistency, portability, and efficiency. We explored core concepts such as images, containers, Dockerfiles, and Docker Hub, and successfully installed Docker Engine 29.0.2 via Docker Desktop. Finally, you gained hands-on experience by running your first containers and exploring basic Docker commands.

You’re now ready to delve deeper into building your own Docker images and managing more complex containerized applications.