Translate

Mostrar mensagens com a etiqueta Engenharia de Software. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta Engenharia de Software. Mostrar todas as mensagens

domingo, 2 de agosto de 2026

IBM Bob : O Holocron do Padawan — Da Primeira Pergunta até os Agentes Inteligentes

 

Bellacosa Mainframe e o holocron do conhecimento do ibm bob

☕ Um Café no Bellacosa Mainframe

IBM Bob para Programadores COBOL

O Holocron do Padawan — Da Primeira Pergunta até os Agentes Inteligentes

"Quando um programador COBOL encontra uma IA pela primeira vez, a tendência é pensar que ela escreve código. Depois de alguns dias percebe que ela faz muito mais. Depois de alguns meses percebe que quem realmente mudou foi a forma de pensar sobre desenvolvimento."


Durante décadas nós aprendemos uma sequência relativamente estável.

Requisito
↓
Análise
↓
Codificação
↓
Compilação
↓
Teste
↓
Produção

O IBM Bob não muda esse fluxo.

Ele muda quem participa dele.

O desenvolvedor deixa de trabalhar sozinho e passa a trabalhar acompanhado por uma IA especializada.

Essa é exatamente a ideia por trás de praticamente todas as fases do treinamento.



Capítulo 1 — O que é o IBM Bob?

O erro mais comum é pensar:

"Bob é um ChatGPT."

Não.

Bob é um AI Software Engineer.

Ele foi construído para acompanhar todo o ciclo de vida do software (SDLC).

Ele entende:

  • código

  • arquitetura

  • documentação

  • Git

  • Pull Request

  • testes

  • APIs

  • banco de dados

  • DevOps

  • Cloud

  • Mainframe

Ele não responde apenas perguntas.

Ele participa do desenvolvimento.



Capítulo 2 — O verdadeiro SDLC

Praticamente em vários momentos do curso falam do SDLC.

A ordem correta é:

Planejamento

↓

Levantamento de requisitos

↓

Análise

↓

Design

↓

Implementação

↓

Testes

↓

Deploy

↓

Manutenção

Nunca confunda.

Os testes nunca vêm antes dos requisitos.


Planejamento

Aqui respondemos:

O que será construído?

Quem vai usar?

Qual problema resolve?


Requisitos

Aqui descobrimos:

  • regras de negócio

  • usuários

  • limitações

  • integrações

É exatamente como conversar com o cliente antes de escrever um COBOL.


Design

Aqui definimos

Arquitetura.

Tecnologias.

Banco.

API.

Cloud.

Infraestrutura.

É a planta da casa.


Implementação

Aqui escrevemos código.

COBOL.

Java.

Python.

TypeScript.

Não importa.

O design vira código.


Testes

Somente agora validamos.

Não antes.


Capítulo 3 — Contexto é Rei

Uma das maiores mensagens do curso.

IA sem contexto é praticamente inútil.

Imagine perguntar:

Melhore esse programa.

Qual programa?

Qual arquivo?

Qual função?

Qual objetivo?

Agora compare com:

Arquivo:

CLIENTE.CBL

Objetivo:

Melhorar performance da leitura VSAM.

Não alterar layout.

Não modificar regras fiscais.

Não instalar bibliotecas.

Agora Bob entende.

Toda IA funciona melhor quando recebe contexto.



Capítulo 4 — Janela de Contexto

Outro assunto recorrente.

A Janela de Contexto é simplesmente tudo aquilo que Bob conhece naquele momento.

Ela contém:

  • conversa

  • arquivos

  • regras

  • prompts

  • histórico

  • documentos

Quanto maior o contexto útil,

melhor a resposta.

Quanto maior o contexto inútil,

pior a resposta.


Context Poisoning

Uma expressão importante.

Imagine manter aberto:

Projeto Banco A.

Depois mudar para

Projeto Banco B.

Mas esquecer documentos antigos.

Bob pode misturar regras.

Isso chama-se

Context Poisoning.

A IA passa a raciocinar baseada em informações erradas.



Capítulo 5 — Human in the Loop

Talvez seja o conceito mais importante do treinamento.

