☕ 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 gRPC. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta gRPC. Mostrar todas as mensagens

quinta-feira, 23 de novembro de 2023

APIs sem Mistérios : O Guia Definitivo do Programador COBOL Padawan para Entender Como o IBM Z Conversa com o Mundo Moderno

 

Bellacosa Mainframe em apis sem misterios

☕ Um Café no Bellacosa Mainframe

APIs sem Mistérios

O Guia Definitivo do Programador COBOL Padawan para Entender Como o IBM Z Conversa com o Mundo Moderno

"A comunicação é a essência da cooperação. Uma tecnologia isolada possui pouco valor. Sistemas que conversam mudam o mundo."

— Dr. Spock (adaptado ao universo Bellacosa Mainframe)


Introdução – Quando o Padawan Descobre que o Mundo Não Vive Apenas de Arquivos Sequenciais

Existe um momento curioso na vida de praticamente todo programador COBOL.

Durante meses ele aprende:

  • JCL

  • VSAM

  • Db2

  • CICS

  • IMS

  • SORT

  • IDCAMS

  • MQ

  • TSO

  • ISPF

Tudo parece fazer sentido.

Até que um dia alguém chega perto de sua mesa e diz:

"Precisamos expor esse programa COBOL como uma API REST."

Logo em seguida aparece outra pessoa:

"O aplicativo mobile quer consumir via GraphQL."

Cinco minutos depois:

"O pessoal da IoT vai mandar dados usando MQTT."

Mais tarde:

"O pessoal da arquitetura decidiu migrar tudo para Event Driven Architecture."

Nesse momento, o Padawan olha para sua tela 3270, respira fundo e pensa:

"Será que entrei na nave errada?"

A resposta é simples.

Não.

Na verdade, você acabou de descobrir que o IBM Z nunca deixou de evoluir.

O COBOL continua processando bilhões de transações diariamente.

O que mudou foi a maneira como o restante do mundo conversa com ele.

Hoje não basta apenas executar um programa.

É preciso fazê-lo conversar com:

  • aplicativos móveis;

  • sistemas web;

  • microsserviços;

  • inteligência artificial;

  • sensores industriais;

  • plataformas em nuvem;

  • robôs;

  • bancos;

  • marketplaces;

  • parceiros comerciais.

E tudo isso acontece através das famosas APIs e protocolos de integração.

Pegue sua caneca de café.

Hoje faremos uma viagem digna da USS Enterprise para descobrir como todos esses mundos se conectam.


Antes de tudo…

API não é protocolo.

Essa é uma das maiores confusões da computação.

Muitas pessoas dizem:

"Qual protocolo de API você usa?"

Na realidade, misturam três conceitos diferentes.

Protocolos

São as regras de comunicação.

Exemplos:

  • HTTP

  • MQTT

  • AMQP

  • CoAP

  • XMPP

  • OPC-UA


Arquiteturas

Definem como organizar os sistemas.

Exemplos:

  • REST

  • Event Driven Architecture (EDA)


Linguagens

Definem como fazer consultas.

Exemplo:

  • GraphQL


Frameworks RPC

Automatizam chamadas remotas.

Exemplos:

  • gRPC

  • Apache Thrift


Padrões

Definem maneiras de integração.

Exemplos:

  • Webhooks

  • EDI

Essa distinção é extremamente importante.

Um arquiteto de software sabe exatamente qual dessas ferramentas resolve determinado problema.


A História da Comunicação Entre Sistemas

Vamos voltar algumas décadas.

Imagine um grande CPD IBM.

Tudo era assim.

Programa COBOL

↓

Arquivo Sequencial

↓

Outro programa COBOL

↓

Relatório

Não existia internet.

Não existia JSON.

Não existia XML.

Muito menos APIs.

Os sistemas trocavam informações através de:

  • fitas magnéticas;

  • cartões perfurados;

  • arquivos VSAM;

  • arquivos QSAM;

  • EDI;

  • filas MQ (mais tarde).

Era extremamente eficiente.

Até hoje muitos bancos funcionam exatamente assim.


A Primeira Grande Revolução

Com o surgimento da Internet nasceu uma nova necessidade.

Ao invés de trocar arquivos uma vez por dia…

…os sistemas precisavam conversar em segundos.

Assim nasceu o modelo Request/Response.

Cliente

↓

Servidor

↓

Resposta

Esse paradigma mudou completamente a computação.


REST — O Idioma Universal das APIs

REST significa:

Representational State Transfer.

Criado por Roy Fielding em sua tese de doutorado em 2000.

Curiosamente…

REST não é um protocolo.

Ele apenas utiliza HTTP.

Imagine um restaurante.

Você faz um pedido.

Cliente

↓

Garçom

↓

Cozinha

↓

Resposta

É exatamente isso que acontece.

GET /clientes/100

Resposta

{
 "id":100,
 "nome":"Maria"
}

Tudo extremamente simples.


Métodos HTTP

O Padawan precisa decorar apenas cinco verbos.

GET

Buscar.

POST

Criar.

PUT

Atualizar tudo.

PATCH

Atualizar parcialmente.

DELETE

Excluir.


No mundo Mainframe

Hoje um programa COBOL pode virar uma API REST utilizando:

  • z/OS Connect EE

  • CICS

  • IMS

  • Java

  • Liberty

Sem alterar praticamente nada da lógica de negócio.

Essa talvez seja uma das maiores revoluções do IBM Z.


SOAP — O Cavaleiro Jedi Corporativo

Antes do REST dominar o planeta…

SOAP reinava absoluto.

Tudo era XML.

Exemplo.

<Envelope>

<Body>

<GetCustomer/>

</Body>

</Envelope>

Parece enorme.

E realmente é.

Mas SOAP possui poderes que REST não possui naturalmente.

Entre eles:

  • assinatura digital;

  • segurança WS-Security;

  • transações;

  • confiabilidade;

  • contratos extremamente rígidos.

Por isso bancos ainda utilizam SOAP em larga escala.


GraphQL — O Cliente Decide

Imagine pedir uma pizza.

REST entrega:

  • pizza

  • refrigerante

  • sobremesa

  • talheres

  • guardanapos

Mesmo que você só queira uma pizza.

GraphQL muda completamente isso.

Você pede exatamente aquilo que deseja.

{
 cliente{

nome

telefone

}
}

Recebe apenas isso.

Nada mais.

Muito eficiente para aplicações móveis.


WebSockets — A Conversa Nunca Termina

HTTP tradicional funciona assim.

Pergunta

↓

Resposta

↓

Fim.

WebSocket funciona assim.

Cliente

⇅

Servidor

⇅

Cliente

A conexão permanece aberta.

Excelente para:

  • bolsa de valores;

  • chats;

  • videogames;

  • monitoramento;

  • dashboards.


Server Sent Events (SSE)

Muito parecido.

Mas existe uma diferença importante.

Apenas o servidor fala.

Servidor

↓↓↓↓↓↓↓↓

Cliente

Ideal para notificações.

Exemplo.

Seu dashboard do z/OS mostra:

CPU.

Fila JES.

Espaço em disco.

Tudo atualizado automaticamente.


gRPC — A Fórmula 1 das APIs

Criado pelo Google.

Enquanto REST utiliza texto…

gRPC utiliza Protocol Buffers.

Muito menores.

Muito mais rápidos.

Imagine enviar um livro.

REST envia tudo em papel.

gRPC envia tudo compactado.

É por isso que grandes empresas utilizam gRPC entre microsserviços.


Apache Thrift

Criado pelo Facebook.

Possui a mesma filosofia.

Você descreve uma interface.

O framework gera automaticamente clientes para diversas linguagens.

Java.

Python.

Go.

C#.

C++.

COBOL?

Ainda não…

Mas pode conversar através de gateways.


MQTT — O Mestre da IoT

Imagine um sensor de temperatura.

Ele possui:

  • pouca memória;

  • bateria;

  • internet lenta.

Não faz sentido transmitir XML gigantesco.

MQTT resolve isso.

Publica mensagens extremamente pequenas.

temperatura

