☕ 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 dbb. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta dbb. Mostrar todas as mensagens

quarta-feira, 29 de julho de 2026

O Portal Stargate do IBM Z : Descobre que Git, DevOps e CI/CD Não São Tecnologias Alienígenas.

 

Bellacosa Mainframe e o portal stargata para adentrar no novo mundo do desenvolvimento mainframe

☕ Um Café no Bellacosa Mainframe

O Portal Stargate do IBM Z

Quando um Programador COBOL Descobre que Git, DevOps e CI/CD Não São Tecnologias Alienígenas... São os Endereços para Viajar Entre Galáxias de Software

"Há milhares de anos, os Antigos construíram uma rede capaz de conectar mundos instantaneamente. No século XXI, engenheiros criaram outra rede capaz de conectar milhares de aplicações corporativas espalhadas pelo planeta. Seu nome não é Stargate... é Pipeline DevOps."



Prólogo — O Chevron Número Sete

O relógio marcava 03:27 da madrugada.

No Centro de Processamento de Dados, apenas o z16 permanecia acordado.

Milhões de transações cruzavam seus canais FICON.

Cartões eram autorizados.

PIX eram liquidados.

Voos eram confirmados.

Hospitais consultavam prontuários.

Bolsa de valores processava ordens.

E, em algum lugar daquele universo invisível, um jovem programador COBOL fazia sua primeira alteração em um COPYBOOK.

Ele acreditava que bastava alterar o código.

Mas o veterano apenas sorriu.

— Você ainda acha que um programa vive sozinho...

Naquele instante, uma enorme estrutura metálica começou a girar.

Não era um Stargate.

Era uma Pipeline.

Os chevrons começaram a travar.

Git...

DBB...

GitLab...

Jenkins...

ZUnit...

Deployment...

Produção.

O portal foi ativado.

E a verdadeira aventura começou.



Episódio 1 — O IBM Z é um Planeta

Em Stargate SG-1, cada planeta possui sua própria civilização.

No mundo IBM Z acontece exatamente o mesmo.

Cada ambiente é praticamente um planeta independente.

Desenvolvimento

↓

Integração

↓

Homologação

↓

Pré-Produção

↓

Produção

Cada um possui:

  • regras

  • segurança

  • bases de dados

  • usuários

  • aplicações

  • auditoria

  • monitoramento

Mover software entre esses mundos nunca foi simples.

Durante décadas isso era feito manualmente.

Hoje quem controla os portais é o DevOps.



Episódio 2 — O DHD Chama-se Git

Em Stargate existe um equipamento chamado DHD (Dial Home Device).

Ele controla o portal.

Sem ele, ninguém viaja.

No desenvolvimento moderno existe um equivalente.

Seu nome é Git.

Muitos iniciantes pensam que Git serve apenas para "guardar arquivos".

Isso seria como dizer que o DHD serve apenas para acender luzes.

Git controla praticamente toda a história da aplicação.

Ele registra:

  • quem alterou

  • quando alterou

  • por que alterou

  • quem aprovou

  • qual versão entrou em produção

  • qual versão voltou (rollback)

Cada commit representa um novo endereço gravado na memória do portal.


Curiosidade Bellacosa ☕

Em projetos antigos, a "verdade absoluta" era um PDS ou um Endevor.

Hoje, em arquiteturas modernas, a verdade oficial normalmente reside no repositório Git. Os datasets do z/OS continuam essenciais para compilação e execução, mas o histórico e a colaboração passam a ser organizados pelo controle de versão.


Episódio 3 — A Linguagem dos Antigos

Existe um problema que todo iniciante descobre cedo ou tarde.

Mainframe fala EBCDIC.

O restante do planeta fala ASCII ou UTF-8.

Imagine Daniel Jackson tentando traduzir uma inscrição dos Antigos.

Se errar um símbolo...

Toda a tradução muda.

O mesmo acontece durante uma migração para Git.

Sem conversão correta podemos encontrar situações como:

Antes

AÇÃO

Depois

AÇÃO

Parece pequeno.

Na prática pode causar:

  • conflitos de merge

  • comentários ilegíveis

  • documentação perdida

  • comparações falsas

  • arquivos inutilizados

Por isso existe toda uma estratégia de conversão de code pages.

É um dos assuntos mais importantes do curso.


Episódio 4 — O SGC Chama-se GitLab

No universo Stargate existe o Stargate Command.

É dali que todas as missões são coordenadas.

No DevOps existe um equivalente.

GitLab.

Ele não é apenas um servidor Git.

Ele funciona como uma base operacional.

Ali encontramos:

  • Issues

  • Merge Requests

  • Pipelines

  • Releases

  • Segurança

  • Artefatos

  • Auditoria

Quando um desenvolvedor envia um commit...

É como uma equipe SG retornando de uma missão.

Tudo será analisado.


Episódio 5 — O Iris é a Pipeline

No Stargate existe um Iris.

Ele impede que qualquer coisa atravesse o portal sem autorização.

No DevOps existe um Iris muito parecido.

A Pipeline.

Ela verifica automaticamente:

✔ O código compila?

✔ Os testes passaram?

✔ Existe vulnerabilidade?

✔ O padrão foi respeitado?

✔ Há aprovação?

Se alguma resposta for negativa...

O portal permanece fechado.

Nenhum software chega à produção.


Episódio 6 — Os Asgard Chamam-se DBB

Os Asgard eram extremamente inteligentes.

Criavam tecnologia capaz de resolver problemas gigantescos.

O DBB (Dependency Based Build) faz algo semelhante.

Imagine um banco com:

  • 18.000 programas COBOL

  • 6.000 COPYBOOKS

  • centenas de mapas BMS

  • milhares de JCLs

Você altera apenas um COPYBOOK.

A pergunta é inevitável.

Quem precisa ser recompilado?

Todos?

Claro que não.

O DBB investiga as dependências.

Ele descobre:

Programa A

↓

COPY X

↓

Programa B

↓

Programa C

↓

Programa D

Somente quem realmente depende daquela alteração será recompilado.

Isso economiza:

  • CPU

  • MIPS

  • tempo

  • dinheiro


Easter Egg ☕

Assim como os Asgard dominavam conhecimento acumulado durante milênios, o DBB concentra décadas de experiência em engenharia de build para IBM Z. O verdadeiro "superpoder" não é compilar mais rápido, mas evitar compilar o que não mudou.


Episódio 7 — Thor Apresenta o zAppBuild

O DBB precisa de alguém dizendo como construir a aplicação.

Esse papel pertence ao zAppBuild.

Ele funciona como um roteiro.

Compile

↓

Link

↓

Bind Db2

↓

Package

↓

Deploy

Sem improviso.

Sem dezenas de JCL diferentes.

Tudo padronizado.


Episódio 8 — O Antigo Conhecimento Perdido

Imagine encontrar um programa COBOL criado em 1987.

Ninguém sabe:

  • quem chama

  • quem utiliza

  • quais tabelas acessa

  • quais COPYBOOKS dependem dele

É exatamente aí que entra o ADDI.

Application Discovery and Delivery Intelligence.

Ele funciona como Daniel Jackson.

Escava.

Relaciona.

Traduz.

Reconstrói.

Mostra mapas gigantescos das dependências.

Você finalmente entende uma aplicação criada há quarenta anos.


Episódio 9 — A Equipe SG-1 Chama-se Jenkins

Em Stargate cada missão possui uma equipe.

No DevOps quem coordena diversas missões pode ser o Jenkins.

Ele recebe a ordem.

Executa.

Compila.

Chama scripts.

Executa testes.

Publica resultados.

Tudo automaticamente.

Em muitos ambientes ele trabalha lado a lado com GitLab, Azure DevOps ou outras plataformas de automação.



Episódio 10 — Outros Mundos: Azure e Wazi

O IBM Z já não vive isolado.

Hoje conversa naturalmente com:

  • Azure

  • OpenShift

  • Kubernetes

  • GitHub

  • GitLab

  • APIs REST

  • microsserviços

O Wazi as a Service demonstra exatamente isso.

Você pode desenvolver aplicações IBM Z utilizando ferramentas modernas hospedadas em nuvem.

É como atravessar o Stargate para outro planeta...

Sem abandonar seu idioma.


Episódio 11 — O Campo de Treinamento Tok'ra

Uma civilização não evolui sem treinamento.

Durante muito tempo acreditava-se que COBOL não fazia testes unitários.

Isso mudou.

Com o ZUnit podemos automatizar testes de programas COBOL.

Imagine uma alteração aparentemente simples.

Antes:

Alterar

↓

Compilar

↓

Mandar para homologação

Hoje:

Commit

↓

Build

↓

ZUnit

↓

Resultado

↓

Deploy

Se algum teste falhar...

A missão é cancelada.


Dica do Coronel O'Neill

"Confiar apenas porque compilou é como atravessar um Stargate sem verificar o planeta de destino."

