Docker - Usando contêineres para criar ambientes reproduzíveis

SECOMP 2025

Brenno Lemos

• Syndelis
• @brenno@fosstodon.org

0. Sobre mim

Antes de começarmos

Cheque se sua máquina está com Docker instalado e com as permissões corretas

$ docker run --rm hello-world

1.1. Pra que serve o Docker?

Docker possui inúmeras aplicações. Aqui estão algumas que abordaremos neste minicurso:

• Rodar programas sem a necessidade de instalá-los na máquina;
• Compilar programas para outros sistemas operacionais;
• Executar serviços como webservers e bancos de dados;
• Rodar pipelines em ambientes externos como GitHub Actions;

2.2. Usando qualquer versão de Python

Muitos programas e ferramentas famosas estão disponíveis em formato de imagens no Docker Hub.

Por exemplo, é possível usar a versão mais recente de Python para rodar um script:

docker run --rm -v ./:/tmp python:3.13 python3 /tmp/hello_world.py

Isto pode ser útil quando a versão desejada do interpretador não estiver disponível na máquina. Por exemplo, Ubuntu 22.04 e derivados possuem Python 3.10 instalado, mas a versão 3.13 já foi lançada.

2.2.1. E as dependências?

Poderíamos escrever um shell script para instalar uma biblioteca e depois executar o nosso script.

#!/usr/bin/env bash
pip3 install numpy
python3 mult_array.py

import numpy as np
x = np.array([1, 2, 3, 4])
print(x * 3)

docker run --rm -v ./:/tmp -w /tmp python:3.13 bash mult_array.sh

Contudo, há um problema: sempre que executamos o contêiner, a dependência tem que ser baixada novamente. Veremos no próximo capítulo como podemos construir novas imagens de Docker para evitar isso.

3.1. Criando sua primeira imagem

FROM debian
RUN apt-get update && apt-get install -y gcc
COPY main.c main.c
RUN gcc main.c -o main
ENTRYPOINT ["./main"]

<-- Camada base
<-- Instale GCC
<-- Copie o programa local para o contêiner
<-- Compile o programa
<-- Rode o programa

$ docker build . -t minha_imagem -f Dockerfile

$ docker run --rm minha_imagem

3.2.1. Overlay FS

3.3. Reparação histórica: criando nossa imagem de Python

FROM python:3.13-alpine
RUN pip install numpy
WORKDIR /app
COPY mult_array.py .
ENTRYPOINT ["python3", "mult_array.py"]

$ docker build . -t python_mult_array -f Dockerfile

$ docker run --rm python_mult_array

Nesta imagem, o NumPy será instalado durante o comando docker build. Portanto, não será necessário reinstalá-lo cada vez que executarmos a imagem com docker run

4.1. Caso de uso: execução de um servidor web com banco de dados

class User(SQLModel, table=True):
    id: int | None = Field(default=None, primary_key=True)
    name: str
    age: int

engine = db_connect()
def get_db():
    with Session(engine) as session:
        yield session

Db = Annotated[Session, Depends(get_db)]
api = FastAPI()

@api.get("/user")
def list_users(db: Db):
    return db.exec(select(User)).all()

5.1. Escrevendo workflows para o GitHub

name: Hello World
on:
  push:
    branches:
      - main
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Say hello world
        shell: bash
        run: echo Hello, World!

5.2. Workflows para a compilação de código

name: Compile and Run
on:
  push:
    branches:
      - main
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      # roda uma ação pré-definida encontrada em
      # https://github.com/actions/checkout
      - name: Checkout Repository
        uses: actions/checkout@v4
      - name: Compile code
        shell: bash
        run: gcc main.c -o main
      - name: Run it
        shell: bash
        run: ./main

5.4. Extra: publicando suas próprias imagens

- name: Log in to the Container registry
  uses: docker/login-action@v2
  with:
    registry: ghcr.io
    username: ${{ github.actor }}
    password: ${{ secrets.GITHUB_TOKEN }}

- name: Define Image Tag
  id: image-tag
  shell: bash
  env:
    USER_AND_REPO: ${{ github.repository }}
  run: echo "tag=ghcr.io/${USER_AND_REPO,,}:latest" >> "$GITHUB_OUTPUT"

- name: Build and Publish Image
  uses: docker/build-push-action@v5
  with:
    push: true
    tags: ${{ steps.image-tag.outputs.tag }}

Cada um possuirá diferentes métodos para a autenticação, mas a ação de publicar uma imagem em qualquer caso está relacionada ao comando docker push.

O exemplo deste slide contém um trecho que poderia ser utilizado para publicar uma nova imagem no GHCR.