2. Containerization

How to avoid the classical..

The answer is: CONTAINERIZATION.

Docker is a platform and tool that enables developers to automate the deployment of applications inside lightweight, portable containers. Containers are a form of virtualization that packages an application and its dependencies together, ensuring consistency across different environments, from development to testing and production.

Here are some key concepts and components of Docker:

• Containerization: Containers are lightweight, standalone, and executable packages that include everything needed to run a piece of software, including the code, runtime, libraries, and system tools. Containers isolate applications from their environment, making them portable and consistent across various systems.
• Docker Engine: This is the core component of Docker. It is a lightweight and portable runtime that can run containers on various operating systems, including Linux and Windows. The Docker Engine consists of a server, a REST API, and a command-line interface.
• Docker Image: An image is a lightweight, standalone, and executable package that includes everything needed to run a piece of software, including the code, a runtime, libraries, environment variables, and config files. Images are used to create containers.
• Dockerfile: A Dockerfile is a text file that contains instructions for building a Docker image. It specifies the base image, sets up the environment, installs dependencies, and configures the application.
• Registry: Docker images can be stored in registries, which are repositories for sharing and distributing container images. Docker Hub is a popular public registry, and organizations often use private registries to store and manage their proprietary images.
• Container Orchestration: Docker can be used in conjunction with container orchestration tools like Kubernetes or Docker Swarm to manage the deployment, scaling, and orchestration of containerized applications in production environments.
• Portability: One of Docker's key advantages is its portability. Since containers encapsulate everything an application needs to run, they can run consistently across different environments, reducing the "it works on my machine" problem often encountered in software development.

Docker has become a widely adopted technology in the software development and deployment space due to its ease of use, portability, and the efficiency it brings to the development and deployment lifecycle. It has revolutionized the way applications are packaged, shipped, and deployed, making it easier for developers to build, test, and deploy applications in a more reliable and consistent manner.

Differences between Docker and Virtual Machines

Docker containers and virtual machines (VMs) are both technologies used for virtualization, but they operate at different levels and have distinct characteristics. Here are the key differences between Docker containers and virtual machines:

In summary, Docker containers and virtual machines have different levels of abstraction and are suitable for different use cases. Containers are lightweight, portable, and efficient, making them popular for modern application development and deployment practices. Virtual machines provide stronger isolation and are more suitable for scenarios where running multiple instances of different operating systems is necessary. The choice between Docker containers and virtual machines depends on the specific requirements of the application and the environment in which it will be deployed. To install Docker Engine, see Install Docker Engine.

Creating a Simple Docker

Docker Compose

Docker Compose is a tool for defining and running multi-container Docker applications. With Compose, you can use a YAML file to configure your application's services, networks, and volumes, making it easier to manage complex applications. All the services defined in the compose.yaml file can be started with a single command, allowing you to run multiple containers as a single application.

name: myapp

services:

  web:
    build:
      dockerfile_inline: |
        FROM nginx:latest
        RUN apt update
        RUN apt install -y net-tools iputils-ping
    ports:
      - "80:80"

  app:
    image: openjdk:23-slim
    depends_on:
      - db

  db:
    image: postgres
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydb
    volumes:
      - volume/db:/var/lib/postgresql/data
    ports:
      - 5432:5432

To run the application defined in the compose.yaml file, you can use the following command:

docker compose up -d --build # (1)!

1. -d runs the containers in detached mode, allowing them to run in the background.
   --build forces a rebuild of the images before starting the containers.

This command will start all the services defined in the compose.yaml file, creating a subnetwork for them to communicate with each other. You can then access the web service on port 80 of your host machine. The illustration below shows how the services are connected:

flowchart LR
    user[User] -->|HTTP| web[Web]
    subgraph myapp [172.18.0.0/16]
        web[Web]
        app[App]
        db[(Database)]
    end
    web -->|API| app
    app -->|Connection| db

name: app

  db:
    image: postgres:17
    environment:
      POSTGRES_DB: ${POSTGRES_DB:-projeto} # (1)!
      POSTGRES_USER: ${POSTGRES_USER:-projeto}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-projeto}
    ports:
      - 5432:5432 #(2)!

POSTGRES_DB=superproject
POSTGRES_USER=myproject
POSTGRES_PASSWORD=S3cr3t

Additional Information

Private Networks

Private networks are networks that are not directly accessible from the public internet. They are used to isolate resources and provide a secure environment for communication between devices. In the context of Docker, private networks allow containers to communicate with each other without exposing their services to the outside world.

---
title: Network Address Translation (NAT)
---
flowchart TB
    host1@{ shape: docs, label: "Host 1"} ---|Public IP| internet([Internet])
    host2@{ shape: docs, label: "Host 2"} ---|Public IP| internet([Internet])
    host3@{ shape: docs, label: "Host 3"} ---|Public IP| internet([Internet])
    internet((Internet)) ---|Public IP| router1((Border Router<br>NAT<br>10.0.0.0/8))
    router1 ---|Private IP| device1([Device 1])
    router1 ---|Private IP| device2([Device 2])
    router1 ---|Private IP| device3([Device 3])
    router1 ---|Private IP| router2((Router<br>NAT<br>172.16.0.0/12))
    router2 ---|Private IP| router3((Router<br>NAT<br>192.168.0.0/16))
    router2 ---|Private IP| router4((Router<br>NAT<br>192.168.0.0/16))
    router2 ---|Private IP| device4([Device 4])
    router2 ---|Private IP| device5([Device 5])
    router3 ---|Private IP| device6([Device 6])
    router3 ---|Private IP| device7([Device 7])
    router4 ---|Private IP| device8([Device 8])
    router4 ---|Private IP| device9([Device 9])
    classDef internet fill:#ccf
    classDef router fill:#fcc
    classDef device fill:#cfc
    class internet internet
    class router1,router2,router3,router4 router
    class device1,device2,device3,device4,device5,device6,device7,device8,device9 device

Private networks are defined by specific IP address ranges that are reserved for private use. These ranges are not routable on the public internet, ensuring that devices within a private network can communicate securely without interference from external networks.

Reserved IPv4 Addresses ⁵

General Reserved IPv4 Addresses

Private IPv4 Addresses ³