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

quarta-feira, 8 de julho de 2026

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

 

Bellacosa Mainframe e o guia do devops para mainframe

☕ Um Café no Bellacosa Mainframe

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

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

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

"Mainframe não precisa de DevOps."

Ou então:

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

Nada poderia estar mais distante da realidade.

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

A verdade é simples:

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

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

Pegue seu café.

Vamos conversar.


Antes de tudo: o que é DevOps?

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

  • Development (Desenvolvimento)

  • Operations (Operação)

Durante décadas essas equipes trabalharam separadas.

O desenvolvedor escrevia código.

O operador implantava.

O suporte resolvia problemas.

Quando dava errado...

Todo mundo culpava o outro.

DevOps nasceu justamente para eliminar esse conflito.

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


O ciclo tradicional

Durante muitos anos o fluxo era parecido com isto:

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

Tudo manual.

Muito e-mail.

Planilhas.

Checklist.

JCL executado manualmente.

Libraries copiadas.

Muitas chances de erro humano.


O ciclo DevOps

Agora imagine outro cenário.

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

Tudo rastreado.

Tudo versionado.

Tudo auditável.

Esse é o objetivo do DevOps.


DevOps não é uma ferramenta

Este talvez seja o maior erro dos iniciantes.

DevOps não é:

  • Jenkins

  • Git

  • GitHub

  • Azure DevOps

  • GitLab

Essas são ferramentas.

DevOps é uma cultura.

As ferramentas apenas ajudam.


Bellacosa Mainframe e o devops para iniciante mainframe

Os pilares do DevOps

Podemos resumir DevOps em seis grandes pilares.

1. Planejamento

Toda mudança começa aqui.

Exemplo:

  • Nova funcionalidade

  • Correção de bug

  • Mudança legal

  • Novo produto

Ferramentas:

  • Jira

  • Azure Boards

  • Trello

  • ServiceNow


2. Desenvolvimento

Aqui entra o programador COBOL.

Ele escreve código.

Exemplo:

Programa COBOL

+
JCL

+
PROC

+
Copybooks

+
DB2

+
CICS

Tudo precisa ficar versionado.


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

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

O sistema automaticamente:

  • compila

  • executa testes

  • verifica qualidade

  • gera relatórios

Sem intervenção humana.


4. Testes

Não basta compilar.

É necessário testar.

Tipos comuns:

  • teste unitário

  • teste funcional

  • teste integração

  • teste regressão

  • teste performance

No Mainframe isso pode envolver:

  • ZUnit

  • IBM Debug

  • File Manager

  • stubs

  • dados mascarados


5. Deploy

Depois da aprovação:

o sistema promove automaticamente os artefatos entre ambientes.

DEV

↓

QA

↓

HML

↓

PRD

Sem copiar datasets manualmente.


6. Monitoramento

Depois da implantação...

O trabalho continua.

Monitoramos:

  • CPU

  • tempo de resposta

  • erros

  • logs

  • abends

  • consumo

  • throughput


Bellacosa Mainframe e ferramentas para implementar o devops

O famoso CI/CD

Você verá muito essa sigla.

CI

Continuous Integration

CD

Continuous Delivery

ou

Continuous Deployment.

A diferença é simples.

Continuous Delivery

O deploy fica pronto.

Mas alguém aprova.

Continuous Deployment

O deploy acontece automaticamente.


Como isso funciona no Mainframe?

Imagine um programa COBOL.

Você altera uma linha.

Ao salvar:

Git

↓

Pipeline

↓

Compilação

↓

Link-edit

↓

Testes

↓

Deploy

↓

Homologação

Tudo automático.


Ferramentas mais usadas

Vamos conhecer as principais.

Git

O coração do DevOps.

Ele controla versões.

Permite:

  • histórico

  • branches

  • merge

  • rollback

Hoje praticamente todo projeto moderno usa Git.

Inclusive Mainframe.


GitHub

Hospeda repositórios Git.

Possui:

  • Pull Request

  • Code Review

  • Actions

  • Issues

Muito usado em projetos open source.


GitLab

Além do Git...

Possui pipeline integrada.

Muito utilizado em empresas.


Azure DevOps

Muito comum em bancos.

Possui:

  • Boards

  • Repos

  • Pipelines

  • Artifacts

  • Test Plans

Integra muito bem com ambientes corporativos.


Jenkins

Uma das ferramentas de automação mais famosas.

Ele executa:

  • compilação

  • testes

  • deploy

  • scripts

Tudo automaticamente.


IBM Dependency Based Build (DBB)

Ferramenta criada pela IBM para Mainframe.

Ela entende:

  • COBOL

  • PL/I

  • Assembler

  • JCL

  • Copybooks

Excelente para pipelines IBM Z.


IBM Developer for z/OS (IDz)

Substitui boa parte do ISPF.

Integra:

  • Git

  • Debug

  • Build

  • Pipeline


