DOCKER PARA

INICIANTES
EXPLORANDO CONTAINERS

FELIPE AZAMBUJA
DOCKER PARA
INICIANTES
EXPLORANDO CONTAINERS

FELIPE AZAMBUJA
ÍNDICE
Bem-vindo ao Mundo do Docker 04

Entendendo os Containers 05

Primeiros Passos com Docker 13

Comandos Docker 21

Criando Imagens 23

Sobre Docker Compose 25

Exemplo Prático: Aplicação Web

com Banco de Dados 29

Conclusão 33
Introdução: Bem-vindo ao Mundo do Docker
Docker é uma ferramenta poderosa que
revolucionou a forma como desenvolvemos e
implementamos aplicações. Antes de nos
aprofundarmos em detalhes técnicos, imagine o
seguinte cenário: você está cozinhando um prato
sofisticado em sua cozinha. Você tem todos os
ingredientes frescos, as ferramentas certas e um
livro de receitas detalhado. Tudo parece perfeito,
mas então você descobre que seu forno não
funciona, sua faca está cega e, para piorar, seus
ingredientes foram deixados ao ar livre e não
estão mais frescos.

Agora, imagine que você tem uma cozinha portátil

onde tudo é sempre perfeito. Sua faca está
sempre afiada, seus ingredientes sempre frescos
e todas as ferramentas funcionam perfeitamente.
Não importa onde você leve essa cozinha, ela
estará sempre pronta para produzir pratos
deliciosos.

Essa é a mágica do Docker. Ele cria um ambiente

controlado e consistente para suas aplicações,
permitindo que você desenvolva, teste e
implemente com confiança, independentemente
da plataforma ou infraestrutura.

4
Capítulo 1: Entendendo os Containers

Quando se começa a explorar o Docker, é

fundamental primeiro entender o que são
containers. Pense nos containers como pequenas
caixas mágicas que podem conter qualquer
aplicação, com todas as suas dependências,
bibliotecas e arquivos de configuração. Eles são
semelhantes aos containers de transporte que se
vêem nos portos: independentemente do que
está dentro, você sabe que pode ser facilmente
transportado e encaixado em qualquer lugar.

Os containers têm suas raízes em tecnologias que

surgiram no início dos anos 2000. Uma das
primeiras implementações foi a tecnologia de jails
do FreeBSD, introduzida em 2000. Essas "prisões"
permitiam que aplicações fossem executadas em
ambientes isolados, garantindo que uma
aplicação não interferisse na outra. Em 2004, a Sun
Microsystems introduziu as zonas do Solaris, que
expandiram ainda mais esse conceito, permitindo
a execução de múltiplos ambientes isolados no
mesmo sistema operacional.

5
Essas tecnologias resolveram muitos problemas
de isolamento e segurança, mas ainda eram
complexas de configurar e gerenciar. A evolução
contínua dessas ideias levou a uma abordagem
mais padronizada e simplificada: os containers
como conhecemos hoje.

Nessa época também, existiam técnicas para criar

e executar containers, e uma delas era usar o
chroot do Unix (exemplo abaixo), para isolar um
pequeno sistema, dentro do sistema principal.

Exemplo de comandos para criar um container

com chroot no linux:

sudo mkdir -p /mycontainer

sudo cp -R /bin /lib /lib64 /usr /etc /var /mycontainer/
sudo mkdir -p /mycontainer/{dev,proc,sys,tmp}
sudo mount -t proc proc /mycontainer/proc
sudo mount -t sysfs sys /mycontainer/sys
sudo mount -o bind /dev /mycontainer/dev
sudo mount -t devpts devpts /mycontainer/dev/pts
sudo chroot /mycontainer /bin/bash

6
Como resultado, temos uma estrutura de
diretórios do sistema parecida com a da imagem
abaixo:

7
A Necessidade dos Containers

Imagine a frustração de um desenvolvedor ao

