Por que os cassinos estão a mudar para a arquitetura modular

Porquê o casino modular

O monólito histórico trava o crescimento, com cada mudança puxando o lançamento de todo o sistema, a integração de provedores e PSP a bater no SLO, os updates complicados em todo o código. A arquitetura modular (domain-driven + API + eventos contratados) permite:

Retirar rapidamente os fichas e conectar os provedores sem coordenar «todos com todos»;
Escala seletiva (vídeo ao vivo separado da bilheteria, carteira separada do catálogo de jogos);
Isolar riscos (erro na promoção não varia a carteira);
Cumprir licenças (loging/versões/políticas em limites de domínio);
Reduzir o TCO através de contratos claros, reutilização e automação.

Mapa de domínios (exemplo de divisão)

Wallet/Ledger - dinheiro, hedge moedas, balanços de bónus, PITR, auditoria.

Cashier/Payments - PSP, ramp/off-ramp, KYT, webhooks idempotantes.

Gaming Bridge - Adaptadores de provedores, normalização de round/bet.

Catalog/Lobby - jogos, provedores, fichering e regras de exibição.

Promo/Bónus - regras de promoções, vales, wager.

KYC/AML/RG - Verificação de identidade, sanções/RER, limites e auto-exclusão.

Experience - Frontand, CDN, i18n, A/B, Telegram WebApp.

Telemetry/Analytics - eventos, vitrines, ML/IA.

Compliance & Audit - relatórios MGA/UKGC, arquivo WORM.

💡 Cada módulo possui seu próprio padrão de dados, API e contrato de evento; interação - através de um pneu de eventos e interfaces estritamente versionadas.

Princípios da arquitetura modular

1. Limites DDD (bounded context). Posse clara de dados e lógica.

2. API-primeiro evento +. JSON-Schema, testes contratuais.

3. Versioning e compatibilidade. 'v1 → v1. 1 → v2` (expand→migrate→contract).

4. Idempotency & Exactly-once-intent. Chaves de consulta, dedução de eventos.

5. Segurança padrão. mTLS, assinaturas HMAC, JWT curtos, RBAC/ABAC.

6. Lançamentos independentes. Os canários/blue-green, as migrações de dois escritores são proibidas.

7. Observabilidade. «traceId», métricas SLO por módulo.

8. Bandeiras fichas. Tráfego/geo/yuser segmentos, retalhos seguros.

Camada de integração: como conectar provedores e PSP

Adaptador/Bridge-Pattern: cada provedor de jogos/pagamentos é um plugin com um único contrato de plataforma.

Jogos: normalização de 'roundId/betId/status', mupping de erros, quebra de limites.

Pagamentos: Interface única 'athorize/capture/refund/payout', webhoot com idumpotência.

Desligamento: adaptador defeituoso traduzido em maintenance sem afetar outros.

Exemplo de contrato (fatia OpenAPI):

yaml post /wallet/debit:
requestBody:
content:
application/json:
schema:
$ref: '#/components/schemas/DebitRequest@v1'
responses:
'200': { $ref: '#/components/schemas/DebitResult@v1' }
'409': { description: IDEMPOTENT_REPLAY }

Eventos como «sistema sanguíneo»

Pneu (Kafka/NATS) → eventos:

`bet. placed`, `round. settled`, `payout. requested/approved`, `kyc. verified/failed`, `rg. limit_set`, `bonus. issued/consumed`, `cashier. webhook. received`, `wallet. hold/release`, `alert. slo_breach`.

Regras:

Eventos não anulam o passado; os ajustes são eventos compensatórios individuais.
Cada módulo só escreve seus eventos de origem, os derivados como novos temas.

Dados: camadas e coerência

OLTP para o módulo: Postgres/MySQL/KeyDB - transações isoladas.

OLAP/vitrines: ClickHouse/BigQuery são construídas a partir de eventos; OLTP e analista não misturamos.

Função Store/ML: Camada independente de OLTP com versões de fic e TTL.

Coerência: estrategicamente evolutivo entre os módulos e, para o dinheiro, ACID local + idumpotência nas fronteiras.

Zoom e zoom

Contêineres (Docker/K8s): scale automático por módulo (wallet - CPU/IO; Vídeo ao vivo - rede; bridge — RPS).

Isolamento do perímetro: políticas de rede, segredos/chaves individuais para o módulo, diferentes armazéns PII/dinheiro/telemetria.

Tráfego-shaping, bandeiras, canárias, rotas regionais.

DR/HA: Multi-AZ; ativo-passivo para dinheiro, ativo-ativo para leitura/mídia.

A complacência «mete» nos pods

O KYC/AML/RG é um módulo próprio com políticas e registros de soluções ('policyVer').

O Check/WORM é um armazenamento imutável de eventos de dinheiro/round/pagamento.

