Arquivo de Web - Página 2 de 10

Categorias

Conceitos fundamentais do graphql

GraphQL tem três operações principais: query, mutation e subscription. Query busca dados (equivalente ao GET do REST). Mutation altera dados (POST, PUT, DELETE). Subscription recebe dados em tempo real (WebSockets). Cada operação é definida em um esquema com tipos. Tipos podem ser escalares (String, Int) ou objetos complexos. A voz passiva é aplicada: “as relações entre tipos são declaradas explicitamente”. Exemplo de um esquema GraphQL simples:

# Esquema GraphQL (linguagem de definição de esquema)
type Usuario {
    id: ID!
    nome: String!
    email: String!
    posts: [Post!]!
}

type Post {
    id: ID!
    titulo: String!
    conteudo: String!
    autor: Usuario!
}

type Query {
    usuario(id: ID!): Usuario
    usuarios: [Usuario!]!
    post(id: ID!): Post
    posts: [Post!]!
}

type Mutation {
    criarUsuario(nome: String!, email: String!): Usuario!
    criarPost(titulo: String!, conteudo: String!, autorId: ID!): Post!
}

# Esquema GraphQL (linguagem de definição de esquema)

type Usuario {

id: ID!

nome: String!

email: String!

posts: [Post!]!

}

type Post {

id: ID!

titulo: String!

conteudo: String!

autor: Usuario!

}

type Query {

usuario(id: ID!): Usuario

usuarios: [Usuario!]!

post(id: ID!): Post

posts: [Post!]!

}

type Mutation {

criarUsuario(nome: String!, email: String!): Usuario!

criarPost(titulo: String!, conteudo: String!, autorId: ID!): Post!

}

O cliente pode fazer consultas como: { usuario(id: 1) { nome email posts { titulo } } }. Isso retorna apenas os campos solicitados, nada mais. A fórmula de economia de dados é: \(E = 1 – \frac{T_{\text{GraphQL}}}{T_{\text{REST}}}\) Onde T representa o tamanho dos dados transferidos. GraphQL pode economizar até 70% de tráfego em aplicações ricas.

Implementando graphql com graphene e django

Graphene é a biblioteca padrão para GraphQL em Python. Ela funciona com Django, Flask, FastAPI e SQLAlchemy. Primeiro, instale com pip install graphene graphene-django. Depois, defina os tipos (Type) e as queries (Query). Quando usar Graphene? Em projetos Django que exigem flexibilidade. Também em APIs públicas onde clientes têm necessidades diversas. Exemplo completo de API GraphQL com Django:

# models.py (Django)
from django.db import models

class Autor(models.Model):
    nome = models.CharField(max_length=100)
    email = models.EmailField(unique=True)

class Livro(models.Model):
    titulo = models.CharField(max_length=200)
    ano = models.IntegerField()
    autor = models.ForeignKey(Autor, on_delete=models.CASCADE, related_name='livros')

# schema.py (GraphQL)
import graphene
from graphene_django import DjangoObjectType
from .models import Autor, Livro

class AutorType(DjangoObjectType):
    class Meta:
        model = Autor
        fields = ('id', 'nome', 'email', 'livros')

class LivroType(DjangoObjectType):
    class Meta:
        model = Livro
        fields = ('id', 'titulo', 'ano', 'autor')

class Query(graphene.ObjectType):
    todos_autores = graphene.List(AutorType)
    autor_por_id = graphene.Field(AutorType, id=graphene.Int(required=True))
    livros_por_ano = graphene.List(LivroType, ano=graphene.Int(required=True))
    
    def resolve_todos_autores(self, info):
        return Autor.objects.all()
    
    def resolve_autor_por_id(self, info, id):
        try:
            return Autor.objects.get(id=id)
        except Autor.DoesNotExist:
            return None
    
    def resolve_livros_por_ano(self, info, ano):
        return Livro.objects.filter(ano=ano)

class CriarAutor(graphene.Mutation):
    class Arguments:
        nome = graphene.String(required=True)
        email = graphene.String(required=True)
    
    autor = graphene.Field(AutorType)
    
    def mutate(self, info, nome, email):
        autor = Autor.objects.create(nome=nome, email=email)
        return CriarAutor(autor=autor)

