Introduction to Containers and Docker on Linux: Basics and Setup

If you’ve ever heard the terms “containers” or “Docker” and felt a little out of your depth, don’t worry—you’re not alone.

Containers are transforming how we manage applications and environments, especially on Linux systems like Debian and Ubuntu.

This guide will explain the essentials, from what containers are and why they matter to how to set up Docker on your Linux box and get a container up and running.

What are Containers, and Why Do We Need Them?

Imagine you’ve built a web app that runs perfectly on your local machine. You push it to production, and suddenly, it’s chaos—dependencies are broken, environment variables aren’t set up, and it’s like the server hates you personally. This is where containers come in to save the day.

The Concept of Containers

Think of a container as a lightweight, self-contained environment. A container includes everything an app needs to run: the code, runtime, system tools, libraries, and settings. It’s like a mini-operating system for your app but without the heavy overhead of a full virtual machine (VM).

Benefits of Containers:

• Consistency: Containers ensure that your app behaves the same way everywhere.
• Isolation: Each container runs its environment, so one app doesn’t interfere with another.
• Efficiency: Containers are fast and lightweight compared to VMs, as they share the host OS kernel.

Docker: The Container Powerhouse

Docker is the most popular tool for creating and managing containers. It simplifies the process of creating, deploying, and running apps in containers, making it easy to handle dependencies and configurations.

Why Use Docker?

Docker abstracts away the complexity of containers, offering:

• Portability: Write code once, and run it anywhere.
• Version control: Keep track of container versions and roll back if something breaks.
• Scalability: Spin up multiple instances of your containers effortlessly.

Key Docker Concepts

• Images: The blueprint of your container. Think of images as templates that include the app and all it needs to run.
• Containers: Running instances of images.
• Docker Hub: A repository where you can find pre-built images for nearly any app.

Getting Started with Docker on Debian/Ubuntu

Before diving into Docker, make sure you’re on a recent version of Debian or Ubuntu. Docker supports versions such as Ubuntu 18.04+, 20.04+, and Debian 10+.

Installing Docker on Debian/Ubuntu

1. Update Packages:

   sudo apt update

2. Install Prerequisites:

   sudo apt install apt-transport-https ca-certificates curl software-properties-common

3. Add Docker’s Official GPG Key:

   curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

4. Add Docker’s Repository:

   echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

5. Update the Package Database Again:

   sudo apt update

6. Install Docker:

   sudo apt install docker-ce

7. Verify Docker Installation:

   sudo docker --version

   You should see an output indicating the Docker version installed. Success!

Managing Docker as a Non-Root User

To avoid using sudo with every Docker command:

sudo usermod -aG docker $USER
newgrp docker

This command adds your user to the Docker group, allowing Docker commands without root privileges.

Basic Docker Commands: Your First Steps

Let’s start with a few fundamental Docker commands. These will help you get comfortable navigating and working with Docker containers.

Pulling an Image

Docker Hub is full of pre-built images. Let’s pull a basic image, such as hello-world:

docker pull hello-world

Running a Container

To run a container from an image, use:

docker run hello-world

This command pulls the image if it’s not on your system yet and runs a container that displays a simple “Hello from Docker” message.

Listing Containers and Images

To see all running containers:

docker ps

To see all containers (even stopped ones):

docker ps -a

To list all images on your system:

docker images

Real-Life Example: Running an NGINX Server in a Container

Let’s say you’re testing a web server setup and want to run NGINX (a popular web server) without installing it directly on your system.

1. Pull the NGINX Image:

   docker pull nginx

2. Run NGINX in a Container:

   docker run -d -p 8080:80 nginx

   • -d: Runs the container in detached mode (in the background).
   • -p 8080:80: Maps port 80 in the container to port 8080 on your local machine.
3. Access NGINX: Open your browser and go to http://localhost:8080. You should see the default NGINX welcome page.

Stopping and Removing Containers

To stop the container:

docker stop <container-id>

To remove a container:

docker rm <container-id>

You can find the <container-id> by running docker ps -a.

Customizing Your Container

Want to add files to your container or modify it? You can create your own Dockerfile to build custom images. Here’s a quick example:

# Create a Dockerfile
FROM nginx
COPY . /usr/share/nginx/html

This Dockerfile copies the files from your current directory into the default NGINX web directory inside the container.

Best Practices and Common Mistakes to Avoid

Best Practices

• Use Docker Compose for managing multiple containers and services.
• Set up resource limits to prevent a container from consuming all your system resources.
• Organize with Tags: Tag your images with version numbers so you can track and manage changes.
• Minimize Image Size: Use smaller base images (like alpine) to keep containers lightweight.

Common Mistakes

• Leaving Containers Running Unnecessarily: Stop and remove containers you don’t need. Running containers consumes resources.
• Using the Latest Tag Recklessly: Avoid the :latest tag in production since it can lead to unexpected updates.
• Not Managing Storage: Docker images and containers can fill up your disk space. Run docker system prune regularly to clean up unused data.

Wrapping Up

Containers and Docker make it easier than ever to develop, deploy, and manage applications on Linux.

They give you consistency, flexibility, and efficiency that are tough to beat.

By following the steps and tips in this guide, you’ll have the basics down and be well on your way to running your applications in containers on your Linux machine.

So go ahead—spin up a container, experiment, and see how Docker can fit into your workflow. Happy containerizing!