Zowe

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

Permite acessar o Mainframe usando:

  • VS Code

  • APIs

  • CLI

  • Explorer

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


VS Code

Hoje muitos programadores COBOL utilizam VS Code.

Com extensões adequadas é possível:

  • editar COBOL

  • enviar código

  • acessar datasets

  • executar comandos


Ansible

Automação de infraestrutura.

Pode automatizar:

  • configuração

  • deploy

  • instalação

  • tarefas repetitivas


SonarQube

Analisa qualidade do código.

Detecta:

  • duplicação

  • complexidade

  • bugs

  • vulnerabilidades

Inclusive existem plugins para COBOL.


JFrog Artifactory

Gerencia artefatos.

Armazena:

  • builds

  • binários

  • versões


Um pipeline simples

Imagine este fluxo.

Programador

↓

Git Commit

↓

Pipeline

↓

Compilar COBOL

↓

Executar testes

↓

Quality Gate

↓

Deploy DEV

↓

Deploy QA

↓

Deploy HML

↓

Produção

Sem copiar datasets manualmente.

Sem FTP.

Sem e-mail.


Como implantar DevOps em um sistema Mainframe?

Aqui está um roteiro simples.

Etapa 1

Mapeie o processo atual.

Pergunte:

Como o programa chega em produção?

Quem aprova?

Quem compila?

Quem faz bind?

Quem copia load modules?

Quem altera CICS?

Quem agenda o Job?


Etapa 2

Versione tudo.

Não apenas programas COBOL.

Também:

  • JCL

  • PROC

  • Copybooks

  • SQL

  • DDL

  • Scripts

  • Documentação


Etapa 3

Padronize.

Todos devem usar:

Mesmo padrão.

Mesmo fluxo.

Mesmo processo.


Etapa 4

Automatize a compilação.

Em vez de:

Editar

Compilar

Link

Testar

Faça:

Commit

↓

Pipeline

↓

Compilação automática

Etapa 5

Automatize testes.

Quanto mais testes...

Maior a confiança.


Etapa 6

Automatize deploy.

Reduza:

  • intervenção humana

  • erros

  • esquecimentos


Etapa 7

Monitore.

Depois do deploy acompanhe:

  • SMF

  • RMF

  • JES

  • SDSF

  • logs

  • CICS

  • DB2


Roadmap para quem está começando

Nível 1

Aprenda:

  • Git

  • GitHub

  • Branch

  • Merge

  • Pull Request


Nível 2

Aprenda:

  • Jenkins

  • Azure DevOps

  • GitLab CI


Nível 3

Aprenda:

  • Pipeline

  • YAML

  • Build


Nível 4

Aprenda:

  • Zowe CLI

  • VS Code

  • REST APIs


Nível 5

Aprenda:

  • DBB

  • IDz

  • SonarQube


Nível 6

Aprenda:

  • Docker (conceitos)

  • Kubernetes (conceitos)

  • OpenShift

Mesmo trabalhando apenas com Mainframe.


Nível 7

Aprenda observabilidade.

Conheça:

  • Grafana

  • Prometheus

  • Elastic

  • OpenTelemetry

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


Quanto custa implantar?

A resposta depende do ambiente.

Há soluções gratuitas e corporativas.

Gratuitas

  • Git

  • GitHub (planos gratuitos)

  • VS Code

  • Jenkins

  • Zowe

  • SonarQube Community

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

Corporativas

Dependendo da empresa podem existir licenças para:

  • IBM Dependency Based Build

  • IBM Developer for z/OS

  • Azure DevOps

  • GitHub Enterprise

  • GitLab Enterprise

  • JFrog Artifactory

  • UrbanCode Deploy (ou soluções equivalentes)

  • ferramentas de testes automatizados

Além das licenças, considere:

  • infraestrutura

  • treinamento

  • consultoria

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

  • manutenção contínua

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


Quais são os riscos?

Toda mudança traz desafios.

Os principais são:

Resistência cultural

O maior obstáculo raramente é técnico.

É comum ouvir:

"Sempre fizemos assim."

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

Automação mal planejada

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

Primeiro simplifique.

Depois automatize.

Falta de testes

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

Invista em testes desde o início.

Controle de acesso

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

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

Dependência de poucas pessoas

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


As grandes vantagens

Os benefícios aparecem rapidamente.

  • Menos erros manuais.

  • Entregas mais rápidas.

  • Maior rastreabilidade.

  • Rollback simplificado.

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

  • Qualidade de código mais alta.

  • Testes executados com frequência.

  • Auditoria facilitada.

  • Processos padronizados.

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

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

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

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


E as desvantagens?

Nem tudo são flores.

  • Curva de aprendizado inicial.

  • Mudança cultural pode gerar resistência.

  • Necessidade de treinamento.

  • Tempo para configurar pipelines.

  • Investimento em ferramentas corporativas, quando necessário.

  • Ajustes em processos antigos.

  • Necessidade de governança para evitar pipelines desorganizados.

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