class Mutation(graphene.ObjectType):
    criar_autor = CriarAutor.Field()

schema = graphene.Schema(query=Query, mutation=Mutation)

# urls.py (configuração do endpoint GraphQL)
from django.urls import path
from graphene_django.views import GraphQLView
from .schema import schema

urlpatterns = [
    path('graphql/', GraphQLView.as_view(graphiql=True, schema=schema)),
]

# models.py (Django)

from django.db import models

class Autor(models.Model):

nome = models.CharField(max_length=100)

email = models.EmailField(unique=True)

class Livro(models.Model):

titulo = models.CharField(max_length=200)

ano = models.IntegerField()

autor = models.ForeignKey(Autor, on_delete=models.CASCADE, related_name='livros')

# schema.py (GraphQL)

import graphene

from graphene_django import DjangoObjectType

from .models import Autor, Livro

class AutorType(DjangoObjectType):

class Meta:

model = Autor

fields = ('id', 'nome', 'email', 'livros')

class LivroType(DjangoObjectType):

class Meta:

model = Livro

fields = ('id', 'titulo', 'ano', 'autor')

class Query(graphene.ObjectType):

todos_autores = graphene.List(AutorType)

autor_por_id = graphene.Field(AutorType, id=graphene.Int(required=True))

livros_por_ano = graphene.List(LivroType, ano=graphene.Int(required=True))

def resolve_todos_autores(self, info):

return Autor.objects.all()

def resolve_autor_por_id(self, info, id):

try:

return Autor.objects.get(id=id)

except Autor.DoesNotExist:

return None

def resolve_livros_por_ano(self, info, ano):

return Livro.objects.filter(ano=ano)

class CriarAutor(graphene.Mutation):

class Arguments:

nome = graphene.String(required=True)

email = graphene.String(required=True)

autor = graphene.Field(AutorType)

def mutate(self, info, nome, email):

autor = Autor.objects.create(nome=nome, email=email)

return CriarAutor(autor=autor)

class Mutation(graphene.ObjectType):

criar_autor = CriarAutor.Field()

schema = graphene.Schema(query=Query, mutation=Mutation)

# urls.py (configuração do endpoint GraphQL)

from django.urls import path

from graphene_django.views import GraphQLView

from .schema import schema

urlpatterns = [

path('graphql/', GraphQLView.as_view(graphiql=True, schema=schema)),

]

Acesse /graphql/ no navegador para ver o GraphiQL. Essa interface interativa permite testar consultas e mutações. O GraphQL playground é uma das maiores vantagens da tecnologia.

GraphQL vs. rest: quando escolher cada um

REST é mais simples e adequado para APIs padrão. GraphQL é mais flexível e eficiente para clientes variados. Quando escolher GraphQL? Em aplicações com muitos recursos relacionados. Por exemplo, dashboards, aplicações móveis ou feeds de redes sociais. REST é melhor para APIs públicas simples e caching em CDN. GraphQL tem curva de aprendizado mais íngreme que REST. A voz passiva é usada: “as decisões de escolha são baseadas no contexto”. Graphene é excelente, mas a comunidade é menor que a do DRF. Para projetos pequenos, REST ainda é mais prático. Para sistemas complexos com frontend exigente, GraphQL brilha. Combine ambos: use REST para operações simples e GraphQL para consultas complexas. Comece com REST e migre partes específicas para GraphQL quando necessário. GraphQL não é bala de prata, mas é uma ferramenta poderosa. Experimente Graphene em seu próximo projeto Django. Você nunca mais vai querer criar múltiplos endpoints REST.

– Web
3 – APIs
3.1 – REST (requests, Django REST Framework)
3.2 – GraphQL (Graphene)

LEGENDA

Nivel_1

Nivel_2

Nivel_3

