☕ Um Café no Bellacosa Mainframe
Gostou do conteúdo? Ajude a manter o café quente, o COBOL compilando e o mainframe acordado. 😄
☕ Pague um café ao Bellacosa

Translate

Mostrar mensagens com a etiqueta PostgreSQL. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta PostgreSQL. Mostrar todas as mensagens

sábado, 4 de novembro de 2023

O Dia em que o Arquiteto Entrou no CPD com Oito Bancos de Dados — e o Velho Programador COBOL Perguntou: “Mas Como Você Vai Acessar o Registro?”

 
Bellacosa Mainframe e o misterio de como escolher um banco de dados

☕ Um Café no Bellacosa Mainframe

O Dia em que o Arquiteto Entrou no CPD com Oito Bancos de Dados — e o Velho Programador COBOL Perguntou: “Mas Como Você Vai Acessar o Registro?”

Ou: como Db2, PostgreSQL, MongoDB, Redis, Neo4j, Elasticsearch, Time-Series, Data Warehouses, Vector Databases, RAG e uma arquitetura com tecnologia demais descobriram que o banco certo não começa no produto — começa no problema


São 03:17 da manhã.

O telefone toca.

Isso nunca é bom.

Principalmente quando você trabalha com mainframe.

Do outro lado está alguém da aplicação:

— Temos um problema em produção.

O programador COBOL, que já aprendeu que a palavra “problema” pode significar desde um espaço em branco até a paralisação econômica de um pequeno país, pergunta:

— Qual?

— Performance.

— Onde?

Silêncio.

— No banco.

Essa resposta também não ajuda muito.

— Qual banco?

Novo silêncio.

— Bem... temos PostgreSQL, Redis, Elasticsearch, MongoDB e agora colocaram um Vector Database.

O programador olha para o café.

O café olha para o programador.

Em algum lugar distante, um S0C7 sente que finalmente encontrou concorrência.

E então surge a pergunta mais importante desta história:

Por que existem cinco bancos de dados nessa aplicação?

A resposta deveria ser baseada em requisitos.

Mas existe uma possibilidade assustadora:

Porque alguém achou cada um deles interessante.

Bem-vindo ao estranho mundo da arquitetura moderna.

Hoje vamos descobrir por que escolher um banco de dados deveria começar muito antes de escolher o banco.



1. A primeira regra: não escolha o banco

Parece contraditório.

Estamos justamente tentando escolher um database e a primeira recomendação é:

Não escolha o database.

Pelo menos não ainda.

Primeiro descubra o problema.

Essa é a grande ideia da frase:

Pick the problem before the database.

Um erro comum de arquitetura acontece quando começamos pelo produto:

"Vamos usar MongoDB."

"Vamos usar PostgreSQL."

"Precisamos de Redis."

"Precisamos de Kubernetes."

"Precisamos de Vector Database."

A pergunta seguinte deveria ser sempre:

POR QUÊ?

Se a resposta for:

"Porque todo mundo está usando."

Temos um problema.

Se for:

"Porque é moderno."

Temos dois.

Se for:

"Porque IA."

O café deve ser imediatamente reforçado.

😂

Tecnologia não deveria preceder requisito.



2. O programador COBOL já conhecia essa história

Aqui aparece uma curiosidade maravilhosa.

O mundo moderno apresenta bancos especializados como se a humanidade tivesse descoberto ontem que diferentes workloads precisam de estruturas diferentes.

O mainframe conhece essa história há décadas.

Um programador poderia encontrar:

QSAM
VSAM KSDS
VSAM ESDS
VSAM RRDS
IMS
Db2

Por que não guardar tudo exatamente da mesma maneira?

Porque o modo como os dados são acessados importa.

Imagine um arquivo VSAM KSDS.

Temos uma chave:

00012345 → REGISTRO DO CLIENTE

Não estou dizendo que VSAM é Redis — são tecnologias, arquiteturas e épocas completamente diferentes.

Mas pedagogicamente existe uma ideia em comum:

Se eu conheço a chave, consigo encontrar aquilo que quero.

Agora imagine IMS.

A navegação hierárquica determina profundamente como pensamos sobre os dados.

Depois temos o modelo relacional.

Em vez de dizer:

Vá até este registro, depois siga aquele ponteiro...

podemos declarar aquilo que queremos:

SELECT NOME,
       SALDO
FROM CLIENTE
WHERE CPF = :WS-CPF;

Mudou o paradigma.

Mas a pergunta fundamental continuou viva:

Como esses dados serão utilizados?



3. Antes do database existe o workload

Essa palavra merece morar permanentemente na cabeça de quem projeta sistemas:

WORKLOAD

Não pergunte apenas:

Quantos terabytes temos?

Pergunte:

Quantas leituras?

Quantas escritas?

Qual tamanho médio?

Quais consultas?

Qual concorrência?

Qual latência?

Precisamos de transações?

Precisamos de joins?

Precisamos pesquisar texto?

Precisamos percorrer relacionamentos?

Precisamos analisar bilhões de registros?

Precisamos consultar séries temporais?

Precisamos encontrar similaridade semântica?

Perceba algo interessante.

O volume sozinho não determina a tecnologia.

Um banco com 20 TB acessado predominantemente por chave pode representar um problema completamente diferente de outro banco de 20 TB utilizado para agregações analíticas.

O tamanho é igual.

O workload não.


4. Access Pattern — a pergunta que sobreviveu a todas as revoluções

Se eu pudesse acrescentar apenas uma caixa ao infográfico original, escreveria:

ACCESS PATTERN

Ou:

Como você vai procurar esses dados?

Considere uma entidade chamada CLIENTE.

Temos:

CLIENTE
-------
ID
CPF
NOME
EMAIL
ENDERECO

Parece um problema relacional perfeitamente comum.

Mas alguém pergunta:

Quero encontrar o cliente pelo CPF.

Um índice resolve elegantemente.

Outra pessoa pergunta:

Quero descobrir clientes relacionados por endereço, telefone, empresas, sócios e transações.

Agora os relacionamentos passaram para o centro do problema.

Outra:

Quero pesquisar reclamações semanticamente semelhantes feitas pelos clientes.

Entramos no território de embeddings e vetores.

Outra:

Quero analisar o comportamento desses clientes durante os últimos cinco anos.

Analytics.

Outra:

Quero descobrir quantas tentativas de login ocorreram por segundo.

Time-series.

Os clientes continuam sendo clientes.

O que mudou?

O padrão de acesso.


5. Relational Database — o velho guerreiro que se recusa a morrer

De tempos em tempos alguém anuncia:

SQL morreu.

SQL provavelmente já morreu mais vezes do que personagem de história em quadrinhos.

E continua trabalhando.

Bancos relacionais são particularmente fortes quando temos:

estrutura
relacionamentos bem definidos
integridade
transações
joins
consistência

Aqui encontramos PostgreSQL, MySQL, SQL Server, Oracle e, naturalmente para nossa história:

Db2.

A documentação da IBM define Db2 for z/OS como um sistema gerenciador de banco de dados relacional para IBM Z, com dados logicamente organizados em tabelas e mecanismos de integridade como constraints e triggers. (IBM)

Imagine uma transferência bancária:

CONTA A  - R$ 1.000
CONTA B  + R$ 1.000

Não queremos:

UPDATE CONTA A
   ↓
menos R$ 1.000

ABEND

CONTA B
   ↓
¯\_(ツ)_/¯

Queremos uma transação.

Em pseudo-COBOL:

EXEC SQL
   UPDATE CONTA
      SET SALDO = SALDO - :WS-VALOR
    WHERE NUMERO = :WS-CONTA-ORIGEM
END-EXEC.

EXEC SQL
   UPDATE CONTA
      SET SALDO = SALDO + :WS-VALOR
    WHERE NUMERO = :WS-CONTA-DESTINO
END-EXEC.

EXEC SQL
   COMMIT
END-EXEC.

Se algo der errado:

ROLLBACK

Isso não é frescura acadêmica.

É a diferença entre processamento financeiro e transformar a contabilidade numa experiência de RPG.


6. ACID — quatro letras que salvam noites de sono

Quando falamos em transações, encontramos:

A — Atomicity
C — Consistency
I — Isolation
D — Durability

Atomicidade

Ou tudo acontece ou nada acontece.

Consistência

As regras do banco continuam válidas.

Isolamento

Transações concorrentes não deveriam produzir estados absurdos.

Durabilidade

Depois do COMMIT, esperamos que aquilo continue existindo mesmo diante de falhas.

Essas propriedades ajudam a explicar por que bancos relacionais continuam tão importantes em sistemas críticos.

O PostgreSQL, por exemplo, utiliza MVCC — Multi-Version Concurrency Control — para fornecer snapshots consistentes às transações e controlar concorrência. (PostgreSQL)

Para quem trabalha com Db2, locks, isolation levels, COMMIT e ROLLBACK, nada disso parece ficção científica.


7. Document Database — quando cada registro quer ser diferente

Agora imagine uma loja.

Vendemos computadores:

{
  "produto": "Notebook",
  "ram": "32GB",
  "cpu": "8 cores"
}

Mas também camisetas:

{
  "produto": "Camiseta",
  "tamanho": "G",
  "tecido": "algodao"
}

E livros:

{
  "produto": "Livro",
  "autor": "Fulano",
  "isbn": "123456"
}

Tentar representar milhares de categorias extremamente diferentes em um esquema relacional rígido pode aumentar bastante a complexidade do modelo.

Document databases podem encaixar-se muito bem aqui.

MongoDB trabalha justamente com documentos e coleções e permite modelagem por embedding e referências entre documentos. (MongoDB University)

Mas cuidado com uma frase perigosa:

“MongoDB não precisa de schema.”

A conclusão errada seria:

“Então posso jogar qualquer coisa lá.”

Não.

Flexibilidade de schema não significa ausência de modelagem.

Se você não organizar seus dados, terá apenas transferido o problema do banco para a aplicação.


8. Key-Value — a filosofia do armário numerado

Agora imagine um enorme guarda-volumes.

Você entrega:

CHAVE = 871923

Ele devolve:

VALOR

Essa é a essência conceitual de um key-value store.

Redis explica esse modelo justamente como pares chave-valor, onde uma chave única identifica um valor. Essa simplicidade favorece operações extremamente rápidas de acesso direto. (Redis)

Casos clássicos:

CACHE:CLIENTE:123
SESSION:987321
CARRINHO:USER:761
TOKEN:ABC123
RATE:API:USER42

Queremos:

CHAVE → VALOR

e queremos isso rápido.

Redis é maravilhoso nesse território.

Mas então alguém decide armazenar o ERP inteiro nele.

E seis meses depois pergunta:

Como faço quinze joins?

É o equivalente arquitetural de comprar uma Ferrari e reclamar que ela transporta poucos sacos de cimento.

A tecnologia não está errada.

O problema escolhido para ela está.


9. Graph Database — Sherlock Holmes entra no CPD

Agora imagine investigação de fraude.

Temos:

JOÃO
  |
possui
  |
CONTA A
  |
transferiu
  |
CONTA B
  |
pertence
  |
MARIA
  |
mora
  |
ENDEREÇO X
  |
também usado por
  |
CARLOS

A pergunta deixa de ser:

Qual é o saldo?

Passa a ser:

Quem está relacionado a quem e através de quais caminhos?

Isso é terreno natural de grafos.

Neo4j representa informações usando nodes, relationships e properties, colocando explicitamente as relações no modelo. (Neo4j Graph Intelligence Platform)

Isso pode ser poderoso para:

fraude
redes sociais
recomendações
dependências
rotas
knowledge graphs
supply chains

Podemos modelar relações em SQL?

Claro.

Essa nunca foi a pergunta.

A pergunta correta é:

Qual modelo torna o workload mais natural e eficiente?


10. Search Database — quando LIKE começa a pedir socorro

Imagine milhões de documentos.

O usuário procura:

falha autenticação usuário produção

Queremos considerar:

relevância
termos
variações
ranking
documentos
campos
filtros

Aí aparece aquele SQL:

WHERE TEXTO LIKE '%falha%'
   OR TEXTO LIKE '%autenticacao%'
   OR TEXTO LIKE '%login%'
   OR TEXTO LIKE '%usuario%'

Em algum lugar, um DBA sente uma perturbação na Força.

Search engines como Elasticsearch foram criados justamente para workloads de pesquisa e indexação.

Mas aqui começa algo extremamente interessante.

As caixas do nosso infográfico já não possuem paredes tão rígidas.

Elasticsearch atualmente também suporta armazenamento de embeddings e pesquisa vetorial, combinando similaridade vetorial com full-text search, filtros e agregações. (Elastic)

Guarde isso.

Voltaremos ao assunto.


11. Time-Series — quando o relógio passa a fazer parte do dado

Imagine o monitoramento:

03:00 CPU 31%
03:01 CPU 34%
03:02 CPU 47%
03:03 CPU 72%
03:04 CPU 94%
03:05 CPU 99%

O tempo não é simplesmente mais uma coluna.

Ele é parte essencial da pergunta.

Queremos coisas como:

média nos últimos 10 minutos

pico nas últimas 24 horas

crescimento por hora

eventos entre T1 e T2

agregação por janela

Encontramos isso em:

IoT
sensores
observabilidade
mercado financeiro
telemetria
monitoramento
métricas

E aqui está uma distinção importante.

Ter uma coluna:

TIMESTAMP

não transforma automaticamente seu sistema em um problema de time-series.

Novamente:

workload.


12. Data Warehouse — o executivo quer cinco anos em cinco segundos

Temos então outra criatura.

O sistema operacional responde:

Qual é o saldo desta conta?

Analytics pergunta:

Qual foi o comportamento médio dos clientes entre 35 e 50 anos, separados por região, produto, mês e canal nos últimos cinco anos?

São problemas profundamente diferentes.

Temos a clássica distinção:

OLTP
versus
OLAP

OLTP

Muitas operações pequenas:

INSERT
UPDATE
DELETE
SELECT
COMMIT

OLAP

Grandes leituras e agregações:

SUM
AVG
GROUP BY
histórico
bilhões de registros

Uma metáfora:

OLTP procura rapidamente uma agulha.

OLAP examina o palheiro inteiro para explicar por que existem tantas agulhas.

É por isso que Data Warehouses e bancos analíticos existem.

E o próprio universo IBM Z hoje convive com esse modelo híbrido: a IBM posiciona Db2 for z/OS tanto como sistema de dados empresariais quanto como fonte integrada a analytics, data lakehouses e IA. (IBM)


13. Então chegou a IA carregando vetores

E finalmente chegamos à celebridade da festa:

Vector Database.

Primeiro precisamos entender embeddings.

Imagine:

"COBOL no mainframe"

transformado matematicamente em algo parecido com:

[0.127, -0.332, 0.819, ...]

Outro texto:

"programação de sistemas legados IBM Z"

também recebe uma representação vetorial.

O objetivo é possibilitar comparações matemáticas de proximidade entre representações.

Assim conseguimos fazer:

semantic search
similarity search
recommendations
RAG

Em vez de perguntar:

Contém exatamente esta palavra?

podemos perguntar:

Qual conteúdo possui significado semelhante?

Essa mudança é gigantesca.


14. RAG entra no CPD

Imagine milhares de manuais internos:

COBOL
CICS
Db2
RACF
JCL
MQ
z/OS

O usuário pergunta:

Como investigar determinado SQLCODE?

Em uma arquitetura RAG simplificada:

PERGUNTA
   |
   v
EMBEDDING
   |
   v
BUSCA VETORIAL
   |
   v
DOCUMENTOS RELEVANTES
   |
   v
LLM
   |
   v
RESPOSTA

Mas existe uma pegadinha.

Alguém imediatamente conclui:

Precisamos comprar um Vector Database!

Talvez.

Talvez não.

O pgvector, por exemplo, adiciona busca de similaridade vetorial ao PostgreSQL, incluindo distâncias como cosine, inner product e L2, além de índices HNSW e IVFFlat. (GitHub)

Elasticsearch também oferece pesquisa vetorial. (Elastic)

Portanto:

RAG

não implica automaticamente:

NOVO DATABASE

Essa é uma das lições mais importantes deste artigo.


15. O grande truque: as categorias estão convergindo

Nos antigos diagramas, colocávamos cada tecnologia numa caixa:

SQL
Document
Key-Value
Graph
Search
Time-Series
Analytics
Vector

Mas o mundo real está borrando essas fronteiras.

Um produto pode oferecer múltiplas capacidades.

Isso muda a pergunta.

Antes:

Qual banco implementa essa funcionalidade?

Agora também precisamos perguntar:

Meu banco atual já oferece capacidade suficiente para esse workload?

Porque cada tecnologia nova traz uma mochila operacional.


16. Polyglot Persistence — a guilda dos oito databases

Existe uma filosofia perfeitamente legítima chamada polyglot persistence.

A ideia:

Diferentes workloads podem utilizar diferentes mecanismos de persistência.

Imagine:

                    APLICAÇÃO
                        |
       +----------------+----------------+
       |                |                |
      Db2             Redis        Elasticsearch
       |                |                |
     OLTP             Cache            Search
       |
       +---------- Warehouse
       |
       +---------- Analytics
       |
       +---------- AI / RAG

Isso pode ser excelente.

Db2 guarda o sistema oficial de registro.

Redis acelera cache.

Elasticsearch fornece pesquisa.

Warehouse executa analytics.

Vector search atende recuperação semântica.

Graph investiga relações.

Perfeito.

Até alguém perguntar:

Quem administra tudo isso?

Silêncio.


17. Cada database adicional invoca novos monstros

Toda nova tecnologia traz consigo:

instalação
configuração
monitoramento
backup
restore
replicação
segurança
patching
upgrade
capacity planning
disaster recovery
skills
licenciamento
governança
auditoria
integração
observabilidade

Então chegamos à pergunta que deveria aparecer depois de todas as caixas do infográfico:

Precisamos realmente de outro database?

Se PostgreSQL com pgvector atende ao requisito, talvez não seja necessário adicionar outra plataforma exclusivamente para vetores.

Se Elasticsearch já existe e satisfaz o requisito de busca híbrida, talvez possamos aproveitá-lo.

Se Db2 resolve perfeitamente o workload transacional, não precisamos substituir tecnologia apenas porque surgiu algo mais elegante em uma conferência.

Arquitetura não é Pokémon.

Você não precisa capturar todos.

😂


18. CAP — quando a rede resolve participar da reunião

Quando distribuímos dados, outro problema aparece.

O famoso CAP:

Consistency
Availability
Partition tolerance

Existe uma explicação popular dizendo:

Escolha dois.

É útil como introdução, mas simplifica demais.

O ponto interessante aparece durante uma partição de rede.

Nesse cenário, sistemas distribuídos precisam lidar com trade-offs entre consistência e disponibilidade.

E então aparece uma expressão capaz de causar pequenos espasmos em programadores bancários:

Eventual Consistency.

O velho COBOLzeiro pergunta:

— O saldo está correto?

— Eventualmente.

— Eventualmente quando?

— Eventualmente.

— Chame o gerente.

😂

Eventual consistency não é ruim.

Ela pode ser perfeitamente apropriada.

Um contador de curtidas numa rede social não precisa necessariamente das mesmas garantias de uma transferência financeira.

Eis novamente nossa palavra mágica:

contexto.


19. Consistência não possui o mesmo preço em todo lugar

Imagine:

LIKES = 10.431

Durante alguns milissegundos outro usuário vê:

LIKES = 10.430

Provavelmente ninguém morrerá.

Agora:

SALDO = R$ 100.000

Um servidor acredita nisso.

Outro pensa:

SALDO = R$ 10

Temos uma reunião.

Possivelmente várias.

Portanto não existe uma única política correta de consistência para todos os sistemas.

Existe a consistência adequada ao negócio.


20. O segredo que o velho programador conhecia

Voltemos ao nosso veterano.

Ele olha para a arquitetura:

PostgreSQL
MongoDB
Redis
Neo4j
Elasticsearch
Timescale
Warehouse
Vector Database

e pergunta:

— Como vocês acessam os dados?

O jovem arquiteto começa a explicar Kubernetes, microservices, cloud-native, embeddings, service mesh...

— Não. Como vocês acessam os dados?

Silêncio.

Eis o easter egg desta história.

Essa pergunta poderia ter sido feita em 1975.

Ou 1985.

Ou 1995.

Ou 2026.

Porque tecnologia muda violentamente.

Mas determinados princípios de engenharia sobrevivem.


21. A árvore Bellacosa de escolha do database

Se eu estivesse ensinando isso a um programador COBOL iniciante, começaria assim:

QUAL É O PROBLEMA?
        |
        +--- Transações?
        |       |
        |       +--> RELATIONAL
        |
        +--- Documentos variáveis?
        |       |
        |       +--> DOCUMENT
        |
        +--- Busca extremamente rápida por chave?
        |       |
        |       +--> KEY-VALUE
        |
        +--- Relações são o problema?
        |       |
        |       +--> GRAPH
        |
        +--- Pesquisa textual?
        |       |
        |       +--> SEARCH
        |
        +--- Tempo domina o workload?
        |       |
        |       +--> TIME-SERIES
        |
        +--- Analytics massivo?
        |       |
        |       +--> WAREHOUSE / OLAP
        |
        +--- Similaridade semântica?
                |
                +--> VECTOR

Mas eu acrescentaria:

                  |
                  v
       A TECNOLOGIA ATUAL
        JÁ CONSEGUE FAZER?
             /       \
           SIM       NÃO
            |         |
            v         v
        INVESTIGUE   AVALIE
        PRIMEIRO     NOVA TECH

Isso evita muita arquitetura desnecessária.


22. Depois escolha o produto

Somente agora começamos a discutir nomes.

Não antes.

Pergunte:

Qual throughput?

Qual latência?

Qual volume?

Qual crescimento?

Qual disponibilidade?

Qual RTO?

Qual RPO?

Qual segurança?

Qual compliance?

Qual custo?

Qual conhecimento da equipe?

Qual estratégia de backup?

Qual recuperação?

Qual suporte?

Qual lock-in?

Qual observabilidade?

E talvez a pergunta mais negligenciada:

Quem vai manter isso às 03:17?

Porque a arquitetura desenhada às 14:00 numa apresentação colorida será administrada por alguém durante um incidente.

Essa pessoa merece consideração.


23. O banco mais rápido pode ser a escolha mais lenta

Imagine que determinada tecnologia reduz uma consulta:

100 ms → 10 ms

Fantástico.

Mas para isso precisamos contratar especialistas, criar infraestrutura, replicação, monitoramento, backup, pipelines e sincronização.

Talvez economizemos:

90 ms

e gastemos:

R$ 2 milhões
+ 4 especialistas
+ 3 servidores
+ 2 ferramentas
+ 1 plantonista revoltado

Performance técnica não é o único componente da eficiência arquitetural.

Existe também:

complexidade.


24. O conceito de System of Record

Em arquiteturas híbridas existe outra pergunta fundamental:

Quem é dono da verdade?

Imagine:

Db2
Redis
Elasticsearch
Warehouse
Vector Store

O saldo aparece diferente em dois deles.

Qual vale?

Precisamos saber claramente qual é o:

System of Record.

Em muitos ambientes corporativos, sistemas transacionais em Db2 continuam exercendo exatamente esse papel. A IBM descreve Db2 for z/OS como plataforma para dados centrais de negócio e aplicações críticas, inclusive quando esses dados são integrados a cloud, analytics e IA. (IBM)

Então podemos ter:

             Db2
        SYSTEM OF RECORD
             |
     +-------+-------+
     |       |       |
   Redis   Search  Analytics

Esses sistemas podem possuir cópias especializadas.

Mas existe uma fonte autoritativa.

Isso evita transformar inconsistência em arqueologia.


25. Curiosidade: NoSQL nunca significou “SQL é inútil”

A explosão NoSQL nasceu de problemas reais:

escala
distribuição
flexibilidade
latência
novos workloads

Mas durante algum tempo o debate tecnológico virou quase futebol:

SQL versus NoSQL

Essa oposição é pobre.

Uma arquitetura pode perfeitamente utilizar ambos.

O problema não é escolher SQL.

Nem escolher NoSQL.

O problema é usar qualquer um deles sem entender por quê.


26. E o Db2 no meio dessa selva?

Para o programador COBOL iniciante, vale reforçar algo.

Db2 não é simplesmente:

“o lugar onde meu COBOL executa SELECT”.

Existe uma civilização inteira por baixo:

COBOL
  |
Host Variables
  |
SQL
  |
Precompile
  |
DBRM
  |
BIND
  |
PACKAGE
  |
Access Path
  |
Db2
  |
Buffer Pools
  |
Logs
  |
IRLM
  |
Storage

Quando você executa:

EXEC SQL
   SELECT NOME
     INTO :WS-NOME
     FROM CLIENTE
    WHERE CPF = :WS-CPF
END-EXEC.

existe muito mais acontecendo do que simplesmente “ler uma tabela”.

Temos otimização, concorrência, locks, buffers, logging, recuperação e access paths.

É por isso que compreender banco de dados não deveria significar apenas decorar SQL.

Precisamos compreender como o mecanismo atende ao workload.


27. O anti-pattern final: Resume-Driven Development

Existe um último monstro escondido nesta dungeon.

O desenvolvedor quer aprender tecnologia X.

Então encontra um problema que justifique tecnologia X.

PROBLEMA
   ↑
TECNOLOGIA

A ordem foi invertida.

Isso às vezes recebe o apelido de:

Resume-Driven Development.

Ou seja:

escolhemos aquilo que ficará bonito no currículo.

O currículo melhora.

A arquitetura talvez não.

😂


28. Passo a passo para escolher corretamente

Antes de aprovar um novo banco, faça este exercício.

Primeiro, descreva o problema sem mencionar nenhum produto:

Precisamos armazenar 200 milhões de eventos.

90% são escritas.

As consultas usam intervalos temporais.

Precisamos agregar por minuto/hora/dia.

Retenção de cinco anos.

Latência desejada abaixo de X.

Excelente.

Agora temos requisitos.

Segundo, descreva o access pattern.

Terceiro, determine requisitos de consistência.

Quarto, estime volume e crescimento.

Quinto, determine disponibilidade e recuperação.

Sexto, verifique tecnologias que a organização já possui.

Sétimo, compare alternativas.

Oitavo, faça benchmark representativo.

Nono, calcule custo operacional.

Décimo, somente então escolha o produto.

Essa ordem parece menos emocionante.

Mas produção costuma recompensar decisões menos emocionantes.


29. Às 04:12 finalmente encontramos o problema

Voltamos ao incidente.

Cinco bancos.

Vários microsserviços.

Dashboards piscando.

O arquiteto pergunta:

— Qual database está lento?

O programador COBOL responde:

— Nenhum.

— Como assim?

— O problema é sincronização.

Silêncio.

Db2 possui um estado.

Redis possui outro.

Elasticsearch ainda não recebeu determinado evento.

O warehouse recebeu uma carga incompleta.

E uma aplicação está consultando uma cópia acreditando ser a fonte oficial.

Não existia um problema de database.

Existia um problema de arquitetura de dados.

O velho programador toma outro gole de café.

— Então qual banco precisamos trocar?

Ele responde:

— Nenhum.

Talvez essa seja a resposta mais difícil de vender numa reunião de arquitetura.


Conclusão — o database começa na pergunta

A tecnologia moderna nos oferece uma quantidade extraordinária de opções:

Relational
Document
Key-Value
Graph
Search
Time-Series
Warehouse
Vector

Isso é fantástico.

Mas liberdade tecnológica também cria responsabilidade arquitetural.

Não existe database universal.

Também não existe obrigação de utilizar um banco diferente para cada característica da aplicação.

Ferramentas modernas inclusive cruzam fronteiras: PostgreSQL pode receber busca vetorial por meio do pgvector, enquanto Elasticsearch combina pesquisa textual, filtros, agregações e vetores. (GitHub)

Portanto, nossa sequência deveria ser:

PROBLEMA
   ↓
WORKLOAD
   ↓
ACCESS PATTERN
   ↓
CONSISTÊNCIA
   ↓
ESCALA
   ↓
DISPONIBILIDADE
   ↓
OPERAÇÃO
   ↓
CUSTO
   ↓
TECNOLOGIA

Nunca:

TECNOLOGIA DA MODA
        ↓
"Agora precisamos encontrar
 algum problema para ela."

E talvez seja essa a grande ironia.

Depois de MongoDB, Redis, Neo4j, Elasticsearch, Data Lakes, Lakehouses, NoSQL, NewSQL, cloud databases, time-series, embeddings, RAG e Vector Databases, chegamos novamente diante daquele veterano sentado no CPD.

Ele trabalhou com arquivos sequenciais.

Conheceu VSAM.

Conheceu IMS.

Aprendeu Db2.