Bob nunca substitui o desenvolvedor.

Ele trabalha junto.

Você continua responsável por:

✔ validar

✔ revisar

✔ aprovar

✔ decidir

A IA sugere.

Você decide.


Capítulo 6 — Auto Approve

Bob pode executar ações automaticamente.

Mas existem níveis.

Exemplo:

Leitura

Pode abrir arquivos.

Pode listar diretórios.

Sem perguntar.

Já comandos perigosos

como

git reset

rm

git push

normalmente pedem confirmação.

Por quê?

Porque alterar um repositório é diferente de apenas ler um arquivo.


Capítulo 7 — Checkpoints

O que faz um checkpoint? Muitas vezes usamos o conceito mas não paramos para analisar e fazer um mapa mental.

Checkpoint significa:

Criar um ponto seguro.

Igual snapshot.

Antes de uma grande mudança:

✔ cria checkpoint

✔ modifica

✔ testa

✔ aprova

É exatamente igual ao conceito de backup antes de um grande IPL.



Capítulo 8 — Bob Rules

Aqui está um conceito excelente.

Imagine um programador COBOL.

Toda vez você escreve:

Sempre documente.

Nunca use GO TO.

Explique em português.

Isso é repetitivo.

As Bob Rules resolvem isso.

São regras permanentes.

Exemplo:

Sempre gerar comentários.

Nunca instalar dependências.

Usar Clean Code.

Elas ficam válidas para o projeto inteiro.



Capítulo 9 — Slash Commands

Enquanto Rules são permanentes,

Slash Commands são ações.

Exemplo:

/review

Revisar código.

/document

Gerar documentação.

/performance

Analisar desempenho.

São pequenas automações.


Capítulo 10 — agent.md

Uma excelente ideia.

O arquivo

agent.md

é um manual para Bob.

Ele registra:

  • arquitetura

  • convenções

  • decisões

  • padrões

  • organização

É muito parecido com um grande README técnico.


Capítulo 11 — Git

O curso insiste bastante nisso.

Fluxo correto.

git checkout -b

↓

editar

↓

commit

↓

push

↓

Pull Request

↓

Review

↓

Merge

Jamais:

Editar diretamente a Main.


Pull Request

Não é apenas enviar código.

É pedir revisão.


Code Review

Serve para verificar

✔ qualidade

✔ documentação

✔ arquitetura

✔ padrões

✔ clareza

✔ links

✔ consistência

Não apenas bugs.



Capítulo 12 — MCP

Aqui começa o futuro.

Model Context Protocol.

Imagine um cabo USB.

Você conecta:

Bob

Git

SQLite

Appwrite

GitHub

Filesystem

Terminal

APIs

Tudo usando um padrão.

Esse padrão chama-se MCP.


MCP Local

Vale apenas para um projeto.


MCP Global

Vale para todos.


MCP Remoto

Permite conversar com serviços externos.

Exemplo:

Appwrite.


API Keys

Sem credenciais

Bob não entra.

Assim como RACF protege um dataset,

API Keys protegem serviços Cloud.



Capítulo 13 — LLM

Outra sequência cobrada.

LLM

↓

Chatbot

↓

Copilot

↓

Agente

LLM

Motor.


Chatbot

Conversa.


Copilot

Ajuda.


Agente

Executa.

Planeja.

Decide.

Corrige.



Capítulo 14 — Sistemas Agentic

Agente faz muito mais.

Ele consegue:

Planejar.

Executar.

Reavaliar.

Corrigir.

Continuar.

Esse conceito aparece sempre que usamos um chat bot, seria o nosso passo a passo na execução da tarefa.


Multistep

Executa várias etapas.

Não apenas uma.


Self Correction

Errou?

Corrige sozinho.


Human in the Loop

Mesmo assim,

o desenvolvedor continua aprovando.



Capítulo 15 — Analytics

Outro bloco do curso.

Bob Analytics mostra:

Consumo.

Bob Coins.

Plano.

Uso.

Métricas.


Bob Coins

Padronizam consumo.

Não importa qual modelo está por trás.


Trial

Temporário.


PRO

Renova Bob Coins mensalmente.


