PricingLoginStart free
AI Agents · Leçon

Pratiques de collecte respectueuses

Respect de robots.txt, en-têtes d’agent utilisateur, délais entre les requêtes et mise en cache.

Leçon 4 sur 413 étapes

Pratiques de collecte respectueuses est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.

Pourquoi une extraction respectueuse est importante

L’extraction de données web peut mettre les serveurs à rude épreuve, enfreindre les conditions d’utilisation et faire bannir l’adresse IP de votre agent. Les outils d’extraction responsables respectent les limites de débit, s’identifient et suivent les règles publiées par les sites web.

Cette leçon présente les outils et les techniques permettant d’effectuer une extraction de données de manière éthique et durable.

Vérifier robots.txt

Chaque site web peut publier un fichier robots.txt indiquant les chemins auxquels les agents automatisés peuvent ou ne peuvent pas accéder. La bibliothèque standard de Python comprend urllib.robotparser pour analyser ce fichier.

Vérifiez toujours robots.txt avant d’extraire des données d’un site.

import urllib.robotparser

rp = urllib.robotparser.RobotFileParser()
rp.set_url('https://example.com/robots.txt')
rp.read()

# Check if our bot can fetch a specific path
can_fetch = rp.can_fetch('MyAgent/1.0', 'https://example.com/public-data')
print(f'Can fetch: {can_fetch}')  # True or False

cannot_fetch = rp.can_fetch('*', 'https://example.com/private/admin')
print(f'Admin allowed: {cannot_fetch}')  # Often False

Définir un User-Agent descriptif

L’en-tête HTTP User-Agent identifie l’auteur d’une requête. Un User-Agent honnête permet aux administrateurs du site de savoir ce qu’est votre robot et comment vous contacter en cas de problème. Se faire passer pour un navigateur afin de contourner les blocages soulève des questions éthiques.

import httpx

headers = {
    # Honest, descriptive User-Agent
    'User-Agent': 'MyResearchBot/1.0 (contact: me@example.com; purpose: academic research)'
}

response = httpx.get(
    'https://example.com/data',
    headers=headers,
    timeout=10.0
)

print(response.status_code)

Limiter le débit avec time.sleep()

Envoyer des centaines de requêtes par seconde peut surcharger un serveur et est souvent considéré comme une attaque par déni de service. Ajoutez des délais entre les requêtes avec time.sleep(). Utilisez random.uniform() pour rendre le délai moins mécanique et plus proche du comportement humain.

import time
import random
import httpx

urls = [
    'https://example.com/page/1',
    'https://example.com/page/2',
    'https://example.com/page/3'
]

for url in urls:
    response = httpx.get(url, timeout=10.0)
    print(f'Fetched {url}: {response.status_code}')

    # Wait between 1 and 3 seconds before the next request
    delay = random.uniform(1, 3)
    print(f'Sleeping {delay:.1f}s...')
    time.sleep(delay)

Respecter les en-têtes Retry-After

Lorsqu’un serveur répond avec 429 Too Many Requests, il inclut souvent un en-tête Retry-After indiquant le nombre de secondes à attendre. Votre agent doit le lire et le respecter au lieu de réessayer immédiatement.

import time
import httpx

def fetch_with_retry(url: str) -> httpx.Response:
    while True:
        response = httpx.get(url, timeout=10.0)

        if response.status_code == 429:
            retry_after = int(response.headers.get('Retry-After', 5))
            print(f'Rate limited. Waiting {retry_after}s...')
            time.sleep(retry_after)
            continue  # retry

        response.raise_for_status()
        return response

Mettre en cache les réponses pour éviter les récupérations répétées

requests-cache met automatiquement en cache les réponses HTTP sur le disque. Si votre agent doit récupérer plusieurs fois la même URL (par exemple pendant le développement ou lors de nouvelles exécutions), les réponses mises en cache sont renvoyées instantanément sans solliciter le serveur.

# pip install requests-cache
import requests_cache

# Install the cache globally — cached responses expire after 1 hour
requests_cache.install_cache(
    'agent_cache',
    backend='sqlite',
    expire_after=3600  # seconds
)

import requests

# First call: fetches from network and caches
response = requests.get('https://api.example.com/data')
print(response.from_cache)  # False

# Second call: returns cached result instantly
response2 = requests.get('https://api.example.com/data')
print(response2.from_cache)  # True

Mise en cache manuelle dans des fichiers avec httpx

Si vous préférez ne pas utiliser requests-cache, un simple cache basé sur des fichiers fonctionne très bien. Stockez les réponses dans des fichiers JSON indexés par le hachage de l’URL et rechargez-les si le fichier est suffisamment récent.

import hashlib
import json
import os
import time
import httpx

CACHE_DIR = '/tmp/agent_cache'
os.makedirs(CACHE_DIR, exist_ok=True)

