WSL2 + Podman: Uma alternativa ao Docker Desktop
Tags: devops, podman, oci
Published: 2022-01-28 12:26:47

Dia 31/01/2022 o Docker desktop passará a ser pago para empresas com mais de 250 funcionários ou com faturamento a partir de 10 milhões de dólares anuais. Esse comunicado está sendo divulgado desde agosto de 2021 e com ele pensei:
> Está na hora de revisitar aqueles links esquecidos no limbo sobre alternativas ao Docker.

Meu objetivo é ter uma solução na parte de execução de containers, eliminando todo o resto da ferramenta do docker que na máquina de desenvolvimento não utilizo. Em minhas pesquisas a ferramenta que mais se encaixa neste cenário é o [podman](https://podman.io/).

> _Podman is a daemonless container engine for developing, managing, and running OCI Containers on your Linux System. Containers can either be run as root or in rootless mode._ 
_Fonte: https://podman.io/_

Lendo a definição do que é o Podman, encontramos o primeiro problema: ele roda somente em Linux e eu uso o Windows. [Até existe um instalador para Windows](https://podman.io/getting-started/installation#windows), porém ele é um client para acessar o podman instalado em algum lugar e não a ferramenta em si.

## WLS2 + Podman = :heart:
Por sorte e visão da nossa amada e odiada Microsoft, não precisamos mais subir uma VM e realizar toda a configuração necessária para rodar o Linux, podemos usar o WSL2.
No próprio site do podman existe [o link do post que ensina como instalar a aplicação no WSL2](https://www.redhat.com/sysadmin/podman-windows-wsl2). Vou seguir este post e acrescentar algumas observações e passos extras que precisei fazer para ter tudo rodando 100%.

## Configurando o WLS2
>_Etapa opcional. Se está tudo certo na parte de configuração do WSL2, pode ir direto para a [instalação do Podman](#instalando-o-podman)._

O primeiro passo é [habilitar o WSL no Windows](https://docs.microsoft.com/en-us/windows/wsl/install) e ativar o WSL2.
Com o WSL2 habilitado e a distro instalada (estou utilizando o Ubuntu 20.04), vamos verificar se a distro esta no formato WSL2 rodando o comando:
```sh
wsl --list -v
```
O resultado será semelhante ao que segue:
```sh
  NAME                   STATE           VERSION
* Ubuntu                 Stopped         2
  docker-desktop         Stopped         2
  docker-desktop-data    Stopped         2
```
Caso a versão da distro não esteja na 2, é necessário rodar o próximo comando:
```sh
wsl --set-version Ubuntu 2
```
## Instalando o Podman
Com o WSL2 configurado vamos iniciar a instalação do Podman.
O primeiro passo é descobrir qual é o nome e a versão da sua distro. Dentro do shell da distro execute o comando
```sh
cat /etc/os-release
```
Ele deve retornar algo parecido com as informações abaixo:
```sh
NAME="Ubuntu"
VERSION="20.04.2 LTS (Focal Fossa)"
ID=ubuntu
ID_LIKE=debian
PRETTY_NAME="Ubuntu 20.04.2 LTS"
VERSION_ID="20.04"
HOME_URL="https://www.ubuntu.com/"
SUPPORT_URL="https://help.ubuntu.com/"
BUG_REPORT_URL="https://bugs.launchpad.net/ubuntu/"
PRIVACY_POLICY_URL="https://www.ubuntu.com/legal/terms-and-policies/privacy-policy"
VERSION_CODENAME=focal
UBUNTU_CODENAME=focal
```
Alternativamente você pode importar esse arquivo direto para as variáveis de ambiente com o comando:
```sh
. /etc/os-release
```
O comando acima facilitará os próximos passos e por isso vou usá-lo.
O próximo passo é adicionar o repositório do podman na lista de fontes do apt:
```sh
echo "deb https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/x${NAME}_${VERSION_ID}/ /" | sudo tee /etc/apt/sources.list.d/devel:kubic:libcontainers:stable.list
```
Aqui vale uma explicação de alguns pontos do comando que estamos executando:
- **sudo tee**: Pega o valor informado no stdin (nesse caso a instrução anterior) e grava no arquivo de destino informado.

Agora adicionamos uma nova chave ao apt para o repositório que contém o podman:
```sh
curl -L "https://download.opensuse.org/repositories/devel:/kubic:/libcontainers:/stable/x${NAME}_${VERSION_ID}/Release.key" | sudo apt-key add -
```
Explicando:
- **curl**: Efetua uma chamada http para o endereço informado
- **sudo apt-key add - **: Adiciona a chave retornada no stdin a lista do apt-key

Feito! Agora basta atualizar a lista do apt:
```sh
sudo apt-get update
```
E instalar o podman:
```sh
sudo apt-get install -y podman
```
## Testando
A parte mais legal é ver os containers funcionando. Vamos começar por algo simples:

```sh
podman run --rm hello-world
```
Este exemplo é o mesmo exemplo de [hello world do docker](https://hub.docker.com/_/hello-world) porém utilizando o podman

A saída deve ser algo assim:

```sh
Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/
```
Como próximo teste, vamos buildar uma imagem nova e colocá-la para rodar. Para isso vamos usar [o repositório do post que contém um CRUD simples em node](https://github.com/julianopoveda/wsl2-plus-podman).
Uma vez baixado o repositório, vamos buildar a imagem.
Execute o comando abaixo:
```sh
podman build -t juridico -f dockerfile.multistaging .
```
Com a imagem pronta, chegou a hora de executar o container:
```sh
 podman run --rm -p 3001:3001 localhost/juridico
```
Executando o comando `curl http://localhost:3001/95069158262525`, temos o seguinte resultado:
```json
{
    "numero": "95069158262525",
    "uf_sigla": "PR",
    "cidade": "Mendoza",
    "reu": "Kaitlin Scutter",
    "identidade": "33925502749086",
    "cliente": "Cherlyn Floyed",
    "status": "Ativo"
}
```
## Conclusão e Próximos Passos
O Podman me surpreendeu pela simplicidade de uso e semelhança com os comandos de Docker. Todos os comandos do docker que uso no dia-a-dia podem ser facilmente utilizados no podman. Inclusive o próprio site do podman ensina a criar um alias para docker. Outro ponto admirável é a transparencia no mapeamento das portas do WSL para a máquina host. Não é necessário realizar qualquer configuração adicional é só mapear as portas e pronto.

O próximo passo é colocar o Kubernetes para rodar utilizando o podman como container engine.

## Referencias
- https://podman.io/
- https://podman.io/getting-started/installation#ubuntu
- https://www.redhat.com/sysadmin/podman-windows-wsl2
- https://docs.microsoft.com/en-us/windows/wsl/install
- tee --help, apt-key --help, . --help