Translate

quinta-feira, 9 de julho de 2026

O Guia Definitivo para um Programador COBOL Padawan Entender por que a Nova Revolução da Inteligência Artificial Parece Muito Mais um Sistema Bancário do IBM Z do que um Chatbot

 

Bellacosa Mainframe ai agents sem misterios

☕ Um Café no Bellacosa Mainframe

AI Agents sem Mistérios

O Guia Definitivo para um Programador COBOL Padawan Entender por que a Nova Revolução da Inteligência Artificial Parece Muito Mais um Sistema Bancário do IBM Z do que um Chatbot

"No Mainframe aprendemos uma lição que o mercado de IA está redescobrindo apenas agora: inteligência nunca esteve em uma única aplicação. Ela sempre surgiu da integração disciplinada entre diversos componentes especializados."


Durante os últimos anos, muito se falou sobre GPT, Llama, Claude, Gemini, DeepSeek e inúmeros outros modelos de linguagem. Para quem observa de fora, parece que a evolução da Inteligência Artificial consiste simplesmente em criar modelos cada vez maiores.

Mas existe uma mudança silenciosa acontecendo.

A próxima revolução não é sobre modelos.

É sobre arquitetura.

E essa talvez seja a melhor notícia que um programador COBOL pode receber.

Enquanto boa parte da indústria acredita que a IA nasceu em 2022, profissionais de Mainframe podem olhar para praticamente qualquer diagrama moderno de AI Agents e dizer:

"Curioso... já vi algo muito parecido funcionando em bancos há décadas."

Obviamente, as tecnologias são diferentes.

Os problemas também.

Mas os princípios da engenharia permanecem surpreendentemente familiares.


A maior ilusão sobre IA

Quando alguém pensa em Inteligência Artificial normalmente imagina algo assim:

Usuário
     │
     ▼
   ChatGPT
     │
     ▼
 Resposta

Isso funciona.

Mas isso não é um agente.

É apenas uma conversa.

Um verdadeiro AI Agent parece muito mais com isto:

Objetivo

↓

Planejamento

↓

Memória

↓

Recuperação de Conhecimento

↓

Raciocínio

↓

Ferramentas

↓

Execução

↓

Avaliação

↓

Nova decisão

Perceba um detalhe extremamente importante.

O modelo de linguagem aparece apenas como um componente.

Ele deixou de ser o protagonista.

Passou a ser apenas uma peça do sistema.

Isso muda completamente a forma de pensar.


Curiosidade nº 1

Os primeiros grandes sistemas corporativos já funcionavam como "agentes", embora ninguém utilizasse esse nome.

Pense em um processamento bancário.

O cliente solicita uma transferência.

O programa COBOL não resolve tudo sozinho.

Ele:

  • consulta o Db2;

  • verifica limites;

  • conversa com CICS;

  • envia mensagens MQ;

  • registra auditoria;

  • grava logs;

  • dispara novos processos.

No final, dezenas de componentes participaram daquela simples operação.

A IA Agêntica está redescobrindo exatamente esse conceito.


O verdadeiro cérebro do agente

Existe uma frase interessante na Engenharia de Software:

"Software complexo não é construído escrevendo funções enormes.

É construído coordenando pequenas funções muito bem organizadas."

Com agentes acontece exatamente isso.

O LLM não controla tudo.

Quem controla é a arquitetura.

Imagine um maestro.

O maestro não toca violino.

Não toca piano.

Não toca trompete.

Mas coordena todos.

O Agent Runtime faz exatamente isso.


Easter Egg nº 1

Se você já escreveu um PERFORM UNTIL em COBOL, já entende melhor um AI Agent do que imagina.

Veja:

PERFORM UNTIL PROCESSO-CONCLUIDO

    LER-DADOS

    VALIDAR

    PROCESSAR

    EXECUTAR

    VERIFICAR-RESULTADO

END-PERFORM

Agora compare com um agente moderno:

Observe

↓

Think

↓

Evaluate

↓

Execute

↓

Observe novamente

São praticamente o mesmo padrão arquitetural.

A única diferença é que agora algumas decisões são tomadas por modelos estatísticos.


Memória não significa banco de dados

Outro erro muito comum.

Quando falamos em memória, muita gente pensa imediatamente em um banco de dados.

Não é isso.

Os agentes modernos possuem diversos tipos de memória.

Isso lembra bastante a organização interna de um programa COBOL.


Working Memory

Equivale às variáveis da Working-Storage.

01 WS-NOME.

01 WS-SALDO.

01 WS-CPF.

Essas informações existem apenas durante o processamento.

Quando o programa termina...

Desaparecem.


Episodic Memory

Guarda experiências anteriores.

Imagine um operador que lembra:

"Ontem essa API ficou indisponível."

Ou:

"O cliente sempre prefere receber PDF."

Essa memória melhora decisões futuras.


Procedural Memory

Talvez seja a mais interessante.

Ela não guarda conhecimento.

Guarda procedimentos.

Exatamente como um programador COBOL.

Você talvez não memorize todos os comandos do SORT.

Mas sabe quando utilizá-los.

Esse conhecimento é procedural.


Easter Egg nº 2

Uma PROCEDURE DIVISION inteira pode ser vista como uma forma primitiva de memória procedural.

Isso mostra que COBOL sempre foi muito mais sofisticado do que muitos imaginam.


O MCP explicado para quem conhece Mainframe

Muita gente acredita que MCP é uma IA.

Não é.

Também não é um banco.

Nem um framework.

MCP é um protocolo.

Pense nele como:

  • JDBC

  • ODBC

  • MQ

  • TCP/IP

  • HTTP

  • REST

Seu trabalho é padronizar comunicação.

Nada mais.

Nada menos.

Sem ele, cada ferramenta precisaria conversar de uma forma diferente.

Com ele:

LLM

↓

MCP

↓

GitHub

↓

SAP

↓

Jira

↓

Mainframe

↓

Banco

↓

Filesystem

Tudo segue uma mesma linguagem.


Curiosidade nº 2

O sucesso do TCP/IP não aconteceu porque era o protocolo mais rápido.

Aconteceu porque todo mundo resolveu falar a mesma língua.

MCP caminha exatamente nessa direção.


Ferramentas são os novos EXEC CICS

Existe uma comparação extremamente divertida.

No COBOL temos:

EXEC SQL

CALL

EXEC CICS

LINK

XCTL

MQPUT

MQGET

Na IA temos:

Tool()

API()

Database()

Search()

Filesystem()

Email()

Calendar()

O conceito é idêntico.

A lógica continua sendo apenas um orquestrador.


O ciclo infinito da inteligência

A figura mostra algo fantástico.

O agente nunca para de observar.

Ele vive em um ciclo permanente.

Observar

↓

Interpretar

↓

Planejar

↓

Executar

↓

Observar novamente

Isso lembra outro velho conhecido.

O monitor CICS.

Recebe transação

↓

Processa

↓

Envia resposta

↓

Espera próxima transação

É um ciclo eterno.


Easter Egg nº 3

O famoso laço de controle OODA (Observe, Orient, Decide, Act), criado pelo estrategista militar John Boyd, é frequentemente comparado ao ciclo de agentes modernos.

Curiosamente, muitos sistemas transacionais corporativos já implementavam ciclos semelhantes muito antes da popularização da IA.


O agente não pensa sozinho

Esta talvez seja a maior descoberta da IA moderna.

Pensar custa caro.

Consultar custa barato.

Por isso surgiu o RAG.

Ao invés de decorar tudo...

O agente consulta.

Isso lembra muito um programa COBOL.

Um sistema bancário não possui todos os clientes em memória.

Ele consulta o Db2.

Sempre que necessário.


Curiosidade nº 3

Quanto maior o agente, menos ele depende da memória interna.

Parece contraditório.

Mas faz sentido.

Grandes sistemas preferem consultar fontes oficiais do que confiar apenas na memória.

Os bancos fazem isso há décadas.


Planejamento lembra um velho conhecido...

JCL.

Antes do programa executar:

STEP001

↓

STEP002

↓

STEP003

↓

STEP004

Tudo já foi planejado.

Os agentes fazem exatamente isso.

Antes de responder.

Eles decompõem o problema.


Easter Egg nº 4

O conceito moderno chamado Task Decomposition é praticamente o equivalente filosófico ao particionamento de um grande JOB em múltiplos STEP's reutilizáveis.


O maior erro de um iniciante

Quem está começando em IA normalmente pergunta:

"Qual é o melhor modelo?"

Essa pergunta equivale a perguntar:

"Qual é o melhor compilador COBOL?"

Não é a pergunta correta.

A pergunta correta seria:

Como toda a arquitetura foi construída?


O verdadeiro diferencial

Os agentes realmente impressionantes possuem:

✔ memória

✔ ferramentas

✔ planejamento

✔ logs

✔ recuperação

✔ auditoria

✔ monitoramento

✔ controle

✔ validação

✔ observabilidade

Parece familiar?

Claro.

É exatamente assim que sistemas críticos são construídos.


Curiosidade nº 4

Os bancos nunca confiaram apenas no programa COBOL.

Sempre confiaram na arquitetura inteira.

A IA está aprendendo essa mesma lição.


O papel da avaliação

Uma diferença enorme entre um chatbot simples e um agente corporativo está na etapa de avaliação.

Depois de executar uma ação, o agente pergunta:

  • A API respondeu?

  • O banco confirmou?

  • O arquivo foi criado?

  • O usuário recebeu?

  • O resultado faz sentido?

No Mainframe fazemos isso desde sempre.

IF SQLCODE = ZERO

IF FILE-STATUS = "00"

IF RETURN-CODE = ZERO

A validação é parte da lógica.

Nunca um detalhe.


Easter Egg nº 5

Um dos padrões mais modernos em agentes é chamado Reflection.

Depois de responder...

O agente analisa sua própria resposta.

Curiosamente, isso lembra bastante um programador experiente revisando o próprio código antes do code review.


Observabilidade: a grande esquecida

Um agente sem logs é como um programa batch sem SYSOUT.

Quando algo dá errado...

Ninguém sabe por quê.

Por isso arquiteturas modernas utilizam:

  • Telemetria

  • Métricas

  • Traces

  • Logs

  • Auditoria

  • Eventos

No IBM Z temos equivalentes extremamente maduros:

  • SMF

  • RMF

  • SYSLOG

  • SDSF

  • JESMSGLG

  • JESYSMSG

Mais uma vez, o Mainframe já praticava esses conceitos há muito tempo.


A verdadeira autonomia

Existe uma frase que merece ser lembrada.

Um agente não é inteligente porque executa muitas ações.

Ele é inteligente porque sabe quando não executar.

Essa é a diferença entre automação e autonomia responsável.

É por isso que governança, políticas de acesso, autenticação, autorização e auditoria são componentes indispensáveis em ambientes corporativos.


