☕ Um Café no Bellacosa Mainframe
Gostou do conteúdo? Ajude a manter o café quente, o COBOL compilando e o mainframe acordado. 😄
☕ Pague um café ao Bellacosa

Translate

Mostrar mensagens com a etiqueta arquitetura. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta arquitetura. Mostrar todas as mensagens

quarta-feira, 23 de setembro de 2026

🐷 A FÁBULA DOS PORCOS ASSADOS NO MAINFRAME

 

Bellacosa Mainframe entre porcos e computadores visoes do sistema legado

☕ Um Café no Bellacosa Mainframe

🐷 A FÁBULA DOS PORCOS ASSADOS NO MAINFRAME

Ou: como uma empresa construiu 47 subsistemas, 312 jobs, 18 filas de MQ e uma War Room para continuar incendiando a floresta

Era uma vez uma enorme empresa que possuía um mainframe.

Ninguém sabia exatamente quando o primeiro programa havia entrado em produção.

Alguns diziam 1974.

Outros juravam ter encontrado um comentário COBOL contendo:

* ALTERADO EM 12/08/1969 - J.SILVA

Mas ninguém tinha coragem de investigar aquilo profundamente.

O importante era que o mainframe funcionava.

E dentro daquele mainframe existia o mais importante sistema corporativo da empresa:


🐷 O SISTEMA DE ASSAR PORCOS

A história começara décadas antes.

Certo dia, um incêndio acidental atingiu uma floresta próxima ao Data Center.

Havia porcos na floresta.

Quando o incêndio terminou, descobriram que os porcos haviam sido assados.

E estavam deliciosos.

Um programador teve então uma ideia:

— Quando precisarmos de porcos assados, podemos incendiar outra floresta.

Funcionou.

Foi criado o primeiro procedimento operacional:

PROC-PORCO-001 — Procedimento para Incêndio Controlado de Floresta para Produção de Porcos Assados.

Durante algum tempo, tudo correu maravilhosamente.

Quando alguém queria porco assado:

  1. colocavam os porcos na floresta;

  2. incendiavam a floresta;

  3. esperavam;

  4. recolhiam os porcos;

  5. serviam o jantar.

Era simples.

Até a empresa crescer.



🖥️ A INDUSTRIALIZAÇÃO DO PORCO

O número de clientes aumentou.

Agora não eram dez porcos.

Eram dez mil.

Foi necessário automatizar o processo.

Um programador COBOL escreveu:

PORC001

Outro criou:

PORC002

Depois vieram:

PORC003

PORC003A

PORC003B

PORC003B2

e finalmente:

PORC003B2N

Ninguém sabia onde estava PORC003B1.

Mas havia referências a ele em três copybooks.

Por segurança, ninguém mexia.

O processo passou a ser executado pelo JES2.

Às 22:00:

JOB PORCO01

selecionava os animais.

Às 22:30:

JOB FLOREST1

identificava uma floresta disponível.

Às 23:00:

JOB FIRE001

iniciava o incêndio.

À 01:00:

JOB ASSADO1

calculava o grau provável de cozimento.

Às 03:17, invariavelmente, alguma coisa dava errado.

Então começava a War Room.



🔥 O PRIMEIRO INCIDENTE

Certa madrugada, metade dos porcos saiu crua.

A outra metade virou carvão.

Foi declarado:

SEV1 — CRITICAL INCIDENT

Trinta e sete pessoas entraram na conferência.

— É COBOL?

— Não.

— É CICS?

— Não.

— Db2?

— Normal.

— MQ?

— Algumas filas estão crescendo.

— CPU?

— 43%.

— WLM?

— Dentro da política.

— Storage?

— Normal.

Finalmente alguém perguntou:

— E o fogo?

Silêncio.

Ninguém da reunião pertencia à equipe responsável pelo fogo.

Foi necessário abrir um chamado.

INC00473192

A equipe respondeu:

FIRE SYSTEM OPERATING AS DESIGNED.

O incidente foi encerrado como:

ROOT CAUSE UNKNOWN.



🐷 CRIA-SE A ENGENHARIA DE PORCOS

A direção decidiu que aquilo jamais poderia acontecer novamente.

Foi criado o departamento de:

Enterprise Pig Roasting Architecture — EPRA.

O departamento estabeleceu padrões.

Agora cada porco precisava possuir:

  • PIG-ID;

  • peso;

  • idade;

  • raça;

  • temperatura inicial;

  • floresta de destino;

  • horário de entrada;

  • previsão de cozimento;

  • classificação de criticidade.

Foi criado um banco Db2.

TB_PORCO
TB_FLORESTA
TB_INCENDIO
TB_ASSAMENTO
TB_TEMPERATURA
TB_PORCO_FLORESTA

Um arquiteto observou que TB_PORCO_FLORESTA possuía uma relação N:N problemática.

Foram necessárias seis reuniões.

Enquanto isso, os porcos continuavam queimando.


📊 OBSERVABILIDADE

Alguém afirmou:

— O problema é falta de observabilidade.

Todos concordaram.

Foram instalados sensores.

Dashboards.

Métricas.

Logs.

Tracing.

Alertas.

Agora era possível saber em tempo real:

PIGS_PER_SECOND

MEAN_TIME_TO_ROAST

FOREST_BURN_RATE

AVERAGE_PIG_TEMPERATURE

PIG_ERROR_RATE

CARBONIZED_PIG_PERCENTAGE

Um enorme monitor foi colocado no NOC.

Quando um porco queimava demais, uma linha ficava vermelha.

Os executivos ficaram impressionados.

— Agora temos visibilidade!

Os porcos continuavam queimando.

Mas agora isso podia ser acompanhado num dashboard.


☁️ A MODERNIZAÇÃO

Chegou então um consultor.

Depois de analisar a arquitetura durante três semanas, apresentou 186 slides.

O primeiro dizia:

DIGITAL PIG TRANSFORMATION

A conclusão era clara:

o problema estava no legado.

Era necessário modernizar.

O COBOL PORC001 foi encapsulado por uma API REST.

Agora era possível incendiar a floresta utilizando:

POST /api/v1/pigs/roast

Payload:

{
  "pigId": "0004711",
  "forest": "F023",
  "roastingLevel": "MEDIUM"
}