Um exemplo prático

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

Sem DevOps:

  1. Desenvolvedor altera o código.

  2. Envia por e-mail.

  3. Outro profissional compila.

  4. Um terceiro faz o BIND.

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

  6. Os testes são executados manualmente.

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

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

Com DevOps:

  1. O desenvolvedor cria uma branch.

  2. Implementa a alteração.

  3. Abre um Pull Request.

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

  5. O pipeline compila automaticamente.

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

  7. A qualidade é validada pelo SonarQube.

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

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

  10. Todo o processo fica registrado para auditoria.

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


Conclusão

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

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

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

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

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

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


quinta-feira, 18 de junho de 2026

Git, GitHub e DevOps para Profissionais IBM Z Por que COBOL Developers, Sysprogs e Sysadmins precisam dominar Git em 2026

 

Bellacosa Mainframe e o Git Github e DevOps para Mainframers

☕🚀 Um Café no Bellacosa Mainframe

Git, GitHub e DevOps para Profissionais IBM Z

Por que COBOL Developers, Sysprogs e Sysadmins precisam dominar Git em 2026

"Deleted your code by mistake? Without Git, it's gone forever."

Confesso que, ao observar aqueles infográficos coloridos sobre Git e DevOps, senti algo curioso.

Em poucos segundos eles conseguiram condensar uma transformação tecnológica que levou quase quarenta anos para acontecer.

Para muitos jovens desenvolvedores, Git sempre existiu.

Para nós, veteranos do Mainframe, sabemos que não foi assim.

Nós vivemos outra realidade.

Vivemos a era dos datasets PDS.

Vivemos a era dos backups manuais.

Vivemos a era do Panvalet.

Do Librarian.

Do Endevor.

Do Changeman.

Do SCLM.

Do ISPW.

Do membro COBOL001.

Do COBOL001.BKP.

Do COBOL001.OLD.

Do COBOL001.TESTE.

Do COBOL001.NOVO.

Do COBOL001.NOVO2.

Do COBOL001.NOVO3.

E, inevitavelmente, do lendário:

COBOL001.FINAL

COBOL001.FINAL2

COBOL001.FINAL_DEFINITIVO

COBOL001.FINAL_DEFINITIVO_OK

COBOL001.AGORA_VAI

Parece piada.

Mas muitos de nós trabalhamos exatamente dessa maneira.

E foi justamente para resolver esse caos que surgiu uma das ferramentas mais importantes da história da Engenharia de Software.

Git.

E não estou exagerando.

Git talvez seja tão revolucionário para o desenvolvimento moderno quanto o JES2 foi para processamento batch, quanto o CICS foi para processamento online ou quanto o DB2 foi para persistência transacional.

Git mudou a maneira como produzimos software.

Bellacosa Mainframe e a evolucao da gestao dos fontes

A primeira geração do controle de versões

Antes do Git existiam várias abordagens.

RCS.

SCCS.

CVS.

Visual SourceSafe.

Subversion.

ClearCase.

Perforce.

Cada um tentou resolver o mesmo problema.

Como permitir que múltiplas pessoas trabalhem no mesmo código sem destruir o trabalho umas das outras?

No Mainframe, resolvemos isso de forma diferente.

Panvalet.

Librarian.

Endevor.

ISPW.

Changeman.

Essas ferramentas foram brilhantes.

E continuam sendo.

Especialmente em ambientes regulados.

Bancos.

Seguradoras.

Governo.

Utilities.

Mas havia uma diferença.

Grande parte delas era centralizada.

Tudo dependia de um servidor.

Git mudou isso.

Git é distribuído.

E isso altera completamente a arquitetura do desenvolvimento.

O que realmente é Git?

A maioria dos cursos ensina:

Git é um sistema de versionamento.

Tecnicamente está correto.

Mas é uma definição pobre.

Git é muito mais.

Git é um banco de dados.

Git é uma máquina do tempo.

Git é um mecanismo de auditoria.

Git é uma ferramenta de colaboração.

Git é um sistema de rastreabilidade.

Git é um gatilho para automação.

Git é praticamente o sistema nervoso central do DevOps moderno.

Cada commit registra:

Quem alterou.

Quando alterou.

Por que alterou.

Qual requisito atendeu.

Qual incidente corrigiu.

Qual sprint participou.

Qual história de usuário foi implementada.

Qual vulnerabilidade foi mitigada.

Git não apenas salva arquivos.

Git preserva conhecimento organizacional.

O segredo escondido do Git

Poucos profissionais conhecem sua arquitetura interna.

Git não armazena arquivos.

Git armazena objetos.

Blob.

Tree.

Commit.

Tag.

Blob representa dados.

Tree representa diretórios.

Commit representa estados.

Tag representa marcos.

Cada commit possui um hash.

