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

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.


terça-feira, 12 de abril de 2022

Jenkins: O JES2 da Era DevOps que Todo Padawan COBOL Precisa Entender

 

Bellacosa Mainframe apresenta o jenkins para mainframers

☕ Um Café no Bellacosa Mainframe

Jenkins: O JES2 da Era DevOps que Todo Padawan COBOL Precisa Entender

"Se você já submeteu um JOB no JES2 esperando que tudo desse certo, então já conhece metade da filosofia do Jenkins. A diferença é que, no mundo moderno, quem dispara os jobs não é mais apenas um operador. É um robô extremamente paciente que nunca esquece um passo da esteira."

Existe uma pergunta que praticamente todo programador COBOL faz quando começa a conversar com equipes DevOps:

"Mas afinal... o que exatamente é esse tal de Jenkins?"

A resposta mais simples seria:

Jenkins é um servidor de automação.

Mas essa resposta é tão incompleta quanto dizer que o JES2 "serve apenas para executar jobs".

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

Para quem vem do universo IBM Z, entender Jenkins fica extremamente fácil quando fazemos as analogias corretas.

Hoje vamos tomar mais um café e descobrir que talvez você já trabalhe com algo muito parecido há décadas...


Antes de existir DevOps...

Durante muito tempo o desenvolvimento Mainframe seguia uma sequência bastante conhecida.

O programador fazia alterações.

Compilava.

Testava.

Gerava Load Module.

Alguém promovia.

Outro aprovava.

Outro copiava bibliotecas.

Outro atualizava o pacote.

Outro executava testes.

Outro validava produção.

Era um processo enorme.

Muito humano.

Muito sujeito a erros.

E principalmente...

Muito lento.

Foi justamente daí que nasceu o conceito de automação de pipelines.


Imagine um operador que nunca dorme

Imagine existir um operador que:

  • nunca esquece um passo

  • nunca pula uma etapa

  • nunca executa fora de ordem

  • nunca chega atrasado

  • trabalha 24 horas

  • registra tudo

  • avisa quando algo falha

  • envia e-mails

  • chama APIs

  • dispara testes

  • gera documentação

  • cria containers

  • publica versões

Esse operador existe.

Seu nome é Jenkins.


A analogia perfeita para um coboleiro

Pense no seguinte fluxo clássico.

Editar COBOL

↓

Compilar

↓

Link Edit

↓

Executar Teste

↓

Validar RC

↓

Gerar pacote

↓

Mover Load

↓

Atualizar ambiente

↓

Notificar equipe

Agora imagine alguém executando tudo isso automaticamente.

Isso é Jenkins.


O Jenkins é um grande Scheduler?

Sim.

Mas com superpoderes.

Ele lembra um pouco:

  • JES2

  • Control-M

  • CA-7

  • ESP

  • IZWS

  • OPC

  • TWS

Só que em vez de apenas disparar JOBs...

Ele coordena toda a cadeia de desenvolvimento.


O pipeline é o novo JCL

Para quem programa COBOL existe uma analogia maravilhosa.

Pipeline é praticamente um JCL moderno.

Veja.

No JCL:

STEP010 EXEC PGM=IGYCRCTL

STEP020 EXEC PGM=IEWL

STEP030 EXEC PGM=TESTE

STEP040 EXEC PGM=IEFBR14

Cada STEP possui dependências.

Cada RC determina o próximo passo.

Pipeline faz exatamente isso.

Stage Build

↓

Stage Test

↓

Stage Package

↓

Stage Deploy

↓

Stage Validation

É a mesma filosofia.


Jenkinsfile é praticamente um PROC moderno

Todo pipeline costuma ficar armazenado em um arquivo chamado

Jenkinsfile

Para um padawan...

Pense nele como um PROC extremamente inteligente.

Nele existe:

  • condições

  • loops

  • paralelismo

  • variáveis

  • chamadas externas

  • scripts

Tudo automatizado.


O Build

Uma palavra muito usada.

Build.

O que significa?

No Mainframe:

Compilar

+

Link Edit

+

Gerar Executável

No mundo distribuído:

Build significa exatamente isso.

