☕ 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

quinta-feira, 7 de março de 2024

Mr. Spock Entra no CPD — O Dia em que o Programador COBOL Disse “É Só um SELECT” e Descobriu uma Civilização Inteira Dentro do Db2

 

Bellacosa Mainframe por dentro do Db2

☕ Um Café no Bellacosa Mainframe

Mr. Spock Entra no CPD — O Dia em que o Programador COBOL Disse “É Só um SELECT” e Descobriu uma Civilização Inteira Dentro do Db2

Ou: por que Buffer Pool, IRLM, DDF, Catalog, Directory, Logs, RUNSTATS, Package, RACF, WLM e Parallel Sysplex fazem parte da mesma missão — e por que dizer que Db2 é “apenas um banco de dados” seria, segundo Spock, altamente ilógico

O turno da noite estava tranquilo.

Tranquilo demais.

E todo profissional de mainframe com alguma estrada sabe que essa frase normalmente é seguida por algum desastre.

O monitor do CICS estava verde. O JES2 aparentemente não tinha nada contra a humanidade naquele momento. O RACF não estava distribuindo ICH408I como panfleto em estação de metrô e nenhum operador havia entrado correndo no CPD gritando:

— A PRODUÇÃO PAROU!

Era quase suspeito.

O jovem programador COBOL, ainda naquela fase da carreira em que acreditamos que um programa que compilou também necessariamente funciona, olhou para sua rotina e anunciou:

EXEC SQL
   SELECT NOME,
          SALDO
     INTO :WS-NOME,
          :WS-SALDO
     FROM CLIENTE
    WHERE CONTA = :WS-CONTA
END-EXEC.

Ele sorriu.

— Pronto. É só um SELECT.

Uma sobrancelha levantou-se no outro lado da sala.

Mr. Spock havia entrado no CPD.

Ninguém soube explicar como um oficial científico da Frota Estelar havia conseguido autorização RACF, crachá temporário e acesso à área restrita do datacenter. Mas considerando que o pessoal de infraestrutura já havia liberado consultores externos com justificativas muito piores, ninguém perguntou.

Spock examinou o código.

Depois examinou o programador.

— Sua afirmação contém uma simplificação estatisticamente perigosa.

— Como assim?

— Você acredita ter executado um SELECT. Na realidade, iniciou uma sequência de eventos envolvendo processamento SQL, gerenciamento de memória, otimização, concorrência, storage, catálogo, controle transacional, autorização e possivelmente comunicação distribuída.

O programador ficou olhando para ele.

— Mas voltou um saldo.

— Exatamente. E esta é a parte fascinante.

Assim começa nossa viagem pela arquitetura do Db2 for z/OS.



1. Primeiro diagnóstico de Spock: Db2 não é uma caixa preta

Para muita gente que começa no COBOL, Db2 parece funcionar assim:

COBOL
  ↓
SQL
  ↓
Db2
  ↓
dados

É confortável.

Também está incompleto.

Uma representação mais próxima da realidade seria algo como:

Programa COBOL
      ↓
CICS / Batch / DDF
      ↓
Thread Db2
      ↓
Package
      ↓
Access Path
      ↓
DBM1
      ↓
Buffer Pools
      ↓
Table Space / Index Space
      ↓
DFSMS / Storage

Enquanto isso, paralelamente:

IRLM → locking
Logs → recovery
RACF → segurança
WLM → prioridade
Catalog → metadados
DDF → acesso distribuído

Spock provavelmente resumiria:

“A simplicidade percebida pelo programador é consequência da complexidade absorvida pela infraestrutura.”

E isso é um dos maiores triunfos do mainframe.



2. O que é um Db2 Subsystem?

Vamos começar pela porta da nave.

No z/OS, frequentemente trabalhamos com um Db2 subsystem.

Ele representa uma instância operacional do Db2 dentro daquele ambiente.

Uma empresa poderia ter algo como:

DB2D → desenvolvimento
DB2T → testes
DB2H → homologação
DB2P → produção

Os nomes variam conforme a instalação.

Não existe mandamento dizendo que produção precisa se chamar DB2P.

Aliás, se existe algo que mainframe ensina rapidamente é:

cada empresa tem suas tradições.

Algumas parecem normas técnicas.

Outras parecem decisões tomadas em 1989 por alguém chamado Geraldo, que se aposentou em 2003 e nunca documentou nada.

Curiosidade do CPD

É muito comum o iniciante dizer:

— Estou conectado no Db2.

O veterano pergunta:

— Qual?

E aí começa a aula.

Um mesmo ambiente pode possuir múltiplos subsystems.

Por isso entender onde seu programa está executando é tão importante quanto entender o que ele executa.



3. DBM1 — a sala de máquinas

No coração da arquitetura encontramos o DBM1, o Database Services Address Space.

É onde ocorre uma quantidade enorme do trabalho relacionado ao banco.

Dentro dessa paisagem aparecem conceitos como:

  • Buffer Pools;

  • EDM Pool;

  • estruturas de processamento;

  • threads;

  • acesso a dados;

  • gerenciamento interno;

  • execução de SQL.

Pense no DBM1 como a engenharia da Enterprise.

Você pode estar sentado confortavelmente na ponte dizendo:

— Warp 5.

Mas alguém lá embaixo precisa fazer o motor funcionar.

No COBOL seria:

EXEC SQL
   SELECT SALDO
     INTO :WS-SALDO
     FROM CONTA
    WHERE NUM_CONTA = :WS-CONTA
END-EXEC.

Do ponto de vista do desenvolvedor:

SELECT → resultado

Do ponto de vista da infraestrutura:

solicitação
→ contexto de execução
→ access path
→ memória
→ índice
→ páginas
→ locking
→ eventualmente I/O
→ retorno

“É só um SELECT” começa a parecer uma frase corajosa.


4. Buffer Pool — o truque que evita transformar cada consulta em uma excursão ao storage

Se existe um conceito que todo programador Db2 deveria entender cedo, é Buffer Pool.

Imagine que você tenha uma tabela com 100 milhões de registros.

O programa procura:

SELECT NOME
FROM CLIENTE
WHERE ID_CLIENTE = 928173;

Fisicamente, os dados estão persistidos em storage.

Se toda consulta tivesse que buscar diretamente no disco, teríamos:

programa
   ↓
Db2
   ↓
storage
   ↓
I/O
   ↓
Db2
   ↓
programa

Constantemente.

A performance seria digna de uma carroça klingon.

O Buffer Pool existe justamente para manter páginas de dados e índices em memória.

              MEMÓRIA

        ┌───────────────────┐
        │    BUFFER POOL    │
        │                   │
        │ páginas de dados  │
        │ páginas de índice │
        └─────────┬─────────┘
                  │
          página ausente?
                  │
              SIM ↓
               STORAGE

Se a página já está em memória, evitamos determinado I/O físico.

Essa diferença pode ser gigantesca.


5. O programador pensa em linha; o Db2 frequentemente pensa em página

Aqui está uma mudança de mentalidade poderosa.

O programador escreve:

WHERE CONTA = 12345

Ele pensa:

“Quero essa linha.”

O Db2 precisa lidar com estruturas de armazenamento organizadas em pages.

Então conceitualmente:

linha solicitada
      ↓
página onde ela está
      ↓
Buffer Pool
      ↓
storage se necessário

Isso explica por que performance de banco não pode ser estudada pensando apenas no SQL textual.

Existem questões envolvendo:

  • número de páginas;

  • organização dos dados;

  • índices;

  • clustering;

  • seletividade;

  • Buffer Pool;

  • I/O;

  • estatísticas.

Spock talvez acrescentasse:

— Confundir linha lógica com armazenamento físico seria ilógico.

O DBA responderia:

— Finalmente alguém me entende.


6. Table Space — onde a tabela mora

Uma tabela Db2 precisa viver em uma estrutura apropriada de armazenamento.

Entra o Table Space.

Podemos visualizar:

DATABASE
   │
   ├── TABLE SPACE
   │      │
   │      └── TABLE
   │
   └── INDEX SPACE
          │
          └── INDEX

Aqui vale uma distinção importante.

Table Space e Index Space não são exatamente a mesma coisa.

A tabela reside no Table Space.

O índice possui sua própria estrutura associada.

Essa diferença aparece bastante quando começamos a estudar:

  • utilities;

  • administração;

  • recovery;

  • reorganização;

  • performance.


7. Índice — o tricorder do Db2

Imagine um arquivo com 20 milhões de clientes.

Você quer:

SELECT *
FROM CLIENTE
WHERE CPF = '12345678900';

Sem um caminho adequado, o Db2 pode precisar examinar uma grande quantidade de dados.

Com um índice apropriado:

CPF procurado
    ↓
ÍNDICE
    ↓
localização das páginas
    ↓
dados

Parece maravilhoso.

E é.

Mas existe uma regra que iniciantes aprendem um pouco depois:

índice não é almoço grátis.

Cada índice pode representar:

  • armazenamento;

  • manutenção;

  • custo em INSERT;

  • custo em UPDATE;

  • custo em DELETE;

  • necessidade de reorganização;

  • estatísticas;

  • complexidade adicional.

Criar índice para absolutamente tudo seria como equipar cada tripulante da Enterprise com quinze tricorders.

Em algum momento alguém precisa carregar aquilo.


8. O Optimizer — Spock trabalhando dentro do Db2

Talvez nenhum componente mereça mais o título de “Mr. Spock interno” do que o optimizer.

Você escreve:

SELECT C.NOME,
       P.VALOR
FROM CLIENTE C
JOIN PAGAMENTO P
  ON P.ID_CLIENTE = C.ID_CLIENTE
WHERE C.UF = 'SP';

Você disse o que deseja.

Mas existe mais de uma maneira de conseguir aquilo.

O Db2 pode precisar decidir:

  • qual tabela acessar primeiro;

  • qual índice usar;

  • se deve usar índice;

  • método de join;

  • ordem das tabelas;

  • custo estimado;

  • paralelismo;

  • quantidade provável de linhas.

Esse conjunto de decisões produz o chamado access path.

Simplificando:

SQL
 ↓
Optimizer
 ↓
estatísticas
 ↓
custos estimados
 ↓
Access Path
 ↓
execução

É por isso que dois SQLs que entregam exatamente o mesmo resultado podem ter performances completamente diferentes.


9. RUNSTATS — não mande Spock calcular com sensores quebrados

O optimizer precisa tomar decisões.

Mas baseado em quê?

Em informações sobre os objetos e os dados.

Entram aí as statistics.

Imagine esta distribuição:

CLIENTE

SP = 5.000.000
RJ = 2.000.000
MG = 1.500.000
AC =    30.000
RR =    20.000

Agora compare:

WHERE UF = 'SP'

com:

WHERE UF = 'RR'

A seletividade pode ser radicalmente diferente.

O optimizer precisa ter noção disso.

Ferramentas como RUNSTATS ajudam a coletar estatísticas utilizadas nas decisões de otimização.

Metáfora Bellacosa

Imagine Spock calculando a rota até Vulcano.

