# Inicio Rapido

Deploy do Monetarie PIX em 15 minutos usando Docker Compose. Este guia utiliza o modo de desenvolvimento, que inclui PostgreSQL, Redis e NATS em containers.

## Pre-requisitos

- Docker Engine 24.0+ instalado e em execucao
- Docker Compose 2.20+ instalado
- 8 GB de RAM disponivel
- 10 GB de espaco em disco
- Portas 4003, 5432, 6379, 4222 e 8080 livres

Verifique os pre-requisitos:

```bash
docker --version
# Esperado: Docker version 24.x.x ou superior

docker compose version
# Esperado: Docker Compose version v2.20.x ou superior
```

## Passo 1: Clonar o Repositorio

```bash
git clone https://github.com/MonetarieBR/pix.git
cd pix
```

Saida esperada:
```
Cloning into 'pix'...
remote: Enumerating objects: ...
Receiving objects: 100% ...
```

## Passo 2: Configurar Variaveis de Ambiente

```bash
cd deploy/docker-compose
cp .env.example .env
```

Edite o arquivo `.env` e configure as variaveis obrigatorias:

```bash
# Gerar um SECRET_KEY_BASE seguro (64+ caracteres)
# Se voce tem Elixir instalado:
#   mix phx.gen.secret
# Ou use openssl:
openssl rand -base64 64 | tr -d '\n'
```

Atualize o `.env` com os valores:

```ini
# OBRIGATORIO: Secret key (64+ caracteres)
SECRET_KEY_BASE=<cole_a_chave_gerada_aqui>

# OBRIGATORIO: Senha do banco de dados
DB_PASS=uma_senha_segura_aqui

# OBRIGATORIO: Database URL (atualize a senha)
DATABASE_URL=ecto://postgres:uma_senha_segura_aqui@postgres:5432/monetarie

# Mantenha os demais valores padrao para desenvolvimento
```

## Passo 3: Iniciar os Servicos

Inicie todos os servicos (backend + admin + PostgreSQL + Redis + NATS):

```bash
docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d
```

Saida esperada:
```
[+] Running 5/5
 ✔ Container pix-postgres-dev  Healthy
 ✔ Container pix-redis-dev     Healthy
 ✔ Container pix-nats-dev      Healthy
 ✔ Container pix-backend-dev   Healthy
 ✔ Container pix-admin-dev     Started
```

::: tip PRIMEIRA EXECUCAO
Na primeira execucao, o Docker fara download das imagens e build dos containers. Isso pode levar de 5 a 10 minutos dependendo da sua conexao.
:::

## Passo 4: Aguardar Health Checks

Aguarde todos os servicos ficarem saudaveis:

```bash
# Verificar status dos containers
docker compose -f docker-compose.yml -f docker-compose.dev.yml ps
```

Saida esperada:
```
NAME                SERVICE    STATUS                    PORTS
pix-backend-dev     backend    Up (healthy)              0.0.0.0:4003->4003/tcp
pix-admin-dev       admin      Up                        0.0.0.0:8080->80/tcp
pix-postgres-dev    postgres   Up (healthy)              0.0.0.0:5432->5432/tcp
pix-redis-dev       redis      Up (healthy)              0.0.0.0:6379->6379/tcp
pix-nats-dev        nats       Up (healthy)              0.0.0.0:4222->4222/tcp
```

Verifique o endpoint de saude do backend:

```bash
curl -s http://localhost:4003/health
```

Saida esperada:
```json
{"status":"ok"}
```

## Passo 5: Executar Migrations

Crie os 8 schemas e 25 migrations do banco de dados:

```bash
docker compose -f docker-compose.yml -f docker-compose.dev.yml \
  exec backend bin/monetarie_pix eval "Shared.Release.migrate()"
```

Saida esperada:
```
17:30:00.000 [info] == Running migrations ==
17:30:00.100 [info] == Migrated 20260201000001 in 0.1s ==
17:30:00.200 [info] == Migrated 20260203000001 in 0.1s ==
...
17:30:05.000 [info] == Migrated 20260210000001 in 0.2s ==
17:30:05.100 [info] Migrations complete.
```

## Passo 6: Popular Dados de Referencia

Execute os seeds para popular dados de referencia, participantes, usuarios de teste e dados de demonstracao:

```bash
docker compose -f docker-compose.yml -f docker-compose.dev.yml \
  exec backend bin/monetarie_pix eval "Shared.Release.seed()"
```