Overage

Uma pegadinha da prova.

No treinamento foi enfatizado que:

o overage precisa ser reativado manualmente a cada mês para continuar em uso.

Mesmo que essa característica possa variar entre serviços, essa é a resposta esperada no contexto da aula.



Capítulo 16 — O Grande Mapa Mental

Cliente

↓

Requisitos

↓

Design

↓

Bob entende contexto

↓

Rules

↓

Slash Commands

↓

agent.md

↓

Checkpoint

↓

Implementação

↓

Git

↓

Commit

↓

Push

↓

Pull Request

↓

Review

↓

Merge

↓

Deploy

↓

Analytics

↓

Melhoria Contínua


O Pensamento Bellacosa Mainframe

Quando comecei no mainframe, lá no final dos anos 1980, a inteligência estava concentrada em dois lugares: na cabeça do analista experiente e nos milhares de programas COBOL que sustentavam o negócio. Hoje, continuamos precisando dessa experiência, mas ganhamos um novo parceiro.

O IBM Bob não substitui o programador COBOL. Ele não conhece melhor o negócio do que quem mantém aquele sistema há anos. O que ele faz é acelerar tarefas repetitivas, organizar informações, sugerir melhorias e reduzir o tempo gasto com atividades mecânicas.

Pense nele como um novo integrante da equipe. Ele trabalha rápido, lê milhares de arquivos em segundos e nunca se cansa de revisar código. Porém, ainda depende do arquiteto, do analista e do desenvolvedor para definir o rumo correto.

No fim das contas, a principal lição de todo esse treinamento não é aprender comandos, MCPs ou Bob Rules. É compreender uma nova forma de desenvolver software:

A IA executa. O desenvolvedor direciona. A experiência humana continua sendo o verdadeiro sistema operacional por trás de qualquer projeto.

Esse é o verdadeiro espírito do Bellacosa Mainframe: combinar décadas de conhecimento em engenharia de software com as novas capacidades da Inteligência Artificial, formando um desenvolvedor que entende tanto o legado quanto o futuro.

sábado, 25 de julho de 2026

O Código Nunca Foi o Mistério : Quando um Programador COBOL Descobre que Alterar Dez Linhas é Fácil... Difícil é Sobreviver ao Templo Esquecido do Sistema

 

Bellacosa Mainframe na aventura onde o codigo nunca foi o misterio

☕ Um Café no Bellacosa Mainframe

O Código Nunca Foi o Mistério

Quando um Programador COBOL Descobre que Alterar Dez Linhas é Fácil... Difícil é Sobreviver ao Templo Esquecido do Sistema

"Arqueologia não é procurar coisas velhas. É descobrir a história escondida por trás delas."

Se Indiana Jones tivesse escolhido Ciência da Computação em vez de Arqueologia, provavelmente terminaria trabalhando em um grande banco desenvolvendo COBOL.

Pode parecer exagero.

Mas pense comigo.

Indiana nunca encontrava o artefato logo na primeira sala.

Primeiro havia um mapa incompleto.

Depois uma caverna.

Uma armadilha.

Um diário escrito há cinquenta anos.

Um símbolo perdido.

Um templo subterrâneo.

Uma pedra falsa.

Uma ponte quebrada.

E somente depois de horas de investigação ele finalmente colocava as mãos no objeto que havia saído para procurar.

No Mainframe acontece exatamente a mesma coisa.

O gerente chega à sua mesa.

— "É só alterar umas dez linhas."

Você sorri.

Respira.

Abre o ISPF.

E cinco minutos depois percebe que acaba de entrar no equivalente computacional do Templo da Perdição.

Bem-vindo ao verdadeiro trabalho de um desenvolvedor COBOL.


Capítulo 1 — O Mapa Perdido

Todo aventureiro começa com um mapa.

O problema é que, no mundo corporativo, esse mapa quase nunca existe.

Ou pior.

Existe.

Mas foi escrito em 1994.

Em WordPerfect.

Impresso.

Escaneado.

Convertido para PDF.

E armazenado numa pasta chamada:

Documentacao_Final_Versao_Final_2_AgoraVai.pdf

