Série Infra One Kindle

Docker One

Da minha máquina à produção, sem mistério

Docker do zero, dentro de uma bilheteria on-line da serra gaúcha que tem oito semanas até abrir a venda do Festival de Inverno: um computador embaixo do balcão com um adesivo de NÃO DESLIGAR, quatro sistemas em quatro linguagens, um deploy que no ano passado derrubou o site por três horas e doze minutos, e um sócio que só pergunta quanto custa. Containers, imagens, Dockerfile, volumes, redes, Compose, registries, CI/CD com GitHub Actions, uma VPS com HTTPS, segurança e diagnóstico — cada peça desenhada em diagrama antes de ser rodada no terminal.

R$ 15,90 ~~R$ 24,00~~ Promoção

Atenção: o idioma desta edição é português.

Comprar agora → Ver o sumário Ler prévia gratuita Avaliações Carregando

57capítulos

13partes

1projeto do início ao fim

Capa de Docker One: Da minha máquina à produção, sem mistério, de Thiago Nogueira

Edição Brasil

DockerComposeDockerfileGitHub ActionsGHCRCaddyVPS

código do livro

Menos teoria vazia.
Mais código que funciona.

Nada de exemplo solto com foo e bar. Todo trecho pertence ao mesmo projeto, que cresce capítulo a capítulo — e os erros aparecem como aparecem na sua tela, para serem lidos linha por linha.

Dockerfile

FROM python:3.12-slimWORKDIR /appCOPY . .CMD ["uvicorn", "app:app", "--host", "0.0.0.0"]

terminal

docker compose up -dContainer serra-api  Started

o projeto

Um sistema só, do primeiro arquivo ao deploy

README.md

A venda do Festival de Inverno, segunda, 1º de março, às 10h.

Da minha máquina à produção, sem mistério.

Um projeto só: a venda do Festival de Inverno, segunda, 1º de março, às 10h
Cada peça do Docker desenhada antes de ser rodada: host, daemon, camadas, redes, volumes
Python, Node.js, PHP e Java no mesmo compose.yaml, com PostgreSQL e Redis
Do Dockerfile ao GHCR, do GitHub Actions à VPS com HTTPS
Segurança, diagnóstico e os erros que derrubam produção numa sexta-feira

leitura de amostra

Leia uma prévia gratuita de Docker One

Esta amostra contém os primeiros capítulos. O PDF completo continua protegido para compradores.

Abrir prévia em nova aba →

sumário

57 capítulos em 13 partes

Abra uma parte para ver os capítulos — e a frase que abre cada um.

parte 01 Funciona na minha máquinaUm computador embaixo do balcão, um deploy que derrubou o site no ano passado, e a ideia de embalar o programa junto com o mundo que ele precisa para rodar. 6 cap.

01
Funciona na minha máquinaUma fita crepe escrito NÃO DESLIGAR, um traceback de seis linhas que custou três horas e doze minutos, e a ideia de mandar o programa para o servidor junto com o mundo todo em que ele foi testado.
02
De chroot a containerUma chamada de sistema de 1979, um orçamento de novecentos reais por mês para quatro máquinas virtuais, e o motivo de um container ligar em um segundo quando um computador simulado leva um minuto.
03
Instalar e conferirUm notebook com Windows, um MacBook do estagiário, um servidor Ubuntu de teste, e a mensagem de um container que diz, em vinte linhas, tudo o que acabou de acontecer com ele.
04
Cliente, daemon e registryUm comando que só pede, um programa que faz, um servidor do outro lado do oceano que guarda as imagens, e um curl que prova que o docker é só um cliente HTTP com boas maneiras.
05
Namespaces e cgroupsUm processo que acha que é o número 1 e é o 4.122, um Alpine que roda dentro de um Ubuntu sem que nenhum dos dois perceba, e um tail que come 64 megabytes e morre com o código 137.
06
A linha de comandoDois containers que sumiram do docker ps sem ter ido a lugar nenhum, um nome sorteado que homenageia uma cientista, e a gramática de quatro palavras que organiza mais de cem comandos.

parte 02 Containers na práticaRodar, parar, entrar, publicar portas, passar configuração, ler o que o container diz e limpar o que ficou para trás. 7 cap.