Relatório - Exportação por jurisdição (MGA/UKGC), SLA em tempo integral.

Amostra de fluxo

Taxa → pagamento → pagamento

1. 'gaming-bridge' envia 'bet. placed` (idempotent).

2. 'wallet' faz 'hold' e publica' wallet '. hold`.

3. 'gaming-bridge' recebe o resultado do provedor → 'round. settled`.

4. 'wallet' conta 'setle' (release/payout) → 'wallet. settled`.

5. 'promo' consome eventos e paga um bónus → 'bónus. issued`.

Caixa (depósito)

1. 'cashier' cria 'payment'. intent` с `Idempotency-Key`.

2. O PSP chama o webhook → 'cashier. webhook. received`.

3. `wallet. credit 'de fato → um evento para analistas e RG.

Alterações sem interrupção (expand→migrate→contract)

1. Expand: adicionaram campos/endpoint em 'v1. 1 ', os velhos clientes não quebram.

2. Migrate: Os consumidores leem coisas novas, escrevem em ambas as versões (dual-write somente para não-dinheiro).

3. Contract: Anunciaram EOL 'v1. 0 ', removido em N semanas.

Engenharia de plataforma

Golden Paths: modelos de módulos (repo-asceleão, CI/CD, alertas, SLO, segredos).

Testes contratuais: Pact/AsyncAPI de testes em CI; ambiente de integração com fake provedores.

Catálogo de Serviços (Backstage): quem é o proprietário, SLA, API, Rucbooks de incidente.

Métricas de sucesso da modularidade

Lead time desde a ideia até o lançamento de prod ↓ em X vezes.

Taxa de lançamento por módulo de ↑ (por dia/semana), mudança-fail rate ↓.

MTTR sobre incidentes ↓ (devido ao isolamento).

O Infra Cost/GGR é estável ou ↓ quando o tráfego aumenta (scale seletivo).

Tempo de integração do provedor/PSP (do briefing ao prod) ↓.

Anti-pattern

Microserviços por microsserviços. Sem limites nítidos, a conectividade e a complexidade crescem.

Dados de base de dados compartilhados entre os módulos. Mata o isolamento e lançamentos independentes.

Eventos sem versão/contrato. Quebram os consumidores silenciosamente.

Dual-write para dinheiro. O risco de incoerência é apenas um passo idimpotente através de um único escritor.

Uma camada de utilidade global com tudo. Transforma-se num monólito oculto.

Sem bandeiras fichas e kill-switch. Qualquer erro bate em todos.

Mistura OLTP/OLAP. Os relatórios travam as apostas/carteira.

Sem observabilidade. Não há nada para medir o SLO e ligar os incidentes.

Folha de cheque para a arquitetura modular

Estratégia e domínios

Definidos bounded contexts, proprietários e KPI no módulo.
Mapa de interações API/evento, criticidade e SLO.

Contratos e segurança

OpenAPI/AsyncAPI + JSON-Schema; versão e ciclo de vida.
mTLS/HMAC, JWT, RBAC/ABAC curtos nas fronteiras.

Dados

Os OLTP separados; eventos são uma fonte para o OLAP.
Idempotency em API/webhooks, dedução de mensagens.

CI/CD e lançamentos

Canário/azul-green, bandeiras de fique, scale automático no módulo.
Testes contratuais em CI; um ambiente de fake provedores.

Observabilidade

Logs/métricas/trens com 'traceId'; O SLO-dashboard.
Alertas de métricas de negócios (VOID, reject, payout lag).

Complaens

Arquivo WORM de dinheiro/round, exportação de relatórios regulatórios.
KYC/AML/RG como um módulo de registro de soluções separado.

Minicérebros

Evento 'round. settled@v1`:

json
{
"event":"round. settled",  "v":"1",  "roundId":"R-2025-10-17-evo-23",  "gameId":"evo_blackjack_23",  "bets":[{"betId":"b_92f","playerId":"p_1","stake":"10. 00","payout":"15. 00","outcome":"WIN"}],  "ts":"2025-10-17T14:23:13. 120Z",  "traceId":"tr_5f1"
}

Carteira Idumpotente:

http
POST /wallet/settle
X-Idempotency-Key: 9a7f-2b1c
{
"roundId":"R-2025-10-17-evo-23",  "operations":[{"playerId":"p_1","delta":"5. 00","currency":"EUR"}]
}

A arquitetura modular transforma a plataforma de cassinos de uma «kombi frágil» em uma composição de domínios confiáveis, cada um com seus contratos, dados e SLO. Isso acelera a integração e os lançamentos, dá escala seletiva, simplifica a complacência e reduz os riscos de incidentes. Comece destacando limites de domínio, contratos e eventos, «coloque» segurança e observabilidade - e você terá uma plataforma que cresce com o produto, em vez de travá-lo.