REST é um estilo arquitetural para construir APIs web. Ele usa os verbos HTTP (GET, POST, PUT, DELETE) como ações. Primeiramente, cada recurso é identificado por uma URL única. Por exemplo, /produtos/42 acessa o produto 42. Além disso, as respostas geralmente usam o formato JSON. A voz passiva é usada aqui: “os dados são transferidos sem estado”. Isso significa que cada requisição contém toda informação necessária. Quando utilizar REST? Na maioria das aplicações web modernas. Python oferece duas ferramentas essenciais para REST. Requests para consumir APIs e Django REST Framework para criá-las. Vamos explorar ambas em detalhes práticos. Três subtítulos organizam este guia completo. Ao final, você saberá construir e consumir APIs profissionais.

Requests: consumindo apis rest com simplicidade

Requests é a biblioteca mais popular para HTTP em Python. Ela simplifica chamadas GET, POST, PUT e DELETE. Quando usar Requests? Em qualquer projeto que consuma APIs externas. Por exemplo, buscar dados de clima, cotação ou redes sociais. Primeiro, instale com pip install requests. Depois, faça chamadas com poucas linhas de código. A voz passiva é aplicada: “os parâmetros são passados como dicionário”. Exemplo completo de consumo de API REST:

import requests

# GET - Buscar dados
response = requests.get('https://jsonplaceholder.typicode.com/posts/1')
if response.status_code == 200:
    dados = response.json()  # Converte JSON para dict
    print(f"Título: {dados['title']}")
else:
    print(f"Erro: {response.status_code}")

# POST - Criar recurso
novo_post = {
    'title': 'Meu Post',
    'body': 'Conteúdo do post',
    'userId': 1
}
response = requests.post(
    'https://jsonplaceholder.typicode.com/posts',
    json=novo_post
)
print(f"Criado: {response.status_code}")

# PUT - Atualizar inteiro
atualizacao = {
    'id': 1,
    'title': 'Título Atualizado',
    'body': 'Novo conteúdo',
    'userId': 1
}
response = requests.put('https://jsonplaceholder.typicode.com/posts/1', json=atualizacao)

# DELETE - Remover
response = requests.delete('https://jsonplaceholder.typicode.com/posts/1')

# Com autenticação básica
response = requests.get('https://api.exemplo.com/dados', auth=('usuario', 'senha'))

# Com headers personalizados
headers = {'Authorization': 'Bearer token123'}
response = requests.get('https://api.exemplo.com/protegido', headers=headers)

# Tratamento de erros
try:
    response = requests.get('https://api.inexistente.com', timeout=5)
    response.raise_for_status()  # Lança exceção para 4xx/5xx
except requests.exceptions.RequestException as e:
    print(f"Falha na requisição: {e}")

import requests

# GET - Buscar dados

response = requests.get('https://jsonplaceholder.typicode.com/posts/1')

if response.status_code == 200:

dados = response.json() # Converte JSON para dict

print(f"Título: {dados['title']}")

else:

print(f"Erro: {response.status_code}")

# POST - Criar recurso

novo_post = {

'title': 'Meu Post',

'body': 'Conteúdo do post',

'userId': 1

}

response = requests.post(

'https://jsonplaceholder.typicode.com/posts',

json=novo_post

)

print(f"Criado: {response.status_code}")

# PUT - Atualizar inteiro

atualizacao = {

'id': 1,

'title': 'Título Atualizado',

'body': 'Novo conteúdo',

'userId': 1

}

response = requests.put('https://jsonplaceholder.typicode.com/posts/1', json=atualizacao)

# DELETE - Remover

response = requests.delete('https://jsonplaceholder.typicode.com/posts/1')

# Com autenticação básica

response = requests.get('https://api.exemplo.com/dados', auth=('usuario', 'senha'))

# Com headers personalizados

headers = {'Authorization': 'Bearer token123'}

response = requests.get('https://api.exemplo.com/protegido', headers=headers)

# Tratamento de erros

try:

response = requests.get('https://api.inexistente.com', timeout=5)

response.raise_for_status() # Lança exceção para 4xx/5xx

except requests.exceptions.RequestException as e:

print(f"Falha na requisição: {e}")

Requests trata JSON, autenticação e erros de forma elegante. É a ferramenta padrão para integração com APIs REST.

Django rest framework: construindo apis profissionais

