Podman: implantando aplicações em containers

Criando containers no Podman - Apresentação

Olá, pessoal! Sou o Zago. Boas-vindas a quem escolheu fazer este curso e espero que gostem do conteúdo.

Audiodescrição: Rafael Zago se identifica como uma pessoa branca. É careca, possui barba e bigode escuros. Usa um headphone preto. No corpo, veste uma camiseta bege. Ao fundo, uma parede clara com objetos que referenciam filmes, especialmente de Star Wars, é iluminada em tons de azul e rosa.

Para quem é o curso?

Se você tem interesse em rodar aplicações dentro de containers separados do seu ambiente operacional, de maneira flexível, com uma ferramenta open source (código aberto), gratuita e usada por muitas empresas, este curso é para você.

O que aprenderemos?

Aqui, aprenderemos a:

• Rodar containers em Podman;
• Entender a diferença entre Podman e Docker;
• Como isolar as aplicações do sistema operacional para evitar conflitos de biblioteca e versões de aplicações;
• Salvar os logs da aplicação em container;
• Conhecer os tipos de redes para isolar a aplicação;
• Como colocar a aplicação dentro de pods;
• O que são pods — partes da aplicação com as quais fazemos o deploy com o Kubernetes ou outras ferramentas.

Conhecendo o projeto

Desenvolveremos uma aplicação de biscoito da sorte. Teremos um front-end em HTML, JavaScript e CSS, e clicaremos no botão da tela para pedir a sorte do dia e receberemos uma mensagem. Essa mensagem será fornecida por outro container rodando uma aplicação em Rust, que consumirá as mensagens de um serviço de terceiros.

Disponibilizaremos uma aplicação completa através de um pod e que pode ser replicada por quem tiver acesso ao código-fonte ou às nossas imagens.

Pré-requisitos

Para fazer este curso, é necessário ter noções básicas de Linux e entender como rodar comandos no terminal. Forneceremos todos os comandos, mas é importante ter familiaridade em digitar ou copiar e colar comandos para entender o que está acontecendo.

Também é útil ter conhecimento em máquinas virtuais, pois usaremos uma para rodar nossas aplicações. É importante saber como criar e configurar uma máquina virtual. Além disso, é necessário conhecimento básico em aplicações web, como funcionam, o que é um front-end, um back-end e um serviço.

Aproveite os recursos da plataforma!

Na plataforma, você pode acessar o fórum para interagir e pedir ajuda se houver algum problema. Além disso, não deixe de entrar na comunidade do Discord, para encontrar outras pessoas fazendo este ou outros cursos. Vocês poderão interagir e trocar ideias, algo interessante para seu desenvolvimento.

Também é muito importante realizar as atividades, pois elas fixarão todos os conceitos que abordaremos aqui.

Esperamos vocês na primeira parte do curso, onde criaremos essa solução inteira. Até lá!

Criando containers no Podman - Criando um container

Vamos começar a planejar a solução que vamos entregar. Nela, criaremos um site de biscoitos da sorte, onde teremos um front-end que acessará um back-end com nossas mensagens da sorte.

Definindo as tecnologias

No front-end, usaremos JavaScript, HTML e CSS. No back-end, utilizaremos Rust. O desafio que enfrentamos é que, como são linguagens e ambientes distintos, vamos containerizar cada uma dessas aplicações, tanto o back-end quanto o front-end, para não depender da configuração da máquina que estamos usando.

Configurando a Máquina Virtual

Para as aulas que seguiremos, utilizaremos uma máquina virtual. Nos pré-requisitos do curso, temos as instruções de como criá-la corretamente.

No caso do vídeo, já temos a máquina virtual funcionando e temos seu IP. Certifique-se de ter o IP salvo em algum lugar para facilitar o acesso.

A primeira coisa a fazer é acessar a máquina pelo terminal, com o comando ssh. No caso do vídeo, a pessoa usuária é aluno e o IP da máquina é 192.168.1.33.

ssh aluno@192.168.1.33

Ao acessar, ele pediu a senha que, no caso do vídeo, também é aluno.