O maior Easter Egg de todos

Talvez o aspecto mais curioso dessa nova geração de IA seja perceber que muitos dos conceitos considerados "inovadores" já existiam, com outros nomes, no universo Mainframe.

IA AgênticaIBM Z / Mainframe
Working MemoryWorking-Storage
Procedural MemoryProcedure Division
Tool CallingEXEC CICS / EXEC SQL / CALL
PlannerJCL / Scheduler
RetrievalDb2 / VSAM / IMS
ReflectionValidação de RC, SQLCODE, FILE STATUS
OrchestratorCICS, JES2, Control-M, OPC
ObservabilitySMF, RMF, SDSF, SYSLOG
Agent RuntimeMonitor transacional + lógica de negócio
GovernanceRACF, SAF, Auditoria

É claro que não são tecnologias equivalentes em implementação, mas os princípios arquiteturais apresentam paralelos notáveis.


Conselho final para um Padawan COBOL

Se você acredita que a Inteligência Artificial substituirá completamente os profissionais de Mainframe, talvez esteja olhando apenas para a superfície.

Os melhores arquitetos de agentes precisarão entender muito mais do que prompts. Eles precisarão dominar orquestração, governança, integração, confiabilidade, observabilidade, recuperação de falhas e regras de negócio — exatamente os pilares sobre os quais os grandes sistemas IBM Z foram construídos ao longo de décadas.

Enquanto muitos enxergam um AI Agent como um "chatbot com ferramentas", um programador COBOL experiente reconhece algo muito mais profundo: um ecossistema de componentes cooperando de forma disciplinada para atingir um objetivo comum.

No fim das contas, a grande lição é quase poética. A indústria da IA está descobrindo que inteligência não nasce de um modelo gigantesco, mas da engenharia cuidadosa que conecta memória, planejamento, raciocínio, execução, auditoria e controle. E para quem passou anos desenvolvendo aplicações críticas em bancos, seguradoras e governos, isso soa surpreendentemente familiar.

Como diria um velho Mestre Jedi do IBM Z:

"Os modelos impressionam nas demonstrações. Mas são as arquiteturas bem projetadas que sobrevivem por décadas."


quarta-feira, 8 de julho de 2026

DevOps no Mainframe: O Guia Definitivo para Quem Programa em COBOL e Quer Entrar no Mundo da Entrega Contínua

 

Bellacosa Mainframe e o guia do devops para mainframe

☕ Um Café no Bellacosa Mainframe

DevOps no Mainframe: O Guia Definitivo para Quem Programa em COBOL e Quer Entrar no Mundo da Entrega Contínua

"DevOps não é instalar uma ferramenta. É mudar a forma como pensamos sobre desenvolvimento, testes, implantação e operação. E sim... isso também vale para COBOL."

Se você trabalha com IBM Mainframe há alguns anos, provavelmente já ouviu alguém dizer:

"Mainframe não precisa de DevOps."

Ou então:

"DevOps é coisa de Java, Kubernetes e Cloud."

Nada poderia estar mais distante da realidade.

Hoje, os maiores bancos, seguradoras, empresas de cartão de crédito, telecomunicações e governos do mundo utilizam práticas de DevOps justamente nos ambientes mais críticos: os sistemas IBM Z.

A verdade é simples:

O código COBOL continua excelente. O processo de desenvolvimento é que evoluiu.

Neste café vamos entender, de maneira prática, o que é DevOps, como funciona, quais ferramentas existem, como começar do zero e como implantar esse modelo em uma fábrica de software Mainframe.

Pegue seu café.

Vamos conversar.


Antes de tudo: o que é DevOps?

A palavra DevOps vem da união de duas áreas:

  • Development (Desenvolvimento)

  • Operations (Operação)

Durante décadas essas equipes trabalharam separadas.

O desenvolvedor escrevia código.

O operador implantava.

O suporte resolvia problemas.

Quando dava errado...

Todo mundo culpava o outro.

DevOps nasceu justamente para eliminar esse conflito.

O objetivo é fazer todos trabalharem juntos durante todo o ciclo de vida do software.


O ciclo tradicional

Durante muitos anos o fluxo era parecido com isto:

Analista
      ↓
Programador COBOL
      ↓
Testes
      ↓
Homologação
      ↓
Mudança
      ↓
Produção

Tudo manual.

Muito e-mail.

Planilhas.

Checklist.

JCL executado manualmente.

Libraries copiadas.

Muitas chances de erro humano.


O ciclo DevOps

Agora imagine outro cenário.

Programador
      ↓
Git
      ↓
Build automático
      ↓
Testes automáticos
      ↓
Deploy automático
      ↓
Homologação
      ↓
Produção
      ↓
Monitoramento

Tudo rastreado.

Tudo versionado.

Tudo auditável.

Esse é o objetivo do DevOps.


DevOps não é uma ferramenta

Este talvez seja o maior erro dos iniciantes.

DevOps não é:

  • Jenkins

  • Git

  • GitHub

  • Azure DevOps

  • GitLab

Essas são ferramentas.

DevOps é uma cultura.

As ferramentas apenas ajudam.


Bellacosa Mainframe e o devops para iniciante mainframe

Os pilares do DevOps

Podemos resumir DevOps em seis grandes pilares.

1. Planejamento

Toda mudança começa aqui.

Exemplo:

  • Nova funcionalidade

  • Correção de bug

  • Mudança legal

  • Novo produto

Ferramentas:

  • Jira

  • Azure Boards

  • Trello

  • ServiceNow


2. Desenvolvimento

Aqui entra o programador COBOL.

Ele escreve código.

Exemplo:

Programa COBOL

+
JCL

+
PROC

+
Copybooks

+
DB2

+
CICS

Tudo precisa ficar versionado.


3. Integração Contínua (CI)

Sempre que alguém altera o código...

O sistema automaticamente:

  • compila

  • executa testes

  • verifica qualidade

  • gera relatórios

Sem intervenção humana.


4. Testes

Não basta compilar.

É necessário testar.

Tipos comuns:

  • teste unitário

  • teste funcional

  • teste integração

  • teste regressão

  • teste performance

No Mainframe isso pode envolver:

  • ZUnit

  • IBM Debug

  • File Manager

  • stubs

  • dados mascarados


5. Deploy

Depois da aprovação:

o sistema promove automaticamente os artefatos entre ambientes.

DEV

↓

QA

↓

HML

↓

PRD

Sem copiar datasets manualmente.


6. Monitoramento

Depois da implantação...

O trabalho continua.

Monitoramos:

  • CPU

  • tempo de resposta

  • erros

  • logs

  • abends

  • consumo

  • throughput


Bellacosa Mainframe e ferramentas para implementar o devops

O famoso CI/CD

Você verá muito essa sigla.

CI

Continuous Integration

CD

Continuous Delivery

ou

Continuous Deployment.

A diferença é simples.

Continuous Delivery

O deploy fica pronto.

Mas alguém aprova.

Continuous Deployment

O deploy acontece automaticamente.


Como isso funciona no Mainframe?

Imagine um programa COBOL.

Você altera uma linha.

Ao salvar:

Git

↓

Pipeline

↓

Compilação

↓

Link-edit

↓

Testes

↓

Deploy

↓

Homologação

Tudo automático.


Ferramentas mais usadas

Vamos conhecer as principais.

Git

O coração do DevOps.

Ele controla versões.

Permite:

  • histórico

  • branches

  • merge

  • rollback

Hoje praticamente todo projeto moderno usa Git.

Inclusive Mainframe.


GitHub

Hospeda repositórios Git.

Possui:

  • Pull Request

  • Code Review

  • Actions

  • Issues

Muito usado em projetos open source.


GitLab

Além do Git...

Possui pipeline integrada.

Muito utilizado em empresas.


Azure DevOps

Muito comum em bancos.

Possui:

  • Boards

  • Repos

  • Pipelines

  • Artifacts

  • Test Plans

Integra muito bem com ambientes corporativos.


Jenkins

Uma das ferramentas de automação mais famosas.

Ele executa:

  • compilação

  • testes

  • deploy

  • scripts

Tudo automaticamente.


IBM Dependency Based Build (DBB)

Ferramenta criada pela IBM para Mainframe.

Ela entende:

  • COBOL

  • PL/I

  • Assembler

  • JCL

  • Copybooks

Excelente para pipelines IBM Z.


IBM Developer for z/OS (IDz)

Substitui boa parte do ISPF.

Integra:

  • Git

  • Debug

  • Build

  • Pipeline


Zowe

Talvez a maior revolução dos últimos anos.

Permite acessar o Mainframe usando:

  • VS Code

  • APIs

  • CLI

  • Explorer

É praticamente uma ponte entre o mundo distribuído e o IBM Z.


VS Code

Hoje muitos programadores COBOL utilizam VS Code.

Com extensões adequadas é possível:

  • editar COBOL

  • enviar código

  • acessar datasets

  • executar comandos


Ansible

Automação de infraestrutura.

Pode automatizar:

  • configuração

  • deploy

  • instalação

  • tarefas repetitivas


SonarQube

Analisa qualidade do código.

Detecta:

  • duplicação

  • complexidade

  • bugs

  • vulnerabilidades

Inclusive existem plugins para COBOL.


JFrog Artifactory

Gerencia artefatos.

Armazena:

  • builds

  • binários

  • versões


Um pipeline simples

Imagine este fluxo.

Programador

↓

Git Commit

↓

Pipeline

↓

Compilar COBOL

↓

Executar testes

↓

Quality Gate

↓

Deploy DEV

↓

Deploy QA

↓

Deploy HML

↓

Produção

Sem copiar datasets manualmente.

Sem FTP.

Sem e-mail.


Como implantar DevOps em um sistema Mainframe?

Aqui está um roteiro simples.

Etapa 1

Mapeie o processo atual.

Pergunte:

Como o programa chega em produção?

Quem aprova?

Quem compila?

Quem faz bind?

Quem copia load modules?

Quem altera CICS?

Quem agenda o Job?


Etapa 2

Versione tudo.

Não apenas programas COBOL.

Também:

  • JCL

  • PROC

  • Copybooks

  • SQL

  • DDL

  • Scripts

  • Documentação


Etapa 3

Padronize.

Todos devem usar:

Mesmo padrão.

Mesmo fluxo.

Mesmo processo.


Etapa 4

Automatize a compilação.

Em vez de:

Editar

Compilar

Link

Testar

Faça:

Commit

↓

Pipeline

↓

Compilação automática

Etapa 5

Automatize testes.

Quanto mais testes...

Maior a confiança.


Etapa 6

Automatize deploy.

Reduza:

  • intervenção humana

  • erros

  • esquecimentos


Etapa 7

Monitore.

Depois do deploy acompanhe:

  • SMF

  • RMF

  • JES

  • SDSF

  • logs

  • CICS

  • DB2