A API chamava z/OS Connect.

Que chamava CICS.

Que chamava COBOL.

Que gravava Db2.

Que publicava MQ.

Que finalmente executava:

INCENDIAR FLORESTA.

O CIO apresentou o projeto numa conferência:

“Transformamos nosso processo tradicional de produção de alimentos em uma plataforma API-first.”

Todos aplaudiram.

Os porcos continuavam sendo assados incendiando florestas.


☁️🐷 PORCOS NA CLOUD

Um novo estudo concluiu que o problema era outro.

A floresta estava on-premises.

Foi criado então:

Hybrid Cloud Pig Roasting Architecture.

O cadastro dos porcos foi para a cloud.

O sistema de incêndio permaneceu no mainframe.

Kafka transmitia eventos:

PIG_ENTERED_FOREST

FOREST_IGNITED

PIG_TEMPERATURE_CHANGED

PIG_ROASTED

PIG_OVERCOOKED

Um Data Lake armazenava vinte anos de telemetria de porcos queimados.

Machine Learning começou a prever quais porcos provavelmente seriam carbonizados.

A precisão chegou a 94%.

Um executivo perguntou:

— E conseguimos evitar que eles queimem?

O cientista de dados respondeu:

— Ainda não. Mas conseguimos prever com excelente precisão quais irão queimar.

O projeto recebeu um prêmio de inovação.


🤖 CHEGA A INTELIGÊNCIA ARTIFICIAL

Em 2026 surgiu a grande esperança.

IA Generativa.

Foi criado:

PigGPT Enterprise Edition.

A IA recebeu documentação, runbooks, logs, dumps, métricas SMF e quarenta anos de incidentes.

Perguntaram:

— Como melhorar o sistema de assar porcos?

A IA respondeu:

“Talvez seja possível assar os porcos diretamente utilizando uma fonte controlada de calor, sem incendiar uma floresta inteira.”

A resposta foi classificada como:

LOW CONFIDENCE / REQUIRES HUMAN VALIDATION

Um comitê de governança de IA foi convocado.

Após oito reuniões decidiu-se que a sugestão representava risco arquitetural porque não respeitava o processo corporativo estabelecido.


👨‍💻 JOÃO BOM-SENSO ENTRA NO CPD

Foi então que apareceu João.

João era programador COBOL.

Não era Distinguished Engineer.

Não era Enterprise Architect.

Não possuía certificação em transformação digital de porcos.

Ele estava apenas acompanhando um incidente.

Olhou os diagramas.

Olhou os jobs.

Olhou os dashboards.

Olhou os milhares de linhas COBOL.

Olhou Kafka.

Olhou MQ.

Olhou Kubernetes.

Olhou o Data Lake.

Depois perguntou:

— Por que vocês incendeiam uma floresta inteira?

A sala ficou silenciosa.

Um arquiteto respondeu:

— Para assar os porcos.

— Sim. Mas por que não fazemos uma pequena fogueira e colocamos o porco sobre ela?

Silêncio.

Alguém desligou o microfone.

Outro escreveu no chat privado:

“Quem convidou esse cara?”


🧪 A PROVA DE CONCEITO

João pegou um porco.

Algumas brasas.

Uma grelha.

Esperou.

O porco ficou perfeitamente assado.

Nenhuma floresta foi incendiada.

Nenhum batch foi executado.

Nenhuma mensagem MQ.

Nenhuma chamada REST.

Nenhum evento Kafka.

Nenhum Data Lake.

Nenhum SEV1.

Custo operacional:

quase zero.

O resultado foi apresentado à direção.

Por alguns segundos João acreditou que seria promovido.

Então começaram as perguntas.

— E o departamento de Engenharia de Incêndios?

— Não precisaria mais existir dessa forma.

— E nossos especialistas certificados em Propagação Florestal?

— Também não.

— E os 312 jobs?

— Poderíamos desativá-los.

— E nosso contrato de observabilidade?

— Grande parte deixaria de ser necessária.

— E o Data Lake?

— Continuaria existindo para outras coisas.

— E os vinte anos de dados históricos de incêndios?

— Seriam históricos.

— E nossa API?

— Provavelmente desnecessária para isso.

— E Kafka?

— Para assar um porco?

João começou a perceber o problema.

Ele não estava propondo apenas uma grelha.

Estava propondo destruir um ecossistema.


🏢 O SISTEMA NÃO ERA MAIS O SISTEMA

Durante cinquenta anos a empresa construíra organizações inteiras ao redor do método de incendiar florestas.

Existiam:

engenheiros de incêndio;

analistas de capacidade de incêndio;

DBAs especializados em tabelas de porcos;

operadores de batch;

especialistas em temperatura;

arquitetos de integração;

consultores;

auditores;

fornecedores;

contratos;

KPIs;

SLAs;

certificações;

procedimentos;

comitês;

diretorias.

O objetivo original havia sido:

assar porcos.

Mas lentamente o objetivo transformara-se em:

operar eficientemente o Sistema Corporativo de Incêndio de Florestas.

Essa diferença parecia pequena.

Não era.

Era gigantesca.


🧠 O DIRETOR EXPLICA A REALIDADE

O diretor chamou João.

— Sua ideia é interessante.

João sorriu.

— Obrigado.

— Mas você não compreende toda a complexidade.

João parou de sorrir.

O diretor mostrou o organograma.

Centenas de pessoas dependiam daquele processo.

Havia contratos plurianuais.

Depreciação de ativos.

Compliance.

Auditoria.

Treinamentos.

Orçamento.

Fornecedores.

Roadmaps.

Projetos estratégicos.

— Você está olhando apenas para o problema técnico — explicou o diretor.

João respondeu:

— Eu estou olhando para o porco.

O diretor respirou fundo.

— Exatamente. Esse é o problema.


🐷 O PORCO ESQUECIDO

Naquela noite João caminhou pelo Data Center.

Passou pelos enormes computadores.

Viu os painéis.

Os dashboards.

As luzes.

Os gráficos.

Tudo extraordinariamente sofisticado.

Então percebeu algo.

A organização sabia medir praticamente tudo.

Sabia quantas árvores queimavam.

Quanto combustível utilizava.