Produzir algo executável.


O Jenkins compila COBOL?

Sim.

E isso surpreende muita gente.

Hoje é comum encontrar pipelines como:

Git

↓

Jenkins

↓

IBM Dependency Based Build

↓

Compilador Enterprise COBOL

↓

DB2 Bind

↓

Package

↓

Deploy

↓

Testes

↓

Produção

Tudo automático.

Sem intervenção humana.


IBM Dependency Based Build

Conhecido como

DBB.

Ele virou praticamente o "make" oficial do Mainframe.

Com ele o Jenkins entende:

  • quais programas mudaram

  • quais COPYBOOKs foram alterados

  • quais programas dependem deles

  • quais precisam recompilar

Antes disso...

Era comum recompilar milhares de programas.

Hoje recompila apenas o necessário.


O Git virou a nova PDS?

Não exatamente.

Mas quase.

Antigamente:

PDS

↓

Membro

↓

ISPF Edit

Hoje:

Git Repository

↓

Branch

↓

Commit

↓

Merge

O conceito mudou.

Mas o objetivo continua igual.

Controlar código-fonte.


Onde entra o Docker?

Aqui aparece uma dúvida enorme.

"Mas Docker roda no Mainframe?"

Sim.

E não.

Depende.


Docker não substitui o z/OS

Jamais.

Docker não executa CICS.

Não executa JES2.

Não executa DB2 z/OS.

Não executa IMS.

Não executa RACF.

Então para que serve?


Docker é o laboratório portátil

Imagine um desenvolvedor Java.

Ele precisa:

  • Maven

  • Java

  • Node

  • Python

  • Git

  • Curl

  • SDKs

  • Ferramentas IBM

Ao invés de instalar tudo...

Ele usa um Container.


O coboleiro também usa Docker

Aqui vem um dos maiores Easter Eggs do mundo Mainframe.

Muitos desenvolvedores COBOL usam Docker diariamente...

Sem perceber.

Exemplo.

Dentro do container ficam:

  • Zowe CLI

  • Git

  • Groovy

  • Python

  • DBB

  • Ferramentas de Build

  • utilitários Unix

  • scripts

O COBOL continua no Mainframe.

Mas todo o ambiente DevOps roda dentro do Container.


Outro Easter Egg

Existe quem imagine:

"Docker executa COBOL."

Na prática...

O que normalmente acontece é:

Docker

↓

Zowe CLI

↓

SSH

↓

z/OSMF

↓

JES

↓

Compilador COBOL

↓

Mainframe

Ou seja...

Docker apenas prepara o ambiente.

Quem executa continua sendo o IBM Z.


Mais um Easter Egg

Muitas empresas possuem dezenas de Jenkins.

Cada um com uma função.

Jenkins DEV

↓

Jenkins QA

↓

Jenkins Produção

↓

Jenkins Infra

Eles conversam entre si.


Jenkins conversa com o Mainframe?

Muito.

Hoje existem plugins para:

  • z/OSMF

  • Zowe

  • SSH

  • FTP

  • SFTP

  • MQ

  • REST APIs

Tudo integrado.


Pipeline típico COBOL

Imagine um Commit.

Git Push

Automaticamente.

↓

Jenkins detecta alteração

↓

Baixa código

↓

Analisa dependências

↓

Compila COBOL

↓

Executa DBB

↓

Executa testes

↓

Executa SonarQube

↓

Publica resultados

↓

Gera artefatos

↓

Promove ambiente

↓

Notifica Teams

↓

Notifica Slack

↓

Fecha Change

Tudo isso pode levar poucos minutos.


E quando algo falha?

O pipeline para.

Exatamente como um STEP retornando:

RC=12

ABEND S0C7

SQLCODE -904

O Jenkins registra tudo.

Logs.

Tempo.

Erro.

Quem fez.

Qual Commit.

Qual Branch.

Tudo.


A importância dos Logs

Um bom coboleiro aprende cedo:

Nunca ignore o SYSPRINT.

No Jenkins vale exatamente a mesma regra.

Nunca ignore:

Console Output

Ali está praticamente tudo.


Como identificar pipelines ruins?