Mas você fornece um mapa feito antes da construção das últimas cinquenta colônias.

Ele continua sendo brilhante.

Só está usando informação ruim.

Em banco de dados:

optimizer bom + estatística ruim = possibilidade de access path ruim.

Por isso performance não é apenas:

— “Reescreve esse SELECT.”

Às vezes o SQL estava perfeitamente aceitável.

O ambiente é que mudou.


10. EDM Pool — aquilo que não queremos reconstruir a toda hora

Outro componente importante é o EDM Pool — Environmental Descriptor Manager Pool.

Ele mantém estruturas importantes usadas pelo Db2, incluindo informações relacionadas a packages e estruturas de execução.

O conceito pedagógico é simples:

aquilo que custa processamento para construir pode ser vantajoso manter disponível em memória.

Não confunda EDM Pool com Buffer Pool.

O Buffer Pool trabalha fortemente com páginas de dados e índices.

O EDM Pool está associado a outras estruturas internas necessárias à execução.

Mas ambos ilustram uma obsessão saudável de sistemas de alta performance:

evitar trabalho desnecessário.


11. IRLM — ninguém toca nesse registro sem conversar com o segurança

Chegamos ao IRLM — Internal Resource Lock Manager.

O problema que ele ajuda a resolver é clássico.

Imagine:

Programa A

UPDATE CONTA
SET SALDO = 500
WHERE CONTA = 100;

Programa B

simultaneamente:

UPDATE CONTA
SET SALDO = 800
WHERE CONTA = 100;

Quem ganha?

Quem espera?

Quem pode ler?

Em qual momento?

Que isolamento estamos usando?

Sem controle de concorrência, banco de dados financeiro viraria bingo.

O IRLM participa do gerenciamento de locks.

Podemos pensar:

Programa A ─────┐
                ├── IRLM ── recurso
Programa B ─────┘

Locks existem para preservar consistência em ambientes concorrentes.

E ambiente mainframe costuma ser sinônimo de concorrência em escala bastante séria.


12. Deadlock — quando dois oficiais se recusam a sair da porta

Considere:

Programa A tem recurso X
Programa B tem recurso Y

Agora:

A precisa de Y
B precisa de X

Resultado:

A ───── espera por Y
↑                 │
│                 ↓
X espera por ───── B

Temos um deadlock.

Os dois ficariam esperando eternamente se o sistema não identificasse a situação.

O Db2 precisa detectar o problema e selecionar uma unidade de trabalho para ser interrompida.

Dica para COBOL iniciante

Quando ocorrer erro associado a deadlock ou timeout, não trate imediatamente como:

“Db2 caiu.”

Não.

Na maioria das vezes Db2 está vivíssimo.

Talvez vivo até demais.

Está protegendo a consistência contra seus programas.


13. LOCK não é LATCH

Esse é um pequeno easter egg técnico para quando você estiver conversando com alguém mais experiente.

Lock e latch não são sinônimos.

Locks estão fortemente associados ao controle lógico/transacional de concorrência.

Latches são mecanismos internos de serialização mais leves usados para proteger determinadas estruturas internas.

Portanto quando alguém disser:

— Temos contenção.

Pergunte:

— Que tipo?

Você ganhará pelo menos +3 pontos de experiência mainframe.

Talvez até um café.


14. Logs — a caixa-preta da Enterprise

Agora entramos em uma das áreas mais importantes do Db2.

Imagine:

UPDATE CONTA
SET SALDO = SALDO - 100
WHERE NUM_CONTA = 123;

Uma alteração aconteceu.

O sistema precisa ter capacidade de preservar consistência e recuperar-se de falhas.

Por isso existe toda uma arquitetura de logging.

Em uma visão simplificada:

alteração
   ↓
Log Buffer
   ↓
Active Logs
   ↓
Archive Logs

Os logs guardam informações fundamentais para:

  • recovery;

  • rollback;

  • restart;

  • consistência transacional.

Sem logs, um banco corporativo seria praticamente um caderno escrito a lápis durante um terremoto.


15. COMMIT — quatro letras e uma enorme responsabilidade

No COBOL:

EXEC SQL
   UPDATE CONTA
      SET SALDO = :WS-NOVO-SALDO
    WHERE NUM_CONTA = :WS-CONTA
END-EXEC.

EXEC SQL
   COMMIT
END-EXEC.

COMMIT não significa simplesmente:

“terminei.”

Ele marca uma fronteira transacional importante.

Imagine:

UPDATE
INSERT
DELETE
UPDATE
   ↓
COMMIT

A unidade de trabalho foi confirmada.

O gerenciamento correto de commit é particularmente importante em batch.

Por quê?

Imagine processar cinco milhões de registros e só dar COMMIT no final.

Isso pode aumentar:

  • volume de locks;

  • duração de locks;

  • quantidade de trabalho a desfazer;

  • impacto de rollback;

  • pressão operacional.

Por outro lado, dar COMMIT a cada registro também pode ser inadequado.

A frequência de commit deve ser desenhada conscientemente.

Não existe “número mágico universal”.


16. ACID — as quatro leis de Vulcano das transações

O Db2 trabalha sob princípios transacionais tradicionalmente descritos pela sigla ACID.

Atomicity

Ou a unidade de trabalho ocorre adequadamente ou precisamos impedir resultado parcial inconsistente.

Consistency

O banco deve passar de um estado válido para outro.

Isolation

Transações concorrentes precisam coexistir de forma controlada.

Durability

Depois de confirmado, o resultado deve sobreviver conforme as garantias do sistema.

Considere uma transferência:

Conta Kirk  -100
Conta Spock +100

O universo proibido seria:

Conta Kirk  -100

💥 falha

Conta Spock +0

O dinheiro sumiu em algum buraco de minhoca.

O banco central provavelmente não aceitaria “anomalia espaço-temporal” como justificativa.


17. Active Log, Archive Log e a arte de voltar no tempo sem DeLorean

Os Active Logs participam diretamente das operações correntes de logging do Db2.

Com o avanço do processamento, parte dessas informações pode ser arquivada em Archive Logs.

Conceitualmente:

atividade recente
       ↓
Active Logs
       ↓
arquivamento
       ↓
Archive Logs

Essa arquitetura é um dos pilares das capacidades de recovery.

E aqui entra outro personagem importante.


18. IMAGE COPY — a fotografia antes da tempestade

Uma Image Copy funciona como uma cópia utilizada em estratégias de recuperação dos objetos Db2.

Imagine:

00:00
IMAGE COPY
   │
   │ logs
   │ logs
   │ logs
   │
13:42
falha

Dependendo da estratégia e do cenário, combinamos:

IMAGE COPY
+
LOGS
+
procedimento de recovery

para reconstruir o estado necessário.

Isso é muito mais sofisticado do que aquela frase genérica:

“Restauramos o backup.”

Em ambientes grandes, recovery é ciência.


19. Catalog — o cartório galáctico

Imagine que você cria:

CREATE TABLE PLANETA
(
   ID_PLANETA INTEGER,
   NOME       VARCHAR(80),
   QUADRANTE  CHAR(1)
);

Db2 precisa saber:

  • que a tabela existe;

  • quais colunas existem;

  • seus tipos;

  • seus índices;

  • seus relacionamentos;

  • tablespace;

  • authorities;

  • estatísticas;

  • dependências.

Essas informações vivem no universo do Db2 Catalog.

A metáfora é simples:

Os dados são cidadãos.
O Catalog é o cartório.

Quer saber sobre determinado objeto?

Frequentemente você consulta tabelas do catálogo.


20. Directory — o compartimento em que Spock recomenda não mexer sem motivo

Além do Catalog existe o Db2 Directory.

São estruturas internas essenciais ao próprio funcionamento do Db2.

Uma distinção simplificada:

CATALOG
→ metadados administrativos acessíveis

DIRECTORY
→ estruturas internas do próprio Db2

Não trate os dois termos como sinônimos.

É uma daquelas diferenças que parece acadêmica no começo.

Depois você começa a estudar internals e percebe por que existia.


21. DDF — o momento em que o mainframe abre as portas da nave

Db2 for z/OS não serve apenas a COBOL rodando dentro do próprio mainframe.

Aplicações externas podem acessar Db2 utilizando DDF — Distributed Data Facility.

Por exemplo:

Java
Python
.NET
Linux
Windows
Cloud
   │
   ↓
DRDA
   ↓
TCP/IP
   ↓
DDF
   ↓
Db2 for z/OS

Isso destrói outro mito antigo:

“Mainframe é uma ilha.”

Há décadas não é.

O mainframe moderno pode conversar com praticamente o ecossistema corporativo inteiro.


22. DRDA — o diplomata entre mundos relacionais

DRDA — Distributed Relational Database Architecture fornece mecanismos padronizados para acesso distribuído a bancos relacionais.

Você pode imaginar:

Aplicação externa
      ↓
Driver
      ↓
DRDA
      ↓
TCP/IP
      ↓
DDF
      ↓
Db2

Ou seja, aquele programa Java no Kubernetes pode estar consultando informações que no final vivem no Db2 for z/OS.

O desenvolvedor Java talvez nem saiba.

E em muitos casos nem precisa saber.

Mas o arquiteto deveria.


23. COBOL + CICS + Db2 — o triângulo clássico

Agora voltamos à nossa velha sala de produção.

Um caminho clássico:

usuário
   ↓
CICS
   ↓
Programa COBOL
   ↓
SQL
   ↓
Db2

No programa:

EXEC SQL
   SELECT SALDO
     INTO :WS-SALDO
     FROM CONTA
    WHERE NUM_CONTA = :WS-CONTA
END-EXEC.

Parece natural.

Mas como o SQL foi parar dentro daquele programa executável?

Aí vem uma parte fundamental que muitos cursos passam rápido demais.


24. PRECOMPILE — COBOL e SQL precisam conversar

COBOL puro não interpreta nativamente aquele EXEC SQL.

Existe uma etapa de preparação.

De forma tradicional e simplificada:

Fonte COBOL + SQL
        ↓
   PRECOMPILER
      ┌─┴─────────────┐
      ↓               ↓
COBOL modificado     DBRM
      ↓               ↓
Compiler             BIND
      ↓               ↓
Object              Package
      ↓
Link
      ↓
Load Module

O precompiler identifica instruções SQL e prepara os elementos necessários para o processamento posterior.

Esse fluxo explica por que desenvolvimento COBOL + Db2 envolve muito mais que:

compilar
executar

25. DBRM e PACKAGE — o que Spock realmente queria encontrar

O DBRM guarda informações extraídas das instruções SQL durante a preparação.

Posteriormente ocorre o BIND.

O BIND gera estruturas como packages utilizadas pela execução.

Simplificando:

SQL
 ↓
DBRM
 ↓
BIND
 ↓
PACKAGE
 ↓
Access Path

O package é extremamente importante.

Porque o programa COBOL pode continuar exatamente igual enquanto o comportamento do SQL muda por razões relacionadas a:

  • rebind;

  • novas estatísticas;

  • novos índices;

  • alteração do ambiente;

  • manutenção;

  • mudança de release;

  • access path diferente.