Quanto tempo levava.

Quantos processadores consumia.

Quantas mensagens trafegavam.

Quantos incidentes aconteciam.

Quanto custava cada floresta.

Mas havia uma pergunta que quase ninguém fazia:

“Ainda precisamos fazer isso dessa maneira?”

Essa pergunta não aparecia no SMF.

Não estava no RMF.

Não aparecia no Splunk.

Não existia no Grafana.

Não estava no Jira.

Não havia campo para ela no ServiceNow.

Porque nenhum sistema de observabilidade consegue detectar sozinho que o próprio processo observado deixou de fazer sentido.


☕ EPÍLOGO — O VERDADEIRO LEGADO

E aqui está a armadilha.

Legado não é COBOL.

Legado não é mainframe.

Legado não é VSAM.

Legado não é CICS.

Um programa COBOL com cinquenta anos que executa perfeitamente uma função necessária pode ser uma extraordinária peça de engenharia.

Enquanto isso, um microsserviço escrito ontem pode nascer legado se automatizar brilhantemente uma coisa que ninguém deveria continuar fazendo.

Modernização verdadeira não significa trocar:

COBOL → Java

ou:

MAINFRAME → CLOUD

ou:

BATCH → KAFKA

A pergunta anterior é muito mais importante:

POR QUE ESTE PROCESSO EXISTE?

Depois:

QUAL PROBLEMA ELE RESOLVE?

Depois:

AINDA PRECISAMOS RESOLVÊ-LO?

E somente então:

QUAL É A MELHOR TECNOLOGIA?

Porque você pode colocar uma API REST na frente do incêndio.

Pode publicar o incêndio no Kafka.

Pode executar o controle do incêndio em containers.

Pode armazenar os incêndios num Data Lake.

Pode usar IA para prever incêndios.

Pode criar dashboards espetaculares mostrando incêndios em tempo real.

E pode chamar tudo isso de transformação digital.

Mas...

se para conseguir um simples porco assado você ainda precisa incendiar uma floresta inteira,

talvez o problema nunca tenha sido o COBOL.

Talvez o problema seja que, em algum momento dos últimos cinquenta anos,

todo mundo começou a cuidar do SISTEMA e ninguém mais perguntou pelo porco.


🥚 EASTER EGG DO OPERADOR

Dizem que até hoje, exatamente às 03:17, existe um job desconhecido no scheduler:

JOB PORK999

Ninguém sabe quem o criou.

Ele executa apenas:

IF FLORESTA-EM-CHAMAS
    DISPLAY 'MAS POR QUE?'
END-IF.

O programa possui somente um comentário:

*> J.BOM-SENSO - NAO REMOVER.

Ninguém remove.

Afinal...

é legado.

Inspirado em fabula dos porcos Juício a La Escuela Cirigliano, Forcade Tilich Editorial Editorial Humanitas – Buenos Aires, 1974

sexta-feira, 11 de setembro de 2026

🧠 Microservices sob a Batuta de Chris Knight — Real Genius, Arquitetura e a Arte de Não Construir um Laser para Aquecer Pipoca

 

Bellacosa Mainframe apresenta microservices

☕ Um Café no Bellacosa Mainframe

🧠 Microservices sob a Batuta de Chris Knight — Real Genius, Arquitetura e a Arte de Não Construir um Laser para Aquecer Pipoca

Quando todo mundo está fascinado pela tecnologia, talvez o verdadeiro gênio seja justamente aquele que pergunta: “Legal... mas por que estamos construindo isso?”

Existe uma cena mental perfeita para explicar boa parte da arquitetura de software moderna.

Imagine uma sala cheia de engenheiros brilhantes. Há diagramas nas paredes, notebooks abertos, APIs sendo desenhadas, Kubernetes em algum canto, Kafka atravessando o desenho, containers surgindo aos montes e alguém acaba de pronunciar palavras capazes de provocar arrepios em qualquer apresentação corporativa:

“Precisamos migrar para microservices.”

Todos concordam.

Alguém acrescenta:

— E microfrontends.

Outro melhora:

— Event-driven!

Do fundo da sala:

— Service mesh!

Então aparece Chris Knight, de Real Genius, observa o quadro por alguns segundos e provavelmente pergunta:

“Tá... qual problema vocês estão tentando resolver?”

Silêncio.

E é justamente aí que começa nossa conversa.

Porque transformar um desenvolvedor em arquiteto não significa ensiná-lo a colocar mais tecnologias dentro de um desenho.

Significa ensiná-lo a questionar o desenho.

Para um programador COBOL começando a olhar para arquitetura moderna, existe uma excelente notícia: você provavelmente já conhece vários dos princípios fundamentais. Talvez apenas os conheça por outros nomes.

Pegue seu café.

Hoje vamos entrar no laboratório de Chris Knight.

E alguém, por favor, esconda a pipoca.



🎬 1. Primeiro precisamos falar sobre Real Genius

Real Genius, lançado em 1985, acompanha estudantes extremamente talentosos envolvidos em um projeto científico universitário. Chris Knight, interpretado por Val Kilmer, é um daqueles personagens que parecem estar permanentemente brincando enquanto enxergam coisas que outras pessoas não percebem.

E isso combina maravilhosamente com arquitetura.

O estereótipo do arquiteto costuma ser alguém extremamente sério diante de um enorme diagrama.

Chris Knight representa quase o contrário.

Ele domina a tecnologia, mas não é hipnotizado por ela.

Essa distinção é fundamental.

Existe uma diferença enorme entre:

saber construir algo

e

saber se aquilo deveria ser construído.

Na arquitetura corporativa encontramos frequentemente pessoas extremamente competentes resolvendo brilhantemente problemas que talvez nem precisassem existir.

Microservices são um excelente exemplo.



🧱 2. “Monólito” não é palavrão

Durante alguns anos, dizer que uma aplicação era monolítica parecia quase uma confissão.

“Nosso sistema ainda é um monólito...”

Pronunciado quase como:

“Temos ratos no datacenter.”

Mas precisamos separar duas coisas:

MONÓLITO

e:

MONÓLITO RUIM

Não são sinônimos.

Imagine:

SISTEMA DE PEDIDOS
│
├── CLIENTES
├── PRODUTOS
├── PEDIDOS
├── ESTOQUE
├── PAGAMENTOS
└── FATURAMENTO

Tudo pode existir dentro da mesma aplicação.

Isso não significa necessariamente que temos uma arquitetura ruim.

Podemos possuir módulos claramente definidos, responsabilidades separadas e interfaces controladas.

Temos então aquilo que costuma ser chamado de:

Modular Monolith.

Agora compare com:

SISTEMA
│
├── tudo acessa tudo
├── qualquer módulo altera qualquer tabela
├── regras aparecem duplicadas
├── dependências circulares
└── ninguém sabe quem é dono de quê

Isso é ruim.

Mas dividir esse segundo sistema em 50 containers não elimina magicamente seus problemas.

Talvez apenas consigamos transformar:

um monólito ruim

em:

50 pequenos pedaços ruins conversando pela rede.

Chris Knight certamente acharia isso divertido.

O pessoal de produção, provavelmente menos.



🧠 3. COBOL já ensinava modularidade antes de ela ganhar slides coloridos

Vamos colocar nosso programador COBOL iniciante diante disso.

Imagine:

       CALL 'CALCJURO'
           USING WS-SALDO
                 WS-TAXA
                 WS-JUROS.

O programa principal não precisa conhecer cada detalhe do cálculo.

Ele conhece uma interface.

Existe entrada.

Existe processamento.

Existe saída.

Isso é uma forma de separação de responsabilidade.

Podemos ter:

PROGRAMA PRINCIPAL
       │
       ├── VALIDCPF
       ├── CALCJURO
       ├── CONSULTA
       └── GRAVAPGTO

Isso não são microservices.

É importante não cair nessa simplificação.

Um subprograma COBOL normalmente não possui várias características associadas a um microservice moderno, como deployment independente, isolamento operacional, endpoint de rede próprio, escalabilidade independente e ownership autônomo.

Mas existe uma ancestralidade conceitual.

Estamos falando de:

modularidade.

coesão.

baixo acoplamento.

contratos.

Esses princípios não nasceram com Docker.


🔬 4. Chris Knight perguntaria onde está a fronteira

Agora imagine que alguém encontre:

PGM001
PGM002
PGM003
...
PGM500

e proponha:

“Vamos transformar cada programa COBOL em um microservice.”

Chris Knight provavelmente levantaria a sobrancelha.

Porque programa não é necessariamente domínio de negócio.

Um sistema bancário poderia possuir algo conceitualmente parecido com:

CONTA
├── abrir
├── consultar
├── bloquear
├── movimentar
└── encerrar

Essas operações possuem relação.

Talvez façam parte de uma capacidade coerente.

Por outro lado, transformar mecanicamente:

PGM001 → SERVICE001
PGM002 → SERVICE002
PGM003 → SERVICE003

não constitui arquitetura.

É conversão de inventário.

Uma boa fronteira deveria tentar responder:

Quem é responsável por esta capacidade?

Quais dados pertencem a ela?

Quem pode modificá-los?

Que contrato oferecemos ao restante do sistema?

Esse raciocínio nos aproxima de conceitos como bounded contexts e Domain-Driven Design.


🚪 5. Então aparece o API Gateway

Nos diagramas modernos frequentemente encontramos:

                 FRONTEND
                    │
                    ▼
              API GATEWAY
                    │
        ┌───────────┼───────────┐
        ▼           ▼           ▼
     PRODUCT      BASKET      ADVERT
     SERVICE      SERVICE     SERVICE

O gateway funciona como uma porta de entrada.

Ele pode participar de tarefas como roteamento, autenticação, autorização, controle de tráfego, transformação e observabilidade.

Isso evita que o consumidor precise conhecer detalhes demais da infraestrutura interna.

Para quem trabalha com mainframe, existe aqui uma conexão importantíssima.

Suponha:

MOBILE
   │
   ▼
REST API
   │
   ▼
API LAYER
   │
   ▼
CICS
   │
   ▼
COBOL
   │
   ▼
Db2

O aplicativo móvel não precisa saber que existe COBOL.

Aliás, ele não deveria precisar saber.

Para ele existe:

GET /accounts/123

Atrás disso pode existir uma transação CICS construída anos atrás.

Isso nos leva a uma das ideias mais importantes deste artigo:

Modernizar a interface de um sistema não exige necessariamente reescrever seu coração.


⚡ 6. “Mas microservices escalam!”

Sim.

E aqui Chris Knight provavelmente responderia:

“Qual parte precisa escalar?”

Imagine uma loja:

CATÁLOGO
50.000 req/s

PAGAMENTO
2.000 req/s

RELATÓRIOS
200 req/s

Se tudo estiver dentro de uma aplicação indivisível, talvez seja necessário escalar todo o conjunto.

Com serviços independentes, podemos ter:

CATÁLOGO
████████████████████

PAGAMENTO
████

RELATÓRIO
█

Agora temos uma vantagem concreta.

Não estamos usando microservices porque são modernos.

Estamos usando porque determinadas capacidades possuem características operacionais diferentes.

Esse é pensamento arquitetural.


🌐 7. Só existe um pequeno problema chamado rede

No COBOL podemos ter:

CALL 'VALIDA' USING WS-DADOS.

Agora transforme conceitualmente essa interação em:

SERVICE-A
    │
    │ HTTP
    ▼
SERVICE-B

Parece semelhante no PowerPoint.

Na operação, não é.

O Service B pode estar indisponível.

A rede pode estar congestionada.

O DNS pode falhar.

A resposta pode demorar.

A conexão pode cair.

A solicitação pode ser processada e a resposta se perder.

Aí Service A pensa:

“Não recebi resposta. Vou tentar novamente.”

Só que Service B executou a operação.

Parabéns.

Talvez você tenha cobrado o cliente duas vezes.


🔁 8. Bem-vindo ao maravilhoso mundo dos retries

Precisamos começar a pensar em:

timeout
retry
backoff
circuit breaker
idempotency
correlation ID
distributed tracing

Suponha:

POST /payment

A chamada chega.

O pagamento é processado.

A resposta desaparece.

O consumidor repete:

POST /payment

O sistema precisa conseguir perceber:

“Eu já processei esta operação.”

Daí surge a importância de idempotência.