Durante muitos anos SHA-1.

Hoje caminhando para SHA-256.

Um commit não é uma diferença.

Ele é uma fotografia completa.

Um snapshot.

É por isso que Git consegue voltar meses no passado.

Como um SMF para código-fonte.

Aliás...

Talvez essa seja a analogia perfeita para um sysprog.

Git é quase um SMF de desenvolvimento.

Cada alteração gera um registro permanente.

O Sysprog e o Git

Talvez alguns sysprogs pensem:

"Mas Git é coisa de desenvolvedor."

Não.

Não mais.

Hoje praticamente toda infraestrutura está migrando para Infrastructure as Code.

Parmlibs.

Policies.

WLM.

NetView.

SA z/OS.

Ansible.

Terraform.

Scripts REXX.

Procedures.

JCL.

USS scripts.

Tudo pode estar em Git.

Imagine uma alteração em uma política WLM.

Antigamente:

Editar.

Salvar.

Copiar.

Torcer.

Hoje:

Criar branch.

Modificar.

Commit.

PR.

Review.

Merge.

Deploy automatizado.

Rollback imediato.

A governança melhora absurdamente.

O Sysadmin moderno também virou desenvolvedor

Existe uma transformação interessante acontecendo.

Sysadmins estão programando.

Desenvolvedores estão automatizando infraestrutura.

DBAs escrevem pipelines.

Sysprogs utilizam APIs REST.

Todos começam a convergir.

A linha entre operações e desenvolvimento desaparece.

Foi exatamente isso que criou DevOps.

DevOps não é ferramenta

Essa talvez seja a maior confusão do mercado.

DevOps não é Jenkins.

Não é GitHub.

Não é Kubernetes.

Não é Docker.

Não é Ansible.

DevOps é cultura.

É reduzir silos.

Eliminar burocracias.

Aproximar pessoas.

Automatizar processos.

Aumentar feedback.

Reduzir tempo de entrega.

No Mainframe isso é extremamente relevante.

Porque o Mainframe sempre teve uma cultura muito compartimentalizada.

Equipe COBOL.

Equipe DB2.

Equipe CICS.

Equipe Storage.

Equipe RACF.

Equipe Sysprog.

Equipe Operações.

Equipe Middleware.

Equipe Rede.

Equipe Segurança.

DevOps propõe outra visão.

Todos trabalham pelo mesmo objetivo.

Entregar valor ao negócio.

GitHub não é Git

Muitos iniciantes confundem.

Git é tecnologia.

GitHub é plataforma.

GitLab é plataforma.

Bitbucket é plataforma.

Azure DevOps é plataforma.

Git continua sendo Git.

Independentemente da hospedagem.

GitHub adicionou uma camada extremamente poderosa.

Issues.

Actions.

Codespaces.

Security.

Dependabot.

Packages.

Container Registry.

Wiki.

Pull Requests.

Tudo integrado.

Pull Request: a maior revolução social do desenvolvimento

Eu particularmente considero Pull Request uma das melhores invenções da engenharia moderna.

Porque ela resolve algo difícil.

Compartilhar conhecimento.

Imagine um desenvolvedor COBOL júnior.

Ele escreve:

MOVE WS-CPF TO WS-TEMP

Um desenvolvedor sênior comenta:

"Poderíamos validar antes."

Outro comenta:

"Talvez usar EVALUATE seja melhor."

Outro:

"Precisamos mascarar LGPD."

Resultado?

O código melhora.

O profissional melhora.

A equipe melhora.

A empresa melhora.

PR é mentoria embutida.

O medo do merge conflict

Todo desenvolvedor já sentiu frio na barriga.

git pull

CONFLICT

Automatic merge failed.

Para iniciantes parece um desastre.

Para equipes maduras é rotina.

Conflitos indicam colaboração.

Duas pessoas trabalharam na mesma área.

Git apenas pede ajuda.

Ele não consegue decidir sozinho.

Você decide.

Git apenas documenta.

Git Flow versus GitHub Flow

Durante anos utilizamos Git Flow.

Main.

Develop.

Feature.

Release.

Hotfix.

Funciona muito bem.

Especialmente em bancos.

Porém empresas modernas começaram simplificar.

GitHub Flow.

Main.

Feature.

PR.

Merge.

Deploy.

Google foi além.

Trunk Based Development.

Branches curtíssimas.

Commits pequenos.

Integração contínua.

Menos divergência.

Menos conflitos.

Mais velocidade.

Git para COBOL Developers

Aqui entramos em um ponto fascinante.

Durante muito tempo dizia-se:

COBOL não combina com Git.

Hoje isso é completamente falso.

IBM DBB.

IBM Dependency Based Build.

zAppBuild.

Z Open Editor.

Rocket Git.

Git Integration for Endevor.

ISPW Git Integration.

IDz.

Wazi Developer.

VS Code.

Tudo isso mudou o cenário.