Essa é uma das primeiras grandes revelações para quem trabalha com performance.

Código-fonte igual não significa necessariamente comportamento operacional idêntico.


26. BIND — o casamento arranjado entre SQL e Db2

O BIND é uma etapa fundamental da vida do SQL estático.

É quando informações do DBRM são utilizadas para produzir um package.

E ali são tomadas decisões importantíssimas.

Se você aprende apenas a programar:

EXEC SQL ...

mas não aprende:

  • package;

  • bind;

  • rebind;

  • access path;

você aprendeu a dirigir, mas nunca abriu o capô.

Serve.

Até o carro começar a fazer barulho.


27. O verdadeiro caminho de um SELECT

Nosso jovem programador agora olha novamente para:

SELECT SALDO
FROM CONTA
WHERE NUM_CONTA = :WS-CONTA;

Mas depois da aula de Spock ele já enxerga outra coisa:

COBOL
  ↓
CICS
  ↓
Thread Db2
  ↓
Package
  ↓
Access Path
  ↓
Index?
  ↓
Buffer Pool
  ↓
Página disponível?
   ├── SIM → usa memória
   └── NÃO → solicita I/O
                  ↓
                Storage
                  ↓
              Buffer Pool
                  ↓
                 Db2
                  ↓
                COBOL

Aquela linha de SQL agora parece uma missão espacial inteira.

E é exatamente essa mudança de percepção que diferencia alguém que apenas escreve SQL de alguém que começa a compreender o Db2.


28. DFSMS — quando descobrimos que storage também faz parte do banco

Db2 não administra storage em um vácuo.

No z/OS existe integração com o universo do DFSMS — Data Facility Storage Management Subsystem.

Entram conceitos como:

  • datasets;

  • volumes;

  • storage classes;

  • management classes;

  • data classes;

  • políticas SMS;

  • VSAM.

Esse ponto é profundamente “mainframe”.

Em plataformas mais simples, desenvolvedor e banco às vezes parecem universos separados do storage.

No z/OS, você começa a perceber que:

banco
+
storage
+
sistema operacional
+
segurança
+
workload management

formam uma arquitetura integrada.


29. E então aparece VSAM escondido atrás da cortina

Essa curiosidade normalmente surpreende o iniciante.

Db2 for z/OS utiliza infraestrutura de armazenamento associada ao ecossistema VSAM para seus datasets.

Então podemos desenhar:

Db2 object
   ↓
Table Space
   ↓
datasets
   ↓
VSAM / DFSMS
   ↓
storage

Mas atenção:

Isso NÃO significa que Db2 seja simplesmente “um VSAM com SQL”.

Db2 acrescenta um universo inteiro:

  • modelo relacional;

  • SQL;

  • optimizer;

  • locking;

  • logging;

  • recovery;

  • catálogo;

  • integridade;

  • transações.

VSAM e Db2 possuem propósitos e abstrações diferentes.


30. RACF — nem Spock acessa folha de pagamento sem autorização

Agora imagine:

SELECT *
FROM FOLHA_PAGAMENTO;

Tecnicamente válido.

Mas deveria qualquer programa poder executá-lo?

Claro que não.

Entram mecanismos de segurança do ambiente, incluindo integração com RACF e os mecanismos de autorização do próprio Db2.

A regra fundamental:

SQL válido
≠
SQL autorizado

E ainda bem.

Imagine um estagiário descobrindo:

SELECT *
FROM SALARIOS_DIRETORIA;

e dizendo:

— Funcionou no desenvolvimento.

Produção:

ICH408I

O RACF entra em cena como o segurança vulcano:

— Seu entusiasmo não constitui autorização.


31. WLM — todos são iguais, mas alguns workloads precisam responder em 100 milissegundos

Outro componente importante do ecossistema é o WLM — Workload Manager.

O z/OS pode administrar workloads conforme objetivos definidos.

Imagine simultaneamente:

Transação PIX
Consulta de saldo
Batch de faturamento
Relatório gerencial
Backup
Compilação
Job de teste

Todos querem CPU.

Todos acham que são importantes.

Alguns realmente são.

WLM ajuda o sistema a priorizar recursos conforme políticas de serviço.

Pense nele como o oficial de operações da ponte:

“Essa transação é crítica.”
“Esse relatório pode esperar.”
“Esse batch precisa terminar antes das 06:00.”

É uma das grandes razões pelas quais mainframes conseguem misturar workloads muito distintos de forma eficiente.


32. MQ, CICS, TCP/IP e companhia — Db2 nunca esteve sozinho

Observe uma arquitetura corporativa típica:

Mobile
  ↓
API
  ↓
z/OS Connect
  ↓
CICS
  ↓
COBOL
  ↓
Db2

Ao lado:

COBOL
  ↓
MQ
  ↓
sistema externo

Com:

RACF → segurança
WLM  → prioridades
DFSMS → storage
TCP/IP → comunicação
JES → batch

O segredo do mainframe nunca foi um único produto.

É a integração.

Isso vale para Db2 também.


33. Parallel Sysplex — quando uma Enterprise deixa de ser suficiente

Agora entramos em território mais avançado.

Em ambientes de altíssima disponibilidade, Db2 pode operar em configuração de Data Sharing, dentro do universo do Parallel Sysplex.

Imagine:

            Aplicações
                │
      ┌─────────┼─────────┐
      ↓         ↓         ↓
    DB2A      DB2B      DB2C
      │         │         │
      └─────────┼─────────┘
                ↓
      dados compartilhados

Vários membros Db2 podem trabalhar cooperativamente.

Isso proporciona benefícios associados a:

  • disponibilidade;

  • escalabilidade;

  • flexibilidade operacional;

  • continuidade.

Mas surge um problema lógico.

Se DB2A e DB2B acessam os mesmos dados:

Como garantir coerência?

Excelente pergunta, jovem cadete.


34. Coupling Facility e Group Buffer Pool

No Data Sharing entram estruturas disponibilizadas através da Coupling Facility.

Entre elas aparecem mecanismos relacionados a Group Buffer Pools e coordenação entre membros.

Simplificando:

DB2A                     DB2B
 │                         │
Buffer Pool            Buffer Pool
 │                         │
 └──────────┐   ┌──────────┘
            ↓   ↓
      Coupling Facility
            │
      Group Buffer Pool

Se vários membros acessam os mesmos dados, precisamos impedir que cada um viva numa realidade alternativa.

Afinal, nem Star Trek resolve consistência eventual com universo paralelo em folha de pagamento.


35. O programa funciona, mas está lento. E agora?

Este é um dos momentos mais importantes da carreira.

Iniciante:

“O SQL está lento.”

Profissional experiente:

“Vamos descobrir por quê.”

Possibilidades:

SQL ruim
estatísticas inadequadas
índice ausente
índice inadequado
access path diferente
muito I/O
Buffer Pool pressionado
contenção
locks
volume de dados cresceu
commit inadequado
CPU
storage
DDF
rede
WLM

Percebe a diferença?

Performance não é adivinhação.

É investigação.

Mr. Spock aprovaria.


36. Checklist Bellacosa para o COBOL iniciante

Quando um SQL apresentar problema, pergunte nesta ordem aproximada:

  1. O SQL está logicamente correto?

  2. Quantas linhas deveriam retornar?

  3. Quantas realmente retornam?

  4. Existe índice apropriado?

  5. Qual access path está sendo usado?

  6. As estatísticas estão atualizadas?

  7. Houve REBIND recentemente?

  8. O volume de dados mudou?

  9. Existe contenção?

  10. Existe timeout ou deadlock?

  11. O programa está dando commits adequadamente?

  12. O problema acontece sempre ou apenas em horários específicos?

  13. É batch, CICS ou acesso distribuído?

  14. Existe pressão de CPU ou I/O?

  15. Houve mudança no ambiente?

Já percebeu que:

“Está lento porque Db2 está lento”

é praticamente uma não-explicação.


37. O easter egg do SQLCODE

Todo programador COBOL conhece algum momento assim:

IF SQLCODE NOT = 0
    DISPLAY 'ERRO DB2'
END-IF

Spock vê isso.

Fica silencioso durante oito segundos.

Depois diz:

— Fascinante. Você descartou todas as informações diagnósticas e preservou apenas o fato de que algo ocorreu.

Não seja esse programador.

SQLCODE é começo de diagnóstico.

Não fim.

Considere também as informações disponibilizadas por SQLCA e mecanismos apropriados de diagnóstico.

A mensagem:

ERRO DB2

é quase equivalente a chamar a manutenção dizendo:

“A máquina não está normal.”

Boa sorte.


38. Segundo easter egg: SELECT *

Spock observa:

SELECT *
FROM CLIENTE;

— Por que você deseja todas as colunas?

— Porque é mais fácil.

— Essa justificativa não parece relacionada à necessidade funcional.

Silêncio.

SELECT * pode ser conveniente em testes.

Em aplicação profissional, pense nas colunas realmente necessárias.

Isso melhora:

  • clareza;

  • manutenção;

  • previsibilidade;

  • potencialmente movimentação de dados;

  • dependências.

Escreva o que precisa.

Não o que seus dedos acharam mais curto.


39. Terceiro easter egg: COMMIT dentro do loop sem pensar

Outro clássico:

PERFORM UNTIL EOF
   ...
   EXEC SQL
      UPDATE ...
   END-EXEC

   EXEC SQL
      COMMIT
   END-EXEC
END-PERFORM

Talvez seja correto.

Talvez seja horrível.

Depende.

A pergunta certa não é:

“Posso dar COMMIT aqui?”

É:

“Qual unidade de trabalho faz sentido para esse processo?”

Em batch, estratégia de commit precisa considerar:

  • restart;

  • volume;

  • locking;

  • recuperação;

  • consistência;

  • desempenho.


40. A diferença entre saber SQL e saber Db2

Este talvez seja o ponto mais importante do artigo.

Conhecer:

SELECT
INSERT
UPDATE
DELETE
JOIN
GROUP BY

é conhecer SQL.

Essencial.

Mas conhecer Db2 for z/OS envolve também:

Subsystem
DBM1
MSTR
IRLM
DDF
Buffer Pool
EDM Pool
Table Space
Index Space
Catalog
Directory
Package
DBRM
BIND
Access Path
RUNSTATS
Logs
Recovery
Image Copy
DFSMS
RACF
WLM
Data Sharing
Parallel Sysplex

É outro nível de entendimento.

E você não precisa aprender tudo no primeiro mês.

Apenas precisa saber que essas camadas existem.


41. Um caminho de estudo em sete missões

Se eu estivesse orientando um programador COBOL iniciante, faria assim.

Missão 1 — SQL

Aprenda bem:

SELECT
INSERT
UPDATE
DELETE
JOIN
CURSOR
NULL
SQLCODE

Missão 2 — COBOL + Db2

Entenda:

host variables
SQLCA
cursor
commit
rollback

Missão 3 — preparação

Estude:

Precompile
DBRM
Bind
Package
Plan

