Um Guia para Iniciantes sobre aiohttp em Python

Quando se trabalha com Python para interagir com APIs da web, especialmente ao lidar com várias solicitações, você provavelmente encontrou alguns atrasos. Seja baixando arquivos, extraindo dados ou fazendo solicitações para APIs, esperar que cada tarefa termine pode desacelerar muito o processo. É aqui que a programação assíncrona entra em cena para salvar o dia, e uma das melhores ferramentas no ecossistema Python para isso é a biblioteca aiohttp.

Se você não está familiarizado com programação assíncrona, não se preocupe! Vou explicar em termos simples como o aiohttp pode ajudar a agilizar suas solicitações na web, tornando-as mais rápidas e eficientes.

Antes de mergulharmos mais fundo, vamos abordar algo com que todo desenvolvedor lida: testes de API. E se você é como a maioria das equipes, provavelmente está usando o Postman para isso.

Eu entendo—o Postman é uma ferramenta familiar. Mas sejamos honestos, todos nós já notamos como ele está se tornando cada vez menos atraente a cada ano? No entanto, aqui está você, trabalhando em equipe, e precisa de ferramentas de colaboração para manter o processo de desenvolvimento suave. Então, o que você faz? Você investe no Postman Enterprise por impressionantes $49 por mês.

Mas aqui está o ponto: você não precisa fazer isso.

Sim, você leu certo. Há uma maneira melhor e mais eficiente de gerenciar testes de API e colaboração em equipe sem ter que gastar tanto dinheiro em uma ferramenta que, francamente, não oferece o que oferecia antes. Vamos explorar algumas alternativas melhores!

APIDog: Você Obtém Tudo da Versão Paga do Postman, Mas Mais BARATO
Isso mesmo, o APIDog oferece todos os recursos que vêm com a versão paga do Postman, a uma fração do custo. A migração foi tão fácil que você só precisa clicar em alguns botões, e o APIDog fará tudo por você.

O APIDog definitivamente vale a pena. Mas se você é o Líder Técnico de uma equipe de desenvolvedores que realmente quer abandonar o Postman por algo Melhor e Mais Barato, confira o APIDog!

O que é aiohttp?

aiohttp é uma biblioteca popular do Python que permite que você escreva clientes e servidores HTTP assíncronos. Pense nisso como a biblioteca requests do Python, mas turboalimentada com o poder da programação assíncrona.

Ela é construída sobre o framework asyncio do Python, o que significa que pode gerenciar um grande número de solicitações simultaneamente, sem esperar que cada uma termine antes de passar para a próxima.

Imagine que você está em uma cafeteria e, em vez de esperar na fila para cada pedido ser concluído um de cada vez, vários baristas começam a trabalhar no seu pedido simultaneamente.

Com o aiohttp, é como se você estivesse trabalhando com uma equipe de baristas, todos preparando café (ou, neste caso, buscando dados) ao mesmo tempo. O resultado? Resultados mais rápidos com menos espera.

Por que você deve se importar com aiohttp?

Vamos falar sobre por que o aiohttp deve importar para você, seja você um iniciante em Python, cientista de dados, coletor de dados da web ou até mesmo um desenvolvedor experiente.

• Desempenho: A principal razão para usar o aiohttp é o desempenho. Se você precisa fazer várias chamadas de API ou solicitações a um site, o aiohttp pode gerenciá-las simultaneamente.
  Em vez de processá-las uma a uma, você pode executar dezenas ou até centenas de solicitações ao mesmo tempo.
• Escalabilidade: A coleta de dados da web ou chamadas para múltiplas APIs pode ser um processo lento e bloqueante usando programação síncrona. No entanto, com o aiohttp, você pode gerenciar mais tarefas em menos tempo, o que significa que seu aplicativo pode lidar com uma demanda maior ou conjuntos de dados maiores.
• Redução do Tempo de Espera: Programas síncronos tradicionais têm que esperar uma tarefa terminar antes de começar a próxima.
  Com código assíncrono, as tarefas não precisam esperar. Você pode baixar dados de várias URLs ao mesmo tempo, reduzindo drasticamente o tempo total de execução.
• Uso Eficiente de Recursos: A programação assíncrona, e o aiohttp em particular, faz um uso mais eficiente dos recursos do seu sistema.
  Em vez de bloquear um thread ou processo inteiro aguardando uma resposta, o aiohttp permite que outras tarefas sejam executadas enquanto espera que uma operação de E/S seja concluída.