07
O primeiro containerUm servidor web que prende o terminal, outro que some em segundo plano, uma página que o navegador não acha, e um nome que não pode ser usado duas vezes.
08
O ciclo de vidaSeis estados, dez segundos de espera para parar um programa que não faz nada, e a diferença entre pedir para um processo sair e arrancá-lo da tomada.
09
Dentro do containerUma página da Serra Ingressos copiada para dentro de um nginx, um ps que não existe, a lista de tudo o que mudou desde que o container nasceu, e uma alteração que some quando o container é recriado.
10
PortasUma porta 80 que já tem dono, um PostgreSQL de teste aberto para a rede toda do escritório, e a diferença entre escutar em todo lugar e escutar só em casa.
11
Variáveis de ambienteUm PostgreSQL que se recusa a nascer sem senha, um arquivo de configuração que entrou no Git por engano, e uma senha que qualquer pessoa com acesso ao Docker lê com um comando.
12
Logs e inspeçãoUm nginx que escreve o log num arquivo que é, na verdade, a tela; um site em PHP cujo docker logs está vazio porque o log foi para um arquivo dentro do container; e um JSON de trezentas linhas com tudo que o daemon sabe.
13
Reiniciar e limparUm servidor que reinicia de madrugada e acorda sem nenhum container rodando, um programa que cai, levanta e cai de novo em intervalos que dobram, e trinta e oito gigabytes de imagens esquecidas no Mac do estagiário.

parte 03 ImagensCamadas, Dockerfile, cache, multi-stage e tags — a receita que transforma o código da Serra Ingressos num pacote que roda igual em qualquer lugar. 7 cap.

14
O que é uma imagemUma camada que já existe porque o nginx a trouxe na semana passada, três pastas que o núcleo empilha e mostra como uma só, e uma impressão digital de 64 caracteres que diz exatamente o que você baixou.
15
O primeiro DockerfileSeis linhas que transformam a API da Serra Ingressos numa imagem, um arquivo que não existe porque alguém escreveu requisitos em vez de requirements, e uma API que responde para si mesma e para mais ninguém.
16
CMD e ENTRYPOINTUma API que leva dez segundos para parar porque quem recebe o sinal é um sh que não repassa nada, duas instruções que parecem fazer a mesma coisa e se combinam numa tabela de quatro casas, e um script de três linhas cuja última palavra importa mais que as outras.
17
EXPOSE, ENV, ARG e USERUma porta que a imagem declara e ninguém abre, um print que só aparece no log quando o buffer enche, uma senha de build que o docker history mostra a quem pedir, e uma API que roda como root sem nenhum motivo.
18
Camadas, cache e contextoDoze segundos de pip install a cada vírgula mudada no código, um contexto de construção de dois gigabytes porque havia um backup do banco na pasta, e um arquivo .env com a senha de produção copiado para dentro da imagem sem ninguém pedir.
19
Multi-stageUm driver de banco que só instala com um compilador, uma imagem que engorda até 1,2 gigabyte por causa de ferramentas que o programa nunca usa, e um Dockerfile com dois FROM em que o segundo só leva o que o primeiro produziu.
20
Tags e versõesUma imagem chamada latest que não é a última, três nomes para os mesmos bytes, e um servidor que roda uma versão que ninguém consegue dizer qual é.

parte 04 Volumes e persistênciaO container que esqueceu todos os ingressos vendidos, e as três formas de guardar dados fora dele. 4 cap.

21
O container que esqueceuTrezentas e doze reservas de teste que somem com um docker rm, um volume com nome de sessenta e quatro caracteres que guardou tudo sem ninguém saber, e a diferença entre um dado que mora no container e um que só passa por ele.
22
Bind mounts e tmpfsUma pasta do notebook aparecendo dentro do container, uma página que muda no navegador no mesmo segundo em que é salva, uma pasta node_modules que desaparece porque alguém montou outra por cima, e um lugar para guardar o que não pode tocar o disco.
23
PermissõesUm usuário chamado livia que, dentro do container, não tem nome nenhum, uma pasta de relatórios que o programa não consegue escrever, arquivos de root que só saem com sudo, e um PostgreSQL que se recusa a usar uma pasta que não é dele.
24
O banco e o backupUm backup diário que rodava desde 2019 e gravava um arquivo de zero bytes, dois jeitos de copiar um banco que só são iguais quando o banco está parado, e a única pergunta que importa sobre qualquer backup: alguém já restaurou?

parte 05 RedesComo um container fala com outro, com o host e com a internet — e o que fazer quando ele para de falar. 3 cap.