criar uma aplicação que funciona perfeitamente
na sua máquina local, mas que, ao ser transferida
para o servidor de produção, começa a apresentar
problemas. Pode ser uma versão diferente de uma
biblioteca, uma configuração de sistema
operacional distinta ou até mesmo um problema
com as permissões de arquivo. Esse tipo de
problema é comum e é resumido pela famosa
frase: "na minha máquina funciona".

Os containers surgem como uma solução para

este problema. Eles encapsulam tudo o que uma
aplicação precisa para rodar: o código, as
dependências, as bibliotecas e até mesmo partes
do sistema operacional. Isso significa que, se um
container funciona na máquina do desenvolvedor,
ele também funcionará no servidor de produção,
em qualquer nuvem, ou em outro ambiente que
suporte containers.

8
Imagine um time de desenvolvedores
trabalhando em uma aplicação complexa. Cada
um tem seu próprio ambiente de
desenvolvimento configurado de forma
ligeiramente diferente. As versões das bibliotecas
não coincidem, as variáveis de ambiente estão
desorganizadas e, frequentemente, um bug surge
em um ambiente mas não no outro. A
coordenação se torna um desafio, e a
produtividade é prejudicada. Com os containers,
cada desenvolvedor pode trabalhar no mesmo
ambiente padronizado, encapsulado dentro de
um container. Isso elimina as discrepâncias e
garante que o código funcione de maneira
consistente para todos.

Além disso, pense em um cenário onde a equipe

precisa implantar a aplicação em produção.
Tradicionalmente, esse processo poderia ser uma
dor de cabeça, com scripts de implantação
complicados e inúmeros pontos onde algo
poderia dar errado. A diferença entre o ambiente
de desenvolvimento e o de produção causava
inúmeros problemas. Com containers, a
implantação se torna uma tarefa simples e direta.
A aplicação roda dentro de um container que
inclui tudo o que ela precisa. Isso significa que, se
funciona em um container no ambiente de
desenvolvimento, também funcionará no
container em produção.

9
E não se trata apenas de consistência. A
segurança também é aprimorada. Quando
múltiplas aplicações são executadas no mesmo
servidor sem containers, há sempre o risco de
uma aplicação interferir na outra, seja por
conflitos de dependências ou por questões de
segurança. Os containers fornecem isolamento.
Cada aplicação roda em seu próprio container,
isolada das outras, evitando conflitos e
aumentando a segurança.

10
A Evolução das Ferramentas e Técnicas

No começo, configurar containers era uma tarefa

desafiadora. Ferramentas como as jails do
FreeBSD e as zonas do Solaris exigiam um
conhecimento profundo do sistema operacional e
uma configuração manual tediosa. A necessidade
de uma solução mais acessível e padronizada se
tornou evidente.

Foi aí que surgiram tecnologias como o LXC (Linux

Containers), que trouxeram uma abordagem mais
simplificada ao isolamento de processos no Linux.
No entanto, ainda faltava uma ferramenta que
fosse fácil de usar, altamente configurável e
amplamente adotada pela comunidade de
desenvolvedores.

11
O Nascimento do Docker

Em 2013, durante a conferência PyCon, Solomon

Hykes apresentou um novo projeto chamado
Docker. O Docker trouxe uma revolução ao
mundo dos containers, tornando-os acessíveis e
fáceis de usar para desenvolvedores de todos os
níveis de experiência.

O Docker introduziu conceitos que facilitam a vida

dos desenvolvedores, como o Dockerfile, que
permite definir tudo o que um container precisa
em um simples arquivo de texto, e o Docker Hub,
um repositório onde os desenvolvedores podem
compartilhar suas imagens de containers.

Com o Docker, a criação, o gerenciamento e a

distribuição de containers se tornaram tão
simples quanto rodar alguns comandos no
terminal. Foi uma transformação que não apenas
resolveu os problemas que enfrentávamos há
anos, mas também abriu novas possibilidades
para o desenvolvimento de software ágil e
escalável.