Por exemplo:

IDEMPOTENCY-KEY: TX-928374

Se a mesma operação chegar novamente, podemos reconhecer que ela já aconteceu.

Observe como algo que parecia simplesmente:

A → B

acabou se tornando uma discussão arquitetural inteira.

Essa é uma das contas escondidas dos sistemas distribuídos.


💾 9. E então chegamos aos dados

Aqui começa a diversão de verdade.

Em um monólito podemos encontrar:

APPLICATION
     │
     ▼
    DB2

Uma transação pode executar várias operações e depois:

COMMIT

ou:

ROLLBACK

É uma ideia maravilhosa.

Tudo funcionou?

COMMIT.

Alguma coisa falhou?

ROLLBACK.

Agora distribua:

ORDER SERVICE
      │
      ▼
ORDER DB

PAYMENT SERVICE
      │
      ▼
PAYMENT DB

STOCK SERVICE
      │
      ▼
STOCK DB

Uma compra precisa:

criar pedido
reservar estoque
autorizar pagamento
emitir nota
solicitar entrega

Quem controla a transação?

Agora a resposta pode envolver eventos, mensagens, compensações, Saga Pattern e consistência eventual.


🍿 10. O microservice que virou laser de pipoca

Aqui está nossa metáfora Real Genius.

Imagine que o requisito fosse:

aquecer pipoca.

A primeira equipe sugere:

panela

Outra diz:

micro-ondas

Então o arquiteto extremamente entusiasmado apresenta:

satélite
     ↓
laser de alta potência
     ↓
espelho orbital
     ↓
sistema de coordenadas
     ↓
pipoca

Funciona?

Provavelmente conseguimos inventar uma maneira.

É impressionante?

Sem dúvida.

Era necessário?

Aí está a pergunta.

Em software fazemos exatamente isso.

Requisito:

600 usuários
CRUD
4 desenvolvedores
1 release mensal

Arquitetura proposta:

37 microservices
Kubernetes
Kafka
service mesh
Redis
API Gateway
15 databases
distributed tracing
GitOps
multi-cloud

E alguém precisa perguntar:

“Nós estamos construindo uma aplicação ou tentando ganhar a feira de ciências?”


🕸️ 11. O monólito distribuído

Existe uma criatura particularmente cruel.

Ela possui microservices no diagrama:

A → B → C → D → E

Mas A não consegue funcionar sem B.

B depende de C.

C depende de D.

Todos compartilham dados.

Precisam ser publicados juntos.

Uma alteração em E exige mudanças em A.

Temos então algo parecido com:

Distributed Monolith.

Conseguimos preservar o acoplamento do monólito e adicionar:

latência
rede
timeouts
deployment
containers
observabilidade
versionamento
falhas distribuídas

É quase uma obra de arte.

Chris Knight estaria impressionado.


📡 12. Observabilidade deixa de ser luxo

Imagine uma operação:

APP
 ↓
GATEWAY
 ↓
ORDER
 ↓
PAYMENT
 ↓
BROKER
 ↓
FRAUD
 ↓
BANK

Às 03:17, toca o telefone.

Easter egg encontrado. ☕

O cliente foi cobrado, mas o pedido não existe.

Agora precisamos reconstruir a viagem daquela transação.

Precisamos de algo parecido com:

TRACE-ID = ABC938271

Esse identificador acompanha a operação:

Gateway  ABC938271
Order    ABC938271
Payment  ABC938271
Fraud    ABC938271
Bank     ABC938271

Finalmente podemos reconstruir a história.

Esse é o valor do distributed tracing.

Em sistemas distribuídos, logs isolados deixam de contar a história completa.

Precisamos correlacioná-los.


🎯 13. Microservices não são principalmente uma decisão tecnológica

Aqui encontramos uma das maiores curiosidades da arquitetura.

Microservices também são uma decisão organizacional.

Imagine uma empresa com 300 desenvolvedores divididos em equipes:

CATALOG TEAM
PAYMENT TEAM
ORDER TEAM
SHIPPING TEAM
CUSTOMER TEAM

Se cada equipe puder controlar uma capacidade com ciclo próprio:

code
 ↓
test
 ↓
deploy
 ↓
operate

a independência arquitetural pode trazer enorme valor.

Agora imagine quatro desenvolvedores mantendo tudo.

Criar 40 serviços talvez não proporcione autonomia.

Talvez proporcione 40 coisas para quatro pessoas cuidarem.

Arquitetura precisa considerar a organização que vai operá-la.


🧩 14. Microfrontends repetem a experiência

Depois dos microservices alguém percebeu:

“E o frontend?”

Surge então:

Microfrontends.

Podemos ter:

BASE APPLICATION
│
├── PRODUCT
├── BASKET
└── ADVERT

Equipes diferentes podem desenvolver partes da experiência.

Em organizações enormes isso pode oferecer independência.

Mas imediatamente surgem novas perguntas.

Quem controla o design?

Quem controla as bibliotecas?

Como evitamos duplicação?

Como mantemos performance?

Como garantimos experiência consistente?

Outra vez:

Todo benefício arquitetural compra alguma complexidade.

A pergunta é se vale o preço.


🤖 15. “Micro/vibe everything” é mais perigoso do que parece

A imagem original contém uma pequena provocação maravilhosa:

Micro/vibe everything.

Em plena era da IA generativa, isso merece atenção.

Hoje podemos pedir:

“Crie 15 microservices para uma plataforma de vendas.”

E minutos depois receber:

/auth
/customer
/product
/order
/payment
/shipping
/inventory
/notification
/recommendation
...

Temos Dockerfiles.

APIs.

Testes.

YAML.

Filas.

Bancos.

Tudo parece extraordinariamente profissional.

Só existe uma questão:

Por que 15?

Talvez fossem necessários três.

Talvez oito.

Talvez nenhum.

IA reduziu dramaticamente o custo de produzir código.

Mas isso não reduz automaticamente o custo de:

possuir o código.

Alguém terá que entender, testar, proteger, atualizar, observar e recuperar aquilo.

Esta talvez seja uma das maiores mudanças para o arquiteto moderno:

Quanto mais barato fica criar complexidade, mais valiosa fica a capacidade de recusá-la.