Missão 4 — armazenamento

Estude:

Table Space
Index
Page
Buffer Pool

Missão 5 — optimizer

Estude:

Access Path
RUNSTATS
EXPLAIN
seletividade
cardinalidade

Missão 6 — concorrência

Estude:

Lock
Timeout
Deadlock
Isolation
Commit

Missão 7 — arquitetura z/OS

Finalmente:

IRLM
DDF
DFSMS
RACF
WLM
Logs
Recovery
Data Sharing

Quando terminar isso, volte à Missão 1.

Você descobrirá que seu antigo SELECT mudou completamente.


42. A grande revelação

Nosso programador volta finalmente ao código:

EXEC SQL
   SELECT NOME,
          SALDO
     INTO :WS-NOME,
          :WS-SALDO
     FROM CLIENTE
    WHERE CONTA = :WS-CONTA
END-EXEC.

Antes ele via:

“Busca o saldo.”

Agora enxerga:

Aplicação
 ↓
contexto Db2
 ↓
Package
 ↓
Access Path
 ↓
Optimizer
 ↓
Statistics
 ↓
Index
 ↓
Buffer Pool
 ↓
Page
 ↓
possível I/O
 ↓
Storage
 ↓
controle transacional
 ↓
segurança
 ↓
resultado

Ele olha para Spock.

— Então nunca foi “só um SELECT”.

Spock responde:

— Correto.

— E tudo isso acontece para devolver duas colunas?

— Correto.

— Isso é completamente insano.

Spock levanta novamente a sobrancelha.

— Eu escolheria a palavra “engenharia”.


Epílogo — Vida longa ao Db2

Existe uma tendência natural de ensinar mainframe de fora para dentro.

Primeiro mostramos:

IDENTIFICATION DIVISION.

Depois:

EXEC SQL.

Depois CICS.

Depois JCL.

Está correto.

O problema é quando o aprendizado para ali.

Um profissional começa realmente a amadurecer quando pergunta:

O que existe atrás dessa instrução?

Db2 é um ótimo exemplo.

Por trás do humilde:

SELECT SALDO

existe uma arquitetura desenhada para funcionar em ambientes nos quais:

  • milhões de transações podem acontecer;

  • múltiplas aplicações disputam recursos;

  • dados precisam permanecer consistentes;

  • falhas precisam ser recuperáveis;

  • workloads críticos têm prioridade;

  • segurança precisa ser auditável;

  • sistemas externos precisam acessar dados;

  • operações precisam continuar durante enormes cargas.

É por isso que Db2 for z/OS não deve ser estudado apenas como linguagem SQL.

Ele deve ser entendido como parte de uma arquitetura transacional completa.

Buffer Pool ensina que memória é estratégia.

IRLM ensina que concorrência precisa de disciplina.

RUNSTATS ensina que inteligência depende de boas informações.

Logs ensinam que sobreviver ao desastre é tão importante quanto evitar o desastre.

RACF ensina que capacidade técnica não significa autorização.

WLM ensina que nem todo trabalho possui a mesma urgência.

DDF ensina que mainframe não é uma ilha.

Parallel Sysplex ensina que alta disponibilidade é uma arquitetura, não uma frase de marketing.

E o humble COBOL programador aprende finalmente uma verdade que acompanha muita gente durante décadas de carreira:

quanto mais você entende o que existe abaixo do seu programa, melhores ficam as decisões que você toma acima dele.

Spock deixou o CPD pouco antes das três da manhã.

Na saída, encontrou o operador.

— O senhor está indo embora?

— Acredito que meu trabalho aqui terminou.

— E o garoto?

Spock olhou através do vidro para o programador, que naquele momento pesquisava access path, Buffer Pool e RUNSTATS enquanto sua caneca de café esfriava ao lado do terminal.

— Ele cometeu um erro comum.

— Qual?

— Pensou que estava aprendendo apenas COBOL.

Spock fez uma pequena pausa.

— Agora começou a aprender sistemas.

O elevador fechou.

No monitor apareceu:

DSN SYSTEM(...)

Depois:

READY

E em algum lugar profundamente dentro do z/OS, um Buffer Pool continuou recebendo páginas, o IRLM continuou arbitrando recursos, os logs continuaram registrando transações e o velho Db2 fez aquilo que vem fazendo há décadas:

carregar boa parte do mundo corporativo nas costas sem exigir que o usuário saiba quantas maravilhas estavam acontecendo atrás de um simples SELECT.

🖖 Vida longa, prosperidade e um access path decente.

quarta-feira, 6 de março de 2024

Stargate no CPD — O Dia em que o COBOL de Quarenta Anos Atravessou o Portal e Voltou como API REST

 

Bellacosa Mainframe e um processo de migracao e evolucao do legado

☕ Um Café no Bellacosa Mainframe

Stargate no CPD — O Dia em que o COBOL de Quarenta Anos Atravessou o Portal e Voltou como API REST

Ou: como uma multinacional industrial trocou z/VSE por z/OS, aposentou um mensageiro criado nos anos 1990, abriu um wormhole até a nuvem e descobriu que o programa mais antigo da casa não precisava morrer — apenas de alguém que falasse JSON sem provocar SOC7



Prólogo — General Hammond, temos um portal no CPD

O alarme tocou às 02h17.

Não era invasão Goa'uld, queda de energia nem estagiário executando DELETE sem WHERE. No centro do CPD de uma grande multinacional industrial — que chamaremos de Companhia Pégaso, porque advogados também possuem zat'nik'tel — um programa COBOL escrito décadas antes acabava de responder a uma chamada REST originada na nuvem.

Na sala de controle, o general Hammond olhou para o monitor. Samantha Carter examinava a telemetria. Daniel Jackson tentava traduzir um copybook. Jack O'Neill segurava uma caneca de café e perguntava se COMP-3 era algum tipo de explosivo alienígena. Teal'c observou o tempo de resposta e pronunciou apenas:

Indeed.

Para quem via de fora, parecia magia: um programa COBOL com quase quarenta anos havia virado uma API em minutos.

Mas não houve magia. Houve aproximadamente seis anos de preparação, milhares de módulos migrados, centenas de interfaces revistas, ambientes paralelos, testes, mensageria, CICS, Db2, IMS, VSAM, JCL, segurança e uma quantidade de café que provavelmente deveria aparecer no balanço patrimonial.

Esta é a primeira lição para o padawan COBOL: a API nasceu em minutos, mas a pista de lançamento levou anos para ficar pronta.

Vamos atravessar esse Stargate passo a passo.



1. As coordenadas do planeta P3X-COBOL

A Companhia Pégaso mantinha no Brasil um ambiente mainframe construído e ampliado durante mais de quarenta anos. Não era uma máquina esquecida atrás de uma porta. Era uma cidade viva.

Nesse ambiente existiam, em números aproximados:

  • Mais de 15 mil módulos;

  • Milhares de programas COBOL, Assembler, BMS e RPG;

  • Milhares de usuários CICS;

  • Mais de 1.500 transações online;

  • Aproximadamente 1.700 jobs batch;

  • Mais de mil arquivos VSAM;

  • Mais de uma centena de tabelas Db2;

  • Mais de uma dezena de bases IMS/DL/I;

  • Centenas de integrações com aplicações internas e externas.

Durante décadas, tudo isso executou sobre z/VSE. O sistema cumpriu sua missão, mas a empresa precisava de uma plataforma com um ecossistema moderno mais amplo, maior padronização operacional e novas opções de integração.

A jornada ocorreu em quatro chevrons:

ChevronMovimentoResultado
1z/VSE para z/OSNova fundação operacional
2Middleware proprietário para IBM MQIntegração padronizada e desacoplada
3MQ Request/Reply entre nuvem e CICSArquitetura híbrida em produção
4z/OS Connect diante do COBOLAPIs REST sem reescrever a regra central

Um Stargate não abre com apenas um símbolo. Da mesma forma, o z/OS Connect sozinho não moderniza uma organização. Ele funciona melhor quando ambiente, aplicações, segurança, operação e integração já foram preparados.



2. Primeiro chevron — migrar z/VSE para z/OS sem desligar a galáxia

Para um iniciante, z/VSE e z/OS podem parecer apenas dois sistemas operacionais do IBM Z. Seria tentador imaginar a migração como copiar fontes, recompilar e trocar o nome de algumas bibliotecas.

Essa visão dura até o primeiro JCL falhar às três da manhã.

Embora os ambientes compartilhem arquitetura IBM Z, conceitos de processamento batch, EBCDIC, COBOL, CICS e VSAM, cada plataforma possui sua própria organização operacional. Uma migração dessa escala exige descobrir como quarenta anos de componentes dependem uns dos outros.

O trabalho normalmente envolve:

  • Inventariar fontes, load modules, copybooks, mapas, procedures e bibliotecas;

  • Identificar programas ainda utilizados e cadáveres digitais mantidos por superstição;

  • Recompilar COBOL, Assembler e outras linguagens com novos compiladores;

  • Ajustar JCL, utilitários, SORT, steps e códigos de retorno;

  • Recriar definições CICS e conexões;

  • Migrar catálogos e arquivos VSAM;

  • Transportar tabelas Db2 e bases IMS;

  • Rever schedulers, calendários, predecessores e sucessores;

  • Validar segurança, identidades e autorizações;

  • Testar online, batch, arquivos, integrações e fechamentos financeiros;

  • Preparar cutover, contingência e rollback.

Curiosidade: módulo não é necessariamente programa

Quando uma apresentação afirma que foram migrados mais de 15 mil módulos, isso não significa que existiam 15 mil programas COBOL independentes. O universo pode incluir executáveis, subprogramas, mapas, objetos, componentes Assembler, rotinas, controles e outros artefatos implantáveis.

É por isso que outro número pode indicar “apenas” alguns milhares de programas. As duas contagens podem estar corretas: uma mede objetos migrados; a outra mede fontes ou programas de determinadas linguagens.

Como se consegue zero downtime?

“Zero downtime” não significa que ninguém reiniciou um subsistema durante seis anos. Significa, em geral, que o corte produtivo ocorreu sem indisponibilidade perceptível para o negócio.

Para isso, uma equipe madura utiliza:

  1. Ambientes antigos e novos coexistindo;

  2. Pontes temporárias entre as duas plataformas;

  3. Ensaios completos de migração;

  4. UAT com usuários reais;

  5. Congelamento controlado de mudanças;

  6. Sincronização ou cópia final dos dados;

  7. Plano minuto a minuto para o go-live;

  8. Critérios objetivos para abortar ou prosseguir;

  9. Equipe de hypercare após a ativação.

Em Stargate, ninguém disca um planeta desconhecido e manda o general Hammond atravessar primeiro. No mainframe, ninguém deveria mover a folha de pagamento antes de ensaiar o retorno.



3. Segundo chevron — o velho mensageiro MGATE encontra IBM MQ

A Companhia Pégaso possuía uma solução própria de comunicação criada nos anos 1990. Vamos chamá-la de PEGCOM. Ela era robusta e havia sustentado integrações críticas durante décadas.