↓

25°C

Pronto.

Perfeito.


Publicador e Assinante

MQTT funciona como um jornal.

Alguém publica.

Publisher

Outro recebe.

Subscriber

No meio existe o Broker.

Sensor

↓

Broker

↓

Aplicativos

Muito elegante.


AMQP — O Carteiro Corporativo

Se MQTT é uma bicicleta…

AMQP é um caminhão blindado.

Possui:

  • filas;

  • persistência;

  • confirmação;

  • roteamento;

  • entrega garantida.

Ideal para:

  • bancos;

  • seguradoras;

  • ERP;

  • processamento financeiro.


Onde entra o IBM MQ?

Curiosamente…

O IBM MQ possui protocolo próprio (MQI).

Mas também suporta integrações usando AMQP em determinados cenários.

É uma das tecnologias mais importantes do mundo corporativo.


Event Driven Architecture (EDA)

Aqui acontece uma mudança de mentalidade.

Ao invés de perguntar:

Pedido foi pago?

O sistema anuncia.

Pagamento realizado.

Todos os interessados recebem.

Financeiro

Estoque

CRM

Analytics

IA

Data Lake

Tudo automaticamente.


Webhooks

Webhooks parecem mágicos.

Mas são extremamente simples.

Imagine o GitHub.

Você faz um Push.

Instantaneamente.

GitHub

↓

HTTP POST

↓

Jenkins

↓

Deploy

Ninguém ficou perguntando.

O GitHub avisou.


EDI — Muito Antes da Internet

Muitos acreditam que integração nasceu com REST.

Na verdade…

EDI existe desde os anos 60.

Ele padronizou documentos empresariais.

Como:

  • pedidos;

  • notas fiscais;

  • faturas;

  • ordens de compra.

Até hoje movimenta trilhões de dólares.


CoAP

Pense nele como:

"O HTTP para sensores."

Funciona sobre UDP.

Muito leve.

Ideal para dispositivos extremamente limitados.


XMPP

Muito famoso no começo da internet.

Utilizado por:

  • chats;

  • mensagens;

  • presença online.

Google Talk utilizava XMPP.


DDS

Aqui entramos no mundo militar.

DDS é utilizado em:

  • submarinos;

  • satélites;

  • aviões;

  • radares;

  • defesa.

Latência extremamente baixa.

Comunicação quase instantânea.


OPC-UA

Esse protocolo merece respeito.

É praticamente o idioma universal das fábricas.

Imagine uma linha de produção.

Robôs.

CLPs.

Esteiras.

Sensores.

Todos conversam usando OPC-UA.

Hoje ele é um dos pilares da Indústria 4.0.


Como Tudo Isso Conversa com o IBM Z?

Agora vem a pergunta que todo Padawan faz.

"O COBOL participa disso tudo?"

A resposta é:

Sim.

Muito mais do que imaginamos.

Exemplo.

Aplicativo Android

↓

REST

↓

API Gateway

↓

z/OS Connect

↓

CICS

↓

Programa COBOL

↓

Db2

↓

Resposta

Outro cenário.

Sensor MQTT

↓

Broker

↓

Kafka

↓

IBM MQ

↓

Programa COBOL

Outro.

Marketplace

↓

Webhook

↓

Microserviço

↓

MQ

↓

Batch COBOL

Perceba.

O COBOL não precisa conhecer MQTT.

Nem GraphQL.

Nem WebSocket.

Existe uma camada responsável por traduzir esses protocolos e entregar os dados ao programa de forma transparente.

Essa separação de responsabilidades é uma das razões pelas quais sistemas IBM Z conseguem evoluir durante décadas sem reescrever milhões de linhas de código.


Comparando Cada Tecnologia

TecnologiaMelhor para
RESTAPIs Web
SOAPIntegrações corporativas
GraphQLAplicações móveis
WebSocketTempo real
SSENotificações
gRPCMicrosserviços
MQTTIoT
AMQPFilas corporativas
EDIB2B
WebhooksIntegração instantânea
CoAPDispositivos restritos
OPC-UAAutomação industrial
DDSSistemas críticos
XMPPMensageria
ThriftRPC multiplataforma

Passo a Passo para o Padawan Aprender APIs

Uma boa jornada de estudos pode seguir esta sequência:

  1. Domine HTTP (GET, POST, PUT, PATCH e DELETE) e compreenda códigos de status como 200, 201, 400, 401, 404 e 500.

  2. Aprenda JSON e XML, pois são os formatos de dados mais comuns em integrações.

  3. Estude REST e pratique com ferramentas como Postman ou Insomnia.

  4. Entenda autenticação com API Keys, OAuth 2.0 e JWT.

  5. Conheça SOAP e WSDL para compreender integrações corporativas legadas.

  6. Explore IBM MQ e conceitos de mensageria assíncrona.

  7. Aprenda os fundamentos de EDA e publicação/assinatura de eventos.

  8. Estude GraphQL e gRPC para arquiteturas modernas.

  9. Descubra como o z/OS Connect EE expõe programas COBOL como APIs REST sem alterar a lógica de negócio.

  10. Finalmente, aprofunde-se em observabilidade, segurança, governança e versionamento de APIs.


Erros Comuns dos Iniciantes

  • Achar que REST é um protocolo.

  • Imaginar que GraphQL substitui REST em todos os cenários.

  • Pensar que SOAP está "morto". Em ambientes corporativos críticos ele continua extremamente relevante.

  • Usar WebSockets quando uma API REST seria suficiente.

  • Escolher MQTT para aplicações que exigem garantias complexas de entrega, onde AMQP pode ser mais adequado.

  • Ignorar autenticação, autorização e criptografia nas APIs.

  • Expor diretamente programas COBOL sem uma camada de gerenciamento, segurança e monitoramento.


Easter Eggs do Bellacosa Mainframe

🔹 Star Trek: o computador da USS Enterprise conversa com sensores, consoles, replicadores e sistemas de navegação usando diferentes protocolos internos. Nenhum tripulante percebe essa complexidade porque existe uma arquitetura de integração por trás. O IBM Z faz exatamente isso nas empresas modernas.

🔹 A Torre de Babel da Computação: REST, SOAP, MQTT, AMQP e GraphQL parecem idiomas diferentes. O papel das plataformas de integração, gateways de API e barramentos de mensagens é funcionar como "tradutores universais", lembrando o Tradutor Universal de Star Trek.

🔹 O COBOL como o Capitão da Nave: enquanto novas tecnologias entram e saem de moda, o COBOL permanece tomando as decisões críticas do negócio. As APIs são os oficiais de comunicações que levam e trazem informações para o capitão.

🔹 Curiosidade Histórica: antes de JSON, XML e APIs, muitos bancos trocavam informações usando arquivos EBCDIC em fitas magnéticas e conexões SNA. Em muitos casos, esses processos ainda coexistem com APIs REST e microsserviços em arquiteturas híbridas.


Conclusão — O Verdadeiro Poder Está na Integração

Existe uma tendência no mercado de apresentar cada nova tecnologia como uma substituta definitiva da anterior. A história da computação mostra exatamente o contrário.

REST não eliminou SOAP.

GraphQL não eliminou REST.

MQTT não eliminou AMQP.

EDI continua movimentando cadeias globais de suprimentos.

IBM MQ permanece essencial para integração corporativa.

E o COBOL continua executando algumas das transações mais importantes do planeta.

O segredo não está em escolher um único protocolo, mas em compreender quando e por que utilizar cada um deles.

Para o programador COBOL Padawan, essa é uma lição valiosa: o IBM Z não vive isolado em uma sala com luzes piscando e terminais 3270. Ele é o coração de um ecossistema conectado por APIs, filas, eventos, microsserviços, sensores industriais, aplicações móveis, inteligência artificial e serviços em nuvem.

Como diria o Dr. Spock ao observar um datacenter moderno:

"A lógica indica que nenhuma tecnologia vence sozinha. As maiores realizações surgem quando sistemas diferentes aprendem a cooperar."