Sobreviveu a milhares de COMMIT, alguns ROLLBACK, incontáveis JCLs e provavelmente um SQLCODE -911 numa sexta-feira.

Ele observa nosso maravilhoso diagrama arquitetural com oito databases, toma um gole do café já frio e faz a mesma pergunta que fazia décadas atrás:

“Muito bonito. Mas como você vai acessar o registro?”

E de repente toda a arquitetura moderna cabe nessa pergunta.

Porque ferramentas envelhecem.

Produtos mudam.

Nomes comerciais desaparecem.

Paradigmas voltam usando roupas novas.

Mas entender o problema antes de escolher a solução continua sendo uma das skills mais importantes que um programador pode aprender.

Easter egg final:

EVALUATE TRUE

   WHEN NEED-TRANSACTION
      PERFORM USE-RELATIONAL

   WHEN NEED-KEY-LOOKUP
      PERFORM USE-KEY-VALUE

   WHEN NEED-RELATIONSHIPS
      PERFORM USE-GRAPH

   WHEN NEED-SEARCH
      PERFORM USE-SEARCH

   WHEN NEED-SEMANTIC-SIMILARITY
      PERFORM USE-VECTOR

   WHEN OTHER
      DISPLAY
      "PERGUNTE PRIMEIRO QUAL E O PROBLEMA"

END-EVALUATE.

Só faltou uma cláusula:

WHEN ARCHITECT-SAYS
     "VAMOS USAR PORQUE TODO MUNDO USA"

     PERFORM MAKE-COFFEE
     PERFORM ASK-WHY
        UNTIL REQUIREMENT-FOUND


quarta-feira, 8 de junho de 2022

A Bússola de Ouro do System Design — Quando Lyra Entrou no Data Center, Igor Instalou Kubernetes e o Daemon do COBOL Descobriu que Complexidade Também Tem Poeira

 
Bellacosa Mainframe e o kubernetes encontrando o cobol

☕ Um Café no Bellacosa Mainframe

A Bússola de Ouro do System Design — Quando Lyra Entrou no Data Center, Igor Instalou Kubernetes e o Daemon do COBOL Descobriu que Complexidade Também Tem Poeira

Ou: um jovem padawan recebeu um servidor, um monólito e um banco SQL; atravessou a Faca Sutil dos microsserviços, encontrou Kafka entre dois mundos e aprendeu que o verdadeiro arquiteto não é quem instala todas as tecnologias, mas quem sabe quais portas jamais deveriam ser abertas



Prólogo — Há mais de um mundo dentro do data center

Imagine que você é um programador COBOL iniciante caminhando pelos corredores de um grande data center.

De um lado, encontra o mundo aparentemente sólido do mainframe: z/OS, CICS, Db2, IMS, VSAM, JCL, RACF, MQ e toneladas de transações passando silenciosamente por processadores que não precisam aparecer no LinkedIn a cada quinze minutos para provar que estão trabalhando.

Do outro, enxerga o mundo distribuído moderno: APIs, containers, Kubernetes, microsserviços, Redis, Kafka, MongoDB, GraphQL, Terraform, Prometheus, Grafana, service mesh e uma procissão de tecnologias com nomes que parecem demônios, constelações ou grupos de rock progressivo.

Entre esses mundos existe uma espécie de Faca Sutil: a arquitetura de sistemas.

Quando usada com inteligência, ela abre passagens úteis entre plataformas, equipes e aplicações. Quando usada sem experiência, corta fronteiras que deveriam permanecer inteiras, espalha dados por vinte serviços e deixa o operador de produção tentando descobrir em qual universo a transação desapareceu.

É essa a grande mensagem da discussão sobre System Design: a tecnologia moderna não tornou inúteis as soluções antigas. Ela apenas criou novas maneiras de distribuir responsabilidades — e, junto com elas, novas maneiras de distribuir problemas.

A série His Dark Materials, baseada na obra de Philip Pullman, acompanha Lyra Belacqua numa travessia por mundos conectados, autoridades que controlam o conhecimento, instrumentos cuja leitura exige experiência e uma misteriosa substância chamada Pó. A produção protagonizada por Dafne Keen adotou uma atmosfera mais sombria que a adaptação cinematográfica de 2007, contando também com nomes como James McAvoy, Ruth Wilson e Lin-Manuel Miranda. O roteiro ficou sob responsabilidade de Jack Thorne. 

Nossa Lyra, porém, não carregará apenas um aletiômetro.

Ela levará um dump, um diagrama de arquitetura e a recomendação mais importante do velho urso de armadura que trabalha no suporte:

“Antes de instalar qualquer coisa, descubra qual problema está tentando resolver.”



1. O aletiômetro da arquitetura

Em His Dark Materials, o aletiômetro parece uma bússola, mas não aponta simplesmente para o norte. Seus símbolos precisam ser interpretados em diferentes níveis. A pergunta correta é tão importante quanto a leitura do instrumento.

System Design funciona do mesmo modo.

Um arquiteto não começa perguntando:

  • Devemos usar Kubernetes?

  • Devemos criar microsserviços?

  • Kafka ou RabbitMQ?

  • MongoDB ou Cassandra?

  • REST, GraphQL ou gRPC?

  • Quantos clusters devemos criar?

Ele começa perguntando:

  • Qual problema de negócio estamos resolvendo?

  • Quantos usuários utilizarão o sistema?

  • Quantos estarão conectados simultaneamente?

  • Quantas transações ocorrerão por segundo?

  • Qual tempo de resposta é aceitável?

  • Quais dados não podem ser perdidos?

  • Quanto tempo o sistema pode ficar indisponível?

  • Quais partes precisam de consistência imediata?

  • O que acontecerá quando um componente falhar?

  • Quem operará tudo isso às três horas da manhã?

O programador inexperiente olha para o aletiômetro e vê símbolos.

O arquiteto experiente olha para os mesmos símbolos e procura relações.

Da mesma maneira, decorar nomes de tecnologias não transforma ninguém em arquiteto. É necessário compreender os problemas, os limites e os custos ocultos de cada escolha.

Kubernetes não é “melhor” que uma máquina virtual em todas as situações. Kafka não é “melhor” que IBM MQ em todos os fluxos. MongoDB não é uma evolução obrigatória do banco relacional. Microsserviços não representam automaticamente um estágio superior ao monólito.

Tecnologia sem contexto é apenas um símbolo sem interpretação.



2. O primeiro mundo: servidor, monólito e SQL

A caricatura do System Design antigo apresenta uma arquitetura muito simples:

Usuário
   ↓
Balanceador
   ↓
Aplicação monolítica
   ↓
Banco SQL

Essa organização foi — e continua sendo — suficiente para uma enorme quantidade de sistemas.

Em um monólito, os módulos da aplicação são construídos e implantados como uma unidade. Cadastro, pedidos, pagamentos, estoque e relatórios podem estar dentro do mesmo executável ou pacote de implantação.

Isso não significa necessariamente que o sistema seja mal projetado.

Um monólito pode ser:

  • dividido em módulos claros;

  • coberto por testes automatizados;

  • implantado por uma pipeline;

  • executado em várias instâncias;

  • protegido por um balanceador;

  • conectado a um banco replicado;

  • monitorado;

  • seguro;

  • rápido;

  • fácil de compreender.

O problema não é o monólito. O problema é o monólito sem fronteiras internas.

Para o programador COBOL, isso não deveria soar estranho. Um grande sistema COBOL pode ser organizado em:

  • programas principais;

  • subprogramas;

  • copybooks;

  • módulos de validação;

  • rotinas de acesso a dados;

  • componentes batch;

  • transações CICS;

  • chamadas a serviços;

  • filas MQ.

Tudo pode pertencer ao mesmo domínio sem precisar se transformar em cem serviços independentes.

O erro começa quando qualquer programa altera qualquer arquivo, todas as regras são duplicadas e ninguém sabe qual módulo é responsável pela verdade.

Um monólito bem estruturado é como Jordan College: parece uma instituição única vista de fora, mas possui bibliotecas, salões, dormitórios, cozinhas, autoridades e passagens internas com responsabilidades distintas.

Não é necessário transformar cada cômodo em um país soberano.



3. A primeira curiosidade: sistemas antigos nunca foram realmente simples

A ideia de que “antigamente era tudo simples” precisa ser examinada com cuidado.

Muito antes da nuvem, já existiam:

  • processamento distribuído;

  • clusters;

  • replicação;

  • filas;

  • escalonamento de workload;

  • controle de concorrência;

  • recuperação de falhas;

  • sistemas transacionais;

  • alta disponibilidade;

  • processamento paralelo;

  • redes complexas;

  • bancos particionados;

  • datacenters geograficamente separados.

O ecossistema mainframe já resolvia muitos desses problemas com tecnologias integradas.

NecessidadeRecurso no universo mainframe
Transações onlineCICS ou IMS
Banco relacionalDb2
Mensageria confiávelIBM MQ
Segurança centralizadaRACF
Gerenciamento de cargaWLM
Processamento assíncronoJES e batch
Alta disponibilidadeParallel Sysplex
Recuperação geográficaGDPS
Telemetria operacionalSMF, RMF e monitores
Integridade transacionalCommit, rollback e logs

A grande diferença é que parte dessa complexidade ficava escondida dentro de plataformas cuidadosamente integradas.

No mundo cloud-native, a empresa frequentemente monta sua própria plataforma escolhendo componentes separados.

É como se o mainframe entregasse uma grande cidade fortificada, enquanto o mundo distribuído entregasse madeira, pedras, ferramentas, cinquenta projetos open source e um vídeo de vinte minutos chamado “Construa sua cidade em produção sem downtime”.

Ambos podem produzir cidades magníficas.

Mas, no segundo caso, alguém precisa saber construir pontes, muralhas, esgotos e saídas de emergência.



