☕ 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 Integração Contínua. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta Integração Contínua. Mostrar todas as mensagens

segunda-feira, 20 de julho de 2026

CI/CD : Quando Batman, Robin, GitHub Actions e Tekton Descobriram que um JOB JCL Também Pode Vestir uma Capa

 

Bellacosa Mainframe e o ci/cd para iniciantes, uma santa charada

☕ Um Café no Bellacosa Mainframe

CI/CD sem Mistérios para Programadores COBOL

Quando Batman, Robin, GitHub Actions e Tekton Descobriram que um JOB JCL Também Pode Vestir uma Capa

"POW!"
"BAM!"
"ZAP!"

Imagine que você entrou em um Data Center da IBM em 1978.

De repente, a porta explode.

Surge Batman correndo pelos corredores do CPD.

Robin grita:

"Santo Pipeline, Batman! Alguém fez um deploy direto em produção!"

Batman olha para o console 3270.

Na tela aparece:

ABEND=S0C7

Batman suspira.

— Robin... alguém ignorou o CI.

Robin responde:

— E também esqueceu o CD...

Batman abaixa a cabeça.

— Chamem o Comissário Gordon.

Só que o Comissário Gordon, em 2026, atende pelo nome de GitHub Actions.


O verdadeiro vilão nunca foi o Git

Durante anos muitos programadores COBOL acreditaram que aprender Git era o grande desafio.

Depois vieram Docker.

Depois Kubernetes.

Depois YAML.

Depois Tekton.

Depois GitHub Actions.

Até que descobriram uma verdade curiosa.

Nenhuma dessas ferramentas é realmente difícil.

O difícil é entender como elas conversam entre si.

É exatamente isso que aprendemos ao longo do curso de Continuous Integration and Continuous Delivery (CI/CD).

E curiosamente...

Tudo faz muito sentido para quem já viveu dentro de um mainframe.


CI é apenas um JCL moderno

Essa frase costuma assustar desenvolvedores web.

Mas para quem programa COBOL...

Ela faz todo sentido.

Imagine um JOB.

STEP001
STEP002
STEP003
STEP004

Cada STEP depende do anterior.

Se um falha...

O JOB termina.

Agora troque:

STEP001 → Checkout

STEP002 → Compile

STEP003 → Teste

STEP004 → Deploy

Parabéns.

Você acabou de entender um Pipeline.


GitHub Actions é o novo JES2

No curso inteiro existe uma ferramenta protagonista.

GitHub Actions.

Ela observa o repositório.

Sempre que alguém faz:

git push

Ela acorda.

Como o JES2 recebendo um JOB.

Ela pega um arquivo chamado:

.github/workflows/workflow.yml

E executa exatamente o que está escrito ali.

Não pensa.

Não interpreta.

Não improvisa.

Ela apenas executa.

Como qualquer bom scheduler.


O Workflow

No curso aprendemos que todo Workflow precisa de quatro partes.

Evento

push

ou

pull_request

É o equivalente ao operador apertando ENTER.


Runner

ubuntu-latest

É a máquina onde tudo acontece.

Pense nela como um LPAR temporário.


Steps

Cada Step é um mini programa.

Exemplo:

Checkout

↓

Setup Node

↓

npm install

↓

ESLint

↓

Jest

No mainframe seria quase:

IEFBR14

↓

COBOL

↓

LINKEDIT

↓

TESTE

↓

EXECUÇÃO

O primeiro inimigo

Durante nosso projeto apareceu um erro curioso.

Recebemos nota zero.

Mas...

O CI estava verde.

Como isso era possível?

Batman chamou Alfred.

Alfred olhou cuidadosamente.

E respondeu:

"Mestre Bruce...

o problema não era o código.

Era o link."

Exatamente isso.

O Coursera esperava:

.github/workflows/workflow.yml

Nós enviamos:

workflow/

Resultado:

Zero.

Moral da história?

No mundo DevOps...

Caminhos importam.

Muito.


O AI Grader é como um compilador COBOL

Essa foi provavelmente a maior descoberta.

O avaliador automático não "entende" intenção.

Ele faz matching.

Se procura:

SERVICERUNNING

e você escreveu:

SERVICE RUNNING

Você perde ponto.

Mesmo estando correto.

Lembra bastante um compilador COBOL.

MOVE ZERO TO WS-TOTAL

é diferente de

MOVE ZEROS TO WS-TOTAL

Um detalhe muda tudo.


A importância dos Logs

Outro erro clássico.

Mandamos o log do GitHub Actions.

Mas a questão queria:

oc logs

Ou seja...

Logs da aplicação.

Não do pipeline.

Batman diria:

"Robin...

não investigue o Batmóvel quando o crime aconteceu dentro do Banco de Gotham."


O mistério do PVC

Durante o laboratório apareceu outro personagem.

pipeline-pvc

Muita gente acha que é apenas um volume.

Mas ele é muito mais.

É o HD temporário do Pipeline.

Imagine um SORT usando um dataset intermediário.

Sem ele...

O STEP seguinte não encontra nada.

No Tekton acontece igual.

Cada Task compartilha arquivos usando Workspaces.

E quem sustenta isso?

O PVC.


Tekton

Se GitHub Actions faz CI...

Tekton faz CD.

Ele possui três personagens.

Task

Uma única ação.

Como:

Lint

ou

Test

Pipeline

O roteiro completo.

Cleanup

↓

Git Clone

↓

ESLint

↓

Jest

↓

Buildah

↓

Deploy

PipelineRun

A execução.

Pense nela como:

SUBMIT JOB

Buildah

Muitos imaginam que Buildah é parecido com Docker.

Na prática...

Ele fabrica imagens OCI.

No curso ele aparece depois do Jest.

Porque primeiro validamos.

Depois construímos.

Nunca o contrário.


Deploy

A última etapa.

oc set image

troca a imagem do Deployment.

É o equivalente moderno do:

NEW LOAD MODULE

no mainframe.


Plano de Estudos para um Programador COBOL Júnior

Semana 1 — Git e GitHub

Objetivo:

  • Repositórios

  • Branches

  • Commits

  • Pull Requests

Prática:

  • Criar um repositório de exemplo.

  • Fazer commits pequenos e descritivos.

  • Aprender a resolver conflitos simples.


Semana 2 — GitHub Actions

Objetivo:

  • Workflow

  • Runner

  • Jobs

  • Steps

Exercício:

Criar um Workflow que execute:

npm install

↓

npm run lint

↓

npm test

Analogia mainframe:

  • Cada Step é como um EXEC em um JOB JCL.


Semana 3 — Testes Automatizados

Objetivo:

  • Jest

  • Cobertura

  • Qualidade

Prática:

  • Escrever testes para funções simples.

  • Corrigir falhas até obter pipeline verde.


Semana 4 — YAML

Objetivo:

  • Sintaxe

  • Indentação

  • Estruturas

Dica:

YAML não perdoa espaços errados.

Assim como JCL não perdoa colunas erradas.


Semana 5 — OpenShift

Objetivo:

  • Projetos (Namespaces)

  • Pods

  • Deployments

  • Services

  • Routes

Prática:

  • Implantar uma aplicação simples.

  • Consultar logs com oc logs.

  • Explorar recursos com oc get e oc describe.


Semana 6 — Tekton

Criar:

✔ Task

✔ Pipeline

✔ PipelineRun

Depois:

Cleanup

↓

Clone

↓

Lint

↓

Test

↓

Build

↓

Deploy

Semana 7 — Observabilidade

Aprender:

oc logs

oc describe

oc get pods

oc get pvc

oc get pipelineruns

Um bom DevOps passa mais tempo lendo logs do que escrevendo YAML.


Semana 8 — Projeto Final

Monte seu próprio pipeline.

Colete evidências.

Revise links.

Valide nomes de arquivos.

Simule a submissão.

E só então envie.


Dicas de Ouro

  • Faça commits pequenos e frequentes.

  • Nunca envie um pipeline sem executá-lo.

  • Leia cuidadosamente o texto das questões: muitas reprovações acontecem por responder com um link quando era pedido um log, ou vice-versa.

  • Use nomes consistentes para arquivos e Tasks.

  • Guarde capturas de tela e saídas de terminal conforme o laboratório exige.