Como o aiohttp funciona?

Vamos mergulhar em como o aiohttp funciona na prática.
Primeiro, vamos esclarecer o que a programação assíncrona realmente significa. Em um programa síncrono, cada tarefa deve terminar antes que a próxima comece.

Se você está esperando que um servidor web responda à sua solicitação, todo o programa para até que essa resposta chegue. A programação assíncrona permite que o programa continue executando outras tarefas enquanto espera pela resposta.

O aiohttp aproveita esse modelo assíncrono para permitir que você envie várias solicitações HTTP de uma vez e, em seguida, manipule as respostas à medida que elas chegam. Aqui está um exemplo que demonstra isso de forma simples:

Como fazer uma solicitação web com aiohttp: o básico

Este diagrama (figura 2) compara o fluxo síncrono (uma tarefa completa antes da próxima) e o fluxo assíncrono (múltiplas tarefas sendo executadas simultaneamente).
Caixas azuis representam tarefas síncronas, enquanto caixas verdes representam tarefas assíncronas.
Setas indicam o fluxo de execução para ambos os processos síncronos e assíncronos.

Visualização do Event Loop (Mecanismo de Loop dentro do Modelo Assíncrono do Python)

Esse diagrama (figura 3) ilustra o mecanismo do loop de eventos no modelo de programação assíncrona do Python.
Os nós representam diferentes etapas, como iniciar tarefas, aguardar operações de E/S e executar callbacks.
Setas direcionadas mostram como as tarefas são iniciadas, como aguardam operações de E/S e como o loop de eventos manipula callbacks e reinicia tarefas.

Busca Concorrente de URLs no aiohttp

O diagrama de caso de uso (figura 4) visualiza como o aiohttp pode lidar com várias solicitações de URL simultaneamente. Cada processo "Buscar URL" é tratado de forma concorrente e passado para um nó de processamento central.

Este diagrama mostra como o aiohttp pode buscar simultaneamente várias URLs em um cenário de coleta de dados da web ou solicitação de API.

Diagrama de Fluxo de Trabalho

O diagrama de fluxo de trabalho visualiza um pipeline de dados básico, mostrando as etapas de busca, processamento, limpeza e armazenamento de dados.

Exemplo: Fazendo Solicitações Assíncronas com aiohttp

import aiohttp
import asyncio