Teste sempre.


Episódio 12 — O Conselho dos Antigos

Chega o momento do Deployment.

Aqui muitos iniciantes imaginam que basta copiar datasets.

Não.

Deployment moderno envolve:

  • empacotamento

  • aprovação

  • auditoria

  • versionamento

  • rollback

  • rastreabilidade

Cada release recebe identidade própria.

Nada entra em produção sem deixar um rastro.


Episódio 13 — As Coordenadas Galácticas (Branches)

Em Stargate cada planeta possui um endereço formado por chevrons.

No Git acontece algo parecido.

Cada branch representa um caminho de desenvolvimento.

main

├── develop

├── release

├── feature

└── hotfix

Cada uma possui finalidade específica.

Misturar tudo seria como discar símbolos aleatórios no Stargate.

Você provavelmente chegaria ao planeta errado.


Episódio 14 — A Cidade Perdida dos Antigos

Muitas empresas possuem aplicações criadas nos anos 1970.

Décadas de evolução.

Milhões de linhas COBOL.

Esses sistemas lembram Atlantis.

Imensos.

Poderosos.

Pouco compreendidos.

Ferramentas como o ADDI ajudam a revelar sua arquitetura, permitindo que equipes modernas façam mudanças com muito mais segurança.


Episódio 15 — O Oráculo da Performance

No fim da jornada surge outro personagem importante.

O APA (Application Performance Analyzer).

Compilar não basta.

Executar também não.

É preciso executar bem.

O APA mostra:

  • consumo de CPU

  • hotspots

  • chamadas excessivas

  • gargalos

  • desperdícios

É como um sensor Asgard analisando cada detalhe de uma nave antes da decolagem.



A Grande Missão DevOps

Quando unimos todas as tecnologias do curso, obtemos uma cadeia contínua de entrega de software:

Programador COBOL
        │
        ▼
 VS Code / IDz
        │
        ▼
      Git
        │
        ▼
 Merge Request
        │
        ▼
 GitLab / Jenkins
        │
        ▼
 DBB + zAppBuild
        │
        ▼
     Build
        │
        ▼
     ZUnit
        │
        ▼
      ADDI
        │
        ▼
  Empacotamento
        │
        ▼
 Deploy Automatizado
        │
        ▼
   CICS • Batch • Db2 • IMS
        │
        ▼
 APA • Monitoramento

Observe como praticamente tudo ocorre de maneira automática. O desenvolvedor continua sendo indispensável, mas passa a dedicar mais tempo ao desenho da solução e menos às tarefas repetitivas.


Passo a Passo para o Iniciante

Se você está começando agora no mundo IBM Z, esta é uma sequência de estudos que faz muito sentido:

  1. Aprenda bem COBOL, JCL, TSO/ISPF e os fundamentos do z/OS.

  2. Entenda VSAM, Db2, CICS e como uma aplicação corporativa é estruturada.

  3. Estude Git profundamente: commits, branches, merge, rebase e revisão de código.

  4. Aprenda conceitos de CI/CD antes de decorar ferramentas específicas.

  5. Conheça DBB e zAppBuild para compreender como builds modernos funcionam.

  6. Estude ZUnit e incorpore testes automatizados desde cedo.

  7. Explore o ADDI para entender impacto de mudanças em aplicações legadas.

  8. Aprenda uma plataforma de orquestração, como GitLab ou Jenkins.

  9. Entenda estratégias de deployment, rollback e versionamento.

  10. Finalmente, aprofunde-se em performance, observabilidade e engenharia de plataformas.

Essa sequência faz com que cada etapa tenha um propósito claro e evita a sensação de aprender tecnologias desconectadas.


Curiosidades que Pouca Gente Conhece

  • O maior desafio de uma pipeline IBM Z normalmente não é compilar COBOL, mas entender corretamente as dependências entre milhares de componentes.

  • Muitos bancos executam centenas ou milhares de pipelines diariamente sem que clientes percebam que há mudanças em produção.

  • Um único COPYBOOK compartilhado pode impactar centenas de programas diferentes.

  • Ferramentas de descoberta de aplicações, como o ADDI, ajudam equipes que nunca participaram do desenvolvimento original a compreender sistemas com décadas de evolução.

  • O movimento Open Mainframe Project acelerou a integração entre tecnologias abertas e o ecossistema IBM Z, aproximando práticas modernas de engenharia de software do ambiente corporativo tradicional.


Conclusão — O Oitavo Chevron

No último episódio de muitas temporadas de Stargate, descobrimos que o verdadeiro objetivo nunca foi apenas atravessar portais.

Era compreender uma rede inteira de civilizações.

O mesmo acontece com o IBM Z.

O programador iniciante costuma acreditar que aprender COBOL é suficiente.

Depois percebe que existe Db2.

Em seguida descobre CICS.

Depois VSAM.

Mais tarde encontra Git.

Pipeline.

DBB.

GitLab.

Jenkins.

ZUnit.

ADDI.

Deployment.

Performance.

Observabilidade.

Cada tecnologia parece um novo planeta.

Mas, pouco a pouco, surge uma revelação: todas fazem parte de uma única galáxia.

O verdadeiro arquiteto não conhece apenas uma linguagem de programação. Ele entende como cada componente conversa com os demais, como uma alteração percorre toda a cadeia de entrega e como manter sistemas que processam bilhões de transações com segurança e previsibilidade.

No fim, o maior portal nunca foi o Stargate.

Foi a mudança de mentalidade.

Quando você deixa de enxergar um simples programa COBOL e passa a visualizar todo o ecossistema que o cerca, o oitavo chevron finalmente trava... e uma nova galáxia de oportunidades se abre diante de você.

Easter Egg Bellacosa: se um dia você ouvir um veterano dizer "o programa compilou, mas a pipeline não deixou passar", lembre-se do Iris do Stargate. O código pode estar pronto para atravessar o portal, mas somente aplicações que sobreviverem a todas as verificações chegam ao destino final: a produção do IBM Z.

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.

sexta-feira, 26 de dezembro de 2025

UrbanCode DBB: Controle de Versionamento no Mainframe, do Jeito Certo


UrbanCode DBB: Controle de Versionamento no Mainframe, do Jeito Certo

Se você já trabalhou em mainframe, sabe que cada linha de código é sagrada. Um erro de versionamento e você pode acordar com todo o departamento olhando para você como se tivesse errado o compilador na sexta-feira à tarde. Foi justamente pensando nisso que nasceu o UrbanCode DBB, o guardião do código COBOL, PL/I, Assembler, JCL e tudo mais que roda em z/OS.


História e Origem

O DBB, que significa Dependency Based Build, começou sua vida nos laboratórios da IBM como uma forma de modernizar o build de aplicações mainframe. A ideia era simples: parar de depender de scripts complicados de JCL e REXX espalhados pelo servidor e criar algo que entendesse as dependências reais do seu código.

Em 2016, o UrbanCode comprou a tecnologia e integrou no seu portfólio de DevOps, transformando o DBB numa peça central para mainframe moderno, pronto para integração com pipelines CI/CD, Git, Jenkins e até o mundo do container e cloud.


Para que serve e por que usar

Imagine o seu sistema legado com dezenas de programas COBOL interdependentes. Alterou um copybook ou uma tabela DB2? Então você precisa recompilar tudo que depende disso, mas somente o que realmente depende. Aqui entra o DBB:

  • Detecção de dependências: Ele analisa seu código e entende as relações entre programas, módulos e copybooks.

  • Build incremental inteligente: Só recompila o que precisa, economizando horas de batch.

  • Integração DevOps: Pode ser chamado por Jenkins, GitLab, UrbanCode Deploy, tornando o mainframe parte do fluxo ágil.

Em resumo: DBB é o cupido do build, unindo o que mudou com o que precisa mudar.

Como usar: dicas práticas

  1. Estrutura de projetos: Organize seu código como projetos, módulos e pacotes. DBB adora clareza.

  2. Dependência declarativa: Marque copybooks, DB2 DDL e includes. Quanto mais informação ele tiver, mais eficiente será o build.

  3. Log e rastreabilidade: Sempre revise os logs. DBB é detalhista — ele te conta cada recompilação que fez.

  4. Pipeline CI/CD: Integre DBB ao Jenkins ou UrbanCode Deploy para builds automáticos e consistentes.

Exemplo básico

Imagine que você tem um programa PAYROLL que depende de EMPLOYEE e SALARY. Se você altera apenas SALARY, DBB identifica que apenas PAYROLL precisa de recompilação, poupando tempo e evitando que outros programas sejam recompilados desnecessariamente.

PROJECT PAYROLL
   MODULE EMPLOYEE
   MODULE SALARY
   MODULE PAYROLL
   DEPENDS_ON SALARY, EMPLOYEE
ENDPROJECT

Simples, mas poderoso.

