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.


terça-feira, 21 de abril de 2020

DevOps sem Mistérios para o Programador COBOL Padawan

 

Bellacosa Mainframe e o DevOps sem misterios

☕ Um Café no Bellacosa Mainframe

DevOps sem Mistérios para o Programador COBOL Padawan

Da Tela Verde à Ponte da USS Enterprise: como desenvolvimento, operações, qualidade e negócio aprenderam a trabalhar na mesma missão

“As necessidades de muitos superam as necessidades de poucos.”
— Sr. Spock

Imagine que você acabou de entrar para a tripulação de uma gigantesca nave estelar chamada IBM Z Enterprise.

Você é um jovem programador COBOL. Seu uniforme ainda está impecável, seu crachá de acesso ao TSO acabou de ser criado e você ainda consulta uma pequena cola para lembrar a diferença entre DISP=SHR, DISP=OLD e DISP=MOD.

Sua primeira missão parece simples:

Alterar um programa COBOL para incluir um novo campo no relatório de clientes.

Você abre o fonte no ISPF, modifica a WORKING-STORAGE, ajusta o PROCEDURE DIVISION, compila o programa e realiza um teste rápido.

Tudo funciona perfeitamente.

Orgulhoso, você informa ao líder:

— Capitão, a alteração está pronta!

Mas então começa a verdadeira viagem.

A mudança precisa ser compilada no ambiente correto. Depois, deve passar pelos testes unitários, testes integrados, homologação, validação do banco de dados, análise de segurança, aprovação do negócio e, finalmente, implantação em produção.

De repente, a pequena alteração em um relatório se transforma em uma missão interplanetária envolvendo programadores, analistas de qualidade, DBAs, operadores, especialistas em CICS, administradores de segurança, gestores, usuários e o sempre misterioso profissional que sabe exatamente qual biblioteca de carga está sendo utilizada pelo job de produção.

É nesse momento que o programador COBOL Padawan descobre uma verdade fundamental:

Escrever código é apenas uma parte da engenharia de software.

O restante da missão envolve entregar esse código de maneira segura, previsível, rápida, rastreável e confiável.

É justamente nesse espaço que entra o DevOps.

Prepare seu café, ajuste o terminal 3270 e ocupe seu posto na ponte. Hoje vamos explorar DevOps não como uma palavra da moda, mas como uma mudança profunda na forma de construir, testar, entregar e operar sistemas.


1. Afinal, o que é DevOps?

O nome DevOps nasce da união de duas palavras:

  • Development, desenvolvimento;

  • Operations, operações.

Entretanto, interpretar DevOps apenas como uma união entre desenvolvedores e operadores seria uma simplificação perigosa.

DevOps é uma combinação de:

  • cultura;

  • colaboração;

  • automação;

  • integração contínua;

  • entrega contínua;

  • testes;

  • segurança;

  • observabilidade;

  • métricas;

  • feedback;

  • responsabilidade compartilhada.

Seu objetivo é reduzir a distância entre a criação de uma mudança e sua disponibilização segura para o usuário.

Em termos simples, DevOps tenta responder à seguinte pergunta:

Como podemos entregar software com maior frequência sem transformar produção em um campo de batalha klingon?

A resposta não está apenas em comprar ferramentas.

Uma empresa pode instalar Jenkins, Git, Docker, Kubernetes, Ansible, Zowe e dezenas de plataformas modernas e, ainda assim, continuar sem praticar DevOps.

Isso acontece porque DevOps não começa na tecnologia.

Ele começa na forma como as pessoas trabalham.


2. O antigo conflito entre desenvolvimento e operações

Durante décadas, muitas organizações trabalharam com uma forte separação entre equipes.

O desenvolvimento escrevia o código.

A qualidade testava.

A infraestrutura instalava.

A operação executava.

A segurança auditava.

O negócio reclamava.

Cada área possuía seus próprios objetivos.

O desenvolvedor queria entregar rapidamente.

A operação queria evitar mudanças.

A qualidade queria mais tempo para testar.

A segurança queria mais controles.

O gestor queria cumprir o prazo.

O usuário queria que tudo funcionasse imediatamente.

Era como uma nave em que cada oficial estivesse tentando definir um destino diferente.

O engenheiro dizia:

— Precisamos desligar os motores para manutenção.

O capitão respondia:

— Não podemos parar a nave.

O oficial científico alertava:

— A probabilidade de falha aumentou para 73,4%.