Easter Eggs Bellacosa Mainframe

  • Bat-Sinal = GitHub Actions: quando há um push, o sinal acende e o pipeline entra em ação.

  • Robin = Jest: sempre conferindo se Batman não esqueceu de testar.

  • Alfred = ESLint: discreto, elegante e sempre apontando os pequenos defeitos antes que virem um desastre.

  • Comissário Gordon = OpenShift Console: mostra a situação da cidade (ou do cluster) em tempo real.

  • Batmóvel = PipelineRun: é ele que coloca toda a operação em movimento.

  • Caverna do Batman = Data Center: cheia de equipamentos, monitores e automação.

  • Coringa = Deploy direto em produção sem testes: divertido por alguns segundos... até tudo explodir.



A Grande Lição

O curso de CI/CD ensina ferramentas, mas a verdadeira habilidade adquirida é pensar em automação, repetibilidade e qualidade.

Para um programador COBOL, isso não é um mundo totalmente novo. É uma evolução natural de conceitos que já existem há décadas em ambientes corporativos: execução em etapas, validações, logs, artefatos, controle de versões e disciplina operacional.

Quando você percebe isso, GitHub Actions deixa de ser uma novidade assustadora. Tekton deixa de parecer um enigma. YAML deixa de ser apenas uma linguagem cheia de espaços.

Você passa a enxergar que, por trás das tecnologias modernas, continuam existindo os mesmos princípios que fizeram o mainframe sobreviver por mais de sessenta anos: planejamento, confiabilidade, automação e controle.

E talvez seja esse o maior "POW!", "BAM!" e "ZAP!" desta aventura: descobrir que o herói nunca foi a ferramenta. O verdadeiro herói sempre foi o profissional que entende o processo inteiro e faz com que ele funcione de forma previsível, segura e elegante — seja em um terminal 3270, em um pipeline do GitHub Actions ou em um cluster OpenShift.


domingo, 28 de dezembro de 2025

CI/CD no Mainframe: o que funciona, o que é mito e o que ninguém te contou

 

Bellacosa Mainframe e o ci/cd na otica mainframe

CI/CD no Mainframe: o que funciona, o que é mito e o que ninguém te contou

por El Jefe – Midnight Lunch

Durante anos, falar de CI/CD e mainframe na mesma frase era quase heresia.
De um lado, o discurso moderno: Git, pipelines, YAML, automação total.
Do outro, o mundo real: COBOL, JCL, CICS, batch crítico, auditoria, SLA e medo justificado de quebrar produção.

A boa notícia?
CI/CD é possível no mainframe.
A má notícia?
Não do jeito que a galera cloud imagina.

Este artigo não é evangelização. É sobrevivência técnica.



Antes de tudo: CI/CD não é ferramenta, é disciplina

O maior erro ao tentar “modernizar” o mainframe é achar que CI/CD é instalar Jenkins, Tekton ou OpenShift.

CI/CD é:

  • controle rigoroso de mudanças

  • builds reproduzíveis

  • rastreabilidade

  • automação com governança

  • rollback possível (e rápido)

Curiosamente, o mainframe sempre fez isso — só não chamava assim.

Endevor, ChangeMan, ISPW:

  • controlam versão

  • impõem fluxo

  • exigem aprovação

  • deixam rastro para auditoria

Ou seja:
o mainframe não está atrasado — ele só não usa camiseta preta escrito DevOps.



Onde o Git entra (e onde ele não manda)

Git é excelente para:

  • versionar código-fonte

  • colaboração entre times

  • automação de gatilhos (webhooks)

  • integração com pipelines modernos

Mas Git não substitui:

  • controle de promoção entre ambientes críticos

  • segregação de funções exigida por auditoria

  • governança de produção Z/OS

Por isso, o modelo que funciona não é Git versus Endevor.
É Git + Endevor.

Modelo realista (e profissional)

  • Git → source of collaboration

  • Endevor → source of control

  • Pipeline → ponte automatizada

Quem tenta matar o Endevor normalmente aprende da pior forma:
na auditoria… ou no incidente.


CI no mainframe: sim, dá — e dá bem

Integração Contínua em mainframe significa:

  1. Commit COBOL no Git

  2. Pipeline dispara:

    • análise estática (ex: Sonar, AppScan)

    • build automatizado (DBB)

    • compilação com dependências reais

  3. Geração de artefatos rastreáveis

  4. Publicação de evidências

Ferramentas comuns:

  • IBM Dependency Based Build (DBB)

  • Jenkins / Tekton

  • Scripts Z/OS

  • Analisadores estáticos

Nada mágico.
Nada “low-code milagroso”.
Só engenharia.


CD no mainframe: aqui mora o respeito

Entrega Contínua no mainframe não é deploy automático em produção.

É:

  • promoção controlada

  • aprovação explícita

  • janela operacional

  • rollback testado

O pipeline:

  • prepara

  • valida

  • evidencia

Quem promove para produção continua sendo:

  • o change

  • a operação

  • o processo

E isso não é atraso — é responsabilidade.


YAML no mainframe: vilão ou aliado?

YAML não é moda.
É apenas uma forma declarativa de dizer:

“este é o pipeline, nesta ordem, com estas regras”

Ele não substitui JCL.
Ele orquestra.

YAML:

  • define pipelines

  • descreve estágios

  • integra ferramentas

JCL:

  • executa trabalho pesado

  • fala direto com o Z

Quem confunde os dois costuma quebrar um ou outro.


GitOps: ótimo… com limites claros

GitOps funciona muito bem para:

  • Kubernetes

  • ambientes declarativos

  • infra elástica

No mainframe:

  • GitOps não governa produção

  • GitOps não substitui change

  • GitOps não remove segregação

Mas ele ajuda:

  • na camada distribuída

  • no controle de pipelines

  • na padronização

Argo CD conversa com OpenShift.
O OpenShift conversa com pipelines.
O pipeline conversa com o mainframe.

Esse é o desenho correto.


O anti-pattern clássico (e perigoso)

“Vamos colocar produção Z controlada direto por Git”

Tradução:

  • auditoria reprovada

  • operação em pânico

  • arquiteto desempregado

Modernizar não é destruir o que funciona.
É integrar com inteligência.


O verdadeiro estado da arte

Hoje, ambientes maduros fazem:

  • Git para código

  • Pipeline CI automatizado

  • DBB para build real

  • Endevor para promoção

  • Evidência para compliance

  • Observabilidade para melhoria contínua

Sem hype.
Sem discurso de palco.
Com produção estável.


Conclusão: CI/CD no mainframe é engenharia adulta

Mainframe não precisa virar cloud.
Precisa conversar com ela.

CI/CD no Z:

  • é possível

  • é poderoso

  • exige respeito ao contexto

Quem entende isso não briga com a plataforma.
E quem não entende… escreve post chamando o mainframe de legado morto.

Nós sabemos quem continua pagando o salário no fim do mês.


🕛 El Jefe – Midnight Lunch
Onde DevOps encontra o mundo real e sobrevive.

quinta-feira, 28 de março de 2024

RAD (Rapid Application Development) — RAD no IBM Mainframe - Parte III

 

Bellacosa Mainframe apresenta a parte III do RAD

☕ Um Café no Bellacosa Mainframe

RAD (Rapid Application Development)

Parte III — RAD no IBM Mainframe: Como Aplicar Desenvolvimento Rápido em COBOL sem Perder a Confiabilidade do IBM Z

"O Mainframe nunca foi lento. Lento sempre foi o processo de desenvolvimento ao seu redor."


Introdução

Existe uma frase que acompanha o IBM Mainframe há décadas.

"Mainframe é lento."

Quase sempre essa frase vem de alguém que nunca trabalhou em um ambiente bancário de alta disponibilidade.

Porque, na prática, o IBM Z executa milhões de transações por segundo, movimenta trilhões de dólares diariamente e mantém índices de disponibilidade que chegam próximos dos famosos cinco noves (99,999%).

Então de onde surgiu essa fama?

A resposta é simples.

As pessoas confundiram velocidade de processamento com velocidade de desenvolvimento.

São coisas completamente diferentes.

Durante muitos anos, alterar um sistema COBOL exigia:

  • abrir uma solicitação;

  • elaborar documentação;

  • aprovar análise;

  • atualizar especificações;

  • codificar;

  • compilar;

  • testar;

  • homologar;

  • agendar implantação;

  • executar mudança.

Em muitos casos, uma alteração simples levava semanas.