Saida esperada:
```
17:31:00.000 [info] == Seeding database ==
17:31:00.100 [info] Seeded 10 participants
17:31:00.200 [info] Seeded 7 users
17:31:00.500 [info] Seeded 369 reference banks
17:31:01.000 [info] Seeded 277 PIX keys
17:31:03.000 [info] Seeded 1000+ transactions
17:31:04.000 [info] Seeds complete.
```

| Dados Populados | Quantidade |
|-----------------|-----------|
| Participantes | 10 |
| Usuarios | 7 |
| Bancos de referencia | 369 + 98 adicionais |
| Chaves PIX | 277 |
| Operacoes DICT | 15.442 |
| Codigos de status | 15 |
| Codigos de razao | 190 |
| Tipos de mensagem | 26 |
| Schemas XSD | 27 |
| Codigos de erro BACEN | 161 |
| Contas COSIF | 44 |
| Centros de custo | 6 |
| Transacoes (30 dias) | 1.000+ |

## Passo 7: Acessar o Portal Admin

Abra o navegador e acesse:

```
http://localhost:8080
```

Faca login com as credenciais de administrador:

| Campo | Valor |
|-------|-------|
| Usuario | `admin` |
| Senha | `Admin@2026!` |

### Outros Usuarios de Teste

| Usuario | Senha | Funcao |
|---------|-------|--------|
| `operator` | `Operator@2026!` | Operador de transacoes |
| `viewer` | `Viewer@2026!` | Visualizacao apenas |
| `integration` | `Monetarie@2026!` | Integracao Monetarie |

## Passo 8: Verificar Todos os Servicos

Verifique que todos os componentes estao operacionais:

```bash
# Backend API
curl -s http://localhost:4003/health | python3 -m json.tool
# Esperado: {"status": "ok"}

# Backend metricas Prometheus
curl -s http://localhost:4003/metrics | head -5
# Esperado: linhas de metricas Prometheus (HELP, TYPE, valores)

# PostgreSQL
docker compose -f docker-compose.yml -f docker-compose.dev.yml \
  exec postgres pg_isready -U postgres
# Esperado: /var/run/postgresql:5432 - accepting connections

# Redis
docker compose -f docker-compose.yml -f docker-compose.dev.yml \
  exec redis redis-cli ping
# Esperado: PONG

# NATS
curl -s http://localhost:8222/healthz
# Esperado: {"status":"ok"}

# NATS JetStream
curl -s http://localhost:8222/jsz | python3 -m json.tool
# Esperado: JSON com informacoes dos streams JetStream
```

## Proximos Passos

Seu Monetarie PIX esta em execucao. Explore os seguintes recursos:

- [Conceitos PIX](./concepts.md) — entenda os conceitos fundamentais do ecossistema PIX
- [Deployment com Docker Compose](../deployment/docker-compose.md) — configuracao avancada para producao
- [Deployment com Kubernetes](../deployment/kubernetes.md) — deploy em cluster Kubernetes
- [Visao Geral de Deployment](../deployment/overview.md) — escolha o modelo ideal para seu ambiente

## Parar os Servicos

Para parar todos os servicos:

```bash
docker compose -f docker-compose.yml -f docker-compose.dev.yml down
```

Para parar e remover volumes (apaga dados do banco):

```bash
docker compose -f docker-compose.yml -f docker-compose.dev.yml down -v
```

## Resolucao de Problemas

### Container backend nao inicia

```bash
docker compose -f docker-compose.yml -f docker-compose.dev.yml logs backend
```

Causas comuns:
- `SECRET_KEY_BASE` nao configurado ou com menos de 64 caracteres
- PostgreSQL ainda nao esta pronto (aguarde o health check)
- Porta 4003 ja em uso por outro processo

### Erro de conexao com o banco

Verifique se o `DATABASE_URL` no `.env` corresponde as credenciais do PostgreSQL:

```bash
docker compose -f docker-compose.yml -f docker-compose.dev.yml \
  exec postgres psql -U postgres -c "SELECT 1"
```

### Porta em uso

```bash
# Verificar quem esta usando a porta
lsof -i :4003
lsof -i :8080
```

## Resultado Esperado

Ao final deste guia, voce tera:

- Monetarie PIX backend rodando na porta 4003 com todos os 4 servicos Elixir
- Portal Admin acessivel na porta 8080 com autenticacao funcionando
- PostgreSQL com 8 schemas, 25 migrations e dados de referencia populados
- Redis, NATS JetStream e todos os workers operacionais
- Capacidade de explorar transacoes, chaves PIX, contabilidade e monitoramento