Translate

Mostrar mensagens com a etiqueta Integração de Sistemas. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta Integração de Sistemas. Mostrar todas as mensagens

quinta-feira, 19 de março de 2026

🚀 Seu cérebro COBOL está pronto para Python? O guia que acelera a migração em horas, não anos

 

Bellacosa Mainframe apresenta Python para Engenheiros e Analistas de Mainframe

🚀 Seu cérebro COBOL está pronto para Python? O guia que acelera a migração em horas, não anos

Python tornou-se uma linguagem estratégica para engenheiros de mainframe que desejam expandir suas habilidades para automação, integração moderna, Data Engineering e Inteligência Artificial. 

Para profissionais acostumados com COBOL, JCL e DB2, Python oferece um modelo mental mais simples e produtivo, substituindo estruturas como WORKING-STORAGE por variáveis dinâmicas, PERFORM por loops e FILE SECTION por manipulação direta de arquivos. 

Com bibliotecas poderosas e sintaxe clara, é possível automatizar rotinas operacionais, processar logs, integrar sistemas legados a APIs REST, consumir serviços web e construir pipelines de dados com muito menos código. 

Python também facilita DevOps, testes de batch, RPA corporativo e modernização de aplicações críticas. Seu uso crescente em nuvem, analytics e machine learning torna essa linguagem uma ponte natural entre o ambiente z/OS e o ecossistema digital atual. 

Aprender Python é, portanto, um passo essencial para mainframe engineers que desejam permanecer relevantes na transformação tecnológica.

🐍🔥 Cheatsheet Python para Mainframe Engineers

🧠 Mental Model — COBOL → Python

Conceito MainframeEquivalente Python
ProgramScript / Module
WORKING-STORAGEVariáveis
PIC clausesTipagem dinâmica
PERFORM UNTILwhile
PERFORM VARYINGfor
COPYBOOKModule / Class
FILE SECTIONFile handling
DB2 cursorIteração
JCL orchestrationScripts + Scheduler

📦 Variáveis (sem DATA DIVISION 😎)

COBOL

01 WS-NUM PIC 9(4) VALUE 100.

Python

ws_num = 100

✔ Sem declaração
✔ Sem tamanho fixo
✔ Tipagem dinâmica


📚 Estruturas de Dados — “Working Storage Turbo”

🔹 List → Tabelas OCCURS

clientes = ["Ana", "João", "Maria"]
clientes.append("Carlos")

👉 Similar a:

OCCURS n TIMES

🔹 Dictionary → Registro com campos nomeados

cliente = {
"nome": "Ana",
"saldo": 1500
}

👉 Mistura de:

✔ Registro
✔ Índice por chave
✔ Estrutura dinâmica


🔹 Tuple → Registro imutável

coordenada = (10, 20)

👉 Ideal quando dados não devem mudar.


🔹 Set → Lista sem duplicatas

codigos = {101, 102, 102, 103}

Resultado:

{101, 102, 103}

👉 Excelente para deduplicação de dados.


🔎 Indexação

nome = "BELLACOSA"

nome[0] # B
nome[-1] # A

👉 Python começa em ZERO (como C, não como COBOL).


⚖️ Condições (IF sem THEN/END-IF)

saldo = 100

if saldo > 0:
print("Positivo")
else:
print("Negativo")

🔁 Loops

🔹 For (PERFORM VARYING)

for i in range(5):
print(i)

🔹 For em coleção

for cliente in clientes:
print(cliente)

👉 Cursor implícito.


🔹 Enumerate (índice + valor)

for i, nome in enumerate(clientes):
print(i, nome)

🔹 While (PERFORM UNTIL)

x = 0

while x < 5:
print(x)
x += 1

🧩 Funções (Subprogramas leves)

def calcular_taxa(valor):
return valor * 0.05

Chamada:

taxa = calcular_taxa(1000)

📏 Built-ins que substituem muito código COBOL

len(lista) # tamanho
sum(lista) # soma
max(lista)
min(lista)
sorted(lista)

⚠️ Tratamento de Erros (sem Abend 😎)

COBOL

ON EXCEPTION

Python

try:
x = int("abc")
except ValueError:
print("Erro de conversão")

📂 Arquivos (QSAM moderno)

Leitura

with open("dados.txt", "r") as f:
for linha in f:
print(linha)

Escrita

with open("saida.txt", "w") as f:
f.write("Hello Mainframe")

👉 with garante fechamento automático.


🧱 Classes (Estruturas + Comportamento)

class Conta:
def __init__(self, saldo):
self.saldo = saldo

def depositar(self, valor):
self.saldo += valor

Uso:

c = Conta(1000)
c.depositar(500)

🔍 Tipos e Debug

type(x)

🚀 Automação — O Superpoder

Executar comandos do sistema

import os

os.system("dir")

Processar arquivos em lote

import glob

for arquivo in glob.glob("*.txt"):
print(arquivo)