Não porque COBOL fosse lento.

Mas porque o processo era.

É justamente nesse ponto que o RAD mostra sua força.


O maior mito sobre COBOL

Quando ouvimos falar em RAD, muitas pessoas imaginam aplicações Web.

JavaScript.

Python.

Java.

.NET.

Poucos lembram do COBOL.

Entretanto, existe uma curiosidade interessante.

Muitos grandes bancos já utilizavam práticas extremamente parecidas com RAD muito antes da popularização do Agile.

Como?

Através de pequenas entregas.

Versionamento interno.

Reuniões constantes com usuários.

Protótipos em CICS.

Homologações frequentes.

Reutilização de módulos.

Na prática...

Faziam RAD sem chamar de RAD.


O que muda no Mainframe?

A resposta curta é:

Muito menos do que as pessoas imaginam.

Os princípios continuam exatamente iguais.

Continuamos buscando:

  • reduzir desperdícios;

  • validar rapidamente;

  • automatizar tarefas;

  • envolver usuários;

  • diminuir retrabalho.

O que muda é a plataforma.


O ciclo RAD dentro do IBM Z

Imagine uma nova funcionalidade para um sistema bancário.

Em vez de esperar seis meses para entregar tudo, o projeto pode seguir este fluxo.

Semana 1

Levantamento com usuários.

Protótipo.

Modelagem das regras.


Semana 2

Alterações em programas COBOL.

Novas tabelas DB2.

Novas transações CICS.


Semana 3

Testes automatizados.

Integração.

Homologação.


Semana 4

Produção.

Feedback.

Nova versão.

Perceba que o ciclo é praticamente o mesmo visto nas partes anteriores.


RAD e COBOL

O COBOL possui características que favorecem bastante o desenvolvimento iterativo.

Entre elas:

Grande legibilidade.

Regras de negócio bem separadas.

Excelente estabilidade.

Código altamente reutilizável.

Processamento previsível.

Programas pequenos podem ser alterados rapidamente.

Especialmente quando a arquitetura foi bem construída.

O problema normalmente não está no COBOL.

Está na forma como o sistema foi organizado.


A importância da modularização

Um dos princípios mais importantes do RAD é dividir problemas grandes em pequenos módulos.

Curiosamente...

Esse também é um dos princípios clássicos do COBOL.

Imagine um programa com cinquenta mil linhas.

Alterar qualquer coisa nele gera medo.

Agora imagine cinquenta programas com mil linhas cada.

A manutenção muda completamente.

Módulos menores significam:

  • menor risco;

  • testes menores;

  • menor impacto;

  • entregas mais rápidas.


COPYBOOKs e reutilização

Muito antes dos frameworks modernos, COBOL já utilizava reutilização.

COPYBOOKs são um excelente exemplo.

Campos.

Layouts.

Constantes.

Mensagens.

Estruturas.

Tudo compartilhado entre centenas de programas.

Isso reduz erros.

Padroniza interfaces.

Facilita manutenção.

RAD valoriza exatamente esse tipo de reutilização.


APIs mudaram completamente o jogo

Durante décadas, sistemas Mainframe conversavam principalmente através de:

Arquivos.

MQ.

CICS.

IMS.

Hoje a realidade é diferente.

Programas COBOL podem ser expostos como APIs REST utilizando:

  • z/OS Connect

  • CICS Web Services

  • IMS Connect

  • API Gateway

  • IBM API Connect

Isso aproxima enormemente o Mainframe das práticas RAD.

Uma equipe pode construir rapidamente um serviço.

Publicar.

Receber feedback.

Melhorar.

Publicar novamente.


RAD e CICS

Talvez nenhum componente do Mainframe combine tanto com RAD quanto o CICS.

Ele nasceu para processamento online.

Pequenas transações.

Respostas rápidas.

Atualizações imediatas.

Cada transação pode evoluir independentemente.

Novas telas podem ser adicionadas.

Novas regras podem ser implantadas.

Novos serviços podem ser publicados.

Tudo isso reduzindo o tempo de entrega.


RAD e DB2

Outro grande aliado.

DB2 permite evolução incremental.

Novas tabelas.

Novas views.

Novos índices.

Stored Procedures.

Funções SQL.

Muitas melhorias podem ser entregues sem alterar profundamente toda a aplicação.

Essa capacidade favorece ciclos curtos.


VSAM continua importante

Mesmo na era das APIs, VSAM continua extremamente presente.

Especialmente em sistemas críticos.

O RAD não exige abandonar tecnologias antigas.

Exige apenas desenvolver melhor.

Um arquivo KSDS bem projetado continua extremamente eficiente.


IMS também participa

Quem trabalha com IMS DB ou IMS TM sabe que estabilidade é prioridade.

Mas isso não impede evolução rápida.

Novos programas.

Novas transações.

Novos PSBs.

Novos DBDs.

Tudo pode seguir ciclos iterativos.


DevOps aproximou RAD do Mainframe

Durante muitos anos parecia impossível falar em DevOps dentro do IBM Z.

Hoje isso mudou completamente.

Ferramentas modernas permitem:

Git.

Pipeline.

Build automático.

Deploy automatizado.

Testes automatizados.

Análise de qualidade.

Code Review.

Integração Contínua.

Entrega Contínua.

Tudo isso acelerou o desenvolvimento COBOL.


Git no Mainframe

Outro paradigma foi quebrado.

Hoje programas COBOL podem ser versionados utilizando Git.

Isso traz inúmeras vantagens.

Histórico.

Branches.

Merge.

Pull Requests.

Auditoria.

Integração com pipelines.

RAD ganha enorme velocidade quando combinado com versionamento moderno.


Testes automatizados

Talvez o maior diferencial do desenvolvimento moderno.

Antes.

Cada alteração exigia dias de testes manuais.

Hoje podemos utilizar:

  • IBM ZUnit;

  • COBOL Unit Test;

  • testes de APIs;

  • testes de integração;

  • testes automatizados em pipelines.

Quanto menor o tempo de teste...

Mais ciclos RAD podemos executar.


Integração Contínua

Sempre que um desenvolvedor altera um programa:

Compila.

Executa testes.

Analisa qualidade.

Publica artefatos.

Tudo automaticamente.

Esse processo praticamente elimina erros humanos repetitivos.


Entrega Contínua

Depois da Integração Contínua vem outro passo.

Deploy automatizado.

Naturalmente ambientes bancários continuam exigindo aprovações.

Mas boa parte das tarefas repetitivas desaparece.


Inteligência Artificial no Mainframe

Estamos vivendo talvez a maior transformação desde o surgimento do COBOL.

Hoje a IA consegue:

Explicar programas legados.

Gerar documentação.

Produzir diagramas.

Encontrar dependências.

Criar casos de teste.

Gerar SQL.

Explicar ABENDs.

Documentar COPYBOOKs.

Converter documentação antiga.

Criar APIs.

Sugerir melhorias.

Isso reduz drasticamente o tempo entre entender um sistema e modificá-lo.


Mas a IA substitui o programador COBOL?

Não.

Na verdade, ela muda seu papel.

O desenvolvedor deixa de gastar horas procurando variáveis.

Passa a dedicar mais tempo às decisões arquiteturais.

Ao negócio.

À integração.

À qualidade.

À segurança.

A produtividade aumenta.

A responsabilidade também.


Governança continua indispensável

RAD nunca significou ausência de controle.

No Mainframe isso é ainda mais importante.

Boas práticas incluem:

  • RACF;

  • segregação de ambientes;

  • aprovação de mudanças;

  • auditoria;

  • versionamento;

  • rastreabilidade;

  • documentação mínima;

  • revisão técnica.

Velocidade sem governança gera incidentes.


Segurança

O IBM Z continua sendo referência mundial.

Entretanto...

Novas APIs significam novos riscos.

Autenticação.

OAuth.

JWT.

TLS.

MFA.

LGPD.

Logs.

Monitoramento.

Tudo deve ser considerado desde o início.


Observabilidade

Outra tendência recente.

Não basta colocar em produção.

É preciso observar.

SMF.

RMF.

OMEGAMON.

Grafana.

OpenTelemetry.

Logs.

Métricas.

Alertas.

Quanto antes identificarmos problemas...

Mais rapidamente corrigimos.


Oportunidades profissionais

Existe um aspecto extremamente interessante.

Empresas procuram profissionais que conheçam:

COBOL.

CICS.

DB2.

Mas também procuram pessoas que compreendam:

DevOps.

Git.

APIs.

Cloud.

Containers.

Integração.

CI/CD.

IA.

RAD aproxima esses dois mundos.

O profissional deixa de ser apenas um programador.

Passa a ser um engenheiro de soluções.


O futuro do RAD no IBM Z

O futuro parece bastante claro.

Veremos cada vez mais:

Assistentes baseados em IA.

Documentação automática.

Conversão de código.

Testes gerados automaticamente.

APIs criadas por IA.

Observabilidade inteligente.

Pipelines autônomos.

Análise preditiva.

Low-Code integrado ao Mainframe.

Agentes de IA especializados em COBOL.

Nada disso elimina o IBM Z.

Na verdade...

Tudo isso aumenta sua importância.

Porque o Mainframe continuará sendo o sistema de registro das maiores organizações do mundo.


O RAD morreu?

Definitivamente não.

Ele apenas mudou de nome várias vezes.

Quando ouvimos falar em:

Agile.

Sprint.

Lean.

XP.

DevOps.

CI/CD.

Low-Code.

No-Code.

IA Generativa.

Estamos observando diferentes evoluções da mesma ideia.

Reduzir o tempo entre uma necessidade do negócio e a entrega de valor.

Essa continua sendo a essência do RAD.


Conclusão

Ao longo desta série vimos que o Rapid Application Development nunca foi apenas uma metodologia para acelerar projetos.

Foi uma mudança de mentalidade.

James Martin percebeu, ainda no início da década de 1990, que o maior desperdício no desenvolvimento de software não era escrever código lentamente. Era construir soluções que não atendiam às necessidades reais do negócio.

Três décadas depois, essa percepção continua atual.

Scrum, DevOps, Low-Code, No-Code e Inteligência Artificial ampliaram as possibilidades, mas preservaram o mesmo princípio: aprender cedo, corrigir cedo e entregar valor continuamente.

No universo IBM Mainframe, essa filosofia encontra um terreno fértil. COBOL, CICS, DB2, IMS e z/OS permanecem como pilares das aplicações mais críticas do planeta, enquanto APIs, Git, pipelines CI/CD, testes automatizados e IA transformam a forma como essas soluções evoluem.

O verdadeiro ganho não está em substituir tecnologias consolidadas, mas em modernizar processos, reduzir desperdícios e aproximar continuamente a TI das necessidades do negócio.

Para o programador COBOL, a mensagem é clara: dominar RAD não significa abandonar décadas de experiência. Significa potencializá-las com práticas modernas, mantendo a confiabilidade que fez do IBM Z uma referência mundial.

No fim das contas, a velocidade nunca esteve na linguagem de programação.

Ela sempre esteve na capacidade da equipe de aprender, adaptar-se e entregar soluções que realmente fazem diferença.

E essa continua sendo uma das maiores lições da Engenharia de Software.


domingo, 17 de março de 2024

CI/CD no Mainframe: Como um Programador COBOL Pode Entrar na Era da Entrega Contínua Sem Esquecer Tudo o que Aprendeu

 

Bellacosa Mainframe CI/CD no Mainframe

☕ Um Café no Bellacosa Mainframe

CI/CD no Mainframe: Como um Programador COBOL Pode Entrar na Era da Entrega Contínua Sem Esquecer Tudo o que Aprendeu

"O problema nunca foi o COBOL. O problema sempre foi imaginar que um processo criado há 40 anos precisa continuar igual para sempre."

Durante décadas, o desenvolvimento em IBM Mainframe seguiu um ritual quase sagrado.

O programador alterava um programa COBOL.

Executava alguns testes.

Enviava o fonte para uma biblioteca de homologação.

Alguém fazia uma revisão.

Outro profissional gerava o package.

Outro realizava o BIND.

Outro submetia o JOB.

Dias depois, talvez semanas, aquela alteração finalmente chegava à produção.

Esse modelo funcionou.

Aliás...

Ele continua funcionando em milhares de empresas.

Mas o mercado mudou.

Hoje bancos digitais publicam dezenas de versões por dia.

Fintechs liberam pequenas correções continuamente.

Empresas querem reduzir riscos fazendo pequenas entregas em vez de grandes implantações trimestrais.

É justamente aí que entra o CI/CD.

E não...

CI/CD não significa abandonar o Mainframe.

Significa modernizar a maneira de trabalhar com ele.


Antes de tudo: o que significa CI/CD?

CI significa Continuous Integration.

CD significa Continuous Delivery ou Continuous Deployment.

São conceitos diferentes.

Continuous Integration

É a prática de integrar alterações ao repositório principal várias vezes ao dia.

Em vez de esperar uma semana para juntar o trabalho de dez programadores, cada alteração pequena é integrada rapidamente.

Isso reduz conflitos.

Reduz retrabalho.

Reduz surpresas.


Continuous Delivery

Depois que o código foi integrado, ele já está preparado para ser implantado.

Existe uma "linha de montagem".

Cada etapa acontece automaticamente.

Por exemplo:

  • compilação

  • geração de DBRM

  • BIND

  • testes

  • análise de qualidade

  • empacotamento

  • aprovação

  • implantação

Tudo acontece de forma repetível.


Continuous Deployment

Vai além.

Após todos os testes serem aprovados, a implantação ocorre automaticamente.

Nem todas as empresas permitem isso no Mainframe.

E tudo bem.

Em ambientes bancários, normalmente existe uma aprovação humana antes da produção.


Como nasceu o CI/CD?

Nos anos 90, os projetos começaram a ficar enormes.

Cada desenvolvedor trabalhava isoladamente.

Quando chegava a hora de integrar tudo...

Era um verdadeiro pesadelo.

Esse problema ficou conhecido como Integration Hell.

Martin Fowler e outros especialistas passaram a defender integrações frequentes.

Mais tarde, o movimento Agile fortaleceu essa ideia.

Depois veio o DevOps.

E finalmente surgiram pipelines automatizados.

Hoje praticamente toda aplicação moderna utiliza CI/CD.

Inclusive aplicações que executam em IBM Z.


"Mas Mainframe sempre teve automação..."

Essa é uma observação extremamente interessante.

Muito antes de existir Jenkins...

Muito antes de existir GitHub Actions...

Muito antes de existir Azure DevOps...

O Mainframe já possuía automação.

Pense em:

  • JCL

  • PROCs

  • Scheduler

  • CA-7

  • Control-M

  • IBM Workload Scheduler

  • REXX

  • CLIST

Na prática...

O Mainframe já automatizava tarefas quando muitos servidores ainda nem existiam.

O que mudou foi a filosofia.

Antes automatizávamos jobs.

Hoje automatizamos todo o ciclo de desenvolvimento.

Essa diferença muda completamente a produtividade.


O velho processo

Imagine um desenvolvedor COBOL.

Ele altera:

CLIENTE01.CBL

Depois precisa:

  • compilar

  • gerar load

  • atualizar DBRM

  • fazer BIND

  • solicitar implantação

  • enviar documentação

  • abrir chamado

  • esperar aprovação

Cada etapa depende de uma pessoa.

Cada pessoa gera espera.

Cada espera aumenta o tempo.

Cada demora aumenta o custo.


O processo moderno

Agora imagine outra empresa.

O desenvolvedor apenas faz:

git commit
git push

O restante acontece sozinho.

Pipeline:

Compila COBOL

Executa testes

Executa análise estática

Compila DB2

Gera Package

Executa BIND

Publica artefatos

Implanta homologação

Notifica equipe

Solicita aprovação

Produção

O programador continua escrevendo COBOL.

Quem mudou foi o processo.


O Git substitui o Endevor?

Essa é uma das perguntas mais comuns.

Resposta curta:

Depende.

Muitas empresas continuam usando:

  • Endevor

  • Changeman

  • ISPW

Outras utilizam Git integrado.

Algumas usam ambos.

Hoje existem integrações excelentes entre Git e ambientes z/OS.

O importante não é abandonar uma ferramenta.

É automatizar o fluxo.


Como funciona uma pipeline Mainframe?

Uma pipeline normalmente possui etapas bem definidas.

Etapa 1

Receber alteração.

git push

Etapa 2

Executar compilação.

COBOL.

PLI.

Assembler.

Easytrieve.

Natural.


Etapa 3

Executar análise de qualidade.