def cached_get(url: str, ttl_seconds: int = 3600) -> dict:
    key = hashlib.md5(url.encode()).hexdigest()
    cache_file = os.path.join(CACHE_DIR, key + '.json')

    if os.path.exists(cache_file):
        age = time.time() - os.path.getmtime(cache_file)
        if age < ttl_seconds:
            with open(cache_file) as f:
                return json.load(f)

    response = httpx.get(url, timeout=10.0)
    response.raise_for_status()
    data = response.json()
    with open(cache_file, 'w') as f:
        json.dump(data, f)
    return data

Lire les conditions d’utilisation

Avant d’extraire des données d’un site, lisez ses conditions d’utilisation. Beaucoup de sites interdisent explicitement l’accès automatisé ou l’utilisation commerciale de leurs données. Enfreindre ces conditions peut entraîner des poursuites judiciaires, et pas seulement le bannissement d’une adresse IP.

Si une API officielle existe, préférez-la toujours à l’extraction du HTML : elle est plus rapide, plus stable et présente moins de risques juridiques.

Temporisation exponentielle en cas d’erreur

Lorsqu’une requête échoue, ne réessayez pas immédiatement. Utilisez une temporisation exponentielle : attendez 1 s, puis 2 s, puis 4 s, etc. Cela évite de marteler un serveur en difficulté et constitue une pratique professionnelle pour les agents en production.

import time
import httpx

def fetch_with_backoff(url: str, max_retries: int = 4) -> dict:
    for attempt in range(max_retries):
        try:
            response = httpx.get(url, timeout=10.0)
            response.raise_for_status()
            return response.json()
        except (httpx.HTTPStatusError, httpx.RequestError) as e:
            if attempt == max_retries - 1:
                raise
            wait = 2 ** attempt  # 1, 2, 4, 8 seconds
            print(f'Attempt {attempt+1} failed: {e}. Retrying in {wait}s...')
            time.sleep(wait)
    return {}

N’extraire que les données nécessaires

Réduisez la charge du serveur en ne récupérant que ce dont votre agent a réellement besoin. Évitez de télécharger des pages entières lorsqu’un petit point d’accès d’API renvoie les mêmes données. Utilisez des requêtes HEAD pour vérifier si une ressource a changé avant de récupérer son contenu complet.

import httpx

def has_page_changed(url: str, last_etag: str = None) -> bool:
    headers = {}
    if last_etag:
        headers['If-None-Match'] = last_etag

    response = httpx.head(url, headers=headers, timeout=5.0)

    if response.status_code == 304:  # Not Modified
        return False

    new_etag = response.headers.get('ETag')
    print(f'New ETag: {new_etag}')
    return True

Récapitulatif des règles d’extraction respectueuse

Une liste de contrôle rapide avant que votre agent n’extraie des données d’un site :

  • Vérifiez robots.txt et respectez les règles d’interdiction
  • Définissez un User-Agent honnête et descriptif
  • Ajoutez des délais aléatoires entre les requêtes (time.sleep(random.uniform(1,3)))
  • Respectez les en-têtes Retry-After dans les réponses 429
  • Mettez les réponses en cache pour éviter les récupérations redondantes
  • Lisez les conditions d’utilisation du site
  • Préférez les API officielles à l’extraction du HTML lorsqu’elles sont disponibles

Contrôle des connaissances : extraction respectueuse

Vérifiez votre compréhension des pratiques d’extraction éthiques et respectueuses.

Réponds-y dans la leçon interactive

Récapitulatif : pratiques d’extraction respectueuse

Vous disposez désormais d’une boîte à outils complète pour extraire des données de manière responsable :

  • robotparser pour vérifier ce à quoi vous êtes autorisé à accéder
  • Des en-têtes User-Agent descriptifs qui identifient votre robot
  • time.sleep(random.uniform(1,3)) entre les requêtes
  • requests-cache ou une mise en cache manuelle pour éviter les récupérations en double
  • Une temporisation exponentielle pour gérer les erreurs
  • Une vigilance juridique : vérifiez toujours les conditions d’utilisation

Une extraction responsable contribue à un web plus sain et permet à vos agents de fonctionner sans être bannis.

Gratuit pour commencer

Apprends AI Agents avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
60
Leçons
239
Commencer gratuitementVoir le cours complet

Questions Fréquemment Posées

La leçon « Pratiques de collecte respectueuses » est-elle gratuite ?

Oui — le texte complet de « Pratiques de collecte respectueuses » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Pratiques de collecte respectueuses » ?

Respect de robots.txt, en-têtes d’agent utilisateur, délais entre les requêtes et mise en cache. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Agents ?

Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Pratiques de collecte respectueuses » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?

Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Clients HTTP pour agents : httpx et requests
  2. Analyser du HTML avec BeautifulSoup
  3. Gérer la pagination et le contenu dynamique
  4. Pratiques de collecte respectueuses
← Retour à AI Agents