Alguns sintomas.

Build demora horas

Normalmente existe:

  • recompilação desnecessária

  • testes redundantes

  • scripts lentos


Pipeline enorme

Às vezes um pipeline possui:

5000 linhas

Ninguém entende.

Ninguém mantém.

É igual um JCL gigantesco.


Sem versionamento

Pipeline criado diretamente pela interface.

Erro clássico.

Sempre use:

Jenkinsfile

Versionado no Git.


Sem testes

Pipeline apenas compila.

Não testa.

É praticamente entregar COBOL sem executar.


Como evoluir?

Primeiro passo.

Automatizar.

Depois.

Padronizar.

Depois.

Medir.

Depois.

Melhorar continuamente.


Métricas importantes

Tempo de Build.

Tempo de Deploy.

Quantidade de falhas.

Rollback.

Lead Time.

Change Failure Rate.

São indicadores extremamente importantes.


O Pipeline perfeito existe?

Não.

Porque software muda.

Infra muda.

Ferramentas mudam.

Negócio muda.

Pipeline também precisa evoluir.


Integração entre ambientes

Uma boa esteira normalmente possui.

Developer

↓

Sandbox

↓

Integração

↓

Homologação

↓

Pré-Produção

↓

Produção

Cada ambiente possui regras diferentes.


O Jenkins respeita aprovações?

Sim.

É muito comum existir.

Build

↓

Testes

↓

Aguardando aprovação

↓

Deploy QA

↓

Aguardando CAB

↓

Deploy Produção

Nada acontece sozinho.


Segurança

Aqui mora um perigo enorme.

Nunca coloque:

  • senhas

  • tokens

  • passwords

  • certificados

Dentro do Jenkinsfile.

Use:

Credentials.

Vault.

Secrets.


O maior erro dos iniciantes

Criar um pipeline que funciona...

Somente na máquina dele.

Isso quebra um dos princípios do DevOps.

Tudo deve ser reproduzível.


Outra armadilha

Scripts gigantes.

Exemplo.

Shell Script

800 linhas

Ninguém mantém isso.

Divida responsabilidades.


Jenkins não faz milagres

Se o processo manual é ruim...

Automatizar apenas cria um desastre mais rápido.

Primeiro melhore o processo.

Depois automatize.


Como um Padawan COBOL deve estudar?

Uma boa sequência seria.

Git

Aprenda commits.

Branches.

Merge.

Pull Request.


Linux básico

Mesmo trabalhando no z/OS.

Você verá muito:

grep

awk

sed

chmod

curl

tar

gzip

Docker

Não precisa virar especialista.

Mas saiba:

  • criar imagem

  • executar container

  • montar volume

  • entrar no bash


Jenkins

Aprenda:

Pipeline

Stages

Agents

Workspace

Artifacts

Credentials


Groovy

Não precisa dominar.

Mas entender a sintaxe ajuda muito.


Curiosidades

Uma empresa pode executar milhares de pipelines por dia.

Algumas executam dezenas por minuto.

Há pipelines que duram:

20 segundos.

Outros:

8 horas.

Tudo depende da aplicação.


Curiosidade Mainframe

Muitas empresas possuem aplicações COBOL com mais de:

40 milhões de linhas.

Sem automação seria impossível manter tudo isso.


Curiosidade interessante

Um COPYBOOK alterado pode obrigar centenas de programas a recompilar.

É justamente aí que o DBB faz enorme diferença.


Curiosidade divertida

Muitos programadores COBOL nunca abriram a interface do Jenkins.

Eles apenas fazem:

git push

E alguns minutos depois...

Recebem um e-mail dizendo:

✔ Build Success

O lado psicológico

Uma boa esteira reduz ansiedade.

Você não fica imaginando:

"Será que esqueceram de promover?"

"Será que copiaram o Load?"

"Será que executaram o Bind?"

O Jenkins lembra.

Sempre.


Fraquezas do Jenkins

Embora seja extremamente poderoso, o Jenkins também apresenta desafios que um programador Mainframe precisa conhecer.