Exemplo:

  • variáveis não utilizadas

  • SQL incorreto

  • COPY duplicado

  • warnings

  • complexidade


Etapa 4

Executar testes.

Hoje existem ferramentas como:

  • zUnit

  • IBM Test Accelerator

  • Micro Focus Unit Test


Etapa 5

Gerar artefatos.

LOAD MODULE

DBRM

Package

Objetos


Etapa 6

Implantar automaticamente.

Dependendo da empresa:

  • Desenvolvimento

  • Integração

  • Homologação

  • Produção


O que muda para um programador COBOL?

Muita coisa.

Mas não na linguagem.

Na forma de trabalhar.

Antes:

"Funcionou na minha LPAR."

Agora:

"O pipeline precisa aprovar."

Antes:

"O compilador aceitou."

Agora:

"Todos os testes precisam passar."

Antes:

"Eu testei."

Agora:

"O teste automatizado comprovou."

Essa mudança cultural é enorme.


O programador passa a escrever testes

Isso assusta muitos profissionais.

Mas pense da seguinte forma.

Se você altera um cálculo de juros.

Como garante que não quebrou o restante?

Criando testes.

Os testes viram documentação viva.

E principalmente...

Protegem seu código daqui a cinco anos.


Qualidade deixa de ser opcional

Em muitas empresas modernas:

Código com warning...

Não passa.

Cobertura baixa...

Não passa.

Duplicação elevada...

Não passa.

Complexidade excessiva...

Não passa.

O pipeline torna-se um fiscal automático.


O papel do JCL muda?

Não.

Na verdade...

Ele ganha ainda mais importância.

Toda pipeline Mainframe executa JCL.

Compilação.

Link-edit.

BIND.

RUN.

Utility.

IDCAMS.

SORT.

Tudo continua passando pelo bom e velho JCL.

A diferença é que ele agora faz parte de um fluxo automatizado.


Ferramentas comuns

Hoje encontramos diversas soluções.

IBM Dependency Based Build (DBB)

Permite construir aplicações Mainframe utilizando Git e pipelines modernas.


Jenkins

Muito usado para orquestrar pipelines.


GitHub Actions

Integra facilmente repositórios Git.


GitLab CI

Muito utilizado em ambientes híbridos.


Azure DevOps

Cada vez mais presente em grandes empresas.


UrbanCode Deploy

Muito forte para implantação empresarial.


Ansible

Automação de infraestrutura.

Inclusive para IBM Z.


O que exige atenção?

Nem tudo são flores.

Alguns cuidados são fundamentais.

Dependências

Um programa COBOL pode utilizar dezenas de COPYBOOKS.

Uma alteração em COPY pode impactar centenas de programas.

A pipeline precisa descobrir essas dependências.


Ordem de compilação

No mundo distribuído isso costuma ser simples.

No Mainframe nem sempre.

Existem:

COPY

DBRM

BMS

Mapsets

PSB

DBD

Macros

Assembler

Tudo possui ordem correta.


Segurança

Automatizar não significa liberar tudo.

Pipelines precisam utilizar:

RACF

certificados

tokens

controle de acesso

segregação de funções

auditoria


Aprovação

Nem toda implantação deve ser automática.

Em ambientes regulados:

bancos

seguros

governo

saúde

geralmente existe aprovação humana.


Os riscos

Automação ruim automatiza erros.

Se o pipeline estiver incorreto...

O erro será reproduzido centenas de vezes.

Outro risco:

Implantar rapidamente código mal testado.

Velocidade sem qualidade é perigosa.

CI/CD não elimina responsabilidade.

Ele aumenta a responsabilidade.


Um erro clássico

Um desenvolvedor altera um COPYBOOK.

Compila apenas seu programa.

Tudo funciona.

Produção falha.

Por quê?

Porque outros 700 programas dependiam daquele COPY.

Uma pipeline moderna detecta esse impacto automaticamente.


Outro erro clássico

"Vamos automatizar tudo."

Sem documentação.

Sem padronização.

Sem versionamento.

Resultado?

Caos automatizado.

Automação precisa nascer de processos bem definidos.


A evolução do papel do programador

Há vinte anos.

O programador escrevia código.

Hoje ele precisa compreender:

Git

Branches

Merge

Pipeline

Testes

Qualidade

Observabilidade

Versionamento

Entrega

Automação

Isso não significa virar DevOps.

Significa entender o ciclo completo.


Curiosidades

Pouca gente sabe, mas muitos bancos já executam pipelines modernas para COBOL.

Algumas empresas realizam centenas de compilações automáticas diariamente.

Existem ambientes em que um simples Pull Request dispara:

  • compilação COBOL

  • geração de DBRM

  • testes

  • análise de qualidade

  • implantação automática em ambiente de integração

Tudo em poucos minutos.

Algo que antigamente podia consumir vários dias.


CI/CD elimina o analista de produção?

Não.

Ele muda de função.

Em vez de executar tarefas repetitivas.

Passa a administrar pipelines.

Governança.

Qualidade.

Segurança.

Métricas.

Automação.

Seu trabalho torna-se mais estratégico.


Vantagens

Os ganhos são enormes.

  • Menos erros humanos.

  • Entregas menores e mais seguras.

  • Feedback quase imediato.

  • Redução do retrabalho.

  • Maior rastreabilidade.

  • Auditoria facilitada.

  • Padronização dos processos.

  • Menor tempo entre desenvolvimento e produção.

  • Melhor qualidade do software.

  • Maior confiança nas implantações.


E as desvantagens?

Também existem.

  • Curva de aprendizado.

  • Mudança cultural.

  • Investimento inicial.

  • Necessidade de testes automatizados.

  • Dependência de boas práticas.

  • Necessidade de revisão das esteiras existentes.

Empresas que tentam implantar CI/CD apenas comprando ferramentas normalmente fracassam.

O sucesso está na mudança de cultura.


O futuro

A próxima evolução já começou.

Pipelines inteligentes.

IA revisando código COBOL.

Agentes analisando impacto.

Testes sendo gerados automaticamente.

Análise de risco baseada em Machine Learning.

Deploy assistido por Inteligência Artificial.

Tudo isso já está chegando ao IBM Z.

O programador que entender CI/CD hoje estará muito mais preparado para trabalhar com essas tecnologias amanhã.


Conclusão

Durante muito tempo acreditou-se que modernizar o Mainframe significava substituir COBOL.

A realidade mostrou exatamente o contrário.

Os maiores bancos, seguradoras e empresas do mundo continuam confiando no IBM Z para executar suas cargas mais críticas. O que mudou não foi a robustez da plataforma, mas a forma como desenvolvemos, testamos e entregamos software.

CI/CD não é uma moda importada do mundo distribuído. É a evolução natural da automação que o próprio Mainframe sempre cultivou. A diferença é que agora automatizamos toda a jornada do desenvolvimento, desde o primeiro commit até a implantação em produção, com rastreabilidade, testes, segurança e governança.

Para o Programador COBOL Padawan, a maior transformação não está em aprender uma nova linguagem, mas em adotar uma nova mentalidade. Continuará escrevendo PROCEDURE DIVISION, manipulando VSAM, DB2, CICS e JCL, porém trabalhando em equipes colaborativas, utilizando Git, pipelines, testes automatizados e revisão contínua de código.

No fim das contas, o COBOL continua sendo o motor. O CI/CD passa a ser a esteira inteligente que garante que esse motor seja atualizado com segurança, rapidez e qualidade.

Porque no universo do IBM Mainframe, o futuro não pertence a quem escreve mais linhas de código.

Pertence a quem consegue entregar valor ao negócio com confiança, repetibilidade e excelência.

E essa é, talvez, a maior evolução que um verdadeiro Padawan pode aprender.

 


segunda-feira, 23 de maio de 2022

CI/CD: DevOps sem Mistérios para Programadores COBOL

 

Bellacosa Mainframe ci cd em devops sem misterios



☕ Um Café no Bellacosa Mainframe

DevOps sem Mistérios para Programadores COBOL

Como entender CI/CD, Containers, Kubernetes, IaC e DevOps usando exemplos do IBM Z

"Um programador COBOL experiente descobre rapidamente que DevOps não substitui o Mainframe. Ele apenas automatiza aquilo que os grandes bancos já faziam há muitos anos."


Antes de tudo...

Imagine um banco.