E o setor comercial perguntava:

— Conseguimos lançar a nova funcionalidade ainda hoje?

Essa fragmentação gerava conflitos, atrasos e erros.

Quando uma aplicação falhava em produção, surgia o famoso jogo de responsabilidades:

  • “O código funcionava em desenvolvimento.”

  • “A infraestrutura estava normal.”

  • “Os testes foram aprovados.”

  • “O problema está no banco.”

  • “O problema está na rede.”

  • “O usuário executou errado.”

  • “O job utilizou uma versão antiga da load library.”

DevOps tenta substituir essa cultura de culpa por uma cultura de colaboração.

Em vez de perguntar:

Quem causou o problema?

A equipe passa a perguntar:

Como o sistema permitiu que esse problema chegasse até aqui?

Essa mudança de pergunta é poderosa.

Ela desloca o foco da pessoa para o processo.


3. DevOps é uma filosofia de responsabilidade compartilhada

Em DevOps, o software não é abandonado depois que o programador termina a codificação.

A equipe acompanha todo o ciclo de vida:

Planejar
   ↓
Codificar
   ↓
Construir
   ↓
Testar
   ↓
Liberar
   ↓
Implantar
   ↓
Operar
   ↓
Monitorar
   ↓
Aprender
   ↓
Planejar novamente

Esse fluxo costuma ser representado como um símbolo de infinito.

A ideia é simples: o processo nunca termina.

Após colocar uma funcionalidade em produção, a organização coleta informações sobre seu comportamento.

Ela observa:

  • quantidade de erros;

  • tempo de resposta;

  • consumo de CPU;

  • número de usuários;

  • transações executadas;

  • falhas de banco;

  • abends;

  • reclamações;

  • custo operacional;

  • impacto no negócio.

Esses dados retornam ao planejamento e influenciam a próxima melhoria.

No universo Star Trek, podemos imaginar esse ciclo como o funcionamento da ponte da Enterprise.

A tripulação define a missão, calcula a rota, executa a viagem, monitora os sensores, identifica anomalias e ajusta o curso.

Nenhum capitão sensato ordenaria velocidade de dobra sem observar os motores, os escudos e os sensores.

Entretanto, algumas organizações fazem exatamente isso com sistemas de produção.

Implantam mudanças e esperam que tudo dê certo.

DevOps substitui esperança por engenharia.


4. Por que DevOps surgiu?

O movimento DevOps ganhou força no final dos anos 2000, principalmente como uma reação aos problemas encontrados em projetos de software grandes e lentos.

Empresas percebiam que poderiam passar meses desenvolvendo uma solução e descobrir, no final, que:

  • o cliente já não precisava mais dela;

  • os requisitos haviam mudado;

  • a integração não funcionava;

  • o ambiente de produção era diferente;

  • o deploy era complexo;

  • a equipe não conseguia recuperar rapidamente uma falha.

No modelo tradicional, grandes alterações eram acumuladas em enormes pacotes de implantação.

Quanto maior o pacote, maior o risco.

Imagine uma manutenção com:

  • 180 programas COBOL;

  • 60 copybooks;

  • 25 tabelas Db2;

  • 14 mapas BMS;

  • 40 jobs JCL;

  • alterações em PROCs;

  • novos arquivos VSAM;

  • mudanças de segurança;

  • atualizações de parâmetros CICS.

Colocar tudo isso em produção de uma única vez é como realizar manutenção nos motores, nos escudos, no computador central e no sistema de suporte de vida simultaneamente.

Talvez funcione.

Mas não é uma estratégia confortável.

DevOps incentiva alterações menores, mais frequentes e mais fáceis de validar.

Uma pequena mudança tende a ser:

  • mais simples de entender;

  • mais fácil de testar;

  • mais rápida de aprovar;

  • mais segura de implantar;

  • mais fácil de reverter.


5. CI: integração contínua

Um dos pilares mais conhecidos do DevOps é a Continuous Integration, ou integração contínua.

Integração contínua significa integrar alterações de código frequentemente, em vez de esperar semanas ou meses para reunir o trabalho de vários desenvolvedores.

Imagine três programadores alterando o mesmo programa COBOL.

Ana modifica o cálculo de juros.

Carlos altera a leitura do arquivo VSAM.

Marina adiciona uma chamada para um subprograma.

Se cada um trabalhar isoladamente durante um mês, a integração final pode se transformar em um episódio de guerra temporal.