E talvez essa seja a maior lição desta jornada: o futuro da computação não pertence a uma linguagem, a um protocolo ou a uma plataforma. Ele pertence à integração inteligente entre todos eles.


sexta-feira, 5 de novembro de 2021

⚔️ MITSUHA YAMANO E A DUNGEON DOS SETE PROTOCOLOS — QUANDO O PROGRAMADOR COBOL DESCOBRIU QUE REST NÃO ERA O ÚNICO PORTAL

 

Bellacosa Mainframe e os 7 protocolos nas APIs

☕ Um Café no Bellacosa Mainframe

⚔️ MITSUHA YAMANO E A DUNGEON DOS SETE PROTOCOLOS — QUANDO O PROGRAMADOR COBOL DESCOBRIU QUE REST NÃO ERA O ÚNICO PORTAL

REST, GraphQL, gRPC, WebSockets, Webhooks, SSE, MQTT, mensageria, eventos, idempotência, sistemas distribuídos — e o dia em que Mitsuha descobriu que uma API mal escolhida pode custar muito mais que 80.000 moedas de ouro.



🎬 PRÓLOGO — MITSUHA ENCONTROU SETE PORTAIS

Mitsuha Yamano olhou para o quadro.

Havia sete portais desenhados diante dela:

REST
GraphQL
gRPC
WebSocket
Webhook
SSE
MQTT

Ao lado estava um jovem programador COBOL.

Ele conhecia algumas coisas.

Sabia que:

MOVE 100 TO WS-QUANTIDADE.

IF WS-SALDO >= WS-VALOR
    PERFORM PROCESSA-PAGAMENTO
END-IF.

Sabia alguma coisa sobre arquivos, JCL e talvez estivesse começando a descobrir CICS, Db2 e VSAM.

Mas aquela sopa de siglas modernas parecia magia.

Mitsuha olhou para ele.

— Qual você escolheria?

— REST.

— Por quê?

— Porque todo mundo usa REST.

Mitsuha suspirou.

Era exatamente assim que se perdia uma fortuna em outro mundo.

Porque a primeira lição desta aventura é:

Tecnologia não deve ser escolhida porque está na moda. Ela deve ser escolhida porque resolve adequadamente um problema.

E REST, GraphQL, gRPC, WebSocket, Webhooks, SSE e MQTT não são simplesmente sete concorrentes tentando conquistar o mesmo reino.

Eles resolvem tipos diferentes de conversa entre sistemas.

Prepare o café.

Nossa dungeon começa aqui.



🏰 CAPÍTULO 1 — ANTES DA API EXISTIA A CONVERSA

Antes de falarmos sobre REST, precisamos entender algo muito mais básico.

Computadores precisam conversar.

Imagine dois programas:

PROGRAMA A

     precisa de uma informação

          ↓

PROGRAMA B

Se os dois estão dentro do mesmo processo, a comunicação pode ser relativamente simples.

No COBOL podemos ter:

CALL 'CALCJURO'
    USING WS-VALOR
          WS-TAXA
          WS-RESULTADO.

O programa chama outro programa.

Mas imagine que CALCJURO não está na mesma máquina.

Ele está em outro servidor.

Talvez em outro datacenter.

Talvez em outro país.

Agora temos:

Programa A
    |
    | REDE
    |
    v
Programa B

Acabamos de entrar no mundo dos sistemas distribuídos.

E a rede acrescentou vários monstros à dungeon:

latência
timeout
queda de conexão
mensagem duplicada
mensagem perdida
servidor indisponível
autenticação
autorização
criptografia
ordenação
retry

Quando tudo acontece dentro de um programa COBOL, podemos pensar:

PERFORM A
PERFORM B
PERFORM C

Quando distribuímos isso pela rede, precisamos começar a pensar:

Enviei A.

Será que chegou?

Se chegou, será que processou?

Se processou, por que não respondeu?

Posso enviar novamente?

Se enviar novamente, será executado duas vezes?

Bem-vindo à arquitetura distribuída.



🌐 CAPÍTULO 2 — O PRIMEIRO PORTAL CHAMA-SE REST

REST significa:

Representational State Transfer.

O termo ficou conhecido a partir do trabalho acadêmico de Roy Fielding no início dos anos 2000.

Mas cuidado com uma simplificação muito comum:

REST não significa simplesmente “JSON trafegando por HTTP”.

REST é um estilo arquitetural.

Uma das ideias mais importantes é trabalhar com recursos.

Imagine um banco.

Existem:

CLIENTE
CONTA
CARTÃO
PAGAMENTO
EMPRÉSTIMO

Podemos representar esses recursos por endereços:

/customers/12345

/accounts/98765

/cards/45678

E utilizar métodos HTTP.

Por exemplo:

GET /customers/12345

significa aproximadamente:

Quero consultar o cliente 12345.

Enquanto:

POST /payments

poderia significar:

Quero criar um novo pagamento.

Temos métodos conhecidos como:

GET
POST
PUT
PATCH
DELETE

Uma associação didática comum seria:

GET       consultar
POST      criar/processar
PUT       substituir/atualizar
PATCH     alterar parcialmente
DELETE    remover

Mas não transforme isso numa religião. A semântica real da API precisa ser bem projetada.



🧙 CAPÍTULO 3 — MITSUHA COLOCA CICS ATRÁS DO PORTAL

Agora nosso COBOLzeiro pergunta:

— Preciso jogar meu COBOL fora para criar APIs?

Mitsuha quase derrubou o café.

Não.

Esse é justamente um dos pontos mais interessantes da modernização de mainframe.

Imagine um programa COBOL executado por CICS contendo uma regra de negócio importantíssima:

Aplicativo Mobile
       |
       | HTTPS / REST
       v
    API Layer
       |
       v
 z/OS Connect
       |
       v
     CICS
       |
       v
     COBOL
       |
   +---+---+
   |       |
  Db2     VSAM

O aplicativo moderno não precisa necessariamente conhecer detalhes internos do COBOL.

Ele pode pedir:

GET /accounts/12345/balance

Uma camada de integração transforma essa requisição em algo compreensível pelo ambiente existente.

O COBOL executa sua lógica.

O resultado volta.

Talvez como:

{
  "account": "12345",
  "balance": 8750.42,
  "currency": "BRL"
}

Observe o detalhe.

O COBOL pode continuar fazendo aquilo que faz bem:

regra de negócio
transação
processamento
acesso aos dados

A API torna essa capacidade acessível ao restante do ecossistema.

Modernização não significa obrigatoriamente:

destruir o sistema antigo.

Às vezes significa:

construir uma porta moderna para um sistema extremamente valioso.



🧬 CAPÍTULO 4 — GRAPHQL ENTRA NA LOJA DE MITSUHA

Agora imagine que Mitsuha abriu sua loja.

Na tela inicial ela precisa mostrar:

Nome
Saldo
Últimas compras
Cartões
Limite
Notificações

Com determinadas APIs REST, poderíamos acabar fazendo:

GET /customer/123
GET /customer/123/accounts
GET /customer/123/cards
GET /customer/123/orders
GET /customer/123/notifications

Cinco requisições.

Outra API poderia responder tudo em uma chamada, mas devolver 80 campos quando a tela utiliza apenas 7.

Temos dois problemas clássicos.

Over-fetching

Você pede pouca coisa e recebe uma carroça inteira.

PRECISO:

nome
saldo


RECEBO:

nome
saldo
endereço
telefone
data nascimento
histórico
cartões
preferências
...

Under-fetching

Você recebe tão pouco que precisa continuar perguntando:

cliente?

agora cartões?

agora pedidos?

agora itens?

agora endereço?

GraphQL oferece outra abordagem.

O cliente pode declarar os campos desejados:

query {
  customer(id: 123) {
    name
    accounts {
      balance
    }
  }
}

Isso é poderoso especialmente em interfaces com necessidades de dados complexas.

Mas Mitsuha levanta o dedo:

— Não existe magia grátis.

GraphQL também traz desafios:

schemas
resolvers
cache
autorização
complexidade das consultas
observabilidade
N+1 queries
limitação de profundidade
controle de custo

