Criação de Imagens Docker Personalizadas

Por que criar imagens personalizadas? Elas permitem empacotar seu aplicativo específico, suas dependências e sua configuração em uma única unidade portátil. Isso é fundamental para garantir consistência e facilitar a implantação.

Você define como criar essa imagem usando um arquivo chamado Dockerfile.

Vamos conteinerizar um aplicativo web super simples em Python Flask. Ele apenas retorna "Olá do Docker!" quando você acessa o endereço web dele.

Imagine que tenhamos estes arquivos em um diretório:

• app.py: o código do aplicativo Python
• requirements.txt: lista as dependências do Python
• Dockerfile: instruções para criar a imagem

Este é o nosso aplicativo básico em Python com Flask. Ele escuta na porta 5000 e responde com "Hello from Docker!".

Você pode executá-lo localmente (depois de instalar o Flask) para vê-lo em funcionamento!

Nosso aplicativo precisa da biblioteca Flask. Nós a listamos em requirements.txt. Esse arquivo informa ao Docker (e ao gerenciador de pacotes do Python, pip) o que deve ser instalado.

Isso garante que nossa imagem tenha todas as bibliotecas necessárias para executar o aplicativo.

Um arquivo Docker é um arquivo de texto com instruções para criar uma imagem. Cada instrução cria uma camada. Veja o que usaremos:

• FROM: especifica a imagem base (por exemplo, Python).
• WORKDIR: define o diretório de trabalho dentro do contêiner.
• COPY: copia arquivos do seu computador para a imagem.
• RUN: executa comandos (por exemplo, para instalar dependências).
• EXPOSE: informa ao Docker sobre as portas nas quais o contêiner escuta.
• CMD: define o comando padrão a ser executado quando o contêiner é iniciado.

Aqui está o Dockerfile completo do nosso aplicativo Flask. Coloque esse arquivo no mesmo diretório que app.py e requirements.txt.

Agora, vamos criar nossa imagem! Abra o terminal no diretório em que estão localizados o Dockerfile e os arquivos do aplicativo.

O sinalizador -t atribui à nossa imagem um nome (my-flask-app) e uma versão (1.0). O . informa ao Docker que o diretório atual deve ser usado como contexto da criação.

docker build -t my-flask-app:1.0 .

Depois que a criação for concluída, você poderá verificar se sua nova imagem existe listando todas as imagens locais do Docker.

Procure por my-flask-app com a tag 1.0 na saída.

docker images

É hora de ver seu aplicativo em ação! Use docker run para criar e iniciar um contêiner a partir da sua imagem.

-p 5000:5000 mapeia a porta 5000 do seu computador host para a porta 5000 dentro do contêiner. -d o executa no modo desacoplado (em segundo plano).

docker run -d -p 5000:5000 my-flask-app:1.0

Acesse http://localhost:5000 no navegador para ver "Hello from Docker!".

As tags são fundamentais para gerenciar diferentes versões das suas imagens. Uma prática comum é usar o versionamento semântico (por exemplo, 1.0.0, 2.1.5) e também uma tag latest.

Você pode adicionar várias tags a uma imagem usando docker tag:

docker tag my-flask-app:1.0 my-flask-app:latest

Isso permite referenciar a mesma imagem por nomes diferentes, tornando-a flexível para implantações.

Considere o seguinte Dockerfile e comando de criação:

# Dockerfile content
FROM alpine:latest
WORKDIR /app
COPY . .
CMD ["echo", "Hello"]

docker build -t my-app:v1 .

Qual das afirmações a seguir é TRUE sobre o comando docker build -t my-app:v1 .?

Excelente trabalho! Você aprendeu a:

• Preparar um aplicativo simples para a conteinerização.
• Escrever um Dockerfile básico usando instruções importantes (FROM, WORKDIR, COPY, RUN, EXPOSE, CMD).
• Criar uma imagem Docker personalizada usando docker build -t.
• Verificar sua imagem com docker images.
• Executar um contêiner a partir da sua imagem personalizada usando docker run -p.
• Entender a importância das tags e do versionamento de imagens.

A seguir, vamos aprofundar a estrutura das imagens Docker com camadas e técnicas para otimizar o tamanho e o tempo de criação!