4. A Faca Sutil dos microsserviços

Microsserviços dividem uma aplicação em serviços menores e independentes.

Uma loja digital poderia ser separada em:

  • serviço de clientes;

  • serviço de produtos;

  • serviço de pedidos;

  • serviço de estoque;

  • serviço de pagamentos;

  • serviço de entregas;

  • serviço de notificações.

Em teoria, cada serviço pode ser desenvolvido, implantado e escalado separadamente. Uma equipe altera pagamentos sem precisar republicar todo o sistema.

Parece maravilhoso.

E pode ser.

Mas a Faca Sutil possui dois lados.

Dentro de um monólito, registrar um pedido poderia acontecer numa única transação:

BEGIN;

INSERT INTO PEDIDO ...;
UPDATE ESTOQUE ...;
INSERT INTO PAGAMENTO ...;
INSERT INTO ENTREGA ...;

COMMIT;

Se algo falhar, executamos ROLLBACK.

Agora imagine que cada tabela pertence a um serviço e a um banco diferente.

O serviço de pedidos grava o pedido. O estoque reserva o produto. O pagamento autoriza o cartão. Entretanto, o serviço de entrega está indisponível.

O que devemos fazer?

  • Cancelar o pedido?

  • Liberar o estoque?

  • Estornar o pagamento?

  • Tentar a entrega novamente?

  • Aguardar numa fila?

  • Marcar a operação como incompleta?

  • Quem coordena tudo?

  • Como o suporte descobre o estado verdadeiro?

A transação local simples foi transformada num fluxo distribuído.

Podemos usar uma saga, na qual cada etapa possui uma ação compensatória:

Criar pedido
   ↓
Reservar estoque
   ↓
Autorizar pagamento
   ↓
Criar entrega

Se a criação da entrega falhar:

Cancelar autorização
   ↓
Liberar estoque
   ↓
Cancelar pedido

Porém, compensar não é voltar no tempo.

Se um e-mail de confirmação já foi enviado, não conseguimos “desenviá-lo”. Se o pagamento foi registrado numa rede externa, o estorno pode demorar. Se o último produto foi liberado, outro cliente pode comprá-lo antes da repetição.

Ao separar os serviços, não eliminamos a complexidade. Nós a transportamos para a rede.

Esse é um dos grandes easter eggs da arquitetura distribuída: toda porta aberta entre dois mundos cria também uma fronteira que precisa ser vigiada.



5. Os daemons e as responsabilidades dos serviços

Em His Dark Materials, cada pessoa possui um daemon, uma manifestação externa ligada à sua natureza. A distância entre ambos possui consequências.

Uma aplicação também possui extensões que revelam sua natureza:

  • banco de dados;

  • cache;

  • fila;

  • métricas;

  • logs;

  • certificados;

  • contratos de API;

  • arquivos de configuração;

  • políticas de segurança.

O erro é tratar esses componentes como criaturas independentes que podem ser abandonadas no ambiente.

Um microsserviço não é apenas seu código. Ele inclui tudo o que é necessário para que funcione e seja operado:

  • proprietário responsável;

  • pipeline de implantação;

  • banco ou armazenamento;

  • monitoramento;

  • alertas;

  • documentação;

  • política de backup;

  • estratégia de recuperação;

  • controle de versão da API;

  • tratamento de falhas;

  • limites de capacidade.

Se uma equipe cria quarenta serviços, criou também quarenta conjuntos de responsabilidades.

A pergunta não é apenas “conseguimos desenvolver?”.

É:

“Conseguimos viver com eles?”



6. Docker e Kubernetes: a armadura de Iorek Byrnison

Docker empacota a aplicação com suas dependências num container. Isso ajuda a reduzir o clássico incidente:

“Na minha máquina funciona.”

O container oferece um ambiente reproduzível. A mesma imagem pode ser executada no notebook, no teste e na produção, respeitadas as diferenças de configuração.

Mas containers precisam ser:

  • distribuídos;

  • iniciados;

  • reiniciados;

  • atualizados;

  • conectados;

  • monitorados;

  • limitados em CPU e memória;

  • protegidos;

  • substituídos quando falham.

É aí que Kubernetes entra.

Kubernetes funciona como uma grande estrutura de orquestração. Ele agenda containers, monitora sua execução, mantém o número desejado de réplicas e coordena atualizações.

Mas Kubernetes é uma armadura, não um urso.

A armadura de Iorek Byrnison amplia sua proteção, porém não substitui sua inteligência, experiência ou vontade. Da mesma maneira, Kubernetes não transforma automaticamente uma aplicação ruim em aplicação resiliente.

Ele pode:

  • reiniciar rapidamente um programa defeituoso;

  • criar vinte cópias de um serviço que sobrecarrega o banco;

  • distribuir uma configuração incorreta para o cluster inteiro;

  • declarar um container “vivo” enquanto o negócio está paralisado;

  • aumentar custos ao escalar pelo indicador errado.

Há uma diferença essencial entre:

O processo responde à verificação técnica.

e:

O cliente consegue concluir uma compra corretamente.

O primeiro é um teste de vitalidade.

O segundo exige compreender a saúde do negócio.

Dica do velho urso: se sua empresa possui duas aplicações simples, quatro desenvolvedores e nenhuma equipe de plataforma, talvez uma máquina virtual bem automatizada ou um serviço gerenciado seja mais apropriado que um cluster Kubernetes.

Não construa uma fortaleza no Ártico para guardar uma bicicleta.



7. Bancos de dados: diferentes mundos não obedecem às mesmas leis

PostgreSQL, MongoDB, Cassandra, Redis e Elasticsearch aparecem frequentemente no mesmo diagrama, como se uma arquitetura moderna precisasse coletar todos eles.

Não precisa.

PostgreSQL

É uma excelente escolha geral para sistemas que precisam de:

  • transações;

  • integridade;

  • relacionamentos;

  • SQL;

  • consultas variadas;

  • consistência.

Para enorme quantidade de projetos, começar com um banco relacional continua sendo sensato.

MongoDB

Armazena documentos e pode ser adequado quando os dados são naturalmente tratados como agregados, com estruturas flexíveis.

Mas “flexível” não significa “sem regra”. Se o banco não impõe parte do esquema, a aplicação precisa fazê-lo.

Cassandra

Foi criada para grande distribuição, alta disponibilidade e volumes expressivos de escrita. Sua modelagem começa pelas consultas que serão realizadas.

Não é um PostgreSQL com logotipo diferente.

Redis

Mantém estruturas rápidas em memória e é excelente para:

  • cache;

  • sessões;

  • contadores;

  • informações temporárias;

  • limitação de taxa;

  • coordenação simples.

Entretanto, velocidade não transforma automaticamente Redis no lugar correto para guardar a verdade financeira.

Elasticsearch

É poderoso para pesquisa textual, indexação e análise. Pode ser fantástico como mecanismo de busca e perigoso quando tratado descuidadamente como banco transacional principal.

Cada banco é um mundo com leis físicas diferentes.

A pergunta correta não é “qual está na moda?”, mas:

  • Como os dados serão consultados?

  • Precisamos de transações?

  • Qual volume será escrito?

  • Podemos tolerar dados temporariamente desatualizados?

  • Como faremos backup?

  • Quanto custará restaurar?

  • Nossa equipe sabe operar esse produto?

Backup não é o arquivo que o job afirma ter produzido.

Backup é aquilo que já demonstramos ser capaz de restaurar.



8. Redis e o Pó do cache

Cache guarda temporariamente dados utilizados com frequência.

Se milhares de pessoas consultam o mesmo produto, talvez não seja necessário buscar a informação no banco todas as vezes. Podemos armazená-la em Redis, numa CDN, no navegador ou na memória da aplicação.

Isso melhora o desempenho e reduz a carga.

Mas o cache, como o misterioso Pó, parece simples até começarmos a observar seu comportamento.

Quando o preço muda, como removemos a versão antiga?

Podemos utilizar:

  • prazo de expiração;

  • invalidação explícita;

  • atualização por evento;

  • política de escrita simultânea;

  • carregamento sob demanda.

Suponha que um produto custe R$100 e permaneça no cache durante uma hora. O banco é atualizado para R$80, mas o cache continua exibindo R$100.

O sistema está rápido.

E errado.

Em outro cenário, a promoção termina, mas o cache continua mostrando R$80. Agora o sistema está rápido, errado e juridicamente interessante.

Cache não é apenas desempenho. É uma negociação sobre por quanto tempo aceitamos que uma cópia fique desatualizada.



9. Kafka, RabbitMQ e as mensagens entre os mundos

Mensageria permite desacoplar produtores e consumidores.

O programa que produz uma informação não precisa esperar que todos os interessados terminem seu trabalho.

RabbitMQ

Funciona muito bem para:

  • filas de tarefas;

  • roteamento;

  • distribuição de trabalho;

  • confirmação de consumo;

  • entrega de mensagens.

Kafka

Funciona como um log distribuído e durável. Os eventos permanecem registrados por determinado período, permitindo que diferentes consumidores leiam e releiam o histórico.

Um evento chamado:

PAGAMENTO_AUTORIZADO

pode interessar a:

  • contabilidade;

  • antifraude;

  • programa de fidelidade;

  • notificações;

  • relatórios;

  • auditoria.

O produtor publica uma vez. Cada consumidor avança em seu próprio ritmo.

Mas surgem perguntas:

  • As mensagens precisam manter ordem?

  • Qual será a chave de particionamento?

  • O que acontecerá se o consumidor processar duas vezes?

  • Como mudaremos o formato do evento?

  • Quanto tempo o histórico ficará armazenado?

  • Como reprocessaremos milhões de eventos?

  • O que faremos com uma mensagem que sempre provoca erro?