Uma consulta aparentemente inocente pode gerar enorme trabalho internamente se a arquitetura estiver mal implementada.

Portanto:

GraphQL não é REST melhorado.

São modelos diferentes.


⚡ CAPÍTULO 5 — gRPC PARECE ESTRANHAMENTE FAMILIAR AO COBOLZEIRO

Mitsuha escreve:

CALL 'AUTORIZA'
    USING WS-CARTAO
          WS-VALOR
          WS-RETURN-CODE.

O programador sorri.

Finalmente alguma coisa familiar.

Então ela desenha:

SERVIÇO A

   chama

SERVIÇO B

RPC significa Remote Procedure Call.

A ideia geral é fazer uma operação localizada em outro processo ou máquina parecer, conceitualmente, uma chamada de procedimento.

gRPC é uma tecnologia moderna muito utilizada nesse universo.

Normalmente os contratos são definidos com Protocol Buffers.

Por exemplo:

service PaymentService {

    rpc Authorize(PaymentRequest)
        returns (PaymentResponse);

}

Temos um contrato bem definido.

Uma vantagem importante é a possibilidade de geração de código para diferentes linguagens.

Podemos ter:

Java
   |
  gRPC
   |
   v
Go Service

ou:

Python
   |
  gRPC
   |
   v
Java

Protocol Buffers utiliza representação binária compacta, diferentemente do JSON textual tão associado às APIs REST.

Isso torna gRPC particularmente interessante em muitos cenários de comunicação interna entre serviços.

Easter egg COBOL

O veterano olha para aquilo e comenta:

— Então inventaram CALL USING pela rede?

Não exatamente.

Mas como modelo mental inicial para nosso Padawan COBOL?

Funciona maravilhosamente bem.


🔥 CAPÍTULO 6 — WEBSOCKET MANTÉM O PORTAL ABERTO

Agora Mitsuha pergunta:

— Como você descobriria se apareceu uma nova mensagem?

O aprendiz responde:

— Perguntaria.

Tem mensagem?

Tem mensagem?

Tem mensagem?

Tem mensagem?

Tem mensagem?

Parabéns.

Você acabou de descobrir o polling.

Dependendo do problema, polling é perfeitamente aceitável.

O problema aparece quando milhares de clientes perguntam repetidamente:

mudou?

mudou?

mudou?

mudou?

mesmo quando nada mudou.

WebSocket permite manter uma conexão de comunicação bidirecional.

CLIENTE <====================> SERVIDOR

Depois de estabelecida a comunicação, ambos podem transmitir informações.

Isso é extremamente útil em:

chat
jogos multiplayer
dashboards
colaboração
telemetria
atualizações interativas

Imagine nossa War Room Mainframe:

           IBM Z
             |
       SMF / MONITOR
             |
             v
          Backend
             |
        WebSocket
             |
             v
+---------------------------+
|    WAR ROOM MAINFRAME     |
+---------------------------+
| CPU                 73%   |
| CICS RESPONSE       0.2s  |
| MQ DEPTH            173   |
| DB2                 OK    |
| BATCH               OK    |
+---------------------------+

Se algum indicador muda, o backend pode enviar imediatamente uma atualização.


📡 CAPÍTULO 7 — SSE: MITSUHA LIGA A ESTAÇÃO DE RÁDIO

Nem sempre precisamos de comunicação nos dois sentidos.

Às vezes queremos principalmente:

SERVIDOR
   |
   |
   |
   v
CLIENTE

É aqui que entram Server-Sent Events, ou SSE.

O cliente estabelece uma conexão HTTP e o servidor pode continuar enviando eventos.

Pense numa estação transmitindo:

evento 1
evento 2
evento 3
evento 4

Isso combina muito bem com:

notificações
feeds
status
progresso
logs
streaming de respostas

Um exemplo moderno está nas aplicações de IA.

Imagine esperar 40 segundos para receber:

RESPOSTA COMPLETA

Podemos, em vez disso, transmitir progressivamente:

COBOL

COBOL foi

COBOL foi criado

COBOL foi criado no...

A experiência percebida pelo usuário melhora muito.

WebSocket versus SSE

Guarde este desenho:

WebSocket

CLIENTE <==========> SERVIDOR


SSE

CLIENTE <----------- SERVIDOR

Precisa de conversa contínua nos dois sentidos?

WebSocket pode fazer sentido.

O servidor precisa principalmente transmitir atualizações ao cliente?

SSE pode ser uma solução mais simples.


🔔 CAPÍTULO 8 — WEBHOOK: “MITSUHA, EU TE AVISO”

Agora chegamos a um dos conceitos mais elegantes.

Imagine Mitsuha esperando um pagamento.

Uma estratégia seria:

Pagamento chegou?

Pagamento chegou?

Pagamento chegou?

Pagamento chegou?

Polling novamente.

Mas podemos inverter.

Mitsuha informa:

Quando acontecer,
mande a informação para cá.

Ela registra um endpoint:

https://loja.example/events/payment

Quando o pagamento acontece:

Sistema de pagamento
        |
        | HTTP POST
        v
Webhook Mitsuha
        |
        v
Processamento

Simples.

Até chegar a produção.

Porque o endpoint pode estar indisponível.

Então precisamos pensar em:

retry
timeout
backoff
assinatura
segurança
logs
monitoramento
duplicidade
idempotência

E aqui aparece um monstro fantástico.


👹 CAPÍTULO 9 — O DEMÔNIO DA DUPLICIDADE

Imagine:

Mitsuha envia pagamento de 100 moedas.

O servidor recebe.

Processa.

Debita.

Mas quando vai responder:

HTTP 200 OK

a conexão cai.

Para Mitsuha:

?????????

Ela não sabe se o pagamento aconteceu.

Então tenta novamente.

Se o sistema simplesmente processar outra vez:

100 moedas
+
100 moedas
=
200 moedas

Temos um problema sério.

Por isso sistemas de pagamento frequentemente trabalham com conceitos de idempotência.

Uma operação idempotente pode ser repetida sem produzir efeitos adicionais indevidos para a mesma intenção.

Podemos associar à operação uma chave:

IDEMPOTENCY-KEY:
PAY-20260925-000317

O servidor registra:

PAY-20260925-000317 = PROCESSADO

Se receber novamente:

PAY-20260925-000317

ele consegue reconhecer:

Eu já processei esta intenção.

Isso é extremamente importante em sistemas distribuídos.

E nosso easter egg apareceu:

03:17

Veteranos da War Room Bellacosa sabem que incidentes gostam de acontecer justamente quando ninguém gostaria de estar acordado.


📻 CAPÍTULO 10 — MQTT E O EXÉRCITO DE PEQUENOS DISPOSITIVOS

Mitsuha agora possui:

10 sensores

Depois:

1.000 sensores

Depois:

100.000 sensores

Cada um precisa transmitir pequenas informações.

Temperatura:

27.3

Pressão:

1012

Estado:

ON

MQTT foi projetado pensando em comunicação leve e funciona muito bem em cenários envolvendo IoT, dispositivos e redes com restrições.

Seu modelo clássico envolve:

PUBLISHER
    |
    v
  BROKER
    |
 +--+--+
 |  |  |
 v  v  v
S1 S2 S3

O produtor publica em um tópico:

factory/machine17/temperature

Os interessados assinam tópicos.

A máquina 17 não precisa conhecer todos os consumidores.

Ela apenas publica.

Isso produz uma propriedade arquitetural valiosíssima:

desacoplamento.

O produtor não precisa saber necessariamente quem consumirá aquela informação.


📨 CAPÍTULO 11 — O COBOLZEIRO RECONHECE IBM MQ NA TAVERNA

Nesse momento nosso aprendiz interrompe:

— Espera. Publisher, consumidor, mensagens, filas, desacoplamento... isso parece mensageria.

EXATAMENTE.

Agora estamos chegando a uma ponte maravilhosa entre arquitetura moderna e mainframe.

Imagine:

COBOL
   |
   v
IBM MQ
   |
   +------> SISTEMA A
   |
   +------> SISTEMA B
   |
   +------> INTEGRAÇÃO

