Lorsque vous accédez directement à Internet, les sites Web peuvent facilement retracer vos demandes jusqu’à votre adresse IP. Cette exposition peut donner lieu à des publicités ciblées et à un suivi en ligne et potentiellement compromettre votre identité numérique.
C’est là que les proxys entrent en jeu. Ils font office d’intermédiaires entre votre ordinateur et Internet et vous aident à protéger votre identité numérique. Lorsque vous utilisez un serveur proxy, il envoie des requêtes aux sites Web en votre nom en utilisant la propre adresse IP du proxy.
En matière de web scraping, les proxys peuvent vous aider à contourner les interdictions d’adresses IP, à éviter le géoblocage et à protéger votre identité. Dans cet article, vous allez apprendre à implémenter des proxys en langage C# pour tous vos projets de web scraping.
Prérequis
Avant de commencer ce tutoriel, assurez-vous de disposer des éléments suivants :
- Visual Studio 2022 ou Visual Studio Code
- .NET 7 ou une version ultérieure
- Package HtmlAgilityPack NuGet
Les exemples de cet article utilisent une application de console .NET distincte. Pour créer la vôtre, vous pouvez utiliser l’un des guides suivants :
- Création d’une application de console .NET à l’aide de Visual Studio Code
- Création d’une application de console .NET à l’aide de Visual Studio
Pour commencer, vous devez créer deux applications de console, WebScrapApp et WebScrapBrightData :
Pour le web scraping, en particulier s’il s’agit de contenu HTML, vous avez besoin d’outils spécifiques tels que HtmlAgilityPack. Cette bibliothèque simplifie l’analyse et la manipulation du code HTML, ce qui facilite l’extraction de données à partir de pages Web.
Dans les deux projets (à savoir WebScrapApp et WebScrapBrightData), ajoutez le package NuGet HtmlAgilityPack en cliquant avec le bouton droit sur le dossier NuGet, puis sur Gérer les packages NuGet. Lorsqu’une fenêtre contextuelle apparaît, recherchez « HtmlAgilityPack » et installez-le pour les deux projets:
Pour exécuter l’un des projets suivants, vous devez accéder au répertoire du projet dans l’invite de commande et utiliser cd chemin\ vers\ votre\ projet suivi de dotnet run. Vous pouvez également appuyer sur F5 pour créer et exécuter le projet dans Visual Studio. Les deux méthodes compilent et exécutent votre application, en affichant le résultat en conséquence.
Remarque : si vous ne possédez pas Visual Studio 2022, vous pouvez utiliser n’importe quel IDE alternatif prenant en charge .NET 7. Sachez simplement que certaines étapes de ce guide peuvent varier.
Comment configurer un proxy local
En matière de web scraping, la première chose à faire est d’utiliser un serveur proxy. Ce tutoriel utilise le proxy open source mitmproxy.
Pour commencer, accédez aux téléchargements de mitmproxy, téléchargez la version 10.1.6 et sélectionnez la version adaptée à votre système d’exploitation. Pour obtenir de l’aide supplémentaire, consultez le guide d’installation officiel de mitmproxy.
Une fois mitmproxy installé, ouvrez votre terminal et lancez mitmproxy en saisissant la commande suivante :
mitmproxy
Vous devriez voir apparaître une fenêtre dans votre interpréteur ou votre terminal qui ressemble à ceci :
Pour tester le proxy, ouvrez un autre terminal ou un autre interpréteur et exécutez la requête curl suivante :
curl --proxy http://localhost:8080 "http://wttr.in/Dunedin?0"
Votre résultat devrait ressembler à ceci :
Weather report: Dunedin
Cloudy
.--. +11(9) °C
.-( ). ↙ 15 km/h
(___.__)__) 10 km
0.0 mm
Dans la fenêtre mitmproxy, vous devriez voir qu’il a intercepté l’appel via le proxy local :
Web scraping dans le langage C#
Dans la section suivante, vous allez configurer l’application de console C# WebScrapApp pour le web scraping. Cette application utilise le serveur proxy et inclut la rotation des proxys pour une efficacité accrue.
Créer un HttpClient
La classe ProxyHttpClient est conçue pour configurer une instance HttpClient destinée à acheminer les requêtes via un serveur proxy spécifié.
Dans le cadre de votre projet WebScrapApp, créez un nouveau fichier de classe nommé ProxyHttpClient.cs et ajoutez le code suivant :
namespace WebScrapApp
{
public class ProxyHttpClient
{
public static HttpClient CreateClient(string proxyUrl)
{
var httpClientHandler = new HttpClientHandler()
{
Proxy = new WebProxy(proxyUrl),
UseProxy = true
};
return new HttpClient(httpClientHandler);
}
}
}
Mettre en œuvre la rotation des proxys
Pour implémenter la rotation des proxys, créez un fichier de classe ProxyRotator.cs sous votre solution WebScrapApp :
namespace WebScrapApp
{
public class ProxyRotator
{
private List<string> _validProxies = new List<string>();
private readonly Random _random = new();
public ProxyRotator(string[] proxies, bool isLocal)
{
if (isLocal)
{
_validProxies.Add("http://localhost:8080/");
}
else
{
_validProxies = ProxyChecker.GetWorkingProxies(proxies.ToList()).Result;
}
if (_validProxies.Count == 0)
throw new InvalidOperationException();
}
public HttpClient ScrapeDataWithRandomProxy(string url)
{
if (_validProxies.Count == 0)
throw new InvalidOperationException();
var proxyUrl = _validProxies[_random.Next(_validProxies.Count)];
return ProxyHttpClient.CreateClient(proxyUrl);
}
}
}
Cette classe gère une liste de proxys et fournit une méthode permettant de sélectionner un proxy de manière aléatoire pour chaque requête Web. Cette randomisation est essentielle pour réduire le risque de détection et d’éventuelles interdictions d’adresses IP lors du web scraping.
Lorsqu’IsLocal est défini sur True, il récupère le proxy local auprès de mitmproxy. S’il est défini sur False, il récupère les adresses IP publiques des proxys.
Le ProxyChecker est utilisé pour valider la liste des serveurs proxy.
Ensuite, créez un nouveau fichier de classe nommé ProxyChecker.cs et ajoutez le code suivant :
using WebScrapApp;
namespace WebScrapApp
{
public class ProxyChecker
{
private static SemaphoreSlim consoleSemaphore = new SemaphoreSlim(1, 1);
private static int currentProxyNumber = 0;
public static async Task<List<string>> GetWorkingProxies(List<string> proxies)
{
var tasks = new List<Task<Tuple<string, bool>>>();
foreach (var proxyUrl in proxies)
{
tasks.Add(CheckProxy(proxyUrl, proxies.Count));
}
var results = await Task.WhenAll(tasks);
var workingProxies = new List<string>();
foreach (var result in results)
{
if (result.Item2)
{
workingProxies.Add(result.Item1);
}
}
return workingProxies;
}
private static async Task<Tuple<string, bool>> CheckProxy(string proxyUrl, int totalProxies)
{
var client = ProxyHttpClient.CreateClient(proxyUrl);
bool isWorking = await IsProxyWorking(client);
await consoleSemaphore.WaitAsync();
try
{
currentProxyNumber++;
Console.WriteLine($"Proxy: {currentProxyNumber} de {totalProxies}");
}
finally
{
consoleSemaphore.Release();
}
return new Tuple<string, bool>(proxyUrl, isWorking);
}
private static async Task<bool> IsProxyWorking(HttpClient client)
{
try
{
var testUrl = "http://www.google.com";
var response = await client.GetAsync(testUrl);
return response.IsSuccessStatusCode;
}
catch
{
return false;
}
}
}
}
Ce code définit le ProxyChecker pour valider une liste de serveurs proxy. Lorsque vous utilisez la méthode getWorkingProxies avec une liste d’URL de proxys, elle vérifie l’état de chaque proxy de manière asynchrone via la méthode checkProxy, en collectant les proxys opérationnels dans une liste WorkingProxies. Dans CheckProxy, vous établissez un HttpClient avec l’URL du proxy, vous envoyez une demande de test à http://www.google.com et vous enregistrez la progression en toute sécurité à l’aide d’un sémaphore.
La méthode IsProxyWorking confirme la fonctionnalité du proxy en examinant le code d’état de la réponse et en renvoyant true pour les proxys opérationnels. Cette classe permet d’identifier les proxys fonctionnels à partir d’une liste donnée.
Scraper des données Web
Pour scraper des données, créez un nouveau fichier de classe WebScraper.cs dans votre solution WebScrapApp et ajoutez le code suivant :
using HtmlAgilityPack;
namespace WebScrapApp
{
public class WebScraper
{
public static async Task ScrapeData(ProxyRotator proxyRotator, string url)
{
try
{
var client = proxyRotator.ScrapeDataWithRandomProxy(url);
// Use HttpClient to make an asynchronous GET request
var response = await client.GetAsync(url);
var content = await response.Content.ReadAsStringAsync();
// Load the HTML content into an HtmlDocument
HtmlDocument doc = new();
doc.LoadHtml(content);
// Use XPath to find all <a> tags that are direct children of <li>, <p>, or <td>
var nodes = doc.DocumentNode.SelectNodes("//li/a[@href] | //p/a[@href] | //td/a[@href]");
if (nodes != null)
{
foreach (var node in nodes)
{
string hrefValue = node.GetAttributeValue("href", string.Empty);
string title = node.InnerText; // This gets the text content of the <a> tag, which is usually the title
// Since Wikipedia URLs are relative, we need to convert them to absolute
Uri baseUri = new(url);
Uri fullUri = new(baseUri, hrefValue);
Console.WriteLine($"Title: {title}, Link: {fullUri.AbsoluteUri}");
// You can process each title and link as required
}
}
else
{
Console.WriteLine("No article links found on the page.");
}
// Add additional logic for other data extraction as needed
}
catch (Exception ex)
{
throw ex;
}
}
}
}
Dans ce code, vous définissez le WebScraper, qui encapsule la fonctionnalité de web scraping. Lorsque vous appelez la méthode ScrapeData, vous lui fournissez une instance ProxyRotator et une URL cible. Dans cette méthode, vous utilisez un HttpClient pour envoyer une requête GET asynchrone à l’URL, récupérer le contenu HTML et l’analyser à l’aide de la bibliothèque HtmlAgilityPack. Vous utilisez ensuite des requêtes XPath pour localiser et extraire des liens et des titres correspondants à partir d’éléments HTML spécifiques. Si des liens vers des articles sont trouvés, vous imprimez leurs titres et leurs URL absolues ; sinon, vous imprimez un message indiquant qu’aucun lien n’a été trouvé.
Après avoir configuré le mécanisme de rotation des proxys et implémenté la fonctionnalité de web scraping, vous devez intégrer ces composants de manière fluide au point d’entrée principal de l’application, qui se trouve généralement dans Program.cs. Cette intégration permet à l’application d’exécuter des tâches de web scraping tout en utilisant des proxys rotatifs, en mettant l’accent sur le scraping de données depuis la page d’accueil de Wikipedia :
namespace WebScrapApp {
public class Program
{
static async Task Main(string[] args)
{
string[] proxies = {
"http://162.223.89.84:80",
"http://203.80.189.33:8080",
"http://94.45.74.60:8080",
"http://162.248.225.8:80",
"http://167.71.5.83:3128"
};
var proxyRotator = new ProxyRotator(proxies, false);
string urlToScrape = "https://www.wikipedia.org/";
await WebScraper.ScrapeData(proxyRotator, urlToScrape);
}
}
}
Dans ce code, l’application initialise une liste d’URL de proxys, crée une instance ProxyRotator, spécifie l’URL cible pour le scraping (dans ce cas, https://www.wikipedia.org/) et invoque la méthode WebScraper.ScrapeData pour démarrer le processus de web scraping.
L’application utilise une liste d’adresses IP de proxys gratuites, spécifiée dans le tableau de proxys, pour acheminer les requêtes de web scraping, masquer la source de confiance et minimiser le risque de blocage par le serveur Wikipedia. La méthode ScrapeData est configurée pour scraper la page d’accueil de Wikipedia afin d’extraire et d’afficher les titres des articles et les liens dans la console. La classe ProxyRotator gère la rotation de ces proxys, améliorant ainsi la discrétion du scraping.
Exécuter la WebScrapApp
Pour exécuter WebScrapApp, ouvrez un nouveau terminal ou un nouvel interpréteur dans le répertoire racine de votre application WebScrapApp et exécutez les commandes suivantes :
dotnet build
dotnet run
Votre résultat devrait ressembler à ceci :
…output omitted…
Title: Latina, Link: https://la.wikipedia.org/
Title: Latviešu, Link: https://lv.wikipedia.org/
Title: Lietuvių, Link: https://lt.wikipedia.org/
Title: Magyar, Link: https://hu.wikipedia.org/
Title: Македонски, Link: https://mk.wikipedia.org/
Title: Bahasa Melayu, Link: https://ms.wikipedia.org/
Title: Bahaso Minangkabau, Link: https://min.wikipedia.org/
Title: bokmål, Link: https://no.wikipedia.org/
Title: nynorsk, Link: https://nn.wikipedia.org/
Title: Oʻzbekcha / Ўзбекча, Link: https://uz.wikipedia.org/
Title: Қазақша / Qazaqşa / قازاقشا, Link: https://kk.wikipedia.org/
Title: Română, Link: https://ro.wikipedia.org/
Title: Simple English, Link: https://simple.wikipedia.org/
Title: Slovenčina, Link: https://sk.wikipedia.org/
Title: Slovenščina, Link: https://sl.wikipedia.org/
Title: Српски / Srpski, Link: https://sr.wikipedia.org/
Title: Srpskohrvatski / Српскохрватски, Link: https://sh.wikipedia.org/
Title: Suomi, Link: https://fi.wikipedia.org/
Title: தமிழ், Link: https://ta.wikipedia.org/
…output omitted…
Lorsque la méthode ScrapeData de la classe WebScraper est invoquée, elle extrait les données de Wikipedia, ce qui entraîne l’affichage dans la console des titres des articles et des liens correspondants. Ce code utilise des proxys disponibles publiquement, et chaque fois que vous exécutez l’application, il choisit l’une des adresses IP répertoriées comme proxys.
Pour effectuer un test avec le proxy local de mitmproxy, mettez à jour la méthode ProxyRotator dans le fichier Program avec ce qui suit :
var proxyRotator = new ProxyRotator(proxies, true)
string urlToScrape = "http://toscrape.com/";
En définissant la valeur sur true, cela récupère le serveur proxy local qui s’exécute sur le port 8080 de votre hôte local (c’est-à-dire le serveur mitmproxy).
Pour simplifier le processus de configuration lorsque vous configurez un certificat sur votre machine, remplacez l’URL par http://toscrape.com/.
Vérifiez que le serveur mitmproxy fonctionne, puis exécutez à nouveau les mêmes commandes :
dotnet build
dotnet run
Votre résultat devrait ressembler à ceci :
…output omitted…
Title: fictional bookstore, Link: http://books.toscrape.com/
Title: books.toscrape.com, Link: http://books.toscrape.com/
Title: A website, Link: http://quotes.toscrape.com/
Title: Default, Link: http://quotes.toscrape.com/
Title: Scroll, Link: http://quotes.toscrape.com/scroll
Title: JavaScript, Link: http://quotes.toscrape.com/js
Title: Delayed, Link: http://quotes.toscrape.com/js-delayed
Title: Tableful, Link: http://quotes.toscrape.com/tableful
Title: Login, Link: http://quotes.toscrape.com/login
Title: ViewState, Link: http://quotes.toscrape.com/search.aspx
Title: Random, Link: http://quotes.toscrape.com/random
…output omitted…
Si vous consultez la fenêtre mitmproxy depuis votre terminal ou votre interpréteur, vous devriez voir que l’appel a été intercepté :
Comme vous pouvez le constater, configurer un proxy local ou passer d’un proxy à l’autre peut être une tâche complexe et chronophage. Heureusement, des outils tels que ceux de Bright Data peuvent vous aider. Dans la section suivante, vous allez apprendre à utiliser le serveur proxy Bright Data pour simplifier le processus de scraping.
Proxy Bright Data
Bright Data propose un réseau de services proxy disponibles dans 195 emplacements. Ce réseau intègre la fonctionnalité de rotation des proxys de Bright Data, qui alterne systématiquement entre les serveurs pour améliorer l’efficacité et la sécurité du web scraping.
L’utilisation de ce système de proxys rotatifs réduit le risque de bannissement ou de blocage d’adresses IP généralement rencontrés lors des tâches de web scraping. Chaque requête utilise un proxy différent, ce qui masque l’identité du scraper et rend difficiles la détection et la limitation de l’accès par les sites Web. Cette approche améliore la fiabilité de la collecte de données, en garantissant un anonymat et une sécurité accrus.
La plateforme Bright Data est conçue pour être facile à utiliser et à configurer, ce qui en fait la solution idéale pour des projets de web scraping en langage C#, un sujet qui sera abordé dans la section suivante.
Créer un proxy résidentiel
Vous devez créer un compte avant de pouvoir utiliser un proxy Bright Data dans votre projet. Pour ce faire, rendez-vous sur le site Web de Bright Data et inscrivez-vous pour un essai gratuit.
Une fois que vous avez configuré votre compte, connectez-vous et cliquez sur l’icône de localisation sur la gauche pour accéder à Proxys et infrastructure de scraping. Cliquez ensuite sur Ajouter et choisissez Proxys résidentiels :
Conservez les noms par défaut et cliquez à nouveau sur Ajouter pour créer un proxy résidentiel :
Une fois le proxy créé, vous devriez voir les informations d’identification, y compris l’hôte, le port, le nom d’utilisateur et le mot de passe. Enregistrez ces informations d’identification en lieu sûr, car vous en aurez besoin ultérieurement :
Accédez à votre projet WebScrapingBrightData depuis votre IDE ou votre terminal/interpréteur. Créez ensuite un fichier de classe BrightDataProxyConfigurator.cs et ajoutez le code suivant :
using System.Net;
namespace WebScrapBrightData
{
public class BrightDataProxyConfigurator
{
public static HttpClient ConfigureHttpClient(string proxyHost, string proxyUsername, string proxyPassword)
{
var proxy = new WebProxy(proxyHost) {
Credentials = new NetworkCredential(proxyUsername, proxyPassword)
};
var httpClientHandler = new HttpClientHandler() {
Proxy = proxy,
UseProxy = true
};
var client = new HttpClient(httpClientHandler);
client.DefaultRequestHeaders.Add("User-Agent", "YourUserAgent");
client.DefaultRequestHeaders.Add("Accept", "application/json");
client.DefaultRequestHeaders.TryAddWithoutValidation("Proxy-Authorization", Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes($"{proxyUsername}:{proxyPassword}")));
return client;
}
}
}
Dans ce code, vous définissez une classe BrightDataProxyConfigurator, qui inclut la méthode ConfigureHttpClient. Lorsqu’elle est invoquée, cette méthode configure et renvoie un HttpClient configuré pour utiliser un serveur proxy. Pour ce faire, créez une URL de proxy en utilisant le nom d’utilisateur, le mot de passe, l’hôte et le port fournis, puis configurez un HttpClientHandler avec ce proxy. La méthode renvoie finalement une instance HttpClient qui achemine toutes ses requêtes via le proxy spécifié.
Ensuite, créez le fichier de classe WebContentScraper.cs dans le cadre du projet WebScrapingBrightData et ajoutez le code suivant :
using HtmlAgilityPack;
namespace WebScrapBrightData
{
public class WebContentScraper
{
public static async Task ScrapeContent(string url, HttpClient client)
{
var response = await client.GetAsync(url);
var content = await response.Content.ReadAsStringAsync();
HtmlDocument doc = new();
doc.LoadHtml(content);
var nodes = doc.DocumentNode.SelectNodes("//li/a[@href] | //p/a[@href] | //td/a[@href]");
if (nodes != null)
{
foreach (var node in nodes)
{
string hrefValue = node.GetAttributeValue("href", string.Empty);
string title = node.InnerText;
Uri baseUri = new(url);
Uri fullUri = new(baseUri, hrefValue);
Console.WriteLine($"Title: {title}, Link: {fullUri.AbsoluteUri}");
}
}
else
{
Console.WriteLine("No article links found on the page.");
}
}
}
}
Ce code définit une classe WebContentScraper avec une méthode asynchrone statique, ScrapeContent. Cette méthode prend une URL et un HttpClient, récupère le contenu de la page Web, l’analyse au format HTML et extrait des liens à partir d’éléments HTML spécifiques (éléments de liste, paragraphes et cellules de tableau). Elle affiche ensuite les titres et les URI absolus de ces liens dans la console.
Classe de programme
Maintenant, scrapez à nouveau Wikipedia et découvrez comment Bright Data améliore l’accès et l’anonymat.
Mettez à jour le fichier de classe Program.cs avec le code suivant :
namespace WebScrapBrightData
{
public class Program
{
public static async Task Main(string[] args)
{
// Bright Data Proxy Configuration
string host = "your_brightdata_proxy_host";
string username = "your_brightdata_proxy_username";
string password = "your_brightdata_proxy_password";
var client = BrightDataProxyConfigurator.ConfigureHttpClient(host, username, password);
// Scrape content from the target URL
string urlToScrape = "https://www.wikipedia.org/";
await WebContentScraper.ScrapeContent(urlToScrape, client);
}
}
}
Remarque : assurez-vous de remplacer les informations d’identification du proxy Bright Data par celles que vous avez enregistrées précédemment.
Ensuite, pour tester et exécuter votre application, ouvrez votre interpréteur ou votre terminal depuis le répertoire racine de votre projet WebScrapBrightData et exécutez la commande suivante :
dotnet build
dotnet run
Vous devriez obtenir le même résultat que précédemment lorsque vous utilisiez des proxys publics :
…output omitted…
Title: Latina, Link: https://la.wikipedia.org/
Title: Latviešu, Link: https://lv.wikipedia.org/
Title: Lietuvių, Link: https://lt.wikipedia.org/
Title: Magyar, Link: https://hu.wikipedia.org/
Title: Македонски, Link: https://mk.wikipedia.org/
Title: Bahasa Melayu, Link: https://ms.wikipedia.org/
Title: Bahaso Minangkabau, Link: https://min.wikipedia.org/
Title: bokmål, Link: https://no.wikipedia.org/
Title: nynorsk, Link: https://nn.wikipedia.org/
Title: Oʻzbekcha / Ўзбекча, Link: https://uz.wikipedia.org/
Title: Қазақша / Qazaqşa / قازاقشا, Link: https://kk.wikipedia.org/
Title: Română, Link: https://ro.wikipedia.org/
Title: Simple English, Link: https://simple.wikipedia.org/
Title: Slovenčina, Link: https://sk.wikipedia.org/
Title: Slovenščina, Link: https://sl.wikipedia.org/
Title: Српски / Srpski, Link: https://sr.wikipedia.org/
Title: Srpskohrvatski / Српскохрватски, Link: https://sh.wikipedia.org/
Title: Suomi, Link: https://fi.wikipedia.org/
Title: தமிழ், Link: https://ta.wikipedia.org/
…output omitted…
Le programme utilise le proxy Bright Data pour scraper la page d’accueil de Wikipedia et afficher les titres et les liens extraits dans la console. Cela montre l’efficacité et la facilité de l’intégration du proxy Bright Data dans un projet de web scraping en langage C# pour une extraction de données discrète et robuste.
Si vous souhaitez visualiser l’effet de l’utilisation d’un proxy Bright Data, vous pouvez essayer d’envoyer une requête GET à http://lumtest.com/myip.json. Ce site Web renverra la localisation et d’autres informations relatives au réseau du client qui tente actuellement d’accéder au site Web. Si vous voulez l’essayer vous-même, ouvrez le lien dans un nouvel onglet de navigateur. Vous devriez voir les détails de votre réseau qui sont visibles publiquement.
Pour l’essayer avec un proxy Bright Data, mettez à jour le code dans WebContentScraper.cs pour qu’il corresponde à ce qui suit :
using HtmlAgilityPack;
public class WebContentScraper
{
public static async Task ScrapeContent(string url, HttpClient client)
{
var response = await client.GetAsync(url);
var content = await response.Content.ReadAsStringAsync();
HtmlDocument doc = new();
doc.LoadHtml(content);
Console.Write(content);
}
}
Ensuite, mettez à jour la variable URLToScrape dans le fichier Program.cs pour scraper le site Web :
string urlToScrape = "http://lumtest.com/myip.json";
Maintenant, essayez à nouveau d’exécuter l’application. Vous devriez voir un résultat comme celui-ci dans votre terminal :
{"ip":"79.221.123.68","country":"DE","asn":{"asnum":3320,"org_name":"Deutsche Telekom AG"},"geo":{"city":"Koenigs Wusterhausen","region":"BB","region_name":"Brandenburg","postal_code":"15711","latitude":52.3014,"longitude":13.633,"tz":"Europe/Berlin","lum_city":"koenigswusterhausen","lum_region":"bb"}}
Cela permet de vérifier que la requête a bien été acheminée par proxy via les serveurs proxy de Bright Data.
Conclusion
Dans cet article, vous avez appris à utiliser des serveurs proxy en langage C# pour le web scraping.
Bien que les serveurs proxy locaux puissent être utiles dans certains scénarios, ils présentent souvent des limites pour les projets de web scraping. Heureusement, des serveurs proxy peuvent vous aider. Grâce à son vaste réseau mondial et à une gamme variée d’options de proxys, notamment des proxys résidentiels, de FAI, de datacenters et mobiles, Bright Data garantit un haut degré de flexibilité et de fiabilité. La fonction de rotation des proxys est notamment très utile pour les tâches de scraping à grande échelle, car elle permet de préserver l’anonymat et de réduire le risque de bannissement d’adresses IP.
Alors que vous poursuivez votre parcours de web scraping, pensez à utiliser les solutions Bright Data comme un moyen puissant et évolutif de collecter des données de manière efficace tout en respectant les meilleures pratiques en matière de web scraping.
Tout le code de ce tutoriel est disponible dans ce repository sur GitHub.
