IFCE Horizonte · Portal
ADS23 · Sistemas Operacionais

Mão na massa · ~55 min

De usuário de imagens prontas a autor da sua própria

Hoje você usa o Docker de verdade: baixa uma imagem pronta do Docker Hub, sobe um container a partir dela, e depois escreve seu próprio Dockerfile e constrói sua primeira imagem do zero.

Parte 1 · Imagens prontasParte 2 · Sua primeira imagem
Parte 1 · Imagens prontas

Passo 1 de 8

Confirmando que o Docker está de pé

Antes de qualquer coisa, vamos confirmar que o Docker instalado na Semana 0 continua funcionando.
1docker --version e docker ps

O que é

docker --version confirma que o Docker está instalado. docker ps lista containers rodando agora (deve vir vazio).

Por que importa

Confirma o ambiente antes de você depender dele nos próximos passos — barato de checar, caro de descobrir travado no meio da prática.

$ docker --version
Docker version 26.1.0, build 8cbe042
$ docker ps
CONTAINER ID   IMAGE   COMMAND   CREATED   STATUS   PORTS   NAMES
O que esperar:

a tabela do docker ps vem só com cabeçalho, sem linhas — normal, significa que nenhum container está rodando agora.

Comando não encontrado ou "permission denied"

Confirme a instalação da Semana 0. Se der "permission denied", tente sudo docker ps — seu usuário pode não estar no grupo docker ainda.

Passo 2 de 8

Baixando uma imagem sem rodar nada

docker pull só baixa a imagem do Docker Hub pro seu computador — não sobe container nenhum ainda.
2docker pull alpine

O que é

Baixa a imagem alpine (um Linux mínimo, ~5 MB) do registro público Docker Hub.

Por que importa

Separar "baixar" de "rodar" deixa claro que imagem e container são coisas diferentes — a confusão mais comum de quem está começando.

$ docker pull alpine
latest: Pulling from library/alpine
Digest: sha256:a8560b36e8b8210634f77d9f7f9efd7ffa4…
Status: Downloaded newer image for alpine:latest
O que esperar:

algumas linhas de download e a mensagem final "Downloaded newer image". Se você já tiver baixado essa imagem antes (no Encontro 3), pode aparecer "Image is up to date" em vez disso — tudo bem, significa que já está lá.

Passo 3 de 8

Vendo o que já está baixado

Toda imagem baixada ou construída fica guardada localmente até você apagar.
3docker images

O que é

Lista todas as imagens que existem no seu computador agora — baixadas ou construídas por você.

Por que importa

É o "estoque" de receitas prontas pra usar. Antes de rodar um docker run, vale saber o que já existe.

$ docker images
REPOSITORY   TAG       IMAGE ID       CREATED       SIZE
alpine       latest    b0c9d4f2abcd   3 weeks ago   7.8MB
O que esperar:

pelo menos a linha do alpine. O tamanho (coluna SIZE) costuma ser minúsculo comparado a uma VM inteira — vale reparar nisso.

Passo 4 de 8

Subindo seu primeiro container desta imagem

Agora sim: um container de verdade, nascendo da imagem que você acabou de baixar.
4docker run alpine echo "primeiro container"

O que é

docker run cria e inicia um container a partir da imagem alpine, executando o comando echo dentro dele.

Por que importa

É a diferença entre imagem (a receita, parada) e container (a receita em execução, viva por alguns instantes).

$ docker run alpine echo "primeiro container"
primeiro container
O que esperar:

a palavra que você mandou o echo imprimir, e o comando volta pro seu prompt normal — o container fez o trabalho dele e encerrou.

Passo 5 de 8

O container que "sumiu" ainda existe (parado)

Um container que terminou não desaparece — ele fica registrado como parado, até você removê-lo.
5docker ps -a

O que é

A flag -a ("all") mostra todos os containers, incluindo os que já terminaram — não só os que estão rodando agora.

Por que importa

Explica por que docker ps (sem -a) pode vir vazio mesmo depois de você ter acabado de rodar um container.

$ docker ps -a
CONTAINER ID   IMAGE     COMMAND                  STATUS                     NAMES
7f3a1c9e2b04   alpine    "echo 'primeiro cont…"   Exited (0) 10 seconds ago  festive_hopper
O que esperar:

uma linha com STATUS "Exited (0)" — o container rodou, terminou com sucesso (código 0), e continua existindo, só que parado.

Quero apagar esse container parado

Use docker rm <CONTAINER ID> (os primeiros caracteres já bastam). Não precisa fazer isso agora — é só pra saber que existe.

qual a diferença entre uma imagem (passo 3) e um container (passo 4/5)? Use suas próprias palavras.