O universo corporativo trabalha há décadas com conceitos como:

filas
mensagens
persistência
transações
assincronicidade
store-and-forward
publish/subscribe

Por isso um profissional mainframe experiente frequentemente encontra conceitos supostamente “moderníssimos” e pensa:

Já enfrentei esse monstro antes.

Mudaram as ferramentas.

Mudaram os nomes.

Mudaram as abstrações.

O problema fundamental continua reconhecível.


🧠 CAPÍTULO 12 — NÃO SÃO REALMENTE “SETE PROTOCOLOS IGUAIS”

Existe uma correção conceitual importante na imagem que iniciou nossa aventura.

Colocar tudo sob o título “7 API Protocols” facilita a comunicação, mas tecnicamente mistura categorias diferentes.

REST é essencialmente um estilo arquitetural.

GraphQL envolve linguagem de consulta, sistema de tipos e runtime.

gRPC é um framework/sistema de RPC.

WebSocket é efetivamente um protocolo.

MQTT também é protocolo.

Webhooks representam principalmente um padrão de integração orientado a eventos.

SSE é um mecanismo padronizado para eventos enviados pelo servidor sobre HTTP.

Portanto, imagine a placa:

7 FORMAS IMPORTANTES
DE SISTEMAS CONVERSAREM

Ela seria menos sexy para LinkedIn.

Mas pedagogicamente seria mais segura. 😄


🧙‍♀️ CAPÍTULO 13 — MITSUHA DESCOBRE QUE FALTAVAM PORTAIS

Nossa lista também não contém todo o universo.

Precisamos conhecer pelo menos conceitualmente outros habitantes dessa dungeon.

SOAP

Foi extremamente importante na história dos Web Services empresariais.

Normalmente associado a XML e contratos formais, apareceu intensamente em integrações corporativas.

Ainda existem muitos sistemas utilizando SOAP.

AMQP

Importante no universo de mensageria.

Kafka

Apache Kafka popularizou arquiteturas baseadas em event streaming em enorme escala.

O modelo mental começa a ficar diferente de simplesmente:

manda mensagem
recebe mensagem
acabou

Eventos podem formar um registro persistente que consumidores processam conforme suas necessidades.

IBM MQ

Para o COBOLzeiro e para ambientes empresariais críticos, seria impossível discutir seriamente integração sem mencionar MQ.

Especialmente quando começamos a conversar sobre confiabilidade.


🏦 CAPÍTULO 14 — UMA ARQUITETURA REAL USA VÁRIOS PORTAIS

Agora Mitsuha finalmente constrói seu império financeiro.

O aplicativo utiliza REST:

MOBILE
   |
 REST
   |
API GATEWAY

Internamente alguns microsserviços conversam via gRPC:

SERVICE A
   |
 gRPC
   |
SERVICE B

O mainframe continua responsável por determinadas regras:

API
 |
 v
z/OS Connect
 |
 v
CICS
 |
 v
COBOL
 |
 +---- Db2
 |
 +---- VSAM

Eventos importantes passam por mensageria:

COBOL
 |
 v
 MQ
 |
 +------> Fraud
 |
 +------> Settlement
 |
 +------> Notification

O parceiro externo recebe:

WEBHOOK

O dashboard recebe:

SSE

O chat utiliza:

WebSocket

Sensores de algum equipamento poderiam utilizar:

MQTT

Veja o ponto fundamental.

Não escolhemos:

REST OU gRPC OU MQ OU WebSocket

Podemos escolher:

REST
+
gRPC
+
MQ
+
Webhook
+
SSE

porque cada tecnologia ocupa uma posição diferente na arquitetura.


⚔️ CAPÍTULO 15 — O VERDADEIRO CHEFÃO É O SISTEMA DISTRIBUÍDO

Nosso aprendiz agora conhece sete tecnologias.

Ele está feliz.

Mitsuha, porém, abre a última porta.

Atrás dela existe um monstro gigantesco chamado:

DISTRIBUTED SYSTEM

Porque aprender sintaxe é relativamente fácil.

O difícil é responder perguntas como:

E se a rede cair?

E se a mensagem chegar duas vezes?

E se não chegar?

E se chegar fora de ordem?

E se o servidor processar,
mas não conseguir responder?

E se o consumidor ficar offline?

E se eu tiver 10.000 consumidores?

E se uma operação demorar 40 segundos?

E se ocorrer timeout?

Posso tentar novamente?

Como sei o que aconteceu?

É aqui que entram conceitos fundamentais:

timeout
retry
backoff
idempotência
circuit breaker
dead-letter queue
observabilidade
correlation ID
tracing
autenticação
autorização
rate limiting

🔍 CAPÍTULO 16 — OBSERVABILIDADE: QUEM NÃO ENXERGA NÃO INVESTIGA

Imagine uma transação:

Mobile
  |
API
  |
Service A
  |
MQ
  |
COBOL
  |
Db2

O cliente reclama:

Meu pagamento desapareceu.

Onde?

Precisamos seguir a transação.

Um identificador de correlação pode ajudar:

CORRELATION-ID

TX-20260925-00042

Então conseguimos procurar:

API
TX-20260925-00042

SERVICE
TX-20260925-00042

MQ
TX-20260925-00042

COBOL
TX-20260925-00042

Agora a investigação deixa de ser:

Acho que o problema está no mainframe.

E passa a ser:

14:31:02.103 API recebeu
14:31:02.121 API publicou
14:31:02.135 MQ recebeu
14:31:02.148 COBOL iniciou
14:31:02.172 Db2 COMMIT
14:31:02.181 resposta publicada

Isso é ouro operacional.

Em ambientes modernos distribuídos, observabilidade não deveria ser decoração.

É parte da arquitetura.


🗺️ CAPÍTULO 17 — O MAPA DE DECISÃO DE MITSUHA

Quando precisar escolher uma abordagem, não comece pela tecnologia.

Faça perguntas.

Passo 1 — Quem inicia a conversa?

Cliente?

Servidor?

Dispositivo?

Outro sistema?

Passo 2 — Preciso de resposta imediata?

Se sim, um modelo síncrono pode ser apropriado.

Se não, mensageria assíncrona pode oferecer vantagens.

Passo 3 — Preciso manter conexão aberta?

Se não:

REST
GraphQL
Webhook

podem aparecer entre as possibilidades, dependendo do problema.

Se sim:

WebSocket
SSE
gRPC streaming

podem entrar na análise.

Passo 4 — A comunicação é bidirecional?

Se for:

WebSocket

merece investigação.

Se for predominantemente servidor → cliente:

SSE

pode ser suficiente.

Passo 5 — Tenho muitos produtores e consumidores desacoplados?

Pense em:

MQ
MQTT
Kafka
event-driven architecture

Passo 6 — Posso perder uma mensagem?

Essa pergunta muda tudo.

Pergunte também:

Posso duplicar?

Preciso manter ordem?

Preciso fazer replay?

Por quanto tempo?

Preciso comprovar processamento?

Agora estamos fazendo arquitetura.


💰 CAPÍTULO 18 — MITSUHA ENSINA A REGRA DAS 80.000 MOEDAS

Existe uma armadilha recorrente em tecnologia:

“X é moderno.”

Logo:

“Vamos usar X.”

Não.

Imagine usar WebSocket para uma operação executada uma vez por mês.

Ou GraphQL para uma API trivial com três campos.

Ou introduzir Kafka onde uma fila simples resolveria perfeitamente.

Ou fazer polling a cada segundo quando um webhook resolveria o problema.

Complexidade também custa dinheiro.

Ela produz:

infraestrutura
monitoramento
treinamento
suporte
incidentes
dependências
documentação
segurança
manutenção

Mitsuha não ficaria rica gastando 80.000 moedas para resolver um problema de 8 moedas.

Arquitetura madura procura a solução adequada, não a solução com maior quantidade de siglas.


🏛️ CAPÍTULO 19 — A CATEDRAL MAINFRAME JÁ CONHECIA MUITOS DESSES MONSTROS