🌐 Integração moderna

Consumir API

import requests

r = requests.get("https://api.github.com")
print(r.status_code)

👉 Equivalente moderno de MQ + Web Services.


🧠 Padrões mentais úteis

Python é:

✔ Scriptável
✔ Interativo
✔ Orientado a objetos
✔ Ideal para automação
✔ Excelente para integração


💥 Onde Python brilha para Mainframe Engineers

🔥 Automação operacional
🔥 DevOps e pipelines
🔥 Testes de batch
🔥 Processamento de logs
🔥 APIs REST para legado
🔥 Data Engineering
🔥 Machine Learning
🔥 RPA e scripting corporativo


☕ Frase estilo War Room

👉 COBOL mantém o mundo funcionando.
Python automatiza o mundo que muda.

segunda-feira, 29 de dezembro de 2025

💥 MQ NÃO É FILA — É O SEGURO DE VIDA DO SEU COBOL

 

Bellacosa Mainframe conheça MQ 

💥 MQ NÃO É FILA — É O SEGURO DE VIDA DO SEU COBOL

O guia definitivo de IBM MQ Fundamentals para quem vive no z/OS

Se você é um dev COBOL experiente, já sabe:
👉 o problema nunca foi o código…
👉 o problema sempre foi integração.

E é exatamente aí que entra o IBM MQ — o componente que transformou o mainframe de “ilha isolada” em coração da arquitetura moderna.


🕰️ ORIGEM — POR QUE O MQ EXISTE?

Antes do MQ:

  • Sistemas conversavam via sockets, arquivos, chamadas diretas
  • Tudo era síncrono
  • Se o destino caía → 💥 tudo quebrava

👉 A IBM criou o MQ (antigo WebSphere MQ) para resolver:

✔ Desacoplamento
✔ Confiabilidade
✔ Escalabilidade
✔ Integração heterogênea

💡 Tradução Bellacosa:

“MQ nasceu para impedir que um sistema derrube o outro.”


🧠 CONCEITO CENTRAL (O QUE MUDA TUDO)

👉 Aplicações não se falam diretamente

Elas falam com filas.


📦 MODELO MENTAL

COBOL A → MQ → COBOL B

✔ A envia
✔ MQ guarda
✔ B consome

👉 Simples… e revolucionário


💥 O TRIO QUE VOCÊ NUNCA ESQUECE

ConceitoPapel
MessageUnidade de dados
QueueArmazenamento
Queue ManagerCérebro

🧠 FRASE DE OURO

“Sem Queue Manager… não existe MQ.”


⚙️ COMO ISSO FUNCIONA (PASSO A PASSO REAL)

🔹 1. Aplicação COBOL envia mensagem

CALL 'MQPUT' USING ...

👉 Não importa:

  • Se o destino está online
  • Onde ele está
  • Qual linguagem usa

🔹 2. MQ armazena na fila

✔ Persistente (disco)
✔ Seguro
✔ Ordenado


🔹 3. Outra aplicação consome

CALL 'MQGET' USING ...

👉 Pode ser:

  • COBOL
  • Java
  • .NET
  • SAP

🔄 ASSÍNCRONO — O PODER REAL

👉 Diferente de CICS sync:

✔ Envia → continua
✔ Não bloqueia
✔ Alta performance

💡 Isso muda tudo em batch + online


💾 PERSISTENT vs NON-PERSISTENT

🔥 Persistent

✔ Gravado em disco
✔ Não perde
✔ Entrega garantida

👉 Use em:

  • Financeiro
  • Débito
  • Liquidação

⚡ Non-persistent

✔ Mais rápido
❌ Pode perder

👉 Use em:

  • Consulta
  • Logs
  • Eventos leves

🔄 UOW — TRANSAÇÃO DE VERDADE

👉 Unit of Work = grupo de mensagens

✔ Tudo ou nada

💡 Exemplo:

  • 4 mensagens
  • 1 falha

👉 MQ faz rollback de todas


💀 DLQ — DEAD LETTER QUEUE

👉 Quando dá ruim:

✔ Mensagem vai para DLQ
✔ Com motivo + código

💡 Easter egg de produção:

DLQ cheia = sistema gritando socorro


🔐 SEGURANÇA (NÍVEL ENTERPRISE)

🧠 OAM (Object Authority Manager)

✔ Controla acesso
✔ Quem pode PUT/GET


🔒 SSL / TLS

✔ Criptografia
✔ Autenticação


🔄 CONVERSÃO DE DADOS (A MÁGICA)

👉 COBOL (EBCDIC) ↔ Java (ASCII)

✔ MQ converte automaticamente

💡 Você nem vê acontecer


⚙️ CUSTOM CONVERSION

👉 Quer regra própria?

✔ Use exits

💡 Muito usado em legado


🧩 PADRÕES DE ARQUITETURA (OURO)


📦 Point-to-Point

✔ 1 → 1
✔ Request/Reply