Para um programador COBOL, IBM MQ oferece uma ponte conceitual importante. Colocar uma mensagem numa fila dentro da mesma unidade de trabalho permite coordenar banco e mensageria com garantias transacionais robustas.

O nome das ferramentas muda. A pergunta permanece:

“Como garantir que o trabalho não desapareça e não seja executado incorretamente duas vezes?”



10. O espectro do retry

Imagine que o sistema envie uma solicitação para cobrar R$500.

O serviço de pagamentos executa a cobrança, mas sua resposta se perde na rede.

O programa chamador recebe timeout.

Ele não sabe se o pagamento falhou. Sabe apenas que não recebeu uma resposta no prazo.

Igor decide tentar novamente.

O cliente é cobrado duas vezes.

Esse incidente ensina uma diferença vital:

Não recebi confirmação.

não significa:

A operação não aconteceu.

Operações críticas precisam ser idempotentes. Isso significa que repetir a mesma solicitação não deve repetir seu efeito.

Uma solução é enviar uma chave única:

IDEMPOTENCY-KEY: PEDIDO-2026-000184

O serviço verifica se essa operação já foi processada. Se já foi, retorna o resultado anterior sem cobrar novamente.

Retries também precisam de:

  • limite;

  • intervalo crescente;

  • jitter;

  • timeout total;

  • circuit breaker;

  • fila de exceção;

  • reconciliação.

Sem controle, retries viram espectros: quanto mais o sistema sofre, mais requisições retornam para assombrá-lo.



11. Consistência: uma verdade pode chegar atrasada?

Nem todos os dados precisam estar atualizados no mesmo instante.

Uma contagem de visualizações pode aparecer alguns segundos depois. Um ranking pode ser recalculado a cada minuto.

Mas alguns dados exigem decisão imediata:

  • saldo bancário;

  • limite de crédito;

  • último assento disponível;

  • alteração de senha;

  • autorização de pagamento;

  • concessão de permissão;

  • estoque de um item único.

Se duas pessoas tentarem comprar o último ingresso, o sistema precisa impedir que ambas se tornem proprietárias do mesmo assento.

Isso é consistência forte.

Já a consistência eventual aceita que diferentes cópias se alinhem depois de algum tempo.

O erro está nos extremos:

  • exigir consistência forte para tudo, sacrificando desempenho e disponibilidade;

  • aceitar consistência eventual onde o negócio exige uma única verdade imediata.

No mundo distribuído, às vezes dois observadores enxergam estados diferentes. A arquitetura precisa determinar quando isso é aceitável e quando representa um ABEND do negócio.



12. Observabilidade: o aletiômetro de produção

Num monólito, seguir uma operação costuma ser relativamente direto.

Num ambiente distribuído, uma requisição pode atravessar:

API Gateway
   ↓
Serviço de Pedidos
   ↓
Serviço de Clientes
   ↓
Serviço de Estoque
   ↓
Serviço de Pagamentos
   ↓
Antifraude externo

Se a resposta demorar oito segundos, onde está o problema?

Pode ser:

  • DNS;

  • rede;

  • certificado;

  • pool de conexões;

  • banco;

  • fila;

  • retry;

  • lock;

  • serviço externo;

  • falta de CPU;

  • pausa de garbage collection.

Por isso precisamos de observabilidade.

Métricas

Mostram números ao longo do tempo:

  • CPU;

  • memória;

  • latência;

  • erros;

  • filas;

  • transações por segundo.

Logs

Registram eventos específicos:

  • pedido recebido;

  • pagamento negado;

  • exceção;

  • timeout;

  • usuário autenticado.

Traces

Acompanham uma mesma requisição através de vários serviços.

Perfis

Mostram onde o programa consome CPU, memória ou tempo.

Prometheus coleta métricas. Grafana as apresenta. Ferramentas de tracing acompanham operações distribuídas.

Mas uma parede com cinquenta dashboards não significa que alguém compreenda o sistema.

Um bom painel responde a perguntas operacionais. Um bom alerta exige ação. Um log útil contém contexto suficiente para investigação.

O aletiômetro de produção só funciona quando sabemos formular a pergunta.



13. Sharding: cortar o banco com a Faca Sutil

Sharding divide os dados entre servidores.

Por exemplo:

Clientes A–F → Shard 1
Clientes G–M → Shard 2
Clientes N–Z → Shard 3

Ou:

SHARD = HASH(CLIENTE-ID) MOD 4

Isso pode permitir que o sistema armazene e processe mais dados do que um único servidor comportaria.

Mas surgem novos desafios:

  • consultas entre shards;

  • transações distribuídas;

  • rebalanceamento;

  • clientes concentrados num único shard;

  • relatórios globais;

  • restauração;

  • mudança da quantidade de shards.

Antes de aplicar sharding, verifique:

  1. As consultas possuem índices corretos?

  2. Existem leituras desnecessárias?

  3. Dados históricos podem ser arquivados?

  4. O banco pode crescer verticalmente?

  5. Réplicas de leitura ajudariam?

  6. Cache reduziria a pressão?

  7. Particionamento interno seria suficiente?

  8. O gargalo foi realmente medido?

Sharding prematuro é usar a Faca Sutil para abrir uma passagem antes de saber o que existe do outro lado.


14. Auto scaling e o exército que chega tarde

Auto scaling cria ou remove instâncias conforme a carga.

Parece simples:

CPU alta → criar servidores
CPU baixa → remover servidores

Entretanto, a CPU talvez não represente o problema real.

Um consumidor pode ter CPU baixa e milhões de mensagens atrasadas. Uma aplicação pode aumentar para cinquenta réplicas e criar dez mil conexões contra o mesmo banco.

A camada da aplicação cresce, mas o banco continua único.

O gargalo apenas muda de endereço.

Métricas melhores podem incluir:

  • tamanho da fila;

  • atraso do consumidor;

  • requisições por segundo;

  • latência;

  • número de workers ocupados;

  • conexões disponíveis;

  • tempo restante para cumprir um SLA.

Escalar também leva tempo. Se uma instância demora cinco minutos para inicializar, talvez chegue depois do pico.

Auto scaling não cria capacidade infinita. Ele administra capacidade disponível dentro de limites técnicos e financeiros.



15. Disponibilidade e o preço dos noves

Dizer “o sistema precisa ficar sempre disponível” é fácil.

Transformar isso num requisito mensurável é mais difícil.

Aproximadamente:

DisponibilidadeIndisponibilidade mensal permitida
99%7 horas e 18 minutos
99,9%43 minutos
99,99%4 minutos e 23 segundos
99,999%26 segundos

Cada nove adicional exige investimentos em:

  • redundância;

  • replicação;

  • automação;

  • testes;

  • failover;

  • observabilidade;

  • pessoas;

  • recuperação;

  • eliminação de pontos únicos de falha.

Duas instâncias não garantem alta disponibilidade se ambas dependem:

  • do mesmo banco;

  • da mesma região;

  • do mesmo provedor;

  • do mesmo certificado;

  • da mesma configuração defeituosa.

Dois mundos podem cair juntos quando a mesma autoridade controla os dois.

Eis outro easter egg do Magisterium: centralizar poder pode simplificar a administração, mas também amplia o impacto de uma decisão errada.



16. Passo a passo do jovem padawan COBOL

Ao receber um novo projeto, não comece desenhando trinta caixas.

Passo 1 — Entenda o negócio

Descubra:

  • quem usa;

  • qual problema resolve;

  • quais operações são críticas;

  • quanto custa uma falha;

  • quais leis e auditorias se aplicam.

Passo 2 — Estime a carga

Calcule:

  • usuários ativos;

  • simultaneidade;

  • transações por segundo;

  • picos;

  • tamanho dos dados;

  • crescimento.

Passo 3 — Classifique os dados

Pergunte:

  • Qual é a fonte da verdade?

  • O que exige transação?

  • O que pode ser cacheado?

  • O que pode ficar temporariamente desatualizado?

  • Por quanto tempo deve ser preservado?

Passo 4 — Desenhe a solução mínima

Comece, se possível, com:

  • aplicação modular;

  • banco relacional;

  • balanceamento;

  • armazenamento de objetos;

  • backup;

  • monitoramento.

Passo 5 — Identifique gargalos reais

Meça antes de otimizar:

  • CPU;

  • memória;

  • I/O;

  • locks;

  • consultas lentas;

  • conexões;

  • filas;

  • latência externa.

Passo 6 — Adicione componentes por evidência

Use cache quando houver leituras repetidas.

Use fila quando o trabalho puder ser assíncrono.

Extraia um microsserviço quando houver fronteira clara e necessidade de independência.

Use Kubernetes quando o volume de workloads justificar uma plataforma.

Aplique sharding quando um banco corretamente otimizado realmente atingir seus limites.

Passo 7 — Projete a falha

Para cada componente, pergunte:

“O que acontece quando ele para?”

Depois pergunte:

“Como descobriremos?”

E finalmente:

“Como recuperaremos?”

Passo 8 — Teste a recuperação

Restaure backups.

Simule indisponibilidade.

Valide timeouts.

Interrompa consumidores.

Teste mensagens duplicadas.

Confirme que os procedimentos funcionam sem depender da memória de Igor.

Passo 9 — Documente decisões

Registre:

  • contexto;

  • alternativas;

  • decisão;

  • motivos;

  • riscos;

  • momento de revisão.

Passo 10 — Preserve o direito de simplificar

Arquitetura também é remoção.

Se um componente deixou de justificar seu custo, aposente-o.



17. Curiosidades escondidas entre os mundos

“Daemon” já existia na computação

Em sistemas Unix, um daemon é um processo executado em segundo plano, frequentemente prestando algum serviço. O termo ganhou uso computacional muito antes da série televisiva e possui raízes conceituais distintas dos companheiros animais de Pullman.