aluno

A máquina usada no vídeo é um sistema operacional Linux na distribuição Fedora. Recomendamos que você use essa distribuição, conforme indicado nas instruções da atividade "Preparando o ambiente". No entanto, teoricamente, qualquer outra distribuição Linux também consegue rodar o Podman de maneira simples.

Verificando e instalando o Podman

A primeira checagem que faremos é verificar se o Podman está instalado. Para isso, utilizaremos o comando abaixo:

podman --version

No caso do vídeo, ele já está instalado. Se não estivesse, usaríamos o gerenciador de pacotes abaixo, onde dnf identifica o gerenciador de pacotes do Fedora:

sudo dnf install -y podman

Ele pedirá a senha de pessoa usuária privilegiada e fará a instalação após a inserirmos. Isso é fundamental.

No nosso caso, estamos usando o dnf. Se você estiver usando o Ubuntu, provavelmente usará o apt, ou outra distribuição que use o apt. No Arch Linux, usaria o pacman, e assim por diante. É importante ter clareza de que, apesar de estarmos usando uma ferramenta no Fedora, não se trata de algo exclusivo do Fedora.

Executando o primeiro container

Após a instalação do Fedora, precisamos validar se está funcionando. Quem já utilizou o Docker notará que esse processo é muito parecido com o tutorial de instalação do Docker. No próprio site do Podman, também há essa instrução.

Vamos executar o seguinte comando:

podman run hello-world

Estamos rodando nosso primeiro container com uma imagem chamada "hello-world". Vamos entender mais adiante sobre a imagem, onde ela fica e por que tem esse nome. Ao executar, ele tentará encontrar essa imagem localmente. Se não encontrar, buscará no registro quay.io.

Retorno do terminal:

Resolved "hello-world" as an alias (/etc/containers/registries.conf.d/000-shortnames.conf)

Trying to pull quay.io/podman/hello:latest...

Getting image source signatures

Copying blob 81df7ff16254 done |

Copying config 5dd467f7fce5 done |

Writing manifest to image destination

!... Hello Podman World ...!

Feito isso, nosso Podman terá funcionado e estará instalado.

Criando uma aplicação Rust no container

Nosso primeiro container já foi executado. Vamos avançar um pouco mais para entender alguns conceitos de containers.

Nossa aplicação back-end é em Rust. Vamos criar um exemplo de aplicação em Rust com o seguinte comando:

podman run -it --rm rust:1.72 bash

Nesse comando, o podman é o comando e run é a ordem que estamos dando para o Podman. Ele rodará uma imagem em Rust na versão 1.72. O -it é o modo iterativo, pois vamos acessar o container e digitar comandos lá dentro. Após tudo terminar, queremos que ele remova o container. No final, damos o comando bash, que abre um terminal ao acessar o interior do container.

Ao executar o comando acima, ele tentará encontrar essa imagem localmente. Se não encontrar, buscará no docker.io, um registro do próprio Docker, o hub.docker.com. Isso demonstra uma das flexibilidades do Podman: ele pode acessar diferentes registros.

O Podman está configurado para procurar primeiro no quay.io e, se não encontrar, buscará no Docker ou em outro registro configurado.

Editando e buildando a aplicação

Após o download da imagem, nosso container estará rodando. Para saber se estamos no container, basta observar o terminal: antes estávamos logados em aluno@fedora, onde temos a máquina fedora e a pessoa usuária aluno. Agora, estamos com o usuário root em um ID diferente, indicando que estamos no container.

Para criar nossa aplicação Rust, vamos atualizar os pacotes na máquina com o comando abaixo:

apt update

É interessante notar que, embora estejamos rodando um Fedora como sistema operacional, nosso container é baseado no Debian, isolado da aplicação.

Em seguida, instalaremos o editor de texto Nano para criar a aplicação:

apt install nano

Poderíamos usar outro editor, como o Vim, mas recomendamos o Nano por ser mais fácil de navegar.

Na sequência, criaremos nossa aplicação com o seguinte comando:

cargo new --bin rust-example