As linhas modificadas entram em conflito.

Um copybook está desatualizado.

Uma variável foi renomeada.

A interface de um CALL foi alterada.

O programa de Ana compila com uma versão do copybook, enquanto o programa de Carlos utiliza outra.

Na integração contínua, essas alterações são incorporadas com maior frequência.

Cada integração pode disparar automaticamente:

  1. obtenção do código;

  2. verificação das dependências;

  3. compilação;

  4. link-edit;

  5. execução de testes;

  6. análise de qualidade;

  7. geração de relatórios;

  8. armazenamento dos artefatos.

No mainframe moderno, ferramentas como Git, IBM Dependency Based Build, Jenkins, GitHub Actions, GitLab CI, Azure DevOps e soluções de gerenciamento de mudanças podem participar desse fluxo.


6. Um exemplo de pipeline COBOL

Vamos imaginar um fluxo simplificado.

O programador modifica um fonte COBOL e envia a alteração para o repositório.

O pipeline começa.

Commit no Git
      ↓
Validação do fonte
      ↓
Identificação das dependências
      ↓
Compilação COBOL
      ↓
Pré-compilação Db2, se necessária
      ↓
Link-edit
      ↓
Execução de testes unitários
      ↓
Análise estática
      ↓
Deploy em ambiente de testes
      ↓
Testes integrados
      ↓
Aprovação
      ↓
Promoção para produção

Em um programa Db2, o fluxo pode incluir:

  • pré-compilação SQL;

  • compilação COBOL;

  • linkedição;

  • criação ou atualização de package;

  • execução de BIND PACKAGE;

  • validação do plano;

  • testes de SQL;

  • análise de desempenho.

Em uma aplicação CICS, pode envolver:

  • compilação do mapa BMS;

  • compilação do programa;

  • geração do módulo de carga;

  • atualização da definição;

  • instalação do recurso;

  • novo NEWCOPY;

  • testes de transação.

Perceba que o pipeline não substitui o conhecimento técnico.

Ele organiza e automatiza esse conhecimento.

Automatizar uma compilação COBOL incorreta apenas produz erros em maior velocidade.


7. Continuous Delivery e Continuous Deployment

Esses dois conceitos são parecidos, mas não são idênticos.

Continuous Delivery

Na entrega contínua, o sistema é mantido em estado potencialmente implantável.

O pipeline prepara, testa e valida a mudança.

Entretanto, a entrada em produção ainda pode depender de uma aprovação humana.

Em ambientes bancários, governamentais ou altamente regulados, isso é comum.

O fluxo pode ser:

Build aprovado
   ↓
Testes aprovados
   ↓
Homologação aprovada
   ↓
Gestor autoriza
   ↓
Produção

Continuous Deployment

Na implantação contínua, toda mudança que passa pelos controles pode chegar automaticamente à produção.

Isso exige:

  • testes maduros;

  • grande automação;

  • forte observabilidade;

  • rollback confiável;

  • arquitetura preparada;

  • baixo acoplamento;

  • confiança nos controles.

Nem toda organização precisa implantar automaticamente em produção.

DevOps não obriga uma empresa a remover aprovações.

O objetivo é remover atrasos desnecessários e tornar o fluxo mais confiável.

No IBM Z, é perfeitamente possível praticar DevOps mantendo governança, segregação de funções e auditoria.


8. DevOps não significa ausência de controle

Este é um dos maiores medos em ambientes corporativos.

Algumas pessoas escutam “entrega contínua” e imaginam programadores enviando alterações diretamente para produção às duas horas da tarde de uma sexta-feira.

Isso não é DevOps.

Isso é imprudência.

DevOps não elimina controles.

DevOps automatiza controles.

Em vez de depender de uma lista manual, o pipeline pode verificar:

  • se o código foi revisado;

  • se os testes passaram;

  • se não há vulnerabilidades críticas;

  • se o artefato foi aprovado;

  • se a versão está identificada;

  • se existe plano de reversão;

  • se as dependências estão corretas;

  • se o ambiente está disponível.

O objetivo não é abrir os portões da nave.

É instalar sensores melhores nas portas.


9. Testes contínuos

No modelo tradicional, testes costumavam ocorrer perto do final do projeto.

Esse atraso era perigoso.

Um erro descoberto tarde pode exigir mudanças em:

  • código;

  • arquitetura;

  • banco;

  • documentação;

  • cronograma;

  • treinamento;

  • contratos.