Portanto, se o sysadmin disser que “o daemon morreu”, não procure um animal ferido no corredor. Consulte o log.

Muitos conceitos modernos são antigos com novas interfaces

Filas, isolamento, escalonamento, replicação, controle de acesso e telemetria não nasceram na era dos containers.

A inovação frequentemente está na maneira como esses recursos são empacotados, automatizados, distribuídos e consumidos.

O monólito pode escalar horizontalmente

Monólito não significa servidor único. Se a aplicação for adequadamente projetada, múltiplas instâncias podem atender usuários através de um balanceador.

A rede sempre pode falhar

Dentro do mesmo processo, uma chamada de função é relativamente previsível. Entre serviços, precisamos considerar:

  • latência;

  • perda;

  • duplicação;

  • timeout;

  • indisponibilidade;

  • respostas fora de ordem.

Toda chamada remota é uma aposta controlada.

“Exatamente uma vez” precisa de contexto

Sistemas reais costumam combinar entrega, persistência e idempotência para produzir o efeito de negócio desejado.

Confiar apenas num slogan de “exactly once” é perigoso. O mundo externo — cartão, e-mail, transportadora — talvez não participe da mesma garantia.



Epílogo — A autoridade tentou proibir a simplicidade

No fim da viagem, Lyra Bellacosa chega à sala principal da arquitetura.

Sobre a mesa estão:

  • API Gateway;

  • CDN;

  • Kubernetes;

  • service mesh;

  • Redis;

  • PostgreSQL;

  • MongoDB;

  • Cassandra;

  • Kafka;

  • RabbitMQ;

  • gRPC;

  • WebSockets;

  • GraphQL;

  • Elasticsearch;

  • Terraform;

  • Prometheus;

  • Grafana.

Igor sorri e pergunta:

— Instalamos tudo?

O daemon do COBOL observa o diagrama, consulta o aletiômetro e responde:

— Quantos usuários?

Igor hesita:

— Cento e vinte.

— Quantas transações por segundo?

— Talvez três.

— Quantas pessoas na equipe?

— Quatro, contando o estagiário que ainda não recebeu acesso.

O velho urso de armadura fecha a caixa de ferramentas.

A equipe escolhe uma aplicação modular, PostgreSQL, armazenamento de objetos, backup testado, métricas básicas e uma pipeline de implantação.

Não porque desconhece o restante.

Mas porque conhece.

Essa é a diferença entre simplicidade e ignorância. O ignorante usa pouco porque não conhece alternativas. O arquiteto maduro usa pouco porque compreende o preço das alternativas.

System Design não é uma competição para preencher diagramas.

É a disciplina de escolher a quantidade de complexidade que o problema merece — nem menos, deixando riscos escondidos, nem mais, criando uma máquina que ninguém consegue operar.

O programador COBOL iniciante não precisa temer o mundo moderno. Grande parte dele responde às mesmas perguntas que CICS, Db2, MQ, RACF, WLM e os sistemas transacionais enfrentam há décadas:

  • Como receber trabalho?

  • Como proteger dados?

  • Como coordenar operações?

  • Como suportar falhas?

  • Como recuperar?

  • Como provar o que aconteceu?

  • Como crescer sem destruir o que já funciona?

Mudam os nomes. Mudam as interfaces. Mudam os mapas.

As leis fundamentais continuam reconhecíveis.

E, quando alguém apresentar uma arquitetura com quarenta componentes para resolver um problema que ainda não possui quarenta usuários, segure firmemente sua Bússola de Ouro e faça a pergunta que atravessa todos os mundos:

“Qual problema real justifica cada uma dessas caixas?”

Se ninguém souber responder, não estamos diante de arquitetura.

Estamos diante de uma coleção de tecnologias vestida com uma armadura que não lhe pertence.





quarta-feira, 23 de fevereiro de 2022

SQL versus NoSQL: A Guerra que Nunca Existiu (e por que todo Programador COBOL deveria entender os dois)

 

Bellacosa Mainframe numa guerra que nunca existiu sql versus nosql

☕ Um Café no Bellacosa Mainframe

SQL versus NoSQL: A Guerra que Nunca Existiu (e por que todo Programador COBOL deveria entender os dois)

"A tecnologia muda. Os princípios permanecem."

Imagine que você acabou de entrar em uma grande empresa. É seu primeiro emprego como programador COBOL. Você acabou de aprender JCL, já conseguiu fazer seu primeiro programa rodar no z/OS, descobriu o que é um Job, um Dataset e finalmente conseguiu fazer um SELECT sem esquecer o END-EXEC.

Então alguém da equipe comenta durante uma reunião:

"Estamos integrando o Mainframe com MongoDB."

Cinco minutos depois outro colega fala:

"Os dados vão para Redis."

Na sequência o arquiteto comenta:

"O Neo4j será usado para análise de fraude."

Você pensa:

"Mas... eu aprendi SQL... o que aconteceu? Agora existem quatro bancos diferentes?"

Bem-vindo ao desenvolvimento moderno.

Hoje vamos conversar sobre uma das maiores dúvidas de quem está começando:

SQL ou NoSQL?

Spoiler...

A resposta é muito diferente do que a internet costuma vender.

Pegue seu café.

Vamos conversar.


O mito da guerra

Existe uma narrativa que aparece em vídeos, blogs e redes sociais dizendo que:

SQL morreu.

Ou então:

NoSQL veio substituir os bancos relacionais.

Nada poderia estar mais distante da realidade.

Na verdade, SQL nunca esteve tão vivo.

E NoSQL nunca tentou matá-lo.

Os dois nasceram para resolver problemas completamente diferentes.

É como comparar:

  • um caminhão

  • um avião

Qual é melhor?

Depende.

Você quer transportar cimento entre cidades?

Ou cruzar o oceano?

A pergunta está errada.

Da mesma forma:

A pergunta nunca foi SQL versus NoSQL.

A pergunta correta sempre foi:

Qual tecnologia resolve melhor ESTE problema?


Uma pequena viagem no tempo

Imagine que estamos em 1970.

Os computadores ocupavam salas inteiras.

Não existia internet.

Não existia smartphone.

Nem notebook.

Muito menos Cloud.

Os bancos de dados funcionavam quase como arquivos gigantes.

Era preciso conhecer exatamente onde cada informação estava gravada.

Era complicado.

Foi então que um pesquisador da IBM chamado Edgar Frank Codd publicou um artigo que mudaria para sempre a computação:

A Relational Model of Data for Large Shared Data Banks

Esse trabalho apresentou uma ideia brilhante.

Em vez de pensar em ponteiros físicos...

Vamos pensar em relações.

Assim nasceram:

  • tabelas

  • linhas

  • colunas

  • chaves

  • relacionamentos

Nascia o Modelo Relacional.

Poucos anos depois, a própria IBM desenvolveu o System R, um projeto experimental que introduziu a linguagem SQL (Structured Query Language). A ideia mostrou tanto potencial que outras empresas passaram a investir no modelo, surgindo plataformas como Oracle, Informix, SQL Server, PostgreSQL, MySQL e, naturalmente, o Db2, um dos pilares do universo IBM Mainframe.


Por que o SQL fez tanto sucesso?

Porque ele resolveu um problema gigantesco.

Imagine um banco.

Existem milhões de clientes.

Cada cliente possui:

  • conta corrente

  • poupança

  • investimentos

  • cartões

  • empréstimos

Tudo isso precisa estar relacionado.

Se João mudar de endereço...

Não faz sentido atualizar vinte lugares diferentes.

O SQL organiza essas informações em tabelas relacionadas, reduzindo redundâncias e garantindo consistência.

Esse conceito recebe o nome de normalização.

Parece um detalhe.

Na prática...

Economizou bilhões de dólares em armazenamento ao longo da história.


ACID: o superpoder invisível

Existe um conceito que todo programador júnior deveria decorar.

ACID.

Não porque cai em entrevista.

Mas porque explica por que bancos confiam tanto em SQL.

Imagine transferir R$ 500 de uma conta para outra.

São duas operações:

  • retirar da Conta A

  • adicionar na Conta B

E se faltar energia exatamente no meio?

ACID garante que isso não aconteça.

Ou tudo acontece...

Ou nada acontece.

Isso é chamado de Atomicidade.

Depois temos:

Consistência

Os dados permanecem válidos.

Isolamento

Milhares de pessoas podem operar simultaneamente sem "atropelar" umas às outras.

Durabilidade

Depois do COMMIT...

Mesmo que o servidor desligue...

Os dados continuam lá.

É por isso que bancos, seguradoras e bolsas de valores continuam confiando em bancos relacionais.


Onde entra o Mainframe?

Agora vem uma curiosidade que muita gente desconhece.

Grande parte do dinheiro que circula diariamente no mundo passa por Mainframes.

Cartões.

PIX.

TED.

DOC.

Compras internacionais.

Folha de pagamento.

Seguros.

Tudo isso frequentemente passa por sistemas COBOL utilizando Db2 for z/OS.

Quando você escreve:

EXEC SQL

SELECT SALDO

INTO :WS-SALDO

FROM CONTAS

WHERE NUMERO = :WS-CONTA

END-EXEC.

O SQL não está apenas buscando dados.

Existe todo um universo trabalhando por trás:

  • Pré-compilador SQL

  • DBRM

  • Package

  • Bind

  • Plan

  • Otimizador

  • Buffer Pools

  • Logging

  • Locking

  • Recovery

O desenvolvedor enxerga apenas a ponta do iceberg.


Então por que surgiu o NoSQL?

Porque o mundo mudou.

Muito.

Em 1970 ninguém imaginava redes sociais.

Nem streaming.

Nem IoT.

Nem celulares.

Nem milhões de fotos por minuto.