Existe uma deliciosa ironia histórica aqui.

Hoje falamos constantemente em:

mensageria
eventos
transações
filas
RPC
assíncrono
publish/subscribe
observabilidade
alta disponibilidade
processamento distribuído

Muitos desses problemas são antigos.

Mainframes empresariais enfrentam há décadas desafios relacionados a:

milhares de transações
concorrência
integridade
recuperação
auditoria
segurança
mensageria
disponibilidade

CICS, IMS, Db2, MQ e outras tecnologias nasceram e evoluíram dentro dessa realidade.

Isso não significa que:

“Mainframe já inventou tudo.”

Seria exagero.

Significa algo muito mais interessante:

Os problemas fundamentais da computação sobrevivem às gerações de tecnologia.

As abstrações mudam.

Os protocolos evoluem.

As interfaces ficam mais elegantes.

Mas continuamos perguntando:

Quem envia?

Quem recebe?

Quando?

Em qual ordem?

Quantas vezes?

O que acontece se falhar?

🥚 EASTER EGG — A TRANSAÇÃO FANTASMA DAS 03:17

Às 03:17 da manhã, Mitsuha recebe uma ligação.

— Produção caiu!

Ela abre o dashboard.

REST funcionando.

CICS funcionando.

Db2 funcionando.

MQ funcionando.

Tudo verde.

Mesmo assim, pagamentos estão sendo duplicados.

Depois de duas horas investigando, encontra:

Webhook
   |
timeout
   |
retry
   |
processamento novamente

A aplicação consumidora não implementava idempotência corretamente.

O mesmo evento havia sido processado várias vezes.

Mitsuha olha para o aprendiz.

— Qual protocolo falhou?

Ele pensa.

— Nenhum.

Exatamente.

O erro estava no desenho do sistema.

Essa talvez seja a lição mais importante desta dungeon.


☕ EPÍLOGO — O COBOLZEIRO ATRAVESSOU OS SETE PORTAIS

Nosso jovem programador começou acreditando que precisava decorar:

REST
GraphQL
gRPC
WebSocket
Webhook
SSE
MQTT

Terminou entendendo algo muito maior.

Essas tecnologias representam diferentes maneiras de sistemas trocarem informações.

REST ensina a pensar em recursos e interfaces HTTP.

GraphQL permite ao consumidor declarar dados de que necessita.

gRPC aproxima sistemas distribuídos de um modelo de chamada remota baseado em contratos fortemente definidos.

WebSocket mantém um canal bidirecional.

SSE permite ao servidor transmitir eventos continuamente ao cliente.

Webhooks invertem o polling:

não fique perguntando; eu aviso quando acontecer.

MQTT apresenta um modelo leve de publish/subscribe extremamente útil para dispositivos e IoT.

E mensageria empresarial, MQ, event streaming e tecnologias relacionadas expandem ainda mais essa dungeon.

Mas Mitsuha ensinou algo que nenhuma tabela comparativa consegue ensinar:

Antes de escolher o protocolo, descubra a natureza da conversa.

Pergunte:

Quem fala?

Quem escuta?

Quem começa?

Precisa responder?

Precisa esperar?

Pode repetir?

Pode perder?

Precisa preservar ordem?

O receptor pode estar offline?

Quantos participantes existem?

Como descubro que falhou?

Como recupero?

Como provo o que aconteceu?

Quando um programador começa a fazer essas perguntas, alguma coisa muda.

Ele deixa de pensar somente:

COMO IMPLEMENTO ESTA API?

e começa a perguntar:

COMO ESTE SISTEMA DEVE SE COMPORTAR?

Essa é uma mudança gigantesca.

É a passagem da programação para a engenharia de sistemas.

E talvez seja justamente por isso que um programador COBOL possui uma vantagem inesperada nessa aventura.

Ele vem de um universo no qual palavras como:

transação
commit
rollback
fila
batch
online
integridade
recuperação
auditoria
disponibilidade

nunca foram apenas buzzwords.

Quando um pagamento envolve dinheiro verdadeiro, não basta desenhar uma seta bonita entre dois quadradinhos num PowerPoint.

A transação precisa chegar.

Precisa ser processada corretamente.

Precisa sobreviver a falhas.

Precisa poder ser investigada.

E, às 03:17 da madrugada, alguém precisa conseguir descobrir exatamente o que aconteceu.

Mitsuha fecha o mapa dos sete portais, guarda algumas moedas e olha para nosso Padawan COBOL:

— Então, qual é o melhor protocolo?

Ele finalmente aprendeu.

— Depende da conversa que os sistemas precisam ter.

Mitsuha sorri.

A primeira dungeon estava concluída.

A próxima porta tinha uma placa ainda mais assustadora:

                 EVENT-DRIVEN ARCHITECTURE

                          |
             +------------+------------+
             |                         |
          IBM MQ                     Kafka
             |                         |
       Queues / Topics            Event Streams
             |                         |
             +------------+------------+
                          |
                    COBOL PROGRAM

E alguém havia escrito em letras pequenas no canto:

ATENÇÃO:

“EXACTLY ONCE”
PODE CONTER MAGIA,
MARKETING
E MUITAS LETRAS MIÚDAS.

Mitsuha pegou novamente sua calculadora.

O COBOLzeiro preparou outro café.

E os dois entraram.

segunda-feira, 29 de julho de 2019

☕🔥 APIs NO IBM MAINFRAME — O MUNDO MODERNO DESCOBRIU AGORA O QUE O z/OS JÁ FAZIA HÁ DÉCADAS

 

Bellacosa Mainframe e o uso de APIs em Mainframe

☕🔥 APIs NO IBM MAINFRAME — O MUNDO MODERNO DESCOBRIU AGORA O QUE O z/OS JÁ FAZIA HÁ DÉCADAS

Hoje o mercado fala sem parar sobre:

  • APIs

  • REST

  • GraphQL

  • gRPC

  • Event Streaming

  • Webhooks

  • Tempo real

  • Microsserviços

E muita gente imagina que isso nasceu:

  • na nuvem

  • no Kubernetes

  • no Node.js

  • no mundo cloud-native

Mas existe uma realidade histórica quase escondida:

O Mainframe sempre foi uma máquina de integração.

Muito antes do termo “API Economy” virar moda…

o IBM Mainframe já fazia:

  • comunicação distribuída

  • transações remotas

  • integração entre sistemas

  • troca de mensagens

  • processamento assíncrono

  • request/reply

  • eventos

  • streaming de dados

E talvez essa seja a parte mais impressionante:

🔥 O z/OS não apenas sobreviveu à era das APIs…
ele virou um dos pilares dela.


☕ O QUE MUITA GENTE NÃO ENTENDE SOBRE APIs

API não é “modinha web”.

API é:

contrato de comunicação.

O formato muda.

A tecnologia muda.

Mas a ideia é a mesma desde os anos 70:

  • um sistema solicita algo

  • outro sistema responde

  • existe um protocolo

  • existe um padrão

  • existe governança

E o Mainframe foi pioneiro nisso.


☕🔥 GRAPHQL NO MAINFRAME — A VOLTA DO “PEDIR SOMENTE O NECESSÁRIO”

GraphQL virou tendência porque resolve um problema clássico:

👉 excesso de dados.

O cliente pede exatamente o que quer.


☕ Mas olha a ironia…

O Mainframe já tinha essa mentalidade há décadas.


Exemplo clássico no CICS + COBOL

Uma transação antiga:

EXEC CICS LINK
     PROGRAM('CLI0001')
     COMMAREA(WS-AREA)
END-EXEC

A COMMAREA levava apenas:

  • campos específicos

  • estruturas necessárias

  • dados filtrados

Não havia desperdício.


☕ GraphQL + z/OS Connect

Hoje o Mainframe moderno usa:

  • z/OS Connect

  • API Connect

  • Db2 REST Services

para expor:

  • COBOL

  • CICS

  • IMS

  • DB2

como APIs modernas.


Exemplo real

Um app mobile pode pedir:

cliente {
  nome
  saldo
}

