Tutorial de instalação do Docker

Instalação do Docker + primeiro container (FastQC)

Fala, galera! Bora colocar o Docker pra rodar no WSL?
Quem nunca sofreu com o famoso "na minha máquina funciona"? Pois é... containers resolvem isso com isolamento Cada app roda em um ambiente fechado, sem atrapalhar o restante do sistema. , reprodutibilidade Você consegue recriar exatamente o mesmo ambiente em qualquer lugar. e portabilidade O mesmo container roda no seu notebook, em servidores ou na nuvem sem ajustes. . No fim das contas, o Docker é como uma caixa fechada onde você coloca seu software e garante que vai rodar sempre do mesmo jeito.

Neste guia, você vai:

• Entender o que é um container;
• Criar seu primeiro container usando o FastQC como exemplo.

Imagina um porto: cada navio carrega containers fechados com tudo o que precisam dentro. O Docker funciona assim: você empacota o software em um container e ele chega intacto em qualquer lugar.

Quer aprender mais sobre Docker acesse o meu medium para aprender mais?

O que é o Docker?

O Docker é como um sistema de containers Caixas padronizadas que carregam aplicativos e todas as suas dependências. que transporta seu software sem dor de cabeça.

• Você usa uma imagem Pacote pronto: mini sistema + dependências + programa. É um molde que não muda e serve para criar containers iguais. : um molde pronto com sistema, bibliotecas e programa configurados.
• Quando a imagem “zarpa”, ela vira um container: um navio ativo navegando isolado do resto do sistema.
• É possível rodar vários containers Cada um tem seus próprios processos e arquivos. Podem usar a mesma imagem sem “brigar” entre si. ao mesmo tempo, como uma frota organizada, sem conflitos.
• O mesmo container pode “atracar” em qualquer porto A mesma imagem roda do mesmo jeito em notebook, WSL, servidor ou nuvem, desde que tenha Docker instalado. : seu notebook, WSL, servidor ou nuvem.
• Resultado: softwares reprodutíveis Mesma versão do app e das dependências, sempre. , portáteis Você “puxa” a imagem (ex.: Docker Hub) e roda em outra máquina. e fáceis de compartilhar Publique com uma tag de versão e qualquer pessoa obtém igualzinho. .

Passo a passo

1. Instalando o Docker
2. Seu primeiro container (FastQC)
3. Criando sua própria imagem

1. Instalando o Docker

Para usar o Docker, você precisa do engine Serviço que cria e executa containers. É o “motor” do Docker. rodando no sistema. No WSL/Ubuntu a instalação é direta.

Se você já tem o Docker, pode pular a instalação. Verifique com:

docker --version

Dica: recomendo Ubuntu 20.04 LTS ou superior (idealmente 22.04 LTS). Confira sua versão com:

lsb_release -a

1.1 Instalando o Docker (WSL/Ubuntu)

sudo apt update
sudo apt install -y docker.io

Verifique se o serviço está ativo:

sudo systemctl status docker

Saída esperada (algo como):

WSL e systemctl: se esse comando não funcionar, tente:
sudo service docker status. Em algumas instalações do WSL é preciso habilitar o systemd em /etc/wsl.conf e reiniciar o WSL (wsl.exe --shutdown).

Saída esperada (algo como):

1.2 Pós-instalação e teste

Permita usar o Docker sem sudo:

sudo usermod -aG docker $USER
newgrp docker

Grupo docker: o newgrp docker aplica a permissão na sessão atual. Para persistir, feche e reabra o terminal (ou rode wsl.exe --shutdown e abra o WSL de novo).

Teste a instalação:

docker --version

Saída esperada (algo como):

Docker version 24.0.x, build XXXXXXX

Teste rápido do engine:

docker run --rm hello-world

Se aparecer a mensagem de boas-vindas, o engine está OK.

Quero a versão oficial mais recente:
curl -fsSL https://get.docker.com | sh
(instala a versão estável diretamente da Docker)

Segurança: curl | sh executa um script da internet. Use apenas se confiar na fonte; quando possível, prefira os pacotes do Ubuntu.