A primeira fraqueza é a manutenção. Quanto mais pipelines personalizados uma empresa cria, maior se torna o esforço para mantê-los. Um Jenkins mal administrado acaba se transformando em uma coleção de scripts difíceis de entender, semelhante àquela PROC antiga que apenas um analista aposentado sabia alterar.

Outra limitação é a dependência de plugins. O ecossistema do Jenkins é gigantesco, mas isso significa que plugins podem ficar desatualizados, incompatíveis entre si ou apresentar vulnerabilidades de segurança. É fundamental manter uma política de atualização e testes antes de promover novas versões para ambientes produtivos.

Também existe a questão da escalabilidade. Um único servidor Jenkins executando centenas de builds simultâneos pode tornar-se um gargalo. Por isso, grandes organizações costumam distribuir a carga utilizando Agents, que funcionam como "executores remotos" capazes de processar builds em paralelo.


Vantagens para quem trabalha com IBM Z

Para o universo Mainframe, o Jenkins traz benefícios que vão muito além da simples automação:

  • Elimina tarefas repetitivas.

  • Reduz erros humanos durante promoções.

  • Padroniza o processo de compilação.

  • Garante que todos utilizem as mesmas ferramentas.

  • Facilita auditorias e conformidade.

  • Integra facilmente Git, Zowe, DBB, SonarQube e plataformas de colaboração como Teams e Slack.

  • Produz histórico completo de todas as alterações realizadas.

Isso significa menos tempo resolvendo problemas operacionais e mais tempo escrevendo código COBOL de qualidade.


O futuro do Padawan COBOL

Há alguns anos era comum imaginar que um programador Mainframe viveria apenas dentro do ISPF.

Hoje a realidade é diferente.

O profissional moderno alterna naturalmente entre:

  • VS Code

  • Git

  • Jenkins

  • Docker

  • Zowe CLI

  • APIs REST

  • Enterprise COBOL

  • JCL

  • CICS

  • DB2

  • z/OS

Ele continua sendo um especialista em Mainframe, mas agora também compreende como sua aplicação percorre toda a esteira DevOps até chegar à produção.


Conclusão

Existe uma frase bastante conhecida no mundo DevOps:

"Se um processo precisa ser executado duas vezes, ele provavelmente deveria ser automatizado."

No universo IBM Z essa ideia faz ainda mais sentido. Sistemas críticos processam milhões de transações diariamente e não podem depender da memória de uma pessoa para lembrar cada etapa de compilação, teste e implantação.

O Jenkins não substitui o conhecimento do programador COBOL. Ele não escreve regras de negócio, não resolve um S0C7 e não otimiza um SQL ruim. O que ele faz é garantir que todo o caminho entre o commit e a produção seja repetível, rastreável e confiável.

Para o Padawan COBOL, aprender Jenkins é como aprender JCL décadas atrás: no começo parece apenas mais uma ferramenta, mas logo se percebe que ela se torna parte do trabalho diário. E quanto antes você entender como Git, Docker, Zowe, DBB e Jenkins trabalham em conjunto, mais preparado estará para atuar nos ambientes IBM Z modernos.

No fim das contas, o Jenkins é o JES2 da era DevOps: recebe solicitações, organiza a execução, controla dependências, registra tudo o que aconteceu e garante que cada etapa aconteça na ordem correta. A diferença é que, agora, a esteira começa muito antes do JOB chegar ao z/OS e termina muito depois da compilação do COBOL, conectando desenvolvimento, testes, segurança, observabilidade e entrega contínua em um único fluxo automatizado.

E esse é talvez o maior easter egg de todos: muitos dos conceitos considerados "modernos" no DevOps sempre existiram no Mainframe. Apenas ganharam novas ferramentas, novos nomes e uma interface muito mais amigável. O espírito continua o mesmo: processos confiáveis, automação inteligente e qualidade acima de tudo.


domingo, 22 de abril de 2007

O que é Git no z/OS?

 

Bellacosa Mainframe o que é o git no zos

O que é Git no z/OS?

Se há alguns anos alguém dissesse que programadores COBOL usariam Git, fariam commits, trabalhariam com branches e executariam pipelines CI/CD diretamente para aplicações Mainframe, muita gente acharia impossível. 