E o Mainframe responde apenas isso.

Sem payload gigante.


☕🔥 gRPC — O “NOVO RPC” QUE O MAINFRAME JÁ CONHECIA

Quando o mercado descobriu gRPC…

o profissional mainframe veterano provavelmente sorriu.

Porque:

👉 gRPC é basicamente a evolução moderna do RPC.

E RPC já existia no universo IBM há MUITO tempo.


☕ O que é gRPC?

Comunicação:

  • rápida

  • binária

  • eficiente

  • orientada a contratos

usando Protocol Buffers.


☕ O Mainframe fazia isso como?

APPC/LU6.2

Comunicação transacional remota.


DPL (Distributed Program Link)

Programa chama outro remotamente:

EXEC CICS LINK
     SYSID('PRD1')
END-EXEC

Isso é praticamente:

🔥 “gRPC raiz”.


☕ MQ também antecipou isso

Mensagens compactas.

Baixa latência.

Integração confiável.

Comunicação assíncrona.


☕🔥 SOAP — O REINADO ABSOLUTO DO MAINFRAME CORPORATIVO

Antes do REST dominar o mundo…

SOAP era rei absoluto.

E o Mainframe foi um dos maiores ambientes SOAP do planeta.


☕ Por quê?

Porque SOAP entrega algo que o mundo financeiro AMA:

  • contratos rígidos

  • padronização

  • WS-Security

  • governança

  • transações confiáveis

  • XML estruturado


☕ CICS Web Services

O CICS consegue expor programas COBOL como SOAP services.


Fluxo clássico

SOAP Request
     ↓
CICS Pipeline
     ↓
COBOL
     ↓
DB2 / VSAM
     ↓
SOAP Response

☕ O que pouca gente sabe

Grande parte:

  • bancos

  • seguradoras

  • governos

AINDA usam SOAP no Mainframe.

E sinceramente?

🔥 Em sistemas críticos, SOAP ainda é extremamente poderoso.


☕🔥 REST — O MAINFRAME APRENDEU A FALAR “INTERNET”

REST virou padrão porque simplifica integração.

HTTP + JSON.

Simples.

Leve.

Universal.


☕ E o Mainframe?

O Mainframe se reinventou brutalmente aqui.


☕ Hoje temos:

z/OS Connect

Transforma:

  • COBOL

  • IMS

  • CICS

em APIs REST modernas.


☕ Exemplo

Aplicação mobile faz:

GET /clientes/1001

E no backend:

  • COBOL executa

  • DB2 consulta

  • CICS processa

O usuário nem percebe que existe um z/OS por trás.


☕ O REST ajudou o Mainframe a sobreviver

Essa talvez seja uma das maiores viradas históricas do IBM Z.

REST permitiu:

  • integração com cloud

  • apps mobile

  • fintechs

  • Open Banking

  • microsserviços

  • APIs públicas


☕🔥 WEBHOOKS — O MAINFRAME SEMPRE VIVEU DE EVENTOS

Webhook é:

“me avise quando algo acontecer”.


☕ Parece moderno…

Mas o Mainframe já vivia disso.


☕ Exemplos clássicos

WTO/WTOR

Mensagens do sistema disparam ações.


Automation

NetView e System Automation executam workflows baseados em eventos.


MQ Triggering

Fila recebe mensagem → programa inicia automaticamente.

Isso é Webhook conceitualmente.


☕ Exemplo real

Pagamento aprovado:

MQ Message
   ↓
Trigger
   ↓
COBOL Batch
   ↓
Atualização DB2
   ↓
Notificação externa

Event-driven desde antes do termo existir.


☕🔥 SSE (SERVER-SENT EVENTS) — O MAINFRAME SEMPRE AMOU STREAMING

SSE mantém conexão aberta enviando eventos contínuos.

Hoje isso aparece em:

  • dashboards

  • monitoring

  • fintechs

  • trading

  • observabilidade


☕ Mas o Mainframe já fazia streaming há décadas

SMF

Fluxo contínuo de eventos do sistema.


RMF

Monitoramento em tempo real.


OMEGAMON

Streaming operacional contínuo.


☕ Ambientes financeiros usam isso intensamente

Bolsa de valores.

Cartões.

PIX.

Fraude.

Monitoramento de transações.

Tudo depende de fluxo contínuo.


☕🔥 O GRANDE CHOQUE CULTURAL

O mercado moderno acha que inventou:

  • integração

  • APIs

  • eventos

  • streaming

  • observabilidade

Mas o Mainframe já enfrentava esses problemas:

  • nos anos 70

  • nos anos 80

  • nos anos 90

em escala absurda.


☕ O QUE MUDA É O FORMATO

Ontem:

  • SNA

  • APPC

  • MQ

  • CICS LINK

  • COMMAREA

Hoje:

  • REST

  • GraphQL

  • gRPC

  • Kafka

  • Webhooks

Mas a essência continua a mesma:

🔥 sistemas precisam conversar de forma confiável.


☕🔥 O MAIOR MITO SOBRE O MAINFRAME

“Mainframe não conversa com sistemas modernos.”

Isso está completamente errado.

Hoje o IBM Z conversa com:

  • AWS

  • Azure

  • Kubernetes

  • OpenShift

  • APIs REST

  • Kafka

  • aplicações mobile

  • IA generativa

E faz isso mantendo:

  • segurança absurda

  • disponibilidade 24x7

  • integridade transacional

  • throughput gigantesco


☕🔥 A VERDADE QUE O MERCADO COMEÇA A REDESCOBRIR

Quanto mais o mundo moderno cresce…

mais ele percebe a importância de:

  • resiliência

  • observabilidade

  • governança

  • transação confiável

  • mensageria robusta

  • integração desacoplada

E adivinha?

👉 Esses sempre foram pilares do Mainframe.


☕🔥 CONCLUSÃO — O MAINFRAME NÃO FICOU PARA TRÁS

Ele apenas:

evoluiu antes dos outros.

REST, GraphQL, gRPC e Webhooks não substituíram o Mainframe.

Eles se conectaram a ele.

Porque no fim das contas…

🔥 quase todo sistema moderno ainda acaba conversando com um IBM Z em algum momento da vida.


quarta-feira, 25 de abril de 2018

☕🔥 API PROTOCOLS NO IBM MAINFRAME — ENQUANTO O MUNDO DISCUTIA “MICROSSERVIÇOS”, O z/OS JÁ PROCESSAVA O PLANETA EM TEMPO REAL

Bellacosa Mainframe e uma visão das api protocols


☕🔥 API PROTOCOLS NO IBM MAINFRAME — ENQUANTO O MUNDO DISCUTIA “MICROSSERVIÇOS”, O z/OS JÁ PROCESSAVA O PLANETA EM TEMPO REAL

Existe uma frase que resume perfeitamente a história da integração corporativa:

“Toda tecnologia moderna acaba redescobrindo algo que o Mainframe já fazia.”

Hoje o mercado vive cercado de siglas:

  • REST

  • GraphQL

  • SOAP

  • gRPC

  • MQTT

  • WebSockets

  • SSE

  • EDA

  • AMQP

  • Webhooks

E muita gente acredita que isso nasceu:

  • na cloud

  • no Kubernetes

  • nas startups

  • no mundo DevOps

Mas existe uma verdade quase chocante:

🔥 O IBM Mainframe já dominava integração distribuída quando muita dessas tecnologias nem existia.


☕ O MAINFRAME NUNCA FOI “ISOLADO”

Esse talvez seja o maior mito da computação.

Muita gente imagina o Mainframe como:

  • terminal verde

  • sistema fechado

  • ambiente monolítico

  • tecnologia presa ao passado

Só que historicamente o Mainframe SEMPRE foi:

✅ distribuído
✅ integrado
✅ orientado a mensagens
✅ orientado a eventos
✅ transacional
✅ resiliente

Na prática:

👉 o Mainframe foi um dos primeiros grandes “hubs de APIs” corporativas do mundo.


☕🔥 REST — O MAINFRAME APRENDEU A FALAR A LÍNGUA DA INTERNET

