3 maneiras de fazer chamadas HTTP com o Requests em Python (do nível iniciante ao avançado)

A capacidade de fazer uma solicitação HTTP é essencial para a forma como as aplicações interagem com a web. Se você estiver usando Python — seja para criar um scraper da web, utilizar APIs RESTful ou interagir com a web de alguma outra forma —, o módulo de terceiros Requests do Python é a opção mais popular e fácil de usar. Nesta postagem, exploraremos três níveis de solicitações HTTP com o módulo Requests, começando pelo básico e avançando até técnicas avançadas. Ao final, você estará pronto para usar o Requests em produção!

Os exemplos de código de nível mais avançado desta postagem são provenientes do SDK do Vonage para Python, nosso SDK que permite chamar APIs para mensagens, voz, vídeo, autenticação de dois fatores e muito mais, tudo usando Python. Utilizamos o módulo Requests para fazer tudo isso e muito mais, por isso este é o projeto de exemplo perfeito para o uso do Requests.

Vamos subir de nível no nosso jogo de Pedidos, começando pelo Nível 1... agora mesmo!

Nível 1: Solicitações HTTP básicas

No nível básico, temos as solicitações HTTP fundamentais. Elas são o pão com manteiga dos desenvolvedores Python que precisam interagir com serviços web. O módulo `Requests` torna incrivelmente fácil realizar solicitações GET e POST, permitindo que você recupere páginas da web ou envie dados a um servidor sem esforço.

Primeiro, instale o requests em um ambiente virtual de sua escolha:

Depois de ativar seu ambiente virtual e instalar o Requests, você pode começar a usá-lo imediatamente. Aqui está um exemplo de uma solicitação GET para obter o conteúdo de uma página da web:

import requests

response = requests.get('https://example.com')
print(response.text)

Ao executar o código acima, você deverá ver o código HTML completo da https://example.com página. Mas podemos fazer muito mais do que apenas obter páginas da web por meio de solicitações!

Aqui está uma solicitação POST, na qual enviamos dados para uma URL:

import requests

data = {'vonage': 'loves', 'python': '!'}
response = requests.post('https://httpbin.org/post', json=data)
print(response.json())

Podemos ver a resposta, serializada em um dicionário do Python, a seguir. Observe que ela inclui os dados que enviamos:

{'args': {}, 'data': '{"vonage": "loves", "python": "!"}', 'files': {}, 'form': {}, 'headers': {'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate', 'Content-Length': '34', 'Content-Type': 'application/json', 'Host': 'httpbin.org', 'User-Agent': 'python-requests/2.31.0', 'X-Amzn-Trace-Id': 'Root=1-65012480-007aeecf146f5ff007c7678d'}, 'json': {'python': '!', 'vonage': 'loves'}, 'origin': '82.30.197.62', 'url': 'https://httpbin.org/post'}

Com esses exemplos simples, você já pode começar a fazer solicitações HTTP em Python. Mas e se você precisar manter as configurações entre várias solicitações ou compartilhar recursos? É aí que entra o Nível 2!

Nível 2: Uso de sessões para persistência

As sessões HTTP são uma forma de manter as configurações entre várias solicitações enviadas ao mesmo servidor. As sessões também utilizam o pool de conexões, o que significa que, se você fizer várias chamadas HTTP para os mesmos hosts, utilizará os mesmos recursos e poderá observar melhorias significativas no desempenho!

Se alguma dessas situações se aplicar a você, talvez seja uma boa ideia usar uma sessão:

• Se você precisar manter uma conexão com estado, como ao trabalhar com APIs autenticadas ou Applications da web.

• Se você fizer muitas solicitações à mesma API/servidor e não quiser perder tempo e recursos.

O módulo Requests disponibiliza um objeto Session que permite fazer exatamente isso. Veja um exemplo:

import requests

# Create a session
session = requests.Session()

# Set headers to be sent in every request
session.headers.update({'Accepts': 'application/json'})

# Perform multiple requests within the same session
response1 = session.get('https://example.com/some-page')
response2 = session.get('https://example.com/some-other-page')

Usar uma sessão como essa significa que quaisquer cookies que definirmos serão mantidos. Também podemos definir valores padrão para uma sessão adicionando-os ao objeto de sessão, como fizemos acima com o cabeçalho que enviamos. Isso é extremamente útil, mas a principal razão pela qual usamos objetos de sessão no SDK Python da Vonage é que isso permite que nossos usuários façam muitas chamadas de API com muita rapidez.

Aqui está um exemplo dos benefícios de desempenho decorrentes do uso de uma sessão HTTP. O código abaixo NÃO utiliza uma sessão, realizando, em vez disso, 100 chamadas de API separadas para a Number Insight API da Vonage para consultar informações sobre 100 números de telefone diferentes e convertê-los para o formato internacional E.164:

import requests
import time

start_time = time.perf_counter()

number_conversions = {}
params = {'api_key': 'MY_API_KEY', 'api_secret': 'MY_API_SECRET', 'country': 'GB'}

for i in range(100):
    phone_number = str(1614960100 + i)
    params['number'] = phone_number
    
    with requests.get(
        'https://api.nexmo.com/ni/basic/json',
        params=params,
    ) as response:
        number_conversions[phone_number] = response.json()[
            'international_format_number'
        ]

elasped_time = time.perf_counter() - start_time
print(f'Time elapsed is: {elasped_time} seconds.')

Obtemos o seguinte resultado: Time elapsed is: 11.103735665994463 seconds. Portanto, levou mais de 11 segundos para executar 100 chamadas de API, o que não é tão ruim assim, mas poderia ser muito melhor.