Roadmap para quem está começando

Nível 1

Aprenda:

  • Git

  • GitHub

  • Branch

  • Merge

  • Pull Request


Nível 2

Aprenda:

  • Jenkins

  • Azure DevOps

  • GitLab CI


Nível 3

Aprenda:

  • Pipeline

  • YAML

  • Build


Nível 4

Aprenda:

  • Zowe CLI

  • VS Code

  • REST APIs


Nível 5

Aprenda:

  • DBB

  • IDz

  • SonarQube


Nível 6

Aprenda:

  • Docker (conceitos)

  • Kubernetes (conceitos)

  • OpenShift

Mesmo trabalhando apenas com Mainframe.


Nível 7

Aprenda observabilidade.

Conheça:

  • Grafana

  • Prometheus

  • Elastic

  • OpenTelemetry

Mesmo que parte do monitoramento do IBM Z utilize soluções específicas da IBM.


Quanto custa implantar?

A resposta depende do ambiente.

Há soluções gratuitas e corporativas.

Gratuitas

  • Git

  • GitHub (planos gratuitos)

  • VS Code

  • Jenkins

  • Zowe

  • SonarQube Community

O investimento principal será tempo de implantação, treinamento e adaptação dos processos.

Corporativas

Dependendo da empresa podem existir licenças para:

  • IBM Dependency Based Build

  • IBM Developer for z/OS

  • Azure DevOps

  • GitHub Enterprise

  • GitLab Enterprise

  • JFrog Artifactory

  • UrbanCode Deploy (ou soluções equivalentes)

  • ferramentas de testes automatizados

Além das licenças, considere:

  • infraestrutura

  • treinamento

  • consultoria

  • integração com RACF, CICS, DB2 e sistemas legados

  • manutenção contínua

Apesar do investimento inicial, a redução de retrabalho e de falhas costuma compensar em projetos de médio e grande porte.


Quais são os riscos?

Toda mudança traz desafios.

Os principais são:

Resistência cultural

O maior obstáculo raramente é técnico.

É comum ouvir:

"Sempre fizemos assim."

Sem apoio da liderança, a adoção perde força.

Automação mal planejada

Automatizar um processo ruim apenas faz o erro acontecer mais rápido.

Primeiro simplifique.

Depois automatize.

Falta de testes

Um pipeline sem testes é apenas um "copiador automático" de problemas.

Invista em testes desde o início.

Controle de acesso

Automações precisam respeitar políticas de segurança.

Integração com RACF, auditoria e segregação de funções são indispensáveis.

Dependência de poucas pessoas

Evite que apenas um especialista conheça o pipeline. Documente, treine a equipe e compartilhe conhecimento.


As grandes vantagens

Os benefícios aparecem rapidamente.

  • Menos erros manuais.

  • Entregas mais rápidas.

  • Maior rastreabilidade.

  • Rollback simplificado.

  • Melhor colaboração entre desenvolvimento e operações.

  • Qualidade de código mais alta.

  • Testes executados com frequência.

  • Auditoria facilitada.

  • Processos padronizados.

  • Redução do tempo de implantação.

  • Mais confiança para liberar novas versões.

  • Maior integração entre Mainframe e plataformas distribuídas.

Para ambientes regulados, como bancos e seguradoras, isso também significa maior conformidade e facilidade em auditorias.


E as desvantagens?

Nem tudo são flores.

  • Curva de aprendizado inicial.

  • Mudança cultural pode gerar resistência.

  • Necessidade de treinamento.

  • Tempo para configurar pipelines.

  • Investimento em ferramentas corporativas, quando necessário.

  • Ajustes em processos antigos.

  • Necessidade de governança para evitar pipelines desorganizados.

A boa notícia é que esses desafios diminuem à medida que a equipe ganha experiência.


Um exemplo prático

Imagine que uma alteração fiscal exige mudanças em um programa COBOL.

Sem DevOps:

  1. Desenvolvedor altera o código.

  2. Envia por e-mail.

  3. Outro profissional compila.

  4. Um terceiro faz o BIND.

  5. Alguém copia o módulo para homologação.

  6. Os testes são executados manualmente.

  7. A documentação é atualizada depois (ou esquecida).

  8. A implantação depende de uma janela operacional.

Com DevOps:

  1. O desenvolvedor cria uma branch.

  2. Implementa a alteração.

  3. Abre um Pull Request.

  4. O código passa por revisão.

  5. O pipeline compila automaticamente.

  6. Testes unitários e de integração são executados.

  7. A qualidade é validada pelo SonarQube.

  8. Após aprovação, o deploy é promovido para homologação.

  9. Com a autorização final, a mesma pipeline promove a versão para produção.

  10. Todo o processo fica registrado para auditoria.

Perceba que o COBOL continua sendo COBOL. O que mudou foi a forma de entregar software.


Conclusão

Durante muito tempo, DevOps foi visto como algo exclusivo do mundo Linux, Java e Cloud. Hoje sabemos que essa visão ficou no passado.

O IBM Z evoluiu. Ferramentas como Git, Zowe, IBM Dependency Based Build, Azure DevOps, Jenkins e pipelines de CI/CD permitem que aplicações COBOL participem do mesmo ciclo moderno de desenvolvimento utilizado nas demais plataformas da empresa.

Se você é um Padawan COBOL, não tente aprender tudo de uma vez. Comece pelo essencial: Git, versionamento, revisão de código e conceitos de integração contínua. Em seguida, avance para pipelines, automação de testes e deploy. Com essa base, ferramentas específicas do Mainframe farão muito mais sentido.

Lembre-se: DevOps não substitui o conhecimento de COBOL, JCL, CICS ou DB2. Ele potencializa esse conhecimento, reduzindo erros, aumentando a qualidade e permitindo que sistemas críticos evoluam com segurança.

No fim das contas, o maior legado do DevOps não é uma ferramenta nem um pipeline. É uma mudança de mentalidade: desenvolver, testar, implantar e operar como um único time, entregando valor continuamente para o negócio.

E esse, meu amigo Padawan, é um princípio que nunca ficará obsoleto.


PERFORM Recursivo em COBOL: O Warning que Todo Padawan Ignora (Até o Job Estourar o TIME e o REGION)

 

Bellacosa e o perigo do perform recursivo

☕ Um Café no Bellacosa Mainframe

PERFORM Recursivo em COBOL: O Warning que Todo Padawan Ignora (Até o Job Estourar o TIME e o REGION)

"Recursão é uma ferramenta fantástica... exceto quando você tenta usá-la como estrutura de repetição dentro de um programa COBOL Batch."

Quem vem de Java, C#, Python ou C costuma achar natural escrever funções recursivas.

Quem cresceu no COBOL aprende rapidamente uma regra quase sagrada:

Nunca faça um PERFORM recursivo em um parágrafo ou seção.

Mas por quê?

Vamos abrir o capô do compilador.


Primeiro: o que é um PERFORM recursivo?

Imagine algo assim:

0000-PRINCIPAL.

    PERFORM 1000-PROCESSA

    STOP RUN.

1000-PROCESSA.

    DISPLAY "PROCESSANDO"

    PERFORM 1000-PROCESSA.

O programa chama...

...que chama...

...que chama...

...que chama novamente...

Nunca termina.


O warning da compilação

O Enterprise COBOL consegue detectar algumas formas óbvias de recursão.

Durante a compilação pode surgir mensagens semelhantes a:

IGYPSxxxx-W

Recursive PERFORM detected.

ou

Possible recursive PERFORM.

O compilador está dizendo:

"Existe um caminho onde este PERFORM pode executar novamente antes do anterior terminar."

Nem sempre é erro.

Mas quase sempre indica problema de projeto.


Por que isso é perigoso?

Porque PERFORM não foi criado para funcionar como chamada infinita de procedimentos.

Cada PERFORM precisa guardar informações como:

  • endereço de retorno

  • contexto de execução

  • pilha de controle

  • informações internas do runtime

A cada nova chamada tudo isso cresce.

PERFORM A
    ↓
PERFORM A
    ↓
PERFORM A
    ↓
PERFORM A
    ↓
PERFORM A

A pilha nunca é liberada.


O que acontece durante a execução?

Enquanto houver memória:

Stack

+----------------+
| retorno        |
+----------------+
| retorno        |
+----------------+
| retorno        |
+----------------+
| retorno        |
+----------------+
| retorno        |
+----------------+

Cada PERFORM adiciona um novo frame.

Quando acaba a pilha...

Boom.


O programa pode terminar com

Dependendo do ambiente:

  • S0C1

  • S0C4

  • S0CB

  • S878

  • S80A

Ou simplesmente:

ABEND

Tudo depende de onde ocorreu a falha.


O erro de TIME no JCL

Muito antes da memória acabar...

o Job pode morrer por tempo.

Exemplo:

//STEP1 EXEC PGM=MEUPROG,TIME=1

ou

TIME=1440

Mesmo com TIME=1440...

o programa nunca termina.

O JES percebe que o tempo máximo foi atingido.

Resultado:

S322

Ou mensagens semelhantes indicando limite de CPU excedido.

Não foi o COBOL.

Foi o JCL protegendo o sistema.


O erro de REGION

Outro clássico.

Cada PERFORM recursivo consome mais memória.

Em algum momento:

REGION=0M

não resolve.

Porque memória infinita não existe.

O resultado costuma ser:

S878

ou

S80A

Falta de armazenamento.


"Mas REGION=0M não é infinito?"

Não.

É apenas o máximo permitido pela instalação.

Existe limite de:

  • memória virtual

  • stack

  • storage abaixo da linha

  • storage acima da linha

  • política do sistema

Nada disso é infinito.


O maior problema: lógica

Suponha:

1000-ROTINA.

    IF WS-FIM = 'N'
       PERFORM 1000-ROTINA
    END-IF.

Quem altera:

WS-FIM

Se ninguém alterar...

Nunca haverá saída.

É um loop infinito disfarçado.


Por que não usar recursão em parágrafos e seções?

Porque COBOL foi projetado para outro paradigma.

A linguagem nasceu para processamento sequencial.

Ela possui comandos próprios para repetição.

Como:

PERFORM UNTIL
PERFORM VARYING
SEARCH
SEARCH ALL

Essas estruturas:

  • são previsíveis

  • ocupam pouca memória

  • facilitam depuração

  • têm melhor desempenho


"Mas COBOL suporta recursão."

Sim.

Desde o Enterprise COBOL moderno existe:

RECURSIVE PROGRAM-ID.

ou

PROGRAM-ID. MEUPROG RECURSIVE.

Isso significa que o programa pode chamar a si próprio.

Exemplo clássico:

  • árvore binária

  • parsing

  • algoritmos matemáticos

  • estruturas hierárquicas

Mesmo assim...

Não significa que seja recomendado para processamento batch tradicional.


A diferença importante

Errado

Parágrafo
↓

