Translate

segunda-feira, 27 de abril de 2026

💣🔥 LAB DE GUERRA — FINTECH NO z/OS: TPS REAL, LEDGER CONSISTENTE E MULTI-REGIÃO SEM ILUSÃO 🔥💣

 

Bellacosa Mainframe em Lab TPS 

💣🔥 LAB DE GUERRA — FINTECH NO z/OS: TPS REAL, LEDGER CONSISTENTE E MULTI-REGIÃO SEM ILUSÃO 🔥💣

Aqui não é slide. Aqui é produção simulada.
Você vai montar um fluxo que separa quem roda código de quem segura banco no ar.


⚙️ VISÃO DO LAB (ARQUITETURA)

👉 Dois mundos:

🔴 Região BR (CICS AOR)

  • Entrada da transação
  • Validação
  • Débito local (ledger consistente)

🔵 Região MX (CICS AOR)

  • Recebe evento assíncrono
  • Aplica crédito

⚫ TOR (Terminal Owning Region)

  • Entrada de carga (simulação TPS)

🧠 OBJETIVO DO LAB

Você vai provar na prática:

  • 💰 Ledger consistente localmente
  • ♻️ Idempotência salvando sua vida
  • 🔁 Assíncrono dominando multi-região
  • 📊 TPS ≠ Throughput (medido, não teórico)

📦 COMPONENTES

  • COBOL (CICS)
  • VSAM KSDS (ledger)
  • DB2 (controle/idempotência)
  • TSQ/TDQ (fila assíncrona simulando Kafka)
  • JCL (carga batch TPS)

🧾 1. LEDGER CONSISTENTE (COBOL + VSAM)

💣 Aqui não tem brincadeira: saldo é consistência forte local

Estrutura VSAM

ACCOUNT-ID PIC X(10)
BALANCE PIC S9(15)V99
LAST-UPDATE PIC X(26)

COBOL (CICS - débito)

EXEC CICS READ
FILE('LEDGER')
INTO(WS-ACCOUNT)
RIDFLD(WS-ACCOUNT-ID)
END-EXEC

IF WS-BALANCE < WS-AMOUNT
MOVE 'INSUFFICIENT' TO WS-STATUS
EXEC CICS ABEND END-EXEC
END-IF

SUBTRACT WS-AMOUNT FROM WS-BALANCE

EXEC CICS REWRITE
FILE('LEDGER')
FROM(WS-ACCOUNT)
END-EXEC

🔥 Isso aqui é o seu TPS real
👉 Só conta se COMMITOU


♻️ 2. IDEMPOTÊNCIA (DB2 — ANTI-DUPLICAÇÃO)

💣 Sem isso, retry vira fraude.

Tabela DB2

CREATE TABLE TX_CONTROL (
TX_ID VARCHAR(36) PRIMARY KEY,
STATUS VARCHAR(10),
CREATED_AT TIMESTAMP
);

Lógica COBOL

EXEC SQL
SELECT STATUS INTO :WS-STATUS
FROM TX_CONTROL
WHERE TX_ID = :WS-TX-ID
END-EXEC

IF SQLCODE = 0
MOVE 'DUPLICATE' TO WS-STATUS
GOBACK
END-IF

EXEC SQL
INSERT INTO TX_CONTROL VALUES (:WS-TX-ID, 'NEW', CURRENT TIMESTAMP)
END-EXEC

🔥 Resultado:

  • Retry seguro
  • Zero duplicação
  • TPS protegido

🔁 3. FLUXO ASSÍNCRONO (TSQ/TDQ)

💣 Aqui nasce a escalabilidade.

Após débito (BR)

EXEC CICS WRITEQ TS
QUEUE('TXQUEUE')
FROM(WS-EVENT)
END-EXEC

Consumidor (MX)

EXEC CICS READQ TS
QUEUE('TXQUEUE')
INTO(WS-EVENT)
END-EXEC

🔥 Tradução moderna:

Você acabou de simular Kafka no mainframe raiz.


🌍 4. MULTI-REGIÃO (SIMULADO)

💣 Não existe commit distribuído aqui.

Fluxo:

  1. BR debita (consistente)
  2. Evento vai para fila
  3. MX processa depois
  4. Reconciliação se falhar