Hoje isso é uma realidade.

O Git tornou-se uma das principais ferramentas de desenvolvimento também no ambiente IBM Z, permitindo que aplicações COBOL, PL/I, Assembler, JCL e REXX sejam desenvolvidas utilizando as mesmas práticas modernas empregadas em Java, Python, C# e JavaScript.

Mais do que uma ferramenta de controle de versões, o Git representa uma mudança cultural na forma como aplicações Mainframe são desenvolvidas.


Definição simples

O Git no z/OS é a utilização do sistema de controle de versões Git para armazenar, controlar, compartilhar e gerenciar o código-fonte das aplicações IBM Mainframe.

Ele registra todas as alterações realizadas em:

  • programas COBOL;

  • programas PL/I;

  • programas Assembler;

  • JCLs;

  • PROCs;

  • REXX;

  • Copybooks;

  • scripts de automação;

  • definições de pipelines.

Em outras palavras:

O Git é a memória completa da evolução de uma aplicação Mainframe.


Uma analogia simples

Imagine um escritor produzindo um livro.

Ao longo do tempo ele cria diversas versões.

Sem Git:

Livro_Final.doc

Livro_Final_2.doc

Livro_Final_3.doc

Livro_Final_AgoraVai.doc

Livro_Final_Definitivo.doc

Ninguém sabe qual é a versão correta.

Com Git:

Cada alteração possui:

  • autor;

  • data;

  • descrição;

  • histórico;

  • possibilidade de retorno.

Tudo organizado.


O que é Git?

Git é um sistema de Controle de Versões Distribuído (Distributed Version Control System - DVCS).

Criado por Linus Torvalds, em 2005, para o desenvolvimento do kernel Linux.

Hoje é o padrão mundial para desenvolvimento de software.


Por que usar Git no Mainframe?

Durante décadas o código COBOL era armazenado em bibliotecas PDS ou PDSE.

Embora isso funcionasse muito bem, surgiam limitações como:

  • histórico reduzido;

  • dificuldade para colaboração;

  • integração limitada com ferramentas modernas;

  • processos manuais de promoção.

O Git resolve esses desafios.


Como funciona?

Imagine um programa COBOL.

Antes:

Biblioteca PDS

↓

Editar

↓

Compilar

↓

Produção

Agora:

Programa COBOL

↓

Git

↓

Commit

↓

Pipeline

↓

Build

↓

Testes

↓

Deploy

Todo o processo torna-se rastreável.


Conceitos principais

Repositório (Repository)

É o local onde o código-fonte fica armazenado.

Exemplo:

Projeto_Banco

Dentro dele podem existir:

  • COBOL;

  • Copybooks;

  • JCL;

  • REXX;

  • documentação.


Commit

Sempre que uma alteração é concluída, cria-se um:

Commit

Ele registra:

  • o que mudou;

  • quem mudou;

  • quando mudou;

  • por que mudou.


Branch

Uma Branch é uma linha independente de desenvolvimento.

Exemplo:

Main

↓

Feature_PIX

↓

Correção_Boleto

Cada equipe pode trabalhar sem interferir nas demais.


Merge

Após os testes:

Branch

↓

Merge

↓

Main

As alterações são incorporadas ao projeto principal.


Clone

Permite copiar um repositório inteiro para a máquina do desenvolvedor.


Push

Envia alterações locais para o servidor Git.


Pull

Obtém as alterações mais recentes realizadas por outros desenvolvedores.


Git e COBOL

Hoje um programa COBOL pode seguir este fluxo:

Editar

↓

Commit

↓

GitHub

↓

Pipeline

↓

Compilação

↓

Testes

↓

Produção

Tudo semelhante ao desenvolvimento moderno.


Git e o z/OS

O código normalmente permanece armazenado no Git.

Quando necessário:

Git

↓

Pipeline

↓

Transferência

↓

Dataset

↓

Compilação COBOL

O processo é automatizado por ferramentas especializadas.


Ferramentas IBM

Diversas soluções integram Git ao Mainframe.

IBM Developer for z/OS (IDz)

