Introduction
Le crawling est essentiel pour extraire des données depuis des sites web, mais peut rapidement devenir inefficace sans une bonne structure. Plutôt que de naviguer dans les pages de catégories et de paginer les listes de produits, une approche plus performante consiste à exploiter les index de sitemap et les sitemaps pour accéder directement au contenu utile, comme les pages produits et leurs horodatages de dernière mise à jour.
Le problème du crawling traditionnel
Les robots d’indexation traditionnels suivent généralement cette séquence :
- Extraire les catégories principales depuis la page d’accueil
- Parcourir chaque catégorie pour obtenir les sous-catégories
- Paginer dans les listes de produits de chaque sous-catégorie
- Extraire les détails des produits
Cette méthode garantit une collecte exhaustive mais présente plusieurs inconvénients :
- Forte consommation de ressources : explorer des pages inutiles augmente la charge serveur et la bande passante
- Traitement plus lent : récupérer et analyser chaque page prend du temps, surtout sur les gros sites e-commerce
- Risque de blocage accru : les sites peuvent imposer du rate-limiting ou bloquer les IP générant trop de requêtes
Exploiter les index de sitemap pour un crawling efficace
La plupart des sites fournissent un index de sitemap XML référençant plusieurs fichiers sitemap. Ces sitemaps contiennent souvent des liens directs vers les pages importantes (fiches produits, articles de blog, contenu structuré). Les utiliser pour le crawling offre des avantages significatifs :
1. Accès plus rapide aux pages produits
Au lieu de parcourir les catégories et paginer, le crawler peut extraire directement les URL des produits depuis le sitemap. Cela élimine les requêtes superflues et accélère la récupération des données.
2. Suivi des mises à jour de contenu
Les sitemaps incluent souvent une balise <lastmod> indiquant quand la page a été mise à jour. Cela permet au crawler de :
- Récupérer uniquement les produits récemment mis à jour plutôt que de réindexer tout le site
- Optimiser les appels API en se concentrant sur les données fraîches
3. Risque de détection réduit
Comme le crawler imite les moteurs de recherche en récupérant des sitemaps, il réduit la probabilité d’être identifié comme un bot ou bloqué.
Stratégie d’implémentation
- Récupérer l’index de sitemap : identifier le sitemap racine (par ex.
https://example.com/sitemap_index.xml) - Extraire les sitemaps individuels : parser l’index pour obtenir les liens vers les sitemaps produits (par ex.
https://example.com/sitemap_products.xml) - Traiter les URL de produits : parcourir chaque sitemap, extraire les liens et vérifier la date
<lastmod> - Récupérer uniquement les produits mis à jour : comparer la date de mise à jour avec le timestamp du dernier crawl, et ne traiter que les éléments nouveaux ou modifiés
Exemple : analyser un sitemap en Python
def scrape_products_links(self) -> list[str]:
sitemaps = self.get_sitemaps_from_index("https://www.example.com/sitemap.xml")
logger.info(f"Trouvé {len(sitemaps)} sitemaps.")
links_crawled = []
for sitemap in sitemaps:
logger.info(f"Exploration du sitemap: {sitemap}")
r = requests.get(sitemap)
soup = self.b4s_parse(r.text, 'xml')
links = soup.find_all('url')
logger.info(f"Trouvé {len(links)} liens.")
# Trouver toutes les balises <url> où <loc> se termine par .html
links = [
url for url in links
if url.loc and url.loc.text.endswith(".html")
]
logger.info(f"Trouvé {len(links)} liens de produits.")
new_products = []
old_products = []
for link in links:
product = Product()
# Extraire les champs requis
product.url = link.loc.text if link.loc else None
# Ignorer si l'URL n'est pas trouvée
if not product.url:
continue
hash = self.create_hash(product.url)
p = Product.get_by_hash(hash=hash)
product.website_updated_at = link.lastmod.text if link.lastmod else None
# Ignorer si le produit existe déjà ou a été mis à jour
if p:
if p.website_updated_at != product.website_updated_at:
p.website_updated_at = product.website_updated_at
old_products.append(p)
continue
else:
links_crawled.append(product.url)
product.hash = hash
product.website = CategoryWebsite.BOTICINAL
data_object = link.find("DataObject", {"type": "thumbnail"})
if data_object:
name_attr = data_object.find("Attribute", {"name": "name"})
if name_attr:
product.name = name_attr["value"]
image_loc = link.find("image:loc")
if image_loc:
product.image = self.get_clean_url(image_loc.text)
product.crawler_updated_at = product.website_updated_at
new_products.append(product)
if len(new_products) > 0:
Product.bulk_insert(new_products)
if len(old_products) > 0:
Product.bulk_insert(old_products)
return links_crawled
Conclusion
Utiliser les index de sitemap pour le crawling est une stratégie d’optimisation puissante : extraction de données plus rapide, meilleure efficacité des ressources et plus grande précision en ne traitant que le contenu mis à jour. Cette approche permet de maintenir des informations produits à jour tout en réduisant la charge inutile sur les sites cibles et votre infrastructure.
Adopter cette technique améliore significativement la performance de toute solution de crawling web, rendant la collecte de données à la fois plus intelligente et plus durable.