Criamos uma aplicação chamada rust-example com o cargo, que é o binário de criação de aplicações Rust. Após a criação, ele informa que o pacote foi criado.

Retorno do terminal:

Created binary (application) rust-example package

Se listarmos os arquivos com ls, veremos o rust-example.

ls

Retorno do terminal:

bin   dev   home   lib32   libx32   mnt   proc   run   sbin   sys   usr 
boot  etc   lib    lib64   media    opt   root   rust-example  srv   tmp   var

Vamos entrar nesse diretório com o comando cd e limpar o terminal para facilitar a visualização.

cd rust-example

Consultaremos o interior desse diretório com o comando abaixo:

ls -l

Com isso, teremos dois arquivos: Cargo.toml, responsável pelas dependências, e um diretório chamado "src", que contém a aplicação main.rs.

Vamos editar o arquivo main.rs com o Nano:

nano src/main.rs

Com o arquivo aberto na janela do Nano, teremos em seu interior uma aplicação pronta, com a famosa frase "Hello, world".

fn main() {
    println!("Hello, world!");
}

Vamos apenas trocar o texto. Navegaremos até os parênteses do println e adicionaremos "do Podman" ao final da frase, e mais uma exclamação no final.

fn main() {
    println!("Hello, world do Podman!!");
}

Usaremos o atalho "Ctrl + O" seguido de "Enter" para salvar o arquivo. Em seguida, usaremos "Ctrl + X" para sair do Nano.

Nossa aplicação está quase pronta. Precisamos apenas buildá-la com o comando abaixo:

cargo build --release

Ele criou o binário da nossa aplicação, que está no diretório "target". Vamos entrar nesse diretório com cd target e, em seguida, no subdiretório "release" com cd release, onde está o binário rust-example.

cd target

cd release

Executaremos esse binário com:

./rust-example

Recapitulando o processo

Nossa aplicação rodou. Vamos recapitular o que fizemos:

• Instalamos o Podman
• Criamos um container "Hello, world" para validar a instalação
• Criamos um container com o Rust instalado
• Criamos uma aplicação Rust
• Editamos com um editor de texto instalado dentro do container
• Usamos um gerenciador de pacotes diferente do Fedora para mostrar que está separado
• Fizemos o build da aplicação.

Explorando containers

Sairemos do container com o comando exit.

exit

Em seguida, se executarmos podman ps, que lista os containers, não haverá containers rodando.

podman ps

Com podman ps -a, que mostra todos os containers, ele indicará que o único container que já rodou foi o "Hello, world".

Retorno do terminal:

CONTAINER ID	IMAGE	COMMAND	CREATED	STATUS	PORTS	NAMES
e218613682c2	quay.io/podman/hello:latest	/usr/local/bin/po...	6 minutes ago	Exited (0) 6 minutes ago		flamboyant_pare

O container Rust não está mais na lista porque rodamos com o parâmetro --rm.

Conclusão

Aprendemos a criar um container em Rust, acessar o container, criar uma aplicação e entendemos algumas flags, como --rm, -it e bash. Isso nos ajudará a construir nosso projeto ao longo das aulas.

Próximos passos

No próximo vídeo, vamos entender as diferenças entre o Podman e o Docker. Citamos o Docker no início do curso, e agora vamos explorar como eles se diferenciam. Nos vemos lá!

Criando containers no Podman - Diferenciando: Podman vs Docker

Até agora, construímos nosso container no Podman e tivemos contato com alguns comandos dessa ferramenta. Agora, vamos abordar uma questão muito comum: as diferenças entre o Podman e o Docker.

Entendendo as diferenças entre Podman e Docker

O Docker é uma ferramenta amplamente utilizada no mundo empresarial e no desenvolvimento de aplicações, independentemente do tamanho da empresa. O Podman é uma alternativa, mas possui diferenças importantes.

Para entender essas diferenças, vamos revisitar alguns conceitos de containers.

Revisando os conceitos de containers