👉 Clássico COBOL ↔ COBOL


💻 Client/Server

✔ Muitos → 1

👉 Centralização (ex: core bancário)


⚖️ Workload Sharing

✔ 1 fila → vários consumidores

👉 Paralelismo brutal

💡 Padrão:

Competing Consumers


📡 Publish/Subscribe

✔ 1 → muitos
✔ Desacoplado

👉 Base de Event-Driven Architecture


💣 PEGADINHAS QUE DERRUBAM SENIOR

❌ MQ é síncrono → ERRADO
❌ Aplicações se conectam direto → ERRADO
❌ Remote queue armazena mensagem → ERRADO
❌ MQ garante non-persistent → ERRADO


🧠 CENÁRIO REAL (BANCO)

👉 Fluxo típico:

  1. COBOL envia transação (MQPUT)
  2. MQ armazena (persistent)
  3. Workers processam (workload)
  4. Evento dispara (pub/sub)

💥 Tudo via MQ


🔥 CURIOSIDADES (EASTER EGGS)

  • MQ existe desde os anos 90 e ainda domina bancos
  • DLQ handler pode automatizar correções
  • MQ roda em:
    • z/OS
    • Linux
    • Windows
  • Pode transportar até 100MB por mensagem

💥 FRASES QUE DEFINEM MQ

“MQ desacopla no tempo, no espaço e na tecnologia.”

“Se caiu, MQ segura. Se voltou, MQ entrega.”

“COBOL não morreu… ele só ganhou MQ.”


🚀 CONCLUSÃO

Se você domina MQ:

✔ Seus sistemas não quebram fácil
✔ Integração deixa de ser dor
✔ Você pensa como arquiteto


💣 VERDADE FINAL

“MQ não é só middleware…
é o que separa sistemas frágeis de sistemas resilientes.”

 

quarta-feira, 1 de maio de 2024

☕💣 OPERADOR, O TRELLO ACABOU DE RECEBER ORDENS DE UM AGENTE PYTHON! — Construindo um Organizador Inteligente de Tarefas do Zero e Entendendo Como Nasce um Agente de IA

Bellacosa Mainframe crie um agente organizador Trello com o Python


☕💣 OPERADOR, O TRELLO ACABOU DE RECEBER ORDENS DE UM AGENTE PYTHON! — Construindo um Organizador Inteligente de Tarefas do Zero e Entendendo Como Nasce um Agente de IA

Imagine a seguinte cena.

São 2 horas da manhã.

O operador monitora dezenas de sistemas.

Há tarefas para acompanhar, chamados para abrir, solicitações para registrar, atividades para priorizar e uma equipe inteira esperando informações.

De repente surge uma pergunta:

"Por que ainda estamos criando tarefas manualmente?"

Foi exatamente essa pergunta que levou ao nascimento dos primeiros sistemas de automação, dos workflows corporativos e, mais recentemente, dos Agentes de Inteligência Artificial.

Hoje vamos construir um projeto extremamente importante para quem está entrando no universo dos agentes: um Organizador de Tarefas em Python integrado ao Trello.

Mas não vamos apenas escrever código.

Vamos entender arquitetura, dependências, APIs, tratamento de erros, segurança, evolução para IA e como tudo isso se conecta ao mundo corporativo e até ao universo Mainframe.

Pegue seu café.

O job acabou de entrar na fila.


O Que Estamos Construindo?

Nosso projeto será um agente capaz de:

  • Conectar-se ao Trello

  • Criar tarefas automaticamente

  • Consultar tarefas existentes

  • Mover tarefas entre listas

  • Organizar fluxos de trabalho

  • Servir como base para futuros agentes inteligentes

Visualmente teremos algo assim:

Python Agent
      ↓
API REST
      ↓
Trello
      ↓
Cards
      ↓
Workflow

Parece simples.

Mas essa mesma arquitetura é utilizada em:

  • Jira

  • ServiceNow

  • Salesforce

  • SAP

  • Zendesk

  • GitHub

  • Azure DevOps

E até em plataformas de automação como N8N.


O Que é um Agente?

Muita gente acredita que um agente é sinônimo de IA.

Não necessariamente.

Um agente é um software que:

  • Observa

  • Analisa

  • Decide

  • Executa

Nosso primeiro agente ainda não terá inteligência artificial.

Mas ele já será capaz de agir sozinho.

Isso é exatamente o primeiro estágio da evolução.


O Trello Como Ambiente de Trabalho

Antes de escrever uma linha de código precisamos preparar o Trello.

Crie uma conta.

Depois crie um Board.

Exemplo:

Projeto DIO

Agora crie três listas:

To Do

Doing

Done

Quem já trabalhou com Kanban reconhecerá imediatamente o modelo.

O fluxo é simples:

Pendente
    ↓
Executando
    ↓
Concluído

Obtendo as Credenciais

Assim como um terminal CICS exige autenticação, a API do Trello também exige.