Fiz o perfil do código acima; aqui está uma visualização em gráfico “icicle” usando snakeviz:

Vanilla requests icicle plot

Podemos ver que gastamos a maior parte do tempo (mais de 10/11 segundos) no pool de conexões. Usar uma sessão para permitir que várias chamadas HTTP utilizem um pool de conexões comum e compartilhem recursos deve reduzir esse tempo. Vamos dar uma olhada.

Se usarmos um objeto de sessão para as chamadas à Number Insight API, podemos perceber a diferença:

with requests.Session() as session:

    for i in range(100):
        phone_number = str(441614960100 + i)
        params['number'] = phone_number
    
        with session.get(
            'https://api.nexmo.com/ni/basic/json',
            params=params,
        ) as response:
            number_conversions[phone_number] = response.json()[
                'international_format_number'
            ]

Desta vez, obtemos esta saída: Time elapsed is: 4.058261167003366 seconds. que é quase três vezes mais rápido! Podemos ver neste gráfico em forma de pingente de gelo do programa que nosso sistema gastou proporcionalmente menos tempo com o pool de conexões, e o tempo utilizado foi empregado de forma muito mais eficiente do que ao fazer 100 solicitações separadas, como fizemos acima.

Session requests case icicle plot

Assim, podemos ver que, ao usar uma sessão, é possível lidar automaticamente com elementos como cookies e cabeçalhos, tornando seu código mais limpo e eficiente. Mas e se você precisar de ainda mais controle sobre suas solicitações HTTP ou quiser ajustar suas conexões? É hora do Nível 3.

Nível 3: Utilização de um adaptador HTTP para configurações avançadas

Agora estamos prontos para o nível mais avançado, no qual personalizamos o comportamento das solicitações HTTP em um nível muito baixo, incluindo configurações como pool de conexões e tentativas de reconexão. O Requests nos permite definir essas propriedades de baixo nível usando um adaptador HTTP, que você pode associar a um objeto Session para aplicar suas configurações personalizadas durante toda a sessão. No Requests, usamos um objeto chamado HTTPAdapter para fazer isso.

Veja a seguir como você pode usar o HTTPAdapter objeto para definir configurações personalizadas:

import requests
from requests.adapters import HTTPAdapter

session = requests.Session()

# Create an HTTPAdapter object and configure connection pooling and retries
adapter = HTTPAdapter(pool_connections=20, pool_maxsize=5, max_retries=3)

# Mount the HTTPAdpater object to the session
session.mount('https://', adapter)

response = session.get('https://example.com')

Isso também pode ser combinado com valores específicos da solicitação, como o tempo limite (por exemplo, session.get('https://example.com', timeout=10)) para proporcionar um controle mais preciso por solicitação.

O uso de um adaptador HTTP permite controlar a forma como suas solicitações HTTP são feitas, possibilitando ajustar com precisão o comportamento da sua aplicação para atender às suas necessidades específicas.

Bônus: Como usar um SDK de Python adequado

No SDK Python da Vonage, utilizamos todas essas técnicas para enviar solicitações da maneira mais eficaz. Usamos uma sessão e permitimos que os usuários configurem as opções de solicitação e do adaptador HTTP ao criarem um Client objeto. O código abaixo mostra como executar a mesma solicitação de acima, para fazer 100 chamadas à Number Insight API, mas, desta vez, utilizando o SDK Python da Vonage para realizar as chamadas.

import vonage

client = vonage.Client(key='MY_API_KEY', secret='MY_API_SECRET')
number_conversions = {}

for i in range(100):
    phone_number = str(1614960100 + i)
    response = client.number_insight.get_basic_number_insight(
        country='GB', number=phone_number
    )
    number_conversions[phone_number] = response['international_format_number']

Se você quiser personalizar qualquer uma das configurações padrão, como pool_connections ou solicitar timeout, você pode especificar isso ao criar o client objeto.

A vantagem de usar o SDK da Vonage para acessar as APIs da Vonage é que você não precisa se preocupar com a lógica da solicitação. Basta especificar o que deseja que aconteça, e o SDK cuida disso para você. Muitos outros serviços possuem SDKs semelhantes, que abstraem a lógica que talvez não seja relevante para você, mas permitem que você se aprofunde nos detalhes caso precise ou queira.

Conclusão

Nesta postagem do blog, exploramos os três níveis de solicitações HTTP com o módulo `Requests` do Python, desde solicitações básicas até personalizações avançadas usando sessões e adaptadores HTTP. Ao dominar esses níveis, você estará bem preparado para lidar com uma ampla variedade de tarefas relacionadas à web em seus projetos em Python.

Lembre-se de que cada nível se baseia no anterior; portanto, comece pelo básico e vá avançando gradualmente à medida que os requisitos do seu projeto forem evoluindo. As solicitações HTTP são um aspecto fundamental do desenvolvimento web e, com o módulo Requests, você tem à sua disposição uma ferramenta poderosa para lidar com elas de forma eficaz.

Se você quiser começar a usar as APIs da Vonage, pode se cadastrar para obter um Account de desenvolvedor gratuito (com créditos grátis!)

Se você tiver alguma dúvida sobre este artigo, sinta-se à vontade para entrar em contato conosco na nossa Slack da Comunidade Vonage e nos perguntar por lá, ou nos enviar uma mensagem no X, anteriormente conhecido como Twitter.

Então vá em frente, experimente diferentes níveis de solicitações HTTP e faça com que suas aplicações em Python interajam com a web como um profissional!