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

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.
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.
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.
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.
Docker Hub: The default public Docker registry, where you can find both official and community-contributed Docker images.
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.
Docker CLI: The command-line tool used to interact with the Docker daemon. It allows you to manage containers, images, networks, and volumes.
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

Stop all containers using the image
- docker stop <container_id_or_name>
Remove all containers that are using the docker image
- docker rm <container_id_or_name>
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.