Você precisará obter:

  • API Key

  • API Token

Essas informações funcionam como usuário e senha para seu agente.

Sem elas o Trello recusará todas as solicitações.


Instalando o Python

Verifique a instalação:

python --version

ou

python3 --version

Resultado esperado:

Python 3.10+

Se aparecer erro:

python não é reconhecido

Significa que o Python não está instalado ou não foi adicionado ao PATH.


Criando o Ambiente Virtual

Uma das melhores práticas modernas.

Crie:

python -m venv venv

Ative:

Windows

venv\Scripts\activate

Linux

source venv/bin/activate

Quando ativado:

(venv)

aparecerá antes do prompt.


Instalando Dependências

Nosso agente precisa conversar com APIs.

Instalaremos:

pip install requests python-dotenv

Essas bibliotecas possuem funções importantes.

Requests:

Consumir APIs REST

Dotenv:

Carregar variáveis seguras

Estrutura do Projeto

Organização é fundamental.

Criamos:

agente_trello/

├── app.py
├── trello.py
├── view.py
├── .env
├── requirements.txt
└── README.md

Observe que estamos separando responsabilidades.

Essa é uma prática muito valorizada em ambientes corporativos.


O Papel do app.py

Ele funciona como o maestro.

Controla:

  • Menus

  • Fluxo principal

  • Chamadas ao agente

Em Mainframe seria semelhante ao programa principal que coordena outros módulos.


O Papel do trello.py

Aqui fica toda a comunicação com a API.

Esse módulo:

  • Cria Cards

  • Consulta Cards

  • Move Cards

  • Testa conexão

Em uma analogia com COBOL:

Programa Principal
      ↓
Sub-rotina de acesso
      ↓
Banco/API

O Papel do view.py

Responsável pela apresentação.

Separar interface da lógica é uma prática extremamente importante.

Isso permite futuramente trocar:

Terminal

por

Web

ou

Dashboard

sem alterar a lógica do agente.


Variáveis de Ambiente

Nunca coloque credenciais no código.

Use:

TRELLO_KEY=
TRELLO_TOKEN=
TODO_ID=
DOING_ID=
DONE_ID=

Isso protege informações sensíveis.

É o equivalente moderno de esconder senhas em datasets protegidos por RACF.


Primeiro Teste

Execute:

python app.py

Escolha:

1 - Testar conexão

Se tudo estiver correto:

Conexão OK

Problemas Comuns

Erro 401

Unauthorized

Significa:

  • Token inválido

  • Chave inválida


Erro 404

Not Found

Significa:

  • Lista inexistente

  • ID incorreto


Erro de Importação

ModuleNotFoundError

Normalmente:

pip install requests

resolve.


Criando Seu Primeiro Card

Selecione:

Criar tarefa

Digite:

Estudar Agentes

O agente enviará:

{
  "name":"Estudar Agentes"
}

para o Trello.

Resultado:

Card criado

Instantaneamente.


Listando Tarefas

O agente consulta a API.

Recebe:

[
 {
   "name":"Estudar Python"
 }
]

e exibe:

Estudar Python

Simples.

Mas extremamente poderoso.


Movendo Tarefas

Imagine:

To Do

Ao iniciar:

Doing

Ao terminar:

Done

Nosso agente realiza isso automaticamente.

Na prática ele apenas altera um identificador interno do Trello.

Mas para o usuário parece mágica.


O Que Está Acontecendo nos Bastidores?

Quando você cria um card:

Python
   ↓
HTTP POST
   ↓
API Trello
   ↓
Banco de Dados Trello
   ↓
Resposta JSON

Isso é exatamente o mesmo conceito utilizado por:

  • APIs bancárias

  • APIs governamentais

  • APIs corporativas


Transformando em um Agente Inteligente

Agora vem a parte interessante.

Suponha que uma tarefa seja criada:

Sistema parado em produção

Uma IA pode analisar.

Resultado:

Prioridade Alta

O agente decide:

Mover para Urgente

sem intervenção humana.

Nesse momento ele deixa de ser apenas automação.

Passa a tomar decisões.


Integrando OpenAI

Exemplo conceitual:

prioridade = analisar_tarefa(descricao)

Resposta:

ALTA

O agente pode então:

if prioridade == "ALTA":
    mover_para_urgente()

Agora temos comportamento inteligente.


Integrando Ollama

Nem sempre você quer depender da nuvem.

Com Ollama é possível executar modelos locais.

Exemplos:

  • Llama

  • DeepSeek

  • Mistral

Tudo rodando em sua máquina.


Integração com N8N

Imagine:

Novo E-mail
       ↓
Webhook
       ↓
N8N
       ↓
Agente Python
       ↓
Trello

Nenhum ser humano participa.

O processo inteiro acontece sozinho.


E o Mainframe?

Agora vem a parte favorita do Bellacosa.

Imagine um JOB.

BILLJOB

executa.