Uma solução não sobrevive trinta anos sendo inútil. O problema era outro: conhecimento concentrado, protocolo particular, ferramentas próprias e dificuldade crescente para conectar aplicações modernas.

O PEGCOM foi substituído gradualmente por IBM MQ em quase duzentas integrações, envolvendo mais de uma dezena de aplicações, dezenas de filas e centenas de alterações em COBOL online, batch e JCL.

MQ explicado com café

Sem mensageria, o programa A liga diretamente para o programa B:

— Preciso desta operação agora. Vou ficar parado até você responder.

Com MQ, o programa A deposita uma mensagem numa fila:

— Aqui está o pedido. O responsável pode processá-lo quando estiver disponível.

MQ funciona como um correio empresarial com recibo, persistência, transação e controle de entrega.

Os benefícios principais são:

  • Desacoplamento: produtor e consumidor não precisam conhecer toda a implementação um do outro;

  • Resiliência: a mensagem pode aguardar durante uma indisponibilidade temporária;

  • Absorção de picos: a fila amortece diferenças de velocidade;

  • Escalabilidade: vários consumidores podem processar trabalho;

  • Rastreabilidade: descritores e identificadores ajudam a acompanhar cada mensagem;

  • Persistência: mensagens importantes podem sobreviver a reinicializações.

Mas atenção: dizer “entrega garantida” não significa que o negócio será executado exatamente uma vez em qualquer circunstância. Se o consumidor atualizar o Db2, perder a conexão antes da confirmação e receber novamente o pedido, poderá duplicar uma operação. MQ protege a mensagem; idempotência protege o negócio.

Dica de ouro

Para pagamentos, faturamento, estoque ou limite de crédito, inclua uma chave funcional única, como REQUEST-ID. Antes de executar a alteração, consulte se aquele pedido já foi processado. Repetições técnicas não devem produzir débitos duplicados.



4. Terceiro chevron — Azure chama o CICS por MQ Request/Reply

Depois de padronizar a mensageria, a empresa conectou aplicações na nuvem ao mainframe por meio do padrão Request/Reply.

O fluxo funciona assim:

  1. Uma aplicação web recebe uma solicitação;

  2. Cria o JSON de negócio;

  3. Executa MQPUT na fila de requisições;

  4. O MQ sinaliza a existência de trabalho;

  5. Uma transação CICS é iniciada;

  6. Um router executa MQGET;

  7. O router descobre qual serviço chamar;

  8. O JSON é convertido para um layout COBOL;

  9. A subrotina de negócio é executada;

  10. O resultado volta a ser JSON;

  11. A resposta é colocada na reply queue;

  12. A aplicação cloud localiza a resposta correta pelo identificador de correlação.

O MsgId e o CorrelId

Cada mensagem MQ possui um descritor chamado MQMD. Nele estão campos como tipo, persistência, prioridade, MsgId, CorrelId e reply queue.

Normalmente, o produtor deixa o MsgId como MQMI_NONE e permite que o queue manager gere um identificador único. Depois do MQPUT, a aplicação guarda esse valor.

Na resposta, aplica-se a regra:

CORRELID-DA-RESPOSTA = MSGID-DA-REQUISIÇÃO

Assim, se cem solicitações estiverem usando a mesma reply queue, cada consumidor poderá encontrar sua própria resposta.

Cuidado com a pesquisa seletiva

Executar MQGET procurando determinado CorrelId pode exigir que o MQ examine mensagens até localizar a desejada. Em filas movimentadas no z/OS, deve-se estudar INDXTYPE(CORRELID) ou outro desenho de filas.

Sem índice, a reply queue pode se transformar numa gaveta com dez mil cartas, e o carteiro precisa ler envelope por envelope.

O trigger não carrega a mensagem de negócio

Outro detalhe frequentemente simplificado: o trigger do MQ não entrega diretamente o JSON ao COBOL.

O queue manager coloca uma mensagem de trigger numa initiation queue. No CICS, um trigger monitor como o CKTI lê esse aviso e inicia a transação configurada. A transação então executa MQGET na fila onde está a mensagem real.

Existem modalidades como:

  • EVERY: sinalização para cada mensagem;

  • FIRST: quando a profundidade passa de zero para um;

  • DEPTH: quando a fila alcança determinada profundidade.

O trigger é a sirene da base. A mensagem de negócio é o viajante esperando na rampa do Stargate.


5. O tradutor de Daniel Jackson — JSON encontra o copybook

O COBOL tradicional não trabalha naturalmente com este objeto:

{
  "customerId": "000012345678",
  "amount": 125000.50
}

Ele prefere algo parecido com:

       01  LK-CREDIT-AREA.
           05 LK-OPERATION       PIC X.
           05 LK-CUSTOMER-ID     PIC X(12).
           05 LK-AMOUNT          PIC S9(9)V99 COMP-3.
           05 LK-RETURN-CODE     PIC 9(2).
           05 LK-APPROVED-LIMIT  PIC S9(9)V99 COMP-3.
           05 LK-MESSAGE         PIC X(80).

O CICS oferece mecanismos como:

       EXEC CICS TRANSFORM JSONTODATA
            CHANNEL(WS-CHANNEL)
            INCONTAINER(WS-JSON-IN)
            OUTCONTAINER(WS-COBOL-DATA)
            TRANSFORMER(WS-TRANSFORMER)
       END-EXEC.

E, no retorno:

       EXEC CICS TRANSFORM DATATOJSON
            CHANNEL(WS-CHANNEL)
            INCONTAINER(WS-COBOL-DATA)
            OUTCONTAINER(WS-JSON-OUT)
            TRANSFORMER(WS-TRANSFORMER)
       END-EXEC.

Isso não significa que não exista parsing. Significa que o programador não precisa criar um parser manual, movendo caractere por caractere e rezando para ninguém enviar uma chave fora de ordem.

A transformação depende de binding, schema e recurso JSONTRANSFRM. O verdadeiro tradutor não é Daniel Jackson: é o metadado corretamente gerado e implantado.


6. Quarto chevron — z/OS Connect abre o wormhole REST

Com a arquitetura MQ funcionando, surgiu a pergunta:

Podemos oferecer a mesma subrotina COBOL diretamente como uma API REST?

Sim. É aqui que entra o IBM z/OS Connect.

No cenário de API provider, ele fica entre o consumidor REST e o ativo do z/OS:

Aplicação → API Gateway → z/OS Connect → CICS → Subrotina COBOL
Aplicação ← JSON/HTTP  ← z/OS Connect ← COMMAREA ← Resultado

Seu trabalho inclui:

  • Receber HTTPS e JSON;

  • Aplicar autenticação e autorização configuradas;

  • Interpretar o contrato OpenAPI;

  • Mapear request para COMMAREA;

  • Invocar o ativo CICS por IPIC;

  • Receber a resposta binária;

  • Mapear campos para JSON;

  • Converter códigos internos em respostas HTTP.

O COBOL não virou REST

Esta distinção merece moldura:

O programa COBOL continua sendo COBOL. O z/OS Connect é que aprendeu a falar REST de um lado e COMMAREA do outro.

É como o Stargate: a equipe não se transforma em onda de rádio por decisão própria. O portal realiza a conversão necessária para transportá-la.


7. Passo a passo — expondo uma subrotina COBOL adequada

Suponha que exista uma subrotina CICS chamada CRDTCHECK, responsável por avaliar um limite.

Passo 1 — confirmar se ela é uma boa candidata

Pergunte:

  • Possui entrada e saída claras?

  • Executa rapidamente?

  • Tem códigos de retorno conhecidos?

  • Pode ser chamada sem tela 3270?

  • Não depende de estado escondido entre telas?

  • É reentrante ou segura para chamadas concorrentes?

  • A operação pode ser tornada idempotente?

  • O impacto em Db2, VSAM ou IMS é conhecido?

Se metade das respostas for “não sei”, a primeira etapa não é publicar a API. É estudar o programa.

Passo 2 — desenhar a API pelo negócio

Evite isto:

POST /execute/CRDTCHECK

Prefira algo como:

POST /finance/v1/credit-decisions

O consumidor quer uma decisão de crédito. Ele não deveria conhecer nome de load module, transação CICS ou copybook.

Passo 3 — escrever o OpenAPI

Defina:

  • Caminho;

  • Método HTTP;

  • Campos obrigatórios;

  • Tipos e tamanhos;

  • Exemplos;

  • Respostas possíveis;

  • Modelo padronizado de erro;

  • Regras de autenticação.

Passo 4 — registrar o ativo CICS

Configure a conexão IPIC e descreva o programa, transação, COMMAREA e copybook utilizados.

Passo 5 — mapear request e response

Associe, por exemplo:

customerId → LK-CUSTOMER-ID
amount     → LK-AMOUNT

No retorno:

LK-APPROVED-LIMIT → approvedLimit
LK-MESSAGE        → message

Passo 6 — traduzir retorno COBOL para HTTP

Retorno do legadoSemântica REST possível
Sucesso200 OK
Cadastro inexistente404 Not Found
Regra de negócio rejeitada422 Unprocessable Content
Solicitação duplicada409 Conflict
Falha inesperada500 Internal Server Error
Dependência indisponível503 Service Unavailable

Nunca devolva 200 OK com "errorCode": 9999 para tudo. Isso faz o HTTP participar da reunião sem direito a opinar.

Passo 7 — testar

Teste pelo menos:

  • Caminho feliz;

  • Campo obrigatório ausente;

  • Valor fora do limite;

  • Caracteres e code pages;

  • Decimal COMP-3;

  • Timeout;

  • CICS indisponível;

  • Db2 indisponível;

  • Chamada duplicada;

  • Volume concorrente;

  • Autorização negada;

  • Alteração de versão do copybook.

Passo 8 — implantar com governança

Promova os artefatos por desenvolvimento, teste, homologação e produção. Versione OpenAPI, mappings e configuração junto do código. O clique no Designer não substitui Git, pipeline, aprovação e trilha de auditoria.


8. “Zero Code Rewrite” — verdade ou propaganda Goa'uld?

Pode ser verdade que nenhuma linha da subrotina central tenha sido alterada.

Mas alguém ainda precisou criar ou configurar:

  • OpenAPI;

  • Mapeamentos;

  • Conexão CICS;

  • Servidor z/OS Connect;

  • Certificados;

  • Segurança;

  • Regras de status HTTP;

  • Gateway;

  • Monitoração;

  • Pipeline;

  • Testes;

  • Documentação.

Portanto:

Zero reescrita da regra de negócio não significa zero trabalho.

Isso não diminui a conquista. Preservar uma regra confiável e mudar apenas sua forma de acesso é uma estratégia de redução de risco.

Os Goa'uld se apresentam como deuses. A frase “zero esforço” também. Ambos merecem investigação.


9. “API em minutos” — onde está o truque?

Depois que a fábrica de APIs está pronta, um ativo simples pode realmente ser mapeado e implantado rapidamente.