👉 Isso evita:

  • lock global
  • latência absurda
  • TPS morto

📊 5. SIMULAÇÃO REAL — TPS vs THROUGHPUT

JCL de carga

//LOADTPS JOB ...
//STEP1 EXEC PGM=TXGEN
//SYSIN DD *
TPS=10000
DURATION=60
/*

Resultado esperado

MétricaValor
Requests/s10.000
TPS real2.500–4.000
Latência50–300ms
Retry5–15%

💣 Interpretação Bellacosa:

  • Throughput alto = sistema ocupado
  • TPS alto = sistema fazendo dinheiro acontecer

⚠️ TESTES DE CAOS (OBRIGATÓRIO)

👉 Derrube o consumidor (MX)

  • TPS local continua alto
  • Fila cresce

👉 Simule duplicação

  • Idempotência segura

👉 Force latência

  • TPS cai se você errar arquitetura

☠️ LIÇÃO FINAL

Sistema financeiro NÃO escala com tecnologia.
Escala com decisão arquitetural consciente.


🔥 FECHAMENTO (NÍVEL PRODUÇÃO)

Se você entendeu esse LAB, você já sabe:

  • Por que Kafka não salva arquitetura ruim
  • Por que consistência custa TPS
  • Por que assíncrono é obrigatório
  • Por que ledger não negocia

🔥💣 RAG NÃO SOBE JOB: O DIA EM QUE A IA QUEBROU O MAINFRAME (E NINGUÉM SABIA POR QUÊ) 💣🔥

 

Bellacosa Mainframe e os perigos da IA

🔥💣 RAG NÃO SOBE JOB: O DIA EM QUE A IA QUEBROU O MAINFRAME (E NINGUÉM SABIA POR QUÊ) 💣🔥

Um guia definitivo — raiz, sem filtro e sem buzzword — para quem quer usar IA no mundo COBOL sem destruir produção


Se você está entrando agora no mundo do mainframe — ou pior, se já está nele e alguém apareceu com um PowerPoint prometendo “modernização com IA em 3 meses” — este artigo é o seu firewall mental.

Porque aqui vai a verdade que ninguém coloca no slide:

💣 Mainframe não é código. É execução.

E execução tem história, dependência, tempo, estado… e consequências.


🧠⚙️ FUNDAMENTO: O QUE OS “PADAWANS COBOL” PRECISAM ENTENDER

Antes de falar de IA, RAG ou qualquer buzzword, você precisa internalizar isso:

🏦 O ecossistema real do z/OS

  • COBOL → lógica de negócio
  • JCL (Job Control Language) → orquestração
  • CICS → mundo transacional online
  • VSAM → armazenamento estruturado crítico
  • Db2 → consistência e persistência
  • Scheduler (Control-M, CA-7) → o “tempo” do sistema

👉 Isso forma um grafo de execução vivo.

Não é um repositório. Não é um projeto.
É um organismo.


💣🔥 O PECADO ORIGINAL: “CÓDIGO É SÓ TEXTO”

Ferramentas modernas tratam código assim:

função → entrada → saída

Mas no mainframe:

JCL → dataset → SORT → VSAM → COBOL → CICS → Db2 → JOB seguinte

💥 Isso é um pipeline físico e temporal.


🤖 O QUE É RAG (E POR QUE ELE TE TRAI)

RAG (Retrieval-Augmented Generation) faz:

  1. Quebra código em pedaços
  2. Vetoriza (transforma em embeddings)
  3. Busca por similaridade
  4. Responde com base nisso

👉 Funciona bem em:

  • APIs modernas
  • microserviços
  • código isolado

👉 Falha brutalmente em:

  • sistemas batch
  • fluxos dependentes
  • ambientes com estado externo

⚠️💣 EXEMPLO REAL — O ERRO QUE TODO MUNDO COMETE

🧾 Código COBOL:

READ CLIENTE-FILE
IF STATUS NOT = 'OK'
PERFORM ERRO
END-IF

🤖 IA (RAG) responde:

“Se falhar, chama rotina ERRO”

😈 Realidade:

  • O arquivo foi gerado por um SORT no JCL
  • O erro dispara um ABEND
  • O CICS intercepta
  • Um handler redireciona
  • O erro vai para Db2
  • Um job batch reconcilia depois

💣 Resultado:
A IA ignorou 80% do sistema.


⏱️💀 O FATOR TEMPO (O ASSASSINO SILENCIOSO)

Mainframe não é só lógica — é quando algo acontece.

Exemplo:

01:00 → JOB-A cria dataset
02:00 → JOB-B transforma
03:00 → COBOL processa

👉 Se o JOB-A falhar:

  • o COBOL continua existindo
  • mas o sistema quebra

💥 RAG não vê isso.


🕳️🔥 CICS: O BURACO NEGRO DA ANÁLISE

No mundo online:

  • Você NÃO chama programa diretamente
  • Existe:
    • definição de transação
    • routing
    • interceptação

👉 O fluxo real passa por camadas invisíveis ao código.

💣 Resultado:
A lógica está fora do COBOL.


🚨💣 RISCOS REAIS (NÃO TEÓRICOS)

1. 🔥 Decisão errada de negócio

IA responde incompleto → time muda código → quebra fluxo batch


2. 💥 Impacto invisível

Mudança em um programa:

  • quebra 3 jobs
  • afeta 2 sistemas downstream
  • só aparece às 3 da manhã

3. ⚠️ Compliance e auditoria

Sistema financeiro exige rastreabilidade
RAG não explica origem do dado


4. 🧨 Debug impossível

Erro não está no código
Está no fluxo


🐞💣 BUG CLÁSSICO DE QUEM USA IA ERRADO

“O programa não mudou, mas o resultado mudou”

👉 Motivo:

  • dataset diferente
  • ordem diferente
  • job anterior falhou

💥 IA não vê histórico → você caça fantasma


🧠💡 BOAS PRÁTICAS (OU COMO NÃO VIRAR INCIDENTE)

✅ 1. Modele o fluxo, não só o código

  • entenda JCL
  • entenda datasets
  • entenda ordem de execução

✅ 2. Pense em GRAFO, não em arquivos

  • quem chama quem
  • quem depende de quem
  • quem produz o quê

✅ 3. Trace o lineage dos dados

Pergunta chave:

“De onde veio esse dataset?”

Se você não sabe → risco crítico


✅ 4. Entenda o runtime

  • batch vs online
  • interceptações CICS
  • handlers

✅ 5. Use IA como apoio — não como verdade

IA ajuda, mas:

💣 não tem visão sistêmica por padrão


🛠️🔥 ARQUITETURA CORRETA (NÍVEL PROFISSIONAL)

Se quiser usar IA de verdade:

🧩 Combine:

  • Graph Database → dependências reais
  • Parser de JCL → fluxo batch
  • Parser CICS → fluxo online
  • Lineage de dados → origem real
  • Observabilidade → runtime

💡 Resultado:

Você responde perguntas como:

  • “Se eu mudar isso, o que quebra?”
  • “Qual job depende disso?”
  • “Qual dataset alimenta isso?”
  • “Qual fluxo gera esse erro?”

🧭💣 PASSO A PASSO (CAMINHO CERTO)

🥇 Passo 1 — Mapear JCL

  • jobs
  • steps
  • datasets

🥈 Passo 2 — Mapear programas COBOL

  • entradas
  • saídas
  • chamadas

🥉 Passo 3 — Mapear CICS

  • transações
  • programas
  • routing

🏅 Passo 4 — Construir grafo

  • dependência real
  • fluxo completo

🎯 Passo 5 — Só então usar IA

  • enriquecimento
  • análise
  • explicação

🧠📚 BASE TEÓRICA (SEM ISSO VOCÊ SOFRE)

Você precisa dominar:

  • Execução batch
  • Dependência temporal
  • Data lineage
  • Sistemas distribuídos (pré-cloud!)
  • Arquitetura orientada a eventos (sim, mainframe já fazia isso)

💣🔥 FRASES QUE VOCÊ NUNCA MAIS ESQUECE

💥 “COBOL não é o sistema. É só a interface da lógica.”

💥 “JCL é o diretor do filme — COBOL é o ator.”

💥 “Se você não entende o fluxo, você não entende o bug.”

💥 “IA sem contexto é só autocomplete caro.”


🚀💣 CONCLUSÃO (A VERDADE NUA)

A promessa de “jogar COBOL em vetor e entender tudo” é sedutora…

…mas perigosa.

Porque:

👉 Mainframe não é texto
👉 Mainframe é execução
👉 Execução tem tempo, estado e dependência

E isso NÃO cabe em embedding.


🧠🔥 MISSÃO PARA OS PADAWANS

Se você quer dominar isso de verdade:

  1. Leia JCL como se fosse código
  2. Siga o caminho do dado
  3. Pense em fluxo, não em linha
  4. Questione qualquer IA
  5. Nunca confie em resposta sem contexto

💣🔥 FINAL ESTILO RAIZ

Se sua IA não entende JCL…
ela não entende seu sistema.

E se ela não entende seu sistema…
ela não deveria chegar perto da produção.


.


🧠💡 O QUE É RAG?

RAG significa:

Retrieval-Augmented Generation
(Geração aumentada por recuperação)

👉 Em português simples:

💬 Uma IA que responde usando informações buscadas em uma base de dados.


🔧 COMO FUNCIONA (VISÃO PRÁTICA)

O RAG segue esse fluxo:

1. 📚 Você fornece conteúdo

  • código
  • documentos
  • PDFs
  • base de conhecimento

2. 🧩 O sistema “quebra” tudo

Exemplo:

Programa COBOL → dividido em pedaços menores

3. 🔢 Vetorização

Cada pedaço vira um vetor (embedding):

👉 uma representação matemática do texto


4. 🔍 Busca por similaridade

Quando você pergunta algo:

“Como funciona validação de conta?”

O sistema:

  • transforma sua pergunta em vetor
  • procura pedaços “parecidos”

5. 🤖 Geração da resposta

O modelo usa:

  • sua pergunta
    • os trechos encontrados

👉 para montar a resposta


💣 RESUMO EM UMA LINHA

RAG = IA + busca inteligente em conteúdo relevante


🔥 EXEMPLO SIMPLES

Você pergunta:

“Onde o cliente é validado?”

O RAG:

  • acha um trecho COBOL com IF CLIENTE-OK
  • retorna explicação baseada nisso

👉 Parece mágico… mas aqui começa o perigo.


⚠️💣 O PROBLEMA (PRINCIPAL)

RAG funciona baseado em:

🔎 similaridade de TEXTO

E NÃO em:

  • fluxo real
  • execução
  • dependência
  • contexto externo

🧠💥 ANALOGIA (FACILITA MUITO)

Imagine:

👉 Você lê páginas soltas de um livro
👉 e tenta entender a história inteira

💣 Isso é RAG.


🏦 NO MUNDO MODERNO

Funciona bem em:

  • documentação
  • APIs
  • microserviços
  • código recente

Porque:
👉 tudo está no próprio código


💀 NO MAINFRAME

Aqui ele sofre:

  • JCL controla execução
  • CICS controla fluxo
  • datasets vêm de outros jobs
  • lógica está espalhada

👉 O código sozinho NÃO conta a história


🔥 EXEMPLO REAL (DOR DE PRODUÇÃO)

Pergunta:

“O que acontece quando falha a validação?”

🤖 RAG responde:

  • lógica IF no COBOL

😈 Realidade:

  • erro interceptado no CICS
  • redirecionado
  • gravado no Db2
  • tratado em batch depois

💣 O RAG erra porque não vê o sistema inteiro


🧠💡 QUANDO USAR RAG

✅ Bom uso:

  • documentação técnica
  • FAQ
  • busca em código isolado
  • suporte a desenvolvedor

❌ Péssimo uso:

  • análise de sistemas complexos
  • dependência batch
  • impacto de mudança
  • fluxo mainframe

⚙️ RESUMO TÉCNICO (NÍVEL MAIS PROFUNDO)

RAG combina:

  • LLM (modelo de linguagem)
  • Vector Database
  • Busca semântica

👉 Ele NÃO entende execução
👉 Ele NÃO entende tempo
👉 Ele NÃO entende dependência real


💣🔥 FRASE PRA GUARDAR

RAG entende o que está escrito
mas não entende o que acontece


🚀 FECHAMENTO

RAG é poderoso — mas:

👉 é ferramenta de leitura
👉 não é ferramenta de entendimento sistêmico



🔥💣 CICS TOR + AOR NA VEIA — O LAB QUE TRANSFORMA SEU MAINFRAME EM UM CLUSTER DE GUERRA 💣🔥

 

Bellacosa Mainframe CICS TOR AOR na pratica

🔥💣 CICS TOR + AOR NA VEIA — O LAB QUE TRANSFORMA SEU MAINFRAME EM UM CLUSTER DE GUERRA 💣🔥

Se você já leu teoria e ainda não “atravessou o portal” do TOR/AOR… relaxa. Isso é clássico. CICS distribuído só faz sentido quando você monta, quebra e conserta. Então bora pro LAB estilo Bellacosa: mão na massa, sem firula, com dicas de quem já tomou S0C4 na madrugada 😄


🧠 VISÃO RÁPIDA (SEM ENROLAÇÃO)

  • TOR (Terminal Owning Region)
    👉 Onde os terminais conectam (3270 / usuários)
  • AOR (Application Owning Region)
    👉 Onde os programas COBOL rodam
  • Comunicação: MRO (Multi-Region Operation) via ISC (Inter-System Communication)

🧪 LAB — ARQUITETURA

[ USER / 3270 ]
|
(TOR)
|
MRO / ISC
|
(AOR)
|
DB2 / VSAM

⚙️ PRÉ-REQUISITOS

  • CICS TS instalado (qualquer versão moderna serve)
  • 2 regiões CICS (ou 2 STCs diferentes)
  • VTAM ativo
  • JES2 rodando
  • RACF (opcional, mas recomendado)

🏗️ PASSO 1 — CRIAR AS DUAS REGIÕES

Você precisa de:

  • CICSTOR
  • CICSAOR

👉 Copie uma região base:

//COPYTOR EXEC PGM=IEBCOPY

Crie duas cópias do DFHRPL / DFHCSD

💡 Dica Bellacosa:
Nunca compartilhe DFHCSD no começo. Separe. Depois você evolui.


⚙️ PASSO 2 — CONFIGURAR TOR

No TOR:

  • Sem lógica de negócio
  • Só roteamento

RDO (CEDA)

DEFINE TERMINAL(...)
DEFINE CONNECTION(AORCONN)
DEFINE SESSION(AORSESS)
DEFINE SYSID(AOR1)

⚙️ PASSO 3 — CONFIGURAR AOR

No AOR:

  • Programas ativos
  • Transações reais
DEFINE PROGRAM(MYPROG)
DEFINE TRANSACTION(MYTX)

💡 Aqui é onde mora o COBOL raiz.


🔗 PASSO 4 — CONFIGURAR MRO (O PULO DO GATO)

No TOR:

DEFINE CONNECTION(AOR1)
GROUP(MRO)
NETNAME(AOR1)

DEFINE SESSION(AOR1)
CONNECTION(AOR1)
PROTOCOL(LU62)

No AOR:

DEFINE CONNECTION(TOR1)
DEFINE SESSION(TOR1)

🔥 PASSO 5 — TRANSACTION ROUTING

No TOR:

DEFINE TRANSACTION(MYTX)
PROGRAM(MYPROG)
REMOTESYSTEM(AOR1)

💥 BOOM: agora o TOR encaminha pro AOR


🧪 PASSO 6 — TESTE

  1. Loga no TOR
  2. Digita MYTX
  3. Execução ocorre no AOR

👉 Se funcionar: você virou outro profissional
👉 Se não funcionar: bem-vindo ao mundo real 😄


🚨 TROUBLESHOOTING (OU “POR QUE NÃO FUNCIONA?”)

❌ SYSIDERR

  • SYSID não definido igual nos dois lados

❌ APPC / ISC DOWN

  • VTAM não levantou sessão

❌ TRANSID NOT FOUND

  • Definição não está no TOR

❌ AEI0 / AEY9

  • Problema de routing / security

💡 Dica de ouro:
Use:

CEMT I CONN
CEMT I SESS

💣 DICAS DE GUERRA (ESSAS NÃO TEM EM LIVRO)

  • TOR NÃO roda lógica → se rodar, você já errou arquitetura
  • AOR pode escalar horizontalmente
  • MRO local é mais simples que IPIC (comece por ele!)
  • Sempre versione DFHCSD
  • Nome de SYSID tem que bater EXATAMENTE

🧠 CURIOSIDADES (RAIZ MAINFRAME)

  • TOR/AOR surgiu para escala antes da nuvem existir
  • É basicamente um load balancer dos anos 80
  • Grandes bancos usam isso até hoje com dezenas de AORs

📦 EXEMPLO REAL (SIMPLIFICADO)

TOR → recebe 5000 usuários
AOR1 → contas
AOR2 → crédito
AOR3 → investimentos

👉 Cada AOR especializado
👉 TOR só roteia


📚 MATERIAL DE APOIO (OURO PURO)

Se você quer atravessar de vez:

  • IBM CICS Transaction Server Documentation (IBM Docs)
  • Redbook:
    👉 CICS Intercommunication Guide
  • Curso oficial IBM:
    👉 CICS TS System Administration

💡 Dica sincera:
O melhor material ainda é… quebrar ambiente e arrumar


🧪 DESAFIO FINAL (NÍVEL HARD)

  • Crie 2 AORs
  • Faça load balancing manual
  • Simule falha de um AOR
  • Veja o TOR redirecionando

👉 Se fizer isso: você não é mais iniciante


💥 FECHAMENTO ESTILO BELLOCAZA

CICS distribuído não é teoria.
É arquitetura viva.

Você não aprende lendo…
👉 aprende quando dá erro às 3 da manhã e você resolve.

Bellacosa Mainframe mão na massa CICS TOR AOR

🔥💣 LAB COMPLETO CICS TOR + AOR — DO ZERO AO “ROUTING FUNCIONANDO” 💣🔥

JCL + DFHCSD + RDO + TESTE REAL (estilo Bellacosa: direto ao ponto, mas com os macetes que evitam horas de dor)

Objetivo: levantar duas regiões CICS (TOR e AOR), configurar MRO/ISC, publicar uma transação roteada e testar ponta a ponta.


🧠 ARQUITETURA DO LAB

[ 3270 USER ]
|
TOR (CICSTOR)
|
MRO / ISC
|
AOR (CICSAOR)
|
PROG COBOL / VSAM

📦 CONVENÇÕES USADAS

  • TOR: CICSTOR (SYSID = TOR1)
  • AOR: CICSAOR (SYSID = AOR1)
  • Transação: MYTX
  • Programa: MYPROG
  • Grupo RDO: GRPTOR, GRPAOR, GRPMRO

💡 Regra de ouro: nomes idênticos (SYSID/CONNECTION/SESSION) nos dois lados — 80% dos erros somem aqui.


🏗️ 1) PROVISIONAR AS REGIÕES (JCL)

▶️ CICSTOR (TOR)

//CICSTOR PROC
//CICS EXEC PGM=DFHSIP,REGION=0M,
// PARM='CICSTOR,SYSID=TOR1'
//STEPLIB DD DSN=CICS.SDFHLOAD,DISP=SHR
//DFHCSD DD DSN=CICSTOR.DFHCSD,DISP=SHR
//DFHRPL DD DSN=CICSTOR.LOADLIB,DISP=SHR
//DFHPRINT DD SYSOUT=*
//DFHLOG DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD DUMMY

▶️ CICSAOR (AOR)

//CICSAOR PROC
//CICS EXEC PGM=DFHSIP,REGION=0M,
// PARM='CICSAOR,SYSID=AOR1'
//STEPLIB DD DSN=CICS.SDFHLOAD,DISP=SHR
//DFHCSD DD DSN=CICSAOR.DFHCSD,DISP=SHR
//DFHRPL DD DSN=CICSAOR.LOADLIB,DISP=SHR
//DFHPRINT DD SYSOUT=*
//DFHLOG DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD DUMMY

💡 Dica Bellacosa:
Separe DFHCSD por região no início. Compartilhar cedo = confusão garantida.


🧱 2) INICIALIZAR DFHCSD (SE AINDA NÃO EXISTIR)

//DEFCTLG EXEC PGM=DFHCSDUP
//STEPLIB DD DSN=CICS.SDFHLOAD,DISP=SHR
//DFHCSD DD DSN=CICSTOR.DFHCSD,DISP=SHR
//SYSIN DD *
DEFINE GROUP(GRPTOR) DESCRIPTION(TOR BASE)
DEFINE GROUP(GRPMRO) DESCRIPTION(MRO TOR)
/*

Repita para AOR mudando dataset e grupos (GRPAOR, GRPMRO).


🔗 3) RDO — MRO (CONNECTION + SESSION + SYSID)

▶️ NO TOR (CICSTOR)

CEDA DEF SYSID(AOR1) GROUP(GRPMRO)

CEDA DEF CONNECTION(AOR1) GROUP(GRPMRO)
NETNAME(AOR1)
ACCESSMETHOD(VTAM)

CEDA DEF SESSION(AOR1) GROUP(GRPMRO)
CONNECTION(AOR1)
PROTOCOL(LU62)
MAXIMUM(10)

▶️ NO AOR (CICSAOR)

CEDA DEF SYSID(TOR1) GROUP(GRPMRO)

CEDA DEF CONNECTION(TOR1) GROUP(GRPMRO)
NETNAME(TOR1)
ACCESSMETHOD(VTAM)

CEDA DEF SESSION(TOR1) GROUP(GRPMRO)
CONNECTION(TOR1)
PROTOCOL(LU62)
MAXIMUM(10)

💡 Macete crítico:
NETNAME deve bater com definição VTAM/APPLID.


🧠 4) AOR — PROGRAMA + TRANSAÇÃO

CEDA DEF PROGRAM(MYPROG) GROUP(GRPAOR)
LANGUAGE(COBOL)

CEDA DEF TRANSACTION(MYTX) GROUP(GRPAOR)
PROGRAM(MYPROG)

💻 COBOL EXEMPLO (MYPROG)

IDENTIFICATION DIVISION.
PROGRAM-ID. MYPROG.

DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-MSG PIC X(40) VALUE 'RODANDO NO AOR COM SUCESSO'.

PROCEDURE DIVISION.
EXEC CICS SEND TEXT FROM(WS-MSG)
ERASE FREEKB
END-EXEC.
EXEC CICS RETURN END-EXEC.

🚀 5) TOR — TRANSACTION ROUTING

👉 Aqui acontece a mágica

CEDA DEF TRANSACTION(MYTX) GROUP(GRPTOR)
PROGRAM(MYPROG)
REMOTESYSTEM(AOR1)

💥 Isso diz:
“Quando digitarem MYTX no TOR → manda pro AOR1”


▶️ 6) SUBIR AS REGIÕES

//S TOR
//S AOR

Ou via JES2:

/S CICSTOR
/S CICSAOR

🧪 7) TESTE REAL

  1. Loga no TOR
  2. Digita: MYTX
  3. Resultado esperado:
RODANDO NO AOR COM SUCESSO

👉 Se apareceu: você DOMINOU MRO básico


🚨 8) TROUBLESHOOTING RAIZ

🔍 Ver conexões

CEMT I CONN
CEMT I SESS

🔴 Problemas clássicos

  • SYSIDERR → SYSID não bate
  • ISC CLOSED → VTAM não subiu
  • AEY9 → routing errado
  • NOTAUTH → RACF bloqueando

💣 DICAS DE PRODUÇÃO (OURO)

  • Nunca misture lógica no TOR
  • Use múltiplos AORs para escala
  • Versione DFHCSD (backup sempre!)
  • Comece com MRO → depois evolua pra IPIC
  • Monitore com SMF 110

🧠 CURIOSIDADE DE ARQUITETURA

TOR/AOR é literalmente o ancestral do microserviço + load balancer.
Década de 80… já resolvendo problema de escala que muita stack moderna ainda sofre 😄


📚 MATERIAL DE APOIO (SE QUISER IR MAIS FUNDO)

  • IBM CICS Transaction Server Docs (IBM)
  • Redbook: CICS Intercommunication Guide
  • CEDA / CEMT Reference Guide

🧪 DESAFIO HARD (PRÓXIMO NÍVEL)

  • Criar 2 AORs (AOR1 + AOR2)
  • Duplicar MYPROG
  • Alternar REMOTESYSTEM manualmente
  • Simular queda de AOR1

👉 Se fizer isso… você já pensa como arquiteto CICS


💥 FECHAMENTO

Isso aqui não é só um lab.
É o momento que separa quem leu sobre CICS de quem opera CICS de verdade.