Permite trabalhar com Git diretamente no Eclipse.


IBM Z Open Editor

Extensão para Visual Studio Code.

Suporte completo a:

  • Git;

  • COBOL;

  • JCL;

  • REXX.


IBM Dependency Based Build (DBB)

Automatiza builds utilizando código armazenado em Git.


IBM Wazi

Integra desenvolvimento moderno ao ambiente IBM Z.


z/OSMF

Pode participar de pipelines automatizados.


Plataformas Git

As mais utilizadas são:

  • GitHub;

  • GitLab;

  • Bitbucket;

  • Azure DevOps;

  • Gitea.


Git e CI/CD

O Git normalmente é o primeiro passo de um pipeline.

Commit

↓

Git

↓

Jenkins

↓

Build COBOL

↓

Testes

↓

Deploy

Benefícios

Histórico completo

Cada alteração fica registrada.


Trabalho em equipe

Diversos programadores podem desenvolver simultaneamente.


Segurança

É possível voltar rapidamente para versões anteriores.


Integração

Compatível com ferramentas modernas de DevOps.


Auditoria

Permite identificar quem alterou cada linha de código.


Quem utiliza Git no Mainframe?

Diversos profissionais.

  • Programadores COBOL;

  • Desenvolvedores PL/I;

  • Desenvolvedores Assembler;

  • DevOps Engineers;

  • Analistas de Sistemas;

  • Arquitetos;

  • Sysprogs;

  • Equipes de Qualidade.


Curiosidades incríveis

1. Git não substitui o z/OS

Ele controla o código-fonte, enquanto o z/OS continua sendo o sistema operacional que executa as aplicações.


2. Milhões de linhas de COBOL já são gerenciadas por Git

Grandes bancos e seguradoras migraram seus repositórios tradicionais para Git, mantendo décadas de código sob controle de versões moderno.


3. Git aproxima o Mainframe do restante da empresa

Equipes que desenvolvem em Java, Python, Node.js e COBOL passam a utilizar processos semelhantes de versionamento e colaboração.


4. O Git tornou-se peça fundamental do DevOps no IBM Z

Sem um sistema de controle de versões robusto, seria muito mais difícil automatizar builds, testes e implantações.


Erros comuns de iniciantes

"Git substitui PDS"

Não completamente.

Os programas continuam sendo compilados a partir de datasets no z/OS. O Git atua como repositório principal do código-fonte, enquanto ferramentas de build sincronizam os arquivos para o ambiente de compilação.


"Git serve apenas para Java"

Não.

Ele funciona igualmente bem com COBOL, PL/I, Assembler, JCL, REXX e praticamente qualquer tipo de arquivo texto.


"Git faz backup"

Não exatamente.

Embora mantenha o histórico das alterações, seu objetivo principal é o controle de versões e a colaboração entre desenvolvedores.


Quando aprender Git?

Depois de compreender:

  • COBOL;

  • JCL;

  • z/OS;

  • datasets;

  • DevOps;

  • CI/CD.

Esse conhecimento permitirá integrar o desenvolvimento Mainframe às práticas modernas utilizadas pelas maiores empresas do mundo.


Conclusão

O Git no z/OS representa a modernização do desenvolvimento no IBM Mainframe. Ele permite que aplicações escritas em COBOL, PL/I, Assembler e JCL sejam versionadas, compartilhadas e integradas a pipelines automatizados de DevOps, utilizando as mesmas práticas adotadas no desenvolvimento de software moderno.

Ao registrar cada alteração, facilitar o trabalho em equipe e integrar-se com ferramentas como GitHub, GitLab, Jenkins, IBM Dependency Based Build (DBB), IBM Developer for z/OS (IDz) e Z Open Editor, o Git tornou-se um componente essencial para qualquer profissional que deseje desenvolver aplicações IBM Z com qualidade, rastreabilidade e agilidade.

sexta-feira, 20 de abril de 2007

O que é DevOps no Mainframe?

 

Bellacosa Mainframe e o devops 

O que é DevOps no Mainframe?