0 / 40 caracteres

Parte 2 · Sua primeira imagem

Passo 6 de 8

Escrevendo seu próprio Dockerfile

Chegou a hora de vocês escreverem a receita, não só usarem as prontas. Crie uma pasta nova (ex: mkdir ~/minha-imagem && cd ~/minha-imagem) e dois arquivos dentro dela.
6Criar ola.sh e Dockerfile

O que é

Um script de 2 linhas (ola.sh) e uma receita de 4 linhas (Dockerfile) que empacota esse script numa imagem.

Por que importa

É o primeiro passo pra construir imagens sob medida — o que separa "usar Docker" de "usar Docker de verdade no trabalho".

ola.sh

#!/bin/sh
echo "Ola do meu primeiro container!"

Dockerfile

# imagem-base
FROM alpine:3.20
# copia seu script pra dentro da imagem
COPY ola.sh /ola.sh
# dá permissão de execução (acontece 1x, na construção)
RUN chmod +x /ola.sh
# roda toda vez que um container nascer daqui
CMD ["/ola.sh"]
Atenção: no Dockerfile, comentário só vale em linha própria, começando com #. Escrito no fim de uma instrução, o # vira parte dela e o docker build falha.
O que esperar:

você pode criar os arquivos com nano ola.sh e nano Dockerfile (ou o editor de sua preferência) e colar o conteúdo acima exatamente. Os dois arquivos precisam estar na mesma pasta.

Diferença entre RUN e CMD ainda não ficou clara

RUN acontece uma vez, no momento em que a imagem é construída (docker build) — como cozinhar um prato antes de guardar na geladeira. CMD acontece toda vez que um container novo nasce dessa imagem (docker run) — como esquentar e servir o prato guardado.

Passo 7 de 8

Construindo sua imagem

Com os dois arquivos prontos na mesma pasta, é hora de transformar a receita numa imagem de verdade.
7docker build -t meu-ola .

O que é

docker build lê o Dockerfile da pasta atual (o . no final) e monta a imagem, executando cada instrução na ordem. -t meu-ola dá um nome (tag) pra ela.

Por que importa

É o momento em que sua receita escrita vira um artefato de verdade, guardado e reutilizável — igual às imagens prontas que vocês baixaram na Parte 1.

$ docker build -t meu-ola .
[+] Building 1.2s (8/8) FINISHED
=> [1/3] FROM docker.io/library/alpine:3.20
=> [2/3] COPY ola.sh /ola.sh
=> [3/3] RUN chmod +x /ola.sh
Successfully tagged meu-ola:latest
O que esperar:

uma lista curta de passos ([1/3], [2/3]...) e a mensagem final "Successfully tagged". Rode docker images de novo depois — agora meu-ola deve aparecer na lista, ao lado do alpine.

Erro dizendo que não encontrou o Dockerfile

Confirme que você está dentro da pasta certa (pwd pra checar) e que o arquivo se chama exatamente Dockerfile, sem extensão, com D maiúsculo.

Passo 8 de 8

Rodando um container da sua própria imagem

O momento da verdade: um container nascendo de uma imagem que você mesmo escreveu.
8docker run meu-ola

O que é

Sobe um container a partir da imagem meu-ola — sem precisar dizer o que rodar, porque o CMD do Dockerfile já define isso.

Por que importa

Fecha o ciclo completo: escrever a receita → construir a imagem → rodar o container, exatamente como qualquer imagem do Docker Hub que vocês já usaram.

$ docker run meu-ola
Ola do meu primeiro container!
O que esperar:

a mensagem do seu ola.sh, impressa por um container criado a partir de uma imagem 100% escrita por vocês.

o que aconteceu quando você rodou docker build? Conecte com a diferença entre RUN e CMD no Dockerfile.

0 / 40 caracteres

livre: algo que te surpreendeu ou uma dúvida que sobrou de hoje

0 / 40 caracteres

Exemplo de observação forte × fraca

Observação fraca

"Consegui construir a imagem e rodar o container."

Observação forte

"O RUN chmod só apareceu nos logs do docker build, uma vez — mas quando rodei docker run três vezes, o CMD (o echo) executou nas três, provando que RUN é construção e CMD é execução."

Checklist final

  • Confirmei o Docker funcionando com docker --version e docker ps
  • Rodei docker pull alpine e vi a imagem em docker images
  • Subi um container com docker run alpine echo ... e o vi parado em docker ps -a
  • Escrevi meu próprio Dockerfile e construí com docker build
  • Rodei um container da minha própria imagem com docker run meu-ola
  • Preenchi as 3 observações acima (vou colar no quiz semanal)
0 / 6 verificados