DevOps aproxima os testes do momento em que o código é criado.

Isso é frequentemente associado ao conceito de shift left.

Imagine uma linha do tempo:

Requisito → Código → Build → Teste → Produção

Mover a qualidade para a esquerda significa testar mais cedo.

Para um programa COBOL, podem existir:

  • testes unitários;

  • testes de arquivos;

  • testes de copybooks;

  • testes de subprogramas;

  • testes de integração com Db2;

  • testes de transações CICS;

  • testes de processamento IMS;

  • testes de regressão;

  • testes de performance;

  • testes de segurança.

Ferramentas como ZUnit, IBM COBOL Check, Galasa, Z Virtual Test Platform e frameworks personalizados ajudam a automatizar parte desse processo.

Um programa simples de cálculo pode ser testado com entradas conhecidas.

Por exemplo:

Valor: 1000
Taxa: 2%
Resultado esperado: 1020

Se uma mudança alterar o resultado para 1200, o pipeline deve detectar a anomalia antes que ela alcance produção.

O teste automatizado funciona como o computador da Enterprise alertando:

“Capitão, a trajetória calculada colide com um asteroide.”


10. Automação: o motor de dobra do DevOps

A automação permite executar tarefas repetitivas com consistência.

No mainframe, muitas rotinas sempre foram automatizadas por:

  • JCL;

  • PROCs;

  • schedulers;

  • REXX;

  • CLIST;

  • utilities;

  • ferramentas de gerenciamento de mudanças.

Por isso, é incorreto afirmar que o mainframe nunca teve automação.

Na verdade, o ambiente IBM Z automatiza processamento há décadas.

O que mudou foi a integração entre automações.

No passado, poderíamos ter:

  • um JCL para compilar;

  • outro para linkar;

  • um operador executando;

  • um analista conferindo o spool;

  • um e-mail pedindo aprovação;

  • uma planilha registrando a versão;

  • um segundo JCL promovendo o módulo.

No modelo moderno, essas etapas podem fazer parte de um fluxo integrado.

A automação reduz:

  • digitação repetitiva;

  • erros humanos;

  • variações entre execuções;

  • dependência de conhecimento informal;

  • tempo de espera;

  • risco operacional.

Mas existe uma regra importante:

Não automatize o caos.

Antes de automatizar, compreenda o processo.

Se o processo possui dez aprovações inúteis, automatizá-las não resolve o problema.

Você terá apenas um desperdício mais rápido.


11. O poder das alterações pequenas

Uma das práticas mais importantes do DevOps é reduzir o tamanho das mudanças.

Suponha que um release contenha 100 alterações.

Se ocorrer uma falha, qual delas causou o problema?

Agora imagine um release com apenas duas mudanças pequenas.

A investigação se torna muito mais simples.

Alterações menores favorecem:

  • revisão;

  • teste;

  • diagnóstico;

  • rollback;

  • compreensão;

  • comunicação.

Isso combina perfeitamente com a lógica vulcana.

Uma mudança pequena possui menos variáveis desconhecidas.

Logo, a probabilidade de localizar uma falha aumenta.


12. Observabilidade: os sensores de longo alcance

Depois que o software entra em produção, a missão não termina.

É preciso observar seu comportamento.

Monitoramento informa que algo está errado.

Observabilidade ajuda a explicar por que está errado.

Os principais sinais de observabilidade são:

  • métricas;

  • logs;

  • traces;

  • eventos.

No mainframe, já convivemos com uma enorme riqueza de dados operacionais.

Podemos utilizar:

  • SMF;

  • RMF;

  • SDSF;

  • SYSLOG;

  • CICS statistics;

  • CICS monitoring;

  • Db2 accounting;

  • Db2 statistics;

  • IMS logs;

  • OMEGAMON;

  • mensagens JES;

  • dumps;

  • registros de segurança.

Um programador COBOL iniciante pode pensar que SMF e RMF são assuntos exclusivos de sysprogs.

Entretanto, esses dados podem explicar diretamente o comportamento de uma aplicação.

Por exemplo:

  • aumento do tempo de CPU;

  • crescimento de I/O;

  • excesso de chamadas Db2;

  • espera por lock;

  • contenção em arquivo;

  • aumento de abends;

  • tempo de resposta CICS;

  • crescimento de filas.

Se uma nova versão do programa consome o dobro de CPU, a observabilidade deve revelar isso.