async def fetch_url(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = [
        "https://jsonplaceholder.typicode.com/posts/1",
        "https://jsonplaceholder.typicode.com/posts/2",
        "https://jsonplaceholder.typicode.com/posts/3",
    ]
    
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        responses = await asyncio.gather(*tasks)
        
        for i, response in enumerate(responses):
            print(f"Resposta {i+1}: {response[:60]}...")  # Imprime os primeiros 60 caracteres de cada resposta

Executar o loop de evento
asyncio.run(main())

Baixando conteúdos de forma síncrona
Primeiro, vamos tentar fazer isso de forma síncrona usando a biblioteca requests. Ela pode ser instalada usando:

pip.python3.7 -m pip install requests

Baixar um recurso online usando requests é simples.

import requests
response = requests.get("https://www.python.org/dev/peps/pep-8010/")
print(response.content)

Isso imprimirá o conteúdo HTML do PEP 8010. Para salvá-lo localmente em um arquivo:

filename = "sync_pep_8010.html"
with open(filename, "wb") as pep_file:
    pep_file.write(content.encode('utf-8'))

O arquivo sync_pep_8010.html será criado.

Casos de Uso do Mundo Real para aiohttp

1. Coleta de Dados da Web
Se você está coletando várias páginas de um site, esperar que cada página carregue pode ser um processo dolorosamente lento. Com aiohttp, você pode coletar várias páginas simultaneamente, acelerando o processo dramaticamente. Imagine buscar centenas de páginas ao mesmo tempo, em vez de esperar que cada uma carregue em sequência.
2. Solicitações de API
Ao trabalhar com APIs, especialmente aquelas que têm limites de taxa ou respondem lentamente, você pode enviar várias solicitações ao mesmo tempo usando aiohttp. Por exemplo, se você está consultando uma API de clima para obter dados de várias cidades, o aiohttp pode ajudar você a reunir os resultados mais rápido.
3. Coleta de Dados
Seja você trabalhando com dados do mercado de ações, feeds de mídias sociais ou sites de notícias, o aiohttp pode ser um divisor de águas para lidar com grandes quantidades de solicitações HTTP simultaneamente, permitindo coletar dados mais rápido e de maneira mais eficiente.

Aqui estão três exemplos práticos de uso da biblioteca aiohttp do Python, completos com etapas e código de amostra:

1. Fazendo Solicitações HTTP Assíncronas

Este exemplo demonstra como fazer várias solicitações HTTP assíncronas usando aiohttp.

Etapas:

1. Importar os módulos necessários
2. Definir uma função assíncrona para buscar uma URL
3. Criar uma lista de URLs para buscar
4. Configurar um loop de eventos assíncrono
5. Executar a função assíncrona para cada URL de forma concorrente

import aiohttp
import asyncio

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = [
        'https://api.github.com',
        'https://api.github.com/events',
        'https://api.github.com/repos/python/cpython'
    ]
    
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        responses = await asyncio.gather(*tasks)
        
        for url, response in zip(urls, responses):
            print(f"URL: {url}\nTamanho da resposta: {len(response)}\n")

asyncio.run(main())

2. Criando um Servidor API Simples

Este exemplo mostra como criar um servidor API básico usando aiohttp.

Etapas:

1. Importar os módulos necessários
2. Definir manipuladores de rota
3. Criar a aplicação e adicionar rotas
4. Executar a aplicação

from aiohttp import web

async def handle_root(request):
    return web.json_response({"message": "Bem-vindo à API"})

async def handle_users(request):
    users = [
        {"id": 1, "name": "Alice"},
        {"id": 2, "name": "Bob"},
        {"id": 3, "name": "Charlie"}
    ]
    return web.json_response(users)

app = web.Application()
app.add_routes([
    web.get('/', handle_root),
    web.get('/users', handle_users)
])

if __name__ == '__main__':
    web.run_app(app)

3. Servidor de Chat Websocket

Este exemplo demonstra como criar um servidor de chat baseado em websocket simples usando aiohttp.

Etapas:

1. Importar os módulos necessários
2. Criar um conjunto para armazenar websockets ativos
3. Definir o manipulador de websocket
4. Criar a aplicação e adicionar rotas
5. Executar a aplicação

import aiohttp
from aiohttp import web
import asyncio

active_websockets = set()

async def websocket_handler(request):
    ws = web.WebSocketResponse()
    await ws.prepare(request)
    
    active_websockets.add(ws)
    
    try:
        async for msg in ws:
            if msg.type == aiohttp.WSMsgType.TEXT:
                for client in active_websockets:
                    if client != ws:
                        await client.send_str(f"Usuário{id(ws)}: {msg.data}")
            elif msg.type == aiohttp.WSMsgType.ERROR:
                print(f"A conexão WebSocket foi fechada com a exceção {ws.exception()}")
    finally:
        active_websockets.remove(ws)
    
    return ws

app = web.Application()
app.add_routes([web.get('/ws', websocket_handler)])

if __name__ == '__main__':
    web.run_app(app)

Para testar este servidor websocket, você pode usar um cliente websocket ou criar uma página HTML simples com JavaScript para se conectar ao servidor.

Esses exemplos mostram diferentes aspectos do aiohttp, desde fazer solicitações assíncronas até criar servidores web e lidar com websockets. Eles fornecem uma base sólida para construir aplicações mais complexas usando esta poderosa biblioteca.

Concluindo

No mundo orientado a dados de hoje, a velocidade importa, e a capacidade de lidar com muitas tarefas ao mesmo tempo pode lhe dar uma vantagem. O aiohttp é uma ferramenta indispensável no seu kit de ferramentas Python se você está lidando com coleta de dados da web, solicitações de API ou qualquer outra tarefa que exija fazer muitas solicitações HTTP.

Ao adotar a programação assíncrona, você não só economiza tempo, mas também torna seu código mais eficiente e escalável.
Portanto, se você está procurando levar suas solicitações web em Python para o próximo nível, experimente o aiohttp.

Você rapidamente verá por que é uma escolha tão popular entre os desenvolvedores que lidam com aplicações que consomem I/O.

Você achou esta página útil? Espero que este tenha sido um material muito rico para você!
Desejo tudo de melhor!