Que obviamente está desatualizada desde 1998.

É nesse momento que o jovem programador descobre uma das maiores verdades da profissão.

O COBOL não é o sistema.

O programa é apenas uma pequena pedra dentro de uma pirâmide construída durante décadas.


Capítulo 2 — O Chicote Não é o COBOL

Muita gente acredita que dominar COBOL significa dominar Mainframe.

É o mesmo que dizer:

"Indiana Jones venceu porque sabia usar um chicote."

Não.

O chicote era apenas uma ferramenta.

O verdadeiro diferencial era compreender:

  • história

  • culturas

  • idiomas

  • símbolos

  • armadilhas

  • comportamento humano

Com COBOL acontece exatamente igual.

Conhecer:

MOVE
ADD
PERFORM
IF
READ
WRITE

é apenas aprender a usar o chicote.

O arqueólogo ainda nem entrou no templo.


Capítulo 3 — A Primeira Porta

Chega o chamado.

Modificar o programa FAT001.

Perfeito.

Onde ele está?

Ninguém sabe.

Começa então a expedição.

Primeira parada:

PDS COBOL

Nada.

Segunda parada.

LIBLOAD

Nada.

Terceira.

JCLLIB

Quarta.

PROCLIB

Quinta.

Scheduler

Somente depois de muito procurar você descobre:

JOBFIN01

↓

PROCFAT

↓

STEP040

↓

PGM=FAT001

Parabéns.

Você encontrou a porta do templo.

Agora começa a aventura.


Capítulo 4 — O Diário do Professor Ravenwood

Indiana Jones sempre encontrava um velho diário.

No Mainframe ele possui outro nome.

JCL.

O JCL é praticamente um diário de viagem.

Ele conta:

  • quem chamou o programa;

  • quais arquivos entram;

  • quais arquivos saem;

  • qual biblioteca foi usada;

  • quais parâmetros chegaram;

  • qual região executa;

  • qual ambiente está sendo utilizado.

Um simples trecho como:

//EXEC PGM=FAT001

parece insignificante.

Mas atrás dele existem dezenas de decisões arquitetônicas tomadas durante décadas.

O JCL responde perguntas que o próprio programa COBOL jamais responderá.


Capítulo 5 — As Pegadas na Poeira

Indiana observava pegadas.

Você observa datasets.

Imagine encontrar:

CLIENTE.GDG(+1)

Quem criou?

Quando?

Qual layout?

Possui compressão?

É VB?

FB?

RECFM?

LRECL?

Existe SORT anterior?

Existe IDCAMS?

Existe IEBGENER?

Cada dataset é uma pegada deixada por alguém que passou antes.

E cada pegada pode revelar uma história completamente diferente.


Capítulo 6 — O Labirinto dos Processamentos

Na imagem analisada, uma das partes mais brilhantes é justamente a existência de dois mundos:

Traitements Amont

e

Traitements Aval.

Pouca gente percebe a importância disso.

Imagine uma corrente.

Sistema A

↓

Sistema B

↓

Sistema C

↓

Sistema D

↓

Seu programa

O problema talvez tenha começado cinco programas antes.

Agora imagine o contrário.

Seu programa

↓

Financeiro

↓

PIX

↓

SPED

↓

Data Warehouse

↓

BI

↓

IA

Alterar um campo pode quebrar seis departamentos.

É como retirar uma pedra da parede de um templo maia.

Talvez nada aconteça.

Ou talvez toda a construção desabe.


Capítulo 7 — A Câmara das Armadilhas

Nos filmes existe sempre uma sala cheia de mecanismos mortais.

No Mainframe essa sala chama-se:

Regras de Negócio

Elas raramente aparecem documentadas.

Você encontra coisas como:

IF UF = "AM"

Por quê?

Silêncio.

Outro exemplo.

IF CODIGO = 37

Por quê?

Ninguém sabe.

Até que um veterano lembra.

— Em 1996 surgiu uma legislação especial.

Pronto.

Você acaba de resolver um mistério de trinta anos.


Curiosidade Bellacosa nº 1