O que pode levar minutos ou horas:

  • Importar o copybook;

  • Definir o ativo;

  • Mapear campos;

  • Associar respostas;

  • Gerar o projeto;

  • Fazer deploy em ambiente preparado.

O que normalmente não leva minutos:

  • Descobrir o que um programa antigo realmente faz;

  • Desenhar um contrato público estável;

  • Classificar dados sensíveis;

  • Criar testes de regressão;

  • Avaliar capacidade;

  • Configurar segurança;

  • Obter aprovação produtiva;

  • Testar alta disponibilidade e recuperação.

A frase honesta seria:

Depois de anos preparando plataforma e integração, uma subrotina previamente adequada pode ganhar uma interface REST em minutos sem reescrever sua lógica.

Ainda é fantástico. Apenas não foi encontrado dentro de uma pirâmide por um arqueólogo com chapéu.


10. Todo COBOL é uma API esperando para nascer?

Todo programa pode ser analisado. Nem todo programa deve ser exposto.

Bons candidatos

  • Subrotina de negócio com interface clara;

  • Consulta curta;

  • Atualização transacional pequena;

  • Copybook estável;

  • Retornos documentados;

  • Ausência de dependência de terminal;

  • Execução previsível;

  • Controle de duplicidade.

Maus candidatos diretos

  • Programa conversacional dependente de várias telas;

  • Batch de horas;

  • Varredura completa de arquivo;

  • Programa que mistura apresentação, negócio e acesso a dados;

  • Código que mantém estado global inseguro;

  • Rotina que prende locks por muito tempo;

  • Programa cujo contrato ninguém compreende.

Um batch longo ainda pode ser acionado por API, mas o padrão deveria ser assíncrono:

POST /reports
→ 202 Accepted
→ operationId
→ GET /operations/{id}

Não mantenha uma thread HTTP esperando um fechamento mensal terminar. Nem o Stargate fica aberto indefinidamente sem consumir energia suficiente para irritar o setor financeiro.


11. REST e MQ: Carter e O'Neill, não inimigos

REST e MQ atendem necessidades diferentes.

REST com z/OS ConnectMQ
Ótimo para consultas interativasÓtimo para desacoplamento
Modelo síncrono naturalModelo assíncrono natural
Fácil para web e mobileExcelente para integração crítica
Resposta imediataSuporta espera persistente
Sensível a timeoutAbsorve indisponibilidade temporária
Governado por contrato OpenAPIGovernado por filas e contratos de mensagem

Exemplos:

  • Consultar situação de uma fatura: REST;

  • Receber lote de documentos: MQ;

  • Consultar limite disponível: REST;

  • Propagar evento de pagamento: MQ;

  • Solicitar relatório demorado: REST retornando 202, seguido de processamento assíncrono.

A grande qualidade do caso Pégaso é não duplicar a regra. O adapter MQ e o adapter REST chegam à mesma subrotina central.

Isso é arquitetura de portas e adaptadores: o negócio permanece no núcleo; protocolos vivem nas bordas.


12. A Dead Letter Queue não é o porão do SGC

É comum dizer: “Se der erro, mande para a DLQ”. A frase parece organizada até a DLQ acumular milhares de mensagens que ninguém entende.

A Dead Letter Queue é especialmente apropriada para mensagens que não puderam ser entregues ao destino correto. Erros funcionais e mensagens venenosas merecem destinos mais específicos:

  • APP.BACKOUT: processamento sofreu rollback repetidas vezes;

  • APP.INVALID: conteúdo inválido;

  • APP.ROUTING.ERROR: serviço desconhecido;

  • APP.RETRY: falha temporária;

  • DLQ: falha de entrega ou roteamento do middleware.

Defina:

  • BOTHRESH;

  • BOQNAME;

  • Número máximo de tentativas;

  • Alerta por profundidade;

  • Responsável pela fila;

  • Procedimento de correção;

  • Forma segura de replay;

  • Proteção contra duplicidade.

Fila de erro sem dono é apenas um arquivo morto com marketing melhor.


13. Segurança — fechar a íris do Stargate

No SGC, o Stargate possui uma íris porque abrir um portal para qualquer origem seria uma ideia ruim. APIs corporativas precisam do equivalente digital.

O API Gateway pode cuidar de:

  • OAuth e OIDC;

  • Validação de tokens;

  • Rate limiting;

  • Quotas;

  • Catálogo e assinatura;

  • Políticas de tráfego;

  • Proteção contra abuso.

O z/OS Connect pode autenticar a solicitação, aplicar autorização por operação e mapear identidades para SAF. CICS e RACF continuam responsáveis por proteger transações, programas, filas e recursos.

Evite uma única identidade técnica com autorização universal. Se todos entram como APIUSER, a auditoria perde a capacidade de responder quem fez o quê.

Uma arquitetura séria precisa considerar:

  • TLS ou mTLS;

  • Rotação de certificados;

  • JWT com validade curta;

  • Privilégio mínimo;

  • Identidade propagada ou auditavelmente representada;

  • Mascaramento de dados sensíveis em logs;

  • Proteção contra payload excessivo;

  • Autorização no gateway e novamente no recurso final.

Confiar apenas na DMZ é como fechar a porta da frente e deixar cada sala interna sem fechadura.


14. Observabilidade — Walter, qual chevron falhou?

“Resposta em milissegundos” é uma informação incompleta.

Precisamos saber:

  • Milissegundos medidos onde?

  • Média ou percentil 99?

  • Com uma chamada ou quinhentas?

  • Incluindo Azure, gateway e rede?

  • Incluindo espera na fila?

  • Incluindo Db2 e commit?

Meça:

  • Latência p50, p95 e p99;

  • Tempo no gateway;

  • Tempo no z/OS Connect;

  • Tempo IPIC;

  • Tempo CICS;

  • Tempo Db2;

  • CPU por chamada;

  • Tamanho do JSON;

  • Profundidade das filas;

  • Idade da mensagem mais antiga;

  • Taxa de timeout;

  • Retries;

  • Backouts;

  • DLQ;

  • Respostas atrasadas ou órfãs.

Utilize um identificador de rastreamento que acompanhe toda a viagem:

HTTP Trace ID
 → API Gateway
 → z/OS Connect
 → CICS Task
 → MQ MsgId/CorrelId
 → Db2 Unit of Work
 → Código COBOL de retorno

Sem correlação ponta a ponta, a arquitetura híbrida vira um episódio em que cada personagem investiga um planeta diferente.


15. Checklist do jovem programador COBOL antes de abrir o portal

Antes de transformar uma rotina em serviço, responda:

Sobre o programa

  • Qual é a responsabilidade real?

  • Quem o chama hoje?

  • Ele usa COMMAREA, channel/container ou parâmetros de LINK?

  • É reentrante?

  • Possui estado escondido?

  • Quanto tempo demora?

  • Quais recursos acessa?

  • Quais códigos de retorno produz?

Sobre os dados

  • O copybook possui REDEFINES?

  • OCCURS DEPENDING ON?

  • Existem campos binários ou COMP-3?

  • Qual é a code page?

  • Existem datas sem século?

  • Zeros e espaços possuem significados diferentes?

  • Há dados pessoais ou financeiros?

Sobre a transação

  • Onde ocorre o commit?

  • MQ e Db2 estão na mesma unidade de trabalho?

  • O que acontece após rollback?

  • A chamada pode ser repetida?

  • Existe chave idempotente?

  • O programa deixa locks prolongados?

Sobre a API

  • O nome representa o negócio?

  • O consumidor está isolado dos nomes internos?

  • Existe versionamento?

  • Os erros usam HTTP corretamente?

  • Há limites e validação?

  • O OpenAPI está versionado?

Sobre produção

  • Qual é o SLO?

  • Qual é o timeout?

  • Qual é o pico esperado?

  • Quem recebe os alertas?

  • Existe rollback?

  • Existe plano de disaster recovery?

  • Quem é dono da API?

Se essas respostas existem, o clique que publica o serviço pode realmente ser rápido. A velocidade final é consequência do conhecimento acumulado.


16. O que foi modernizado — e o que continua antigo

A Companhia Pégaso modernizou quatro camadas:

  1. Plataforma: z/VSE deu lugar ao z/OS;

  2. Transporte: o middleware proprietário deu lugar ao MQ;

  3. Conectividade: a nuvem passou a conversar com CICS;

  4. Consumo: regras COBOL ganharam contratos REST.

Isso não significa que todo o código tenha sido refatorado. Podem continuar existindo:

  • Programas monolíticos;

  • Copybooks difíceis;

  • Regras duplicadas;

  • Falta de testes unitários;

  • Dependência de especialistas;

  • Dívida técnica.

Mas agora há fronteiras modernas ao redor dos ativos. A empresa pode refatorar apenas onde existir valor, sem apostar todo o negócio numa reescrita gigantesca.

Reescrever quarenta anos de regra empresarial de uma vez costuma ser vendido como coragem. Às vezes é apenas uma forma sofisticada de esquecer todos os bugs que já foram corrigidos.

Encapsular primeiro cria opções:

  • Reutilizar imediatamente;

  • Observar o uso real;

  • Identificar serviços mais valiosos;

  • Medir gargalos;

  • Substituir componentes gradualmente;

  • Manter compatibilidade durante a transição.

Modernização não é obrigar COBOL a vestir uma camiseta escrito cloud native. É permitir que novas aplicações consumam capacidades antigas com segurança, contrato, métricas e governança.


Epílogo — Chevron sete travado

A sala de controle ficou em silêncio quando a primeira resposta chegou.

Na nuvem, uma aplicação enviara JSON. No z/OS, CICS recebera uma estrutura conhecida. A subrotina COBOL executara a mesma regra que executava havia anos. O resultado retornara como HTTP, sem que o programa central soubesse o que era REST, Azure ou smartphone.

Carter sorriu diante da telemetria.

— A integração está estável, general.

Daniel Jackson fechou o copybook.

— O curioso é que o programa nunca esteve realmente ultrapassado. Apenas falava uma língua que os novos consumidores não conheciam.

O'Neill tomou o último gole de café.

— Então construímos um tradutor de bilhões de dólares para evitar mexer num MOVE de 1987?

Teal'c ergueu a sobrancelha.

— Alterar aquele MOVE na sexta-feira seria imprudente, O'Neill.

Eis a essência desta jornada:

O mainframe não deixou de ser legado porque ganhou uma API. Ele deixou de ser uma ilha porque ganhou pontes controladas.

Nem todo programa COBOL é uma API pronta. Entretanto, toda capacidade de negócio bem delimitada, segura, curta e compreendida pode se tornar candidata a um serviço moderno.

A regra de quarenta anos não precisou morrer. Recebeu dois intérpretes: IBM MQ, que prefere cartas registradas, e z/OS Connect, que fala REST fluentemente.

E a famosa API criada em minutos?

Ela é real. Mas aqueles minutos são os juros compostos de seis anos de engenharia.

Em algum lugar da spool, um job terminou com CC 0000. Ninguém percebeu que seu JOBID era SG10042 — porque todo bom Stargate precisa de sete chevrons, e todo bom universo precisa saber a resposta para a vida, o universo e tudo mais.