Antes dos containers, utilizávamos máquinas virtuais para isolar aplicações. Nesse contexto, a ferramenta utilizada, seja Podman ou Docker, não faz diferença. A diferença básica é a infraestrutura necessária para uma máquina virtual: precisamos de hardware e de um sistema operacional (geralmente Linux, pois containers acessam diretamente as chamadas do kernel com mais facilidade). Assim, temos nosso binário rodando, com Rust no back-end e com HTML, CSS e Javascript no front-end.

As vantagens de usar uma máquina virtual incluem a facilidade de rodar binários. No entanto, gerenciar dependências pode ser complicado quando temos várias aplicações, como diferentes versões do Rust ou Java rodando em paralelo. Por isso, optamos por usar containers. No caso do Podman, podemos ter várias aplicações rodando em paralelo.

Diferenças fundamentais entre Podman e Docker

Vamos diferenciar o Podman do Docker. A primeira diferença é que o Docker roda com um daemon, um serviço global sob a pessoa usuária root que gerencia todos os containers na máquina. Ou seja, se o daemon cair, todas as aplicações caem.

Já o Podman é daemonless, ou seja, não possui esse daemon. Além disso, ele possui um serviço por container. Isso significa que, se um container falhar, os outros continuam funcionando.

Outra diferença é que, no Docker, gerenciamos apenas containers. No Podman, além de containers, podemos gerenciar pods, que são pedaços da aplicação com um ou mais containers, semelhante ao conceito no Kubernetes.

Com essas diferenças em mente, decidimos que nossa solução de biscoito da sorte será um pod, dentro do qual há o back-end e o front-end.

Configurando e comparando comandos

Voltando ao nosso terminal, verificaremos se o Docker está instalado com o comando abaixo:

docker --version

Ele indicará que o Docker não está instalado e sugerirá aplicativos que podem atender à demanda. Vamos instalar um deles, o Podman Docker:

sudo dnf install podman-docker -y

O Podman Docker é um alias (apelido) no Linux que permite rodar comandos Docker, emulando o Podman. Isso facilita a migração de quem usa Docker para Podman.

Vamos rodar um comando simples no Podman, parecido com outro que já conhecemos. A diferença entre eles é que, no anterior, usamos o interpretador de comando bash devido à imagem do Rust, enquanto neste, usamos o sh para a imagem do Alpine:

podman run -it --rm alpine sh

Estamos rodando o container no modo interativo e pedindo para que ele seja removido após o uso. A imagem Alpine é pequena, portanto, o comando executará mais rápido do que o anterior.

Após a execução dessa imagem Alpine com o Podman, sairemos com exit.

exit

Em seguida, rodaremos o mesmo comando usando o Docker:

docker run -it --rm alpine sh

O Docker não está instalado, mas o comando emula o Podman. Após a execução, o terminal indicará que está emulando o Docker CLI usando o Podman:

Retorno do terminal:

Emulate Docker CLI using podman. Create /etc/containers/nodocker to quiet msg.

Isso minimiza o impacto da migração entre ferramentas. Ao sair dessa imagem com exit e executar docker --version, ele indicará novamente que está emulando o Docker usando o Podman.

docker --version

Recapitulando as diferenças

Recapitulando, usamos containers para isolar aplicações sem a necessidade de instalar bibliotecas no sistema operacional principal. Tanto o Podman quanto o Docker criam containers, mas com diferenças.

A principal diferença é que o Docker usa um serviço daemon para gerenciar containers, enquanto o Podman roda cada container como um serviço separado, sem pessoa usuária root, aumentando a segurança.

Próximos passos

Entendemos as diferenças entre Podman e Docker. Na sequência, vamos aprender a isolar nossas aplicações usando o Podman.

Sobre o curso Podman: implantando aplicações em containers

O curso Podman: implantando aplicações em containers possui 113 minutos de vídeos, em um total de 46 atividades. Gostou? Conheça nossos outros cursos de Containers em DevOps, ou leia nossos artigos de DevOps.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Criando containers no Podman
• Configurando opções avançadas
• Configurando images no Podman
• Debugando sua aplicação
• Testando a aplicação final