Hoje um desenvolvedor COBOL pode trabalhar assim.

Abrir VS Code.

Editar programa COBOL.

Executar testes.

Commit.

Push.

Criar PR.

Executar pipeline.

Compilar.

Linkedit.

DB2 Bind.

Newcopy CICS.

Deploy.

Exatamente como Java.

Exatamente como Python.

Exatamente como Node.

Jenkins: o operador automático

Se Git é o cérebro.

Jenkins é o operador.

Ele observa commits.

Dispara builds.

Executa testes.

Compila COBOL.

Gera relatórios.

Aciona SonarQube.

Publica artefatos.

Executa deploy.

Notifica equipes.

No fundo, Jenkins faz o papel que muitos operadores humanos executavam.

Só que 24 horas por dia.

Sem esquecer etapas.

Sem distrações.

GitOps: talvez a próxima revolução

GitOps é simples.

Tudo é Git.

Deseja mudar um cluster Kubernetes?

Commit.

Deseja alterar firewall?

Commit.

Deseja atualizar pipeline?

Commit.

Deseja modificar política?

Commit.

Git torna-se a fonte única da verdade.

Single Source of Truth.

Isso é extremamente poderoso.

Porque elimina configurações manuais.

Elimina servidores "snowflake".

Elimina ambientes misteriosos.

Tudo fica reproduzível.

E a segurança?

Segurança também mudou.

DevSecOps nasceu justamente aqui.

SAST.

DAST.

Dependency Scan.

Secrets Detection.

SBOM.

Tudo integrado ao pipeline.

O desenvolvedor faz commit.

Ferramentas verificam.

Bibliotecas vulneráveis.

Credenciais expostas.

Falhas conhecidas.

Antes de chegar em produção.

No Mainframe isso pode incluir:

RACF reviews.

JCL analysis.

CICS security checks.

DB2 privilege validation.

SMF auditing.

O papel do Sysprog em 2026

Antigamente o Sysprog era apenas administrador.

Hoje é arquiteto.

Automatizador.

Consultor.

Especialista em APIs.

Especialista em observabilidade.

Especialista em pipelines.

Especialista em integração.

Especialista em segurança.

Sysprog moderno entende:

Git.

GitHub.

GitLab.

Ansible.

Python.

REXX.

Jenkins.

OpenShift.

Containers.

z/OSMF.

Zowe.

REST APIs.

Porque o Mainframe deixou de ser uma ilha.

Ele tornou-se parte do ecossistema corporativo.

O novo profissional IBM Z

Acredito que o profissional IBM Z de maior valor em 2026 possui uma característica interessante.

Ele pensa como um desenvolvedor.

Age como um administrador.

Automatiza como um engenheiro DevOps.

Protege como um especialista em segurança.

E governa como um arquiteto.

Ele consegue conversar com:

Desenvolvedor Java.

Equipe Cloud.

Kubernetes.

Segurança.

Storage.

Networking.

Data Science.

IA.

Sem abandonar aquilo que torna o Mainframe único.

Confiabilidade.

Escalabilidade.

Disponibilidade.

Integridade transacional.

Processamento massivo.

Pensando durante o café

Talvez a grande mensagem escondida por trás daqueles simpáticos desenhos coloridos seja esta:

Git não substitui o conhecimento Mainframe.

Git potencializa o conhecimento Mainframe.

Ele não aposenta COBOL.

Ele amplia o alcance do COBOL.

Ele não elimina o Sysprog.

Ele transforma o Sysprog em um engenheiro de plataforma.

Ele não mata operações.

Ele automatiza operações repetitivas.

A próxima geração de profissionais IBM Z provavelmente não conhecerá Panvalet.

Talvez nunca utilize Librarian.

Possivelmente jamais veja um Changeman clássico.

Mas certamente abrirá um Pull Request.

Criará uma branch.

Executará uma pipeline.

Fará deploy automatizado.

E continuará processando bilhões de transações por dia em um IBM Z.

Porque, no final das contas, o objetivo nunca foi Git.

Nunca foi GitHub.

Nunca foi Jenkins.

Nunca foi Kubernetes.

O objetivo sempre foi o mesmo desde os tempos do System/360.

Entregar software confiável.

Mais rápido.

Mais seguro.

Mais auditável.

Mais sustentável.

E, se possível, com uma boa xícara de café ao lado do teclado 3270.

segunda-feira, 8 de junho de 2026

IBM COBOL Check: A Ferramenta Que Trouxe Testes Unitários Modernos Para o Mundo do Mainframe

 

Bellacosa Mainframe e o IBM Cobol Check

☕💣🚀 OPERADOR, O COBOL GANHOU UM JUNIT!

IBM COBOL Check: A Ferramenta Que Trouxe Testes Unitários Modernos Para o Mundo do Mainframe

Se você trabalhou anos com COBOL, provavelmente já viveu esta situação:

Altera o programa
↓
Compila
↓
Executa o JCL
↓
Espera o batch
↓
Confere SYSOUT
↓
Descobre erro
↓
Volta para o início

Durante décadas essa foi a rotina natural do desenvolvedor Mainframe.

Enquanto isso, no mundo Java, C#, Python e JavaScript, os programadores criavam centenas de testes automatizados que validavam cada função antes mesmo do deploy.

Então surgiu uma pergunta:

"Por que COBOL não pode fazer o mesmo?"

Foi exatamente dessa necessidade que nasceu o COBOL Check.


O Que é o IBM COBOL Check?

O COBOL Check é um framework de testes unitários para COBOL inspirado diretamente em ferramentas como:

  • JUnit (Java)

  • NUnit (.NET)

  • PyTest (Python)

  • RSpec (Ruby)

Seu objetivo é permitir que desenvolvedores criem testes automatizados para programas COBOL de forma granular, validando regras de negócio sem depender de execuções batch completas. (GitHub)

Na prática, ele permite testar:

  • Parágrafos

  • Seções

  • Regras de negócio

  • Cálculos

  • Validações

  • Programas inteiros

Tudo de forma automatizada.


Quem Criou o COBOL Check?

Muita gente pensa que é um produto comercial da IBM.

Na realidade, o COBOL Check nasceu dentro do ecossistema do Open Mainframe Project, com apoio da comunidade Mainframe moderna e contribuições de empresas que utilizam COBOL em larga escala. (GitHub)

Seu propósito era resolver um problema antigo:

Como fazer microtestes em aplicações COBOL do mesmo modo que fazemos em Java?


Quando Foi Lançado?

O projeto apareceu publicamente no final da década de 2010 dentro do movimento de modernização DevOps para IBM Z.

Ele surgiu durante a onda de iniciativas Open Source voltadas ao Mainframe, juntamente com projetos como:

  • Zowe

  • IBM Z Open Editor

  • DBB

  • Galasa

e rapidamente ganhou destaque por trazer testes unitários para COBOL de forma simples. (GitHub)


O Problema Que Ele Resolve

Imagine um programa bancário.

CALCULA-JUROS.
    COMPUTE JUROS =
       SALDO * TAXA.

Sem testes unitários você normalmente:

  1. Compila.

  2. Executa JCL.

  3. Alimenta arquivos.

  4. Analisa relatórios.

  5. Verifica resultados.

Tudo isso para validar uma única regra.

Com COBOL Check você cria um teste automatizado.


A Grande Ideia

O conceito é exatamente o mesmo do JUnit.

Você cria:

Código

CALCULA-DESCONTO.

Teste

TEST-DESCONTO.

Execução

PASS

ou

FAIL

Simples assim.


Como Funciona Internamente?

O COBOL Check cria um ambiente de teste que:

  • Executa trechos específicos do programa

  • Injeta dados de entrada

  • Compara resultados

  • Gera relatórios

Ele também oferece suporte para:

  • Assertions

  • Stubs

  • Mocks

  • Verificação de chamadas

  • Relatórios JUnit XML

  • Relatórios HTML (GitHub)

Isso o aproxima bastante dos frameworks modernos.


Sistemas Suportados

O foco principal é:

IBM z/OS

Utilizando:

  • Enterprise COBOL

  • JCL

  • Ambientes tradicionais de produção

Também pode ser utilizado em ambientes modernos ligados ao ecossistema Open Mainframe.


Dependências

Uma instalação típica envolve:

Compilador COBOL

Normalmente:

  • Enterprise COBOL V5+

  • Enterprise COBOL V6+

Ambiente z/OS

  • TSO

  • ISPF

  • USS (quando aplicável)

Ferramentas modernas

Frequentemente combinado com:


Como Instalar

O processo varia conforme a empresa.

Em geral:

1. Obter o projeto

Disponível através do repositório oficial do Open Mainframe Project. (GitHub)

2. Fazer upload

Copiar os fontes para datasets do ambiente.

Exemplo:

USER.COBOLCHECK.SOURCE

3. Compilar

Executar os jobs de instalação.

//COMPILE EXEC IGYWCL

4. Configurar bibliotecas

Adicionar:

STEPLIB
SYSLIB
COPYLIB

5. Validar instalação

Executar os exemplos fornecidos.


Primeiro Exemplo Passo a Passo

Vamos criar algo simples.


Programa

IDENTIFICATION DIVISION.
PROGRAM-ID. CALC01.

WORKING-STORAGE SECTION.
01 WS-VALOR PIC 9(5).
01 WS-DESCONTO PIC 9(5).

PROCEDURE DIVISION.

    COMPUTE WS-DESCONTO =
       WS-VALOR * 10 / 100.

    GOBACK.

Cenário de Teste

Queremos provar que:

1000 = 100 de desconto

Caso de Teste

MOVE 1000 TO WS-VALOR