O agente monitora o JES2.

Detecta:

ABEND S0C7

Automaticamente:

Lê SYSOUT

Depois:

Cria Card Trello

Em seguida:

Notifica equipe

E finalmente:

Abre incidente

Tudo sozinho.

Percebe o potencial?


O Caminho da Evolução

Nível 1:

Script

Nível 2:

Automação

Nível 3:

Workflow

Nível 4:

Agente

Nível 5:

Multiagentes

É exatamente essa trilha que está sendo seguida pela indústria.


Conclusão

Muitos enxergam esse projeto apenas como um exercício simples da DIO.

Mas ele é muito mais que isso.

Você está aprendendo:

  • Python

  • APIs REST

  • Integração entre sistemas

  • Variáveis de ambiente

  • Automação

  • Arquitetura de agentes

  • Fundamentos de IA

  • Boas práticas corporativas

O Organizador de Tarefas é apenas o começo.

A mesma arquitetura pode evoluir para:

  • Assistentes corporativos

  • Agentes DevOps

  • Agentes FinOps

  • Agentes Mainframe

  • Agentes de atendimento

  • Agentes de monitoramento

E talvez, em um futuro não muito distante, você veja uma mensagem parecida com esta aparecendo no terminal:

☕💣 OPERADOR!

Detectei um problema no sistema.

Já analisei os logs.
Já consultei incidentes anteriores.
Já criei o Card no Trello.
Já notifiquei a equipe.

Deseja apenas acompanhar... ou quer que eu resolva o problema também?

segunda-feira, 30 de novembro de 2020

☕💣 FastAPI: O Framework Python que Está Conectando a Nova Geração ao Mundo Mainframe


Bellacosa Mainframe e framework FastAPI


☕💣 FastAPI: O Framework Python que Está Conectando a Nova Geração ao Mundo Mainframe

Introdução

Nos últimos anos, poucas tecnologias cresceram tão rapidamente no universo Python quanto o FastAPI. Em um mercado cada vez mais orientado por APIs, microsserviços, computação em nuvem e inteligência artificial, o FastAPI tornou-se uma das ferramentas preferidas para a construção de aplicações modernas.

Mas afinal:

  • O que é FastAPI?

  • Quem criou?

  • Quando surgiu?

  • Como funciona?

  • Por que ele ficou tão popular?

  • Qual sua relação com o universo Mainframe?

Para profissionais acostumados com COBOL, CICS, IMS, DB2 e z/OS, compreender o FastAPI é também entender como as novas aplicações estão consumindo e expondo serviços em arquiteturas distribuídas.


A Origem do FastAPI

O FastAPI foi criado por Sebastián Ramírez, desenvolvedor de software da América Latina conhecido na comunidade Python como "tiangolo".

O projeto nasceu da necessidade de criar um framework que reunisse simultaneamente:

  • Alto desempenho

  • Facilidade de desenvolvimento

  • Tipagem forte

  • Documentação automática

  • Compatibilidade com padrões modernos da web

O lançamento inicial ocorreu em 2018.

Na época, o mercado Python era dominado principalmente por:

  • Django

  • Flask

  • Pyramid

  • Tornado

Embora extremamente populares, essas soluções possuíam algumas limitações para aplicações REST modernas.

Sebastián percebeu que era possível criar uma alternativa mais simples e ao mesmo tempo extremamente rápida.

O resultado foi o FastAPI.


Licença Open Source

O FastAPI é distribuído sob a licença:

MIT License

Uma das licenças mais permissivas do mercado.

Isso significa que empresas podem:

  • Utilizar gratuitamente

  • Modificar

  • Distribuir

  • Incorporar em produtos comerciais

sem necessidade de pagamento de royalties.

Essa característica acelerou sua adoção em bancos, fintechs, seguradoras e grandes corporações.


O Que é FastAPI?

FastAPI é um framework para desenvolvimento de APIs REST utilizando Python.

Seu objetivo principal é permitir que desenvolvedores construam serviços web modernos de forma rápida, segura e altamente performática.

De forma simplificada:

Aplicação Cliente
       ↓
API FastAPI
       ↓
Banco de Dados
       ↓
Sistemas Legados
       ↓
Serviços Externos

O FastAPI funciona como uma camada de integração capaz de receber solicitações, processar regras de negócio e retornar respostas.


Por Que o Nome "FastAPI"?

A palavra "Fast" não foi escolhida por acaso.

O FastAPI foi projetado para oferecer desempenho extremamente elevado.

Os testes realizados pela comunidade mostram resultados próximos a frameworks escritos em linguagens tradicionalmente mais rápidas, como:

  • Go

  • Java

  • Node.js

  • C#

Isso ocorre graças à utilização de componentes modernos do ecossistema Python.


Os Pilares do FastAPI

O framework foi construído sobre três tecnologias fundamentais:

Starlette

Responsável pela camada web.

Fornece:

  • Rotas

  • Requisições HTTP

  • Respostas

  • WebSockets