Os sensores da nave precisam estar ligados.


13. DevOps orientado por dados

Decisões DevOps não devem depender apenas de opiniões.

A equipe pode medir:

  • frequência de implantação;

  • tempo entre alteração e produção;

  • percentual de mudanças com falha;

  • tempo de recuperação;

  • quantidade de incidentes;

  • defeitos por release;

  • duração dos testes;

  • tempo de aprovação;

  • retrabalho.

Quatro indicadores são frequentemente utilizados para avaliar o desempenho de entrega:

Frequência de implantação

Com que frequência a organização consegue colocar mudanças em produção?

Lead time for changes

Quanto tempo passa entre a criação de uma mudança e sua disponibilidade?

Change failure rate

Quantas mudanças provocam falhas, incidentes ou rollback?

Mean time to restore

Quanto tempo é necessário para restaurar o serviço depois de um problema?

Observe que DevOps não mede apenas velocidade.

Também mede estabilidade.

Uma equipe que implanta 50 vezes por dia, mas provoca 20 incidentes, não é necessariamente madura.


14. Por que o Project Manager deve se importar?

Em um projeto tradicional, o gerente pode acompanhar:

  • prazo;

  • orçamento;

  • escopo;

  • pessoas;

  • tarefas.

No contexto DevOps, ele também precisa compreender o fluxo real de entrega.

Não basta dizer:

“A programação está 90% concluída.”

Essa frase pode esconder muitos problemas.

O código pode estar pronto, mas:

  • os testes não foram automatizados;

  • o ambiente não está configurado;

  • o package Db2 não foi validado;

  • a segurança não aprovou;

  • o rollback não existe;

  • o monitoramento não foi preparado;

  • a operação não foi treinada.

O PM moderno precisa perguntar:

  • Onde está o gargalo?

  • Quanto tempo uma mudança espera por aprovação?

  • Qual etapa possui mais retrabalho?

  • Quantos defeitos escapam para produção?

  • O deploy é reproduzível?

  • O rollback foi testado?

  • As métricas estão disponíveis?

  • O usuário está recebendo valor?

O gerente deixa de administrar apenas cronogramas e passa a administrar fluxo, risco e valor.


15. Customer-centric delivery

DevOps também aproxima a tecnologia do cliente.

O objetivo não é apenas entregar funcionalidades.

É entregar valor.

Imagine que o negócio pede um novo relatório com 40 campos.

A equipe desenvolve durante três meses.

Após a entrega, descobre-se que os usuários consultam apenas cinco campos.

Uma abordagem orientada por feedback poderia entregar uma versão menor em duas semanas, observar o uso e evoluir com base em dados reais.

Esse processo reduz desperdício.

Em Star Trek, uma missão não é considerada bem-sucedida apenas porque a nave chegou ao destino.

Ela precisa cumprir seu objetivo.

Da mesma forma, um projeto não é sucesso apenas porque o código entrou em produção.

Ele precisa resolver um problema real.


16. DevSecOps: segurança dentro da missão

Segurança não pode ser uma inspeção realizada apenas no final.

DevSecOps integra segurança ao ciclo de desenvolvimento.

O pipeline pode verificar:

  • senhas expostas;

  • credenciais em fontes;

  • bibliotecas vulneráveis;

  • permissões excessivas;

  • falhas de configuração;

  • código inseguro;

  • violações de políticas.

No mainframe, isso envolve temas como:

  • RACF;

  • SAF;

  • ACEE;

  • perfis de datasets;

  • permissões em USS;

  • acesso a transações CICS;

  • privilégios Db2;

  • APF;

  • auditoria SMF;

  • segregação de funções.

Um programa pode funcionar corretamente e ainda ser inseguro.

Por exemplo, um job com acesso desnecessário a uma base sensível representa um risco, mesmo que nunca tenha falhado.

Segurança é parte da qualidade.


17. DevOps no mundo IBM Z

O mainframe não é inimigo do DevOps.

Na verdade, muitos de seus princípios já existiam no ambiente há décadas.

O IBM Z sempre valorizou:

  • controle de mudanças;

  • versionamento;

  • rastreabilidade;

  • automação;

  • disponibilidade;

  • processamento previsível;

  • auditoria;

  • separação de ambientes;

  • recuperação.

Ferramentas tradicionais como Endevor, ChangeMan e ISPW organizaram durante anos a promoção de componentes entre ambientes.