Existe uma frase muito conhecida entre desenvolvedores experientes:

"Todo IF estranho possui uma história triste."

E normalmente ela envolve:

  • imposto;

  • banco central;

  • auditoria;

  • legislação;

  • cliente VIP;

  • bug ocorrido numa madrugada de domingo.


Capítulo 8 — O Cálice Sagrado Chama-se DB2

Muitos iniciantes acreditam que alterar uma tabela significa apenas executar:

ALTER TABLE

Longe disso.

Uma coluna nova pode afetar:

  • índices;

  • packages;

  • plans;

  • RUNSTATS;

  • REORG;

  • BIND;

  • stored procedures;

  • triggers;

  • views;

  • aplicações Java;

  • aplicações .NET;

  • relatórios;

  • APIs REST.

No filme, Indiana precisava escolher o cálice correto.

No Mainframe você precisa alterar a coluna correta.

Escolher errado custa muito mais caro que um filme de Hollywood.


Capítulo 9 — O Reino Invisível do CICS

Durante o dia:

Cliente consulta saldo.

À noite:

Batch recalcula saldo.

São dois mundos completamente diferentes.

Mas compartilham os mesmos dados.

É como duas expedições arqueológicas explorando entradas diferentes do mesmo templo.

Se um explorador mover uma pedra...

O teto pode cair sobre o outro.


Capítulo 10 — O Calendário Maia do Scheduler

Existe uma entidade misteriosa.

Poucos iniciantes lhe dão atenção.

Scheduler.

Ele sabe exatamente:

  • que horas tudo começa;

  • quanto cada JOB demora;

  • quem depende de quem;

  • qual janela operacional existe;

  • qual SLA precisa ser cumprido.

Imagine:

22:00 Recepção

22:30 Validação

23:10 DB2

00:20 COBOL

01:30 SPED

03:40 Banco Central

Você aumenta cinco minutos no processamento.

Agora tudo termina quinze minutos depois.

Às vezes isso significa apenas atraso.

Às vezes significa multa milionária.


Easter Egg nº 1 — A Pedra Rolante

Todo programador COBOL já viveu algo parecido.

Você altera uma linha.

Executa o teste.

Tudo funciona.

Vai para homologação.

Tudo funciona.

Vai para produção.

Então aparece uma "pedra rolante" gigantesca.

Não era seu programa.

Era um JOB executado apenas no último dia útil do mês, usando um parâmetro que ninguém lembrava existir.

A pedra não persegue Indiana Jones apenas no cinema.

Ela também aparece às 02h47 da manhã, durante o fechamento contábil.


Capítulo 11 — A Arqueologia Digital

Talvez a maior habilidade de um desenvolvedor Mainframe não seja programar.

Seja investigar.

Você vira uma mistura de:

  • arqueólogo;

  • historiador;

  • investigador;

  • detetive;

  • matemático;

  • contador;

  • psicólogo;

  • engenheiro.

Cada programa é uma civilização antiga.

Cada comentário:

* NÃO ALTERAR

é uma inscrição hieroglífica.

Cada COPYBOOK é um pergaminho.

Cada PDS é uma biblioteca de Alexandria.

Cada JOB é uma rota comercial entre impérios.


Passo a Passo — Como um Desenvolvedor Experiente Investiga uma Alteração

Antes de escrever qualquer linha de código, siga uma metodologia quase arqueológica:

Etapa 1 — Entenda o requisito

Não aceite frases como:

"É só mudar um IF."

Pergunte:

  • Qual problema de negócio será resolvido?

  • Existe documentação?

  • Quem é o usuário afetado?


Etapa 2 — Localize o programa

  • PDS fonte

  • Load Library

  • Histórico de versões

  • Chamadores

  • Programas chamados


Etapa 3 — Analise o JCL

Verifique:

  • EXEC PGM

  • DD Statements

  • GDGs

  • SYSIN

  • SYSOUT

  • PROCs

  • PARM


Etapa 4 — Descubra os arquivos

Para cada dataset pergunte:

  • Quem gera?

  • Quem consome?

  • Qual layout?

  • Existe versionamento?


