Criar Imagens Docker Passo a Passo

Introdução

Este tutorial abrangente sobre Docker fornece aos desenvolvedores e profissionais de DevOps conhecimentos essenciais sobre a criação, gestão e compreensão de imagens Docker. Explorando os componentes das imagens, as estruturas de camadas e as técnicas de implementação práticas, os aprendizes adquirirão competências práticas em contencionalização e empacotamento de aplicações.

Fundamentos de Imagens Docker

O que são Imagens Docker?

Imagens Docker são modelos de leitura-somente usados para criar contêineres. Elas contêm ambientes de software pré-configurados, código de aplicação, dependências e configurações de tempo de execução. As imagens Docker servem como projetos para implantar ambientes de aplicação consistentes e reproduzíveis em diferentes sistemas.

Componentes Principais de Imagens Docker

Criando uma Imagem Docker Básica

Aqui está um exemplo de criação de uma imagem simples de aplicação web Python:

## Criar diretório do projeto
mkdir docker-demo
cd docker-demo

## Criar Dockerfile
touch Dockerfile

## Conteúdo do Dockerfile
cat > Dockerfile << EOL
FROM ubuntu:22.04
RUN apt-get update && apt-get install -y python3 python3-pip
WORKDIR /app
COPY app.py .
RUN pip3 install flask
EXPOSE 5000
CMD ["python3", "app.py"]
EOL

## Criar aplicação de exemplo Flask
cat > app.py << EOL
from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello():
    return "Exemplo de Imagem Docker"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)
EOL

## Construir imagem Docker
docker build -t python-web-app .

Camadas de Imagem e Armazenamento

Imagens Docker são compostas por múltiplas camadas de leitura-somente. Cada instrução no Dockerfile cria uma nova camada, permitindo armazenamento eficiente e criação rápida de imagens. Quando uma imagem é construída, o Docker armazena em cache essas camadas para otimizar os tempos de construção e reduzir o uso do espaço em disco.

Identificação de Imagem

Imagens Docker são identificadas exclusivamente por:

• Nome do repositório
• Tag
• ID da imagem

Exemplo: ubuntu:22.04 ou python-web-app:latest

Construindo Imagens Docker

Dockerfile: O Projeto para a Criação de Imagens

O Dockerfile é um arquivo de texto que contém instruções para a construção de uma imagem Docker. Cada instrução cria uma nova camada na imagem, definindo o ambiente, as dependências e a configuração da aplicação.

Tipos de Instruções Dockerfile

Exemplo Prático de Construção de Imagem Docker

## Criar estrutura do projeto
mkdir -p /tmp/docker-nodejs-app
cd /tmp/docker-nodejs-app

## Criar Dockerfile
cat > Dockerfile << EOL
FROM node:16-alpine
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]
EOL

## Criar package.json
cat > package.json << EOL
{
  "name": "nodejs-docker-app",
  "version": "1.0.0",
  "dependencies": {
    "express": "^4.17.1"
  }
}
EOL

## Criar servidor Express simples
cat > server.js << EOL
const express = require('express');
const app = express();
const PORT = 3000;

app.get('/', (req, res) => {
  res.send('Exemplo de Construção de Imagem Docker');
});

app.listen(PORT, () => {
  console.log($(Servidor rodando na porta ${PORT}));
});
EOL

## Construir imagem Docker
docker build -t nodejs-web-app .

## Verificar a criação da imagem
docker images

Contexto de Construção da Imagem

O contexto de construção é o diretório que contém o Dockerfile e os arquivos referenciados. O Docker envia este diretório inteiro para o daemon Docker durante a construção da imagem, permitindo a criação abrangente da imagem.

Construções Multi-Stage

Construções multi-stage permitem criar imagens menores e mais eficientes usando várias instruções FROM em um único Dockerfile, separando as dependências de tempo de construção dos ambientes de tempo de execução.

Técnicas de Gerenciamento de Imagens

Estratégias de Otimização de Imagens Docker

O gerenciamento eficiente de imagens envolve reduzir o tamanho da imagem, minimizar o número de camadas e implementar boas práticas para a criação e armazenamento de imagens.

Técnicas de Redução de Tamanho de Imagem

Gerenciamento do Ciclo de Vida de Imagens Docker

## Listar imagens locais
docker images

## Remover imagens não utilizadas
docker image prune

## Marcar e versionar imagens
docker tag original-image:latest myregistry/image:v1.0

## Empurrar para o Registro Docker
docker push myregistry/image:v1.0

## Puxar uma versão específica da imagem
docker pull myregistry/image:v1.0

Exemplo Avançado de Otimização de Imagem

## Criar Dockerfile otimizado
cat > Dockerfile << EOL
## Construção multi-stage para aplicação Python
FROM python:3.9-alpine AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

FROM python:3.9-alpine
WORKDIR /app
COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages
COPY . .
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser
CMD ["python", "app.py"]
EOL

## Criar arquivo requirements
cat > requirements.txt << EOL
flask==2.1.0
gunicorn==20.1.0
EOL

## Construir imagem otimizada
docker build -t optimized-python-app:slim .

## Analisar o tamanho da imagem
docker images | grep optimized-python-app

Gerenciamento de Registro Docker

Registros Docker fornecem armazenamento e distribuição centralizados de imagens. Eles suportam versionamento, controle de acesso e compartilhamento eficiente de imagens entre equipes de desenvolvimento e ambientes.

Cache de Camadas de Imagem

O Docker armazena em cache as camadas de imagem para acelerar as construções subsequentes. A organização das instruções do Dockerfile, da menos à mais frequentemente alterada, minimiza o tempo de reconstrução e otimiza o processo de criação da imagem.

Resumo

Imagens Docker são fundamentais para a implantação moderna de software, oferecendo uma forma consistente e eficiente de empacotar aplicações com suas dependências. Ao dominar as técnicas de criação de imagens, compreender a mecânica de camadas e utilizar as instruções do Dockerfile, os desenvolvedores podem otimizar seus fluxos de trabalho de desenvolvimento e garantir ambientes de aplicação confiáveis e portáveis em diferentes sistemas.