Afinal o que é Docker?

De maneira simplificada para não assustar ninguém, o Docker é uma forma de container onde utiliza o OS para compartimentar configurações padrões, a grande vantagem do mesmo é o deploy em produção e os ambientes de todos os devs estarem alinhados mesmo que os devs utilizem múltiplos OS diferentes.

Ao meu ver a grande vantagem do Docker em relação a VM pra desenvolvimento é que a VM você compartimenta recursos e instalado um OS do zero inclusive toda vez que precisa usa-lo você precisa dar boot no sistema operacional da VM, no Docker isso não é necessário mas como é feita essa diferenciação?

Diferença Docker e VM

1. Abstração do sistema operacional
2. Docker: Utilizam o pensamento de container e utiliza o Kernel do OS nativo, tornando mais rápido e eficiente sua inicialização e mantendo suas próprias bibliotecas e binários dentro do container.
3. Virtual machine: Máquinas virtuais completas com seu próprio OS, incluindo Kernel. Acaba que a VM consome mais recursos físicos em comparação ao Docker.
4. Isolamento
5. Docker: Apesar de compartilharem o mesmo kernel do OS, os containers são isolados uns dos outros, apesar de não ter um OS próprio consegue manter um alto grau de isolamento de recursos, como processos e sistemas de arquvos.
6. Virtual machine: Cada VM é uma instância independente com seu próprio kernel e sistema operacional, proporcionando um alto nível de isolamento mas acaba que por consequência exigindo mais do hardware.
7. Eficiência de recursos
8. Docker: Contêineres são geralmente mais eficientes em termos de uso de recursos de hardware em comparação com as VMs, podendo ser iniciadas e interrompidas rapidamente, justamente devido a utilização do Kernel nativo do OS hospedeiro.
9. Vitual machine: VMs consomem mais recursos devido à duplicação de sistemas operacionais, sendo assim sendo mais custosas para iniciar e interrompê-las.
10. Portabilidade
11. Docker: É altamente portátil, incluem todos os componentes necessários para executar um aplicativo, tornando mais fácil mover entre ambientes de desenvolvimento, teste e produção.
12. Virtual machine: VMs também são portáteis, mas são menos leves do que os contêineres. A migração das VMs pode ser mais complicada devido às diferenças de infraestrutura entre os hosts.
13. 
    

Na prática

Aproveitando que preciso desenvolver um Docker para testar o Blog Open Source que desenvolvi, https://github.com/andmarruda/sbblog vou configurar um ensinando passo a passo aqui como fazer seu primeiro container Docker.

Mas Anderson, porque não usa o sail do laravel?

Se usasse o sail do laravel eu não poderia fazer uma boa introdução ao Docker para quem é muito recém chegado ao mesmo.

Experiência pessoal

Pude perceber que pelo sistema ser nativo o Linux tem uma eficiência muito grande rodando Docker, já o Windows tem algumas dificuldades relacionada ao WSL2 e a conversão de formatação de arquivo, muitas vezes tendo que converter de NTFS pra EXT4 o que causa uma lentidão absurda, no Mac ainda não tive experiência mas estou ansioso para ter.

Como contornei a lentidão no Windows?

Procuro configurar o Docker sempre usando o Ubuntu dentro do Linux o que aumenta e muito a eficiência e desempenho do container. Mas caso queiram que eu comentei mais sobre isso por favor digam nos comentários, #comoMelhorarDockerWsl2

Docker do SBBlog

O SBBlog foi projetado para rodar com Laravel 9 e PostgreSQL por isso irei pegar uma imagem de php-fpm de dockerfile para iniciar o pensamento do container do Docker para esse projeto.

O PostgreSQL vai ter suas características e configurações, não somente o nginx e o php, por isso é necessário que se atente e não as esqueça para trás.

A primeira coisa que fiz foi procurar referências de imagens oficiais:

• PHP: https://hub.docker.com/_/php
• PostgreSQL: https://hub.docker.com/_/postgres
• Nginx: https://hub.docker.com/_/nginx

Vão perceber que grande parte das soluções que você pensa em customizar manualmente já foi prevista pelas imagens oficiais no Docker, então é sempre bom tentar ler antes de tentar fazer configurações na mão, configurações na mão requer muita experiência e muito experimento até que seja refinado e flua da forma adequada a seu problema, dito isso vamos prosseguir.

Configurando Docker

docker-compose.yml

Primeiro eu criei uma pasta na raiz do projeto chamada docker-compose onde ficará armazenado os arquivos de configuração dos serviços que irei utilizar, os arquivos de PostgreSQL eu já falei em outros posts então não vou entrar em detalhes deles para não ficar muito longo.

Aqui estão os arquivos que utilizei.

https://github.com/andmarruda/docker-pgsql-php-laravel

Afinal o que é o Docker-compose.yml?

É o arquivo que descreve a composição, os pacotes, instalações, portas e configurações gerais que o Docker terá que executar.

Dockerfile

Arquivo de configuração usado no Docker para construir imagens de contêiner personalizadas, descrevendo passos e as configurações necessárias para criar uma imagem de contêiner específica que pode ser usada para executar aplicativos ou serviços em seus respectivos contêineres.