Todos os dias existem milhares de programas COBOL sendo alterados.

Imagine fazer isso manualmente.

Editar.

Compilar.

Gerar Load Module.

Fazer BIND.

Atualizar CICS.

Liberar produção.

Executar testes.

Se cada desenvolvedor fizesse isso do seu jeito...

...o banco pararia em poucas horas.

Foi exatamente para resolver esse problema que nasceu o DevOps.

Não para Cloud.

Não para Containers.

Mas para organizar o desenvolvimento.


1 — CI/CD

A imagem mostra:

Código

↓

Build

↓

Testes

↓

Deploy

Parece moderno.

Mas vamos traduzir.

No Mainframe seria algo parecido com:

Editar COBOL

↓

Compile

↓

Link Edit

↓

BIND DB2

↓

Newcopy CICS

↓

Testes

↓

Produção

Percebe?

É praticamente igual.

A diferença é que hoje tudo isso acontece automaticamente.


O que significa CI?

Continuous Integration.

Integração Contínua.

Na prática:

Em vez de esperar um mês para juntar alterações...

...cada alteração é integrada imediatamente.

Imagine cinco programadores.

Cada um altera um programa.

Antigamente:

João altera.

Maria altera.

José altera.

Carlos altera.

Tudo junta sexta-feira.

Sexta-feira...

Nada compila.

Ninguém sabe quem quebrou.

Hoje:

Commit

↓

Compile automático

↓

Teste automático

↓

Se falhar...

ninguém faz Merge.

Muito mais seguro.


No Mainframe

Imagine ISPW.

Imagine Endevor.

Imagine Changeman.

Quando você promove um componente...

Já existe uma pipeline.

Hoje ela apenas ficou mais inteligente.


2 — Container

Essa talvez seja a palavra mais mal compreendida.

Todo mundo fala:

"Container."

Mas...

O que é?

Imagine que você escreveu um programa COBOL.

Ele precisa:

  • Enterprise COBOL

  • LE Runtime

  • Db2 Client

  • MQ

  • Bibliotecas

  • Configuração

  • Certificados

Se você copiar apenas o executável...

Não funciona.

O Container resolve exatamente isso.

Ele empacota tudo.

Programa

+

Bibliotecas

+

Dependências

+

Configuração

+

Runtime

Tudo vira um único pacote.


Analogia Mainframe

Imagine um LOADLIB completo.

Ou uma STEPLIB preparada.

Você leva exatamente o ambiente necessário.

O Container faz isso para Linux.


Por que isso é importante?

Porque elimina:

"Na minha máquina funciona."

Essa frase praticamente desaparece.


3 — Kubernetes

A imagem chama Kubernetes de controlador de tráfego.

Gostei dessa definição.

Imagine um banco.

Existem:

Servidor A

Servidor B

Servidor C

Servidor D

Se um servidor morrer?

Quem percebe?

Quem cria outro?

Quem redistribui usuários?

Quem balanceia carga?

No mundo Cloud:

Kubernetes.


No Mainframe...

Quem faz isso?

Vários componentes.

WLM.

Sysplex.

Coupling Facility.

Dynamic Routing do CICS.

VIPA.

Parallel Sysplex.

Na prática...

IBM resolveu isso muito antes.

Só usou outros nomes.


O Kubernetes faz:

  • escala

  • reinicia

  • monitora

  • distribui

  • atualiza

Tudo sozinho.


4 — Infrastructure as Code (IaC)

Essa talvez seja a maior revolução.

Imagine instalar um servidor manualmente.

Clique.

Clique.

Clique.

Próximo.

Avançar.

OK.

Agora imagine repetir isso cem vezes.

Impossível.

Então surgiu:

Infrastructure as Code.

Em vez de clicar...

Você escreve.

Exemplo simplificado:

Servidor:

Linux

8 CPUs

32 GB

Porta 443

Firewall ativo

Rede privada

Pronto.

Um script cria tudo.


No mundo IBM Z

Isso lembra muito:

JCL.

Pense nisso.

JCL descreve infraestrutura.

Quero executar

este programa

com esta memória

este dataset

esta região

estas bibliotecas

Na essência...

JCL já era Infrastructure as Code.

Décadas antes do termo existir.


5 — Pipeline

Pipeline é uma linha de produção.

Literalmente.

A imagem mostra:

Código

Build

Teste

Scan

Deploy


No banco isso pode virar:

Developer

↓

Git

↓

Compile COBOL

↓

Compile Copybooks

↓

SQL Precompiler

↓

DBRM

↓

Bind

↓

Unit Test

↓

SonarQube

↓

Deploy QA

↓

Deploy Homologação

↓

Deploy Produção

Tudo automático.


Ferramentas comuns

GitHub Actions

GitLab CI

Azure DevOps

Jenkins

Tekton

ArgoCD

UrbanCode Deploy

ISPW

Endevor


6 — Monitoring

Depois que o sistema entra em produção...

Acabou?

Muito pelo contrário.

Começa o trabalho.

Monitoramento significa responder perguntas como:

CPU está alta?

Memória?

Tempo de resposta?

Fila MQ?

Db2?

CICS?

VSAM?

JES2?

SMF?


No IBM Z

Você já conhece muitos monitores.

RMF

OMEGAMON

SMF

SDSF

NetView

Tivoli

Z APM

Instana

Todos fazem exatamente isso.


Sem monitoramento...

Você só descobre o problema quando o cliente liga.


7 — Configuration Management

Esse conceito nasceu porque administradores faziam mudanças manualmente.

Servidor 1:

Java 17

Servidor 2:

Java 11

Servidor 3:

Java 21

Resultado?

Caos.

Ferramentas como:

Ansible

Chef

Puppet

SaltStack

garantem que todos fiquem iguais.


Analogia Mainframe

Pense em PROCLIB.

PARMLIB.

IEASYSxx.

JES2PARM.

RACF.

Tudo precisa permanecer consistente.

A diferença é que hoje isso é automatizado.


8 — CI/CD novamente

A oitava imagem aprofunda o assunto.

Vale destacar uma diferença importante.

Continuous Integration

Sempre compila.

Sempre testa.

Sempre valida.

Mas nem sempre publica.


Continuous Delivery

Tudo pronto.

Apenas alguém aperta:

Deploy.


Continuous Deployment

Nem isso.

Terminou os testes?

Produção automaticamente.


Bancos normalmente fazem:

CI

+

Continuous Delivery

Poucos usam Continuous Deployment completo.

Por razões regulatórias.


9 — IaC novamente

Agora aparecem ferramentas.

Terraform.

CloudFormation.

Pulumi.

Ansible.


Para um programador COBOL

A ideia é simples.

Você não administra servidores.

Você administra código que administra servidores.

É um novo nível de abstração.


10 — DevOps Culture

Essa é provavelmente a imagem mais importante.

Porque DevOps NÃO é ferramenta.

É cultura.

Imagine:

Desenvolvimento culpa Infraestrutura.

Infraestrutura culpa Banco.

Banco culpa Segurança.

Segurança culpa Rede.

Rede culpa Middleware.

Middleware culpa COBOL.

COBOL culpa CICS.

CICS culpa Db2.

Resultado?

Ninguém resolve.

DevOps diz:

Todos são responsáveis.


O objetivo

Eliminar silos.

Criar colaboração.

Automatizar tarefas repetitivas.

Aprender continuamente.

Compartilhar conhecimento.


O que muda para um Programador COBOL Padawan?

Antigamente bastava dominar:

  • COBOL

  • JCL

  • CICS

  • DB2

  • VSAM

Hoje isso continua essencial, mas não é suficiente em muitos projetos de modernização. Um profissional de IBM Z passa a ganhar vantagem competitiva quando também compreende:

  • Git e GitHub

  • GitFlow e Pull Requests

  • Jenkins, GitHub Actions ou Azure DevOps

  • UrbanCode Deploy ou ISPW Pipelines

  • SonarQube para análise estática

  • Docker e conceitos de Containers (mesmo que não execute COBOL dentro deles)

  • Kubernetes e OpenShift para entender onde vivem as APIs modernas

  • Ansible para automação de tarefas no z/OS

  • APIs REST e JSON

  • z/OS Connect Enterprise Edition

  • Observabilidade com Instana, OMEGAMON e OpenTelemetry

  • Segurança integrada com RACF, certificados digitais, OAuth2, JWT e TLS

  • Integração contínua de aplicações COBOL com pipelines automatizadas