Curiosidade e Easter Egg

Você sabia que o DBB foi inspirado em técnicas de build usadas em ambientes UNIX? A diferença é que ele traduziu essas ideias para o z/OS, entendendo a complexidade do JCL, copybooks e DB2.

E o easter egg? Se você examinar os logs detalhados, verá pequenos comentários de debug deixados pelos engenheiros: mensagens como "Aqui mora o fantasma do COBOL" ou "Não acorde o compilador antes do café"… só quem vive de batch entende.

Comentários finais

O DBB é um salvavidas para equipes que querem DevOps sem abandonar o mainframe. Ele reduz erros, agiliza deploys e ainda preserva aquela aura mística de que o código mainframe “funciona sozinho, mas precisa de respeito”.

Se você ainda não experimentou, vale a pena. Modernizar builds não é apenas um luxo, é sobre manter a sanidade e ganhar tempo para o café da tarde.

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.

 


terça-feira, 28 de novembro de 2023

☕ DBB e zBuilder: Os Jedi Invisíveis da Modernização IBM Z

 

Bellacosa Mainframe em um visao do dbb e zbuilder

☕ DBB e zBuilder: Os Jedi Invisíveis da Modernização IBM Z   

Quando a Galáxia Fala de IA, OpenShift e APIs, Mas Esquece Quem Realmente Constrói o Sabre de Luz

Por Vagner Bellacosa – Bellacosa Mainframe

Existe uma cena recorrente no universo da tecnologia corporativa contemporânea.

Um executivo sobe ao palco de um grande evento. Atrás dele aparecem imagens futuristas de nuvens híbridas, containers rodando em OpenShift, dashboards coloridos alimentados por Inteligência Artificial Generativa, modelos LLM analisando código COBOL e APIs REST conectando sistemas legados a aplicativos móveis.

A plateia aplaude.

Os fornecedores sorriem.

Os analistas produzem relatórios.

Os CIOs aprovam investimentos milionários.

E, em algum canto silencioso de um datacenter refrigerado, um desenvolvedor COBOL continua aguardando que alguém compile seu programa utilizando um processo criado quando Ronald Reagan ainda era presidente dos Estados Unidos.

Talvez seja exatamente aí que esteja um dos maiores paradoxos da modernização do Mainframe.

Todos querem modernizar aplicações.

Poucos querem modernizar a engenharia que produz essas aplicações.

E talvez seja por isso que IBM Dependency Based Build (DBB) e zBuilder continuem sendo duas das tecnologias mais importantes, poderosas e menos discutidas do ecossistema IBM Z.

A Modernização que o Mercado Enxerga

Quando falamos em transformação digital associada ao Mainframe, normalmente escutamos frases semelhantes a estas:

"Precisamos expor COBOL como APIs."

"Vamos colocar CICS atrás de um API Gateway."

"Devemos integrar IBM Z ao OpenShift."

"Precisamos utilizar IA Generativa para entender programas legados."

"Vamos migrar workloads para a nuvem híbrida."

Tudo isso possui valor.

Tudo isso representa avanços importantes.

Mas existe uma pergunta quase filosófica que raramente aparece nas apresentações corporativas.

Como essas aplicações são construídas hoje?

A resposta costuma ser desconfortável.

Em muitas organizações ainda encontramos processos semelhantes a este:

Desenvolvedor altera programa COBOL.

Salva em um PDS.

Executa compile manual.

Submete JCL.

Espera aprovação.

Abre chamado.

Aguarda CAB.

Equipe operacional promove.

Produção.

Se substituirmos COBOL por Java, Python ou Go, provavelmente qualquer desenvolvedor moderno consideraria esse fluxo algo retirado de um museu de informática.

No entanto, em centenas de empresas ao redor do mundo, essa ainda é a realidade operacional.

Enquanto equipes cloud utilizam GitHub Actions, GitLab Pipelines, ArgoCD, Tekton e GitOps, muitos ambientes z/OS permanecem dependentes de mecanismos desenvolvidos em uma época em que a palavra DevOps sequer existia.

O Mainframe Não Precisa Ser Modernizado. A Engenharia Sim.

Esta talvez seja a primeira provocação importante deste artigo.

O IBM Z já é extremamente moderno.

Executa Linux.

Possui aceleração para IA.

Executa containers.

Suporta APIs.

Possui criptografia embarcada.

Disponibiliza telemetria avançada.

Integra-se com Kubernetes.

Suporta OpenShift.

Conecta-se com praticamente qualquer ecossistema corporativo.

O problema raramente está na plataforma.

O problema está na forma como produzimos software para essa plataforma.

Em outras palavras:

Não basta transformar programas COBOL em APIs.

Precisamos transformar desenvolvedores Mainframe em engenheiros de software do século XXI.

IBM DBB: O Maven que Nasceu em z/OS

IBM Dependency Based Build surgiu justamente para resolver esse problema.

Muitas pessoas imaginam que DBB seja apenas um mecanismo de compilação.

Na prática, ele é muito mais do que isso.

DBB representa uma mudança conceitual profunda.

Historicamente, ambientes Mainframe trabalhavam com builds completos.

Alterou um copybook?

Compila tudo.

Mudou uma tabela?

Compila tudo.

Atualizou uma rotina compartilhada?

Compila tudo.

Imagine um banco contendo dois mil programas COBOL.

Um único COPY chamado CLIENTE é utilizado em mil e duzentos programas.

Uma alteração de dois bytes nesse copybook pode disparar uma compilação massiva.

Horas de processamento.

Centenas de datasets temporários.

JES2 congestionado.

Fila de builds aumentando.

DBB muda completamente essa lógica.

Ele constrói um grafo de dependências.

Algo semelhante ao que Maven, Gradle ou Bazel fazem há anos no mundo distribuído.

O DBB entende que:

CLIENTE

é utilizado por

COB001

COB017

COB105

COB221

COB998

Logo, apenas esses componentes precisam ser recompilados.

O ganho operacional pode ser gigantesco.

Horas podem transformar-se em minutos.

Dias podem transformar-se em horas.

O Encanamento que Ninguém Mostra no LinkedIn

Existe uma razão interessante para DBB receber relativamente pouca atenção.

Ferramentas de build são invisíveis.

Ninguém publica uma foto dizendo:

"Olhem meu maravilhoso sistema hidráulico."

As pessoas mostram a piscina.

Mostram a fachada.

Mostram o jardim.

DBB é o encanamento.

Sem ele, a casa não funciona.

Mas dificilmente aparece na propaganda.

Executivos não compram compiladores.

Executivos compram redução de risco.

Compram velocidade.

Compram governança.

Compram previsibilidade.

Compram auditoria.

Compram produtividade.

DBB entrega exatamente isso.

O Desafio do Groovy

Historicamente, muitas implementações DBB foram construídas utilizando Groovy.

Algo como:

buildProgram("COB001")

compile()

link()

package()

Para equipes acostumadas ao universo z/OS isso pode ser aceitável.

Mas estamos vivendo uma nova era.

A era do Platform Engineering.

E Platform Engineers respiram YAML.

Respiram GitOps.

Respiram Infrastructure as Code.

Respiram Kubernetes.

Respiram ArgoCD.

Respiram Tekton.

Respiram Ansible.

Respiram pipelines declarativos.

Nesse contexto, surge um novo protagonista.

zBuilder: O YAML Desperta na Força

Talvez zBuilder seja uma das iniciativas mais promissoras do ecossistema IBM Z atual.

Sua proposta é elegantemente simples.

Trocar imperatividade por declaratividade.

Trocar scripts complexos por descrições legíveis.

Ao invés de dezenas de linhas em Groovy, podemos imaginar algo semelhante a:

application:

 name: BANKAPP


languages:

 - COBOL
 - PL1
 - JCL



test:

 zunit



deploy:

 cics

Subitamente, o Mainframe começa a falar o mesmo idioma das equipes cloud.

E isso é muito poderoso.

Porque YAML tornou-se praticamente a língua franca da engenharia moderna.

Kubernetes utiliza YAML.

OpenShift utiliza YAML.

GitHub Actions utiliza YAML.

Ansible utiliza YAML.

ArgoCD utiliza YAML.

Crossplane utiliza YAML.

Tekton utiliza YAML.

Terraform possui sintaxe declarativa semelhante.

Platform Engineering gira em torno desse paradigma.

O Surgimento do GitOps Mainframe

Talvez este seja o próximo estágio evolutivo da engenharia IBM Z.

Durante décadas o repositório oficial era um PDS.

Hoje ele pode ser Git.

Antes:

PDS

Compile

Promotion

Agora:

Git

Pull Request

Review

Pipeline

Testes

Security Scan

Deploy

Exatamente igual ao mundo Java.

Exatamente igual ao mundo Python.

Exatamente igual ao universo Go.

Exatamente igual ao desenvolvimento cloud-native.

