Docker SDK Python: Gerencie Contêineres Docker com Python…

Introdução ao Docker SDK for Python

A conteinerização é a base da infraestrutura DevOps moderna. O Docker se tornou o padrão de fato para isolar aplicações e gerenciar ambientes. No entanto, quando você precisa de um controle mais flexível e programável sobre os contêineres, entra em cena o Docker SDK for Python, mais conhecido como docker-py.

Esta biblioteca permite interagir diretamente com o daemon do Docker através de código Python, gerenciando contêineres, imagens, redes, volumes e tudo o que normalmente é feito pela linha de comando. Por isso, o docker-py é amplamente utilizado em pipelines de CI/CD, automação, testes e controle de orquestração dinâmica.

O que é o Docker SDK for Python

O Docker SDK for Python é uma biblioteca oficial que fornece uma interface de alto nível para interagir com a API do Docker Engine. Ela permite que desenvolvedores integrem a funcionalidade do Docker diretamente em aplicações Python, automatizando processos de implantação e gerenciamento de contêineres.

Principais recursos da biblioteca

O Docker SDK oferece um conjunto completo de ferramentas para trabalhar com o Docker:

Gerenciamento programático do ciclo de vida dos contêineres
Automação da construção e implantação de imagens
Configuração de redes e armazenamento de dados
Integração com sistemas de monitoramento e logging
Suporte ao Docker Swarm para orquestração
Processamento de eventos do Docker em tempo real

Instalação e configuração inicial

Instalação da biblioteca

Para instalar o Docker SDK, use o gerenciador de pacotes pip padrão:

pip install docker

Para instalar com dependências adicionais para suporte a SSH e TLS:

pip install docker[ssh,tls]

Conexão ao Docker Engine

Conexão básica ao daemon Docker local:

import docker

# Conexão automática via variáveis de ambiente
client = docker.from_env()

# Especificando parâmetros de conexão explicitamente
client = docker.DockerClient(base_url='unix://var/run/docker.sock')

# Conexão a um Docker Engine remoto
client = docker.DockerClient(base_url='tcp://192.168.1.100:2376')

Verificando a conexão

try:
    # Verifica se o Docker Engine está acessível
    print("Docker Engine disponível:", client.ping())
    
    # Obtém informações do sistema
    info = client.info()
    print(f"Versão do Docker: {info['ServerVersion']}")
    print(f"Arquitetura: {info['Architecture']}")
    
except docker.errors.DockerException as e:
    print(f"Erro ao conectar ao Docker: {e}")

Arquitetura e estrutura da biblioteca

O Docker SDK for Python é construído como uma camada sobre a API REST do Docker Engine, fornecendo interfaces de alto e baixo nível para interagir com o Docker.

Estrutura dos módulos

A biblioteca é organizada em vários módulos principais:

docker.DockerClient — cliente principal para interação de alto nível
docker.APIClient — cliente de API de baixo nível
docker.models — modelos orientados a objetos para trabalhar com recursos
docker.types — tipos de dados auxiliares
docker.errors — exceções e tratamento de erros

Princípios arquiteturais

A biblioteca segue os princípios da API REST do Docker Engine:

Cada recurso (contêiner, imagem, rede) é representado por um objeto separado
As operações são executadas através de métodos dos objetos
Suporte à execução assíncrona de operações
Tratamento automático de conexões e reconexões

Gerenciamento de contêineres

Criação de contêineres

Para criar um contêiner, use o método containers.create() ou containers.run():

# Criar um contêiner sem iniciá-lo
container = client.containers.create('nginx:latest', name='meu-nginx')

# Criar e iniciar um contêiner imediatamente
container = client.containers.run('nginx:latest', detach=True, name='meu-nginx-exec')

Gerenciamento do ciclo de vida

# Iniciar um contêiner
container.start()

# Parar um contêiner
container.stop()

# Reiniciar um contêiner
container.restart()

# Remover um contêiner
container.remove(force=True)