A Grande Lição do Mestre

Quando um Padawan olha para CI/CD, Kubernetes, Infrastructure as Code ou DevOps, pode parecer que tudo isso pertence apenas ao mundo Linux e à Cloud. Mas um profissional experiente de IBM Z percebe algo diferente: esses conceitos representam uma evolução natural de princípios que o ecossistema mainframe já aplicava há décadas — padronização, automação, controle de mudanças, alta disponibilidade, rastreabilidade e confiabilidade.

A grande transformação não está em abandonar o COBOL. Está em conectá-lo a um ecossistema moderno de desenvolvimento contínuo, APIs, automação e observabilidade. O futuro do programador COBOL não é escolher entre "mainframe" ou "DevOps"; é dominar ambos e entender como fazer o IBM Z conversar com o restante da arquitetura corporativa.

No fim das contas, DevOps não substitui o conhecimento de um programador COBOL. Ele amplia esse conhecimento, permitindo que aplicações críticas continuem evoluindo com velocidade, segurança e qualidade — exatamente o que os maiores bancos do mundo esperam de seus sistemas mais importantes.





quarta-feira, 19 de fevereiro de 2020

Jenkins - O Que Todo Programador COBOL Padawan Precisa Saber Sobre CI/CD, DevOps, Pipelines, Git, Automação, IBM Z

 

Bellacosa Mainframe apresenta o jenkins

☕ Um Café no Bellacosa Mainframe

Jenkins Muito Além do Botão "Build"

O Que Todo Programador COBOL Padawan Precisa Saber Sobre CI/CD, DevOps, Pipelines, Git, Automação, IBM Z e Como o Jenkins se Tornou o Maestro da Engenharia de Software Moderna

"Compilar um programa é uma tarefa. Automatizar uma empresa inteira é engenharia."


Introdução

Se você começou recentemente sua jornada no universo IBM Mainframe, provavelmente já ouviu alguém dizer algo parecido com:

"Faz um build no Jenkins."

Parece algo simples.

Você altera um programa COBOL.

Faz um git push.

Alguns minutos depois alguém informa:

"O pipeline ficou verde."

Ou então...

"O Jenkins quebrou."

Para quem está começando, tudo isso parece mágica.

Existe um servidor.

Existe um robô.

Existe um botão chamado Build Now.

E, aparentemente, tudo acontece sozinho.

Mas o Jenkins está muito longe de ser apenas um servidor que compila programas.

Na realidade, ele é um dos pilares que sustentam praticamente toda a engenharia moderna de software.

Se o Git organiza o código-fonte, o Jenkins organiza todo o trabalho realizado sobre esse código.

Neste artigo vamos muito além dos conceitos básicos. Vamos entender como o Jenkins nasceu, por que ele revolucionou a indústria, como funciona sua arquitetura, por que ele continua relevante mesmo na era do Kubernetes, GitHub Actions e Inteligência Artificial, e como tudo isso conversa perfeitamente com o universo IBM Z, COBOL, CICS, DB2 e z/OS.

Pegue seu café.

Hoje vamos conversar sobre um dos softwares mais importantes da história da Engenharia de Software.


Antes do Jenkins: a era da integração manual

Imagine um banco em 1998.

A equipe possui:

  • 80 programadores COBOL

  • 20 analistas

  • dezenas de aplicações

  • centenas de programas

Cada desenvolvedor trabalha em sua própria máquina.

Ao final da semana...

Todos entregam seus programas.

Alguém precisa reunir tudo.

Compilar.

Executar testes.

Gerar executáveis.

Mover bibliotecas.

Executar JCLs.

Atualizar CICS.

Publicar em produção.

Tudo manualmente.

Agora imagine o caos.

João alterou o Programa A.

Maria alterou o Programa B.

Carlos modificou um COPY utilizado por ambos.

Quando tudo é compilado junto...

Nada funciona.

Esse problema ficou conhecido como Integration Hell.

Quanto maior a equipe...

Maior o problema.

Era necessário encontrar uma solução.


O nascimento da Integração Contínua

Foi aí que surgiu uma ideia simples.

Ao invés de integrar o código apenas no final do projeto...

Por que não integrar continuamente?

Sempre que alguém fizer uma alteração:

  • compilar automaticamente;

  • executar testes;

  • verificar qualidade;

  • avisar imediatamente se algo deu errado.

Assim nasceu a Continuous Integration (CI).

A integração contínua não é uma ferramenta.

É uma filosofia.

O Jenkins tornou essa filosofia prática.


O que realmente é o Jenkins?

Muita gente responde:

"É uma ferramenta de Build."

Na verdade, isso é apenas uma pequena parte.

O Jenkins é um servidor de automação.

Ele automatiza praticamente qualquer tarefa repetitiva.

Pode:

  • compilar programas

  • executar testes

  • gerar documentação

  • criar containers Docker

  • executar scripts Shell

  • chamar APIs

  • publicar microsserviços

  • disparar Ansible

  • executar Terraform

  • chamar Zowe CLI

  • enviar notificações

  • atualizar ambientes Mainframe

Ou seja...

O Jenkins não entende apenas de software.

Ele entende de processos.


Pense no Jenkins como um maestro

Imagine uma orquestra.

Cada músico conhece apenas seu instrumento.

O maestro coordena todos.

O Jenkins faz exatamente isso.

Ele não precisa saber programar Java.

Nem COBOL.

Nem Python.

Ele apenas coordena.

Git

↓

Compilar

↓

Testar

↓

Analisar qualidade

↓

Criar artefatos

↓

Publicar

↓

Implantar

↓

Monitorar

Cada ferramenta executa sua especialidade.

O Jenkins organiza a sequência.


O Pipeline: a esteira de produção do software

Uma fábrica produz automóveis.

O software moderno produz versões.

Imagine uma linha de montagem.

Chassi

↓

Motor

↓

Pintura

↓

Inspeção

↓

Entrega

Agora substitua por desenvolvimento.

Código

↓

Build

↓

Testes

↓

Qualidade

↓

Deploy

↓

Monitoramento

Esse fluxo recebe o nome de Pipeline.

Pipeline significa literalmente:

tubulação.

Cada etapa entrega seu resultado para a próxima.

Se uma etapa falhar...

Nada continua.


O primeiro passo: Git

Tudo começa no Git.

O desenvolvedor altera um programa COBOL.

CLIENTE.CBL

Executa:

git add .

git commit

git push

Nesse instante acontece algo extremamente importante.

O Git envia um evento.

Esse evento dispara um Webhook.


WebHooks: quem avisa quem?

Um erro comum é imaginar que o Jenkins fica perguntando ao Git:

Mudou?

Mudou?

Mudou?

Isso existia.

Chamava-se Poll SCM.

Hoje o modelo mais moderno é o WebHook.

O GitHub avisa imediatamente:

Recebi um commit.

Pode iniciar o Pipeline.

É mais rápido.

Mais eficiente.

Mais escalável.


Build: muito além de compilar

No universo Java, Build normalmente significa:

.java

↓

.class

↓

.jar

No universo COBOL isso muda bastante.

Um Build pode incluir:

  • compilação COBOL

  • Link-Edit

  • geração do Load Module

  • pré-compilação DB2

  • BIND

  • geração de mapas CICS

  • cópia para bibliotecas

  • atualização de catálogos

Observe que "Build" não é apenas traduzir código.

É transformar código-fonte em algo executável.


Testes: por que eles são indispensáveis?

Imagine um caixa eletrônico.

Você altera apenas uma linha.

Sem testes.

Na segunda-feira...

Nenhum saque funciona.

Por isso o Pipeline executa testes automaticamente.

Existem vários níveis.

  • Unit Test

  • Integration Test

  • Component Test

  • Smoke Test

  • Regression Test

  • Performance Test

  • Security Test

  • Acceptance Test

No universo IBM Z encontramos ferramentas como:

  • IBM ZUnit

  • COBOL Check


SonarQube: o inspetor de qualidade

Compilar não significa qualidade.

Um programa pode compilar perfeitamente e ainda assim possuir:

  • código duplicado

  • vulnerabilidades

  • baixa cobertura de testes

  • alta complexidade

  • más práticas

Ferramentas como SonarQube analisam tudo isso.

Se a qualidade estiver abaixo do padrão...