Isso reduz uma barreira psicológica importante.

O Mainframe deixa de parecer um ambiente exótico.

Passa a parecer apenas mais uma plataforma suportada pelo pipeline corporativo.

DevSecOps Não É Opcional

Durante muitos anos o Mainframe foi considerado seguro por definição.

E, de certa forma, ele realmente é.

RACF.

Criptografia.

Auditoria.

SMF.

Segurança robusta.

Porém, DevSecOps não trata apenas da segurança da plataforma.

Trata da segurança do ciclo de desenvolvimento.

Podemos imaginar pipelines semelhantes a:

Git

DBB

ZUnit

SonarQube

Checkmarx

SBOM

Artifact Repository

Approval

Deploy

Agora COBOL participa das mesmas políticas utilizadas pelo restante da organização.

Existe rastreabilidade.

Existe compliance.

Existe análise estática.

Existe assinatura digital.

Existe inventário de componentes.

Existe governança corporativa.

O Grande Equívoco da Modernização

Talvez o maior erro cometido por algumas organizações seja acreditar que modernização significa abandonar Mainframe.

Na prática, a maior parte dos projetos bem-sucedidos mostra exatamente o oposto.

Modernizar significa aumentar a capacidade de evolução do Mainframe.

Transformá-lo em uma plataforma capaz de competir pela atenção dos novos desenvolvedores.

Se um profissional de vinte e cinco anos consegue utilizar VS Code, GitHub, Pull Request, pipelines automatizados, Zowe, OpenShift e YAML para desenvolver COBOL, a experiência muda completamente.

Ele deixa de enxergar IBM Z como um fóssil tecnológico.

Passa a enxergá-lo como um backend extremamente robusto conectado a práticas modernas.

A Analogia dos Jedi

Talvez DBB e zBuilder possam ser comparados aos técnicos responsáveis por construir os sabres de luz dos Jedi.

Nos filmes, a atenção está sempre voltada para o duelo.

Para a batalha espacial.

Para os poderes da Força.

Pouco se fala sobre os artesãos que produziram as armas.

Mas sem eles não existiria batalha.

Não existiria Ordem Jedi.

Não existiria legado.

DBB e zBuilder desempenham papel semelhante.

Não aparecem em demonstrações de IA.

Não aparecem em apresentações sobre OpenShift.

Não aparecem em propagandas de APIs.

Mas tornam possível algo muito mais importante.

Permitem que a engenharia IBM Z participe plenamente do movimento DevSecOps corporativo.

Considerações Finais

A pergunta original permanece extremamente pertinente.

DBB e zBuilder ainda são subestimados?

Possivelmente sim.

Mas talvez isso esteja começando a mudar.

Estamos observando o surgimento de uma nova geração de profissionais que não deseja apenas integrar Mainframe à nuvem.

Deseja integrar Mainframe à cultura moderna de engenharia.

Quer Git.

Quer pipelines.

Quer automação.

Quer segurança contínua.

Quer observabilidade.

Quer experiência de desenvolvedor.

Quer Platform Engineering.

Quer GitOps.

Quer tratar COBOL exatamente como trata Java, Python ou Go.

Se esse movimento continuar crescendo, talvez daqui a dez anos olhemos para DBB e zBuilder da mesma forma que hoje observamos Git ou Kubernetes.

Ferramentas que inicialmente pareciam apenas componentes técnicos, mas que acabaram redefinindo completamente a maneira como organizações constroem software.

E talvez essa seja a verdadeira modernização do Mainframe.

Não trocar COBOL por outra linguagem.

Não mover aplicações para outro ambiente.

Mas transformar o IBM Z em algo que ele sempre teve potencial para ser:

Uma plataforma de engenharia contínua, capaz de unir a estabilidade de cinquenta anos de missão crítica com a velocidade, automação e governança exigidas pela próxima geração de sistemas corporativos.

Que a Força do Pipeline esteja com vocês.

domingo, 20 de fevereiro de 2022

Ferramentas para Implementar CI/CD no Mainframe

 

Bellacosa Mainframe apresenta ferramentas ci/cd para mainframers

☕ Um Café no Bellacosa Mainframe

Ferramentas para Implementar CI/CD no Mainframe

Do Git ao IBM Z: Construindo uma Esteira Moderna para Aplicações COBOL

"O maior erro de um programador COBOL é imaginar que CI/CD significa apenas instalar Jenkins. O verdadeiro pipeline começa muito antes da primeira ferramenta e termina muito depois do deploy."

Durante muitos anos existiu um mito dentro das equipes de desenvolvimento IBM Z.

O mito dizia que DevOps era coisa de aplicações Java.

Que Docker era para Linux.

Que Git era para desenvolvedores Web.

Que CI/CD não fazia sentido para COBOL.

Enquanto isso, silenciosamente, bancos, seguradoras, bolsas de valores, empresas aéreas e grandes instituições financeiras começaram a automatizar praticamente todo o ciclo de desenvolvimento de aplicações Mainframe.

Hoje, um programa COBOL raramente percorre o caminho entre desenvolvimento e produção apenas pelas mãos de um operador. Em vez disso, ele passa por uma esteira automatizada composta por dezenas de ferramentas responsáveis por versionamento, compilação, análise de qualidade, testes, empacotamento, implantação, monitoramento e auditoria.

Se antigamente o programador entregava apenas um fonte COBOL, hoje ele entrega um conjunto de artefatos que precisam passar por um pipeline inteligente.

Neste café vamos conhecer as principais ferramentas que compõem esse ecossistema moderno.


O quebra-cabeça do CI/CD

Antes de falar de ferramentas, precisamos entender uma verdade importante.

Não existe uma ferramenta chamada CI/CD.

CI/CD é um conjunto de práticas.

Cada ferramenta resolve apenas uma parte do problema.

Imagine uma linha de montagem de automóveis.

Uma máquina solda.

Outra pinta.

Outra instala o motor.

Outra testa os freios.

Nenhuma delas constrói o carro sozinha.

No mundo DevOps acontece exatamente a mesma coisa.


O pipeline moderno

Um pipeline corporativo normalmente possui etapas como:

Git

↓

Merge

↓

Build

↓

Compile

↓

Static Analysis

↓

Unit Test

↓

Integration Test

↓

Artifact

↓

Deploy DEV

↓

Deploy QA

↓

Approval

↓

Deploy Production

↓

Monitoring

Cada etapa pode utilizar uma ferramenta diferente.


Git — O novo PDS do Coboleiro

A primeira ferramenta que todo desenvolvedor precisa conhecer é o Git.

Não importa se você trabalha com COBOL, PL/I, Assembler ou Java.

Sem controle de versões não existe CI/CD.

Git permite:

  • histórico completo;

  • rollback;

  • branches;

  • merge;

  • auditoria;

  • colaboração entre equipes.

Para quem vem do mundo IBM Z, uma boa analogia é pensar que o Git é um grande PDS inteligente que registra todas as alterações feitas em cada membro, preservando versões e identificando exatamente quem modificou cada linha de código.


GitHub, GitLab e Bitbucket

O Git controla versões localmente.

Já GitHub, GitLab e Bitbucket hospedam os repositórios e adicionam funcionalidades colaborativas.

Essas plataformas oferecem:

  • Pull Requests;

  • Code Review;

  • gestão de branches;

  • integração com pipelines;

  • controle de permissões;

  • rastreabilidade.

No dia a dia, um programador COBOL pode alterar um programa, abrir um Pull Request e aguardar a aprovação do líder técnico antes que o código seja integrado à branch principal.


Jenkins — O Maestro da Orquestra

Se o Git armazena o código, quem coordena a esteira?

Uma das respostas mais comuns é o Jenkins.

O Jenkins é um servidor de automação.

Sua função é executar tarefas automaticamente sempre que algum evento ocorre.

Por exemplo:

git push

↓

Executar Build

↓

Compilar

↓

Executar testes

↓

Publicar relatório

↓

Enviar e-mail

↓

Implantar

Para um coboleiro, o Jenkins lembra bastante um agendador de JOBs.

A diferença é que, em vez de executar apenas batchs, ele orquestra toda a cadeia de desenvolvimento.


GitHub Actions

Nos últimos anos, GitHub Actions tornou-se uma excelente alternativa ao Jenkins.

O pipeline fica descrito em arquivos YAML dentro do próprio repositório.

Exemplo simplificado:

Push

↓

Checkout

↓

Build

↓

Test

↓

Deploy

Toda alteração no código pode disparar automaticamente essa sequência.


GitLab CI

Quem utiliza GitLab encontra uma solução semelhante.

O arquivo .gitlab-ci.yml define as etapas do pipeline.

Cada etapa executa scripts específicos.

É uma excelente opção para organizações que desejam manter todo o ciclo DevOps em uma única plataforma.


Docker — O Ambiente que Viaja Junto