12
Capítulo 1I: Primeiros Passos com Docker

Após entender a importância e a evolução dos

containers, é hora de entrar no mundo do Docker.
Este capítulo guiará você pelos primeiros passos
para começar a usar Docker, desde a instalação
até a execução dos primeiros containers.

Instalando o Docker
O primeiro passo para começar a usar Docker é
instalá-lo em seu sistema. O Docker é compatível
com várias plataformas, incluindo Windows,
macOS e Linux. Abaixo, você encontrará
instruções para instalar Docker em cada uma
dessas plataformas.

Windows
1 - Instale o WSL no seu sistema. Para isso, abra o
PowerShell e execute o comando:

wsl --install

13
2 - Reinicie e depois abra a nova aplicação
disponível “Ubuntu”. (Ubuntu é padrão)

3 - Acesse o Ubuntu e crie um usuário e senha para

o sistema. Após definir, está pronto para uso.

4 - Baixe e instale o Docker Desktop for Windows

no site oficial: clicando aqui

5- Após reiniciar mais uma vez, já pode abrir o

terminal e testar fazendo um "Hello World" no
Docker:

docker run hello-world

14
Linux (Ubuntu based)
1 - Atualize o sistema

sudo apt-get update

sudo apt-get upgrade

2 - Instale os pacotes necessários

sudo apt-get install \

apt-transport-https \
ca-certificates \
curl \
software-properties-common

3 - Instale o Docker
sudo apt-get install docker-ce

4 - Adicione o usuário ao grupo Docker

sudo usermod -aG docker ${USER}

5 - Agora é só reiniciar e testar

docker run hello-world

15
MacOS

1 - Baixe o Docker Desktop para Mac no site oficial

do Docker: clicando aqui

2 - Abra o arquivo .dmg baixado e arraste o ícone

do Docker para a pasta Aplicativos.

3 - Inicie o Docker Desktop a partir da pasta

Aplicativos e verifique se está rodando.

16
Conceitos Básicos do Docker

Agora que o Docker está instalado, é hora de

entender alguns conceitos básicos. Esses
conceitos são fundamentais para usar o Docker
de forma eficaz.

Imagem Docker

Uma imagem Docker é um pacote leve e

independente que contém tudo o que é
necessário para executar uma aplicação,
incluindo o código, as bibliotecas e as
dependências. Pense na imagem como um
modelo a partir do qual os containers são criados.

Imagine a imagem Docker como se fosse uma iso

de um pequeno sistema operacional, cujo único
objetivo seja rodar uma aplicação em específico.

Container Docker

Um container é uma instância em execução de

uma imagem Docker. Ele encapsula uma aplicação
e todas as suas dependências, garantindo que ela
possa ser executada de maneira consistente em
qualquer ambiente.

17
Dockerfile

Um Dockerfile é um script de texto que contém

uma série de comandos para criar uma imagem
Docker. Ele define o que será incluído na imagem,
desde o sistema operacional base até as
dependências e configurações da aplicação.

As imagens são construídas em camadas, e cada

comando do Dockerfile cria uma camada na
imagem Docker. Veja um exemplo de Dockerfile e
da imagem buildada a partir dele:

Dockerfile
FROM python:3.11-slim

WORKDIR /app COPY requirements.txt /app/

RUN pip install --no-cache-dir -r requirements.txt

COPY . /app/

EXPOSE 8000