🏛️ 16. O velho mainframe entra no laboratório

Aqui nosso programador COBOL pode sorrir.

Mainframes corporativos carregam décadas de lições sobre:

contratos
compatibilidade
transações
workload
segurança
mensageria
recuperação
disponibilidade
observabilidade

Sistemas antigos sobreviveram não porque nunca mudaram.

Sobreviveram justamente porque conseguiram mudar preservando contratos importantes.

Podemos encontrar algo como:

React
   ↓
REST
   ↓
API
   ↓
CICS
   ↓
COBOL
   ↓
Db2

E isso não deveria provocar vergonha arquitetural.

Talvez seja uma arquitetura excelente.

O frontend pode ser substituído.

A API pode evoluir.

A camada de integração pode mudar.

Enquanto isso, uma rotina COBOL comprovada durante bilhões de transações continua fazendo exatamente aquilo para que foi construída.

Chris Knight provavelmente perguntaria:

“Se funciona, escala, é seguro e atende ao negócio... exatamente por que vocês querem reescrever?”

Excelente pergunta.


🧠 17. O que realmente transforma Engineer em Architect

Não é Kubernetes.

Não é Kafka.

Não é AWS, Azure ou qualquer outra plataforma.

Não é conhecer cinquenta design patterns.

A transformação acontece quando mudamos de:

COMO CONSTRUO?

para:

POR QUE CONSTRUIR?

QUAL PROBLEMA?

QUAL ESCALA?

QUAL SLA?

QUAL CUSTO?

COMO FALHA?

COMO RECUPERA?

COMO OBSERVAMOS?

QUEM MANTÉM?

COMO EVOLUI?

QUAL É A ALTERNATIVA MAIS SIMPLES?

Um arquiteto não deveria ser simplesmente o profissional capaz de desenhar mais caixas.

Às vezes sua maior contribuição é pegar o desenho:

□ → □ → □ → □ → □
       ↓
       □
       ↓
   □ → □ → □

e perguntar:

“Podemos fazer isso com três?”


⚖️ 18. A regra Bellacosa-Chris Knight

Podemos transformar toda esta conversa em uma pequena regra:

Não escolha uma arquitetura porque consegue construí-la. Escolha porque consegue justificar sua existência.

Microservices podem ser extraordinários.

Um modular monolith também.

Event-driven architecture pode resolver problemas difíceis.

Uma chamada síncrona simples também.

Kafka pode ser fantástico.

Uma fila MQ pode continuar sendo exatamente aquilo que o problema exige.

REST pode ser perfeito.

Uma transação CICS pode estar executando sua função impecavelmente há décadas.

O arquiteto não deveria possuir religião tecnológica.

Deveria possuir critérios.


🔬 19. Passo a passo: antes de escolher microservices

Quando alguém disser:

“Precisamos de microservices.”

Faça o exercício Chris Knight.

Primeiro pergunte:

Qual problema atual queremos resolver?

Depois:

Precisamos de deployment independente?

Depois:

Partes diferentes precisam escalar independentemente?

Depois:

Existem boundaries de negócio claros?

Depois:

As equipes realmente possuem autonomia?

Depois:

Temos CI/CD maduro?

Depois:

Temos observabilidade?

Depois:

Sabemos operar sistemas distribuídos?

Depois:

Como trataremos consistência de dados?

Finalmente:

Um modular monolith resolveria?

Se ninguém consegue responder à primeira pergunta, não precisamos discutir a décima.


🎓 20. A lição para o programador COBOL iniciante

Se você está começando COBOL e olha para diagramas modernos pensando:

“Meu Deus, preciso aprender tudo isso antes de entender arquitetura.”

Não.

Comece pelos fundamentos.

Entenda profundamente:

dados
interfaces
responsabilidades
transações
dependências
falhas
contratos
estado
recuperação

Aprenda por que existe:

CALL

Entenda por que existe:

COMMIT

Entenda por que existe:

ROLLBACK

Entenda arquivos, Db2, VSAM, CICS e mensageria.

Depois olhe novamente para microservices.

Você começará a reconhecer velhos problemas usando roupas novas.

Naturalmente, sistemas distribuídos trouxeram desafios e soluções próprias. Não devemos fingir que um CALL COBOL e uma chamada HTTP são equivalentes.

Mas ambos obrigam o arquiteto a pensar:

Quem chama quem?

Qual é o contrato?

O que acontece quando falha?

Essas perguntas atravessam gerações tecnológicas.


🍿 Epílogo — alguém trouxe pipoca?

No final, talvez essa seja a melhor contribuição de Chris Knight para nossa imaginária aula de arquitetura.

Tecnologia pode — e deve — ser divertida.

Precisamos experimentar.

Precisamos construir protótipos.

Precisamos estudar microservices, containers, APIs, eventos, IA e tudo aquilo que surgir depois.

Mas devemos conservar uma pequena irreverência diante das modas.

Quando uma apresentação disser:

“Todo mundo está migrando para microservices.”

Pergunte:

Por quê?

Quando disserem:

“Precisamos quebrar o monólito.”

Pergunte:

Onde exatamente ele está nos prejudicando?

Quando disserem:

“Precisamos de 70 serviços.”

Pergunte:

Por que 70?

E quando alguém apresentar uma arquitetura gigantesca para resolver um problema relativamente pequeno, imagine Chris Knight entrando na reunião, olhando aquele maravilhoso laser tecnológico apontado para uma simples panela de milho e perguntando:

“Vocês sabem que existe um jeito mais fácil de fazer pipoca, não sabem?”

Essa é a diferença entre conhecer tecnologia e compreender arquitetura.

O desenvolvedor aprende a construir o laser.

O engenheiro aprende a fazê-lo funcionar.

O arquiteto calcula potência, disponibilidade, segurança e custo.

Mas o Real Genius olha para o requisito e pergunta:

“A gente precisava mesmo do laser?”

☕ Bellacosa Mainframe — porque às 03:17 da madrugada, simplicidade também é uma feature.

domingo, 12 de julho de 2026

Capítulo 12 — O Legado dos Profetas e a Grande Lição para 2026

Bellacosa Mainframe e o legado dos profetas do apocalipse mainframe

☕ Um Café no Bellacosa Mainframe