Talvez esta seja a ferramenta mais mal compreendida pelos desenvolvedores Mainframe.

Docker normalmente não executa aplicações z/OS.

Ele executa aplicações Linux.

Mas isso não significa que ele esteja distante do IBM Z.

Muito pelo contrário.

Imagine uma aplicação composta por:

  • Front-end React;

  • API Java;

  • Redis;

  • Kafka;

  • PostgreSQL;

  • COBOL no Mainframe.

Durante os testes, Docker pode subir automaticamente todos os componentes distribuídos, permitindo que apenas o Mainframe permaneça como ambiente externo.

Assim, o pipeline consegue validar toda a aplicação antes da entrega.


Easter Egg Bellacosa

Uma Docker Image lembra muito uma PROC catalogada.

Alguém preparou um ambiente padronizado.

Os demais apenas reutilizam.

Da mesma forma que uma PROC encapsula passos JCL reutilizáveis, uma imagem Docker encapsula bibliotecas, ferramentas e configurações.


IBM Dependency Based Build (DBB)

Agora entramos nas ferramentas específicas do mundo IBM Z.

O IBM Dependency Based Build foi criado para automatizar builds de aplicações Mainframe.

Seu grande diferencial é entender dependências entre:

  • programas COBOL;

  • COPYBOOKs;

  • JCLs;

  • BMS;

  • PL/I;

  • Assembler.

Imagine alterar um COPYBOOK.

Em vez de recompilar milhares de programas, o DBB identifica exatamente quais módulos dependem daquele componente.

Isso reduz drasticamente o tempo de build.


IBM Developer for z/OS (IDz)

Durante muitos anos o ISPF foi praticamente o único ambiente de desenvolvimento utilizado por programadores COBOL.

Hoje o IBM Developer for z/OS oferece recursos modernos:

  • edição inteligente;

  • autocomplete;

  • refatoração;

  • integração com Git;

  • depuração;

  • integração com pipelines.

Ele aproxima a experiência do desenvolvedor Mainframe daquela encontrada em IDEs modernas.


Zowe CLI

Poucas ferramentas revolucionaram tanto a integração entre Mainframe e DevOps quanto o Zowe.

O Zowe CLI permite executar comandos z/OS diretamente da linha de comando.

É possível:

  • enviar arquivos;

  • submeter JOBs;

  • consultar JES;

  • baixar datasets;

  • acessar USS;

  • manipular perfis.

Isso transforma o Mainframe em um participante natural dos pipelines modernos.

Um Jenkins pode executar comandos Zowe da mesma forma que executa comandos Linux.


z/OSMF

O z/OS Management Facility disponibiliza serviços REST para administração do ambiente.

Essas APIs permitem:

  • submeter JOBs;

  • consultar status;

  • manipular datasets;

  • automatizar operações.

Isso reduz a necessidade de scripts específicos e facilita a integração com ferramentas DevOps.


IBM UrbanCode Deploy

Quando falamos em implantação controlada, uma ferramenta bastante conhecida é o UrbanCode Deploy.

Ela oferece:

  • versionamento de pacotes;

  • promoção entre ambientes;

  • rollback;

  • aprovações;

  • auditoria;

  • histórico de deploys.

Em bancos, normalmente um pacote percorre DEV → QA → UAT → Produção obedecendo regras rígidas de governança.


SonarQube

Compilar não significa produzir código de qualidade.

É aí que entra o SonarQube.

Ele realiza análise estática identificando:

  • duplicação de código;

  • complexidade excessiva;

  • vulnerabilidades;

  • más práticas;

  • código morto.

No universo COBOL, também ajuda a localizar programas com manutenção difícil, excesso de GO TO ou baixa legibilidade.


Testes Automatizados

CI/CD sem testes automatizados é apenas automação de compilação.

Ferramentas como ZUnit permitem validar programas COBOL automaticamente.

Cada alteração dispara dezenas ou centenas de testes sem intervenção humana.

Isso reduz regressões e aumenta a confiança nas entregas.


Nexus e Artifactory

Após o build surge outra pergunta.

Onde armazenar os artefatos?

Ferramentas como Nexus Repository e JFrog Artifactory centralizam:

  • pacotes;

  • bibliotecas;

  • versões;

  • dependências.

Mesmo quando o artefato final é um LOAD Module, o pipeline pode armazenar documentação, scripts, relatórios e componentes auxiliares.


Ansible

Cada vez mais utilizado em ambientes híbridos.

Permite automatizar:

  • configuração;

  • implantação;

  • execução de comandos;

  • integração entre servidores Linux e Mainframe.

Com coleções específicas para IBM Z, torna-se possível executar tarefas administrativas repetitivas de forma padronizada.


OpenShift

Embora aplicações COBOL normalmente permaneçam no z/OS, muitos componentes modernos são executados em OpenShift.

APIs.

Microsserviços.

Monitoramento.

Dashboards.

Ferramentas de apoio ao pipeline.

Tudo isso pode coexistir com o Mainframe.


Monitoramento

Depois do deploy o trabalho não termina.

Ferramentas como:

  • Grafana;

  • Prometheus;

  • Elastic;

  • Splunk;

  • Dynatrace;

  • Instana.

permitem acompanhar métricas, logs e desempenho.

No IBM Z elas complementam informações provenientes de RMF, SMF e outras soluções tradicionais.


Segurança

Pipelines modernos também verificam:

  • credenciais;

  • certificados;

  • assinaturas;

  • vulnerabilidades;

  • conformidade.

O objetivo é impedir que software inseguro alcance produção.


Como tudo conversa?

Imagine o seguinte fluxo.

Git

↓

GitHub

↓

GitHub Actions

↓

Docker

↓

DBB

↓

Compile COBOL

↓

ZUnit

↓

SonarQube

↓

Artifact

↓

UrbanCode

↓

Produção IBM Z

Cada ferramenta executa apenas sua especialidade.

Juntas, constroem uma esteira extremamente confiável.


O erro mais comum

Muitas empresas acreditam que basta instalar Jenkins.

Não basta.

Sem:

  • versionamento;

  • testes;

  • padronização;

  • documentação;

  • governança;

o pipeline apenas automatiza problemas antigos.

Existe uma frase famosa no mundo DevOps:

"Automatizar um processo ruim apenas faz com que ele falhe mais rápido."


Como escolher as ferramentas?

Não existe resposta única.

Uma empresa pequena pode começar apenas com:

  • Git;

  • GitHub;

  • GitHub Actions;

  • Zowe.

Uma organização maior pode utilizar:

  • GitLab;

  • Jenkins;

  • DBB;

  • SonarQube;

  • UrbanCode;

  • ZUnit;

  • Artifactory;

  • OpenShift;

  • Ansible.

Tudo depende da maturidade do ambiente.


A jornada do Coboleiro Moderno

O desenvolvedor COBOL do futuro continuará escrevendo PROCEDURE DIVISION.

Continuará criando JCL.

Continuará utilizando Db2.

Continuará desenvolvendo CICS.

Mas também precisará compreender conceitos como:

  • Git;

  • Pull Request;

  • Merge;

  • Pipeline;

  • Docker;

  • YAML;

  • Testes Automatizados;

  • Quality Gates;

  • DevSecOps;

  • Observabilidade.

Isso não significa abandonar o Mainframe.

Significa ampliar suas competências.


Conclusão

Durante décadas, o IBM Z foi visto como uma ilha tecnológica, separado do restante da engenharia de software. Hoje essa visão já não corresponde à realidade. As ferramentas modernas de CI/CD demonstram que é possível integrar aplicações COBOL aos mesmos processos de automação, qualidade e governança utilizados no desenvolvimento distribuído, preservando toda a confiabilidade que tornou o Mainframe indispensável para os negócios.

O segredo não está em substituir tecnologias tradicionais, mas em conectá-las de forma inteligente. Git não elimina o conhecimento sobre bibliotecas PDS; Docker não substitui o z/OS; Jenkins não toma o lugar do JES2; Zowe não elimina o ISPF. Cada ferramenta complementa o ambiente e amplia a capacidade de entrega das equipes.

Para o COBOL Jr, dominar esse ecossistema representa uma enorme vantagem competitiva. Ele deixa de ser apenas um programador que compila programas e passa a compreender toda a jornada do software, desde o primeiro commit até o monitoramento da aplicação em produção. Essa visão sistêmica é cada vez mais valorizada em bancos, seguradoras e empresas que executam milhares de transações por segundo no IBM Z.

No universo Bellacosa Mainframe, a mensagem é simples: o COBOL continua sendo o motor dos negócios, mas o CI/CD é a esteira invisível que mantém esse motor evoluindo com velocidade, qualidade e segurança. O profissional que aprender a combinar a robustez do Mainframe com as práticas modernas de DevOps estará preparado para construir a próxima geração de aplicações críticas, onde tradição e inovação caminham lado a lado.


quinta-feira, 2 de dezembro de 2021

