# AUTOMATION-JOBS-CORE

Este serviço é responsável pela execução de automações, workflows de longa duração e jobs agendados, utilizando o poder do [Temporal](https://temporal.io/) para garantir confiabilidade e idempotência.

## 📋 Visão Geral

O projeto é dividido em três componentes principais que trabalham em conjunto para processar tarefas assíncronas:

1.  **API (HTTP)**: Ponto de entrada leve para iniciar workflows.
2.  **Temporal Server**: O "cérebro" que orquestra o estado e o agendamento das tarefas.
3.  **Workers (Go)**: Onde o código da lógica de negócio (workflows e activities) realmente é executado.

### Arquitetura

O diagrama abaixo ilustra como os componentes interagem:

```mermaid
graph TD
    Client[Cliente Externo/Frontend] -->|HTTP POST /jobs/run| API[API Service :8080]
    API -->|gRPC StartWorkflow| Temporal[Temporal Service :7233]
    
    subgraph Temporal Cluster
        Temporal
        DB[(PostgreSQL)]
        Temporal --> DB
    end
    
    Worker[Go Worker] -->|Poll TaskQueue| Temporal
    Worker -->|Execute Activity| Worker
    Worker -->|Return Result| Temporal
```

## 🚀 Estrutura do Projeto

Abaixo está o detalhamento de cada diretório e arquivo importante:

| Caminho | Descrição |
| :--- | :--- |
| `cmd/api/` | Ponto de entrada (`main.go`) para o serviço da API. |
| `cmd/worker/` | Ponto de entrada (`main.go`) para o serviço do Worker. |
| `internal/` | Código compartilhado e lógica interna do aplicativo. |
| `temporal/` | Definições de Workflows e Activities do Temporal. |
| `Dockerfile.api` | Configuração de build otimizada para a API (Distroless). |
| `Dockerfile.worker` | Configuração de build otimizada para o Worker (Distroless). |
| `docker-compose.yml` | Orquestração local de todos os serviços. |

## 🛠️ Tecnologias e Otimizações

-   **Linguagem**: Go 1.23+
-   **Orquestração**: Temporal.io
-   **Containerização**: 
    -   Images baseadas em `gcr.io/distroless/static`.
    -   Multi-stage builds para reduzir o tamanho final da imagem (~20MB).
    -   Execução como usuário `nonroot` para segurança aprimorada.

## 💻 Como Executar

O projeto é projetado para ser executado via Docker Compose para um ambiente de desenvolvimento completo.

### Pré-requisitos
-   Docker Engine
-   Docker Compose

### Passo a Passo

1.  **Inicie o ambiente:**
    ```bash
    docker-compose up --build
    ```
    Isso irá subir:
    -   Temporal Server & Web UI (Porta `8088`)
    -   PostgreSQL (Persistência do Temporal)
    -   API Service (Porta `8080`)
    -   Worker Service

2.  **Dispare um Workflow de Teste:**
    ```bash
    curl -X POST http://localhost:8080/jobs/run
    ```

3.  **Monitore a Execução:**
    Acesse a interface do Temporal para ver o progresso em tempo real:
    [http://localhost:8088](http://localhost:8088)

## 🔧 Detalhes dos Dockerfiles

Os Dockerfiles foram refatorados para máxima eficiência:

-   **Builder Stage**: Usa `golang:1.23-alpine` para compilar o binário estático, removendo informações de debug (`-ldflags="-w -s"`).
-   **Runtime Stage**: Usa `gcr.io/distroless/static:nonroot`, que contém apenas o mínimo necessário para rodar binários Go, sem shell ou gerenciador de pacotes, garantindo:
    -   ✅ **Segurança**: Menor superfície de ataque.
    -   ✅ **Tamanho**: Imagens extremamente leves.
    -   ✅ **Performance**: Bootrápido.