Translate

Mostrar mensagens com a etiqueta Entrega Contínua. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta Entrega Contínua. Mostrar todas as mensagens

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.

 


quarta-feira, 19 de fevereiro de 2020

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

 

Bellacosa Mainframe apresenta o jenkins

☕ Um Café no Bellacosa Mainframe

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

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

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


Introdução

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

"Faz um build no Jenkins."

Parece algo simples.

Você altera um programa COBOL.

Faz um git push.

Alguns minutos depois alguém informa:

"O pipeline ficou verde."

Ou então...

"O Jenkins quebrou."

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

Existe um servidor.

Existe um robô.

Existe um botão chamado Build Now.

E, aparentemente, tudo acontece sozinho.

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

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

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

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

Pegue seu café.

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


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

Imagine um banco em 1998.

A equipe possui:

  • 80 programadores COBOL

  • 20 analistas

  • dezenas de aplicações

  • centenas de programas

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

Ao final da semana...

Todos entregam seus programas.

Alguém precisa reunir tudo.

Compilar.

Executar testes.

Gerar executáveis.

Mover bibliotecas.

Executar JCLs.

Atualizar CICS.

Publicar em produção.

Tudo manualmente.

Agora imagine o caos.

João alterou o Programa A.

Maria alterou o Programa B.

Carlos modificou um COPY utilizado por ambos.

Quando tudo é compilado junto...

Nada funciona.

Esse problema ficou conhecido como Integration Hell.

Quanto maior a equipe...

Maior o problema.

Era necessário encontrar uma solução.


O nascimento da Integração Contínua

Foi aí que surgiu uma ideia simples.

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

Por que não integrar continuamente?

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

  • compilar automaticamente;

  • executar testes;

  • verificar qualidade;

  • avisar imediatamente se algo deu errado.

Assim nasceu a Continuous Integration (CI).

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

É uma filosofia.

O Jenkins tornou essa filosofia prática.


O que realmente é o Jenkins?

Muita gente responde:

"É uma ferramenta de Build."

Na verdade, isso é apenas uma pequena parte.

O Jenkins é um servidor de automação.

Ele automatiza praticamente qualquer tarefa repetitiva.

Pode:

  • compilar programas

  • executar testes

  • gerar documentação

  • criar containers Docker

  • executar scripts Shell

  • chamar APIs

  • publicar microsserviços

  • disparar Ansible

  • executar Terraform

  • chamar Zowe CLI

  • enviar notificações

  • atualizar ambientes Mainframe

Ou seja...

O Jenkins não entende apenas de software.

Ele entende de processos.


Pense no Jenkins como um maestro

Imagine uma orquestra.

Cada músico conhece apenas seu instrumento.

O maestro coordena todos.

O Jenkins faz exatamente isso.

Ele não precisa saber programar Java.

Nem COBOL.

Nem Python.

Ele apenas coordena.

Git

↓

Compilar

↓

Testar

↓

Analisar qualidade

↓

Criar artefatos

↓

Publicar

↓

Implantar

↓

Monitorar

Cada ferramenta executa sua especialidade.

O Jenkins organiza a sequência.


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

Uma fábrica produz automóveis.

O software moderno produz versões.

Imagine uma linha de montagem.

Chassi

↓

Motor

↓

Pintura

↓

Inspeção

↓

Entrega

Agora substitua por desenvolvimento.

Código

↓

Build

↓

Testes

↓

Qualidade

↓

Deploy

↓

Monitoramento

Esse fluxo recebe o nome de Pipeline.

Pipeline significa literalmente:

tubulação.

Cada etapa entrega seu resultado para a próxima.

Se uma etapa falhar...

Nada continua.


O primeiro passo: Git

Tudo começa no Git.

O desenvolvedor altera um programa COBOL.

CLIENTE.CBL

Executa:

git add .

git commit

git push

Nesse instante acontece algo extremamente importante.

O Git envia um evento.

Esse evento dispara um Webhook.


WebHooks: quem avisa quem?

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

Mudou?

Mudou?

Mudou?

Isso existia.

Chamava-se Poll SCM.

Hoje o modelo mais moderno é o WebHook.

O GitHub avisa imediatamente:

Recebi um commit.

Pode iniciar o Pipeline.

É mais rápido.

Mais eficiente.

Mais escalável.


Build: muito além de compilar

No universo Java, Build normalmente significa:

.java

↓

.class

↓

.jar

No universo COBOL isso muda bastante.

Um Build pode incluir:

  • compilação COBOL

  • Link-Edit

  • geração do Load Module

  • pré-compilação DB2

  • BIND

  • geração de mapas CICS

  • cópia para bibliotecas

  • atualização de catálogos

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

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


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

Imagine um caixa eletrônico.

Você altera apenas uma linha.

Sem testes.

Na segunda-feira...

Nenhum saque funciona.

Por isso o Pipeline executa testes automaticamente.

Existem vários níveis.

  • Unit Test

  • Integration Test

  • Component Test

  • Smoke Test

  • Regression Test

  • Performance Test

  • Security Test

  • Acceptance Test

No universo IBM Z encontramos ferramentas como:

  • IBM ZUnit

  • COBOL Check


SonarQube: o inspetor de qualidade

Compilar não significa qualidade.

Um programa pode compilar perfeitamente e ainda assim possuir:

  • código duplicado

  • vulnerabilidades

  • baixa cobertura de testes

  • alta complexidade

  • más práticas

Ferramentas como SonarQube analisam tudo isso.

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

O Jenkins interrompe o Pipeline.


Continuous Delivery e Continuous Deployment

Esses conceitos costumam gerar confusão.

Continuous Delivery

Tudo acontece automaticamente.

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

Build

↓

Testes

↓