🧪 RICK SANCHEZ E O JENKINSFILE DA DIMENSÃO C-137

Bellacosa Mainframe apresenta o jenkins

☕ Um Café no Bellacosa Mainframe

🧪 RICK SANCHEZ E O JENKINSFILE DA DIMENSÃO C-137

Jenkins Pipelines, Git, agentes, artefatos, containers, quality gates, rollback, observabilidade — e o dia em que Rick descobriu que o verdadeiro monstro da produção não era um alienígena, mas um deploy manual de sexta-feira.

Nota de estilo: este artigo usa Rick Sanchez como lente humorística e paródica. A explicação técnica, porém, é bem terrestre — e perigosamente aplicável à produção.



🎬 PRÓLOGO — MORTY, QUEM FEZ DEPLOY DIRETO EM PRODUÇÃO?

Imagine a cena.

03:17 da madrugada.

O celular toca.

Produção caiu.

CICS está respondendo.

Db2 está de pé.

MQ aparentemente está normal.

CPU está em 34%.

Nenhum LPAR está pegando fogo.

Mesmo assim, clientes não conseguem concluir transações.

Rick olha para Morty.

Morty... o que você mudou?

— Nada, Rick!

Morty, todo programador que diz "nada" às 03:17 acabou de alterar alguma coisa.

Cinco minutos depois descobrimos:

Mudança emergencial
      ↓
Compilação manual
      ↓
Load module copiado manualmente
      ↓
Produção
      ↓
"Funcionou aqui"

Rick pega a portal gun.

Não para fugir.

Para mandar o responsável para uma dimensão na qual toda implantação precisa ser feita manualmente pelo resto da eternidade.

E aqui começa nossa história.

Porque Jenkins Pipeline não é simplesmente uma ferramenta para "automatizar compilação".

Estamos falando de algo conceitualmente muito maior:

SOURCE
   ↓
BUILD
   ↓
TEST
   ↓
QUALITY
   ↓
SECURITY
   ↓
PACKAGE
   ↓
APPROVAL
   ↓
DEPLOY
   ↓
VERIFY
   ↓
OBSERVE

O Jenkins ajuda a transformar o processo de entrega do software em software.

A própria documentação do Jenkins define Pipeline como uma maneira de modelar o processo de entrega como código; um Jenkinsfile pode ficar junto ao código-fonte, permitindo revisão, histórico de auditoria e uma fonte comum da definição da pipeline. (Jenkins)

E para quem passou décadas no mainframe existe algo deliciosamente familiar nisso tudo.



🧪 CAPÍTULO 1 — RICK DESCOBRE QUE O JENKINS NÃO FAZ QUASE NADA

Esse é um dos primeiros conceitos que eu ensinaria para alguém começando em DevOps:

Jenkins não é a fábrica. Jenkins é o maestro da fábrica.

O Jenkins não precisa ser o compilador.

Não precisa ser o scanner de vulnerabilidades.

Não precisa ser o repositório Git.

Não precisa ser o repositório de artefatos.

Não precisa ser Kubernetes.

Ele coordena ferramentas que executam essas funções.

Pense:

                    ┌─────────────┐
                    │   JENKINS   │
                    │ ORCHESTRATOR│
                    └──────┬──────┘
                           │
        ┌──────────────────┼──────────────────┐
        ↓                  ↓                  ↓
       Git              Compiler          Tests
        │                  │                  │
        └──────────┬───────┴─────────┬────────┘
                   ↓                 ↓
             Security Scan      Artifact Repo
                   │                 │
                   └────────┬────────┘
                            ↓
                         Deploy
                            ↓
                       Production

Rick provavelmente resumiria:

"Morty, Jenkins não constrói a nave. Ele manda cada idiota da garagem fazer sua parte na ordem certa."

E isso é importante porque muita arquitetura ruim nasce quando Jenkins vira uma espécie de Deus DevOps.

Jenkins chama Docker.

Docker constrói uma imagem.

Jenkins publica a imagem em um registry.

Uma ferramenta de deployment ou Kubernetes executa essa imagem.

São responsabilidades diferentes.



🧠 CAPÍTULO 2 — O JENKINSFILE É O JCL DO DEVOPS?

Calma.

Antes que alguém arremesse um manual do JES2 na minha cabeça:

não tecnicamente.

Mas pedagogicamente a comparação é excelente.

Para um programador COBOL entrando em Jenkins, podemos imaginar:

Mundo mainframeJenkins/DevOps
JOBPipeline
STEPStage/Step
EXECexecução de ferramenta
RCexit status
SYSOUTlogs
load moduleartifact
PROCLIBlógica reutilizável/shared library
schedulerparte da orquestração

Não são equivalências arquitetônicas 1:1.

São pontes mentais.

Veja um JCL:

//BELLACOS JOB ...
//COMPILE EXEC PGM=IGYCRCTL
//LINK    EXEC PGM=IEWL
//TEST    EXEC PGM=TESTPGM

Agora uma pipeline extremamente simplificada:

pipeline {
    agent any

    stages {
        stage('Compile') {
            steps {
                sh './compile.sh'
            }
        }

        stage('Test') {
            steps {
                sh './test.sh'
            }
        }

        stage('Package') {
            steps {
                sh './package.sh'
            }
        }
    }
}

Um mainframer olha isso e pensa:

"Vocês inventaram STEP de novo."

😂

Mas existe uma evolução importantíssima.

O Jenkinsfile pode estar dentro do mesmo repositório Git da aplicação.

Portanto:

programa mudou
pipeline mudou
teste mudou
configuração mudou

Tudo isso pode passar pelo mesmo mecanismo de versionamento e revisão.

O Jenkins recomenda manter o Jenkinsfile no source control, justamente por benefícios como revisão, auditabilidade e uma fonte comum da definição da pipeline. (Jenkins)



🛸 CAPÍTULO 3 — CONTROLLER E AGENTS: RICK NÃO FAZ O TRABALHO PESADO

Imagine Rick administrando cem Mortys.

Rick recebe os pedidos.

Decide prioridades.

Escolhe quem executará cada tarefa.

Coordena tudo.

Mas seria absurdo Rick pessoalmente pegar cada programa, compilar, testar, empacotar e instalar.

No Jenkins existe uma ideia semelhante:

             JENKINS CONTROLLER
                    │
       ┌────────────┼────────────┐
       ↓            ↓            ↓
   AGENT-01     AGENT-02     AGENT-03
    Linux        z/OS         Docker

O controller administra a coordenação.

Os agents fornecem ambientes onde o trabalho efetivamente é executado.

Um agent poderia possuir:

Java
Maven
Git
Docker
Python
Node.js

Outro poderia possuir ferramentas específicas.

No universo IBM Z, podemos ter integração com ferramentas e processos executados no próprio z/OS.

E novamente surge uma analogia útil com mainframe.

JES2 recebe trabalho, gerencia filas e participa da seleção/execução conforme recursos e classes.

Não significa que Jenkins seja "um JES moderno".

Não é.

Mas o conceito de separar orquestração do trabalho de execução do trabalho certamente não provoca choque cultural em quem conhece mainframe.



🧬 CAPÍTULO 4 — O PIPELINE DE PRODUÇÃO NÃO É BUILD → DEPLOY

Essa simplificação é perigosa:

BUILD → DEPLOY

Uma pipeline de produção madura se parece muito mais com:

COMMIT
   ↓
CHECKOUT
   ↓
DEPENDENCY ANALYSIS
   ↓
BUILD
   ↓
UNIT TEST
   ↓
STATIC ANALYSIS
   ↓
SECURITY SCAN
   ↓
QUALITY GATE
   ↓
PACKAGE
   ↓
PUBLISH ARTIFACT
   ↓
DEPLOY DEV
   ↓
INTEGRATION TEST
   ↓
DEPLOY SIT
   ↓
DEPLOY UAT
   ↓
APPROVAL
   ↓
DEPLOY PROD
   ↓
VERIFY
   ↓
OBSERVE

Cada estágio deveria responder a uma pergunta.

Build: conseguimos construir?

Test: o comportamento conhecido continua correto?

Security: introduzimos riscos conhecidos?

Quality Gate: atingimos os critérios mínimos?

Deploy: conseguimos instalar?

Verify: o software realmente iniciou e responde?

Observe: continua saudável sob tráfego real?

É aí que aparece uma das frases mais importantes deste artigo:

🚨 DEPLOY SUCCESS ≠ SYSTEM HEALTHY

Morty vê isto:

DEPLOY ........ SUCCESS

e comemora.

Rick pergunta:

"E as transações?"

Silêncio.


💳 CAPÍTULO 5 — O SISTEMA ESTÁ VERDE, MAS O NEGÓCIO ESTÁ MORTO

Vamos trazer isso para Cards & Payments.

Imagine um programa COBOL:

AUTHORIZATION