Quando alguém começa a estudar IBM Mainframe, normalmente imagina um ambiente onde tudo é manual:

  • programas COBOL;  

  • JCLs;

  • compilações em telas verdes;

  • operadores executando jobs.

Essa visão já não representa a realidade das grandes empresas.

Hoje, bancos, seguradoras, companhias aéreas, operadoras de telecomunicações e governos utilizam conceitos modernos de desenvolvimento conhecidos como DevOps, também no ambiente IBM Z.

Na verdade, um dos maiores movimentos tecnológicos da última década foi justamente levar as práticas de DevOps para o Mainframe, integrando décadas de confiabilidade do IBM Z com ferramentas modernas de automação, integração contínua e entrega contínua.


Definição simples

DevOps no Mainframe é a aplicação das práticas de desenvolvimento ágil, automação e integração contínua ao ambiente IBM Z.

Seu objetivo é permitir que aplicações sejam:

  • desenvolvidas;

  • compiladas;

  • testadas;

  • implantadas;

  • monitoradas;

de forma rápida, automatizada e segura.

Em outras palavras:

DevOps é fazer o software chegar à produção com velocidade, qualidade e segurança.


Uma analogia simples

Imagine uma fábrica de automóveis.

Antigamente cada carro era montado quase artesanalmente.

Hoje existem robôs, esteiras e sensores.

O resultado:

  • produção mais rápida;

  • menos erros;

  • maior qualidade.

O DevOps faz exatamente isso com o desenvolvimento de software.



Antes do DevOps

Há alguns anos o processo era parecido com isto:

Programador COBOL

↓

Compila

↓

Entrega ao Analista

↓

Testes

↓

Produção

↓

Operador instala manualmente

Cada etapa dependia de pessoas.

Muitos processos eram totalmente manuais.


Depois do DevOps

Hoje o fluxo pode ser:

Programador

↓

Git

↓

Pipeline

↓

Compilação

↓

Testes

↓

Análise de qualidade

↓

Deploy

↓

Produção

Grande parte ocorre automaticamente.


O que significa DevOps?

A palavra vem da união de:

Development

Operations

Ou seja:

Desenvolvimento + Operações.

Essas duas equipes passam a trabalhar juntas.


Objetivos do DevOps

Entre os principais objetivos estão:

  • reduzir erros;

  • acelerar entregas;

  • automatizar processos;

  • aumentar a qualidade;

  • melhorar testes;

  • facilitar implantações;

  • reduzir riscos.


Como funciona no Mainframe?

Imagine uma alteração em um programa COBOL.

O programador salva o código.

Automaticamente:

Git

↓

Pipeline

↓

Compilação COBOL

↓

Build

↓

Testes

↓

Análise

↓

Deploy

↓

Produção

Sem intervenção manual.


Principais etapas

Controle de Versão

Todo código fica armazenado em:

  • Git;

  • GitHub;

  • GitLab;

  • Bitbucket.

Cada alteração fica registrada.


Build

Após um commit:

o pipeline executa:

  • compilação COBOL;

  • Link Edit;

  • geração de Load Modules;

  • geração de artefatos.


Testes

São executados automaticamente.

Exemplos:

  • testes unitários;

  • testes de integração;

  • testes automatizados.


Qualidade

Ferramentas verificam:

  • padrões de código;

  • complexidade;

  • cobertura;

  • vulnerabilidades.


Deploy

Após aprovação:

a aplicação é instalada automaticamente.


Ferramentas IBM

Diversas ferramentas fazem parte desse ecossistema.

IBM Developer for z/OS (IDz)

Ambiente moderno baseado em Eclipse para desenvolvimento COBOL, PL/I, Assembler e JCL.


IBM Z Open Editor

Extensão para Visual Studio Code.

Permite desenvolver aplicações Mainframe usando VS Code.


IBM Dependency Based Build (DBB)

Automatiza builds de aplicações Mainframe.


IBM Wazi

Ambiente moderno para desenvolvimento e testes em IBM Z.


IBM z/OSMF

Permite automações e administração via interface Web e APIs REST.


IBM UrbanCode Deploy

Automatiza implantações.


IBM Z Ansible Collection

Permite automatizar tarefas do z/OS utilizando Ansible.