PERFORM

↓

Mesmo parágrafo

Recursão interna.

Difícil de manter.


Correto

Programa A

CALL Programa A

Novo contexto

Retorna

Quando realmente houver necessidade de recursão.


Curiosidade

Os compiladores antigos praticamente desencorajavam qualquer tipo de recursão.

O foco sempre foi:

  • velocidade

  • previsibilidade

  • baixo consumo de memória

A maioria dos sistemas bancários jamais precisou de recursão.


Como um sênior resolveria?

Em vez disso:

PERFORM UNTIL WS-FIM = 'S'

    ...

END-PERFORM

ou

PERFORM VARYING IDX FROM 1 BY 1
        UNTIL IDX > TOTAL

Muito mais claro.

Muito mais rápido.

Muito mais seguro.


Boas práticas

✅ Prefira PERFORM UNTIL para laços controlados.

✅ Use PERFORM VARYING para contadores.

✅ Evite PERFORM chamando o próprio parágrafo.

✅ Revise IFs que nunca alteram a condição de saída.

✅ Analise os warnings do compilador; eles frequentemente apontam defeitos reais de lógica.

✅ Monitore consumo de CPU e storage no SDSF durante testes.

✅ Se precisar de recursão, utilize programas declarados RECURSIVE e valide cuidadosamente profundidade máxima e condição de parada.

✅ Sempre tenha uma condição de saída claramente identificável.


Dicas de depuração

Se um Job "não termina":

  1. Verifique se a CPU continua aumentando no SDSF.

  2. Procure PERFORMs que retornam ao mesmo parágrafo.

  3. Confirme se a variável de controle realmente muda.

  4. Ative SSRANGE em ambiente de teste para detectar erros relacionados a índices e referências inválidas.

  5. Gere um compile listing (LIST, MAP, XREF) para acompanhar o fluxo de chamadas.

  6. Revise mensagens do compilador; um warning ignorado hoje pode virar um ABEND amanhã.


Caminho para o Padawan COBOL

Antes de pensar em recursão, domine completamente:

  1. PERFORM

  2. PERFORM THRU

  3. PERFORM UNTIL

  4. PERFORM VARYING

  5. Estrutura de parágrafos e seções

  6. Escopo explícito (END-IF, END-PERFORM)

  7. Fluxo estruturado sem GO TO

  8. Subprogramas com CALL

  9. Programas RECURSIVE apenas quando o problema realmente exigir

Quando você entender por que o COBOL prefere estruturas iterativas, começará a enxergar o sistema como os arquitetos do IBM Z enxergam: programas previsíveis, eficientes e fáceis de manter. Em ambientes que processam milhões de transações por dia, previsibilidade vale muito mais do que elegância acadêmica.


terça-feira, 7 de julho de 2026

Como um Programador COBOL Padawan Pode Aprender Engenharia de Prompt e Conversar com IA Como um Arquiteto IBM Z

 

Bellacosa Mainframe dicas para criar prompts de ia melhores e mais abrangentes

☕ Um Café no Bellacosa Mainframe

Muito Além do "Escreva um Artigo"

Como um Programador COBOL Padawan Pode Aprender Engenharia de Prompt e Conversar com IA Como um Arquiteto IBM Z

"A diferença entre um programador júnior e um especialista raramente está na linguagem que ele conhece. Está na qualidade das perguntas que ele faz."


Imagine a seguinte situação.

São 8h30 da manhã.

Você acabou de entrar no TSO.

Depois de alguns segundos aparece a velha tela verde.

Você abre o SDSF.

Olha a fila.

Mais de 5.000 jobs.

Centenas de programas COBOL.

DB2.

IMS.

CICS.

MQ.

VSAM.

JCL para todos os lados.

Então alguém chega e pergunta:

— "Você conhece COBOL?"

Você responde:

— "Conheço."

Mas alguns minutos depois a mesma pessoa faz outra pergunta.

— "Como o sistema inteiro funciona?"

É aí que muitos programadores percebem que escrever código é apenas uma pequena parte da profissão.

Com Inteligência Artificial acontece exatamente a mesma coisa.

Quase todo mundo sabe escrever:

Escreva um artigo sobre COBOL.

Pouquíssimos sabem construir um pensamento.

E é justamente isso que diferencia quem apenas usa IA de quem trabalha lado a lado com ela.

Hoje vamos conversar sobre isso.

Pegue seu café.


O maior erro de um Padawan

Quando começamos em COBOL fazemos perguntas assim.

Como faço um READ?

Depois evoluímos.

Como funciona um VSAM KSDS?

Mais tarde.

Quando devo utilizar ESDS ao invés de DB2?

Depois.

Qual arquitetura suporta melhor processamento distribuído mantendo consistência ACID?

Percebeu?

As perguntas ficaram maiores.

Mais inteligentes.

Mais completas.

Com IA acontece exatamente igual.


A IA não lê pensamentos

Este talvez seja o maior Easter Egg deste artigo.

A IA possui bilhões de parâmetros.

Conhece milhões de livros.

Documentações.

Artigos.

Normas.

Código.

Mas existe uma coisa que ela nunca saberá.

O que você realmente queria.

Ela precisa inferir.

Quanto menos contexto você fornece...

Mais ela precisa adivinhar.

E adivinhações nunca são boas em engenharia.


Pense como um Sysprog

Um Sysprog nunca instala um produto IBM digitando apenas

INSTALL

Existe documentação.

Pré-requisitos.

SMP/E.

PTFs.

HOLDDATA.

CSI.

Libraries.

Parâmetros.

Porque sistemas complexos exigem contexto.

A IA também.


Um Prompt é Igual a um JCL

Esse é um paralelo que quase ninguém faz.

Observe.

Um JOB possui:

JOB

EXEC

DD

SYSIN

PARM

COND

REGION

CLASS

MSGCLASS

Cada linha informa uma intenção ao sistema.

Agora veja um prompt moderno.

ROLE

OBJECTIVE

AUDIENCE

CONTEXT

CONSTRAINTS

OUTPUT

STYLE

Não é muito diferente.

Na verdade...

É praticamente um JCL para um cérebro artificial.

Easter Egg #1

Sempre que pensar em Prompt Engineering imagine que você está escrevendo um JOB para executar um programa chamado GPT.

A analogia funciona incrivelmente bem.


Bellacosa Mainframe e a lista de frameworks para ampliar seu prompt

Frameworks são PROCs do pensamento

Quem trabalha com JCL sabe o poder de um PROC.

Você reutiliza padrões.

Evita erros.

Padroniza execução.

Frameworks fazem exatamente isso.

Eles são PROCs para organizar ideias.

Ao invés de reinventar a forma de escrever...

Você reutiliza um modelo que já foi validado durante décadas.


AIDA — O Job de Marketing

Imagine que você criou um curso COBOL.

Você escreve:

Meu curso ensina COBOL.

Fim.

Agora usando AIDA.

Attention

"O PIX brasileiro movimenta bilhões todos os dias utilizando tecnologias que nasceram décadas atrás."

Interest

"Você sabia que provavelmente existe COBOL em alguma etapa dessa transação?"

Desire

"Imagine fazer parte desse mundo."

Action

"Comece estudando COBOL no IBM Z."

Perceba.

As informações são praticamente iguais.

O caminho psicológico mudou completamente.


FAB — O erro clássico do iniciante

Quase todo programador apresenta tecnologia assim.

"COBOL possui COMP-3."

Legal.

E daí?

FAB ensina.

Feature

COMP-3.

Advantage

Ocupa menos espaço.

Benefit

Seu processamento Batch movimenta menos bytes, reduzindo I/O e aumentando desempenho.

O benefício sempre responde:

"Por que eu deveria me importar?"


PEEL — Escrevendo como um Arquiteto

Um arquiteto nunca despeja informações.

Ele organiza.

Cada parágrafo possui.

Point

Evidence

Explanation

Link

Observe qualquer documentação IBM.

Quase todas seguem essa lógica.

Nada está ali por acaso.


KISS — Um dos maiores segredos da IBM

Existe uma frase famosa.

Complexidade gera defeitos.

No Mainframe isso vale ouro.

Os melhores programas COBOL que conheci tinham milhares de linhas.

Mas eram fáceis de ler.

Nomes claros.

Fluxo simples.

Poucos IFs aninhados.

Poucos GO TO.

A IA também gosta disso.

Prompt enorme não significa prompt melhor.

Prompt organizado significa prompt melhor.


SOAPSTONE — Quem está falando?

Este framework é um verdadeiro Easter Egg.

Imagine pedir:

"Explique CICS."

Agora compare.

Você é um IBM Distinguished Engineer.

Explique CICS para um programador COBOL Júnior.

Tom inspirador.

Utilize exemplos bancários.

Use analogias.

Explique em português.

Pronto.

Você praticamente contratou um professor.


STAR — O framework escondido das entrevistas

Muitos usam STAR apenas para RH.

Erro enorme.

STAR é excelente para ensinar tecnologia.

Situação

Batch demorava 8 horas.

Tarefa

Reduzir para quatro.

Ação

RUNSTATS.

REORG.

Novo Access Path.

Resultado

2 horas.

Perceba como contar histórias facilita o aprendizado.


SWOT não serve apenas para empresas

Faça SWOT da sua carreira.

Forças

Conhece COBOL.

Fraquezas

Não conhece APIs.

Oportunidades

Modernização IBM Z.

Ameaças

Parar de estudar.

Você acabou de criar um plano de carreira.


OAR — O framework favorito do Bellacosa

Se eu tivesse que ensinar apenas um...

Seria OAR.

Objective.

Audience.

Research.

Toda vez que conversar com IA diga.

Objetivo.

Quem vai ler.

Quanto aprofundar.

Você ficará impressionado com a diferença.


O Easter Egg que ninguém comenta

Todos esses frameworks parecem diferentes.

Mas escondem um padrão.

Observe.

Todos respondem três perguntas.

O que?

Por quê?

Como?

É só isso.

Alguns acrescentam emoção.

Outros acrescentam evidências.

Outros acrescentam contexto.

Mas todos organizam pensamento.


O framework invisível da IBM

Depois de décadas lendo Redbooks percebi algo interessante.

A IBM raramente escreve utilizando apenas INTRO.

Ou apenas PEEL.

Ou apenas AIDA.

Ela mistura vários.

Introdução.

Contexto.

Problema.

Arquitetura.

Implementação.

Boas práticas.

Resumo.

É um framework híbrido.

E isso inspira um conceito poderoso para prompts.


O Framework Bellacosa Mainframe

Depois de muitos artigos, cursos e apresentações, gosto de organizar um prompt técnico em nove camadas:

1. Papel (Role)
Quem a IA deve representar: um arquiteto IBM Z, um especialista em CICS, um DBA Db2 ou um Sysprog.