25
Como um container falaUma ponte de rede que o Docker cria no host sem pedir licença, um par de cabos virtuais por container, um ping que acha o vizinho pelo número e não pelo nome, e um container sem rede nenhuma de propósito.
26
Redes e DNSUma rede chamada ingressos em que a API acha o banco pelo nome, um servidor de DNS que mora no endereço 127.0.0.11 de todo container, e um site antigo que não deveria conseguir falar com o banco e conseguia.
27
Fora da rede do DockerUm localhost que dentro do container quer dizer outra coisa, o banco antigo do SRV01 alcançado de um container novo, uma imagem cheia de ferramentas de rede que se pendura no namespace de outro container, e quatro perguntas, em ordem, para qualquer conexão que não conecta.

parte 06 Docker ComposeQuatro serviços, um banco e um cache num arquivo só, que sobe com um comando e se explica sozinho. 6 cap.

28
ComposeUm arquivo de texto chamado subir-tudo.sh com quarenta linhas e três bugs, um arquivo YAML que diz a mesma coisa em vinte, e um único comando que cria a rede, o volume e os containers na ordem certa.
29
Build, redes e volumes no ComposeUma imagem que o Compose constrói sozinho quando o código muda, uma rede frente e uma rede dados escritas em seis linhas, e um volume de trezentas e doze reservas que já existia antes do projeto e não pode ser apagado por ele.
30
Variáveis e arquivos .envUma senha escrita duas vezes no mesmo arquivo, um .env que o Compose lê e o container não vê, um env_file que o container vê e o Compose não lê, e o comando que mostra o arquivo depois que todas as variáveis foram trocadas.
31
Dependências e health checksUma API que sobe meio segundo antes do banco aceitar conexões e morre por isso, um depends_on que garante a ordem e não garante nada mais, e um container que diz não só que está rodando, mas que está pronto.
32
Profiles, ambientes e escalaUm painel de banco de dados que só deveria existir no notebook e foi parar no servidor, dois arquivos que se somam num terceiro que ninguém escreveu, e três APIs que dividem o trabalho sem que nenhuma saiba das outras.
33
Tarefas, logs e atualizaçõesUm script de importação que precisa do ambiente exato da API e de nenhum container a mais, um restart que não aplica a mudança que alguém acabou de fazer, e a pasta do servidor que não tem uma linha de código.

parte 07 Aplicações de verdadeA API em FastAPI, o check-in em Node.js, o site antigo em PHP, o emissor fiscal em Java, PostgreSQL, Redis, testes e migrations. 6 cap.

34
A API em FastAPIUma API que lê a configuração do ambiente e se recusa a subir sem ela, um health check que pergunta ao banco em vez de responder ok para si mesma, quatro workers que comem a memória de um servidor de dois gigas, e a imagem final da API, linha por linha.
35
Node.js e PHPO leitor de QR code da portaria, que o porteiro do teatro chama de 'o programinha', e o site antigo de 2014, que ninguém tem coragem de abrir — dois Dockerfiles, dois gerenciadores de pacotes e o mesmo erro de sinal que volta com outra roupa.
36
Java e Spring BootO emissor de notas fiscais que a contabilidade encomendou em 2021, que num sábado de 2025 comeu toda a memória do SRV01, e uma JVM que, dentro de um container, finalmente sabe quanto de memória tem.
37
PostgreSQL e RedisDois compradores que clicam no mesmo assento no mesmo segundo, um cache que segura a cadeira por dez minutos e esquece sozinho, e um banco que recusa a conexão número cento e um.
38
Hot reload e testesUm arquivo salvo no editor que aparece no container antes de a mão sair do teclado, um banco de testes que mora na memória e some no fim, e um teste que passa no Mac do estagiário e falha no notebook da Lívia — até os dois rodarem no mesmo container.
39
MigrationsUma coluna meia_entrada que precisa aparecer em três bancos sem ninguém digitar ALTER TABLE à mão, três réplicas da API que tentam criá-la ao mesmo tempo, e a ordem certa para mudar um banco que está vendendo.

parte 08 Registries e distribuiçãoOnde a imagem mora quando sai da sua máquina, quem pode buscá-la e como saber exatamente qual versão está rodando. 2 cap.

40
Publicar uma imagemUma imagem que sai do notebook e chega ao servidor sem pendrive nem scp, um token com prazo de validade no lugar da senha, e uma API construída num Mac que o servidor se recusa a executar com uma mensagem de quatro palavras.
41
Versões, promoção e errosA mesma imagem que passou no teste promovida para a produção sem ser construída de novo, uma tag que ninguém deveria mover e alguém moveu, e a lista das seis mensagens que um registry dá quando diz não.

parte 09 CI/CDO push que testa, constrói, publica e entrega — e o botão que volta para a versão de ontem. 2 cap.