Deploy QA

↓

Aprovação

↓

Produção

É o modelo predominante em bancos.

Continuous Deployment

Não existe aprovação manual.

Passou em todos os testes?

Vai automaticamente para produção.

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


Jenkinsfile: Pipeline como Código

Antigamente configurávamos tudo pela interface gráfica.

Hoje utilizamos Pipeline as Code.

Arquivo:

Jenkinsfile

Exemplo simplificado:

pipeline {

    agent any

    stages {

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

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

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

    }

}

Esse arquivo também fica versionado no Git.

O Pipeline passa a fazer parte do projeto.


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

Imagine quatro ambientes:

  • DEV

  • QA

  • HML

  • PRD

Você poderia criar quatro pipelines.

Ou criar apenas um.

Na execução o Jenkins pergunta:

Qual ambiente?

DEV

QA

HML

PRD

Isso é parametrização.

Também podemos solicitar:

  • número da versão

  • branch

  • Change Request

  • arquivo de entrada

  • descrição da implantação

Um único Pipeline atende dezenas de cenários.


Cron: automação baseada em tempo

Nem todo Build depende de commits.

Às vezes queremos executar tarefas periodicamente.

Por exemplo:

  • backup diário

  • limpeza semanal

  • geração de relatórios

  • sincronização de ambientes

O Jenkins utiliza a sintaxe CRON.

Exemplo:

0 2 * * *

Executa diariamente às duas da manhã.

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

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


Controller e Agents

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

Hoje a nomenclatura oficial é:

  • Controller

  • Agent

O Controller coordena.

Os Agents trabalham.

Imagine um restaurante.

O gerente organiza os pedidos.

Os cozinheiros preparam os pratos.

O gerente não cozinha.

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


Por que vários Agents?

Suponha três Builds de 30 minutos.

Sem Agents:

Build A

↓

Build B

↓

Build C

Tempo total:

90 minutos.

Com três Agents:

Todos executam simultaneamente.

Tempo aproximado:

30 minutos.

Essa é a base da escalabilidade.


Labels: enviando o trabalho para a máquina certa

Nem todos os servidores possuem as mesmas ferramentas.

Podemos ter:

  • Linux

  • Windows

  • Docker

  • Kubernetes

  • IBM Z

  • Java

  • .NET

  • COBOL

Os Labels funcionam como etiquetas.

linux

docker

java

ibmz

cobol

Quando o Pipeline precisa compilar COBOL:

agent {
    label 'ibmz'
}

O Jenkins envia automaticamente o trabalho ao Agent correto.


Credenciais: segurança em primeiro lugar

Jamais coloque senhas dentro do Jenkinsfile.

O Jenkins possui um cofre chamado Credentials Store.

Nele podemos armazenar:

  • usuários

  • senhas

  • tokens GitHub

  • chaves SSH

  • certificados

  • chaves privadas

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


Workspaces

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

Nele ficam:

  • código baixado do Git

  • arquivos temporários

  • artefatos

  • logs

  • resultados de testes

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

Isso evita conflitos entre Builds.


Plugins: o verdadeiro poder do Jenkins

O Jenkins possui milhares de plugins.

Entre os mais conhecidos estão:

  • Git

  • GitHub

  • Docker

  • Kubernetes

  • SonarQube

  • Slack

  • Teams

  • Ansible

  • Terraform

  • Artifactory

  • Nexus

  • Blue Ocean

  • Pipeline Utility Steps

Essa arquitetura modular explica sua enorme popularidade.


Jenkins e Containers

Hoje muitos Builds acontecem dentro de containers Docker.

Cada execução recebe um ambiente completamente limpo.

Terminou?

O container é destruído.

Isso elimina problemas do tipo:

"Na minha máquina funciona."


Jenkins e Kubernetes

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

Quando um Build começa:

  • um Pod é criado;

  • o Pipeline executa;

  • o Pod é removido.

O ambiente sempre inicia do zero.

É altamente escalável.


Jenkins no IBM Mainframe

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

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

Nada poderia estar mais distante da realidade.

Hoje o Jenkins integra perfeitamente o universo IBM Z.

Um Pipeline moderno pode executar:

Git Push

↓

Webhook

↓

Jenkins

↓

Zowe CLI

↓

Upload do Programa COBOL

↓

Compilação

↓

Link-Edit

↓

DB2 BIND

↓

Execução do ZUnit

↓

Análise SonarQube

↓

Deploy para CICS

↓

Smoke Test

↓

Atualização do Endevor

↓

Notificação

Perceba.

O Jenkins não substitui o Mainframe.

Ele conversa com o Mainframe.


DevOps não elimina o Mainframe

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

Na realidade, DevOps é uma cultura.

Ela pode ser aplicada em qualquer plataforma.

Inclusive no IBM Z.

Hoje encontramos pipelines automatizando:

  • COBOL

  • PL/I

  • Assembler

  • JCL

  • DB2

  • IMS

  • CICS

  • MQ

  • z/OS Connect

Tudo integrado ao GitHub, GitLab e Azure DevOps.


Inteligência Artificial e Jenkins

Estamos entrando em uma nova fase.

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

Mas alguém ainda precisa orquestrar todo o processo.

É aí que o Jenkins continua relevante.

Imagine um Pipeline moderno:

Commit

↓

IA revisa Pull Request

↓

Build

↓

Testes

↓

SonarQube

↓

Análise de Segurança

↓

Deploy

↓

Observabilidade

↓

Feedback para IA

A automação não desaparece.

Ela apenas incorpora novas ferramentas.


Conclusão

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

Depois descobrimos os Pipelines.

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

Finalmente percebemos algo muito maior.

O Jenkins não é apenas uma ferramenta.

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

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

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

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