O que o DevOps moderno acrescenta é uma integração maior com:

  • Git;

  • APIs;

  • pipelines;

  • testes automatizados;

  • infraestrutura como código;

  • observabilidade integrada;

  • ferramentas de colaboração.

Hoje podemos encontrar tecnologias como:

  • IBM Dependency Based Build;

  • IBM z/OS Connect;

  • Zowe CLI;

  • Ansible;

  • Jenkins;

  • GitHub Actions;

  • UrbanCode Deploy;

  • IBM Developer for z/OS;

  • IBM Z Open Editor;

  • Galasa;

  • ZUnit;

  • watsonx Code Assistant for Z.

O objetivo não é apagar a experiência acumulada do mainframe.

É conectá-la ao fluxo moderno de engenharia.


18. Exemplo completo: uma mudança COBOL em ambiente DevOps

Vamos acompanhar uma missão.

Etapa 1 — Planejamento

O usuário solicita um novo indicador no extrato.

A equipe define:

  • requisito;

  • critério de aceite;

  • impacto;

  • risco;

  • componentes envolvidos.

Etapa 2 — Desenvolvimento

O programador cria uma branch no Git.

Ele altera:

  • programa COBOL;

  • copybook;

  • teste unitário;

  • documentação.

Etapa 3 — Commit

Ao enviar a mudança, o pipeline é iniciado.

Etapa 4 — Build

A ferramenta identifica as dependências.

O programa é:

  • pré-compilado;

  • compilado;

  • linkado;

  • armazenado como artefato versionado.

Etapa 5 — Testes

São executados:

  • testes unitários;

  • testes de regressão;

  • testes de SQL;

  • validação de interface.

Etapa 6 — Análise

A solução verifica:

  • padrões de código;

  • vulnerabilidades;

  • erros;

  • cobertura de testes;

  • dependências.

Etapa 7 — Deploy em testes

O módulo é promovido para o ambiente de qualidade.

Etapa 8 — Homologação

O usuário valida o comportamento.

Etapa 9 — Aprovação

O responsável autoriza a implantação.

Etapa 10 — Produção

O artefato já testado é promovido.

Não se recompila um novo módulo na produção.

Implanta-se o mesmo artefato validado.

Etapa 11 — Monitoramento

A equipe observa:

  • abends;

  • CPU;

  • tempo de resposta;

  • SQL;

  • volume de transações;

  • erros funcionais.

Etapa 12 — Feedback

Os resultados alimentam a próxima melhoria.

Esse fluxo é o símbolo do infinito aplicado ao COBOL.


19. Dicas para o programador COBOL Padawan

Aprenda Git sem abandonar o ISPF

Git não substitui seu conhecimento de COBOL.

Ele organiza versões, colaboração e histórico.

Entenda o pipeline

Não trate o pipeline como uma caixa preta.

Saiba:

  • como o programa é compilado;

  • quais parâmetros são utilizados;

  • onde o load module é gerado;

  • quais testes são executados;

  • como ocorre a promoção.

Escreva mudanças pequenas

Evite misturar correções, melhorias e refatorações enormes no mesmo pacote.

Crie testes repetíveis

Um teste que depende da memória de uma pessoa não é confiável.

Leia o spool

Mesmo com ferramentas modernas, o spool continua sendo uma fonte preciosa de informação.

Conheça a produção

Você não precisa ser operador, mas precisa entender onde seu programa executa.

Documente dependências

Copybooks, tabelas, arquivos, subprogramas e transações devem ser conhecidos.

Pense em rollback

Antes de implantar, saiba como retornar.

Observe métricas

Um programa funcional pode consumir recursos excessivos.

Converse com outras equipes

DevOps depende mais de comunicação do que de ferramentas.


20. Erros comuns ao adotar DevOps

Comprar ferramentas sem mudar processos

A empresa instala plataformas modernas, mas mantém silos e aprovações burocráticas.

Automatizar processos ruins

Um fluxo desnecessariamente complexo continua ruim, mesmo automatizado.

Ignorar o legado

Tentar impor modelos de nuvem ao mainframe sem entender suas características gera resistência e risco.

Eliminar controles importantes

Velocidade não justifica ausência de governança.

Medir produtividade por quantidade de commits

Mais commits não significam mais valor.

Culpar pessoas por falhas sistêmicas

Uma cultura de medo impede aprendizado.

Não investir em testes

Pipeline sem testes é apenas transporte automatizado de problemas.