Etapa 5 — Analise o banco

  • Tabelas

  • Índices

  • Views

  • Packages

  • Plans

  • Estatísticas

  • SQLs afetados


Etapa 6 — Verifique integrações

Existe:

  • CICS?

  • MQ?

  • Web Services?

  • z/OS Connect?

  • APIs?

  • Batch paralelo?


Etapa 7 — Procure regras escondidas

Nunca confie apenas na documentação.

Leia o código.

Leia comentários antigos.

Converse com analistas.

Converse com usuários.

Muitas regras vivem apenas na memória das pessoas.


Etapa 8 — Teste impacto

Pergunte sempre:

Quem depende disso?

Quem será afetado?

Quem vai perceber?


Curiosidade Bellacosa nº 2

Em muitos bancos existem programas COBOL executando diariamente há mais de quarenta anos.

Alguns foram escritos antes mesmo do nascimento dos desenvolvedores que hoje fazem sua manutenção.

É como entrar em uma tumba egípcia sabendo que o arquiteto original nunca imaginou que alguém, quatro décadas depois, ainda pisaria naquele corredor para instalar uma nova "porta secreta".


Easter Egg nº 2 — O "X" Nunca Marca o Lugar

Nos filmes, o mapa sempre mostra um enorme X indicando o tesouro.

No desenvolvimento corporativo acontece exatamente o contrário.

O chamado diz:

"Alterar o programa FAT001."

Você passa dois dias investigando e descobre que o problema verdadeiro está em:

  • um parâmetro no Scheduler;

  • um SORT que remove registros;

  • um COPYBOOK compartilhado;

  • uma VIEW DB2;

  • um arquivo recebido de outro sistema.

O X nunca marca o lugar certo. A jornada até ele é que revela onde o verdadeiro problema estava escondido.


Conclusão — O Tesouro Não é o Código

Quando iniciamos nossa jornada em COBOL, acreditamos que aprenderemos uma linguagem de programação.

Com o tempo percebemos que aprendemos algo muito maior.

Aprendemos engenharia de sistemas.

O programa COBOL é apenas a ponta visível de um enorme continente tecnológico formado por JCLs, PROCs, Scheduler, Db2, CICS, VSAM, arquivos, integrações, calendários operacionais e regras de negócio acumuladas ao longo de décadas.

É por isso que dois profissionais com o mesmo domínio da sintaxe podem ter desempenhos completamente diferentes. Um conhece os verbos da linguagem; o outro conhece a história do templo, onde estão as armadilhas, quais corredores desabam, onde ficam as passagens secretas e qual pedra jamais deve ser removida.

No universo Bellacosa Mainframe, o verdadeiro desenvolvedor COBOL não é apenas um programador. Ele é um explorador da computação corporativa, alguém que entra diariamente em ruínas digitais construídas por gerações de engenheiros e retorna trazendo o artefato mais valioso de todos: uma alteração segura, compreendida e confiável, capaz de preservar sistemas que movimentam bancos, governos, seguradoras e a economia mundial sem que milhões de usuários sequer percebam que uma aventura aconteceu durante a madrugada.

E, como diria um certo arqueólogo de chapéu e chicote, ao fechar mais um chamado aparentemente simples:

"O código pertence ao sistema... mas o conhecimento pertence a quem teve coragem de explorar o templo inteiro antes de alterar uma única linha."

sábado, 18 de julho de 2026

⚽A Copa do Mundo Explica Melhor a Engenharia de Software do que Muitos Livros

 

Bellacosa Mainframe e os ensinamentos da Copa para a gestão de projetos

☕ Um Café no Bellacosa Mainframe: 

⚽A Copa do Mundo Explica Melhor a Engenharia de Software do que Muitos Livros



O Mainframe e a Copa do Mundo

Imagine por um instante.

Uma empresa possui um ambiente IBM Z responsável por bilhões de reais em transações.

Durante quatro anos toda a equipe trabalha.

Desenvolvem sistemas.
Corrigem defeitos.
Treinam.
Criam processos.
Modernizam aplicações.

Então chega um único dia.

O Black Friday.
O fechamento anual.
A migração crítica.
O IPL planejado.
A auditoria internacional.

