Diferença entre Python e JSON

1. Python → é uma linguagem de programação, você escreve código que roda no computador.
2. JSON → é um formato de dados (JavaScript Object Notation), usado para armazenar e transportar informações. 
- Ele não calcula nada sozinho, mas pode ser lido por programas em Python, Java, JavaScript etc.
- Como o Python pode gerar automaticamente um JSON com os dados de entrada, o processo e o resultado da conversão. 
- Isso é muito útil em sistemas reais, porque o JSON é o formato mais usado para troca de informações entre aplicações 
(APIs, bancos de dados, integrações etc.).

Código em Python com Exportação para JSON

import json

# Função para converter reais em dólares
def converter_para_dolar(valor_em_reais, taxa_de_cambio):
    return valor_em_reais / taxa_de_cambio

# Programa principal
valor_em_reais = float(input("Digite o valor em reais (R$): "))
taxa_de_cambio = float(input("Digite a taxa de câmbio (quantos reais equivalem a 1 dólar): "))

valor_em_dolares = converter_para_dolar(valor_em_reais, taxa_de_cambio)

# Exibir resultado no console
print(f"Com a taxa atual, o valor em dólares é: US$ {valor_em_dolares:.2f}")

# Estrutura de dados em Python (dicionário)
dados = {
    "entrada": {
        "valor_em_reais": valor_em_reais,
        "taxa_de_cambio": taxa_de_cambio
    },
    "processo": "valor_em_dolares = valor_em_reais / taxa_de_cambio",
    "saida": {
        "valor_em_dolares": round(valor_em_dolares, 2)
    }
}

Converter para JSON (string formatada)

json_resultado = json.dumps(dados, indent=4, ensure_ascii=False)

# Exibir JSON no console
print("\nRepresentação em JSON:")
print(json_resultado)

# Opcional: salvar em arquivo
with open("conversao.json", "w", encoding="utf-8") as arquivo:
    json.dump(dados, arquivo, indent=4, ensure_ascii=False)

Exemplo de execução

    Entrada:
•	valor_em_reais = 500
•	taxa_de_cambio = 5.00
    Saída no console:
Com a taxa atual, o valor em dólares é: US$ 100.00
Arquivo conversao.json gerado:
{
    "entrada": {
        "valor_em_reais": 500.0,
        "taxa_de_cambio": 5.0
    },
    "processo": "valor_em_dolares = valor_em_reais / taxa_de_cambio",
    "saida": {
        "valor_em_dolares": 100.0
    }
}

Vantagens de integrar JSON