Listando e filtrando contêineres

# Listar todos os contêineres
todos_containers = client.containers.list(all=True)

# Listar apenas contêineres em execução
containers_executando = client.containers.list()

# Filtrar por nome ou imagem
containers_filtrados = client.containers.list(filters={"name": "meu-nginx"})

Trabalhando com imagens Docker

Baixando e gerenciando imagens

# Baixar uma imagem do Docker Hub
imagem = client.images.pull('python:3.11-slim')

# Listar imagens locais
imagens_locais = client.images.list()

# Remover uma imagem
client.images.remove('python:3.11-slim', force=True)

Construindo imagens a partir de um Dockerfile

# Construir uma imagem a partir de um diretório
imagem, logs = client.images.build(path="./meu-projeto", tag="minha-app:1.0")

# Construir com um Dockerfile específico
imagem, logs = client.images.build(
    path="./meu-projeto",
    dockerfile="Dockerfile.prod",
    tag="minha-app:prod"
)

Gerenciamento de redes e volumes

Criando e gerenciando redes

# Criar uma rede personalizada
rede = client.networks.create("minha-rede", driver="bridge")

# Conectar um contêiner a uma rede
rede.connect("meu-nginx")

# Listar redes disponíveis
redes = client.networks.list()

Trabalhando com volumes

# Criar um volume
volume = client.volumes.create("meu-volume")

# Listar volumes
volumes = client.volumes.list()

# Montar um volume em um contêiner
container = client.containers.run(
    'nginx:latest',
    volumes={'meu-volume': {'bind': '/dados', 'mode': 'rw'}},
    detach=True
)

Automação e integração com DevOps

Exemplo prático: Pipeline de CI/CD

import docker
import os

def deploy_aplicacao():
    cliente = docker.from_env()
    
    # 1. Construir a imagem
    print("Construindo imagem...")
    imagem, logs = cliente.images.build(
        path="./app",
        tag=f"minha-app:{os.environ['BUILD_NUMBER']}"
    )
    
    # 2. Parar e remover contêiner antigo
    try:
        container_antigo = cliente.containers.get("app-producao")
        container_antigo.stop()
        container_antigo.remove()
    except docker.errors.NotFound:
        pass
    
    # 3. Iniciar novo contêiner
    container_novo = cliente.containers.run(
        f"minha-app:{os.environ['BUILD_NUMBER']}",
        name="app-producao",
        ports={'8000:8000'},
        detach=True
    )
    
    print(f"Aplicação implantada: {container_novo.id[:12]}")

if __name__ == "__main__":
    deploy_aplicacao()

Monitoramento de eventos em tempo real

# Monitorar eventos do Docker em tempo real
for evento in client.events(decode=True):
    if evento['Type'] == 'container':
        print(f"Contêiner {evento['Action']}: {evento['id'][:12]}")
        if evento['Action'] == 'die':
            print(f"Contêiner {evento['id'][:12]} foi parado!")

Orquestração com Docker Swarm

O Docker SDK também oferece suporte completo ao Docker Swarm para orquestração de clusters:

# Inicializar um swarm
client.swarm.init()

# Criar um serviço
servico = client.services.create(
    'nginx:latest',
    name='meu-servico',
    replicas=3,
    publish_mode='ingress'
)

# Escalar um serviço
servico.scale(5)

# Listar serviços
servicos = client.services.list()

Conclusão

O Docker SDK for Python (docker-py) é uma ferramenta essencial para qualquer desenvolvedor ou profissional de DevOps que trabalhe com contêineres Docker. Com ele, você pode automatizar completamente o gerenciamento de contêineres, imagens, redes e volumes diretamente do seu código Python, integrando-se perfeitamente a pipelines de CI/CD, sistemas de monitoramento e fluxos de trabalho de automação.

A biblioteca é madura, bem documentada e amplamente adotada na comunidade, tornando-se a escolha ideal para quem busca programabilidade e flexibilidade no ecossistema Docker.