2. Seu primeiro container (FastQC)

Agora que o Docker está instalado, é hora de colocar um container para navegar. Vamos usar o FastQC Ferramenta popular para checar a qualidade de arquivos FASTQ. como exemplo.

2.1 Baixando a imagem

No Docker, tudo começa com uma imagem Pacote que contém o programa e suas dependências. . Para o FastQC, existe uma imagem no Docker Hub.

Atenção: esse repositório não tem a tag latest Tag padrão que o Docker usa quando nenhuma versão é informada (equivale a :latest). Muitos projetos não publicam latest para forçar que você escolha uma versão específica/estável. , então é preciso especificar a versão.

Uma versão estável muito usada é a v0.11.9_cv8. Para baixar:

docker pull biocontainers/fastqc:v0.11.9_cv8

Esta era a versão estável no momento da escrita. Verifique se há versões mais novas no Docker Hub antes de baixar.

2.2 Rodando o container

Preparando o ambiente de trabalho:

Crie uma pasta para o workflow e um diretório de dados:

mkdir -p ~/docker_tutorial/data
cd ~/docker_tutorial

Baixe os FASTQs com o SRA-Tools (exemplo com o SRR34840432).
Se você já tem seus .fastq.gz, basta colocá-los em ~/docker_tutorial/data.

Exemplo com dois arquivos FASTQ (R1 e R2):

mkdir -p results && \
  docker run --rm \
  -u "$(id -u)":"$(id -g)" \
  -v "$(pwd)":/data:rw -w /data \
  biocontainers/fastqc:v0.11.9_cv8 \
  fastqc -o results -t "$(nproc)" data/SRR34840432_1.fastq.gz data/SRR34840432_2.fastq.gz

Processar tudo de uma vez:

mkdir -p results && \
  docker run --rm -u "$(id -u)":"$(id -g)" -v "$(pwd)":/data -w /data \
  biocontainers/fastqc:v0.11.9_cv8 \
  fastqc -o results -t "$(nproc)" data/*.fastq.gz

2.3 Conferindo os resultados

Para cada arquivo analisado, o FastQC gera:

• Um relatório .html com gráficos de qualidade;
• Um arquivo .zip com dados detalhados.

Com -o results, os relatórios do FastQC são salvos em ./results no host (garantido pelo mapeamento -v "$(pwd)":/data, que expõe ao container a pasta do projeto com os arquivos *.fastq.gz (ex.: ./data/*.fastq.gz) em /data, e pelo -w /data, que permite usar caminhos relativos e salvar em results/.)

A sua saída deve ser parecida com essa:

Metáfora rápida (versão estendida): pense no container como um navio; o -v é o porão abrindo uma escotilha entre o cais (seu host) e o navio (container).

3. Criando sua própria imagem (FastQC)

Até agora usamos a imagem pronta do Docker Hub. Mas e se você quiser montar sua própria imagem com o FastQC instalado? Isso é útil quando você precisa de versões específicas ou combinar várias ferramentas no mesmo container.

3.1 Preparando a pasta de trabalho

mkdir -p ~/docker_tutorial/fastqc_custom
cd ~/docker_tutorial/fastqc_custom

Essa será a pasta onde vamos salvar o Dockerfile e construir a nova imagem.

3.2 Criando o Dockerfile

Use o nano para criar o arquivo:

nano Dockerfile

Cole o conteúdo abaixo (imagem base enxuta, locale definido, JRE headless e FastQC):

# syntax=docker/dockerfile:1
FROM ubuntu:22.04

ENV DEBIAN_FRONTEND=noninteractive \
    LC_ALL=C.UTF-8 \
    LANG=C.UTF-8

# Instala FastQC e dependências essenciais (Java headless + certificados) e limpa caches
RUN apt-get update && \
    apt-get install -y --no-install-recommends fastqc default-jre-headless ca-certificates && \
    rm -rf /var/lib/apt/lists/*

# Diretório de trabalho padrão para I/O
WORKDIR /data

# Executável padrão: permite "docker run minha_img --help"
ENTRYPOINT ["fastqc"]
# Argumento padrão (pode ser sobrescrito): mostra ajuda se rodar sem nada
CMD ["--help"]

No nano:
– Ctrl + O → salva Enter
– Ctrl + X → sai

3.3 Construindo a imagem

Construa e dê uma tag explícita (boa prática):

docker build -t meu_fastqc:0.11.9 .

• -t meu_fastqc:0.11.9: nome e versão da sua imagem.
• .: usa o diretório atual como contexto (onde está o Dockerfile).

Teste rápido:

docker run --rm meu_fastqc:0.11.9 --version

3.4 Rodando sua imagem personalizada

Baixe seus FASTQs (R1/R2). Caso não saiba, veja este tutorial para obter os arquivos.

mkdir -p results && \
docker run --rm \
  -u "$(id -u)":"$(id -g)" \
  -v "$(pwd)":/data:rw -w /data \
  meu_fastqc:0.11.9 \
  -o results -t "$(nproc)" \
  data/SRR34840432_1.fastq.gz data/SRR34840432_2.fastq.gz

Processar todos os FASTQs da pasta:

mkdir -p results && \
docker run --rm \
  -u "$(id -u)":"$(id -g)" \
  -v "$(pwd)":/data:rw -w /data \
  meu_fastqc:0.11.9 \
  -o results -t "$(nproc)" \
  data/*.fastq.gz

3.5 Otimizando o build: .dockerignore e build context

Quando você executa docker build <contexto>, o último argumento é a pasta de contexto. Em docker build ., o ponto significa “use a pasta atual como contexto”. O cliente Docker empacota (faz um tar) de tudo que está no contexto não ignorado e envia para o daemonServiço dockerd que constrói imagens e executa containers. fazer o buildProcesso de criar a imagem a partir do Dockerfile; cada instrução gera/reutiliza camadas (cache)..

Por que isso importa?
Se o contexto tiver FASTQs/relatórios grandes, o envio (“Sending build context...”) fica lento e qualquer mudança nesses arquivos pode invalidar o cacheReuso de camadas já construídas quando nada relevante mudou. de etapas como COPY. O .dockerignore filtra o que entra no contexto, deixando o build mais rápido e previsível.

Por que evitar dados no build?
• Imagens maiores e lentas de distribuir.
• Cache instável (dados mutáveis quebram camadas).
• Layers imutáveis: deletar no Dockerfile não “tira” o peso.
• Risco de comportamento inesperado (configs/artefatos indevidos).
• Exposição de dados sensíveis.

Padrão recomendado:
• Use .dockerignore e evite COPY . ..
• Copie só o que é necessário para executar a ferramenta.
• Monte dados em runtime com -v (bind mount).
• Se precisar processar no build, use multi-stage e não leve dados ao estágio final.

Regra de ouro: o .dockerignore fica na mesma pasta do contexto do build. Se você roda docker build . em ~/docker_tutorial/fastqc_custom, é lá que o .dockerignore deve existir.

3.5.1 Crie um .dockerignore mínimo

Abra o arquivo na mesma pasta do seu Dockerfile e cole o conteúdo abaixo:

nano .dockerignore

Por que usar .dockerignore?
Ele reduz o tamanho do build context Tudo que está na pasta usada como contexto (geralmente .) e que é enviado ao Docker para construir a imagem. deixando os builds Processo de construir uma imagem a partir do Dockerfile, gerando camadas reutilizáveis. mais rápidos mantém o cache Camadas (layers) já construídas que o Docker reaproveita se nada relevante mudou. previsível e evita enviar dados pesados/sensíveis para o daemon O serviço em segundo plano do Docker (dockerd) que executa builds, containers, redes e volumes. durante o build.

# .dockerignore — recomendado para este tutorial
data/
results/

*.fastq
*.fastq.gz
*.sra
*.zip
*.html

No nano: Ctrl+O para salvar, Enter para confirmar, depois Ctrl+X para sair.

3.5.2 Boas práticas rápidas

• Mantenha o contexto enxuto: deixe apenas o que será COPY junto do Dockerfile; dados ficam fora.
• Prefira montar dados no docker run com -v em vez de copiá-los para a imagem.
• Use tags explícitas nas imagens (meu_fastqc:0.11.9) para builds reproduzíveis.
• Se o Dockerfile estiver em uma subpasta, combine -f com um contexto mínimo:
  docker build -t meu_fastqc:0.11.9 -f fastqc_custom/Dockerfile fastqc_custom/

WSL/Docker Desktop: reduzir o contexto diminui muito o tempo naquele passo “Sending build context to Docker daemon…”. Em pastas com FASTQs, a transferência pode chegar a vários GB — o .dockerignore elimina esse overhead.

Pronto! Agora o comando está rodando com a sua própria imagem em vez de rodar em BioContainers.

Você pode personalizar ainda mais o Dockerfile, adicionando outras ferramentas (ex.: Trimmomatic, MultiQC) e criando um container “tudo em um” para seu pipeline.

3.6 Conferindo a imagem criada

Depois de construir a sua imagem, você pode verificar se ela foi salva no Docker local:

docker images

Saída esperada (exemplo):

REPOSITORY    TAG       IMAGE ID       CREATED          SIZE
meu_fastqc    0.11.9    123abc456def   2 minutes ago    350MB

• REPOSITORY: nome da imagem (no nosso caso, meu_fastqc).
• TAG: versão atribuída (ex.: 0.11.9).
• IMAGE ID: identificador único da imagem.
• CREATED: quando foi construída.
• SIZE: tamanho final da imagem.

Se quiser ver detalhes completos (camadas, variáveis de ambiente, comandos padrão), use:

docker inspect meu_fastqc:0.11.9

Dica: para remover e começar de novo: docker rmi meu_fastqc:0.11.9

Como ver (listar) suas imagens

docker image ls

Filtros úteis:
docker image ls meu_fastqc
docker image ls --filter "reference=meu_fastqc:0.11.9"
docker image ls -a (inclui camadas intermediárias)
docker image ls --digests (mostra o digest)

Apenas “dangling” (<none>:<none>):
docker image ls --filter dangling=true

Espaço em disco:
docker system df

Como remover imagens

Remover uma imagem específica (por nome:tag):

docker image rm meu_fastqc:0.11.9

Remover por ID (copie da coluna IMAGE ID):

docker image rm 123abc456def

Remover imagens “soltas” (dangling):

docker image prune -f

Remover todas as imagens não utilizadas por nenhum container:

docker image prune -a -f

Remover imagens antigas com filtro de tempo:
docker image prune -a -f --filter "until=72h"

Cuidado: prune -a remove qualquer imagem que não esteja em uso por um container (inclusive as que você baixou mas não está usando agora).

Remover todas as imagens (força bruta):

docker image rm $(docker image ls -q)

Conclusão

Fácil, né? Agora você já sabe como instalar o Docker, puxar uma imagem e rodar seu primeiro container. Voltando à metáfora do porto: você aprendeu a receber navios (imagens), descarregar containers (rodar programas) e acessar a carga (seus arquivos e resultados).

• Isolamento: cada app no seu próprio container.
• Portabilidade: roda no notebook, servidor ou nuvem.
• Reprodutibilidade: qualquer pessoa pode repetir a análise.

O próximo passo é explorar outras imagens do Docker Hub ou até criar sua própria imagem personalizada para pipelines bioinformáticos.

Dica: Combine Docker com workflows (como Nextflow ou Snakemake). Assim, cada etapa roda em seu próprio container, garantindo reprodutibilidade total.

Missão cumprida, capitão! 🛳️⚓

Se curtiu, dá aquele apoio no LinkedIn e considere um cafézinho ☕ para manter o projeto vivo. Valeu!

Pix: biologolee@gmail.com
Bitcoin: bc1qg7qrfhclzt3sm60en53qv8fmwpuacfaxt5v55k

Referências

1. Documentação oficial do Docker
2. Docker Hub