🎬 Go Transcoder Service

Um backend de transcodificação de vídeo de nível de produção, altamente concorrente e tolerante a falhas, escrito em Go puro (1.24+). Este serviço utiliza uma fila Redis para consumir trabalhos, processa vídeos usando FFmpeg/FFprobe e expõe métricas detalhadas de progresso via API, tudo isso seguindo os princípios da Clean Architecture.

---

✨ Visão Geral

Este projeto serve como um exemplo robusto de como construir um serviço de backend para processamento de mídia. Ele foi projetado com foco em concorrência, resiliência e observabilidade, utilizando apenas a biblioteca padrão do Go para a lógica principal, garantindo um mínimo de dependências externas.

Principais Funcionalidades

• ** arquitetura limpa**: Separação clara de responsabilidades entre Domínio, Casos de Uso, Infraestrutura e Camadas de Entrega.
• ** pool de workers concorrentes**: Maximiza o uso da CPU com um pool de Goroutines para processar vários trabalhos e renderizações simultaneamente.
• ** Fila de Trabalhos com Redis**: Busca trabalhos de uma lista Redis, garantindo desacoplamento e escalabilidade.
• ** Transcodificação Progressiva**: Detecta a resolução do vídeo de origem e gera todas as camadas de qualidade inferiores (por exemplo, 1080p, 720p, 480p).
• ** Tratamento de Falhas e Retentativas**: Tenta novamente trabalhos que falharam com backoff exponencial e os move para uma fila de "dead-letter" (DLQ) após o esgotamento das tentativas.
• ** Métricas Detalhadas**: Expõe um endpoint /metrics que fornece estatísticas agregadas e um endpoint /metrics/{jobID} para rastrear o progresso em tempo real de cada trabalho.
• ** Encerramento Gracioso**: Lida com SIGINT/SIGTERM para garantir que nenhum trabalho em andamento seja perdido durante o desligamento.
• ** Dockerizado**: Totalmente containerizado com Docker e Docker Compose para fácil configuração e implantação.

---

🏗️ Arquitetura

O serviço é estruturado em torno dos princípios da Clean Architecture para promover a separação de interesses e a testabilidade.

/cmd/transcoder/       # Ponto de entrada, inicialização e fiação
/internal/
├── config/            # Carregamento de configuração (env/flags)
├── domain/            # Modelos de negócio principais (Job, Rendition)
├── usecase/           # Lógica de negócio (TranscodeInteractor)
├── worker/            # Pool de workers concorrentes
└── infra/
    ├── logger/        # Configuração do logger estruturado (slog)
    ├── metrics/       # Coletor de métricas e servidor de API
    ├── queue/         # Implementação da fila com Redis
    └── transcoder/    # Wrapper para os comandos FFmpeg/FFprobe
/samples/         # (Opcional) Diretório para vídeos de teste locais

Diagrama de Fluxo

flowchart TD
    subgraph "Ambiente Externo"
        A[Cliente/Usuário] -- "make add-job" --> B(Fila de Trabalhos Redis);
        style B fill:#fef3c7,stroke:#333,stroke-width:2px;
    end

    subgraph "Aplicação Go Transcoder"
        C(Job Fetcher) -- "BRPOP (bloqueante)" --> B;
        C -- "Envia para canal interno" --> D{Canal de Trabalhos Go};
        E(Worker Pool) -- "Recebe do canal" --> D;
        E -- "Processa Job" --> F(Transcode UseCase);
        F -- "Usa" --> G(FFmpeg Processor);
        F -- "Reporta progresso" --> H(Métricas);
    end

    subgraph "Sistema Operacional"
        G -- "executa" --> I(ffmpeg / ffprobe);
        style I fill:#dbeafe,stroke:#333,stroke-width:2px;
        I -- "Lê vídeo" --> J((Fonte do Vídeo));
        I -- "Escreve arquivos" --> K([Sistema de Arquivos]);
    end

    subgraph "Monitoramento"
         L(API /metrics) -- "Expõe" --> H;
    end

    F -- "Em caso de falha final" --> M(Fila DLQ Redis);
    style M fill:#fee2e2,stroke:#333,stroke-width:2px;

Loading

🚀 Começando

Pré-requisitos

• Docker e Docker Compose
• Make (opcional, para usar os comandos de atalho)
• Um arquivo de vídeo para testar (coloque-o em /local_videos)

Instalação

1. Clone o repositório:

   git clone <URL_DO_SEU_REPOSITORIO>
   cd <NOME_DO_DIRETORIO>

2. Crie o arquivo de ambiente: Copie .env.example para .env ou crie o seu próprio. Os padrões já estão configurados para funcionar com o Docker Compose.

3. Inicie os serviços: Este comando irá construir a imagem do Go, iniciar o container da aplicação e o container do Redis.

   make up

   Ou, sem o make:

   docker-compose up -d --build

Uso

1. Adicione um Trabalho de Transcodificação: Use o comando make para enfileirar um trabalho. Você pode especificar a URL do vídeo (que pode ser um link da web ou um caminho de arquivo local dentro do container).

   • Usando um vídeo da web:

     make add-job VIDEO_URL="http://videothatuwillhaveaccess.com/video.mp4"

   • Usando um vídeo local (deve estar na pasta local_videos):

     make add-job VIDEO_URL="/videos/seu_video.mp4"

2. Monitore os Logs: Para ver o que o serviço está fazendo em tempo real:

   make logs

3. Verifique as Métricas:

   • Métricas Agregadas e Trabalhos em Andamento:

     curl http://localhost:8080/metrics

     Copie o id de um trabalho da lista in_flight_jobs.

   • Progresso de um Trabalho Específico:

     curl http://localhost:8080/metrics/<ID_DO_TRABALHO_AQUI>

4. Acesse os Arquivos de Saída: Os vídeos transcodificados aparecerão na pasta output na raiz do seu projeto.

5. Pare os Serviços:

   make down

---

🔧 Configuração

Todas as configurações são gerenciadas por meio de variáveis de ambiente no arquivo .env.

Variável	Descrição	Padrão
REDIS_ADDR	Endereço do servidor Redis.	redis:6379
REDIS_QUEUE	Nome da lista Redis para novos trabalhos.	video_queue
REDIS_DLQ	Nome da lista para trabalhos que falharam.	dead_letter_queue
WORKER_COUNT	Número de workers concorrentes no pool.	2
MAX_RETRIES	Número máximo de tentativas para um trabalho.	3
OUTPUT_PATH	Caminho dentro do container para salvar os vídeos.	/tmp/transcodes
HTTP_PORT	Porta para o servidor de métricas.	8080
LOG_LEVEL	Nível de log (DEBUG, INFO, WARN, ERROR).	INFO

---

📄 Licença

Este projeto está licenciado sob a Licença MIT. Veja o arquivo LICENSE para mais detalhes.