version: "3.7"
services:
  app:
    build:
      args:
        user: root
        uid: 1000
      context: ./
      dockerfile: Dockerfile
    image: sbblog-laravel
    container_name: sbblog-dockerized
    restart: unless-stopped
    working_dir: /var/www
    volumes:
      - ./:/var/www
    networks:
      - sbblog-network
    command: ["sh", "-c", "php-fpm && composer update && php artisan migrate"]

  nginx:
    image: nginx
    container_name: sbblog-nginx
    restart: unless-stopped
    ports:
      - "100:80"
    volumes:
      - ./:/var/www
      - ./docker-compose/nginx:/etc/nginx/conf.d/
    networks:
      - sbblog-network

  pgsqldb:
    image: postgres:16
    container_name: sbblog-pgsqldb
    restart: unless-stopped
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: sbblog_user
      POSTGRES_PASSWORD: Sbblog@123
      POSTGRES_DB: sbblogdb
    volumes:
      - sbblog-dbdata:/var/lib/postgresql/16/main
      - ./docker-compose/pg_hba.conf:/etc/postgresql/16/main/pg_hba.conf
      - ./docker-compose/postgresql.conf:/etc/postgresql/16/main/postgresql.conf
    networks:
      - sbblog-network

networks:
  sbblog-network:
    driver: bridge
    name: sbblog-network

volumes:
  sbblog-dbdata:
    driver: local

• version: refere-se à versão da especificação do Docker Compose que está sendo usada.
• services: recebe os serviços que serão executados dentro do container
• app o nome do serviço
• build: especificações para a construção do container e serviços
• args: os argumentos que serão utilizados nesse caso usei user e uid, user declarei como root e uid como 1000 que é o id dos usuários não privilegiados no linux por padrão.
• context: diretório do contexto, nesse caso usei o diretório onde o arquivo docker-compose.yml está.
• dockerfile: específica o nome do arquivo que está sendo usado para construir a imagem.
• image: define a imagem Docker que será usada para criar o contêiner, nesse caso sbblog-laravel.
• container_name: Especifica o nome do contêiner Docker que será criado a partir da imagem, nesse caso sbblog-dockerized.
• restart: define a política de reinicialização, unless-stopped indica que o contêiner será reiniciado automaticamente, a menos que você o pare explicitamente.
• working-dir: Define o diretório de trabalho dentro do contêiner. O comando dentro do contêiner será executado no contexto deste diretório.
• volumes: Mapeia o diretório atual( onde o arquivo docker-compose.yml etá localizado) para /var/www dentro do contêiner.
• networks: Associa o contêiner à rede com o nome que você escolher. Isso permite que o contêiner se comunique com outros contêineres na mesma rede, se houver.
• command: Define o comando que será executado quando o contêiner for iniciado.
• nginx: configurando contêiner docker para servidor web Nginx
• image: Define a imagem Docker que será usada para criar o contêiner.
• container_name: o nome do contêiner
• restart: equivalente ao citado anteriormente
• ports: mapeia portas, nesse caso a porta 100 do host será redirecionada para a porta 80 dentro do contêiner.
• volumes: já explicado anteriormente
• networks: já explicado anteriormente
• pgsqldb: nome do serviço do postgresql
• image: a imagem que será usada no contêiner
• container_name: nome do container
• restart: explicado anteriormente
• ports: Aqui são configuração de portas, nesse caso a porta do host 5432 está sendo direcionada pra porta interna do contêiner 5432.
• environment: Declara abertura para configurações de ambiente
• POSTGRES_USER: nome do usuário que será utilizado no PostgreSQL
• POSTGRES_PASSWORD: a senha do usuário PostgreSQL
• POSTGRES_DB: o nome do banco de dados no PostgreSQL
• volumes: explicado previamente
• networks: explicado previamente
• networks: nesse caso é fora das imagens e você está declarando as configurações de redes
• sbblog-network: nome da rede
• driver: especifica o driver de rede como bridge, que é driver padrão do docker.
• name: sbblog-network o nome da rede.
• volumes: sessão volumes específica volumes de dados armazenados pelos contêiner no disco, claro que vai depender da configuração do driver, no caso usei local para armazenar no disco local.

Dockerfile

FROM php:8.2-fpm

ARG user
ARG uid

RUN apt update && apt install -y \
    git \
    curl \
    libcurl4-openssl-dev \
    sudo \
    nano \
    apt \
    wget \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    libpq-dev \
    zip \
    libzip-dev \
    unzip \
    software-properties-common && \
    rm -rf /var/lib/apt/lists/*

RUN docker-php-ext-install pdo_pgsql mbstring exif pcntl bcmath gd zip curl opcache xml zip

RUN pecl install xdebug && docker-php-ext-enable xdebug

COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
RUN mkdir -p /home/$user/.composer && \
    chown -R $user:$user /home/$user && \
    chmod -R 777 /home/$user/.composer && \
    composer config --global process-timeout 2000

WORKDIR /var/www

USER $user

• FROM: especifica a imagem base nesse caso PHP 8.2 com FPM
• ARG: define argumentos para construção, no caso foram definidos 2, user e uid
• RUN: roda comando dentro do contêiner, como instalar pacotes, criação de pastas e outros comandos shell script.
• COPY: copia arquivos, nesse caso copia o arquivo binário do composer para dentro da localização onde ele se torna global em distro Linux.
• WORKDIR: Seta o diretório de trabalho dentro do contêiner.
• USER: troca o contexto do usuário pelo que está sendo passado pelo contexto no caso o user root.

Criei esse Docker como base para ambiente de desenvolvimento, também é uma base para produção porém para isso deve-se considerar melhorar a segurança, evitar utilizar usuário como root e afins, adicionando alguns passos adicionais para que o ambiente fique seguro.

Esse é meu primeiro tutorial do Docker, se gostaram por favor compartilhem, espero ajudar vocês, se quiserem deixar comentários me ensinando coisas novas por favor fiquem a vontade.

Espero vocês no próximo artigo... Até mais!