1. Interoperabilidade: qualquer sistema (Java, C#, JavaScript, etc.) consegue ler esse formato.
2. Padronização: facilita a comunicação entre serviços de uma agência de viagens (ex.: site, app, sistema de 
reservas).
3. Armazenamento: pode ser salvo em arquivos ou bancos NoSQL (como MongoDB).

Simulação 01

[Como esse conversor de moedas poderia ser usado em um cenário de API — ou seja, um sistema de 
reservas de viagens que recebe um valor em reais e devolve o valor em dólares em formato JSON.]

# Criando uma API simples com Flask (Python)
[O Flask é um microframework em Python muito usado para criar APIs de forma rápida e didática. Veja como ficaria:
from flask import Flask, request, jsonify

app = Flask(__name__)

# Função de conversão
def converter_para_dolar(valor_em_reais, taxa_de_cambio):
    return valor_em_reais / taxa_de_cambio

# Rota da API
@app.route('/converter', methods=['POST'])
def converter():
    dados = request.get_json()  # Recebe os dados em JSON
    valor_em_reais = dados['valor_em_reais']
    taxa_de_cambio = dados['taxa_de_cambio']
    
    valor_em_dolares = converter_para_dolar(valor_em_reais, taxa_de_cambio)
    
    resposta = {
        "entrada": dados,
        "saida": {
            "valor_em_dolares": round(valor_em_dolares, 2)
        }
    }
    return jsonify(resposta)

if __name__ == '__main__':
    app.run(debug=True)
    

Exemplo de Requisição (Cliente → Servidor)

[Um cliente (pode ser outro sistema, um app ou até o Postman) enviaria um POST para a API:]
POST /converter
Content-Type: application/json

{
  "valor_em_reais": 500,
  "taxa_de_cambio": 5.0
}

    Resposta da API (Servidor → Cliente)
{
  "entrada": {
    "valor_em_reais": 500,
    "taxa_de_cambio": 5.0
  },
  "saida": {
    "valor_em_dolares": 100.0
  }
}

Vantagens desse modelo

1. Automatização: qualquer sistema pode consumir essa API e obter o valor convertido.
2. Escalabilidade: fácil de integrar em sites, apps móveis ou sistemas internos da agência.
3. Padronização: JSON é universal, então funciona em qualquer linguagem.

Simulação 02

[Como um cliente em Python pode consumir a API que criamos com Flask usando a biblioteca requests. 
Assim você verá o ciclo completo: 
o app de viagens envia os dados em reais → a API responde em dólares → o cliente exibe o resultado.]

    Código do Cliente em Python (consumindo a API)
import requests

# URL da API (supondo que esteja rodando localmente na porta 5000)
url = "http://127.0.0.1:5000/converter"

# Dados de entrada
payload = {
    "valor_em_reais": 500,
    "taxa_de_cambio": 5.0
}

# Enviando requisição POST com JSON
response = requests.post(url, json=payload)

# Verificando resposta
if response.status_code == 200:
    dados = response.json()
    print("Resposta da API:")
    print(dados)
else:
    print("Erro na requisição:", response.status_code)

    O que o cliente envia
{
  "valor_em_reais": 500,
  "taxa_de_cambio": 5.0
}

    O que a API responde
{
  "entrada": {
    "valor_em_reais": 500,
    "taxa_de_cambio": 5.0
  },
  "saida": {
    "valor_em_dolares": 100.0
  }
}

Como isso se encaixa no sistema de viagens

•	O site da agência poderia enviar o valor da compra em reais para a API.
•	A API converte e devolve em dólares.
•	O app do cliente exibe o valor convertido, útil para turistas estrangeiros.

O Pacote Completo

1.	Algoritmo em linguagem natural.
2.	Pseudocódigo (Visualg).
3.	Código em Python.
4.	Representação em JSON.
5.	API com Flask.
6.	Cliente em Python consumindo a API.

Implantando a API em Cloud Computing

• Em Cloud Computing (ex.: Heroku, Render, Azure) a API fica acessível remotamente para todos de qualquer lugar
  desde que se tenha acesso a rede de internet compatível e permissão de acesso.

# Os 03 caminhos bem usados para Implantar uma API Flask na Nuvem:
    
# 1. Heroku (mais simples para começar)
•	Passos básicos: 
1.	Instalar o Heroku CLI.
2.	Criar um arquivo requirements.txt com as dependências (ex.: Flask e gunicorn).
3.	Criar um arquivo Procfile com: 
4.	web: gunicorn app:app
(supondo que seu arquivo principal se chama app.py).
5.	Fazer login no Heroku (heroku login).
6.	Criar o app (heroku create nome-do-app).
7.	Fazer deploy (git push heroku main).
•	Resultado: você ganha uma URL pública como https://nome-do-app.herokuapp.com/converter.

# 2. Google Cloud Run (serverless, escala automático)
•	Você empacota sua API Flask em um container Docker.
•	Com um único comando, o Google Cloud Run cria a infraestrutura e gera uma URL pública.
•	Guia oficial: Deploy Flask no Cloud Run.

# 3. Azure App Service (ótimo para quem já usa Microsoft)
•	Você pode subir o código direto ou empacotar em container.
•	Ele cuida de escalabilidade, monitoramento e segurança.
•	Tutorial oficial: Implantar Flask no Azure.

# Exemplo de Estrutura de Arquivos para Deploy (Heroku)

/meu-projeto
│── app.py              # sua API Flask
│── requirements.txt    # dependências
│── Procfile            # instruções de execução
│── runtime.txt         # versão do Python (opcional)
requirements.txt
Flask==2.3.2
gunicorn==20.1.0
Procfile
web: gunicorn app:app

Vantagens de levar para a nuvem

•	Acessível de qualquer lugar 
•	Escalável: suporta muitos usuários sem você se preocupar com servidores.
•	Integração fácil: apps móveis, sites e sistemas podem consumir sua API.
•	Profissionalismo: sua agência de viagens teria um serviço confiável e moderno.

Passo a Passo – Deploy Flask no Heroku

    # 1. Preparar o projeto
    Crie uma pasta para o projeto e coloque dentro:
•	app.py → seu código Flask (a API de conversão).
•	requirements.txt → lista de dependências.
•	Procfile → instruções de execução no Heroku.
•	(opcional) runtime.txt → versão do Python.
    
    # 2. Arquivos necessários
app.py (exemplo simplificado):
from flask import Flask, request, jsonify

app = Flask(__name__)

def converter_para_dolar(valor_em_reais, taxa_de_cambio):
    return valor_em_reais / taxa_de_cambio

@app.route('/converter', methods=['POST'])
def converter():
    dados = request.get_json()
    valor_em_reais = dados['valor_em_reais']
    taxa_de_cambio = dados['taxa_de_cambio']
    valor_em_dolares = converter_para_dolar(valor_em_reais, taxa_de_cambio)
    return jsonify({
        "entrada": dados,
        "saida": {"valor_em_dolares": round(valor_em_dolares, 2)}
    })

if __name__ == '__main__':
    app.run()
requirements.txt:
Flask==2.3.2
gunicorn==20.1.0
Procfile (sem extensão):
web: gunicorn app:app
runtime.txt (opcional, para fixar versão do Python):
python-3.10.12

    # 3. Instalar ferramentas
•	Git
•	Heroku CLI
•	Python já deve estar instalado.

    

# 4. Comandos no terminal
# entrar na pasta do projeto
cd meu-projeto

# inicializar repositório git
git init
git add .
git commit -m "Primeiro commit da API de conversão"

# login no Heroku
heroku login

# criar app no Heroku (nome único)
heroku create conversor-moedas-ricardo

# enviar código para o Heroku
git push heroku master   # ou: git push heroku main

# abrir no navegador
heroku open

# 5. Testar a API
Depois do deploy, você terá uma URL como:
https://conversor-moedas-ricardo.herokuapp.com/converter
Teste com curl, Postman ou até mesmo com o cliente Python requests:
import requests

url = "https://conversor-moedas-ricardo.herokuapp.com/converter"
payload = {"valor_em_reais": 500, "taxa_de_cambio": 5.0}

resposta = requests.post(url, json=payload)
print(resposta.json())
Saída esperada:
{
  "entrada": {
    "valor_em_reais": 500,
    "taxa_de_cambio": 5.0
  },
  "saida": {
    "valor_em_dolares": 100.0
  }
}

O ciclo completo de ideia → lógica → código → integração → nuvem.

1.	Algoritmo em linguagem natural
2.	Pseudocódigo (Visualg)
3.	Python executável
4.	JSON estruturado
5.	API Flask
6.	Cliente Python
7.	Deploy em Cloud (Heroku)

Cibersegurança – Autenticação por Token (JWT)

- JWT (JSON Web Token) é como um crachá digital: o servidor gera um token assinado quando o usuário faz login. 

# Vantagens: 
•	Esse token é enviado pelo cliente em cada requisição, geralmente no cabeçalho HTTP (Authorization: Bearer <token>).
•	O servidor valida o token antes de permitir o acesso à rota protegida.
•	Assim, não é preciso guardar sessão no servidor, o que torna o sistema mais escalável e seguro.

Exemplo de API Flask com JWT

from flask import Flask, request, jsonify
import jwt
import datetime

app = Flask(__name__)
app.config['SECRET_KEY'] = 'minha_chave_secreta'  # troque por algo seguro

# Função de conversão
def converter_para_dolar(valor_em_reais, taxa_de_cambio):
    return valor_em_reais / taxa_de_cambio

# Rota de login (gera token)
@app.route('/login', methods=['POST'])
def login():
    dados = request.get_json()
    usuario = dados.get("usuario")
    senha = dados.get("senha")

Exemplo simples: usuário fixo

if usuario == "admin" and senha == "1234":
    token = jwt.encode(
        {
            'usuario': usuario,
            'exp': datetime.datetime.utcnow() + datetime.timedelta(minutes=30)
        },
        app.config['SECRET_KEY'],
        algorithm="HS256"
    )
    return jsonify({'token': token})
return jsonify({'mensagem': 'Credenciais inválidas'}), 401

Rota protegida

@app.route('/converter', methods=['POST'])
def converter():
    token = request.headers.get('Authorization')
    if not token:
        return jsonify({'mensagem': 'Token ausente'}), 403

   try:
        token = token.split(" ")[1]  # remove "Bearer"
        jwt.decode(token, app.config['SECRET_KEY'], algorithms=["HS256"])
    except Exception as e:
        return jsonify({'mensagem': 'Token inválido ou expirado'}), 403

   dados = request.get_json()
    valor_em_reais = dados['valor_em_reais']
    taxa_de_cambio = dados['taxa_de_cambio']
    valor_em_dolares = converter_para_dolar(valor_em_reais, taxa_de_cambio)

   return jsonify({
        "entrada": dados,
        "saida": {"valor_em_dolares": round(valor_em_dolares, 2)}
    })

if __name__ == '__main__':
    app.run(debug=True)

Fluxo de uso

1.	Login → cliente envia usuário/senha para /login.
Exemplo: 
{ "usuario": "admin", "senha": "1234" }
Resposta: 
{ "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6..." }

2.	Requisição protegida → cliente envia o token no cabeçalho:

3.	Authorization: Bearer <token>

# Exemplo de payload: 

{ "valor_em_reais": 500, "taxa_de_cambio": 5.0 }
Resposta: 
{
  "entrada": { "valor_em_reais": 500, "taxa_de_cambio": 5.0 },
  "saida": { "valor_em_dolares": 100.0 }
}

Prós & Contras

1. Vantagens
•	Segurança: só quem tem token válido acessa.
•	Escalabilidade: não precisa guardar sessão no servidor.
•	Flexibilidade: pode incluir permissões no token (ex.: admin, cliente).
2. Desafios
•	Precisa proteger bem a chave secreta.
•	Tokens expiram, então é necessário lidar com renovação.
•	Em sistemas grandes, pode ser necessário usar refresh tokens e OAuth2.

Para Consolidação do Conhecimento

•	Revise os exemplos que já construímos (pseudocódigo, Python e JSON).
•	Tente rodar o código em Python no seu computador e brincar com valores diferentes.
•	Se quiser, anote dúvidas para discussões futuras no Fórum.

Oi, Ricardo! Como vai?

Seu pseudocódigo está bem estruturado e a explicação sobre vantagens e limitações ficou clara. Gostei de como você trouxe também uma versão em Python e até em JSON, mostrando diferentes representações da mesma lógica.

Conte com o apoio da comunidade Alura na sua jornada. Abraços e bons estudos!

Muito obrigado, Armando.