2. Público (Audience)
Um Padawan de COBOL? Um desenvolvedor Java? Um gerente? A mesma explicação muda completamente conforme a audiência.

3. Objetivo (Objective)
Ensinar, convencer, revisar código, criar uma aula, produzir um laboratório ou escrever um artigo.

4. Contexto (Context)
Qual ambiente? Banco? Seguradora? IBM Z? z/OS 3.2? CICS TS 6.2? Db2 13? Quanto mais contexto, menos a IA precisa adivinhar.

5. Restrições (Constraints)
O que deve evitar? Qual o tamanho? Deve usar exemplos? Pode usar analogias? Deve citar documentação oficial?

6. Estrutura (Framework)
AIDA, PEEL, STAR, SWOT, INTRO... escolha conscientemente a estrutura que melhor atende ao objetivo.

7. Exemplos (Examples)
Mostre o estilo desejado. Um pequeno exemplo vale mais do que dezenas de instruções abstratas.

8. Formato de Saída (Output)
Artigo, slides, tabela comparativa, FAQ, quiz, roteiro de vídeo, laboratório prático ou infográfico.

9. Revisão (Quality Check)
Peça para a IA verificar coerência, consistência técnica, clareza e possíveis melhorias antes de finalizar.

Essa sequência transforma um pedido simples em uma conversa estruturada, muito parecida com a preparação de uma mudança em produção no ambiente IBM Z.


Easter Eggs para quem quer ir muito além

Se você chegou até aqui, aqui estão alguns "segredos" que costumam fazer diferença.

Easter Egg 1 — Dê identidade à IA

Em vez de pedir:

Explique VSAM.

Experimente:

Você é um IBM Fellow especialista em armazenamento. Explique VSAM para um programador COBOL com seis meses de experiência.

A qualidade costuma aumentar porque você definiu um papel, um público e um nível de profundidade.


Easter Egg 2 — Peça comparações

A IA explica muito melhor quando compara conceitos.

Exemplos:

  • VSAM × Db2

  • COMMAREA × Channels & Containers

  • RACF × ACF2 × Top Secret

  • Batch × Online

  • CICS × IMS TM

Comparações obrigam o raciocínio a destacar diferenças importantes.


Easter Egg 3 — Peça analogias

Analogia é uma ferramenta extraordinária para aprender.

"Explique WLM como se fosse um controlador de tráfego aéreo."

"Explique RACF como se fosse um sistema de portaria de um condomínio."

Você criará conexões mentais muito mais fortes.


Easter Egg 4 — Trabalhe em camadas

Não peça tudo de uma vez.

Prefira uma sequência como:

  1. Explique o conceito.

  2. Mostre a arquitetura.

  3. Apresente um exemplo COBOL.

  4. Explique os erros comuns.

  5. Mostre um caso real.

  6. Crie um laboratório.

  7. Elabore um quiz.

  8. Sugira leituras adicionais.

É exatamente assim que um bom curso é construído.


Easter Egg 5 — Transforme a IA em mentora

Em vez de pedir respostas prontas, peça orientação.

"Faça perguntas que me levem a descobrir a solução."

Esse método desenvolve autonomia e pensamento crítico.


Easter Egg 6 — Use múltiplos frameworks

Um artigo pode começar com INTRO, desenvolver cada seção com PEEL, ilustrar experiências usando STAR, analisar tendências com SWOT e concluir com AIDA. Frameworks não competem entre si; eles se complementam.


Easter Egg 7 — Aprenda observando

Leia Redbooks da IBM, RFCs, artigos técnicos e documentação oficial tentando identificar a estrutura utilizada.

Você começará a enxergar padrões que antes passavam despercebidos.


A maior lição de todas

Existe uma frase muito conhecida na área de desenvolvimento:

Garbage In, Garbage Out.

Ela continua verdadeira na era da Inteligência Artificial.

Uma pergunta superficial tende a produzir uma resposta superficial.

Uma pergunta rica em contexto, objetivos e estrutura abre espaço para uma resposta muito mais útil.

Curiosamente, isso também vale para um programador COBOL. Os profissionais mais respeitados que conheci não eram necessariamente aqueles que memorizavam mais comandos do TSO ou mais instruções COBOL. Eram aqueles que faziam as perguntas certas antes de escrever a primeira linha de código.

No fim das contas, Prompt Engineering não é sobre aprender dezenas de siglas. É sobre desenvolver uma forma organizada de pensar, comunicar objetivos e resolver problemas. Os frameworks apresentados neste artigo — AIDA, PEEL, STAR, SWOT, OAR, FAB, SOAPSTONE, KISS e tantos outros — são ferramentas para isso.

Assim como um Padawan aprende primeiro a dominar os fundamentos da linguagem COBOL antes de enfrentar um sistema bancário de milhões de linhas, quem deseja extrair o máximo da IA precisa dominar os fundamentos da comunicação estruturada. A tecnologia muda, os modelos evoluem e novas siglas surgem todos os meses, mas a capacidade de organizar ideias com clareza continua sendo uma habilidade atemporal.

Da próxima vez que abrir o ChatGPT, não pense apenas em "escrever um prompt". Pense que você está preparando um JCL para executar o maior ambiente de processamento de linguagem natural já criado. Defina o papel, o contexto, o objetivo, a estrutura e o formato da saída. Você descobrirá que conversar com uma IA pode ser tão elegante e previsível quanto construir um bom JOB para o z/OS.

E talvez esse seja o maior aprendizado para um COBOL Padawan: antes de dominar a máquina, aprenda a organizar o próprio pensamento. Afinal, os melhores programas, os melhores projetos e os melhores prompts sempre começam da mesma forma: com uma pergunta bem formulada.


segunda-feira, 6 de julho de 2026

No COBOL e no Futebol : A Distância Entre a Besta e o Bestial é Mínima

 

Bellacosa Mainframe a distancia entre a besta e o bestial é minima

☕ Um Café no Bellacosa Mainframe

A Distância Entre a Besta e o Bestial é Mínima

O Que Todo Programador COBOL Padawan Precisa Saber Sobre Futebol, Carreira, Derrotas, Excelência e Como Não Repetir os Erros da Seleção Brasileira

Existe uma frase que sempre gostei:

A distância entre a besta e o bestial é mínima.

Ela vale para o futebol.

Vale para o mercado financeiro.

Vale para IBM Z.

Vale para COBOL.

Vale para qualquer profissão onde a excelência é construída durante anos e pode desaparecer em apenas alguns minutos.

A derrota da Seleção Brasileira em uma Copa do Mundo costuma gerar um fenômeno curioso. Durante meses ou anos, jogadores são tratados como gênios absolutos. São vendidos por centenas de milhões. Ganham Champions League, Libertadores, Bola de Ouro, títulos nacionais, reconhecimento mundial.

Então chega um único jogo.

Noventa minutos.

Uma eliminação.

E, de repente...

"Não prestam."

"São superestimados."

"Nunca decidiram."

Mas será mesmo?

A resposta é não.

E exatamente aqui existe uma enorme lição para quem trabalha com tecnologia.



Bellacosa Mainframe glorias passadas nao entram em campo

O currículo não entra em campo

Imagine um desenvolvedor COBOL.

Vinte anos de carreira.

Milhares de programas escritos.

Centenas de milhões de transações processadas diariamente.

Zero incidentes graves.

Então...

Em uma madrugada...

Um JOB falha.

Uma alteração gera um ABEND.

O banco fica indisponível.

O cliente vê apenas aquele momento.

Ninguém lembra dos vinte anos anteriores.

O mercado funciona exatamente assim.

Você vale muito...

...até cometer um erro enorme.

Isso parece cruel.

Mas também ensina algo extremamente importante:

Reputação demora décadas para ser construída e segundos para ser questionada.


O futebol não perdoa.

A tecnologia também não.

Grandes craques encerraram a carreira sem conquistar o maior título do futebol.

Zico.

Cruyff.

Puskás.

Di Stéfano.

George Best.

E tantos outros.

Eles deixaram de ser gênios?

Claro que não.

O problema é que o mundo costuma resumir carreiras complexas em um único indicador.

No futebol:

"Copa do Mundo."

Na tecnologia:

"Conhece Cloud?"

"Sabe IA?"

"Tem Kubernetes?"

"Programa em Python?"

Como se décadas de experiência desaparecessem por causa da moda do momento.

Não desaparecem.

Mas também não bastam.


O maior erro da Seleção

Quando analisamos diversas eliminações brasileiras ao longo dos anos, aparece um padrão.

Não foi falta de talento.

Nunca foi.

Talento sempre existiu.

O problema quase sempre esteve em outros fatores.

Planejamento.

Organização.

Adaptação.

Controle emocional.

Leitura do adversário.

Tomada de decisão.

Humildade.

Tudo aquilo que também diferencia um excelente profissional de um profissional apenas talentoso.


COBOL também possui "seleções brasileiras"

Você provavelmente conhece alguém assim.

Sabe tudo de COBOL.

Tudo de JCL.

Tudo de CICS.

Tudo de Db2.

Resolve qualquer dump.

Mas...

Não sabe explicar uma solução.

Não documenta.

Não compartilha conhecimento.

Não conversa com outras equipes.

Não aprende novas tecnologias.

Não entende APIs.

Não conhece Git.

Nunca abriu um VS Code.

Nunca estudou IA.

Nunca aprendeu OpenTelemetry.

Nunca ouviu falar de MCP.

Resultado?

Continua sendo excelente...

...mas apenas dentro de um pequeno espaço.

Enquanto isso, outro profissional talvez saiba menos COBOL.

Muito menos.

Mas entende arquitetura.

Comunicação.

Negócio.

Cloud.

Integração.

Observabilidade.

Automação.

Esse segundo profissional acaba crescendo mais rápido.

Não porque programa melhor.

Mas porque resolve problemas maiores.


O ego derrota muito mais carreiras que a falta de conhecimento

No futebol existe uma frase antiga.

"Time ganha campeonato."

Não estrelas.

No Mainframe isso é ainda mais verdadeiro.

Nenhum sistema bancário sobrevive graças a um único programador.

Existe uma enorme equipe.

Arquitetos.

DBAs.

Operadores.

Analistas.

Segurança.

Infraestrutura.

Storage.

Redes.

Middleware.

Desenvolvimento.

Negócio.

Quando alguém acredita ser indispensável...

Começa sua decadência.


A tecnologia muda o campo

Imagine um craque dos anos 1980 jogando exatamente da mesma maneira hoje.

Provavelmente sofreria.

Não porque ficou ruim.

Mas porque o jogo mudou.

Com COBOL acontece exatamente isso.

Programar COBOL em 2026 não é o mesmo que programar em 1996.

Hoje existe:

  • APIs REST

  • JSON

  • XML

  • Git

  • DevOps

  • CI/CD

  • IA Generativa

  • RAG

  • MCP

  • OpenTelemetry

  • Kafka

  • IBM MQ

  • z/OS Connect

  • Containers

  • VS Code

  • Zowe

  • GitHub Copilot

