Administrando contêineres com Podman na prática

Executando um servidor web

Execute:

$ podman run -d \
    --name meu-servidor \
    -p 127.0.0.1:8080:80 \
    docker.io/library/nginx:alpine

Esse comando cria um contêiner baseado na imagem do Nginx e o mantém em execução em segundo plano.

As opções utilizadas são:

O Nginx escuta a porta 80 dentro do contêiner. Como utilizamos 127.0.0.1:8080:80 a porta 8080 do computador foi associada à porta 80 do contêiner.

O endereço 127.0.0.1 limita o acesso ao próprio computador, uma escolha apropriada para testes locais. Se tivéssemos usado apenas 8080:80, dependendo da configuração, o serviço poderia ficar acessível por outras máquinas da rede.

Abra o navegador e acesse:

http://localhost:8080

Também podemos fazer o teste pelo terminal:

$ curl http://localhost:8080

A página de boas-vindas do Nginx deverá ser apresentada.

Listando os contêineres

Para mostrar os contêineres em execução:

$ podman ps

A saída apresenta informações como identificador, imagem, comando, horário de criação, estado, portas e nome.

Para incluir contêineres que já terminaram:

$ podman ps --all

A forma abreviada é:

$ podman ps -a

Cada contêiner recebe um identificador longo. Na maioria dos comandos, podemos usar seu nome ou os primeiros caracteres do identificador.

Como atribuímos o nome meu-servidor, podemos trabalhar diretamente com ele.

Consultando os registros

A saída produzida pela aplicação pode ser consultada com:

$ podman logs meu-servidor

Depois de acessar a página do Nginx, o registro deverá mostrar a requisição recebida.

Para acompanhar novas mensagens em tempo real:

$ podman logs --follow meu-servidor

A opção pode ser abreviada:

$ podman logs -f meu-servidor

Pressione Ctrl+C para interromper o acompanhamento. O contêiner continuará funcionando.

Os registros são um dos primeiros recursos que devemos consultar quando uma aplicação não inicia ou apresenta algum comportamento inesperado.

Examinando o contêiner

O comando inspect apresenta os detalhes técnicos de uma imagem, contêiner, volume ou rede:

$ podman inspect meu-servidor

A saída é fornecida em formato JSON e pode ser extensa. Ela inclui configurações, volumes, variáveis de ambiente, portas e informações de rede.

Para mostrar apenas o estado:

$ podman inspect \
    --format '{{.State.Status}}' \
    meu-servidor

Para mostrar o identificador da imagem:

$ podman inspect \
    --format '{{.Image}}' \
    meu-servidor

Também podemos examinar os processos executados dentro do contêiner:

$ podman top meu-servidor

Executando comandos dentro do contêiner

O comando podman exec inicia um novo processo dentro de um contêiner que já está funcionando.

Para abrir um shell no servidor:

$ podman exec -it meu-servidor /bin/sh

Dentro do contêiner, podemos examinar os arquivos disponibilizados pelo Nginx:

$ ls /usr/share/nginx/html

Podemos verificar os processos com o comando ps.

Para sair digite exit.

O comando exit encerra apenas o shell iniciado com podman exec. O processo principal do Nginx continua em execução.

Também podemos executar um comando sem abrir uma sessão interativa:

$ podman exec meu-servidor nginx -v

Parando e iniciando o contêiner

Para interromper o servidor:

$ podman stop meu-servidor

Confirme seu estado:

$ podman ps -a

O contêiner ainda existe, embora esteja parado. Podemos iniciá-lo novamente:

$ podman start meu-servidor

Para reiniciá-lo:

$ podman restart meu-servidor

Essa distinção é importante. Parar um contêiner encerra seus processos. Removê-lo apaga a instância criada a partir da imagem.

Por que alguns contêineres terminam imediatamente?

Um contêiner permanece ativo enquanto seu processo principal está sendo executado. Se esse processo terminar, o contêiner também termina.

Podemos demonstrar esse comportamento:

$ podman run --name teste \
    docker.io/library/alpine:latest \
    echo "Tarefa concluída"

O comando echo termina imediatamente. Por isso, o contêiner aparece como encerrado:

$ podman ps -a

Para descobrir o que ocorreu em um contêiner encerrado, consulte:

$ podman logs teste

Depois, remova-o:

$ podman rm teste

Removendo o servidor

Primeiro, interrompa o contêiner:

$ podman stop meu-servidor

Depois, remova-o:

$ podman rm meu-servidor

Também é possível interromper e remover em uma única operação:

$ podman rm --force meu-servidor

A imagem do Nginx continuará armazenada. Ela poderá ser usada posteriormente para criar outro contêiner.

Administrando imagens

Para listar as imagens disponíveis localmente:

$ podman images

Podemos baixar uma imagem sem criar um contêiner:

$ podman pull docker.io/library/debian:stable

Para examinar seus detalhes:

$ podman inspect docker.io/library/debian:stable

Para remover uma imagem que não está sendo utilizada:

$ podman rmi docker.io/library/debian:stable

Se houver algum contêiner baseado nela, mesmo que esteja parado, o Podman poderá impedir a remoção. Nesse caso, examine os contêineres existentes:

$ podman ps -a

Problemas frequentes

$ podman run alpine

$ podman run docker.io/library/alpine:latest

$ podman run -d \
    --name meu-servidor \
    -p 127.0.0.1:8081:80 \
    docker.io/library/nginx:alpine

http://localhost:8081

$ ss -ltnp

$ podman ps -a

$ podman rm meu-servidor

$ podman run --name segundo-servidor ...

$ podman ps

$ podman logs meu-servidor

$ podman port meu-servidor