Capítulo 12 — O Legado dos Profetas e a Grande Lição para 2026

O Mainframe Nunca Venceu a Guerra. Porque Ela Nunca Existiu.

Uma reflexão sobre quatro décadas de previsões, mostrando que a verdadeira evolução da computação ocorreu pela integração de tecnologias, e não pela substituição completa das anteriores.

Por

A evolução do IBM Mainframe até o IBM z17 simbolizando o legado da engenharia
A história do mainframe demonstra que inovação não significa destruir o passado, mas incorporar novas tecnologias preservando décadas de engenharia e conhecimento.

"A melhor previsão sobre tecnologia é construída observando décadas de engenharia, não meses de marketing."

— Bellacosa Mainframe

A guerra que nunca existiu

Durante décadas, parte da indústria apresentou a evolução tecnológica como uma sequência de substituições definitivas: mainframe versus Client/Server, servidores versus cloud, cloud versus edge, IA versus programação tradicional.

Na prática, a história mostrou que as plataformas bem-sucedidas coexistem, integram-se e evoluem continuamente para atender às necessidades do negócio.

O verdadeiro diferencial

A permanência do IBM Z decorre da combinação entre inovação constante e compatibilidade com décadas de aplicações críticas. Recursos modernos como Linux, OpenShift, APIs, DevOps, containers, automação e watsonx foram incorporados sem abandonar COBOL, CICS, Db2 e z/OS.

A grande lição para 2026

A computação corporativa não evolui por rupturas absolutas, mas pela capacidade de integrar novas ideias preservando segurança, disponibilidade, desempenho e regras de negócio construídas ao longo de muitas décadas.


Chegamos ao fim da jornada...

Ou talvez...

Ao começo de outra.

Durante este artigo viajamos quase quarenta anos pela História da Computação.

Visitamos redações.

Conferências.

Centros de pesquisa.

CPDs.

Datacenters.

Conhecemos jornalistas.

Analistas.

Consultores.

Professores.

Arquitetos.

E acompanhamos uma sequência impressionante de manchetes anunciando, repetidamente, o fim do IBM Mainframe.

Forbes.

New York Times.

InfoWorld.

Business Week.

Todas refletiam um momento específico da história.

Nenhuma delas foi escrita com má intenção.

Todas tentavam responder à mesma pergunta.

Como será a computação do futuro?

Essa continua sendo uma das perguntas mais difíceis da Engenharia.


Bellacosa Mainframe agradece ao professor Wolfgang Spruth

O maior personagem desta história

Curiosamente...

O protagonista deste artigo nunca foi a IBM.

Nem o COBOL.

Nem o CICS.

Nem o Db2.

Muito menos o z17.

O verdadeiro protagonista foi algo muito maior.

A evolução da Engenharia.

Porque, enquanto manchetes mudavam de direção a cada nova tendência...

A Engenharia seguia outro ritmo.

Mais lento.

Mais cuidadoso.

Mais pragmático.

Mais responsável.

Enquanto alguns prometiam revoluções anuais...

Os engenheiros pensavam em plataformas capazes de durar décadas.

E essa diferença explica praticamente toda esta história.


O professor que nos deixou um espelho

Se hoje podemos revisitar todas essas previsões, devemos isso ao Professor Wolfgang Spruth.

Seu trabalho The Death of the Mainframe não foi uma crítica à imprensa.

Foi um presente para as futuras gerações.

Spruth poderia simplesmente ter respondido aos artigos.

Não fez isso.

Preferiu arquivá-los.

Organizá-los.

Contextualizá-los.

Transformá-los em História.

Foi uma atitude tipicamente acadêmica.

Porque pesquisadores sabem que a memória também é uma forma de conhecimento.

Sem aquele pequeno conjunto de slides...

Grande parte dessas manchetes estaria perdida em arquivos esquecidos.

Graças a ele, hoje podemos estudá-las com calma, entender seu contexto e aprender com seus acertos e seus erros.


2026 é muito diferente de 1993

Imagine mostrar a um jornalista de 1993 um IBM z17.

Provavelmente ele perguntaria:

— Onde está o terminal verde?

Você responderia:

— Ainda existe.

Mas agora também existem:

  • APIs REST;

  • JSON;

  • OpenAPI;

  • Linux;

  • Containers;

  • Kubernetes;

  • OpenShift;

  • Git;

  • GitHub;

  • VS Code;

  • Python;

  • Java;

  • Node.js;

  • Go;

  • Zowe;

  • Ansible;

  • DevOps;

  • CI/CD;

  • watsonx;

  • Inteligência Artificial embarcada.

Talvez ele olhasse novamente para a máquina.

Depois perguntasse:

— Então isso ainda é um mainframe?

Você sorriria.

— Sim.

E talvez seja exatamente isso que torna essa plataforma tão fascinante.

Ela mudou completamente...

Sem deixar de ser ela mesma.


O COBOL também não ficou parado

Existe outra injustiça histórica.

Muitos imaginam COBOL como uma linguagem congelada em 1974.

Nada poderia estar mais distante da realidade.

O COBOL moderno conversa com:

JSON.

XML.

UTF-8.

APIs.

Serviços REST.

C.

Java.

Db2.

CICS.

MQ.

Git.

Pipelines DevOps.

Compiladores inteligentes.

Análise estática.

Testes automatizados.

Performance extremamente otimizada.

O COBOL não permaneceu vivo porque ficou parado.

Permaneceu vivo porque evoluiu.

Exatamente como qualquer tecnologia saudável deveria fazer.


O Db2, o CICS e o z/OS seguiram o mesmo caminho

O mesmo vale para todo o ecossistema IBM Z.

O Db2 evoluiu para um banco de dados altamente otimizado para cargas analíticas e transacionais.

O CICS transformou-se em uma plataforma moderna de serviços, APIs e integração.

O z/OS incorporou automação, segurança avançada, observabilidade, cloud híbrida e ferramentas abertas.

O BOB simplificou pipelines de build.

O Zowe aproximou novos desenvolvedores.

O Ansible levou automação moderna para o ambiente IBM Z.

O watsonx colocou Inteligência Artificial dentro da estratégia corporativa.

Nada disso existia quando aquelas manchetes foram escritas.