É equivalente ao motor que controla o tráfego das requisições.


Pydantic

Responsável pela validação dos dados.

Permite garantir que as informações recebidas estejam corretas antes de serem processadas.

Exemplo:

class Cliente(BaseModel):
    codigo: int
    nome: str

Se alguém enviar um valor inválido, o próprio framework rejeita a requisição.


Uvicorn

Servidor ASGI utilizado para executar aplicações FastAPI.

Pode ser comparado ao ambiente de execução da aplicação.


Como Funciona uma API?

Antes de entender o FastAPI, precisamos entender o conceito de API.

API significa:

Application Programming Interface

Em termos simples:

É uma forma padronizada para que sistemas conversem entre si.

Por exemplo:

Aplicativo Mobile
       ↓
API
       ↓
Sistema Bancário

Quando o usuário consulta o saldo, o aplicativo não acessa diretamente o banco de dados.

Ele chama uma API.

A API consulta os dados e devolve a resposta.


O Conceito de Endpoint

No FastAPI, cada serviço é chamado de endpoint.

Exemplo:

@app.get("/clientes")

Significa:

GET /clientes

Quando alguém acessar essa URL, o código correspondente será executado.

Para um profissional de CICS, podemos fazer a seguinte analogia:

Transação CICS
      =
Endpoint REST

Cada endpoint representa uma funcionalidade específica.


Exemplo de Código

Um serviço extremamente simples:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def inicio():
    return {
        "mensagem": "Olá Mundo"
    }

Ao acessar:

http://localhost:8000

A resposta será:

{
  "mensagem": "Olá Mundo"
}

Tipagem Moderna

Uma das maiores inovações do FastAPI é o uso intensivo de tipagem.

Exemplo:

@app.get("/cliente/{codigo}")
def cliente(codigo:int):
    return {"codigo":codigo}

Observe:

codigo:int

O framework entende automaticamente que o parâmetro deve ser um número inteiro.

Se um valor inválido for informado, a requisição é rejeitada.


Documentação Automática

Uma das funcionalidades mais admiradas pelos desenvolvedores.

Ao iniciar a aplicação:

uvicorn main:app --reload

O FastAPI gera automaticamente:

/docs

Utilizando Swagger UI.

E também:

/redoc

Utilizando ReDoc.

Isso elimina horas de documentação manual.


JSON: A Linguagem Universal

O principal formato utilizado pelo FastAPI é o JSON.

Exemplo:

{
  "codigo":1001,
  "nome":"Bellacosa"
}

Para quem trabalha com Mainframe, JSON pode ser visto como uma evolução moderna da COMMAREA.

No passado:

01 DFHCOMMAREA.
   05 CODIGO PIC 9(5).
   05 NOME   PIC X(30).

Hoje:

{
   "codigo":1001,
   "nome":"Bellacosa"
}

O objetivo continua sendo o mesmo:

Trocar informações entre sistemas.


Operações HTTP

O FastAPI suporta os principais métodos HTTP.

GET

Consulta dados.

@app.get("/clientes")

POST

Inclui dados.

@app.post("/clientes")

PUT

Atualiza informações.

@app.put("/clientes")

DELETE

Remove registros.

@app.delete("/clientes")

Segurança

O FastAPI possui recursos avançados de autenticação.

Entre eles:

  • OAuth2

  • JWT

  • API Keys

  • LDAP

  • Active Directory

  • OpenID Connect

Isso permite integração com ambientes corporativos de grande porte.


Serviços Modernos Criados com FastAPI

Hoje encontramos FastAPI em:

Bancos

  • Consulta de saldo

  • PIX

  • Open Finance

  • Cartões

Seguradoras

  • Cálculo de apólices

  • Sinistros

E-commerce

  • Catálogo

  • Pedidos

  • Estoque

Saúde

  • Prontuários

  • Agendamentos

Governo

  • Portais digitais

  • Serviços públicos


FastAPI e Inteligência Artificial

Uma das razões do crescimento explosivo do FastAPI é a Inteligência Artificial.

Ferramentas modernas utilizam FastAPI para expor modelos de IA.

Exemplos:

  • Chatbots

  • Assistentes virtuais

  • Sistemas RAG

  • LLMs

  • Processamento de documentos

Muitas soluções de IA usam FastAPI como camada de acesso.


FastAPI e Mainframe

Aqui encontramos um tema extremamente interessante.

Muitas empresas possuem décadas de investimento em Mainframe.

Os sistemas COBOL continuam executando funções críticas como:

  • Contas correntes

  • Folha de pagamento

  • Processamento de cartões

  • Previdência

  • Seguros

Entretanto, novas aplicações precisam acessar esses sistemas.

É nesse momento que o FastAPI entra em cena.


Cenário Típico de Integração

Imagine:

Aplicativo Mobile
        ↓
FastAPI
        ↓
z/OS Connect
        ↓