O dia de pagamento dos velhinhos aposentados.

É exatamente isso que a Copa representa.

Quatro anos de preparação para poucas partidas onde o mundo inteiro está assistindo.

No futebol existe a Copa.

No mainframe existem os grandes projetos.


1. A convocação

Nem todo jogador vai para a Copa.

Nem todo programador participa dos projetos estratégicos.

Ser escolhido significa que alguém acredita que você suporta pressão.

Isso muda completamente a carreira.

No futebol:

"Convocado para a Seleção Brasileira."

No mainframe:

"Ele vai liderar a migração para o COBOL 6.5."

Ou

"Ele ficará responsável pelo projeto PIX."

Ou

"Ele participará do Disaster Recovery."

Esses projetos ficam para sempre no currículo.


2. A camisa pesa

Existe uma frase famosa:

"A camisa pesa."

Vestir a camisa da Seleção Brasileira significa carregar décadas de história.

Vestir a camisa de um grande banco também.

Quando alguém trabalha em um grande banco, seguradora ou governo, ele representa muito mais do que seu próprio trabalho.

Ele representa:

  • confiança

  • estabilidade

  • disponibilidade

  • bilhões de transações

Existe responsabilidade.


3. A vitrine mundial

Na Copa todos estão olhando.

Na produção acontece exatamente igual.

Enquanto o sistema funciona...

ninguém percebe.

Quando ele para...

jornais noticiam.

Clientes reclamam.

Executivos aparecem.

Auditores chegam.

Assim como um atacante pode decidir uma Copa em um único chute, um desenvolvedor pode decidir um projeto inteiro com uma única alteração.


4. O desempenho muda uma carreira

Após uma boa Copa.

Um jogador pode:

  • triplicar salário

  • mudar para um grande clube

  • tornar-se ídolo

  • receber patrocínios

  • crianças sendo batizadas com o nome do craque

Depois de um grande projeto ocorre o mesmo.

Quem resolve incidentes críticos normalmente passa a ser lembrado.

Não apenas pelo gerente.

Mas por outras áreas.

Outras empresas.

Consultorias.

Clientes.

Grandes carreiras costumam nascer em grandes desafios.


5. O fracasso também fica registrado

Infelizmente também acontece o contrário.

Um erro em uma final permanece por décadas.

O mesmo acontece na TI.

Existe uma enorme diferença entre:

"Cometeu um erro."

e

"Escondeu o erro."

Profissionais maduros assumem responsabilidade.

Aprendem.

Melhoram.


6. O ego destrói equipes

Talvez seja uma das maiores lições.

Alguns atletas tornam-se milionários muito cedo.

Passam a acreditar que são maiores que:

  • treinador

  • comissão técnica

  • grupo

  • disciplina

Na tecnologia isso também existe.

O desenvolvedor que acredita saber tudo.

Que não aceita revisão.

Que ignora padrões.

Que despreza documentação.

Que não participa das cerimônias.

Que não ajuda iniciantes.

Esse profissional pode ser tecnicamente excelente.

Mas prejudica a equipe.


7. Talento não vence sozinho

A história da Copa mostra isso diversas vezes.

Times repletos de estrelas já foram eliminados cedo.

Enquanto equipes organizadas chegaram muito longe.

No desenvolvimento acontece igual.

Uma equipe composta por profissionais "nota 8" que colaboram normalmente supera uma equipe formada por "gênios" que trabalham isoladamente.


8. O técnico existe por um motivo

O treinador enxerga o campo inteiro.

O jogador vê apenas sua posição.

O arquiteto de software faz exatamente isso.

O gerente técnico também.

O Tech Lead também.

Às vezes uma decisão parece ruim para um desenvolvedor.

Mas excelente para o projeto inteiro.

Quem vê somente uma classe Java ou um programa COBOL não enxerga toda a arquitetura.


9. O empresário não deveria escalar o time

Você citou um ponto delicado.

Quando interesses externos influenciam decisões técnicas...

o projeto sofre.

No futebol:

patrocínio

marketing

pressão política