42
GitHub ActionsUm push na sexta à noite que roda os testes antes de qualquer pessoa ver, um teste vermelho que impede a imagem de ser publicada, e um cache de construção que mora no próprio GitHub e derruba um build de seis minutos para quarenta segundos.
43
Deploy e rollbackUma tag do Git que vira uma imagem, um botão de aprovação que a Paula aperta, um script no servidor que troca a versão e confere se ela ficou de pé, e o caminho de volta para a versão de ontem em menos de um minuto.

parte 10 ProduçãoUma VPS, um domínio, HTTPS, segredos, limites, logs, métricas e o plano para quando o servidor acordar de mau humor. 5 cap.

44
A VPSUm servidor de cento e dezenove reais por mês em São Paulo, a senha de root que nunca deveria ter existido, um firewall que o Docker atravessa, e um domínio que leva onze minutos para apontar para o lugar certo.
45
Caddy e HTTPSUm único container que recebe a internet toda e decide para onde cada pedido vai, um certificado que se pede, se renova e se guarda sozinho, e um volume que, se for apagado, deixa a Serra Ingressos sem certificado por uma semana.
46
Segredos, saúde e limitesUma pasta de segredos que só o usuário deploy consegue ler, uma API doente que o Docker deixa doente para sempre, e a conta de memória de nove containers num servidor de oito gigas, feita antes do dia da venda e não durante.
47
ObservarNove gigabytes de log de uma API em modo debug esquecida por três semanas, um vigia do lado de fora que pergunta ao site a cada minuto se ele está vivo, e três gráficos que respondem, no dia da venda, se o problema é a API, o banco ou a máquina.
48
Atualizar e sobreviverUma versão nova que entra enquanto a antiga ainda atende, um backup que sai da VPS toda madrugada para um lugar que não pega fogo junto, uma VPS que morre e renasce noutra em quarenta minutos, e a lista que a Lívia colou na parede.

parte 11 SegurançaO container não é uma cela. Privilégios, root, capabilities, o que vem dentro da imagem e de onde ela veio. 2 cap.

49
O container não é uma celaO post-it com a senha de root do SRV01, um painel antigo que dava o socket do Docker a quem abrisse a porta 9000, um container que lê o arquivo de senhas do host com um cat, e as cinco linhas que tiram da API os poderes que ela nunca usou.
50
O que vem dentro da imagemCento e vinte e três vulnerabilidades conhecidas numa imagem que ninguém escreveu, uma senha encontrada por um scanner numa camada de três semanas atrás, e a lista de tudo que entrou na imagem da API, assinada por quem a construiu.

parte 12 DiagnósticoO container que morre ao nascer, a porta ocupada, o DNS que não resolve, o build lento e o registry que diz não. 3 cap.

51
O container que não fica de péSete casos tirados do caderno da Lívia entre janeiro e fevereiro: o container que termina antes de começar, o que reinicia em laço, o que não acha o próprio programa, e o que não sobe porque outro já está na porta.
52
Rede, arquivos e recursosMais oito páginas do caderno: um nome que resolve no host e não no container, uma VPN que deixa o ping passar e trava o HTTPS, uma pasta que o container lê mas não escreve, e um servidor lento por causa de um container que ninguém lembrava que existia.
53
Builds, registries e ComposeAs últimas páginas do caderno: um build de quatro minutos que devia levar quatro segundos, um git clone que o cache guardou para sempre, um servidor que esquece a senha do registry a cada reinício, e as mensagens do Compose que parecem dizer outra coisa.

parte 13 O projeto completoTudo junto, do clone ao HTTPS, um ensaio de falha com cronômetro e a segunda-feira, 1º de março de 2027, às 10h. 4 cap.

54
O ambiente completoSete serviços, três redes, quatro volumes e um repositório que se transforma no sistema completo da Serra Ingressos em quatro minutos e dez segundos, num notebook que nunca tinha visto o projeto.
55
Do push ao HTTPSUma correção de cinco linhas no cálculo da meia-entrada, acompanhada do commit do Gabriel até o navegador de um comprador em Caxias do Sul, com cada parada cronometrada, assinada e conferida.
56
O ensaio de falhaSexta, 26 de fevereiro, 22h: seis mil compradores de mentira, uma réplica morta de propósito, um banco desligado por um minuto, um emissor de notas estrangulado até cair — e a descoberta de que a venda toda dependia da prefeitura de Canela responder rápido.
57
Primeiro de marçoSegunda-feira, 10h00. Seis mil pessoas na fila, uma prefeitura que demora quarenta segundos para responder, um comprador que segura três mil e oitocentos assentos de uma vez, um deploy de configuração no meio da venda, e um computador bege que finalmente é desligado.