PERFORM CALCULO

ASSERT WS-DESCONTO = 100

Resultado

TESTE 001
PASS

Testando Múltiplos Cenários

Você pode criar vários testes.

Caso 1

1000 -> 100

Caso 2

2000 -> 200

Caso 3

5000 -> 500

Resultado:

3 TESTS
3 PASSED

Assertions

Uma das partes mais importantes.

Exemplo:

ASSERT TRUE
ASSERT FALSE
ASSERT EQUAL
ASSERT NOT EQUAL

Muito parecido com:

assertEquals()
assertTrue()
assertFalse()

Mocks

Outro recurso extremamente poderoso.

Imagine um programa que acessa:

DB2
VSAM
IMS
MQ

Você não quer depender desses recursos durante o teste.

Então cria um Mock.


Exemplo Conceitual

Produção:

READ CLIENTE

Teste:

MOCK CLIENTE

Resultado:

CLIENTE SIMULADO

Sem acessar banco real.


Stubs

Parecido com Mock.

Você substitui componentes complexos por versões simplificadas.

Exemplo:

CONSULTA-SERASA

vira

CONSULTA-SERASA-STUB

Permitindo testes rápidos.


Relatórios

Após executar os testes você pode gerar:

HTML

PASS
FAIL
TOTAL

XML

Formato compatível com:

  • Jenkins

  • GitHub Actions

  • Azure DevOps

  • GitLab CI/CD (GitHub)


Integração com Jenkins

Fluxo clássico:

Git Commit
      ↓
Build
      ↓
COBOL Check
      ↓
Relatório
      ↓
Deploy

Se um teste falhar:

BUILD FAILED

Sem deploy.


Integração com Git

Imagine:

Pull Request

Antes da aprovação:

Executar COBOL Check

Resultado:

Todos os testes passaram

Só então ocorre o merge.


Benefícios Para Bancos

Os maiores usuários são:

  • Bancos

  • Seguradoras

  • Telecom

  • Governo

Porque possuem milhões de linhas COBOL.

Alterar uma linha sem proteção pode gerar:

S0C7
Abends
Valores incorretos
Erros financeiros

O COBOL Check reduz drasticamente esse risco.


Curiosidade #1

Muitos programadores COBOL experientes inicialmente desconfiaram da ideia.

A reação típica era:

"Teste unitário é coisa de Java."

Hoje isso mudou completamente.


Curiosidade #2

O projeto nasceu justamente porque ferramentas comerciais existentes geralmente testavam programas inteiros, mas não permitiam testar pequenos blocos de lógica com granularidade suficiente. (GitHub)


Curiosidade #3

Uma das metas do COBOL Check era incentivar melhores práticas de desenvolvimento, como:

  • Separação de responsabilidades

  • Modularização

  • Refatoração segura

Conceitos já populares no mundo Java. (GitHub)


Dicas de Ouro

Dica 1

Comece pelos cálculos.

São os testes mais fáceis.


Dica 2

Não tente cobrir o sistema inteiro.

Comece pelos módulos críticos.


Dica 3

Automatize tudo.

Teste manual não escala.


Dica 4

Integre com Jenkins.

O ganho de produtividade é enorme.


Dica 5

Execute testes a cada alteração.

Não espere a homologação.


Erros Comuns

Erro 1

Criar testes enormes.

Ruim:

Testar 20 regras juntas

Bom:

1 regra = 1 teste

Erro 2

Depender de dados reais.

Use mocks.


Erro 3

Não automatizar.

Se o teste depende de ação humana:

Você perdeu metade do benefício.

Easter Egg Mainframe ☕

Existe uma ironia divertida na história.

Durante décadas ouvimos:

"COBOL é antigo."

Mas hoje encontramos no mundo COBOL:

✅ Git

✅ VS Code

✅ Pipelines CI/CD

✅ DevOps

✅ Open Source

✅ APIs REST

✅ Containers

✅ Testes Unitários

✅ Inteligência Artificial

Enquanto muitos sistemas "modernos" desaparecem após poucos anos, aplicações COBOL escritas nos anos 70 continuam processando bilhões de dólares diariamente.

O COBOL Check é um símbolo dessa evolução.

Ele mostra que o Mainframe não ficou parado no tempo.

Pelo contrário.

O gigante apenas incorporou as melhores ideias do desenvolvimento moderno sem abrir mão da estabilidade que o tornou lendário.


Conclusão

O COBOL Check representa uma das iniciativas mais importantes da modernização do desenvolvimento Mainframe.

Ele trouxe para o COBOL conceitos consagrados por ferramentas como JUnit, permitindo:

  • Testes unitários automatizados

  • Mocks e Stubs

  • Relatórios HTML e XML

  • Integração com CI/CD

  • Maior qualidade de código

  • Refatoração segura

  • Menor risco em produção (GitHub)