Agora imagine armazenar:

  • vídeos

  • comentários

  • curtidas

  • localização

  • mensagens

  • sensores

  • documentos JSON

Tudo isso em tabelas relacionais.

Funciona?

Sim.

Mas nem sempre é a melhor escolha.

Foi então que surgiu o movimento NoSQL.

Curiosamente...

NoSQL não significa "Sem SQL".

Significa:

Not Only SQL

Ou seja...

Existem outros modelos além do relacional.


Os quatro reinos do NoSQL

Quando alguém diz "NoSQL", na verdade está falando de uma família inteira de bancos.

📄 Documento

Exemplo:

MongoDB.

Os dados ficam parecidos com JSON.

Cada documento pode possuir uma estrutura diferente.

Perfeito para aplicações web.


🔑 Chave-Valor

Exemplo:

Redis.

Imagine um gigantesco dicionário.

Você fornece uma chave.

Recebe um valor.

Extremamente rápido.

Muito utilizado como cache.


📚 Colunar

Exemplos:

Cassandra.

ScyllaDB.

HBase.

Projetados para trabalhar com enormes volumes distribuídos.

Muito utilizados em Big Data.


🌐 Grafos

Exemplo:

Neo4j.

Aqui o importante não são os registros.

São os relacionamentos.

Quem conhece quem?

Quem comprou junto?

Quem transferiu dinheiro para quem?

Ideal para detectar fraudes.


SQL é rígido?

Sim.

E isso é uma vantagem.

Imagine um cadastro de funcionários.

Todos possuem:

  • matrícula

  • nome

  • salário

  • departamento

É ótimo exigir que todos tenham exatamente a mesma estrutura.

Já em uma rede social...

Cada usuário pode possuir informações diferentes.

Uns possuem Instagram.

Outros TikTok.

Outros LinkedIn.

Outros nenhum.

Forçar uma estrutura única pode ser desnecessário.

É aí que bancos orientados a documentos brilham.


Escalabilidade

Existe outra diferença importante.

Tradicionalmente, bancos SQL cresceram na vertical.

Mais CPU.

Mais memória.

Mais discos.

Servidor maior.

Já muitos bancos NoSQL foram desenhados pensando em crescer horizontalmente.

Mais servidores.

Mais nós.

Mais máquinas.

É o modelo utilizado por empresas como Google, Amazon, Netflix e Meta.

Mas atenção: hoje essa divisão não é absoluta. Bancos relacionais modernos também oferecem mecanismos de escalabilidade horizontal, e diversas soluções NoSQL implementam recursos avançados de consistência e transações.


SQL também evoluiu

Existe outro mito.

"O SQL parou no tempo."

Errado.

Hoje temos:

  • JSON dentro do PostgreSQL

  • JSON no Oracle

  • JSON no SQL Server

  • JSON no Db2

  • XML

  • Graph Extensions

  • Machine Learning integrado

  • Consultas analíticas

  • Window Functions

  • Compressão avançada

  • IA auxiliando otimização

Os bancos relacionais modernos absorveram diversas características que antes eram exclusivas do NoSQL.


NoSQL também evoluiu

MongoDB hoje possui:

  • transações

  • índices sofisticados

  • agregações complexas

Redis deixou de ser apenas cache.

Neo4j suporta consultas extremamente sofisticadas.

Cassandra possui consistência configurável.

Ou seja...

Os mundos estão convergindo.


O conceito mais importante: Polyglot Persistence

Se existe uma expressão que todo desenvolvedor moderno deveria conhecer é esta:

Polyglot Persistence.

Ela significa:

usar o banco certo para cada problema.

Imagine um banco digital.

Ele pode utilizar:

Db2 → contas correntes

MongoDB → documentos

Redis → cache

Neo4j → fraude

Elastic → pesquisa

Banco Vetorial → IA

Tudo funcionando junto.

Não existe regra dizendo que um sistema deve possuir apenas um banco.


O papel do COBOL nessa história

Aqui existe um enorme equívoco.

Muitos imaginam que COBOL só conversa com Db2.

Hoje isso está longe da realidade.

Aplicações COBOL podem consumir:

REST APIs.

MQ.

Kafka.

gRPC.

z/OS Connect.

Eventos.

Microsserviços.

E esses serviços podem acessar MongoDB, Redis ou qualquer outro banco moderno.

O COBOL continua sendo o cérebro transacional.

Os demais componentes ampliam suas capacidades.


Dicas para quem está começando

Se eu pudesse aconselhar um programador júnior, seguiria esta ordem:

  1. Aprenda modelagem de dados.

  2. Domine SQL.

  3. Entenda normalização.

  4. Aprenda índices.

  5. Estude planos de acesso.

  6. Descubra como funciona um otimizador.

  7. Aprenda transações.

  8. Depois estude MongoDB.

  9. Conheça Redis.

  10. Descubra Neo4j.

  11. Aprenda APIs REST.

  12. Entenda eventos e mensageria.

A tecnologia muda.

Os fundamentos permanecem.


Curiosidades que pouca gente conhece

☕ O primeiro grande projeto SQL da IBM chamava-se System R.

☕ O Db2 nasceu dentro da IBM justamente para materializar as ideias do modelo relacional em ambientes corporativos.

☕ O comando SELECT * é um dos mais utilizados por iniciantes... e um dos menos recomendados em produção. Buscar apenas as colunas necessárias reduz tráfego de dados e melhora o desempenho.

☕ Muitos sistemas bancários escritos há mais de 30 anos continuam processando milhões de transações diariamente com desempenho impressionante.

☕ Redis consegue responder consultas em microssegundos porque mantém os dados principalmente em memória.

☕ Neo4j foi inspirado na Teoria dos Grafos, um ramo da matemática muito mais antigo do que os computadores.

☕ Diversos bancos NoSQL utilizam conceitos publicados em artigos científicos da Google e da Amazon sobre sistemas distribuídos, como Bigtable, Dynamo e MapReduce.

☕ O termo NoSQL surgiu como um movimento alternativo, mas acabou sendo reinterpretado como Not Only SQL, refletindo melhor a realidade atual.


Easter Eggs Bellacosa Mainframe 🥚

🔍 Easter Egg #1 – O herói invisível

Sempre que você executa um SELECT no Db2, existe um componente trabalhando silenciosamente para decidir o melhor caminho de acesso: o otimizador de consultas. Ele é como o GPS do banco de dados. Você não o vê, mas ele escolhe a rota mais eficiente.


🥚 Easter Egg #2 – O COBOL nunca pergunta "como"

Um programa COBOL com Embedded SQL apenas descreve o que deseja. Quem decide como buscar os dados é o Db2. Essa separação entre intenção e estratégia foi uma das grandes revoluções introduzidas pelo SQL.


🥚 Easter Egg #3 – O Mainframe conversa com o futuro

Um programa COBOL criado na década de 1990 pode, com poucas adaptações, consumir uma API REST hospedada na nuvem que, por sua vez, grava documentos em MongoDB e publica eventos em Kafka. O legado não é um obstáculo: ele pode ser parte da arquitetura moderna.


🥚 Easter Egg #4 – Nem tudo é tabela

Quando você olhar para uma árvore genealógica, uma rede social ou um mapa de rotas aéreas, pense em grafos. Quando observar um catálogo de produtos com atributos diferentes para cada item, pense em documentos. Quando acessar seu extrato bancário, pense em tabelas relacionais. O segredo está em reconhecer o problema antes de escolher a ferramenta.


Conclusão

No fim das contas, SQL e NoSQL não são adversários. São aliados que nasceram em épocas diferentes para enfrentar desafios distintos. O SQL continua sendo o alicerce dos sistemas críticos que exigem consistência, integridade e confiabilidade — exatamente o tipo de ambiente onde o IBM Z e o Db2 brilham há décadas. Já o NoSQL oferece flexibilidade, escalabilidade e modelos especializados que complementam essas capacidades em aplicações modernas, distribuídas e orientadas a dados.

Se você está iniciando sua jornada como programador COBOL ou desenvolvedor Mainframe, não caia na armadilha dos modismos. Aprenda primeiro os fundamentos: modelagem de dados, SQL, índices, transações e otimização de consultas. Esses conhecimentos acompanharão toda a sua carreira. Depois, expanda seus horizontes estudando MongoDB, Redis, Cassandra, Neo4j e outras tecnologias que fazem parte das arquiteturas atuais.

Lembre-se sempre de uma filosofia muito presente no universo Bellacosa Mainframe:

Um excelente desenvolvedor não é aquele que conhece todas as ferramentas, mas aquele que sabe exatamente quando usar cada uma delas.

No mundo do IBM Z, onde convivem sistemas escritos há décadas com APIs, microsserviços, inteligência artificial e computação em nuvem, essa capacidade de escolher a tecnologia certa é o que transforma um programador júnior em um verdadeiro arquiteto de soluções. Afinal, o futuro não pertence ao SQL nem ao NoSQL. Ele pertence aos profissionais que compreendem ambos e conseguem fazê-los trabalhar juntos.


Vagner Renato Bellacosa, IBM Champion e especialista em IBM Mainframe
IBM Z17 SYSTEM ONLINE
Sobre o autor

Vagner Renato Bellacosa

IBM Champion 2026 • Especialista em IBM Mainframe

Vagner Renato Bellacosa trabalha com IBM Mainframe desde 1988 , é IBM Champion e especialista em COBOL, CICS, Db2, z/OS e IBM Z. Compartilha experiências profissionais, conhecimento técnico, história da computação e práticas do universo mainframe para aproximar novas gerações das tecnologias que sustentam empresas, bancos e governos ao redor do mundo.

IBM Champion IBM Z COBOL CICS Db2 z/OS Mainframe desde 1988
GitHub LinkedIn
Inicializando conteúdo...