Django REST Framework (DRF) é o padrão para APIs com Django. Ele oferece serializadores, viewsets e autenticação prontos. Quando usar DRF? Em projetos Django que precisam de API robusta. Primeiro, instale com pip install djangorestframework. Adicione 'rest_framework' ao INSTALLED_APPS do Django. A voz passiva é aplicada: “os serializadores são usados para validar dados”. Exemplo completo de uma API de produtos com DRF:

# models.py
from django.db import models

class Produto(models.Model):
    nome = models.CharField(max_length=100)
    preco = models.DecimalField(max_digits=10, decimal_places=2)
    estoque = models.IntegerField()
    criado_em = models.DateTimeField(auto_now_add=True)
    
    def __str__(self):
        return self.nome

# serializers.py
from rest_framework import serializers
from .models import Produto

class ProdutoSerializer(serializers.ModelSerializer):
    class Meta:
        model = Produto
        fields = ['id', 'nome', 'preco', 'estoque', 'criado_em']

# views.py
from rest_framework import viewsets, permissions
from .models import Produto
from .serializers import ProdutoSerializer

class ProdutoViewSet(viewsets.ModelViewSet):
    queryset = Produto.objects.all()
    serializer_class = ProdutoSerializer
    permission_classes = [permissions.IsAuthenticatedOrReadOnly]

# urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import ProdutoViewSet

router = DefaultRouter()
router.register(r'produtos', ProdutoViewSet)

urlpatterns = [
    path('api/', include(router.urls)),
    path('api-auth/', include('rest_framework.urls')),
]

# models.py

from django.db import models

class Produto(models.Model):

nome = models.CharField(max_length=100)

preco = models.DecimalField(max_digits=10, decimal_places=2)

estoque = models.IntegerField()

criado_em = models.DateTimeField(auto_now_add=True)

def __str__(self):

return self.nome

# serializers.py

from rest_framework import serializers

from .models import Produto

class ProdutoSerializer(serializers.ModelSerializer):

class Meta:

model = Produto

fields = ['id', 'nome', 'preco', 'estoque', 'criado_em']

# views.py

from rest_framework import viewsets, permissions

from .models import Produto

from .serializers import ProdutoSerializer

class ProdutoViewSet(viewsets.ModelViewSet):

queryset = Produto.objects.all()

serializer_class = ProdutoSerializer

permission_classes = [permissions.IsAuthenticatedOrReadOnly]

# urls.py

from django.urls import path, include

from rest_framework.routers import DefaultRouter

from .views import ProdutoViewSet

router = DefaultRouter()

router.register(r'produtos', ProdutoViewSet)

urlpatterns = [

path('api/', include(router.urls)),

path('api-auth/', include('rest_framework.urls')),

]

Com esse código, você tem uma API completa com: Listagem, criação, atualização, remoção e autenticação. Acesse /api/produtos/ para testar no navegador. DRF também gera uma interface web para explorar a API. Isso acelera o desenvolvimento em pelo menos 70%.

Quando usar requests vs. django rest framework

Requests é para consumo de APIs de terceiros. DRF é para criação de suas próprias APIs. Portanto, as ferramentas são complementares, não concorrentes. Use Requests em scripts, bots ou integrações simples. Use DRF em sistemas web completos com Django. A fórmula de produtividade com DRF: \(P = \frac{T_{\text{manual}}}{T_{\text{DRF}}} \approx 3\) Ou seja, você é três vezes mais rápido com DRF. No entanto, DRF exige conhecimento de Django. Para APIs pequenas sem Django, prefira FastAPI ou Flask. Requests é obrigatório em qualquer ambiente Python. Ele é leve, rápido e fácil de aprender. Combine ambos quando seu Django REST Framework consumir outras APIs. Exemplo: sua API DRF pode chamar um serviço externo via Requests. A voz passiva é usada: “diferentes camadas são integradas harmoniosamente”. Portanto, domine as duas ferramentas para ser um desenvolvedor completo. Comece com Requests hoje mesmo. Avance para DRF quando precisar escalar seu projeto.

GraphQL com Python

Conceitos fundamentais do graphql

Implementando graphql com graphene e django

GraphQL vs. rest: quando escolher cada um

REST em Python

Requests: consumindo apis rest com simplicidade

Django rest framework: construindo apis profissionais

Quando usar requests vs. django rest framework