CMD ["sh", "-c", "python manage.py migrate && python

manage.py runserver 0.0.0.0:8000"]

18
Camadas da imagem gerada

19
Docker Hub

O Docker Hub é um repositório online onde

desenvolvedores podem encontrar, compartilhar
e colaborar em imagens Docker. É uma
plataforma essencial para qualquer pessoa que
utilize Docker, pois facilita a distribuição de
aplicações e a reutilização de componentes. Neste
capítulo, vamos explorar como usar o Docker Hub,
desde a criação de uma conta até a publicação de
suas próprias imagens.

Pense no Docker Hub como uma loja de

aplicativos, mas em vez de aplicativos móveis, ele
oferece imagens Docker. Existem imagens oficiais
mantidas pelo Docker e pela comunidade, que
cobrem uma ampla gama de aplicações e serviços,
como bancos de dados, servidores web,
ferramentas de desenvolvimento, e muito mais.

Você pode criar uma conta no Docker Hub

clicando aqui

20
Capítulo 1II: Comandos Docker

1 - Executando um container
O comando mais simples para executar um
container é docker run. Vamos começar com uma
imagem popular chamada hello-world, que é
usada para testar se o Docker está funcionando
corretamente.

docker run hello-world

Este comando baixa a imagem hello-world do

Docker Hub (se ainda não estiver presente no seu
sistema) e executa um container a partir dessa
imagem. Você verá uma mensagem confirmando
que o Docker está instalado e funcionando
corretamente.

2 - Listando containers
Para ver todos os containers em execução, use o
comando docker ps. Para listar todos os
containers, incluindo os que foram finalizados,
use docker ps -a.

docker ps
docker ps -a

21
3 - Baixando Imagens
Você pode baixar imagens diretamente do Docker
Hub usando o comando docker pull. Vamos
baixar uma imagem do Ubuntu.

docker pull ubuntu

4 - Executando um Container Interativo

Para executar um container interativo (com
acesso ao terminal), use a opção -it. Vamos
executar um container Ubuntu e acessar o
terminal dele.

docker run -it ubuntu

Você estará dentro do container Ubuntu e poderá

executar comandos como se estivesse em um
sistema Ubuntu normal. Para sair, digite exit.

5 - Removendo Containers e Imagens

Para remover um container , use o comando
docker rm seguido do ID ou nome do container.
Para remover uma imagem, use docker rmi.

docker rm <container_id>
docker rmi <image_id>

22
Capítulo 1V: Criando Imagens
Agora que você já está familiarizado com alguns
comandos básicos do Docker, vamos criar sua
primeira imagem Docker. Para isso, vamos usar
um Dockerfile.

Vamos criar uma imagem Docker que executa

uma aplicação simples em Python. Crie um novo
diretório para o projeto e dentro dele, crie um
arquivo chamado Dockerfile com o seguinte
conteúdo:

# Use a imagem base do Python

FROM python:3.8-slim

# Defina o diretório de trabalho dentro do container

WORKDIR /app

# Copie o arquivo de código para o container

COPY app.py .

# Instale as dependências necessárias (se houver)

# RUN pip install -r requirements.txt

# Defina o comando de execução da aplicação

CMD ["python", "app.py"]

23
Crie também um arquivo chamado app.py no
mesmo diretório com o seguinte conteúdo:

print("Olá, Docker!")

Para criar a imagem Docker a partir deste

Dockerfile, use o comando docker build:

docker build -t minha-app .

Este comando cria uma imagem chamada minha-

app a partir do Dockerfile no diretório atual.

Executando a Imagem
Agora, execute um container a partir da imagem
que você acabou de criar:

docker run minha-app

Você verá a mensagem "Olá, Docker!" no

terminal, indicando que a aplicação foi executada
com sucesso dentro do container.

24
Capítulo V: Sobre Docker Compose
Conforme suas aplicações Docker se tornam mais
complexas, com múltiplos containers interagindo
entre si, gerenciá-las manualmente pode se
tornar uma tarefa desafiadora. É aí que entra o
Docker Compose. Docker Compose é uma
ferramenta poderosa que permite definir e
gerenciar ambientes multi-container de forma
declarativa usando um simples arquivo YAML.
Neste capítulo, você aprenderá a usar o Docker
Compose para facilitar o desenvolvimento, teste e
implantação de aplicações complexas.

O arquivo YAML usado pelo Docker Compose é

chamado docker-compose.yml, onde você
descreve a configuração de todos os serviços,
redes e volumes necessários para sua aplicação.

25
Instalando o Docker Compose

Docker Compose geralmente é instalado junto

com o Docker Desktop para Windows e macOS. No
entanto, se você estiver usando Linux, pode ser
necessário instalá-lo separadamente.

1 - Baixe a versão mais recente do Docker

Compose

sudo curl -L
"https://github.com/docker/compose/releases/download/$(curl -s
https://api.github.com/repos/docker/compose/releases/latest |
grep -oP '"tag_name": "\K(.*)(?=")')/docker-compose-$(uname -
s)-$(uname -m)" -o /usr/local/bin/docker-compose