Ferramentas de mercado

Também são comuns:

  • Jenkins;

  • GitHub Actions;

  • GitLab CI/CD;

  • Azure DevOps;

  • SonarQube;

  • Artifactory;

  • Nexus.


O pipeline

Um pipeline pode seguir este fluxo:

Git Commit

↓

Build COBOL

↓

Compilação JCL

↓

Testes

↓

Quality Gate

↓

Deploy Homologação

↓

Deploy Produção

Tudo pode ocorrer automaticamente.


DevOps e COBOL

O COBOL continua sendo a linguagem principal.

O que muda é a forma de trabalhar.

Antes:

Editar

↓

Compilar

↓

Produção

Agora:

Editar

↓

Git

↓

Pipeline

↓

Build

↓

Testes

↓

Deploy

O desenvolvimento torna-se mais seguro e rastreável.


DevOps e CICS

Também é possível automatizar:

  • instalação de programas;

  • BMS Maps;

  • transações;

  • recursos;

  • regiões.


DevOps e Db2

Os pipelines podem executar:

  • DDL;

  • BIND;

  • RUNSTATS;

  • EXPLAIN;

  • testes SQL.


Benefícios

Mais velocidade

Menos tempo entre desenvolvimento e produção.


Mais qualidade

Testes automáticos reduzem erros.


Mais segurança

Cada alteração fica registrada.


Padronização

Todos seguem o mesmo processo.


Menor risco

Deploys tornam-se previsíveis.


Quem trabalha com DevOps?

Diversos profissionais:

  • Programadores COBOL;

  • Desenvolvedores PL/I;

  • Sysprogs;

  • DevOps Engineers;

  • Administradores CICS;

  • DBAs;

  • Especialistas MQ;

  • Analistas de Qualidade.


Curiosidades incríveis

1. O Mainframe foi um dos primeiros ambientes a automatizar processos

Muito antes da popularização do DevOps, já existiam ferramentas para automação de jobs, builds e implantações no IBM Z.


2. Grandes bancos realizam dezenas ou até centenas de implantações por semana

Com pipelines automatizados, mudanças pequenas podem ser entregues com mais frequência e menor risco.


3. O Git tornou-se padrão também no Mainframe

Hoje é comum encontrar aplicações COBOL armazenadas em repositórios Git e integradas a pipelines CI/CD.


4. DevOps não substitui o Sysprog

O Sysprog continua sendo responsável pela infraestrutura do z/OS. O DevOps aproxima desenvolvimento e operações, automatizando processos e melhorando a colaboração entre equipes.


Erros comuns de iniciantes

"DevOps é uma ferramenta"

Não.

É uma cultura de trabalho apoiada por diversas ferramentas.


"COBOL não funciona com Git"

Funciona.

Hoje existem milhares de aplicações COBOL utilizando Git como sistema de controle de versões.


"DevOps elimina o operador e o Sysprog"

Não.

Ele reduz tarefas repetitivas e automatiza processos, mas continua dependendo de profissionais especializados para administrar a infraestrutura e definir as melhores práticas.


Quando aprender DevOps?

Depois de compreender:

  • COBOL;

  • JCL;

  • z/OS;

  • Git;

  • Build;

  • testes automatizados;

  • CICS;

  • Db2.

Esse conhecimento permitirá entender como o desenvolvimento moderno é realizado no IBM Mainframe.


Conclusão

O DevOps no Mainframe representa a evolução da forma de desenvolver e entregar aplicações no IBM Z. Ao integrar desenvolvimento, operações, automação, controle de versões e pipelines CI/CD, ele permite que sistemas escritos em COBOL, PL/I e outras linguagens tradicionais acompanhem a velocidade exigida pelos negócios atuais.

Mais do que uma coleção de ferramentas, DevOps é uma cultura que une equipes, reduz erros, acelera implantações e aumenta a qualidade do software. Para quem deseja construir uma carreira moderna em Mainframe, dominar conceitos como Git, Jenkins, DBB, IDz, Z Open Editor, Ansible e CI/CD tornou-se tão importante quanto conhecer COBOL e JCL.

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