CICS
        ↓
Programa COBOL

O usuário realiza uma operação.

A API recebe a solicitação.

O FastAPI chama um serviço no Mainframe.

O COBOL processa a transação.

A resposta retorna em JSON.


FastAPI Consumindo Web Services do Mainframe

É comum encontrar arquiteturas como:

FastAPI
     ↓
REST
     ↓
z/OS Connect
     ↓
COBOL

ou

FastAPI
     ↓
SOAP
     ↓
CICS Web Services

Nesse modelo, o FastAPI funciona como uma ponte entre o mundo moderno e os sistemas legados.


FastAPI como Camada de Modernização

Muitas organizações utilizam FastAPI para:

  • Encapsular sistemas legados

  • Expor APIs modernas

  • Criar microsserviços

  • Construir portais web

  • Desenvolver aplicativos móveis

Sem alterar os programas COBOL existentes.

Essa estratégia reduz riscos e custos.


Comparação com Tecnologias Mainframe

MainframeFastAPI
CICSServidor de APIs
TransaçãoEndpoint
COMMAREAJSON
COBOLPython
RACFOAuth/JWT
BMSFront-End Web
MQAPIs REST
Programa OnlineServiço HTTP

Vantagens do FastAPI

Entre os principais benefícios estão:

  • Desenvolvimento rápido

  • Curva de aprendizado simples

  • Alto desempenho

  • Documentação automática

  • Tipagem forte

  • Integração com IA

  • Integração com Mainframe

  • Grande comunidade

  • Código limpo


Limitações

Nenhuma tecnologia é perfeita.

Algumas limitações incluem:

  • Ecossistema mais novo que Django

  • Menor quantidade de plugins

  • Dependência do Python

  • Necessidade de conhecimento de APIs REST

Mesmo assim, seu crescimento continua acelerado.


Conclusão

O FastAPI tornou-se uma das tecnologias mais importantes do ecossistema Python moderno. Lançado em 2018 por Sebastián Ramírez sob licença MIT, ele revolucionou a criação de APIs ao combinar simplicidade, velocidade e recursos avançados de validação e documentação.

Para profissionais de Mainframe, o FastAPI não deve ser visto como concorrente do COBOL ou do CICS. Pelo contrário. Ele atua como uma poderosa camada de integração que permite conectar aplicações modernas aos sistemas corporativos que continuam movimentando bilhões de transações diariamente.

Em muitos projetos atuais, o COBOL permanece responsável pelas regras de negócio mais críticas, enquanto o FastAPI assume o papel de porta de entrada para aplicativos móveis, soluções em nuvem, plataformas digitais e sistemas de inteligência artificial.

Em outras palavras, o FastAPI está para a Internet moderna assim como o CICS esteve para o processamento online corporativo durante décadas: uma plataforma capaz de transformar regras de negócio em serviços acessíveis, escaláveis e disponíveis para milhões de usuários.

☕💣 Bellacosa Mainframe Insight: "O COBOL continua guardando as regras de negócio. O FastAPI apenas abre a porta para que o mundo moderno converse com elas."


segunda-feira, 12 de março de 2007

O que são APIs e seu Uso no Mainframe?

 

Bellacosa Mainframe apresenta API na Stack Mainframe

O que são APIs e seu Uso no Mainframe?

As APIs (Application Programming Interfaces) revolucionaram a forma como sistemas trocam informações. Hoje, elas são a principal ponte entre aplicações modernas, dispositivos móveis, plataformas Cloud e os sistemas Mainframe que processam as operações mais críticas do mundo.

Quando você consulta saldo pelo celular, faz um PIX, compra com cartão ou utiliza um aplicativo bancário, existe uma grande chance de uma API estar conversando com um programa COBOL executando em um Mainframe IBM Z.


O que é uma API?

API significa:

Application Programming Interface

Ou seja:

Interface de Programação de Aplicações

É um conjunto de regras que permite que um sistema solicite serviços ou informações de outro sistema.


Analogia Simples

Imagine um restaurante:

Cliente
   ↓
Garçom
   ↓
Cozinha
   ↓
Resposta

Nesse cenário:

  • Cliente = Aplicação

  • Garçom = API

  • Cozinha = Sistema Mainframe

A API recebe o pedido, encaminha para o sistema correto e devolve a resposta.


Exemplo do Dia a Dia

Aplicativo bancário:

App Mobile
      ↓
API
      ↓
COBOL
      ↓
DB2
      ↓
Resposta

O cliente vê apenas a tela do aplicativo.

Nos bastidores, uma API conversa com o Mainframe.


Por que APIs são importantes?

Antes das APIs, a integração era feita através de:

Arquivos
FTP
MQ
Batch
Troca de datasets

Essas soluções funcionavam, mas eram mais lentas e complexas.

As APIs permitem:

✅ Integração em tempo real

✅ Menor acoplamento

✅ Reutilização de serviços

✅ Facilidade de manutenção

