Docker

Packaging applications into portable containers

What is Docker

Docker is an open-source platform that enables developers to automate the deployment, scaling, and management of applications within lightweight, portable containers. These containers encapsulate an application and all its dependencies, ensuring that it runs consistently across various computing environments, from a developer’s laptop to a production server. By isolating applications from the underlying infrastructure, Docker helps eliminate issues related to environment discrepancies and dependency conflicts.

The key concept behind Docker is containerization, which packages an application and its dependencies into a single unit, known as a container. Containers share the same operating system kernel, but each one runs in its own isolated user space. This makes containers more lightweight and faster to start compared to traditional virtual machines, which require a full operating system for each instance. Containers also improve efficiency by reducing the overhead typically associated with running multiple applications on a single system.

Docker includes several tools and features to facilitate container management, including Docker Engine, which runs and manages containers, and Docker Hub, a registry for sharing and distributing container images. Docker also supports orchestration tools like Docker Compose and Kubernetes, which simplify managing multi-container applications and scaling them across clusters. With Docker, developers can build, test, and deploy applications in a consistent environment, accelerating the development lifecycle and improving collaboration between teams.

How to install Docker

On most system it is installed by default but if it's not it should be in the standard repo for the current linux distro. For Debian and Ubuntu

1. Install Docker
sudo apt install docker.io

2. Verify Docker is installed
sudo docker --version

3. Start and enable Docker service
sudo systemctl start docker
sudo systemctl enable docker

Termomonlogy and Concept

  1. Docker Image: A lightweight, standalone, executable package that contains everything needed to run a piece of software, including the code, runtime, libraries, and system tools. Docker images are read-only templates used to create containers.
  2. Docker Container: A running instance of a Docker image. Containers are isolated from each other and from the host system. They are ephemeral and can be started, stopped, and deleted.
  3. Dockerfile: A text file that contains instructions on how to build a Docker image. It defines the base image, environment variables, files to copy, commands to run, and other configurations.
  4. Docker Registry: A service that stores and distributes Docker images. The most well-known registry is Docker Hub, but you can use private registries or self-hosted ones.
  5. Docker Hub: The default public Docker registry, where you can find both official and community-contributed Docker images.
  6. Docker Daemon (dockerd): The background service that manages Docker containers and images. It runs on the host machine and listens for API requests from the Docker CLI.
  7. Docker CLI: The command-line tool used to interact with the Docker daemon. It allows you to manage containers, images, networks, and volumes.
  8. Docker Compose: A tool used to define and run multi-container Docker applications. You define your services, networks, and volumes in a docker-compose.yml file.

These term

Docker Images

– Like blueprints for containers
– Runtime environment
– Application code
– Any dependencies
– Extra configuration (e.i environment variables)
– Command

Docker are made up from several “layers” and the order of the layers matter!

The first layer is common know as parent layer. You usually get this layer or “partial” image from
DockerHub
For example you could get the mediawiki form there

There are also variation/version of each image that is denoted with a tags
Note: If you do NOT specify any tag the default of latest will be used

Commands - Docker Images

DESCRIPTION COMMAND
Pull (aka download) an image
from dockerhub 		docker pull nginx
OR
docker pull docker.io/nginx
runs a detached (-d)
Docker container from the mediawiki image
llocates a pseudo-TTY (-t)
and names the container myownhomewiki. 		docker run -d -t --name myownhomewiki mediawiki
List all images docker images
Build an image from a Dockerfile docker build -t "image-name":"tag" "path-to-dockerfile"
Push an image to a registry: docker push "image-name":"tag"
Remove an image docker rmi "image-name":"tag"
Remove all unused image docker image prune
Remove Docker image
mediawiki
Make sure the image is NOT
in use by any running containers 		docker image rm mediawiki
build a Docker image from a
Dockerfile in the current directory (.) 		docker build -t myapp:v1 .

Containers

Are running instances of an docker image. It actually creates a process that is completely isolated!

One major benefit of containerize process is that you can run multiple instances (which is identical) on various machines and expect the same output of the application

Commands - Containers

DESCRIPTION COMMAND
Lists all running Docker containers docker ps
Lists all Docker containers docker ps -a
opens an interactive Bash shell inside the
running container named
myownhomewiki 		docker exec -it myownhomewiki bash
Stop a
running container
this case myownhomewiki 		docker stop myownhomewiki
Remove a
container 		docker container rm "containername_or_containerID"
Exit a
running container 		exit

Commands - Misc

DESCRIPTION COMMAND
Real-time statistics about
running Docker containers 		docker stats
Running proeccess
inside
a container 		docker top myownhomewiki
Lists all volumes in Docker docker volume ls
Lists all networks available in Docker docker network ls
Displays disk usage information for Docker images, containers, volumes, and networks docker system df
Displays system-wide information about Docker docker info
Removes all unused containers, networks, images docker system prune -a

DockerFile

A Dockerfile is a text file that contains a set of instructions to automatically build a Docker image. It acts as a blueprint for creating Docker containers by defining the steps to set up an environment, install dependencies, configure settings, and deploy an application inside a container.

Example of and docker file

Here should the code be

# Start with an official Python image as the base
FROM python:3.8-slim

# Set the working directory inside the container
WORKDIR /app

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

# Install dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Expose the port that the app will run on
EXPOSE 5000

# Set environment variable
ENV FLASK_ENV=development

# Command to run the application
CMD ["python", "app.py"]

Text more here

.dockerignore

The .dockerignore file is used to tell Docker which files and directories to exclude from being copied into the Docker image when building it. This helps you avoid unnecessary files, reduces the image size, and speeds up the build process.
Example of and docker file

Here should the code be
# Ignore Git files
.git
.gitignore

# Ignore local environment files
.env

# Ignore log files
*.log

# Ignore build files
node_modules/
dist/

# Ignore Dockerfile and .dockerignore itself
Dockerfile
.dockerignore

More text here

docker-compose.yaml

Is a configuration file used by Docker Compose.
TODO

FAQ

Virtual Machines vs Container

Virtual Machines
Has it’s own operating system & typically slower

Containers
Shares the hosts operating system and typically slower

Remove a docker image you need to

  1. Stop all containers using the image
    • docker stop <container_id_or_name>
  2. Remove all containers that are using the docker image
    • docker rm <container_id_or_name>
  3. Remove the image:
    • docker image rm <image_name_or_id>

TODO

Monolithic Architecture vs Microservices Architecture

In order to fully take advantage of containerization you need to use a Microservices Architecture. Each container handles a microservice independently of each other. It will also be easier to scale this application but at the same time require more individual configuration. Communication between containers is a core feature of containerized microservices architectures.