2 - Aplique permissões executáveis ao binário

sudo chmod +x /usr/local/bin/docker-compose

3 - Verifique a instalação

docker-compose --version

26
Estrutura do Arquivo docker-compose.yml

Um arquivo docker-compose.yml é composto por

várias seções principais:
version: Define a versão do arquivo Compose.
services: Define os containers a serem
executados.
volumes: Define volumes persistentes a
serem usados pelos containeres.
networks: Define redes personalizadas para
os containers.

version: '3'
services:
web:
image: nginx:alpine
ports:
- "8080:80"
volumes:
- web-data:/usr/share/nginx/html

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

volumes:
web-data:
db-data:

27
Comandos Básicos do Docker Compose

Docker Compose oferece uma variedade de

comandos para gerenciar seus ambientes de
containers:

docker-compose up: Inicia todos os serviços

definidos no arquivo docker-compose.yml.

docker-compose down: Para e remove todos os

containeres, redes e volumes criados pelo docker-
compose up.

docker-compose ps: Lista todos os containers em

execução.

docker-compose logs: Exibe os logs dos

containers.

docker-compose exec: Executa um comando em

um container em execução.

28
Capítulo VI: Exemplo Prático: Aplicação Web
com Banco de Dados
Vamos criar uma aplicação web simples que se
conecta a um banco de dados PostgreSQL. A
aplicação será escrita em Python usando o
framework Flask.

Estrutura do Projeto
Crie a seguinte estrutura de diretórios:

29
Arquivos da Aplicação

app/__init__.py
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

db_conn = 'postgresql://user:password@db:5432/mydb'

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = db_conn
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

from app import models

with app.app_context():
db.create_all()

app/app.py
from flask import request, jsonify
from app import app, db
from app.models import Person

@app.route('/')
def hello():
return "Olá, Docker Compose!"

@app.route('/persons', methods=['POST'])
def create_person():
data = request.get_json()
new_person = Person(name=data['name'])
db.session.add(new_person)
db.session.commit()
return jsonify({'message': 'Person created successfully'}), 201

@app.route('/persons', methods=['GET'])
def get_persons():
persons = Person.query.all()
result = [{'id': person.id, 'name': person.name} for person in persons]
return jsonify(result)

30
app/models.py
from app import db

class Person(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)

app/requirements.txt

Flask
Flask-SQLAlchemy
psycopg2-binary

docker-compose.yml
version: '3.8'
services:
web:
build: .
ports:
- "5000:5000"
volumes:
- ./app:/app
depends_on:
- db

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

volumes:
db-data:

31
Dockerfile
FROM python:3.11-slim

WORKDIR /app

COPY app/requirements.txt requirements.txt

RUN pip install -r requirements.txt

COPY app/ .

CMD ["flask", "run", "--host=0.0.0.0"]

Executando a Aplicação
No terminal, navegue até o diretório do projeto e
execute:
docker-compose up

Abra o navegador e acesse http://localhost:5000.

Você verá a mensagem "Olá, Docker Compose!".

Na rota http://localhost:5000/persons é possível

listar todas as pessoas cadastradas na base de
dados usando o método GET.
E usando o método POST na rota
http://localhost:5000/persons é possível cadastrar
uma pessoa passando no body da requisição o
json com os dados:

{
"name": "John Doe"
}

32
Capítulo VII: Conclusão
Ao longo deste e-book, você foi apresentado ao
Docker, uma ferramenta revolucionária que
transformou a maneira como desenvolvemos,
testamos e implantamos aplicações. Desde o
entendimento básico de containers até o uso de
Docker Compose para gerenciar ambientes
complexos, você aprendeu os fundamentos
necessários para começar a utilizar Docker em
seus projetos.

Revisitamos a história dos containers,

compreendendo como surgiram e a importância
deles na solução de problemas de portabilidade e
consistência de ambiente. Exploramos os
conceitos básicos de containers e como eles
proporcionam um isolamento eficaz para nossas
aplicações. Em seguida, mergulhamos nas
funcionalidades avançadas, que permitem a
criação de aplicações mais robustas e
persistentes.

33
Ao longo dos capítulos, também conhecemos o
Docker Hub, uma plataforma essencial para
compartilhar e encontrar imagens Docker. Vimos
como ele facilita a distribuição de aplicações e a
colaboração entre desenvolvedores. Além disso,
exploramos o Docker Compose, uma ferramenta
poderosa para orquestrar múltiplos containers e
simplificar o gerenciamento de ambientes
complexos.

Próximos Passos

Embora você tenha aprendido muito até aqui, há

sempre mais para explorar e dominar. Aqui estão
alguns próximos passos que você pode seguir
para continuar seu aprendizado e aprofundar seu
conhecimento em Docker:

1. Explorar Docker Swarm e Kubernetes: Docker

Swarm e Kubernetes são ferramentas de
orquestração de containers que permitem
gerenciar clusters de containers em larga escala.
Aprender a usar essas ferramentas pode ajudá-lo
a escalar suas aplicações e gerenciar ambientes
de produção de maneira mais eficiente.

34
2. Praticar com Projetos Reais: A melhor maneira
de solidificar seu conhecimento é aplicá-lo em
projetos reais. Tente construir e implantar uma
aplicação completa usando Docker e Docker
Compose. Experimente diferentes configurações
e explore as melhores práticas para otimização e
segurança.

3. Participar da Comunidade: A comunidade

Docker é vasta e ativa. Participe de fóruns, grupos
de discussão e eventos para aprender com outros
desenvolvedores. Contribuir para projetos de
código aberto também pode ser uma excelente
maneira de ganhar experiência prática e
colaborar com a comunidade.

4. Estudar Segurança em Docker: À medida que

você começa a usar Docker em ambientes de
produção, é crucial entender as melhores práticas
de segurança. Estude como proteger seus
containers, gerenciar permissões e configurar
redes seguras.

5. Certificações Docker: Para aqueles que

desejam validar seu conhecimento e habilidades,
a Docker oferece certificações oficiais. Obtê-las
pode ser uma ótima maneira de demonstrar sua
competência e se destacar no mercado de
trabalho.

35
Recursos Adicionais

Documentação Oficial do Docker: A

documentação oficial é uma fonte abrangente
de informações sobre todas as
funcionalidades do Docker. (Recursos
Adicionais)

Docker Labs: Uma coleção de tutoriais

interativos e exercícios práticos.
(https://labs.play-with-docker.com/)

Livros: "Docker Deep Dive" de Nigel Poulton e

"The Docker Book" de James Turnbull são
ótimos livros para aprofundar seu
conhecimento.

Agradecimentos
Obrigado por acompanhar este e-book até o final.
Esperamos que você tenha encontrado o
conteúdo útil e que ele tenha proporcionado uma
base sólida para sua jornada com Docker.
Continue explorando, praticando e aprendendo.
O mundo dos containers é vasto e cheio de
possibilidades. Boa sorte!

36
Contato
Siga @pycodebr nas redes sociais

@pycodebr

@pycodebr

@pycodebr

37
FELIPE AZAMBUJA