✅ Integração com Cloud


Principais Tipos de API

REST

O mais utilizado atualmente.

Comunica-se normalmente usando:

HTTP
HTTPS
JSON

Exemplo:

GET /clientes/1001

Resposta:

{
  "id":1001,
  "nome":"JOAO SILVA"
}

SOAP

Muito utilizado em Mainframe.

Baseado em:

XML
WSDL
HTTP

Exemplo:

<ConsultaSaldo>
   <Conta>12345</Conta>
</ConsultaSaldo>

GraphQL

Mais moderno.

Permite solicitar apenas os dados necessários.


APIs e o Mainframe

O Mainframe tradicionalmente trabalha com:

  • COBOL

  • CICS

  • IMS

  • DB2

  • VSAM

As APIs funcionam como uma camada de integração.


Arquitetura Moderna

Mobile
   ↓
API REST
   ↓
z/OS Connect
   ↓
COBOL
   ↓
DB2

Como o Mainframe Consome APIs?

Existem dois cenários.


1. Mainframe Expondo APIs

O COBOL oferece serviços para outros sistemas.

Exemplo:

Programa COBOL
      ↓
API REST
      ↓
Aplicativo Mobile

2. Mainframe Consumindo APIs

O COBOL chama um serviço externo.

Exemplo:

COBOL
   ↓
API Correios
   ↓
Consulta CEP

APIs REST no Mainframe

Hoje são extremamente comuns.

Utilizam:

HTTP
HTTPS
JSON
REST

Métodos HTTP

GET

Consulta dados.

GET /clientes

POST

Inclui dados.

POST /clientes

PUT

Atualiza dados.

PUT /clientes/1001

DELETE

Remove dados.

DELETE /clientes/1001

JSON e COBOL

Uma integração moderna normalmente utiliza:

JSON
   ↓
JSON PARSE
   ↓
COBOL

ou:

COBOL
   ↓
JSON GENERATE
   ↓
API

z/OS Connect

Uma das tecnologias mais importantes da IBM atualmente.

Permite transformar:

Programa COBOL

em

API REST

sem reescrever a aplicação.


Fluxo com z/OS Connect

Cliente REST
        ↓
JSON
        ↓
z/OS Connect
        ↓
Copybook COBOL
        ↓
Programa COBOL
        ↓
DB2

APIs e CICS

O CICS possui suporte para:

  • REST

  • JSON

  • SOAP

  • HTTP

  • Web Services


Exemplo:

REST API
    ↓
CICS
    ↓
COBOL

APIs e IMS

O IMS também pode ser exposto através de APIs.

Exemplo:

API REST
      ↓
IMS Connect
      ↓
IMS TM
      ↓
Programa COBOL

APIs e DB2

Consultas podem ser disponibilizadas através de APIs.

Exemplo:

SELECT SALDO
FROM CLIENTES

{
  "saldo":5000
}

Open Banking e APIs

Grande parte do Open Finance utiliza:

REST
JSON
OAuth
TLS

integrados ao Mainframe.


Segurança das APIs

Aspecto fundamental.

Normalmente utilizam:

  • HTTPS

  • TLS

  • OAuth 2.0

  • JWT

  • Certificados Digitais

  • RACF


Exemplo de Fluxo Seguro

App
 ↓
OAuth
 ↓
API
 ↓
RACF
 ↓
COBOL

Benefícios para o Mainframe

✅ Modernização sem reescrever COBOL

✅ Integração com Cloud

✅ Integração Mobile

✅ Exposição de serviços legados

✅ Reutilização de regras de negócio

✅ Menor custo de transformação digital


Desafios

❌ Segurança

❌ Governança

❌ Controle de versões

❌ Performance

❌ Monitoramento


Tecnologias Comuns

TecnologiaFunção
RESTAPIs modernas
JSONFormato de dados
SOAPWeb Services XML
z/OS ConnectExpor COBOL como API
CICSProcessamento transacional
IMS ConnectAPIs para IMS
DB2Banco de dados
RACFSegurança

Curiosidade

Muitos bancos processam milhões de chamadas de APIs por dia que, nos bastidores, executam programas COBOL escritos há décadas. O aplicativo parece moderno, mas a regra de negócio continua protegida e executada no Mainframe.


Resumo Rápido

Aplicativo
      ↓
API REST
      ↓
JSON
      ↓
z/OS Connect
      ↓
COBOL
      ↓
DB2

Conclusão

As APIs são interfaces que permitem a comunicação entre sistemas. No Mainframe, elas desempenham um papel essencial na modernização das aplicações COBOL, conectando sistemas IBM Z a aplicativos móveis, plataformas Cloud, microsserviços e ecossistemas digitais modernos. Tecnologias como REST, JSON, CICS Web Services, IMS Connect e z/OS Connect tornaram possível integrar décadas de investimento em Mainframe ao mundo das APIs de forma segura, escalável e eficiente.