Não preparar rollback

Toda mudança pode falhar.

A engenharia madura reconhece essa possibilidade.


21. Curiosidades e easter eggs da Federação DevOps

🥚 O termo DevOps ganhou força por volta de 2009, associado ao movimento que buscava aproximar desenvolvimento e operações.

🥚 O lema “You build it, you run it” defende que a equipe que constrói um serviço também deve acompanhar sua operação.

🥚 O símbolo infinito de DevOps representa um ciclo contínuo, não uma sequência com começo e fim rígidos.

🥚 O mainframe já utilizava automação, controle de versão, promoção e auditoria muito antes de a palavra DevOps se tornar popular.

🥚 Um JCL bem escrito é uma forma histórica de automação operacional.

🥚 Um PROC reutilizável possui o mesmo espírito de padronização encontrado em pipelines modernos.

🥚 SMF pode ser visto como uma espécie de diário de bordo da nave IBM Z.

🥚 O SDSF é praticamente a sala de controle onde podemos acompanhar as missões batch em andamento.

🥚 Um abend sem logs é como uma anomalia espacial sem leitura dos sensores.

🥚 Um deploy realizado sem rollback é semelhante a entrar em velocidade de dobra sem calcular uma rota de retorno.


22. O que DevOps não é

DevOps não é:

  • apenas Jenkins;

  • apenas Git;

  • apenas nuvem;

  • apenas containers;

  • apenas automação;

  • ausência de documentação;

  • fim da governança;

  • desculpa para implantar sem testes;

  • obrigação de colocar tudo em produção automaticamente;

  • guerra contra o mainframe.

DevOps é a combinação equilibrada entre pessoas, processos e tecnologia.


23. A grande lição do Sr. Spock

Spock provavelmente enxergaria DevOps como uma consequência lógica da engenharia.

Separar completamente quem constrói de quem opera cria perda de informação.

Acumular grandes alterações aumenta risco.

Depender de processos manuais aumenta variação.

Ignorar dados reduz a qualidade da decisão.

Logo, a solução racional é:

  • colaborar;

  • automatizar;

  • medir;

  • testar;

  • observar;

  • aprender;

  • melhorar.

Mas Spock também lembraria que lógica não significa ausência de humanidade.

DevOps depende de confiança.

As pessoas precisam poder relatar erros sem medo.

Precisam compartilhar conhecimento.

Precisam pedir ajuda.

Precisam reconhecer que sistemas complexos falham de maneiras inesperadas.

O ambiente mais automatizado do universo ainda depende de equipes capazes de conversar.


Conclusão: da tela verde à entrega contínua

DevOps não nasceu para transformar programadores em operadores nem para obrigar todas as empresas a implantar centenas de vezes por dia.

Ele nasceu para resolver um problema antigo: a fragmentação da engenharia de software.

Para o programador COBOL iniciante, compreender DevOps significa enxergar além do fonte.

Seu programa faz parte de um ecossistema.

Ele depende de:

  • compiladores;

  • bibliotecas;

  • JCLs;

  • bancos de dados;

  • filas;

  • arquivos;

  • transações;

  • permissões;

  • operações;

  • métricas;

  • pessoas.

Uma alteração só está realmente concluída quando chega ao usuário com segurança, produz o resultado esperado e pode ser operada de maneira confiável.

No IBM Z, DevOps não representa a destruição do passado.

Representa a evolução de práticas que o mainframe já conhece muito bem.

A disciplina dos processos tradicionais pode se unir à velocidade dos pipelines modernos.

O conhecimento do programador COBOL pode se integrar ao Git, ao Jenkins, ao Ansible, ao Zowe e à observabilidade.

A tela verde pode conversar com a nuvem.

O batch pode participar de uma esteira automatizada.

O programa de 30 anos pode receber testes modernos.

A tradição e a inovação não precisam ser inimigas.

Como diria o Capitão Kirk antes de ordenar uma nova missão:

“O risco faz parte do jogo quando queremos avançar.”

E como Spock provavelmente acrescentaria:

“Contudo, capitão, riscos calculados, monitorados e automatizados apresentam uma probabilidade consideravelmente maior de sucesso.”

Essa é a essência do DevOps.

Não correr de maneira irresponsável.

Mas construir uma nave melhor, integrar a tripulação, automatizar os procedimentos, observar os sensores e avançar com confiança.

Vida longa e próspera aos seus pipelines. 🖖

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