Chevron sete travado. Wormhole estabelecido. Café servido.



Hércule Poirot Entra no CPD — O Caso do Sistema que Estava Verde, Mas Já Estava Morto por Dentro

 

Bellacosa Mainframe analisando a performance mainframe

☕ Um Café no Bellacosa Mainframe

Hércule Poirot Entra no CPD — O Caso do Sistema que Estava Verde, Mas Já Estava Morto por Dentro

Ou: por que latência, erros, CPU, filas, Db2, MQ e I/O não são uma coleção de números — são as pequenas células cinzentas que impedem o SEV-1 antes do café esfriar

Há uma cena recorrente em tecnologia que faria Hércule Poirot ajustar o bigode, olhar para o dashboard e dizer, com delicada indignação belga: “Mon ami, todos os suspeitos têm álibi. E, ainda assim, a folha de pagamento não foi processada.”

O painel está verde. CPU em 38%. Memória em 61%. Banco “UP”. Rede “normal”. Ninguém abriu chamado de infraestrutura. Mas o usuário está esperando oito segundos para consultar o saldo, o atendente do call center aperta Enter pela terceira vez, a fila do IBM MQ cresce como lista de compras em véspera de feriado e o batch que terminava às 5h ainda está conversando com o DASD às 8h12.

Essa é a verdade incômoda do monitoramento: sistemas raramente deixam de funcionar como uma lâmpada que apaga. Eles se deterioram em sinais pequenos, correlacionados e, muitas vezes, educados demais para disparar um alarme simples. Primeiro uma consulta Db2 demora um pouco mais. Depois o pool de conexões fica ocupado. Em seguida, a aplicação segura as requisições por mais tempo. As filas crescem. Os timeouts começam. Os usuários tentam de novo. O volume aumenta artificialmente. A CPU finalmente sobe. Quando alguém percebe, o incidente já não é técnico: virou negócio, reputação e reunião de diretoria.

Para um programador COBOL iniciante, a mensagem mais importante é esta: monitoramento não é assunto exclusivo do “pessoal de infraestrutura”. Quando seu programa faz um EXEC SQL, grava uma mensagem MQ, chama uma transação CICS, lê um VSAM ou recebe um arquivo de entrada, ele passa a fazer parte da história operacional do sistema. O código pode compilar lindamente e ainda assim criar um gargalo capaz de transformar uma terça-feira comum num episódio de investigação criminal.



Prólogo — Poirot não procura números; ele procura a verdade

Métricas são medições. Observabilidade é a capacidade de explicar o que está acontecendo a partir dos efeitos que o sistema produz. Monitoramento é a prática de acompanhar esses sinais e agir a tempo.

Parece uma diferença de dicionário, mas não é. Um dashboard que exibe 250 gráficos pode ser menos útil do que uma única pergunta bem formulada:

A transação importante para o usuário está concluindo corretamente, dentro do tempo prometido?

Imagine uma aplicação bancária. A CPU pode estar baixa. O CICS pode estar ativo. O Db2 pode responder ao comando de health check. Porém, se a operação de transferência demora 20 segundos e 4% delas terminam em timeout, o serviço não está saudável para quem precisa pagar uma conta. Ele está apenas respirando com aparelhos ligados.

Poirot não ficaria satisfeito com “o servidor está no ar”. Ele perguntaria: “No ar para quem? Fazendo o quê? Em quanto tempo? Com qual taxa de sucesso? E o que mudou antes de Madame Latência começar a gritar?”



1. Latência — a primeira testemunha costuma ser o relógio

Latência é o tempo gasto entre um pedido e uma resposta útil. Em aplicações web é o tempo da requisição. Em CICS, pode ser o tempo percebido pelo usuário na transação. Em batch, pode ser o tempo de execução de uma etapa. Em MQ, pode ser o intervalo entre a mensagem entrar na fila e ser efetivamente consumida.

Ela é uma das melhores primeiras pistas porque o usuário sente demora antes de entender qualquer outra coisa. Usuário não abre RMF, não consulta SMF e não discute buffer pool. Usuário diz: “Está lento.” E frequentemente está certo.

Há uma armadilha: não confie apenas na média. Se 95 consultas respondem em 200 milissegundos e cinco levam 20 segundos, a média pode até parecer elegante num PowerPoint. Mas aquelas cinco pessoas vivem a versão completa do desastre.

Por isso usamos percentis:

  • p50: o comportamento típico, a mediana;

  • p95: a experiência dos 5% mais lentos;

  • p99: a cauda ruim, onde se escondem timeouts e casos críticos.

Em um ambiente COBOL/Db2, uma tela pode permanecer rápida para quase todos, enquanto um tipo específico de cliente dispara uma consulta com critério pouco seletivo. É o equivalente técnico de descobrir que todas as vítimas tomaram chá, mas apenas uma escolheu a xícara errada.

Dica prática: defina um objetivo de serviço, ou SLO. Por exemplo: “99,9% das consultas de saldo devem terminar com sucesso em até 1 segundo.” Agora a conversa deixa de ser “parece lento” e passa a ser verificável.



2. Taxa de erros — quando o sistema deixa evidência no local do crime

Taxa de erros mede falhas explícitas: HTTP 500, timeout, abend, autenticação rejeitada, mensagem devolvida, SQLCODE negativo, transação com rollback ou job encerrado com RC maior que o permitido.

Mas nem todo erro é o mesmo crime. Um 404 causado por URL digitada errada é bem diferente de uma transferência financeira que retorna 500. Um SQLCODE -100 pode ser resultado esperado — nenhum registro encontrado. Já um SQLCODE -911 pode indicar deadlock ou timeout; aí Poirot põe a mão no queixo, porque duas transações disputando recursos contam uma história bem mais interessante.

Um iniciante em COBOL deve aprender desde cedo a tratar retorno e contexto, não apenas “seguir em frente” depois do comando:

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

           EVALUATE SQLCODE
               WHEN 0
                   CONTINUE
               WHEN 100
                   MOVE 'CLIENTE NAO ENCONTRADO' TO WS-MENSAGEM
               WHEN OTHER
                   PERFORM REGISTRA-ERRO-DB2
                   MOVE 'FALHA TEMPORARIA' TO WS-MENSAGEM
           END-EVALUATE.

O detalhe operacional é essencial: registre a falha com identificador da transação, programa, operação e correlação da requisição. Um log dizendo apenas “erro no banco” é tão útil quanto uma testemunha dizendo “vi alguém de chapéu”.

3. Throughput — muito trabalho pode ser sucesso ou pânico

Throughput é volume processado por unidade de tempo: transações por segundo, requisições por minuto, mensagens consumidas, registros lidos, documentos emitidos ou pagamentos autorizados.

Um aumento de throughput pode significar uma campanha bem-sucedida. Mas também pode significar que usuários estão repetindo cliques porque nada responde, que uma integração entrou em loop de retry ou que um lote foi reenviado três vezes.

Esse último caso é uma bela curiosidade de CPD: às vezes o sistema não está recebendo mais trabalho real; está recebendo o mesmo trabalho, repetido por ansiedade humana ou erro de software. É o “efeito elevador”: o botão não respondeu, então alguém apertou cinco vezes. Em sistemas distribuídos, cada tentativa pode abrir conexão, chamar serviço, consultar Db2 e colocar mensagem na fila. A consequência é um aumento de carga que agrava exatamente a lentidão que motivou o novo clique.

Compare sempre throughput com latência, erro e filas. Mais transações com latência estável e erro baixo é capacidade. Mais transações com demora, falhas e acúmulo é saturação disfarçada de sucesso.

4. CPU — o suspeito famoso, mas raramente o único culpado

CPU é a métrica mais vista porque é intuitiva. Uso alto pode apontar carga legítima, loop, compressão, criptografia, serialização, processamento excessivo ou necessidade de capacidade adicional.

Mas CPU baixa não inocenta o sistema. Uma transação bloqueada esperando I/O, lock Db2, resposta de rede ou disponibilidade de conexão pode consumir pouca CPU e, ainda assim, fazer o usuário envelhecer diante da tela.

No z/OS, a investigação é ainda mais refinada. Não basta perguntar “quanto de CPU?”; é preciso considerar CP, zIIP, WLM, prioridade da service class, dispatching delay e a diferença entre usar CPU e esperar para receber CPU. Um workload pode ter sido classificado com importância inadequada, enquanto outro, menos importante, ganha a pista de corrida.

Para o programador COBOL, a lição é humilde e poderosa: antes de concluir que falta máquina, procure trabalho desperdiçado. Um PERFORM mal controlado, uma busca sequencial onde seria possível indexação, conversões repetidas, leitura desnecessária de registros e chamadas redundantes fazem muito barulho quando multiplicadas por milhões.

5. Memória — o vazamento começa como gota e termina como enchente

Memória é a capacidade de manter dados e execução disponíveis sem recorrer excessivamente a paginação, swap ou reinicializações. Vazamentos de memória são particularmente traiçoeiros: a aplicação funciona após o deploy, passa nos testes, opera por algumas horas e, aos poucos, cresce até transformar manutenção de rotina em madrugada de guerra.

Em plataformas distribuídas, procure crescimento contínuo, garbage collection cada vez mais frequente, pausas longas e processos mortos por falta de memória. Em ambiente mainframe, o vocabulário varia — regiões CICS, storage, address spaces, limites e pressão de recursos — mas o princípio é o mesmo: consumo que sobe sem retornar ao patamar normal merece investigação.

Muitos incidentes não são causados por “falta de memória” em sentido absoluto. São causados por fragmentação, limites por processo, vazamento de conexões ou uma aplicação mantendo objetos que deveriam ter sido liberados. O grande crime pode estar numa pequena referência esquecida.

6. Disco e I/O — o porão escuro onde o gargalo se esconde

CPU de 20%, memória tranquila e aplicação lenta: este é o momento de olhar para I/O. A aplicação talvez não esteja calculando; talvez esteja esperando leitura, escrita, flush de log ou páginas do banco.

No mundo Db2, uma consulta aparentemente simples pode fazer centenas de milhares de leituras se o access path for ruim. No VSAM, uma rotina pode transformar acesso direto em leitura sequencial involuntária. No batch, um arquivo enorme pode competir por recursos em um horário já pressionado.

Monitore latência de leitura e escrita, IOPS, fila de I/O, tempo de resposta de volumes, espaço disponível e waits. No z/OS, RMF, SMF, OMEGAMON, SYSVIEW e ferramentas equivalentes ajudam a separar “meu programa está lento” de “meu programa está à espera do storage”.

Eis uma regra de investigação: se alguém sugere comprar mais CPU antes de examinar I/O e SQL, Poirot recomenda cautela. Pode ser como aumentar a potência do carro quando ele está parado numa fila de pedágio.

7. Latência de rede — toda dependência distante aumenta a fragilidade

Uma transação moderna pode atravessar API Gateway, autenticação, microsserviço, cache, serviço externo, MQ, CICS, Db2 e retornar. Cada salto é uma chance adicional de atraso, falha ou timeout.

