3 façons de faire des appels HTTP avec des requêtes Python (du débutant à l'avancé)

La possibilité d'effectuer une requête HTTP est essentielle à la façon dont les applications interagissent avec le web. Si vous utilisez Python, que vous construisiez un scraper web, que vous consommiez des API RESTful ou que vous ayez besoin d'interagir avec le web d'une autre manière, le module Requests de Python est l'option la plus populaire et la plus facile à utiliser. Dans cet article, nous allons explorer trois niveaux de requêtes HTTP avec le module Requests, en commençant par les bases et en progressant vers des techniques avancées. À la fin, vous serez prêt à utiliser Requests en production !

Les exemples de code de haut niveau présentés dans ce billet proviennent du SDK Python de Vonagenotre SDK qui vous permet d'appeler des API pour la messagerie, la Voice, la Video, l'authentification à deux facteurs, et plus encore, le tout en utilisant Python. Nous utilisons le module Requests pour faire tout cela et plus encore, c'est donc le projet d'exemple parfait pour utiliser Requests.

Relevons le niveau de notre jeu de requêtes, en commençant par le niveau 1... tout de suite !

Niveau 1 : Requêtes HTTP de base

Au niveau fondamental, nous avons les requêtes HTTP de base. Celles-ci sont le pain et le beurre des développeurs Python qui ont besoin d'interagir avec des services web. Le module Requests permet d'effectuer très facilement des requêtes GET et POST, ce qui permet de récupérer des pages web ou d'envoyer des données à un serveur sans effort.

Tout d'abord, installez les requêtes dans l'environnement virtuel de votre choix :

Une fois votre environnement virtuel activé et les requêtes installées, vous pouvez commencer à l'utiliser immédiatement. Voici un exemple de requête GET pour obtenir le contenu d'une page web :

import requests

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

L'exécution du code ci-dessus devrait vous permettre d'obtenir l'intégralité du code HTML de la page https://example.com de la page. Mais nous pouvons faire plus qu'obtenir des pages web avec des requêtes !

Voici une requête POST, dans laquelle nous envoyons des données à une URL :

import requests

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

Nous pouvons voir la réponse, sérialisée dans un dictionnaire Python, ci-dessous. Notez qu'elle contient les données que nous avons postées :

{'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'}

Avec ces exemples simples, vous pouvez déjà commencer à effectuer des requêtes HTTP en Python. Mais qu'en est-il si vous avez besoin de conserver des paramètres pour plusieurs requêtes ou de partager des ressources ? C'est là que le niveau 2 entre en jeu !

Niveau 2 : Utilisation des sessions pour la persistance

Les sessions HTTP sont un moyen de conserver les paramètres à travers plusieurs requêtes au même serveur. Les sessions utilisent également la mise en commun des connexions, ce qui signifie que si vous effectuez plusieurs appels HTTP vers les mêmes hôtes, vous utiliserez les mêmes ressources et pourrez constater des améliorations significatives en termes de performances !

Si l'un ou l'autre de ces cas s'applique à vous, vous pourriez avoir recours à une session :

• Si vous avez besoin de maintenir une connexion avec état, comme lorsque vous travaillez avec des API ou des applications web authentifiées.

• Si vous effectuez de nombreuses demandes auprès de la même API/hôte et que vous ne voulez pas perdre de temps et de ressources.

Le module Requêtes fournit un objet Session qui vous permet de le faire. Voici un exemple :

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')

L'utilisation d'une session de cette manière signifie que tous les cookies définis seront conservés. Nous pouvons également définir des valeurs par défaut pour une session en les ajoutant à l'objet session, comme nous l'avons fait ci-dessus avec l'en-tête que nous avons envoyé. C'est incroyablement utile, mais la principale raison pour laquelle nous utilisons les objets de session dans le SDK Python de Vonage est qu'ils permettent à nos utilisateurs d'effectuer de nombreux appels API, très rapidement.

Voici un exemple des avantages de l'utilisation d'une session HTTP en termes de performances. Le code ci-dessous N'UTILISE PAS de session, mais effectue 100 appels API distincts à l'API Number Insight API de Vonage de Vonage pour rechercher des informations sur 100 numéros de téléphone différents et les convertir au format international 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.')

Nous obtenons le résultat suivant : Time elapsed is: 11.103735665994463 seconds. Il a donc fallu plus de 11 secondes pour effectuer 100 appels d'API, ce qui n'est pas terrible, mais pourrait être bien mieux.

J'ai profilé le code ci-dessus, voici une visualisation du tracé des glaçons en utilisant snakeviz:

Vanilla requests icicle plot

Nous pouvons voir que nous avons passé la plupart du temps (plus de 10/11 secondes) sur la mise en commun des connexions. L'utilisation d'une session pour permettre à plusieurs appels HTTP d'utiliser le pooling de connexion commun et de partager les ressources devrait réduire ce temps. Voyons ce qu'il en est.

Si nous utilisons un objet de session pour les appels à l'API Number Insight, nous pouvons voir la différence :

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'
            ]