No estilo Bellacosa Mainframe, podemos resumir assim:

O COBOL Check é a prova definitiva de que o COBOL não ficou preso ao passado. O gigante aprendeu a testar como os sistemas modernos, mas continua entregando a confiabilidade que mantém bancos, governos e grandes empresas funcionando todos os dias. ☕💣🚀

 



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.

terça-feira, 23 de dezembro de 2025

📘 Apostila DevOps Mainframe Jenkins, Ansible, UrbanCode Deploy e o renascimento do z/OS

 


📘 Apostila DevOps Mainframe

Jenkins, Ansible, UrbanCode Deploy e o renascimento do z/OS

Há quem ainda acredite que DevOps nasceu na cloud.
Quem viveu mainframe sabe: o mainframe sempre foi DevOps, só não chamava assim.

Muito antes de YAML, pipelines e dashboards coloridos, o IBM mainframe já praticava:

  • automação,

  • segregação de ambientes,

  • controle rigoroso de mudanças,

  • rollback planejado,

  • auditoria completa.

A diferença é que tudo isso era feito com JCL, PROCs, schedulers e disciplina operacional.
Hoje, Jenkins, Ansible e UrbanCode Deploy apenas vestem roupa nova numa mentalidade antiga e sólida.



🏛️ Um pouco de história (para colocar as coisas no lugar)

Nos anos 70, 80 e 90, o ciclo de vida de uma aplicação COBOL era rígido por necessidade:

  • DEV não era QA

  • QA não era PROD

  • PROD era sagrado

Cada passo deixava rastro. Cada job tinha dono. Cada erro custava caro.

Quando o mundo distribuído descobriu o caos de “funciona na minha máquina”, o mainframe já tinha aprendido — na dor — que processo salva sistemas.

O DevOps moderno surge tentando recuperar essa disciplina, agora com ferramentas novas.


🔧 Onde entram Jenkins, Ansible e UrbanCode no mainframe?

Jenkins — o orquestrador inquieto

No mundo IBM mainframe, o Jenkins não compila COBOL.
Ele manda o mainframe trabalhar.

Seu papel é:

  • detectar mudanças no Git,

  • iniciar pipelines,

  • submeter JCL via Zowe,

  • validar RC,

  • organizar o fluxo.

📌 Easter egg Bellacosa:
Jenkins é, na prática, um scheduler nervoso, menos paciente que o Control-M, mas muito mais falador.


Ansible — o bibliotecário organizado

Ansible traz para o z/OS algo que o mainframe sempre gostou: padronização.

Com playbooks YAML, ele:

  • copia datasets,

  • executa comandos,

  • submete jobs,

  • garante que ambientes estejam no estado correto.

📌 Curiosidade:
Para quem vem de REXX e JCL, Ansible lembra um EXECIO com esteróides, só que multiplataforma.


UrbanCode Deploy — o velho auditor que agora usa terno novo

O IBM UrbanCode Deploy (UCD) é onde o mainframe se sente em casa.

Ele entende:

  • ambientes,

  • promoção controlada,

  • aprovação,

  • rollback,

  • compliance.

UCD não é “mais um Jenkins”.
Ele é o guardião do PROD, aquele colega sisudo que pergunta:

“Tem aprovação? Tem plano de volta?”

📌 Easter egg corporativo:
Em muitos bancos, o UCD é o novo CMF disfarçado de DevOps.


🧠 Aplicação real no mundo IBM Mainframe

Um pipeline típico hoje funciona assim:

  1. COBOL versionado em Git

  2. Jenkins dispara a integração contínua

  3. JCL compila e link-edita no z/OS

  4. Ansible prepara datasets e ambientes

  5. UCD promove DEV → QA → PROD

  6. Tudo auditado, versionado e rastreável

Nada disso quebra o mainframe.
Pelo contrário: valoriza sua arquitetura.


📋 Dicas práticas de quem já viu produção cair

✔ YAML orquestra, JCL executa
✔ Nunca coloque lógica de negócio no pipeline
✔ RC é lei — ignore RC e aprenda pelo incidente
✔ PROD não é laboratório
✔ Rollback não é opcional
✔ Automação sem governança é só caos rápido


🐣 Easter eggs para os atentos

  • Jenkins + Zowe é o novo Submit Job com esteroides

  • Ansible no z/OS é o primo moderno do REXX batch

  • UCD herdou o espírito do change management clássico

  • DevOps não “modernizou” o mainframe — apenas o reencontrou


🧾 Conclusão Bellacosa

O IBM mainframe não precisa ser salvo pelo DevOps.
Ele precisa apenas ser bem apresentado às ferramentas certas.

Jenkins traz velocidade.
Ansible traz ordem.
UrbanCode traz governo.
O z/OS continua fazendo o que sempre fez melhor: rodar o mundo sem cair.

E quem domina essa integração não está preso ao passado —
está segurando o futuro com as duas mãos.


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