REST virou padrão mundial porque simplifica comunicação.

HTTP + JSON.

Simples.

Universal.


☕ Mas veja a ironia…

O Mainframe já fazia integração transacional décadas antes.


☕ Hoje o z/OS usa REST via:

  • z/OS Connect

  • CICS REST APIs

  • Db2 REST Services

  • API Connect

  • OpenShift APIs


☕ Exemplo real

Aplicativo mobile:

GET /contas/1001

☕ O que acontece por trás?

REST API
   ↓
z/OS Connect
   ↓
CICS
   ↓
COBOL
   ↓
DB2

Tudo em milissegundos.


☕ O usuário nem percebe

Ele acha que está falando com:

  • cloud

  • microservice

  • fintech moderna

Mas no fundo:

🔥 existe um COBOL no z/OS processando bilhões com segurança absurda.


☕🔥 GRAPHQL — O MAINFRAME SEMPRE DETESTOU DESPERDÍCIO

GraphQL nasceu para resolver:

  • excesso de dados

  • APIs gigantes

  • múltiplas consultas


☕ O conceito é moderno…

Mas a mentalidade é antiga no Mainframe.


☕ COMMAREA no CICS já fazia isso

EXEC CICS LINK
     PROGRAM('CLI001')
     COMMAREA(WS-AREA)
END-EXEC

Somente os campos necessários eram enviados.

Nada de payload gigantesco.


☕ Hoje com GraphQL + DB2

Apps conseguem pedir:

cliente {
   nome
   saldo
}

E o Mainframe retorna exatamente isso.


☕🔥 SOAP — O IMPÉRIO CORPORATIVO QUE O MAINFRAME AJUDOU A CONSTRUIR

Antes do REST…

SOAP era rei absoluto.

E honestamente?

🔥 Em ambientes críticos ele ainda é extremamente forte.


☕ Por quê?

Porque SOAP entrega:

  • contratos rígidos

  • segurança avançada

  • WS-Security

  • governança

  • auditoria

  • confiabilidade


☕ O Mainframe amava isso

Porque bancos e governos PRECISAM disso.


☕ CICS Web Services

Transforma COBOL em serviço SOAP.


☕ Fluxo clássico

SOAP Request
   ↓
CICS Pipeline
   ↓
COBOL
   ↓
DB2
   ↓
SOAP Response

☕ Muitos sistemas financeiros ainda vivem disso

E continuam funcionando perfeitamente.


☕🔥 gRPC — O “RPC MODERNO” QUE O MAINFRAME JÁ CONHECIA

O mercado moderno descobriu:

  • baixa latência

  • comunicação binária

  • chamadas remotas rápidas

e chamou isso de gRPC.


☕ O Mainframe olha e responde:

“Nós já fazíamos isso.”


☕ APPC/LU6.2

Comunicação remota transacional.


☕ DPL (Distributed Program Link)

EXEC CICS LINK
     SYSID('PRD1')
END-EXEC

Programa remoto chamado como se fosse local.

Isso é praticamente:

🔥 gRPC ancestral.


☕🔥 WEBSOCKET — O MAINFRAME SEMPRE GOSTOU DE CONEXÃO PERSISTENTE

WebSocket permite:

  • comunicação bidirecional

  • conexão contínua

  • baixa latência


☕ Isso é perfeito para:

  • trading

  • PIX

  • monitoramento

  • dashboards

  • antifraude


☕ E o Mainframe?

Sempre viveu de sessões persistentes.


☕ VTAM e sessões SNA

Mantinham conexões contínuas décadas antes do WebSocket.


☕ Hoje o z/OS usa isso com:

  • APIs realtime

  • Open Banking

  • streaming financeiro

  • integração cloud


☕🔥 WEBHOOKS — O MAINFRAME SEMPRE FOI EVENT-DRIVEN

Webhook significa:

“me avise quando algo acontecer”.


☕ Parece moderno.

Mas o Mainframe vive disso desde os anos 70.


☕ MQ Triggering

Mensagem chega na fila:

MQ
 ↓
Trigger
 ↓
Programa COBOL inicia

Isso é praticamente um webhook corporativo.


☕ WTO/WTOR também

Eventos operacionais disparam ações automáticas.


☕🔥 EDA — EVENT DRIVEN ARCHITECTURE

Agora chegamos numa parte fascinante.

O mercado moderno fala de:

  • Kafka

  • Event Bus

  • Streaming

  • Async Systems

como se fosse novidade absoluta.


☕ Mas o Mainframe sempre viveu de eventos

Exemplos clássicos

  • MQ

  • CICS transient data

  • SMF

  • JES2 messages

  • RACF alerts

  • NetView automation

Tudo baseado em eventos.


☕ O Mainframe é naturalmente orientado a eventos

Porque em sistemas críticos:

🔥 reagir rápido é sobrevivência.


☕🔥 SSE — STREAMING CONTÍNUO NO DNA DO z/OS

Server-Sent Events enviam dados continuamente.


☕ O Mainframe já fazia isso há décadas

OMEGAMON

Streaming operacional contínuo.


RMF

Métricas em tempo real.


SMF

Fluxo permanente de eventos do sistema.


☕ Ambientes financeiros usam isso brutalmente

  • monitoramento

  • fraude

  • observabilidade

  • auditoria

  • analytics em tempo real


☕🔥 MQTT — O MAINFRAME ENCONTROU A IoT

MQTT domina:

  • sensores

  • IoT

  • dispositivos leves


☕ E o Mainframe?

Hoje ele processa eventos vindos de:

  • caixas eletrônicos

  • POS

  • sensores industriais

  • dispositivos bancários

  • telemetria


☕ IBM MQ facilita isso

MQTT → MQ → z/OS.


☕ O Mainframe virou cérebro central de IoT corporativa

Sim.

Isso realmente existe.


☕🔥 AMQP — O ESPÍRITO DO MQ ESTAVA NA FRENTE DO TEMPO

AMQP formalizou mensageria aberta.

Mas o IBM MQ já fazia:

  • persistência

  • roteamento

  • filas

  • entrega garantida

  • transação

há muito tempo.


☕ IBM MQ É UMA LENDA CORPORATIVA

Porque resolve algo extremamente difícil:

🔥 comunicação confiável entre sistemas gigantescos.


☕🔥 EDI — O “PROTOCOLO INVISÍVEL” QUE MOVE O COMÉRCIO MUNDIAL

Muita gente jovem nunca ouviu falar em EDI.

Mas ele ainda move:

  • logística

  • indústria

  • bancos

  • supply chain

  • varejo mundial


☕ E onde ele sempre foi fortíssimo?

👉 No Mainframe.


☕ Exemplo

Pedido eletrônico:

Empresa A
   ↓
EDI
   ↓
Mainframe
   ↓
ERP
   ↓
Faturamento

Décadas funcionando.


☕🔥 A GRANDE VERDADE QUE O MERCADO ESTÁ REDESCOBRINDO

Quanto mais o mundo cresce…

mais ele percebe que integração corporativa exige:

  • confiabilidade

  • resiliência

  • auditoria

  • governança

  • throughput

  • segurança

E isso sempre foi território natural do Mainframe.


☕🔥 O FUTURO NÃO É “MAINFRAME vs CLOUD”

Esse pensamento morreu.

O futuro é:

Cloud
  +
APIs
  +
Eventos
  +
Mainframe

☕ O IBM Z virou peça central da arquitetura híbrida

Hoje ele conversa com:

  • Kubernetes

  • OpenShift

  • AWS

  • Azure

  • Kafka

  • APIs REST

  • IA generativa

  • microsserviços

sem abandonar:

🔥 estabilidade absurda.


☕🔥 CONCLUSÃO — O MUNDO MODERNO NÃO SUBSTITUIU O MAINFRAME

Ele apenas:

começou finalmente a conversar com ele da forma correta.

REST, GraphQL, MQTT, gRPC e WebSockets não aposentaram o z/OS.

Na verdade…

🔥 eles transformaram o Mainframe no coração silencioso da integração mundial.


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...