Quem ignora isso...

Está treinando para um campeonato que já terminou.


O maior adversário nunca foi o concorrente

Sempre fomos nós mesmos.

A seleção brasileira muitas vezes entrou acreditando que venceria apenas pela camisa.

Na tecnologia acontece igual.

"Tenho trinta anos de COBOL."

Ótimo.

E agora?

O mercado pergunta outra coisa.

"O que você aprendeu este ano?"

Essa pergunta separa veteranos relevantes de veteranos nostálgicos.


O verdadeiro craque nunca para de treinar

Cristiano Ronaldo continua treinando.

Messi continua treinando.

LeBron continua treinando.

Djokovic continua treinando.

Nenhum deles diz:

"Já sei tudo."

Então por que um desenvolvedor faria isso?


A derrota também ensina

Existe uma enorme diferença entre fracassar...

...e desperdiçar um fracasso.

Toda derrota entrega dados.

Toda falha produz métricas.

Todo incidente ensina.

Todo ABEND conta uma história.

O problema é quando o profissional apenas procura culpados.

Os melhores fazem outra pergunta.

"O que esse erro está tentando me ensinar?"

Essa pergunta muda completamente uma carreira.


O profissional bestial

Existe um momento em que o conhecimento deixa de ser apenas técnico.

O profissional passa a enxergar padrões.

Antes resolvia problemas.

Agora evita que eles aconteçam.

Antes corrigia JOBs.

Agora melhora processos.

Antes escrevia código.

Agora desenha arquitetura.

Antes respondia chamados.

Agora elimina categorias inteiras de chamados.

Esse é o salto.

Não é escrever mais linhas.

É produzir menos problemas.


A distância entre besta e bestial

Ela realmente é mínima.

A diferença normalmente está em pequenas decisões repetidas durante anos.

Ler um capítulo por dia.

Fazer um laboratório por semana.

Estudar inglês.

Escrever artigos.

Compartilhar conhecimento.

Documentar soluções.

Participar de comunidades.

Ensinar iniciantes.

Aceitar críticas.

Aprender algo novo todos os meses.

Parece pouco.

Mas multiplique isso por dez anos.

Você terá duas pessoas completamente diferentes.


Como não repetir os erros da Seleção

Se eu pudesse deixar alguns conselhos para um COBOL Padawan, seriam estes.

Nunca confie apenas no talento.

Talento sem disciplina desaparece.

Nunca pare de estudar.

Seu maior concorrente talvez ainda esteja na faculdade.

Aprenda negócios.

Programas existem para resolver problemas de empresas.

Quem entende o negócio sempre entrega mais valor.

Aprenda comunicação.

Grandes carreiras raramente são construídas apenas digitando código.

Domine o legado.

Mas converse com o futuro.

COBOL continuará importante.

Mas ele faz parte de um ecossistema muito maior.

Documente tudo.

Sua memória falha.

A documentação permanece.

Automatize tarefas repetitivas.

Tempo economizado vira tempo de aprendizado.

Ensine.

Quem ensina aprende duas vezes.

Aceite feedback.

Orgulho custa caro.

Humildade rende dividendos durante décadas.


O próximo campeonato já começou

Enquanto muitos discutem apenas o último resultado...

Os campeões já estão treinando para o próximo.

No mercado de tecnologia acontece exatamente isso.

Enquanto alguns reclamam da IA...

Outros aprendem a utilizá-la.

Enquanto alguns dizem que COBOL morreu...

Outros integram COBOL com modelos de linguagem.

Enquanto alguns criticam APIs...

Outros conectam sistemas escritos há cinquenta anos com aplicações modernas.

Enquanto alguns vivem do passado...

Outros constroem o futuro.


O verdadeiro título

Talvez você nunca seja o programador mais famoso.

Talvez nunca apareça em uma conferência internacional.

Talvez nunca escreva um livro.

Talvez nunca ganhe um prêmio.

E tudo bem.

Seu verdadeiro título pode ser outro.

Ser aquele profissional em quem todos confiam.

Aquele que mantém milhões de brasileiros utilizando bancos, cartões, seguros, hospitais e serviços públicos sem sequer imaginar que existe um IBM Z trabalhando silenciosamente nos bastidores.

Existe uma enorme beleza nisso.

Porque os melhores sistemas são exatamente aqueles que ninguém percebe que estão funcionando.


Um café antes do apito final

No futebol, um detalhe muda uma Copa.

Na tecnologia, um detalhe muda uma carreira.

A diferença entre a "besta" e o "bestial" raramente está no QI, na faculdade ou no talento nato. Ela está na disciplina silenciosa de quem decide melhorar 1% todos os dias.

Não transforme uma derrota em sentença. Transforme-a em combustível.

Não permita que um sucesso vire acomodação. Faça dele apenas o ponto de partida para o próximo desafio.

A Seleção Brasileira ainda voltará a disputar Copas. Alguns jogadores conquistarão títulos, outros encerrarão a carreira sem levantar a taça mais importante do mundo. Isso faz parte do esporte.

Da mesma forma, você terá projetos brilhantes e projetos difíceis. Terá noites resolvendo ABENDs, incidentes e integrações improváveis. Terá momentos em que será reconhecido e outros em que seu trabalho passará despercebido.

Continue evoluindo.

Continue curioso.

Continue humilde.

Porque, no fim das contas, o mercado não procura apenas quem sabe COBOL.

Procura profissionais capazes de aprender, adaptar-se, colaborar e construir o futuro sem esquecer as lições do passado.

E talvez essa seja a maior definição de excelência.

Não vencer sempre.

Mas nunca parar de evoluir.

Nos encontramos no próximo café.


PS: Não foi de virada a Noruega dominou o tempo todo o jogo, mas com licensa poetica, fica essa errata, somente nos ultimos minutos o Neymar diminuiu o marcador. Vamos ver quantos vão notar e comentar.



IA Generativa Muito Além do ChatGPT - Parte II

Bellacosa Mainfram apresenta ia generativa

☕ Um Café no Bellacosa Mainframe

IA Generativa Muito Além do ChatGPT

O Que Todo Programador COBOL Padawan Precisa Saber Sobre RAG, MCP, watsonx, IBM Z, CICS, Db2, APIs e Como a Inteligência Artificial Está Transformando os Sistemas Mais Críticos do Mundo (Parte 2)

"A tecnologia muda. Os princípios permanecem. Empresas não sobrevivem porque adotam modismos, mas porque conseguem evoluir preservando aquilo que já funciona."


Quando a IA Encontra o Mundo Real

Na primeira parte deste artigo vimos que a Inteligência Artificial não veio substituir o Mainframe.

Na verdade, ela depende dele.

Agora vamos responder uma pergunta ainda mais importante:

Como isso acontece dentro de uma grande instituição financeira?

Esqueça por um momento os chatbots públicos.

Imagine um banco que processa:

  • 150 milhões de transações por dia;

  • milhares de PIX por segundo;

  • milhões de cartões;

  • investimentos;

  • empréstimos;

  • seguros;

  • câmbio;

  • previdência.

Todo esse universo continua sendo coordenado por aplicações executando no IBM Z.

A IA entra como uma camada de inteligência.

Não como substituição.


Caso 1 — Atendimento Inteligente

Imagine que um cliente escreve:

"Meu cartão foi recusado. O que aconteceu?"

Sem IA:

  • abertura de chamado;

  • consulta manual;

  • operador verifica sistemas;

  • resposta alguns minutos depois.

Com IA integrada ao Mainframe:

Cliente

↓

Assistente IA

↓

RAG

↓

API REST

↓

CICS

↓

Programa COBOL

↓

Db2

↓

Regras de Negócio

↓

Resposta Personalizada

Resposta:

"Sua compra foi recusada porque ultrapassou o limite diário de segurança definido para transações internacionais. Você pode aumentar esse limite diretamente pelo aplicativo."

Nenhuma informação foi inventada.

Tudo veio do sistema corporativo.


Caso 2 — Explicando Programas COBOL

Imagine um programa com 25.000 linhas.

O desenvolvedor recém-chegado pergunta:

"Como esse programa calcula juros?"

Sem IA:

Dias analisando código.

Com IA:

Programa COBOL

↓

Parser

↓

Embedding

↓

Base Vetorial

↓

LLM

↓

Resumo Técnico

Resposta:

O cálculo de juros ocorre nos parágrafos CALC-JUROS e APLICA-TAXA. A taxa depende do tipo de contrato, perfil do cliente e índice econômico armazenado na tabela FIN_RATE.

O profissional continua responsável pela validação.

Mas economiza horas.


Caso 3 — Documentação Automática

Uma das maiores dores em sistemas legados é documentação desatualizada.

Hoje podemos construir pipelines que façam:

Git

↓

Programa COBOL

↓

Parser

↓

IA

↓

Markdown

↓

Wiki

↓

Confluence

Resultado:

Toda alteração gera documentação automaticamente.


Caso 4 — Geração de Casos de Teste

Imagine este trecho COBOL:

IF SALDO < VALOR-SAQUE
    MOVE "N" TO AUTORIZADO
ELSE
    MOVE "S" TO AUTORIZADO
END-IF

Uma IA pode sugerir automaticamente:

Caso 1

Saldo = 500

Saque = 300

Resultado esperado:

AUTORIZADO = S

Caso 2

Saldo = 300

Saque = 500

Resultado esperado:

AUTORIZADO = N

Caso 3

Saldo = 500

Saque = 500

Resultado esperado:

AUTORIZADO = S

Isso acelera significativamente testes unitários.


Agentes de IA

O próximo passo da evolução são os agentes.

Enquanto um chatbot apenas responde perguntas, um agente executa tarefas.

Imagine:

"Abra um chamado porque houve aumento de ABEND S0C7."

O agente poderá:

  • consultar o SDSF;

  • analisar logs;

  • pesquisar incidentes semelhantes;

  • abrir ticket;

  • notificar equipes;

  • sugerir solução.

Tudo automaticamente.


Arquitetura de um Agente Mainframe

                    Usuário

                       │

                       ▼

               Agente Inteligente

                       │

          ┌────────────┼────────────┐

          ▼            ▼            ▼

      MCP Tool     RAG Engine   Prompt Engine

          │            │            │

          └────────────┼────────────┘

                       ▼

             IBM API Connect

                       │

          ┌────────────┼────────────┐

          ▼            ▼            ▼

      z/OS Connect    MQ      REST APIs

          │

          ▼

      CICS

          │

          ▼

      COBOL

          │

          ▼

     Db2 / VSAM / IMS

Observe que o agente não substitui aplicações.

Ele coordena.


Observabilidade Inteligente