Antes do deploy:

Approval Rate: 87%
CICS Response: 120 ms
CPU: 32%
Db2: NORMAL
MQ: NORMAL

Depois:

Approval Rate: 41%
CICS Response: 118 ms
CPU: 31%
Db2: NORMAL
MQ: NORMAL

Dashboard de infraestrutura:

🟢 CPU

🟢 Memória

🟢 CICS

🟢 Db2

🟢 MQ

Dashboard do negócio:

🔥🔥🔥🔥🔥🔥🔥

A aplicação está respondendo perfeitamente...

e recusando clientes perfeitamente.

Isso nos conduz a uma evolução importantíssima de observabilidade:

TECHNICAL HEALTH
        +
BUSINESS HEALTH
        =
PRODUCTION HEALTH

Para uma autorização de cartões poderíamos acompanhar:

approval rate
decline rate
timeout rate
reversal rate
duplicate transactions
average authorization latency
transactions/minute

Isso é infinitamente mais poderoso do que perguntar apenas:

"A JVM está viva?"

Ou:

"O CICS está UP?"


🧪 CAPÍTULO 6 — QUALITY GATES: RICK PROÍBE MORTY DE APERTAR O BOTÃO

Imagine:

Compile       OK
Unit Tests    OK
Coverage      42%
Security      CRITICAL
Quality       FAILED

Morty pergunta:

— Posso mandar para produção?

Rick:

Claro. E depois podemos testar se respirar no espaço sem capacete realmente mata.

Quality Gates transformam regras organizacionais em controles executáveis.

Podemos determinar:

IF compilation failed
    STOP

IF mandatory tests failed
    STOP

IF critical vulnerability exists
    STOP

IF artifact is invalid
    STOP

Isso é fail fast.

Descobriu cedo?

Pare cedo.

Porque existe uma matemática cruel:

erro descoberto no desenvolvimento
        ↓
barato

erro descoberto no teste
        ↓
mais caro

erro descoberto em produção
        ↓
War Room + pizza + café + 03:17

🔐 CAPÍTULO 7 — MORTY COLOCOU A SENHA NO JENKINSFILE

Rick abre o repositório:

environment {
    USER = "PRODADMIN"
    PASSWORD = "Morty123"
}

Silêncio.

Rick olha para Morty.

Morty olha para Rick.

Rick abre o portal.

😂

Segredos não devem ser hardcoded no código da pipeline.

Jenkins oferece mecanismos de credentials que permitem trabalhar com diferentes tipos de segredo e vinculá-los durante a execução. A documentação também alerta para os cuidados necessários com interpolação e exposição acidental em logs. (Jenkins)

Mas existe uma pegadinha.

Mascarar uma senha no log não transforma uma arquitetura insegura em arquitetura segura.

Precisamos combinar:

Secure storage
      +
Least privilege
      +
Credential scope
      +
Log hygiene
      +
Rotation
      +
Access control

Outra distinção importante:

ENVIRONMENT VARIABLE ≠ SECRET

Uma variável de ambiente pode conter um segredo.

Mas isso não significa que qualquer environment variable seja um mecanismo seguro para armazenamento de segredo.


📦 CAPÍTULO 8 — BUILD ONCE, PROMOTE MANY

Aqui aparece uma ideia maravilhosa.

Imagine:

DEV
 ↓
build A

TEST
 ↓
build B

UAT
 ↓
build C

PROD
 ↓
build D

Rick imediatamente perguntaria:

"Então exatamente o que vocês testaram?"

Essa pergunta destrói a arquitetura.

Porque se eu reconstruí o software entre ambientes, existe a possibilidade de diferenças em:

compiler
dependencies
configuration
timestamps
build environment
scripts
libraries

O modelo muito mais forte é:

SOURCE
   ↓
BUILD
   ↓
ARTIFACT X
   ↓
DEV
   ↓
TEST
   ↓
UAT
   ↓
PROD

O mesmo artefato vai sendo promovido.

A documentação atual da IBM para CI/CD em z/OS descreve explicitamente o artifact repository como peça que desacopla SCM dos ambientes de runtime e possibilita a prática de "Build once, deploy many". (IBM)

Agora conseguimos dizer:

APP       AUTHORIZATION
VERSION   4.7.2
COMMIT    a73fc91
BUILD     1842
ARTIFACT  auth-4.7.2-1842

Isso é rastreabilidade.


🧬 CAPÍTULO 9 — MAS COBOL TEM DEPENDÊNCIAS, RICK!

Exatamente.

Imagine:

COPY CARDREC.
COPY AUTHRESP.

O desenvolvedor altera:

CARDREC

Quem precisa ser recompilado?

É justamente aqui que o problema fica interessante no mainframe.

A IBM descreve o Dependency Based Build como solução para aplicações tradicionais z/OS, incluindo COBOL e PL/I, capaz de rastrear dependências e realizar builds integrados a workflows Git e ferramentas como Jenkins. (IBM)

Assim podemos imaginar:

Git commit
     ↓
Jenkins
     ↓
DBB
     ↓
Dependency Analysis
     ↓
Programs impacted
     ↓
Compile
     ↓
Link-edit
     ↓
Test

Em vez de:

"Alterou COPYBOOK? Compila tudo e reza."

A documentação IBM para DevOps em z/OS inclui no conceito de build justamente dependências, compilação, link-edit e testes unitários; ela posiciona DBB como ferramenta principal para essa parte específica do fluxo z/OS. (IBM)


🧙 CAPÍTULO 10 — O PIPELINE COBOL DA DIMENSÃO C-137

Agora podemos construir mentalmente algo muito interessante:

             DEVELOPER
                 │
                 ↓
                Git
                 │
              Webhook
                 │
                 ↓
              Jenkins
                 │
                 ↓
        Dependency Analysis
                 │
                 ↓
             IBM DBB
                 │
       ┌─────────┼─────────┐
       ↓         ↓         ↓
     COBOL      PL/I    Copybooks
       │
       ↓
    Compile
       │
       ↓
   Link-edit
       │
       ↓
   Unit Tests
       │
       ↓
 Static Analysis
       │
       ↓
 Security Gate
       │
       ↓
 Artifact Repository
       │
       ↓
       SIT
       │
       ↓
       UAT
       │
       ↓
 Approval Gate
       │
       ↓
  PRODUCTION
       │
       ↓
 Verification
       │
       ↓
 Observability

Isso não é "tirar o mainframe do passado".

É justamente o contrário.

É integrar IBM Z ao processo corporativo moderno.

A própria orientação IBM sobre DevOps para Z apresenta uma pipeline CI/CD baseada em componentes como serviço Git e DBB, buscando alinhar ferramentas, práticas e resultados com as demais plataformas da empresa. (IBM)


🛑 CAPÍTULO 11 — O BOTÃO VERMELHO CHAMADO APPROVAL

Automação não significa:

ninguém controla nada

Esse é outro mito.

Uma pipeline pode chegar até:

Deploy Production

e parar:

╔══════════════════════════════════════╗
║       PRODUCTION APPROVAL           ║
║                                    ║
║ Tests.................... PASSED    ║
║ Security................. PASSED    ║
║ Quality.................. PASSED    ║
║ Artifact................. SIGNED    ║
║ Change Ticket............ VALID     ║
║                                    ║
║       [ APPROVE ] [ REJECT ]        ║
╚══════════════════════════════════════╝

Isso é especialmente relevante em ambientes regulados.

Governança não precisa significar:

planilha
+
e-mail
+
telefonema
+
reunião
+
"quem tem a senha?"

Governança também pode virar código e evidência.


🚀 CAPÍTULO 12 — ROLLING, BLUE-GREEN E CANARY

Agora Rick abre três portais.

Rolling

Temos:

V1 V1 V1 V1

Vamos substituindo gradualmente:

V2 V1 V1 V1
V2 V2 V1 V1
V2 V2 V2 V1
V2 V2 V2 V2

Útil quando a arquitetura suporta substituição gradual.

Blue-Green

Temos dois ambientes:

BLUE  → V1 → ACTIVE

GREEN → V2 → READY

Testamos Green.

Depois:

TRAFFIC
   ↓
 GREEN

Se houver problema e as condições permitirem retorno:

TRAFFIC
   ↓
 BLUE

Canary

Liberamos V2 para pequena parcela:

95% → V1
 5% → V2

Observamos.

Depois:

75% → V1
25% → V2

Depois:

50 / 50

até eventualmente:

100% → V2

No mainframe, não devemos copiar esses modelos cegamente como se CICS fosse Kubernetes.

Mas princípios semelhantes podem ser implementados, dependendo da arquitetura, usando regiões, roteamento, APIs, gateways, feature flags, LPARs ou segmentação de tráfego.


💥 CAPÍTULO 13 — ROLLBACK NÃO É CTRL+Z

Aqui mora um monstro.

Aplicamos:

PROGRAM V1
       ↓
PROGRAM V2

Deu problema.

Então:

PROGRAM V1

Resolvido?

Talvez.

Agora imagine que V2 também mudou:

COPYBOOK
DB2 SCHEMA
MQ MESSAGE
CONFIGURATION
API CONTRACT
DATA

O programa antigo pode não entender mais o estado atual.

Por exemplo:

V1:
01 CUSTOMER.
   05 ID      PIC 9(08).
   05 STATUS  PIC X.

V2:

01 CUSTOMER.
   05 ID      PIC 9(08).
   05 STATUS  PIC X.
   05 RISK    PIC 9(03).

Dependendo de onde e como esse contrato é utilizado, voltar somente o executável pode criar outro problema.

Portanto:

Rollback é propriedade da arquitetura, não apenas comando da ferramenta de deployment.

Precisamos pensar em:

Code rollback
Data rollback
Schema rollback
Configuration rollback
Infrastructure rollback
Contract compatibility

Rick não inventaria o plano de fuga depois que a dimensão começasse a explodir.

Nós também não deveríamos.


🔥 CAPÍTULO 14 — RETRY NÃO É CURA UNIVERSAL

Pipeline falhou?

Alguém imediatamente propõe:

retry(5)

Rick pergunta:

"Por quê?"

Excelente pergunta.

Retry pode fazer sentido para uma falha transitória:

network timeout
temporary API failure
registry temporarily unavailable

Mas imagine:

COBOL COMPILATION ERROR

Retry.

Erro.

Retry.

Erro.

Retry.

Erro.

Você não criou resiliência.

Criou um computador extremamente persistente em provar cinco vezes que seu código está errado.

😂

Podemos pensar:

TRANSIENT FAILURE
      ↓
    RETRY

DETERMINISTIC FAILURE
      ↓
    INVESTIGATE

🕵️ CAPÍTULO 15 — RICK SANCHEZ VIRA ANALISTA DE ABEND

Pipeline:

FAILED

Isso é praticamente inútil sozinho.

Precisamos perguntar:

Onde?
Quando?
Qual stage?
Qual command?
Qual return code?
Qual agent?
Qual commit?
Qual artifact?
Qual dependency?

É exatamente a disciplina que o mainframer já conhece.

Imagine:

JOB FAILED

Tá.

E daí?

Queremos:

JOB
 ↓
STEP
 ↓
ABEND
 ↓
S0C7
 ↓
PROGRAM
 ↓
OFFSET
 ↓
FIELD
 ↓
RECORD
 ↓
ORIGIN

Ou seja:

SYMPTOM ≠ ROOT CAUSE

Um pipeline maduro precisa fornecer evidência suficiente para transformar:

"deu pau"

em:

Security stage failed
      ↓
dependency scan
      ↓
library X
      ↓
critical vulnerability
      ↓
version Y
      ↓
introduced by commit Z

Isso é investigação.


📊 CAPÍTULO 16 — OBSERVE A PRÓPRIA PIPELINE

Aqui existe um nível acima.

Não monitoramos apenas a aplicação.

Monitoramos a fábrica que produz a aplicação.

Podemos acompanhar:

Pipeline Success Rate
Build Duration
Queue Waiting Time
Deployment Frequency
Failure Rate
Rollback Rate
Mean Recovery Time
Flaky Tests
Agent Utilization
Approval Waiting Time

Imagine:

Checkout .......... 1 min
Build ............. 8 min
Tests ............ 14 min
Security .......... 5 min
Package ........... 2 min
Approval ..........32 min
Deploy ............ 7 min
Verify ............ 5 min

Tempo total:

74 minutos

Qual é o gargalo?

Compilador?

Não.

Jenkins?

Não.

Mainframe?

Não.

32 minutos esperando alguém aprovar.

Agora DevOps deixa de ser conversa sobre ferramenta e começa a revelar problemas do fluxo organizacional.

Isso é poderoso.


🧠 CAPÍTULO 17 — O QUE ESTAMOS REALMENTE VERSIONANDO?

Nos velhos tempos poderíamos pensar:

SOURCE CODE

Hoje estamos caminhando para algo muito maior:

Source Code
+
Build Definition
+
Tests
+
Infrastructure
+
Security Policies
+
Deployment Rules
+
Observability

Ou seja:

Não estamos versionando apenas o programa. Estamos tentando versionar o processo pelo qual esse programa nasce, é validado, autorizado, implantado e observado.

Esse é um dos aspectos mais interessantes de Pipeline as Code.

A documentação Jenkins trata o Jenkinsfile justamente como parte versionável do projeto, enquanto a IBM descreve pipelines z/OS combinando Git, DBB e outros componentes de CI/CD. (Jenkins)


🧓 CAPÍTULO 18 — O MAINFRAMER DE 1985 ENTRA NA GARAGEM DO RICK

Agora vem meu Easter Egg favorito.

Coloque um mainframer veterano diante destas expressões:

Pipeline as Code
Infrastructure as Code
Policy as Code
Immutable Artifact
Return Code
Dependency Management
Automated Scheduling
Audit Trail
Separation of Duties
Repeatable Build

Ele talvez fique alguns segundos em silêncio.

Tome um gole de café.

Olhe para Rick.

E diga:

"Então vocês passaram quarenta anos distribuindo tudo para finalmente descobrir que processos declarativos, controlados, auditáveis, repetíveis e cheios de return codes eram uma boa ideia?"

Rick olha para Morty.

Morty olha para Rick.

E ninguém responde.

☕😂

Naturalmente, mainframe tradicional e DevOps moderno são arquiteturas e ecossistemas profundamente diferentes.

Mas existe uma continuidade filosófica fascinante:

REPETIBILIDADE
CONTROLE
AUTOMAÇÃO
RASTREABILIDADE
EVIDÊNCIA

Isso sempre teve enorme valor em sistemas críticos.


🧪 EPÍLOGO — A PIPELINE NÃO TERMINA NO DEPLOY

Aqui está o erro que eu mais gostaria que um Junior Engineer evitasse.

Pensar:

DEPLOY SUCCESS

          FIM

Não.

Eu redesenharia mentalmente a última página do notebook assim:

                 SOURCE
                    ↓
                   GIT
                    ↓
                 JENKINS
                    ↓
             BUILD + TEST
                    ↓
                SECURITY
                    ↓
              QUALITY GATE
                    ↓
                ARTIFACT
                    ↓
              ENVIRONMENTS
                    ↓
                APPROVAL
                    ↓
               PRODUCTION
                    ↓
                 VERIFY
                    ↓
              OBSERVABILITY
                    ↓
          ┌───────────────────┐
          │ SYSTEM HEALTHY ?  │
          └─────────┬─────────┘
              YES   │   NO
               ↓    │    ↓
             DONE   │ RECOVERY
                    │    ↓
                    │ INVESTIGATION
                    │    ↓
                    │ ROOT CAUSE
                    │    ↓
                    └──→ FIX

Porque entregar software não significa apenas copiar um binário.

Significa conseguir demonstrar:

qual código foi utilizado, qual versão foi construída, quais testes foram executados, quais controles foram satisfeitos, qual artefato foi promovido, quem autorizou a mudança, onde ele foi implantado e o que aconteceu depois que usuários reais começaram a utilizá-lo.

É aí que Jenkins deixa de ser "aquele negócio que roda script".

Torna-se parte de uma cadeia de engenharia.

E quando trazemos isso para IBM Z, COBOL, CICS, Db2, MQ e sistemas de pagamentos, percebemos algo ainda mais interessante: não precisamos jogar fora décadas de disciplina operacional para adotar DevOps.

Podemos fazer justamente o contrário.

Podemos combinar:

DISCIPLINA DO MAINFRAME
          +
AUTOMAÇÃO DEVOPS
          +
PIPELINE AS CODE
          +
OBSERVABILIDADE
          =
ENTREGA MODERNA DE SISTEMAS CRÍTICOS

A documentação IBM atual recomenda uma abordagem CI/CD para z/OS que integra SCM baseado em Git, DBB e ferramentas corporativas de pipeline; DBB, inclusive, integra-se a Jenkins por CLI e suporta aplicações tradicionais COBOL e PL/I. (IBM)

E essa talvez seja a grande lição que Rick deixaria antes de desaparecer pelo portal:

"Morty, qualquer idiota consegue automatizar um deploy. Engenharia é automatizar as evidências de que aquilo deveria ter sido implantado — e saber exatamente como reagir quando não deveria."

☕🧪

No Bellacosa Mainframe, eu resumiria em uma frase ainda mais simples:

A PIPELINE NÃO TERMINA QUANDO O DEPLOY TERMINA.

Ela termina quando temos evidências suficientes de que a versão correta foi construída, testada, autorizada, implantada e continua funcionando corretamente em produção.

E se alguém discordar...

Rick já está carregando a portal gun. 🛸

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