Na TI:

  • tecnologia da moda

  • fornecedor pressionando

  • gerente querendo atalhos

  • decisões baseadas em ego

Boas arquiteturas são escolhidas porque resolvem problemas.

Não porque estão na moda.


10. A estrela depende do time

Messi.

Maradona.

Pelé.

Zidane.

Nenhum ganhou sozinho.

Mesmo os maiores precisavam de:

  • goleiro

  • zagueiros

  • laterais

  • meio-campo

No mainframe:

o melhor programador depende de:

  • operadores

  • DBA

  • Sysprog

  • segurança

  • redes

  • storage

  • analistas

  • testes

  • negócio

Sem eles nada funciona.


11. O elo mais fraco determina a corrente

Talvez seja sua melhor analogia.

Em engenharia existe um conceito parecido.

A disponibilidade de um sistema costuma ser limitada pelo componente menos confiável.

Em equipes ocorre o mesmo.

Imagine cinco profissionais.

Um domina COBOL.

Outro Db2.

Outro CICS.

Outro MQ.

Outro começou há três meses.

O erro seria dizer:

"Ele que se vire."

O correto é:

"Vamos treiná-lo."

Porque no dia da implantação...

se ele falhar...

todos falham.


12. Mentoria é investimento

Grandes seleções possuem veteranos.

Eles ensinam.

Orientam.

Protegem os jovens.

No mainframe isso é ouro.

O profissional sênior não perde tempo ensinando.

Ele reduz futuros incidentes.

Cada hora investida em treinamento economiza dezenas de horas em produção.


13. O banco de reservas importa

Na Copa existem reservas.

No mainframe também deveria existir.

Se apenas uma pessoa conhece determinado sistema...

o risco é enorme.

Chamamos isso de fator ônibus (Bus Factor):

Quantas pessoas poderiam deixar a equipe antes que o projeto ficasse comprometido?

Quanto menor esse número, maior o risco operacional.


14. O treino invisível vence o jogo

O torcedor vê apenas noventa minutos.

Não vê:

  • preparação física

  • alimentação

  • fisioterapia

  • análise de vídeos

  • treinos táticos

No desenvolvimento acontece igual.

O cliente vê apenas:

"O sistema funcionou."

Mas por trás existiram:

  • testes

  • code review

  • documentação

  • planejamento

  • homologação

  • automação

  • monitoramento

  • rollback

  • backups

O sucesso quase sempre nasce do trabalho invisível.


15. O verdadeiro campeão faz o companheiro jogar melhor

Existe uma diferença enorme entre:

um craque

e

um líder.

O craque resolve jogadas.

O líder melhora o time inteiro.

No desenvolvimento isso é ainda mais importante.

O melhor profissional não é necessariamente aquele que escreve o código mais complexo.

É aquele que faz todos ao redor crescerem.

Que compartilha conhecimento.

Que revisa código com respeito.

Que documenta.

Que orienta.

Que inspira confiança.


A maior lição para um Programador COBOL Padawan

No universo do mainframe, não existem Copas do Mundo anuais. Existem projetos que, pela sua criticidade e visibilidade, equivalem a uma final diante de bilhões de "torcedores": uma migração de versão do COBOL, a implantação de um novo sistema de pagamentos, um Disaster Recovery ou a abertura de um grande banco em um dia de pico.

Quando esse momento chega, ninguém se lembra apenas de quem escreveu o algoritmo mais sofisticado. Lembram-se da equipe que entregou estabilidade, confiabilidade e colaboração.

Assim como no futebol, o talento individual chama atenção, mas são a disciplina, o treinamento constante, a humildade para aprender, o respeito às decisões coletivas e a disposição para fortalecer o colega com mais dificuldade que transformam um grupo de bons profissionais em um time campeão.

No fim das contas, um mainframe em produção e uma seleção em campo compartilham o mesmo princípio: o objetivo não é que um integrante brilhe sozinho, mas que o sistema inteiro — ou o time inteiro — funcione de forma harmoniosa até alcançar a vitória. É essa mentalidade que diferencia um bom programador de um verdadeiro profissional preparado para os maiores desafios da carreira.


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.


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.



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.


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