Ferramentas como:

  • OpenTelemetry

  • Grafana

  • Prometheus

  • Instana

  • IBM Z APM Connect

produzem milhões de métricas.

Uma IA consegue resumir tudo.

Exemplo:

Ao invés de mostrar:

CPU = 83%

I/O = 65%

Storage = 72%

Buffer Pool = 94%

Response Time = 1,8s

A IA apresenta:

Detectamos degradação iniciada às 14h23 causada por aumento nas leituras aleatórias do Db2. Existe forte correlação com o deploy realizado às 14h18.

Isso muda completamente a produtividade.


Segurança com IA

Fraudes evoluem diariamente.

A IA ajuda identificando padrões.

Exemplo:

Cliente normalmente utiliza:

São Paulo

09:00 às 20:00

Compras abaixo de R$ 500.

De repente:

Compra de US$ 8.000

Outro continente

03:17 da manhã.

O modelo identifica anomalias antes mesmo da autorização.


IA Não Pode Alucinar

Esse é um ponto crítico.

Em sistemas financeiros:

Não existe "quase certo".

Imagine responder:

Seu saldo é R$ 15.000

quando na verdade são R$ 1.500.

Por isso arquiteturas corporativas utilizam:

  • RAG

  • MCP

  • APIs oficiais

  • Catálogo de Dados

  • Governança

  • Logs

  • Auditoria

Toda resposta precisa ser rastreável.


Engenharia de Prompt para Mainframe

Prompt ruim:

Explique esse programa.

Prompt profissional:

Você é um arquiteto IBM Z.

Analise este programa COBOL.

Explique:

• regras de negócio

• dependências

• tabelas Db2

• transações CICS

• arquivos VSAM

• riscos

• complexidade

• sugestões de testes

Não invente informações.
Indique apenas aquilo identificado no código.

A qualidade muda completamente.


DevOps + IA

Imagine um pipeline.

Git

↓

Pull Request

↓

SonarQube

↓

COBOL Check

↓

IA

↓

Resumo

↓

Code Review

↓

Deploy

Antes mesmo do revisor abrir o código, a IA já produziu:

  • resumo;

  • riscos;

  • impacto;

  • módulos afetados;

  • documentação.


O Papel do Desenvolvedor

Existe medo.

"IA vai substituir programadores."

A história mostra outra coisa.

Quando surgiram:

  • compiladores;

  • IDEs;

  • Git;

  • Java;

  • frameworks;

  • Cloud;

  • DevOps.

Disseram exatamente a mesma coisa.

O profissional mudou.

Não desapareceu.


O Novo Desenvolvedor Mainframe

Nos próximos anos veremos um perfil diferente.

Além de COBOL, ele entenderá:

✓ APIs

✓ JSON

✓ Python

✓ Engenharia de Prompt

✓ RAG

✓ MCP

✓ IA Generativa

✓ DevOps

✓ Observabilidade

✓ Segurança

✓ Arquitetura

Esse profissional será extremamente valorizado.


O Que Ainda Não Será Substituído

A IA pode escrever código.

Mas ela não conhece:

  • estratégia do banco;

  • legislação;

  • decisões executivas;

  • riscos jurídicos;

  • compliance;

  • auditoria;

  • cultura organizacional.

Quem conhece isso?

As pessoas.


Um Possível Futuro

Imagine daqui a alguns anos.

Você chega ao trabalho.

Pergunta:

"Existe algum problema crítico hoje?"

Resposta:

Foram detectadas três degradações.

Corrigi automaticamente duas.

A terceira envolve alteração de regra de negócio.

Já preparei documentação.

Seguem possíveis soluções.

Isso não é ficção.

É exatamente para onde estamos caminhando.


Arquitetura Completa de IA Corporativa para IBM Z

                    ┌──────────────────────────────────────────────┐
                    │              Usuário Final                   │
                    └──────────────────┬───────────────────────────┘
                                       │
                                       ▼
                        Web │ Mobile │ Chatbot │ Teams │ Slack
                                       │
                                       ▼
                  ┌────────────────────────────────────────┐
                  │        Gateway de APIs / WAF           │
                  └────────────────┬───────────────────────┘
                                   │
                    ┌──────────────┼──────────────┐
                    ▼              ▼              ▼
               Autenticação     Auditoria     Rate Limit
                                   │
                                   ▼
                      ┌────────────────────────────┐
                      │      Modelo Generativo     │
                      │        (watsonx.ai)        │
                      └────────────┬───────────────┘
                                   │
                  ┌────────────────┼────────────────┐
                  ▼                ▼                ▼
              Prompt           RAG Engine       MCP Server
             Orchestrator        Vetores        Ferramentas
                  │                │                │
                  └────────────────┼────────────────┘
                                   ▼
                    ┌──────────────────────────────────┐
                    │ APIs Corporativas / z/OS Connect │
                    └────────────────┬─────────────────┘
                                     │
              ┌──────────────────────┼──────────────────────┐
              ▼                      ▼                      ▼
           CICS                 IBM MQ                Batch
              │                      │                      │
              └──────────────┬───────┴──────────────────────┘
                             ▼
                     Aplicações COBOL
                             │
        ┌────────────────────┼────────────────────┐
        ▼                    ▼                    ▼
      Db2                  VSAM                 IMS
                             │
                             ▼
                    Fonte Oficial da Verdade

Considerações Finais

Durante décadas, ouvimos previsões sobre o fim do Mainframe. Entretanto, a realidade mostrou algo diferente: os sistemas que sustentam bancos, seguradoras, governos e grandes empresas continuam evoluindo porque concentram o ativo mais valioso de qualquer organização — seus dados e suas regras de negócio.

A Inteligência Artificial Generativa amplia esse cenário ao adicionar novas capacidades de interpretação, automação e interação. Tecnologias como RAG, MCP, watsonx, APIs, z/OS Connect e modelos privados permitem que aplicações modernas dialoguem com décadas de conhecimento implementado em COBOL, CICS e Db2, sem abrir mão de segurança, governança ou desempenho.

Não estamos testemunhando a substituição do Mainframe, mas o surgimento de uma nova geração de arquiteturas corporativas em que IA e IBM Z trabalham lado a lado. Para os profissionais da área, isso representa uma oportunidade única: dominar tanto os fundamentos dos sistemas críticos quanto as novas ferramentas de Inteligência Artificial.

O futuro pertence aos profissionais capazes de conectar esses dois mundos. Afinal, a inovação mais duradoura não nasce da ruptura, mas da integração inteligente entre o legado que funciona e as tecnologias que apontam para o amanhã.


☕ Continua a conversa no Bellacosa Mainframe

https://eljefemidnightlunch.blogspot.com/2026/07/ia-generativa-muito-alem-do-chatgpt.html




domingo, 5 de julho de 2026

Kubernetes Autoscaling Muito Além do HPA

 

Bellacosa Mainframe e o kubernetes autoscaling

☕ Um Café no Bellacosa Mainframe

Kubernetes Autoscaling Muito Além do HPA

O Que Todo Programador COBOL Padawan Precisa Saber Sobre HPA, VPA, Cluster Autoscaler e Como os Grandes Bancos Escalam Milhões de Transações Sem Desperdiçar Recursos

"No Mainframe aprendemos que desempenho nunca foi apenas velocidade. Sempre foi equilíbrio entre capacidade, disponibilidade, custo e confiabilidade. Kubernetes apenas reinventou esse conceito para a era da nuvem."


Introdução

Existe uma pergunta que praticamente todo desenvolvedor faz quando começa a estudar Kubernetes:

"Se meu sistema receber mais acessos, o Kubernetes cria novos Pods automaticamente?"

A resposta é:

Depende.

E é justamente esse "depende" que confunde milhares de profissionais todos os anos.

Quando um Programador COBOL começa a estudar Kubernetes, normalmente imagina que existe apenas um mecanismo responsável por aumentar a capacidade da aplicação.

Na prática, isso está longe da realidade.

Na verdade, Kubernetes possui diversos mecanismos diferentes de escalabilidade, cada um resolvendo um problema específico.

Alguns aumentam a quantidade de Pods.

Outros aumentam CPU e memória.

Outros adicionam novos servidores inteiros ao cluster.

Cada um trabalha em uma camada diferente da infraestrutura.

É exatamente como acontece em um grande banco.

Quando o Internet Banking começa a ficar lento, ninguém simplesmente compra um novo servidor.

Antes disso existem diversas decisões:

  • aumentar regiões CICS?

  • criar novos servidores WebSphere?

  • ajustar WLM?

  • aumentar memória?

  • ativar Capacity on Demand?

  • adicionar uma nova LPAR?

No Kubernetes acontece exatamente a mesma filosofia.

Neste artigo vamos entender profundamente como funcionam:

  • Horizontal Pod Autoscaler (HPA)

  • Vertical Pod Autoscaler (VPA)

  • Cluster Autoscaler (CA)

Sempre fazendo paralelos com IBM Z, COBOL, CICS, Batch, WLM e arquitetura corporativa.


Antes de falar sobre Autoscaling...

Precisamos entender um conceito fundamental.

O verdadeiro objetivo não é aumentar recursos.

É utilizar exatamente os recursos necessários.

Essa diferença parece pequena.

Mas muda completamente a forma de projetar sistemas.

Imagine um supermercado.

Às 3 horas da manhã existem apenas cinco clientes.

Às 18 horas existem dois mil clientes.

Você contrataria:

  • 200 caixas funcionando o dia inteiro?

Claro que não.

Também não deixaria apenas dois caixas funcionando às 18 horas.

A solução inteligente é adaptar a quantidade de caixas conforme o movimento.

É exatamente isso que Kubernetes faz.


O grande problema dos sistemas tradicionais

Durante décadas o modelo foi simples.

Comprar servidores suficientes para suportar o pior cenário.

Imagine uma aplicação bancária.

Segunda-feira:

CPU: 12%

Terça-feira:

CPU: 18%

Quarta-feira:

CPU: 22%

Na Black Friday:

CPU: 98%

O servidor foi comprado pensando apenas nesse último dia.

Resultado:

Durante praticamente todo o ano:

  • CPU parada

  • memória parada

  • discos subutilizados

  • energia desperdiçada

  • dinheiro desperdiçado

Cloud Computing mudou completamente essa lógica.

Agora infraestrutura pode crescer e diminuir automaticamente.


Elasticidade x Escalabilidade

Esses conceitos costumam ser confundidos.

Escalabilidade

É a capacidade do sistema suportar mais carga.

Exemplo:

Um servidor suporta:

500 usuários

Depois de melhorias:

5.000 usuários

Ele ficou mais escalável.


Elasticidade

É a capacidade de crescer e diminuir automaticamente.

Hoje:

2 Pods

Daqui cinco minutos:

20 Pods

Mais tarde:

4 Pods

Tudo sem intervenção humana.

Isso é elasticidade.

É justamente o coração do Kubernetes.