Cette fois-ci, nous obtenons le résultat suivant : Time elapsed is: 4.058261167003366 seconds. ce qui est presque trois fois plus rapide ! Nous pouvons voir dans ce diagramme de glace du programme que notre système a passé moins de temps proportionnellement à la mise en commun des connexions, et que le temps utilisé l'a été de manière beaucoup plus efficace qu'en effectuant 100 requêtes distinctes comme nous l'avons fait plus haut.

Session requests case icicle plot

Nous voyons donc qu'en utilisant une session, vous pouvez gérer automatiquement des éléments tels que les cookies et les en-têtes, ce qui rend votre code plus propre et plus efficace. Mais qu'en est-il si vous avez besoin d'un contrôle encore plus poussé sur vos requêtes HTTP ou si vous souhaitez affiner vos connexions ? Il est temps de passer au niveau 3.

Niveau 3 : Utilisation d'un adaptateur HTTP pour les paramètres avancés

Nous sommes maintenant prêts pour le niveau le plus avancé, où nous personnalisons le comportement des requêtes HTTP à un niveau très bas, y compris des paramètres tels que la mise en commun des connexions et les tentatives. Les requêtes nous permettent de définir ces propriétés de bas niveau en utilisant un adaptateur HTTP, que vous pouvez monter sur un objet Session afin d'utiliser vos paramètres personnalisés pour l'ensemble de la session. Dans Requests, nous utilisons un objet appelé HTTPAdapter pour ce faire.

Voici comment vous pouvez utiliser l'objet HTTPAdapter pour configurer des paramètres personnalisés :

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')

Cela peut également être combiné avec des valeurs spécifiques aux requêtes, telles que le délai d'attente (par ex. session.get('https://example.com', timeout=10)) afin d'obtenir un contrôle fin par requête.

L'utilisation d'un adaptateur HTTP permet de contrôler la manière dont les requêtes HTTP sont effectuées, ce qui permet d'adapter le comportement de votre application à vos besoins spécifiques.

Bonus : Utilisation d'un SDK Python approprié

Dans SDK Python de Vonagede Vonage, nous utilisons toutes ces techniques pour envoyer des demandes de la manière la plus efficace possible. Nous utilisons une session et permettons aux utilisateurs de configurer la demande et les paramètres de l'adaptateur HTTP lorsqu'ils créent un objet Client objet. Le code ci-dessous montre comment exécuter la même requête que ci-dessus, pour effectuer 100 appels à l'API Number Insight, mais cette fois-ci en utilisant le SDK Python de Vonage pour effectuer les appels.

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']

Si vous souhaitez personnaliser l'un des paramètres par défaut, tels que pool_connections ou la demande timeoutvous pouvez le spécifier lors de la création de l'objet client lors de la création de l'objet.

L'avantage d'utiliser le SDK de Vonage pour appeler les API de Vonage est que vous n'avez pas à vous soucier de la logique de la demande. Vous spécifiez ce que vous voulez qu'il se passe, et le SDK s'en charge pour vous. De nombreux autres services disposent de SDK dans la même veine pour abstraire la logique qui pourrait ne pas vous importer, mais vous permettre de plonger dans les détails si vous le souhaitez ou si vous en avez besoin.

Conclusion

Dans cet article de blog, nous avons exploré les trois niveaux de requêtes HTTP avec le module Requests de Python, depuis les requêtes de base jusqu'à la personnalisation avancée à l'aide de sessions et d'adaptateurs HTTP. En maîtrisant ces niveaux, vous serez bien équipé pour vous attaquer à un large éventail de tâches liées au web dans vos projets Python.

N'oubliez pas que chaque niveau s'appuie sur le précédent. Commencez donc par les bases et passez progressivement au niveau supérieur au fur et à mesure de l'évolution des besoins de votre projet. Les requêtes HTTP sont un aspect fondamental du développement web, et avec le module Requêtes, vous disposez d'un outil puissant pour les traiter efficacement.

Si vous souhaitez commencer à utiliser les API de Vonage, vous pouvez vous inscrire à un compte de développeur gratuit (avec des crédits gratuits !)

Si vous avez des questions sur cet article, n'hésitez pas à nous contacter sur notre Communauté Vonage Slack et nous poser des questions, ou en nous envoyant un en nous envoyant un message sur X, anciennement connu sous le nom de Twitter.

Alors allez-y, expérimentez les différents niveaux de requêtes HTTP et donnez à vos Applications Python les moyens d'interagir avec le web comme un pro !