O Jenkins interrompe o Pipeline.


Continuous Delivery e Continuous Deployment

Esses conceitos costumam gerar confusão.

Continuous Delivery

Tudo acontece automaticamente.

Mas existe aprovação humana antes da produção.

Build

↓

Testes

↓

Deploy QA

↓

Aprovação

↓

Produção

É o modelo predominante em bancos.

Continuous Deployment

Não existe aprovação manual.

Passou em todos os testes?

Vai automaticamente para produção.

Empresas como Netflix, Spotify e Amazon utilizam amplamente essa estratégia para muitos de seus serviços.


Jenkinsfile: Pipeline como Código

Antigamente configurávamos tudo pela interface gráfica.

Hoje utilizamos Pipeline as Code.

Arquivo:

Jenkinsfile

Exemplo simplificado:

pipeline {

    agent any

    stages {

        stage('Build') {
            steps {
                sh 'mvn clean package'
            }
        }

        stage('Test') {
            steps {
                sh 'mvn test'
            }
        }

        stage('Deploy') {
            steps {
                sh './deploy.sh'
            }
        }

    }

}

Esse arquivo também fica versionado no Git.

O Pipeline passa a fazer parte do projeto.


Parametrização: um Pipeline para vários cenários

Imagine quatro ambientes:

  • DEV

  • QA

  • HML

  • PRD

Você poderia criar quatro pipelines.

Ou criar apenas um.

Na execução o Jenkins pergunta:

Qual ambiente?

DEV

QA

HML

PRD

Isso é parametrização.

Também podemos solicitar:

  • número da versão

  • branch

  • Change Request

  • arquivo de entrada

  • descrição da implantação

Um único Pipeline atende dezenas de cenários.


Cron: automação baseada em tempo

Nem todo Build depende de commits.

Às vezes queremos executar tarefas periodicamente.

Por exemplo:

  • backup diário

  • limpeza semanal

  • geração de relatórios

  • sincronização de ambientes

O Jenkins utiliza a sintaxe CRON.

Exemplo:

0 2 * * *

Executa diariamente às duas da manhã.

Outro detalhe interessante é o uso da letra H, exclusiva do Jenkins.

Ela distribui automaticamente os horários dos Jobs, evitando que centenas de pipelines iniciem exatamente no mesmo minuto.


Controller e Agents

As versões antigas utilizavam os termos Master e Slave.

Hoje a nomenclatura oficial é:

  • Controller

  • Agent

O Controller coordena.

Os Agents trabalham.

Imagine um restaurante.

O gerente organiza os pedidos.

Os cozinheiros preparam os pratos.

O gerente não cozinha.

Da mesma forma, o Controller distribui tarefas para diversos Agents.


Por que vários Agents?

Suponha três Builds de 30 minutos.

Sem Agents:

Build A

↓

Build B

↓

Build C

Tempo total:

90 minutos.

Com três Agents:

Todos executam simultaneamente.

Tempo aproximado:

30 minutos.

Essa é a base da escalabilidade.


Labels: enviando o trabalho para a máquina certa

Nem todos os servidores possuem as mesmas ferramentas.

Podemos ter:

  • Linux

  • Windows

  • Docker

  • Kubernetes

  • IBM Z

  • Java

  • .NET

  • COBOL

Os Labels funcionam como etiquetas.

linux

docker

java

ibmz

cobol

Quando o Pipeline precisa compilar COBOL:

agent {
    label 'ibmz'
}

O Jenkins envia automaticamente o trabalho ao Agent correto.


Credenciais: segurança em primeiro lugar

Jamais coloque senhas dentro do Jenkinsfile.

O Jenkins possui um cofre chamado Credentials Store.

Nele podemos armazenar:

  • usuários

  • senhas

  • tokens GitHub

  • chaves SSH

  • certificados

  • chaves privadas

O Pipeline acessa essas informações de forma segura, sem expô-las no código.


Workspaces

Cada execução recebe um diretório exclusivo.

Nele ficam:

  • código baixado do Git

  • arquivos temporários

  • artefatos

  • logs

  • resultados de testes

Ao final da execução o Workspace pode ser limpo automaticamente.

Isso evita conflitos entre Builds.


Plugins: o verdadeiro poder do Jenkins

O Jenkins possui milhares de plugins.

Entre os mais conhecidos estão:

  • Git

  • GitHub

  • Docker

  • Kubernetes

  • SonarQube

  • Slack

  • Teams

  • Ansible

  • Terraform

  • Artifactory

  • Nexus

  • Blue Ocean

  • Pipeline Utility Steps

Essa arquitetura modular explica sua enorme popularidade.


Jenkins e Containers

Hoje muitos Builds acontecem dentro de containers Docker.

Cada execução recebe um ambiente completamente limpo.

Terminou?

O container é destruído.

Isso elimina problemas do tipo:

"Na minha máquina funciona."


Jenkins e Kubernetes

A evolução natural foi integrar o Jenkins ao Kubernetes.

Quando um Build começa:

  • um Pod é criado;

  • o Pipeline executa;

  • o Pod é removido.

O ambiente sempre inicia do zero.

É altamente escalável.


Jenkins no IBM Mainframe

Aqui começa a parte que mais interessa ao Programador COBOL Padawan.

Muitas pessoas acreditam que Jenkins serve apenas para aplicações Java.

Nada poderia estar mais distante da realidade.

Hoje o Jenkins integra perfeitamente o universo IBM Z.

Um Pipeline moderno pode executar:

Git Push

↓

Webhook

↓

Jenkins

↓

Zowe CLI

↓

Upload do Programa COBOL

↓

Compilação

↓

Link-Edit

↓

DB2 BIND

↓

Execução do ZUnit

↓

Análise SonarQube

↓

Deploy para CICS

↓

Smoke Test

↓

Atualização do Endevor

↓

Notificação

Perceba.

O Jenkins não substitui o Mainframe.

Ele conversa com o Mainframe.


DevOps não elimina o Mainframe

Existe um mito de que DevOps pertence apenas ao mundo Linux.

Na realidade, DevOps é uma cultura.

Ela pode ser aplicada em qualquer plataforma.

Inclusive no IBM Z.

Hoje encontramos pipelines automatizando:

  • COBOL

  • PL/I

  • Assembler

  • JCL

  • DB2

  • IMS

  • CICS

  • MQ

  • z/OS Connect

Tudo integrado ao GitHub, GitLab e Azure DevOps.


Inteligência Artificial e Jenkins

Estamos entrando em uma nova fase.

Os modelos de IA auxiliam na geração de código, revisão automática, documentação e testes.

Mas alguém ainda precisa orquestrar todo o processo.

É aí que o Jenkins continua relevante.

Imagine um Pipeline moderno:

Commit

↓

IA revisa Pull Request

↓

Build

↓

Testes

↓

SonarQube

↓

Análise de Segurança

↓

Deploy

↓

Observabilidade

↓

Feedback para IA

A automação não desaparece.

Ela apenas incorpora novas ferramentas.


Conclusão

Quando começamos a estudar Jenkins, é comum enxergá-lo apenas como uma tela com um botão chamado Build Now.

Depois descobrimos os Pipelines.

Mais tarde aprendemos sobre WebHooks, Agents, Labels, Credenciais, Containers, Kubernetes e DevOps.

Finalmente percebemos algo muito maior.

O Jenkins não é apenas uma ferramenta.

Ele é uma plataforma de orquestração da engenharia de software.

Para um Programador COBOL Padawan, compreender esse ecossistema significa deixar de pensar apenas na compilação de programas e começar a enxergar o ciclo completo de vida das aplicações.

O futuro do IBM Mainframe não está em competir com as tecnologias modernas, mas em integrá-las. Git, Jenkins, Zowe CLI, Ansible, APIs REST, testes automatizados, observabilidade e Inteligência Artificial já fazem parte da realidade dos ambientes corporativos que executam aplicações críticas sobre IBM Z.

Dominar Jenkins é compreender que escrever código é apenas o começo. A verdadeira engenharia acontece quando conseguimos transformar esse código em software confiável, testado, rastreável, seguro e entregue continuamente aos usuários. E é justamente nesse ponto que o Jenkins deixa de ser um simples servidor de Build para se tornar o maestro que coordena toda a sinfonia da entrega contínua, conectando o legado robusto do Mainframe às práticas mais modernas da Engenharia de Software.

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