O maior erro continua acontecendo

Talvez a parte mais interessante desta história seja perceber que ela continua se repetindo.

Hoje o discurso mudou.

Não ouvimos mais:

"O Client/Server acabará com o Mainframe."

Agora ouvimos:

"A Inteligência Artificial acabará com os programadores."

Ou:

"LLMs substituirão arquitetos."

Ou:

"Ninguém mais precisará aprender linguagens de programação."

Será?

Talvez.

Talvez não.

Mas depois de estudar quarenta anos de História...

Aprendemos uma lição importante.

Desconfie sempre das previsões absolutas.

Principalmente quando elas envolvem palavras como:

"Nunca."

"Sempre."

"Definitivamente."

"Até 2030."

"A última."

A História da Computação costuma ser muito mais criativa do que qualquer cronograma.


O velho Jedi explica o segredo

Nosso Padawan encontra novamente o velho mestre.

Depois de toda essa jornada ele faz apenas uma pergunta.

— Mestre...

Qual foi o segredo do Mainframe?

O velho engenheiro permanece alguns segundos em silêncio.

Depois responde.

— O segredo nunca foi o hardware.

— Então foi o COBOL?

— Também não.

— O CICS?

— Não.

— O Db2?

— Ainda não.

— Então o que foi?

O mestre sorri.

Aponta para uma palavra escrita em um quadro branco.

Compatibilidade.

Depois escreve outra.

Evolução.

E mais uma.

Confiabilidade.

Por fim conclui.

— O Mainframe nunca obrigou seus clientes a jogar fora quarenta anos de investimento para aproveitar uma inovação.

Ele carregou o passado junto com o futuro.

Essa talvez tenha sido sua maior invenção.


A verdadeira Estrela da Morte

Como todo bom Bellacosa Mainframe...

Precisamos terminar com uma referência a Star Wars.

Durante anos o mercado enxergou o IBM Mainframe como se fosse a Estrela da Morte.

Gigante.

Antigo.

Centralizado.

Imponente.

Mas talvez a comparação correta seja outra.

O IBM Mainframe nunca foi a Estrela da Morte.

Ele sempre foi o Mestre Yoda.

Enquanto todos corriam atrás da próxima moda...

Ele permanecia em silêncio.

Aprendendo.

Evoluindo.

Adaptando-se.

Observando gerações inteiras de tecnologias nascerem.

Algumas brilharem intensamente.

Outras desaparecerem.

No final...

Ainda estava lá.

Mais experiente.

Mais moderno.

Mais forte.


Uma carta ao Padawan COBOL

Se você chegou até aqui...

Talvez esteja começando sua carreira.

Talvez já tenha décadas de experiência.

Não importa.

Existe uma única mensagem que gostaria que permanecesse com você.

Nunca estude uma tecnologia apenas porque ela está na moda.

Estude porque ela resolve um problema.

Nunca abandone uma tecnologia apenas porque alguém a chamou de "legado".

Descubra primeiro se ela continua gerando valor.

Nunca confunda marketing com arquitetura.

Nunca confunda novidade com inovação.

Nunca confunda interface bonita com engenharia sólida.

E, acima de tudo...

Nunca deixe de aprender.

Porque foi exatamente isso que permitiu ao IBM Mainframe atravessar mais de seis décadas.


A História escreveu seu próprio final

Em 1989 disseram que era um dinossauro.

Em 1991 marcaram a data de sua morte.

Em 1993 afirmaram que caminhava para a extinção.

Em 1994 começaram a perceber que talvez estivessem enganados.

Em 2026...

O IBM z17 executa Inteligência Artificial.

O watsonx auxilia empresas em escala global.

O COBOL continua movimentando trilhões de dólares.

O Db2 continua protegendo informações críticas.

O CICS continua processando bilhões de transações.

O z/OS continua sendo referência em disponibilidade e segurança.

E milhares de novos Padawans continuam aprendendo essa plataforma extraordinária.

A História foi generosa.

Ela não humilhou quem errou.

Apenas mostrou que prever o futuro é muito mais difícil do que construir um bom sistema.


Epílogo

Quando terminar este café...

Feche o navegador.

Abra seu editor.

Entre no TSO.

Compile um programa COBOL.

Execute um JCL.

Faça um SELECT no Db2.

Chame uma transação CICS.

Observe tudo funcionando.

Então lembre-se de uma frase.

O Mainframe nunca sobreviveu porque resistiu ao futuro.

Ele sobreviveu porque aprendeu a evoluir junto com ele.

Essa talvez seja a maior lição deixada por Wolfgang Spruth.

E certamente é a maior herança que podemos transmitir para a próxima geração de Programadores COBOL Padawans.

Que a Engenharia esteja com você.

Sempre.

Bellacosa Mainframe e o Funeral que nunca aconteceu



C:\BELLACOSA\COBOL\FUNERAL_QUE_NUNCA_ACONTECEU.HTML
★ BELLACOSA MAINFRAME APRESENTA ★

A MORTE DO COBOL

O Funeral que Nunca Aconteceu

Uma investigação histórica em 14 capítulos sobre as previsões, reportagens, buzzwords e profetas que anunciaram repetidamente o fim do COBOL — enquanto bilhões de transações continuavam sendo processadas silenciosamente.

SISTEMA ONLINE — 14 CAPÍTULOS DISPONÍVEIS
▼ DIRETÓRIO DE CAPÍTULOS ▼

README.TXT

Esta série investiga uma das narrativas mais repetidas da história da tecnologia: a suposta morte do COBOL. Durante décadas, revistas, jornais, consultorias e especialistas anunciaram seu desaparecimento. Entretanto, o COBOL permaneceu processando bancos, seguradoras, governos, cartões, pagamentos e sistemas críticos.

Os títulos e links acima são elementos HTML reais, permitindo que mecanismos de busca encontrem e rastreiem todos os capítulos. Os iframes funcionam apenas como previews visuais.

C:\> RUN BELLACOSA.EXE /COBOL /HISTORY /NO-FUNERAL _

★ BELLACOSA MAINFRAME ★ COBOL ★ IBM Z ★ HISTÓRIA DA COMPUTAÇÃO ★

Melhor visualizado em qualquer navegador com café disponível.

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