Não reduza rede a um teste de ping. Há DNS lento, perda de pacotes, handshake TLS, proxy saturado, pool de conexões esgotado, firewall, rota alterada e API de terceiro que decidiu fazer manutenção sem avisar. A parte local pode estar perfeita; a chamada externa pode ser o veneno no chá.

O remédio é rastreamento distribuído: um identificador de correlação que acompanha a requisição. Assim, em vez de saber apenas que a operação demorou oito segundos, você descobre que gastou 200 ms no gateway, 300 ms no CICS, 6,7 s esperando a API externa e 800 ms no Db2.

8. Profundidade de fila — a confissão silenciosa do sistema assíncrono

Fila é uma promessa: “não processei agora, mas processarei daqui a pouco”. IBM MQ é excelente nisso. Ele desacopla produtor e consumidor, absorve picos e protege aplicações. Mas fila crescendo sem parar é a prova de que a entrada é maior que a saída.

Não observe só quantas mensagens existem. Observe também:

  • taxa de entrada versus taxa de consumo;

  • idade da mensagem mais antiga;

  • quantidade de consumidores ativos;

  • retries e mensagens em dead-letter queue;

  • tempo total até a conclusão do negócio.

Uma fila com 100 mil mensagens pode ser normal numa madrugada de processamento massivo. Uma fila com 200 mensagens pode ser gravíssima se costumava ficar zerada e cada uma corresponde a uma autorização de cartão. Contexto, como sempre, é a pequena célula cinzenta que separa análise de decoração.

9. Cache hit rate — velocidade emprestada precisa ser devolvida com correção

Cache evita consultas caras. Quando há hit, o dado já está disponível; quando há miss, a aplicação precisa buscar no banco, no disco ou num serviço remoto. Taxa de acerto baixa pode despejar carga sobre o Db2 e iniciar uma cascata: mais leitura, mais I/O, mais latência, mais timeouts e mais retries.

Porém, uma taxa alta não é absolvição. Cache pode entregar dado velho. Em sistemas de saldo, estoque, preço ou autorização, velocidade sem consistência é apenas um erro muito rápido.

Defina claramente o que pode ser armazenado, por quanto tempo, como invalidar e o que fazer em caso de falha. Nem tudo merece cache; alguns dados existem exatamente para serem consultados em sua forma mais atual.

10. Tempo de consulta Db2 — o mordomo quase sempre tem um índice

Há uma piada de veterano: quando uma aplicação está lenta, a culpa é da rede; quando a rede está boa, a culpa é do servidor; quando o servidor está bom, alguém finalmente abre o EXPLAIN.

Consultas ao banco são causas clássicas de degradação escondida. Meça duração, volume de execuções, linhas lidas versus retornadas, uso de índices, locks, deadlocks, tempo de commit e plano de acesso. Uma query de dois segundos rodando uma vez pode ser tolerável. A mesma query executada vinte mil vezes por minuto é um pedido formal de incidente.

Para quem começa em COBOL com Db2, três hábitos evitam boa parte dos crimes:

  1. Não use SELECT * se precisa de duas colunas.

  2. Conheça as colunas de filtro e os índices disponíveis.

  3. Verifique o plano de acesso quando o volume real crescer.

Também cuide das estatísticas. Um otimizador decide com base no que sabe. Se as estatísticas não representam mais a tabela, ele pode escolher um caminho que parece excelente no papel e péssimo no DASD.

O método Poirot: um passo a passo para investigar degradação

Quando o alerta tocar, resista à tentação de acusar o primeiro gráfico vermelho. Siga um roteiro.

Primeiro: confirme o impacto. Qual jornada foi afetada? Login, pagamento, consulta, emissão, batch, integração? Quem sente: todos, uma região, um cliente, uma versão?

Segundo: determine quando começou. Houve deploy, alteração de parâmetro, pico de tráfego, janela de batch, mudança de certificado, atualização de tabela, campanha comercial ou falha externa?

Terceiro: compare sinais. A latência subiu antes dos erros? A fila cresceu antes da CPU? O Db2 ficou lento antes da aplicação esgotar conexões? A sequência importa: ela é a linha do tempo do crime.

Quarto: encontre o gargalo, não o sintoma. Aumentar instâncias pode piorar uma base já sobrecarregada. Reiniciar consumidor pode gerar uma tempestade de reprocessamento. Escalar CPU não cura lock Db2.

Quinto: reduza o impacto. Limite tráfego, faça rollback de mudança, ative modo degradado, aumente consumidores com cuidado, interrompa batch concorrente ou desabilite uma função não essencial.

Sexto: registre o caso. Depois do incidente, documente causa, sinais iniciais, decisão tomada, impacto, correção e alerta preventivo. O objetivo não é achar um culpado humano; é fazer o sistema ensinar a própria equipe.

O dashboard que vale alguma coisa

O painel deve começar pelo negócio, não pelo hardware. Coloque no topo as transações críticas, taxa de sucesso, latência p95/p99 e orçamento de erro. Depois, use CPU, memória, I/O, rede, cache, fila e banco como trilha de investigação.

Uma estrutura simples e poderosa é observar quatro sinais de ouro:

  • latência: está demorando?

  • tráfego: quanto trabalho chegou?

  • erros: está falhando?

  • saturação: qual recurso chegou ao limite?

Os dez sinais do infográfico aprofundam essa estrutura. Eles não competem entre si; conversam entre si.

Epílogo — o sinal em que se deve confiar

Se Poirot tivesse de escolher apenas um sinal para decisão em produção, ele provavelmente escolheria um SLO ligado à experiência da transação crítica: sucesso dentro de um tempo aceitável. CPU, memória, rede, disco, Db2 e fila são fundamentais para encontrar a causa. Mas o usuário não compra CPU. Ele compra o resultado.

Portanto, a melhor métrica não é “CPU abaixo de 80%”. É algo como: “99,9% das transferências devem concluir corretamente em até dois segundos.” Essa promessa pode ser medida, defendida e investigada.

No fim, monitorar é isso: notar o aumento discreto da latência antes de virar timeout; perceber a fila antes de virar backlog; encontrar a query antes de ela virar indisponibilidade; ouvir os sinais antes que o CPD inteiro grite.

E quando alguém disser que está tudo verde, mas o cliente está esperando, ajuste o bigode imaginário e responda: “Então, mon ami, talvez devêssemos investigar o que esses verdes estão deixando de contar.”




terça-feira, 5 de março de 2024

⚡ Quando o Homem Médio Desperta: Salarymen que Quebraram o Sistema nos Animes

 


⚡ Quando o Homem Médio Desperta: Salarymen que Quebraram o Sistema nos Animes

Durante décadas, o salaryman foi o retrato da obediência: o homem que não falava alto, não sonhava alto e não errava em público.
Mas em algum momento, o Japão — e o anime — começou a perguntar:
“E se ele simplesmente dissesse não?”


🕴️ O colapso do terno e gravata

A geração pós-guerra construiu o mito do trabalhador perfeito.
Mas os anos 90 trouxeram o colapso financeiro, a falência de empresas e a percepção de que o esforço cego não garantia segurança alguma.
O salaryman moderno herdou o script sem o final feliz — e começou a rasgá-lo.

Nos animes, essa ruptura aparece como despertar existencial, uma faísca que acende dentro da rotina automática.
Ele deixa de ser engrenagem e se torna indivíduo.
Às vezes pela raiva, às vezes pelo cansaço — mas sempre pela necessidade de existir de verdade.


🔥 Kintarō: o ex-gângster que virou executivo

Em “Salaryman Kintarō” (1999), o protagonista é tudo o que um salaryman tradicional não deve ser: impulsivo, emotivo, rebelde.
Ex-membro de uma gangue, ele entra em uma construtora e desafia o sistema hierárquico com honestidade brutal.
Kintarō não joga o jogo da política corporativa — ele o explode.
Sua presença é quase mítica: o homem que mostra que coragem e moral ainda podem sobreviver no asfalto corporativo.


🎤 Aggretsuko: o grito no karaokê

Retsuko é a versão milennial do salaryman: uma contadora de 25 anos, explorada, exausta e obrigada a sorrir o tempo todo.
Quando o expediente acaba, ela vai para uma cabine de karaokê e canta death metal.
A voz dela é o grito contido de uma geração inteira.
Em meio ao caos, Retsuko não destrói o sistema — mas o enfrenta à sua maneira, transformando dor em arte.
É a rebelião cotidiana, disfarçada de desabafo.


🧠 Satou (NHK ni Youkoso!): o que acontece quando o colapso é interno

Satou, o protagonista de “NHK ni Youkoso!” (2006), é o salaryman que desistiu antes mesmo de começar.
Trancado em casa, preso a teorias conspiratórias e vícios, ele é o retrato do colapso psicológico de uma geração que não conseguiu se adaptar ao modelo de sucesso japonês.
O despertar de Satou não é heroico — é doloroso, vacilante, humano.
Ele não quer mais ser parte do sistema, mas também não sabe como existir fora dele.
Seu maior inimigo é o próprio vazio.


💻 “Eden of the East”: o jovem executivo e a moral em ruínas

Em “Higashi no Eden” (2009), Akira Takizawa acorda nu, com amnésia e um celular cheio de dinheiro.
Descobre que faz parte de um jogo onde 12 pessoas podem “salvar o Japão” usando bilhões de ienes.
A série transforma o salaryman em um hacker, messias e terrorista ao mesmo tempo — uma alegoria da rebelião digital contra a burocracia e o conformismo.


🏙️ O despertar silencioso

Nem todo despertar é explosivo.
Às vezes, o homem médio desperta em silêncio — um pequeno gesto de resistência:
dizer “não” ao nomikai obrigatório,
ir pra casa mais cedo,
confessar que está cansado,
ou simplesmente lembrar quem era antes do crachá.

Animes como “Tokyo Godfathers”, “Shinya Shokudō” e “Midnight Occult Civil Servants” mostram personagens que encontram sentido nas margens da vida urbana — um prato quente, um gesto de compaixão, uma conversa após o expediente.
É a revolução em escala humana.


🌅 O novo arquétipo

Hoje, o salaryman nos animes não é apenas símbolo de submissão — é um terreno fértil de transformação.
Ele é o homem comum que cansou de sobreviver.
Que percebeu que o sistema não o salvará, mas que ainda assim pode salvar algo: sua dignidade, seus sonhos, seu riso.

O despertar não é gritar contra o mundo.
É recusar o automático.
É abrir os olhos dentro do trem e notar que há uma cidade inteira lá fora esperando — e que o herói da história, finalmente, pode ser ele mesmo.

終電まで働く人々 ・ Histórias de quem trabalha até o último trem

Crônicas do Homem Comum

O salaryman como espelho do Japão moderno: solidão, ruptura e sobrevivência na passagem do escritório analógico para a vida pós-digital.

4 crônicas Japão contemporâneo Trabalho e sociedade
“A rotina é só o palco. A vida, se você olhar direito, ainda está acontecendo.”

☕ Um Café no Bellacosa Mainframe

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