Os três tipos de escalabilidade

A maioria das pessoas acredita que existe apenas um tipo.

Na realidade existem três.

Escalabilidade Horizontal

Adicionar mais instâncias.

Exemplo:

Antes

2 Pods

Depois

8 Pods

Cada Pod continua igual.

Apenas existem mais deles.


Escalabilidade Vertical

Não aumenta quantidade.

Aumenta potência.

Antes

CPU 500m

Memória 512Mi

Depois

CPU 2

Memória 4Gi

Mesmo Pod.

Mais poderoso.


Escalabilidade da Infraestrutura

Agora nem estamos falando da aplicação.

Estamos falando do próprio cluster.

Antes

3 Workers

Depois

10 Workers

Agora existe espaço para muito mais Pods.


HPA — Horizontal Pod Autoscaler

Este é o autoscaler mais famoso.

Seu trabalho é extremamente simples.

Responder uma única pergunta.

Existem Pods suficientes?

Observe o que ele NÃO pergunta.

  • Existe CPU suficiente?

  • Existe memória suficiente?

  • Existem servidores suficientes?

Nada disso.

Ele pensa apenas em quantidade de Pods.


Como o HPA funciona?

Imagine uma API.

Ela começou o dia assim.

2 Pods

CPU média:

20%

Tudo funcionando.

Então começa uma campanha de marketing.

A CPU sobe para:

92%

O HPA verifica que sua meta era:

70%

Então ele faz um cálculo.

Simplificando:

Novos Pods =
Pods atuais ×
(CPU Atual / CPU Desejada)

Se havia:

4 Pods

CPU:

84%

Meta:

70%

Resultado:

4 × 84 ÷ 70

≈ 4,8

O Kubernetes arredonda.

Agora teremos:

5 Pods

Se a carga continuar aumentando:

6

8

12

20 Pods

Tudo automático.


Mas o HPA não olha apenas CPU

Esse é um erro muito comum.

Na realidade ele pode observar praticamente qualquer métrica.

Exemplos.

CPU

Memória

Requests por segundo

Tempo médio de resposta

Fila Kafka

RabbitMQ

Prometheus

Número de usuários

Sessões abertas

Mensagens pendentes

Quantidade de pedidos

Pix aguardando processamento

Fila de cartões

Custom Metrics

Isso significa que o HPA pode crescer baseado na necessidade real do negócio.

Imagine um banco.

Talvez CPU nem seja importante.

O importante pode ser:

Fila PIX > 2000

Nesse momento:

Criar novos Pods.

Muito mais inteligente.


Como o HPA conversa com Kubernetes?

O fluxo é relativamente simples.

Usuário

Ingress

Service

Pods

Kubelet mede CPU

Metrics Server coleta

API Server publica

HPA consulta

ReplicaSet aumenta Pods

Deployment cria novas réplicas

Tudo acontece continuamente.

Sem intervenção humana.


HPA não fica escalando o tempo todo

Imagine esta situação.

CPU:

69%

71%

69%

70%

71%

69%

Sem mecanismos de estabilização.

Teríamos:

8 Pods

9 Pods

8 Pods

9 Pods

8 Pods

Isso seria um desastre.

Por isso existem diversos mecanismos internos.

Cooldown.

Stabilization Window.

Tolerance.

Scale Policies.

Esses mecanismos evitam oscilações desnecessárias.


HPA possui limitações

Ele não faz milagres.

Imagine.

Seu cluster possui apenas:

2 Workers

Cada Worker possui:

8 CPUs

Todos estão completamente ocupados.

O HPA decide criar:

30 Pods

Mas onde eles serão executados?

Resposta.

Em lugar nenhum.

Eles ficam:

Pending

É aqui que entra outro personagem.


VPA — Vertical Pod Autoscaler

Agora o problema mudou completamente.

Não queremos mais criar novos Pods.

Queremos melhorar os Pods existentes.

Imagine.

Seu Deployment foi criado assim.

requests:
 cpu: 100m
 memory: 128Mi

Na prática ele utiliza:

CPU

850m

Memória

950Mi

Resultado.

CPU Throttling.

OOMKilled.

Baixo desempenho.

O VPA observa isso.


Como o VPA aprende?

Ao contrário do HPA.

Ele analisa histórico.

Dias.

Semanas.

Meses.

Depois calcula recomendações.

Exemplo.

Atual.

CPU

100m

Recomendado.

900m

Atual.

256Mi

Recomendado.

1Gi

Isso reduz desperdício.

E melhora desempenho.


Os modos do VPA

Off

Apenas recomenda.

Muito usado em produção.

Você recebe um relatório.

Mas nenhuma alteração acontece.


Auto

Atualiza automaticamente.

Se necessário reinicia Pods.

É extremamente poderoso.


Initial

Aplica apenas durante a criação.

Excelente para aplicações críticas.


Por que o VPA reinicia Pods?

Muitos iniciantes estranham isso.

O motivo é simples.

CPU e memória fazem parte da especificação do Pod.

Depois que o container está em execução.

Esses parâmetros normalmente não podem ser alterados.

Então o Kubernetes cria um novo Pod.

Com os novos valores.


O que o VPA não faz?

Não cria novos Pods.

Não cria servidores.

Não aumenta Workers.

Não substitui HPA.

São ferramentas complementares.


Cluster Autoscaler

Agora chegamos à infraestrutura.

Imagine.

Seu HPA criou:

50 Pods

Mas existem apenas:

3 Workers

Todos lotados.

Resultado.

Pods Pending

O Scheduler tenta.

Não consegue.

Agora entra o Cluster Autoscaler.


O trabalho do Cluster Autoscaler

Ele pergunta.

Existe algum Pod que não consegue ser agendado?

Se existir.

Ele conversa com o provedor de nuvem.

AWS.

Azure.

Google.

OpenShift.

VMware.

E solicita novos Workers.

Depois que os novos servidores entram no cluster.

O Scheduler distribui os Pods.


Fluxo completo

Usuários aumentam.

CPU aumenta.

HPA cria Pods.

Pods ficam Pending.

Cluster Autoscaler detecta.

Cloud cria Workers.

Workers entram.

Scheduler agenda Pods.

Aplicação volta ao normal.

Tudo automático.


Como o Cluster Autoscaler decide remover servidores?

Ele também reduz custos.

Imagine.

Domingo.

Pouquíssimos acessos.

Existem:

15 Workers

Mas apenas:

3

são necessários.

O Cluster Autoscaler verifica.

Os Pods podem ser movidos?

Se sim.

Executa.

Drain.

Eviction.

Delete Node.

Resultado.

Economia de infraestrutura.


Comparando HPA, VPA e Cluster Autoscaler

Imagine um supermercado.

HPA

Contrata mais caixas.

Mais pessoas atendendo clientes.


VPA

Entrega computadores mais rápidos para cada caixa.

Cada funcionário trabalha melhor.


Cluster Autoscaler

Constrói uma nova loja.

Agora existe espaço para muito mais caixas.

São três problemas diferentes.


Um exemplo real de um grande banco

Imagine um aplicativo bancário.

Às 8h da manhã.

Começam os acessos.

Primeiro.

O HPA aumenta.

6 Pods

↓

20 Pods

Depois percebe-se que cada Pod está consumindo muito mais memória.

O VPA recomenda.

512Mi

↓

2Gi

Agora não existe mais capacidade física.

O Cluster Autoscaler adiciona.

8 Workers

↓

16 Workers

O usuário final nem percebe.

Essa é a magia da elasticidade.


Analogia com IBM Mainframe

Quem trabalha com IBM Z perceberá rapidamente várias semelhanças.

HPA

Lembra aumentar regiões CICS.

Ou criar mais servidores Liberty.

Mais instâncias.

Mesmo programa COBOL.


VPA

Lembra ajustar REGION.

Heap Java.

Parâmetros WLM.

Mais recursos para uma região existente.


Cluster Autoscaler

Lembra.

Adicionar novas LPARs.

Capacity on Demand.

Expandir Parallel Sysplex.

Mais infraestrutura.

A filosofia é praticamente idêntica.


Quando utilizar cada um?

Use HPA.

Quando existem picos de acesso.

APIs REST.

Microsserviços.

Front-end.

Aplicações stateless.


Use VPA.

Quando deseja otimizar CPU e memória.

Eliminar desperdício.

Evitar OOMKilled.

Melhorar desempenho.


Use Cluster Autoscaler.

Quando a infraestrutura precisa crescer automaticamente.

Principalmente em Cloud.

AWS.

Azure.

Google Cloud.

OpenShift.


O futuro: KEDA e Event-Driven Autoscaling

Os mecanismos que estudamos são apenas a base. Em arquiteturas modernas, surge um quarto componente importante: o KEDA (Kubernetes Event-Driven Autoscaling).

Enquanto o HPA reage principalmente a métricas como CPU e memória, o KEDA reage a eventos.

Imagine um sistema de processamento de boletos. Não importa a CPU; o importante é saber quantos boletos aguardam processamento em uma fila do IBM MQ ou do Kafka.

Se houver 10 mensagens, um Pod é suficiente.

Se houver 10.000 mensagens, o KEDA pode solicitar ao HPA dezenas de Pods para processar a fila rapidamente.

Esse modelo aproxima o Kubernetes dos conceitos de processamento orientado a filas, muito conhecidos por profissionais de Mainframe que trabalham com IBM MQ, CICS Trigger Transactions e Batch.


Conclusão

Quando começamos a estudar Kubernetes, é comum acreditar que autoscaling significa apenas "criar mais Pods". Porém, vimos que a realidade é muito mais rica. O ecossistema foi projetado para atacar diferentes gargalos de forma especializada:

  • HPA responde ao aumento da carga criando ou removendo Pods.

  • VPA ajusta CPU e memória para que cada Pod tenha os recursos ideais.

  • Cluster Autoscaler adiciona ou remove nós do cluster conforme a capacidade física necessária.

  • KEDA amplia essa inteligência ao escalar aplicações com base em eventos e filas.

Para um Programador COBOL Padawan, essa arquitetura não deve ser vista como algo completamente novo. Ela representa a evolução de princípios que sempre existiram no mundo corporativo: distribuir carga, otimizar recursos, garantir disponibilidade e controlar custos.

No IBM Z, esses objetivos eram alcançados com WLM, Parallel Sysplex, Capacity on Demand, regiões CICS, tuning de DB2 e planejamento de capacidade. No Kubernetes, os mesmos princípios são implementados de forma declarativa, automática e integrada à nuvem.

A tecnologia mudou. As ferramentas evoluíram. Mas a missão continua exatamente a mesma: entregar sistemas resilientes, escaláveis e eficientes, capazes de atender milhões de usuários sem desperdiçar recursos. É essa mentalidade de engenharia que transforma um desenvolvedor em um verdadeiro arquiteto de soluções modernas.