A mostrar o Markdown sem formatação: não foi possível carregar o visualizador.
## Objetivo
Construir uma pequena imagem de contentor a partir de um `Containerfile` com uma imagem de base fixada e inspecionar as suas camadas. Depois, executá-la e observar o contentor a partir do anfitrião: os seus processos, os seus namespaces e o seu cgroup. Por fim, definir limites de CPU e memória, lê-los nos ficheiros do cgroup e provocar de propósito uma terminação por falta de memória (OOM, out-of-memory) para a poder diagnosticar.
## Objetivos
- Construir uma imagem a partir de um `Containerfile` com uma imagem de base fixada e explicar as suas camadas (objetivo 4).
- Demonstrar que um contentor é um processo normal do anfitrião nos seus próprios namespaces: comparar nome de anfitrião, lista de processos e IDs de namespace dentro e fora (objetivo 3).
- Definir limites `--cpus` e `--memory` e lê-los como `cpu.max` e `memory.max` nos ficheiros de cgroup v2 (objetivos 3 e 5).
- Provocar uma terminação por OOM e diagnosticá-la com `OOMKilled`, o código de saída 137 e o registo do kernel (objetivo 5).
## Pré-requisitos
- Uma máquina Linux, ou uma VM Linux, com Podman 4 ou posterior (testado com Podman 5.8.7, sem root, cgroups v2, `crun`, sem `sudo`). O Docker serve com pequenas alterações: consulte a NOTA mais abaixo.
- Uma shell de utilizador (não `root`). Tudo neste laboratório se executa sem `sudo`.
- Acesso à Internet para descarregar a imagem de base `docker.io/library/alpine:3.20.10` (cerca de 8 MB) e para descarregar um pacote pequeno (`procps-ng`) durante a construção.
- Cerca de 30 MB de espaço em disco.
- [A lição](lesson.pt.md) deste módulo.
> [!WARNING]
> O laboratório é gratuito e executa apenas contentores que o próprio inicia na sua máquina, como utilizador comum e sem `--privileged`. Todos os contentores se chamam `lab-virt-...`, e os comandos que removem coisas nomeiam-nos explicitamente, pelo que não tocam nos restantes contentores. Um passo faz um contentor usar mais memória do que o seu limite de propósito; só pode prejudicar esse contentor, não a máquina. O laboratório não altera nada no sistema fora de uma pasta (`~/virt-lab`) e de uma imagem local, ambas removidas no fim.
> [!NOTE]
> As saídas abaixo foram capturadas em Linux baseado em Fedora em novembro de 2026. Os IDs, os PID, os números de namespace, as horas e o nome do anfitrião serão diferentes na sua máquina; o que deve comparar é a estrutura e os valores que provêm dos seus comandos (como `67108864`).
>
> **Docker:** substitua `podman` por `docker`; o nome `Containerfile` continua válido (`docker build -f Containerfile` se a sua versão não o encontrar). Duas diferenças: com o Docker por omissão, que corre como root, os processos do contentor pertencem a `root`, pelo que ler `/proc/<pid>/ns` e o registo de OOM pode exigir `sudo`, e `podman top ... hpid huser` não tem equivalente no Docker. Não foi testado com Docker.
## Arquitetura
<figure class="diagram" style="--dg-w: 1100px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1100 560" width="1100" height="560" role="img" aria-labelledby="virt-lab-architecture-pt-title virt-lab-architecture-pt-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pt">
<title id="virt-lab-architecture-pt-title">Arquitetura do laboratório: um Containerfile, uma imagem, três contentores sem root e o kernel do anfitrião</title>
<desc id="virt-lab-architecture-pt-desc">Na sua máquina Linux, com Podman sem root e sem sudo, a pasta ~/virt-lab contém um Containerfile e app.sh. O Podman constrói-os na imagem localhost/lab-virt-hello:1.0, que tem três camadas e ocupa cerca de 9.4 MB. A imagem de base vem de um registo na Internet, docker.io/library/alpine, etiqueta 3.20.10. A imagem executa-se como três contentores cujos nomes começam por lab-virt-: lab-virt-demo, que executa sleep 3600 sem limites; lab-virt-limited, com limite de CPU 0.5 e limite de memória 64 MB; e lab-virt-oom, com um limite de memória de 64 MB que aloca 200 MB e é terminado. Os contentores são isolados e limitados pelo kernel Linux do anfitrião, que inspeciona a partir do anfitrião: /proc/<pid>/ns para os namespaces, /sys/fs/cgroup para memory.max, cpu.max e pids.max, e o registo do kernel para o OOM killer e o código de saída 137.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="1099" height="559" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l1"><rect class="dg-tint" x="20" y="20" width="230" height="160" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g>
<text x="62" y="47" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">Internet</text></g>
<g class="dg-l2"><rect class="dg-tint" x="280" y="20" width="800" height="520" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(296 33) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g>
<text x="322" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">A sua máquina Linux: Podman sem root, sem sudo</text></g>
<g class="dg-l7"><rect class="dg-tint" x="620" y="56" width="440" height="298" rx="16" fill="#f6f2fd" stroke="#c5a9f0" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(636 69) scale(0.7500)" fill="none" stroke="#6d28d9" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g>
<text x="662" y="83" font-size="13" class="dg-ink" fill="#6d28d9" font-weight="700">Contentores (nomes que começam por lab-virt-)</text></g>
<g class="dg-l4"><rect class="dg-tint" x="296" y="400" width="768" height="124" rx="16" fill="#fbf4f0" stroke="#e7b39e" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(312 413) scale(0.7500)" fill="none" stroke="#c2410c" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="2" rx="2"/><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6 6h.01"/><path d="M6 18h.01"/></g>
<text x="338" y="427" font-size="13" class="dg-ink" fill="#c2410c" font-weight="700">Kernel Linux do anfitrião: o que inspeciona</text></g>
<rect class="dg-card" x="34" y="64" width="202" height="100" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(50 80) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><ellipse cx="12" cy="5" rx="9" ry="3"/><path d="M3 5V19A9 3 0 0 0 21 19V5"/><path d="M3 12A9 3 0 0 0 21 12"/></g></g>
<g class="dg-l1"><text x="92" y="101" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">Registo</text></g>
<text x="52" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">alpine:3.20.10</text>
<text x="52" y="152" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">docker.io/library</text>
<rect class="dg-card" x="310" y="64" width="250" height="104" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(326 80) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-l1"><text x="368" y="101" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">Imagem</text></g>
<text x="328" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">localhost/lab-virt-hello:1.0</text>
<text x="328" y="152" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">3 camadas · cerca de 9.4 MB</text>
<rect class="dg-card" x="310" y="240" width="250" height="104" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(326 256) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M10 9H8"/><path d="M16 13H8"/><path d="M16 17H8"/></g>
<text x="368" y="277" font-size="15" class="dg-text" fill="#17171c" font-weight="700">~/virt-lab</text>
<text x="328" y="308" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">Containerfile</text>
<text x="328" y="328" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">app.sh</text>
<rect class="dg-card" x="636" y="92" width="408" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l7"><g class="dg-icon" transform="translate(652 108) scale(1.2500)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-l7"><text x="694" y="129" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">lab-virt-demo</text></g>
<text x="654" y="160" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">sleep 3600 · sem limites</text>
<rect class="dg-card" x="636" y="178" width="408" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l7"><g class="dg-icon" transform="translate(652 194) scale(1.2500)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-l7"><text x="694" y="215" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">lab-virt-limited</text></g>
<text x="654" y="246" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">--cpus 0.5 --memory 64m</text>
<rect class="dg-card" x="636" y="264" width="408" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(652 280) scale(1.2500)" fill="none" stroke="#b91c1c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g></g>
<g class="dg-warn"><text x="694" y="301" font-size="15" class="dg-ink" fill="#b91c1c" font-weight="700">lab-virt-oom</text></g>
<text x="654" y="332" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">--memory 64m · aloca 200 MB</text>
<rect class="dg-card" x="312" y="436" width="230" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(328 452) scale(1.2500)" fill="none" stroke="#c2410c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M8 6h13"/><path d="M8 12h13"/><path d="M8 18h13"/><path d="M3 6h.01"/><path d="M3 12h.01"/><path d="M3 18h.01"/></g></g>
<g class="dg-l4"><text x="370" y="473" font-size="14" class="dg-ink" fill="#c2410c" font-weight="700">/proc/<pid>/ns</text></g>
<text x="330" y="504" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">namespaces vistos do anfitrião</text>
<rect class="dg-card" x="558" y="436" width="230" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(574 452) scale(1.2500)" fill="none" stroke="#c2410c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M8 6h13"/><path d="M8 12h13"/><path d="M8 18h13"/><path d="M3 6h.01"/><path d="M3 12h.01"/><path d="M3 18h.01"/></g></g>
<g class="dg-l4"><text x="616" y="473" font-size="14" class="dg-ink" fill="#c2410c" font-weight="700">/sys/fs/cgroup/…</text></g>
<text x="576" y="504" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">memory.max · cpu.max</text>
<rect class="dg-card" x="804" y="436" width="230" height="76" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(820 452) scale(1.2500)" fill="none" stroke="#b91c1c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"/><path d="M12 9v4"/><path d="M12 17h.01"/></g></g>
<g class="dg-warn"><text x="862" y="473" font-size="14" class="dg-ink" fill="#b91c1c" font-weight="700">Registo do kernel</text></g>
<text x="822" y="504" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">OOM killer: código de saída 137</text>
<g class="dg-l1"><path class="dg-stroke" d="M238 116H300" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M293 110l8 6-8 6" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="247.12" y="104" width="43.76" height="24" rx="12" fill="#ffffff"/><text x="269" y="120.5" font-size="11.5" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle">pull</text></g>
<g class="dg-l1"><path class="dg-stroke" d="M435 238V172" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M429 179l6-8 6 8" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="409.9" y="193" width="50.2" height="24" rx="12" fill="#ffffff"/><text x="435" y="209.5" font-size="11.5" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle">build</text></g>
<g class="dg-l7"><path class="dg-stroke" d="M562 116H610" stroke="#6d28d9" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><path class="dg-stroke" d="M605 110l8 6-8 6" stroke="#6d28d9" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><rect class="dg-bg-plain" x="568.34" y="104" width="37.32" height="24" rx="12" fill="#ffffff"/><text x="587" y="120.5" font-size="11.5" class="dg-ink" fill="#6d28d9" font-weight="600" text-anchor="middle">run</text></g>
<g class="dg-l4"><path class="dg-stroke" d="M840 358V392" stroke="#c2410c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><path class="dg-stroke" d="M834 387l6 8 6-8" stroke="#c2410c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><rect class="dg-bg-plain" x="750.5" y="364" width="179" height="24" rx="12" fill="#ffffff"/><text x="840" y="380.5" font-size="11.5" class="dg-ink" fill="#c2410c" font-weight="600" text-anchor="middle">isolados e limitados pelo</text></g>
</svg></figure>
*Figura 1. Constrói-se uma imagem a partir de uma pasta, executa-se como três contentores e lê-se o que o kernel do anfitrião fez para os isolar e limitar.*
## Passos
### Passo 1 — Verifique as ferramentas e crie uma pasta de trabalho
Primeiro, verifique que tem o Podman, que funciona sem root e que o sistema usa cgroups v2. Guardam-se todos os ficheiros do laboratório numa pasta para que a limpeza seja simples.
```bash
podman --version
podman info --format 'rootless={{.Host.Security.Rootless}} cgroups={{.Host.CgroupsVersion}} runtime={{.Host.OCIRuntime.Name}}'
stat -fc %T /sys/fs/cgroup
mkdir -p ~/virt-lab && cd ~/virt-lab
```
Saída esperada (a versão pode ser mais recente; o runtime pode ser `runc`):
```text
podman version 5.8.7
rootless=true cgroups=v2 runtime=crun
cgroup2fs
```
`cgroup2fs` significa que o sistema de ficheiros cgroup v2 está montado em `/sys/fs/cgroup`. Se vir `tmpfs`, o sistema usa cgroups v1 e os passos dos limites não coincidirão; consulte Resolução de problemas.
> [!WARNING]
> Execute todos os comandos seguintes a partir de `~/virt-lab`, salvo indicação em contrário num passo.
### Passo 2 — Escreva a aplicação e o Containerfile
A aplicação é um pequeno script de shell. O `Containerfile` lista os passos de construção; cada passo que altera ficheiros acrescenta uma camada. Fixe a imagem de base a uma etiqueta de versão exata (`3.20.10`), não a `latest`, para que a construção seja repetível.
```bash
cat > app.sh <<'EOF'
#!/bin/sh
echo "Hello from $(hostname), running as $(id -un) (PID $$)"
EOF
chmod +x app.sh
cat > Containerfile <<'EOF'
FROM docker.io/library/alpine:3.20.10
LABEL org.opencontainers.image.title="lab-virt-hello"
RUN apk add --no-cache procps-ng
COPY app.sh /usr/local/bin/app.sh
CMD ["/usr/local/bin/app.sh"]
EOF
```
O que faz cada linha:
- `FROM` escolhe a imagem de base e as suas camadas.
- `LABEL` acrescenta metadados à configuração da imagem (sem camada nova).
- `RUN` executa um comando num contentor temporário e guarda as alterações aos ficheiros como uma camada nova.
- `COPY` acrescenta um ficheiro da sua pasta como uma camada nova.
- `CMD` define o comando por omissão (apenas metadados).
> [!NOTE]
> A linha `RUN` está lá para dar à imagem uma camada que se possa ver. Para ela é necessário acesso à rede durante a construção.
### Passo 3 — Construa a imagem
```bash
podman build -t lab-virt-hello:1.0 .
```
`-t` dá à imagem o nome `lab-virt-hello` com a etiqueta `1.0`, e `.` é o contexto de construção (esta pasta).
Saída esperada (os IDs serão diferentes; as linhas de descarregamento do `apk` estão cortadas):
```text
STEP 1/5: FROM docker.io/library/alpine:3.20.10
STEP 2/5: LABEL org.opencontainers.image.title="lab-virt-hello"
--> b1be2b84c186
STEP 3/5: RUN apk add --no-cache procps-ng
Executing busybox-1.36.1-r31.trigger
OK: 9 MiB in 19 packages
--> c76c408b748b
STEP 4/5: COPY app.sh /usr/local/bin/app.sh
--> 964fed8bd61c
STEP 5/5: CMD ["/usr/local/bin/app.sh"]
COMMIT lab-virt-hello:1.0
--> de5c993d6a99
Successfully tagged localhost/lab-virt-hello:1.0
de5c993d6a996bcc2d734c27e4290c4d4d80a12865dc8c7833be391f7e51feb6
```
Da primeira vez, o Podman também imprime `Trying to pull docker.io/library/alpine:3.20.10...` e as linhas de descarregamento dos blobs. Verifique a imagem:
```bash
podman images lab-virt-hello
```
```text
REPOSITORY TAG IMAGE ID CREATED SIZE
localhost/lab-virt-hello 1.0 de5c993d6a99 Less than a second ago 9.37 MB
```
### Passo 4 — Inspecione as camadas
O `podman history` lista uma linha por instrução de construção, com o tamanho da camada que acrescentou.
```bash
podman history lab-virt-hello:1.0
```
Saída esperada (cortada para caber; as horas e os IDs serão diferentes):
```text
ID CREATED CREATED BY SIZE COMMENT
964fed8bd61c Less than a second ago /bin/sh -c #(nop) CMD ["/usr/local/bin/app... 0B
<missing> Less than a second ago /bin/sh -c #(nop) COPY file:23760a3ecceb3e... 3.58kB
c76c408b748b Less than a second ago /bin/sh -c apk add --no-cache procps-ng 1.27MB
bf8527eb54c3 1 second ago /bin/sh -c #(nop) LABEL org.opencontainers... 0B FROM docker.i...
<missing> 6 months ago CMD ["/bin/sh"] 0B buildkit.dock...
<missing> 6 months ago ADD alpine-minirootfs-3.20.10-x86_64.tar.g... 8.09MB buildkit.dock...
```
Leia-a de baixo para cima: o sistema de ficheiros raiz da imagem de base (8.09 MB), o seu `RUN` (1.27 MB), o seu `COPY` (3.58 kB). `CMD` e `LABEL` são 0 B: só alteram a configuração. Agora peça diretamente as camadas e o formato:
```bash
podman image inspect lab-virt-hello:1.0 --format 'Layers: {{len .RootFS.Layers}} Cmd: {{.Config.Cmd}} Format: {{.ManifestType}}'
podman image inspect lab-virt-hello:1.0 --format '{{range .RootFS.Layers}}{{println .}}{{end}}'
```
Saída esperada (a primeira camada, Alpine, é igual na sua máquina; as outras duas serão diferentes, porque o seu conteúdo inclui as horas de construção):
```text
Layers: 3 Cmd: [/usr/local/bin/app.sh] Format: application/vnd.oci.image.manifest.v1+json
sha256:08bc4e534116aa76b16015484b82eac51f9a593416feae9296c8a2d4bb7aa4a2
sha256:f55ed2bae43c665dab4e7586118f8ad3e837d47e4f580dbc8c6ae63b55ac8f5e
sha256:df259c8f1ca6356b3feac01c6d60efbe8439114afa5442ddbcfba2f5286d92c7
```
Três camadas (a base, `RUN`, `COPY`), cada uma nomeada pelo digest SHA-256 do seu conteúdo, e uma imagem no formato de imagem OCI (`application/vnd.oci.image.manifest.v1+json`).
> [!NOTE]
> Os digests acima são os IDs de conteúdo não comprimido (`diff_id` na configuração da imagem). Os digests das camadas comprimidas no manifesto, que um registo usa, são valores diferentes.
### Passo 5 — Execute o contentor
Execute-o uma vez em primeiro plano. `--rm` apaga o contentor quando termina, e `--name` segue a regra `lab-virt-`.
```bash
podman run --rm --name lab-virt-hello lab-virt-hello:1.0
```
Saída esperada (o nome de anfitrião são os primeiros 12 carateres do ID do contentor, pelo que o seu será diferente):
```text
Hello from 5088d1aeb13f, running as root (PID 1)
```
Repare em três coisas: o nome de anfitrião não é o do computador (namespace uts), o script é o **PID 1** (namespace pid) e o utilizador é `root` (um namespace user, como se verá no Passo 7).
### Passo 6 — Compare a vista do contentor com a do anfitrião
Desta vez, inicie um contentor que continue a executar-se, para o poder observar dos dois lados.
```bash
podman run -d --name lab-virt-demo lab-virt-hello:1.0 sleep 3600
podman ps --filter name=lab-virt- --format 'table {{.Names}}\t{{.Status}}\t{{.Command}}'
```
Saída esperada (a primeira linha é o ID completo do contentor):
```text
9f26995a174db194e15e4322e83b28bdfb0928df0ed9f5be2a803f0607cc6b50
NAMES STATUS COMMAND
lab-virt-demo Up Less than a second sleep 3600
```
Peça ao Podman os processos do contentor, com a vista do anfitrião ao lado da do contentor:
```bash
podman top lab-virt-demo user pid hpid huser comm
```
```text
USER PID HPID HUSER COMMAND
root 1 41390 1000 sleep
```
`PID` é o número dentro do contentor (1); `HPID` é o PID do mesmo processo no anfitrião (aqui 41390, o seu será diferente); `USER` é `root` dentro, e `HUSER` é `1000` no anfitrião: o seu próprio ID de utilizador. O contentor «root» é o próprio utilizador. Agora compare as vistas com comandos executados dentro e fora:
```bash
podman exec lab-virt-demo hostname
podman exec lab-virt-demo ps -o pid,user,comm
podman exec lab-virt-demo uname -r
echo "--- host ---"
hostname
uname -r
```
Saída esperada:
```text
9f26995a174d
PID USER COMMAND
1 root sleep
3 root ps
7.2.4-ogc3.1.fc44.x86_64
--- host ---
bazzite
7.2.4-ogc3.1.fc44.x86_64
```
No interior vê-se um nome de anfitrião diferente e apenas dois processos (`sleep` como PID 1 e o `ps` que acabou de iniciar), enquanto o anfitrião tem centenas. Mas `uname -r` imprime **a mesma versão do kernel**: não há kernel convidado, o contentor partilha o do anfitrião. Esta é a principal diferença em relação a uma VM.
### Passo 7 — Observe os namespaces a partir do anfitrião
Cada processo tem uma ligação por namespace em `/proc/<pid>/ns/`. Dois processos estão no mesmo namespace quando o número da ligação é o mesmo. Compare a shell com o `sleep` do contentor, usando o seu PID do anfitrião:
```bash
PID=$(podman inspect lab-virt-demo --format '{{.State.Pid}}')
echo "container PID on the host: $PID"
for ns in cgroup ipc mnt net pid user uts time; do
printf '%-7s host %-18s container %s\n' $ns "$(readlink /proc/self/ns/$ns)" "$(readlink /proc/$PID/ns/$ns)"
done
```
Saída esperada (os números serão diferentes na sua máquina; compare-os aos pares):
```text
container PID on the host: 41390
cgroup host cgroup:[4026531835] container cgroup:[4026533219]
ipc host ipc:[4026531839] container ipc:[4026533217]
mnt host mnt:[4026531832] container mnt:[4026533215]
net host net:[4026531833] container net:[4026533103]
pid host pid:[4026531836] container pid:[4026533218]
user host user:[4026531837] container user:[4026533101]
uts host uts:[4026531838] container uts:[4026533216]
time host time:[4026531834] container time:[4026531834]
```
Sete namespaces são diferentes. O namespace `time` é o mesmo: os contentores não têm um próprio por omissão. Se o `lsns` estiver instalado (pacote `util-linux`), lista a mesma informação:
```bash
lsns -p $PID -o NS,TYPE,NPROCS,PID,COMMAND
```
```text
NS TYPE NPROCS PID COMMAND
4026531834 time 153 1853 /usr/bin/mpris-proxy
4026533101 user 16 15774 catatonit -P
4026533103 net 1 41390 sleep 3600
4026533215 mnt 1 41390 sleep 3600
4026533216 uts 1 41390 sleep 3600
4026533217 ipc 1 41390 sleep 3600
4026533218 pid 1 41390 sleep 3600
4026533219 cgroup 1 41390 sleep 3600
```
A primeira linha é o namespace `time` que se partilha com o anfitrião (o `COMMAND` mostrado é apenas o processo mais antigo nele). A linha `user` tem mais do que um processo: o Podman sem root mantém um único namespace user para todos os contentores, sustentado por um pequeno auxiliar (`catatonit`).
Agora, o namespace user. Dentro do contentor é-se o UID 0. Que utilizador pensa o anfitrião que se é e como é feito o mapeamento?
```bash
podman exec lab-virt-demo cat /proc/self/uid_map
stat -c 'owner of the host process: %U' /proc/$PID
```
```text
0 1000 1
1 524288 65536
owner of the host process: user
```
Leia cada linha de `uid_map` como `<primeiro UID dentro> <primeiro UID fora> <quantos>`: o UID 0 do contentor é o UID 1000 do anfitrião (o utilizador; uma contagem de 1), e os UID 1 a 65536 do contentor são mapeados para um intervalo de UID reservado em `/etc/subuid`. O processo no anfitrião pertence ao nome de utilizador próprio (`user` aqui; o seu será diferente). Uma falha que permitisse ao processo escapar só encontraria os direitos do utilizador, não os de root.
### Passo 8 — Defina limites e leia-os no cgroup
Inicie um segundo contentor com um limite de meio CPU e 64 MB de memória:
```bash
podman run -d --name lab-virt-limited --cpus 0.5 --memory 64m lab-virt-hello:1.0 sleep 3600
```
O cgroup do contentor é um diretório abaixo de `/sys/fs/cgroup`. Encontre-o a partir do PID do anfitrião e leia os ficheiros de limites:
```bash
PID=$(podman inspect lab-virt-limited --format '{{.State.Pid}}')
CG=/sys/fs/cgroup$(cut -d: -f3 /proc/$PID/cgroup)
echo "$CG"
for f in memory.max cpu.max pids.max memory.current; do printf '%-15s %s\n' $f "$(cat $CG/$f)"; done
```
Saída esperada (o ID do contentor no caminho será diferente, cortado aqui como `<id>`; `memory.current` varia):
```text
/sys/fs/cgroup/user.slice/user-1000.slice/user@1000.service/user.slice/libpod-<id>.scope/container
memory.max 67108864
cpu.max 50000 100000
pids.max 2048
memory.current 741376
```
- `memory.max` é `67108864`: 64 × 1024 × 1024 bytes, de `--memory 64m`.
- `cpu.max` é `50000 100000`: 50 000 µs de tempo de CPU em cada período de 100 000 µs, ou seja, 0.5 CPU, de `--cpus 0.5`.
- `pids.max` é um valor por omissão que o Podman define (2048 aqui; o seu pode ser diferente).
Compare com o contentor que não tem limites, `lab-virt-demo`:
```bash
CGD=/sys/fs/cgroup$(cut -d: -f3 /proc/$(podman inspect lab-virt-demo --format '{{.State.Pid}}')/cgroup)
for f in memory.max cpu.max; do printf '%-15s %s\n' $f "$(cat $CGD/$f)"; done
```
```text
memory.max max
cpu.max max 100000
```
`max` significa «sem limite». O contentor também pode ler os seus próprios limites, porque tem o seu próprio namespace cgroup, em que o seu cgroup aparece como a raiz:
```bash
podman exec lab-virt-limited cat /sys/fs/cgroup/memory.max /sys/fs/cgroup/cpu.max
podman inspect lab-virt-limited --format 'Memory={{.HostConfig.Memory}} NanoCpus={{.HostConfig.NanoCpus}} CpuQuota={{.HostConfig.CpuQuota}} CpuPeriod={{.HostConfig.CpuPeriod}}'
```
```text
67108864
50000 100000
Memory=67108864 NanoCpus=500000000 CpuQuota=50000 CpuPeriod=100000
```
### Passo 9 — Veja o limite de CPU a limitar um contentor ocupado
Inicie um ciclo infinito dentro do contentor limitado. Sem limite usaria um CPU inteiro; com `--cpus 0.5` deverá obter cerca de metade.
```bash
podman exec -d lab-virt-limited sh -c 'while :; do :; done'
sleep 8
podman stats --no-stream --format 'table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}' lab-virt-limited
grep -E 'nr_periods|nr_throttled|throttled_usec' $CG/cpu.stat
```
Saída esperada (as percentagens e os contadores variam):
```text
NAME CPU % MEM USAGE / LIMIT
lab-virt-limited 48.63% 450.6kB / 67.11MB
nr_periods 83
nr_throttled 78
throttled_usec 3373263
```
O ciclo quer 100 % de um CPU mas obtém cerca de 50 %. `nr_throttled` conta os períodos em que o cgroup esgotou a quota e foi pausado até ao período seguinte: quase todos (78 de 83). CPU acima do limite significa **mais lento**, não terminado.
Remova os dois contentores. O `sleep` como PID 1 ignora o sinal de paragem (`SIGTERM`), pelo que `-t 0` dispensa a espera de 10 segundos:
```bash
podman rm -f -t 0 lab-virt-limited lab-virt-demo
```
```text
lab-virt-demo
lab-virt-limited
```
### Passo 10 — Provoque de propósito uma terminação por OOM
Agora dê 64 MB a um contentor e peça à sua shell que mantenha em memória uma cadeia de 200 MB. O comando `head -c 200000000 /dev/zero | tr "\0" a` produz 200 MB da letra `a`, e a shell guarda-os todos na variável `x`.
```bash
podman run --name lab-virt-oom --memory 64m lab-virt-hello:1.0 \
sh -c 'x=$(head -c 200000000 /dev/zero | tr "\0" a); echo "allocated ${#x} bytes"'
echo "exit code: $?"
```
Saída esperada:
```text
exit code: 137
```
Não há linha «allocated»: a shell foi terminada antes de a poder imprimir. O nome não leva `--rm`, pelo que é possível inspecionar o contentor parado. O código de saída 137 é 128 + 9, ou seja, `SIGKILL`. Mas foi o OOM killer? Pergunte ao motor:
```bash
podman inspect lab-virt-oom --format 'OOMKilled={{.State.OOMKilled}} ExitCode={{.State.ExitCode}} Status={{.State.Status}}'
```
```text
OOMKilled=true ExitCode=137 Status=exited
```
`OOMKilled=true` confirma que o OOM killer do cgroup de memória o parou. O registo do kernel dá os detalhes:
```bash
journalctl -k --since "-2min" --no-pager | grep "Memory cgroup out of memory"
```
Saída esperada (abreviada; o PID e os tamanhos variam):
```text
nov 07 19:55:34 bazzite kernel: Memory cgroup out of memory: Killed process 43622 (sh) total-vm:136808kB, anon-rss:62252kB, file-rss:904kB, shmem-rss:0kB, UID:1000 pgtables:300kB oom_score_adj:200
```
O processo estava a usar cerca de 62 MB de memória residente (`anon-rss`) quando atingiu o limite de 64 MB, e foi nesse momento que foi terminado.
> [!NOTE]
> Ler o registo do kernel requer acesso ao journal: em muitos sistemas um utilizador comum tem de pertencer ao grupo `systemd-journal` (ou `adm`), ou usar `dmesg` se o sistema o permitir (`sysctl kernel.dmesg_restrict` é `0`). Sem acesso, o `podman inspect` e o código de saída 137 bastam para concluir o laboratório; a linha do kernel é uma confirmação.
> [!NOTE]
> Se o processo que fica sem memória for iniciado com `podman exec` num contentor cujo processo principal está bem, apenas esse processo lançado com `exec` é terminado: o contentor continua a executar-se e `OOMKilled` continua `false`. O ficheiro `memory.events` do cgroup mostra-o de qualquer forma, como um contador `oom_kill 1`. Ao diagnosticar um reinício ou uma terminação, deve consultar-se `memory.events` além de `OOMKilled`.
Agora corrija. A tarefa precisa de cerca de 200 MB, pelo que se aumenta o limite para 512 MB. Desta vez, use `--rm`:
```bash
podman rm lab-virt-oom
podman run --rm --name lab-virt-oom --memory 512m lab-virt-hello:1.0 \
sh -c 'x=$(head -c 200000000 /dev/zero | tr "\0" a); echo "allocated ${#x} bytes"'
echo "exit code: $?"
```
```text
lab-virt-oom
allocated 200000000 bytes
exit code: 0
```
O mesmo comando funciona quando o limite se ajusta à necessidade real. A primeira linha é a saída de `podman rm`, que imprime o nome do contentor removido.
## Verificação
Verifique cada resultado. Todos os seguintes pontos devem ser verdadeiros:
- `podman history lab-virt-hello:1.0` mostra uma camada de base de cerca de 8 MB, uma camada `RUN` de cerca de 1 MB e uma camada `COPY` de alguns kB; `CMD` e `LABEL` mostram `0B`.
- Dentro de um contentor, `hostname` difere do do anfitrião, `ps` mostra `sleep` como PID 1 e `uname -r` é igual à versão do kernel do anfitrião.
- `readlink /proc/<pid>/ns/...` dá números diferentes para `cgroup`, `ipc`, `mnt`, `net`, `pid`, `user` e `uts`, e o mesmo número para `time`.
- `memory.max` é `67108864` e `cpu.max` é `50000 100000` em `lab-virt-limited`.
- A execução com OOM termina com `OOMKilled=true` e o código de saída 137, e a nova tentativa com `--memory 512m` termina com `allocated 200000000 bytes`.
Autoverificação rápida:
```bash
podman ps -a --filter name=lab-virt- --format '{{.Names}} {{.Status}}'
```
Depois do Passo 10 isto não imprime nada, porque o último contentor usou `--rm` e os anteriores foram removidos.
## Resolução de problemas
| Sintoma | Causa provável | Correção |
|---|---|---|
| `stat -fc %T /sys/fs/cgroup` imprime `tmpfs` | O sistema usa cgroups v1, onde os limites sem root não são suportados | Usar uma distribuição com cgroups v2 (Fedora, Ubuntu 22.04 ou posterior, Debian 11 ou posterior) ou uma VM. O Podman avisa: `Resource limits are not supported and ignored on cgroups V1 rootless systems`. |
| `podman run --cpus 0.5` falha ou o ficheiro `cpu.max` fica em `max` | O controlador `cpu` não está delegado ao utilizador | Executar `cat /sys/fs/cgroup/user.slice/user-$(id -u).slice/user@$(id -u).service/cgroup.controllers`; deve listar `cpu`, `memory` e `pids`. Em sistemas mais antigos, um administrador tem de ativar a delegação (um drop-in do systemd com `Delegate=cpu cpuset io memory pids`). |
| `Error: pulling image ... connection refused` ou tempo esgotado | Sem Internet ou com um proxy | Definir a variável `HTTPS_PROXY`, ou descarregar de um registo acessível e alterar a linha `FROM`. |
| `apk add` falha durante a construção | O contentor não tem DNS nem rede | Verificar que `podman run --rm docker.io/library/alpine:3.20.10 nslookup example.com` funciona; verificar a firewall e a VPN. |
| `cannot clone: Operation not permitted` ou erros de namespace user | O modo sem root precisa de entradas em `/etc/subuid` e `/etc/subgid` e de namespaces user sem privilégios | `grep $USER /etc/subuid /etc/subgid`; um administrador pode acrescentá-las (`usermod --add-subuids ...`). |
| O contentor executa-se mas `OOMKilled` é `false` e o código de saída é 137 | Terminado por outro motivo (por exemplo um tempo limite de stop), ou o limite de memória não foi aplicado | Verificar `memory.max` no cgroup; ver o Passo 10. |
| Sem linha de OOM em `journalctl -k` | Sem permissão para ler o registo do kernel, ou a entrada é anterior à janela de `--since` | Ver a NOTA do Passo 10; usar `--since "-10min"`. |
| `/proc/<pid>/ns` ou o caminho do cgroup não existe | O contentor já parou, ou o PID está desatualizado | Executar `podman ps` e ler o PID de novo. |
| `Error: creating container storage: the container name "lab-virt-oom" is already in use` | Ficou um contentor parado com esse nome | `podman rm lab-virt-oom` |
## Desafio (opcional)
Use-os sem instruções passo a passo:
1. Inicie um contentor com `--pids-limit 20` e tente iniciar mais de 20 processos nele (por exemplo com um ciclo de shell que execute `sleep 300 &`). Que erro se obtém e que ficheiro e contador do cgroup mudaram? Remova o contentor depois.
2. Inicie um contentor com `--uts=host` e depois com `--pid=host`, e compare `hostname` e `ps` com os valores por omissão. Que isolamento se retirou em cada caso? Porque é que raramente se quereria isto?
3. Construa a imagem de novo com `FROM docker.io/library/alpine:3.20.10@sha256:<digest>` (obtenha o digest com `podman image inspect docker.io/library/alpine:3.20.10 --format '{{.Digest}}'`). O que garante o digest que a etiqueta não garante?
## Limpeza
Remova os contentores (os nomes são explícitos, e `--ignore` salta os que já não existem), a imagem construída e a pasta do laboratório:
```bash
podman rm -f -t 0 --ignore lab-virt-demo lab-virt-limited lab-virt-oom lab-virt-hello
podman rmi lab-virt-hello:1.0
cd ~ && rm -r ~/virt-lab
```
Saída esperada (os IDs serão diferentes; o primeiro comando imprime o nome de cada contentor que remove, e nada se não restar nenhum):
```text
Untagged: localhost/lab-virt-hello:1.0
Deleted: de5c993d6a996bcc2d734c27e4290c4d4d80a12865dc8c7833be391f7e51feb6
Deleted: 964fed8bd61ca0b105dcbf80de33b5c8eb7bab12ab5f96fa46d4d98e2830587a
Deleted: c76c408b748b1e099ea7e4d5e1350499b7d405187fe91f6d497e686e4688fba6
Deleted: b1be2b84c1863941b122d42738aeef7356b81e3f2704e6db0b2faa6f099e28f3
```
Se a imagem de base foi descarregada só para este laboratório, remova-a também. Salte este passo se usar o Alpine 3.20.10 para outra coisa; o Podman recusa remover uma imagem que um contentor ainda usa:
```bash
podman rmi docker.io/library/alpine:3.20.10
```
Verifique que não resta nada:
```bash
podman ps -a --filter name=lab-virt-
podman images lab-virt-hello
ls ~/virt-lab
```
Os dois primeiros comandos imprimem apenas as linhas de cabeçalho (ou nada), e `ls` indica que a pasta não existe.
## O que aprendeu
- Um `Containerfile` transforma-se numa imagem OCI formada por camadas: cada `RUN` e `COPY` acrescenta uma, e `CMD` e `LABEL` só acrescentam metadados. Fixar a imagem de base a uma etiqueta exata mantém as construções repetíveis.
- Um contentor é um processo normal do anfitrião: `podman top` mostra o seu PID do anfitrião, `/proc/<pid>/ns` mostra que está nos seus próprios namespaces pid, net, mnt, uts, ipc, user e cgroup, e `uname -r` mostra que partilha o kernel do anfitrião.
- Num contentor sem root, o root do interior é o próprio utilizador sem privilégios do exterior, através do mapeamento do namespace user.
- `--memory` e `--cpus` tornam-se `memory.max` e `cpu.max` no cgroup do contentor; exceder o limite de CPU limita a velocidade, e exceder o limite de memória invoca o OOM killer.
- O código de saída 137 significa `SIGKILL`; `OOMKilled=true`, a linha do registo do kernel e `memory.events` indicam se foi o OOM killer, e a correção é compreender a necessidade real de memória, não apenas aumentar o limite.