Quando você acessa a internet diretamente, os sites podem facilmente rastrear suas solicitações até chegar ao seu endereço IP. Essa exposição pode levar a publicidade direcionada e rastreamento on-line e potencialmente comprometer sua identidade digital.
É aí que entram os proxies. Eles atuam como intermediários entre seu computador e a internet e ajudam você a proteger sua identidade digital. Quando você usa um servidor proxy, ele envia solicitações para os sites em seu nome usando o próprio endereço IP do proxy.
Quando se trata de web scraping, os proxies podem ajudar você a contornar banimentos de IP, evitar o bloqueio geográfico e proteger sua identidade. Neste artigo, você aprenderá como implementar proxies em C# para todos os seus projetos de web scraping.
Pré-requisitos
Antes de começar este tutorial, certifique-se de ter o seguinte:
- Visual Studio 2022 ou Visual Studio Code
- .NET 7 ou mais recente
- Pacote HTMLAgilityPackdo NuGet
Os exemplos neste artigo usam um aplicativo de console .NET separado. Para criar o seu próprio, você pode usar um dos seguintes guias:
- Crie um aplicativo de console .NET usando o Visual Studio Code
- Crie um aplicativo de console .NET usando o Visual Studio
Para começar, você precisa criar dois aplicativos de console, WebScrapApp e WebScrapBrightData:
Para web scraping, especialmente se você estiver lidando com conteúdo HTML, você precisa de ferramentas específicas, como o HTMLAgilityPack. Essa biblioteca simplifica a análise e a manipulação de HTML, facilitando a extração de dados das páginas web.
Em ambos os projetos (ou seja, WebScrapApp e WebScrapBrightData), adicione o pacote HTMLAgilityPack do NuGet clicando com o botão direito do mouse na pasta NuGet e depois em Gerenciar pacotes NuGet. Quando uma janela pop-up aparecer, pesquise por “HTMLAgilityPack” e instale-o para os dois projetos:
Para executar qualquer um dos projetos a seguir, você precisa navegar até o diretório do projeto no prompt de comando e usar cd path\to\your\project seguido por dotnet run. Como alternativa, você pode pressionar F5 para criar e executar o projeto no Visual Studio. Ambos os métodos compilam e executam seu aplicativo, exibindo a saída de acordo.
Nota: se você não tiver o Visual Studio 2022, poderá usar qualquer IDE alternativo com suporte ao .NET 7. Lembre-se de que algumas etapas deste guia podem variar.
Como configurar um proxy local
Quando se trata de web scraping, a primeira coisa que você precisa fazer é usar um servidor proxy. Este tutorial usa o proxy de código aberto mitmproxy.
Para começar, navegue até mitmproxy downloads, baixe a versão 10.1.6 e selecione a versão correta para seu sistema operacional. Para obter ajuda adicional, confira o guia oficial de instalação do mitmproxy.
Depois de instalar o mitmproxy, abra seu terminal e inicialize o mitmproxy usando o seguinte comando:
mitmproxy
Deve aparecer uma janela em seu shell ou terminal parecida com esta:
Para testar o proxy, abra outro terminal ou shell e execute a seguinte solicitação curl:
curl --proxy http://localhost:8080 "http://wttr.in/Dunedin?0"
O resultado deve ser semelhante a este:
Weather report: Dunedin
Cloudy
.--. +11(9) °C
.-( ). ↙ 15 km/h
(___.__)__) 10 km
0.0 mm
Na janela do mitmproxy, você deve ver que ele interceptou a chamada por meio do proxy local:
Web scraping em C#
Na seção a seguir, você configurará o aplicativo de console em C# WebScrapApp para web scraping. Esse aplicativo utiliza o servidor proxy e inclui rotação de proxies para maior eficiência.
Crie um HttpClient
A classe ProxyHttpClient foi projetada para configurar uma instância HttpClient para rotear solicitações por meio de um servidor proxy especificado.
Em seu projeto WebScrapApp , crie um novo arquivo de classe chamado ProxyHttpClient.cs e adicione o seguinte código:
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);
}
}
}
Implementar a rotação de proxies
Para implementar a rotação de proxies, crie um arquivo de classe ProxyRotator.cs em sua solução 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);
}
}
}
Essa classe gerencia uma lista de proxies, fornecendo um método para selecionar aleatoriamente um proxy para cada solicitação da web. Essa randomização é fundamental para reduzir o risco de detecção e possíveis banimentos de IP durante a extração de dados da web.
Quando isLocal está definido como True, ele usa o proxy local do mitmproxy. Se estiver definido como False, ele usa os IPs públicos dos proxies.
O ProxyChecker é usado para validar a lista de servidores proxy.
Em seguida, crie um novo arquivo de classe chamado ProxyChecker.cs e adicione o seguinte código:
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;
}
}
}
}
Esse código define o ProxyChecker para validar uma lista de servidores proxy. Quando você usa o método getWorkingProxies com uma lista de URLs de proxy, ele verifica o status de cada proxy de forma assíncrona por meio do método checkProxy , reunindo proxies operacionais em uma lista WorkingProxies . Em checkProxy, você estabelece um HttpClient com o URL do proxy, faz uma solicitação de teste para http://www.google.come registra o progresso com segurança usando um semáforo.
O método isProxyWorking confirma a funcionalidade do proxy examinando o código de status da resposta, retornando true para proxies operacionais. Essa classe ajuda na identificação de proxies funcionais de uma determinada lista.
Extrair dados da web
Para extrair dados, crie um novo arquivo de classe WebScraper.cs em sua solução WebScrapApp e adicione o seguinte código:
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;
}
}
}
}
Nesse código, você define o WebScraper, que encapsula a funcionalidade de web scraping. Ao chamar o método ScrapeData , você fornece a ele uma instância ProxyRotator e um URL de destino. Dentro desse método, você usa um HttpClient para fazer uma solicitação GET assíncrona para o URL, recuperar o conteúdo HTML e analisá-lo usando a biblioteca HTMLAgilityPack. Em seguida, você usa consultas XPath para localizar e extrair links e títulos correspondentes de elementos HTML específicos. Se algum link de artigo for encontrado, você imprime seus títulos e URLs absolutos. Do contrário, você imprime uma mensagem indicando que nenhum link foi encontrado.
Depois de configurar o mecanismo de rotação de proxies e implementar a funcionalidade de web scraping, você precisa integrar perfeitamente esses componentes ao ponto de entrada principal do aplicativo, que normalmente é encontrado em Program.cs. Essa integração permite que o aplicativo execute tarefas de extração de dados na web enquanto utiliza proxies rotativos com um foco específico na extração de dados da página inicial da 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);
}
}
}
Nesse código, o aplicativo inicializa uma lista de URLs de proxy, cria uma instância ProxyRotator , especifica o URL de destino para extração (nesse caso, https://www.wikipedia.org/) e invoca o método webScraper.scrapeData para iniciar o processo de web scraping.
O aplicativo usa uma lista de IPs de proxies gratuitos, especificada no array de proxies, para rotear solicitações de web scraping, mascarando a fonte confiável e minimizando o risco de ser bloqueado pelo servidor da Wikipedia. O método ScrapeData está configurado para extrair dados da página inicial da Wikipedia para extrair e exibir títulos e links de artigos no console. A classe ProxyRotator manipula a rotação desses proxies, aumentando a discrição do scraping.
Executar o WebScrapApp
Para executar o WebScrapApp, abra um novo terminal ou shell no diretório raiz do seu aplicativo WebScrapApp e execute os seguintes comandos:
dotnet build
dotnet run
O resultado deve ser semelhante a este:
…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…
Quando o método ScrapeData da classe WebScraper é invocado, ele executa a extração de dados da Wikipedia, resultando na exibição dos títulos dos artigos e seus links correspondentes no console. Esse código usa proxies disponíveis publicamente e, toda vez que você executa o aplicativo, ele escolhe um dos endereços IP listados como proxy.
Para testar com o proxy local do mitmproxy, atualize o método ProxyRotator no arquivo Program com o seguinte:
var proxyRotator = new ProxyRotator(proxies, true)
string urlToScrape = "http://toscrape.com/";
Ao definir o valor como true, ele usa o servidor proxy local que está sendo executado na porta 8080 do seu localhost (ou seja, o servidor mitmproxy).
Para simplificar o processo de configuração de um certificado em sua máquina, altere o URL para http://toscrape.com/.
Verifique se o servidor mitmproxy está em execução. Em seguida, execute os mesmos comandos novamente:
dotnet build
dotnet run
O resultado deve ser semelhante a este:
…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…
Se você verificar a janela do mitmproxy a partir do seu terminal ou shell, verá que ele interceptou a chamada:
Como você pode ver, configurar um proxy local ou alternar entre vários proxies pode ser uma tarefa complexa e demorada. Felizmente, ferramentas como a Bright Data podem ajudar. Na seção a seguir, você aprenderá a usar o servidor proxy da Bright Data para simplificar o processo de extração de dados.
Proxy da Bright Data
A Bright Data oferece uma rede de serviços de proxy disponível em 195 localizações. Essa rede integra o recurso de rotação de proxies da Bright Data, alternando sistematicamente entre servidores para melhorar a eficácia e a segurança do web scraping.
O uso desse sistema de proxy rotativo diminui o risco de banimentos ou bloqueios de IP normalmente enfrentados durante tarefas de web scraping. Cada solicitação usa um proxy diferente, ocultando a identidade do scraper e dificultando que os sites detectem e limitem o acesso. Essa abordagem aumenta a confiabilidade da extração de dados, garantindo maior anonimato e segurança.
A plataforma Bright Data foi projetada para facilitar o uso e simplificar a configuração, tornando-a perfeita para projetos de web scraping em C#, que você verá na próxima seção.
Criar um proxy residencial
Antes de usar um proxy da Bright Data em seu projeto, você precisa configurar uma conta. Para fazer isso, visite o site da Bright Data e inscreva-se para um teste gratuito.
Depois de configurar sua conta, faça login e clique no ícone de localização à esquerda para navegar até Proxies & Scraping Infrastructure (infraestrutura de proxies e scraping). Em seguida, clique em Add (adicionar) e escolha Residential Proxies (proxies residenciais):
Mantenha os nomes padrão e clique em Add novamente para criar um proxy residencial:
Depois de criado, você verá as credenciais do proxy, incluindo host, porta, nome de usuário e senha. Salve essas credenciais em um local seguro, pois você precisará delas mais tarde:
Navegue até seu projeto WebScrapingBrightData a partir do seu IDE ou terminal/shell. Em seguida, crie um arquivo de classe BrightDataProxyConfigurator.cs e adicione o seguinte código:
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;
}
}
}
Nesse código, você define uma classe BrightDataProxyConfigurator , que inclui o método ConfigureHttpClient . Quando chamado, esse método configura e retorna um HttpClient configurado para usar um servidor proxy. Você consegue isso criando um URL de proxy usando o nome de usuário, senha, hoste porta e, em seguida, configurando um HttpClientHandler com esse proxy. Em última análise, o método retorna uma instância HttpClient que encaminha todas as suas solicitações por meio do proxy especificado.
Em seguida, crie o arquivo de classe WebContentScraper.cs no projeto WebScrapingBrightData e adicione o seguinte código:
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.");
}
}
}
}
Esse código define uma classe WebContentScraper com um método estático assíncrono, ScrapeContent. Esse método usa um URL e um HttpClient, busca o conteúdo da página web, analisa-a como HTML e extrai links de elementos HTML específicos (itens de listas, parágrafos e células de tabelas). Em seguida, ele imprime os títulos e os URIs absolutos desses links no console.
Classe do programa
Agora, extraia dados da Wikipedia novamente e veja como a Bright Data melhora o acesso e o anonimato.
Atualize o arquivo de classe Program.cs com o seguinte código:
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);
}
}
}
Nota: certifique-se de substituir as credenciais de proxy da Bright Data pelas que você salvou anteriormente.
Em seguida, para testar e executar seu aplicativo, abra seu shell ou terminal a partir do diretório raiz do seu projeto WebScrapBrightData e execute o seguinte comando:
dotnet build
dotnet run
Você deve obter a mesma saída de antes, quando utilizou proxies públicos:
…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…
O programa usa o proxy Bright Data para extrair dados da página inicial da Wikipedia e exibir no console os títulos e links extraídos. Isso mostra a eficácia e a facilidade de integrar o proxy Bright Data em um projeto de web scraping em C# para uma extração de dados discreta e robusta.
Se você quiser visualizar o efeito do uso de um proxy da Bright Data, tente enviar uma solicitação GET para http://lumtest.com/myip.json. Esse site retornará a localização e outros detalhes relacionados à rede do cliente que está tentando acessar o site no momento. Se você quiser tentar fazer isso sozinho, abra o link em uma nova guia do navegador. Você deve ver os detalhes da sua rede que são visíveis publicamente.
Para testar com um proxy da Bright Data, atualize o código em WebContentScraper.cs para corresponder ao seguinte:
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);
}
}
Em seguida, atualize a variável URLToScrape no arquivo Program.cs para extrair dados do site:
string urlToScrape = "http://lumtest.com/myip.json";
Agora, tente executar o aplicativo novamente. Você deve ver no terminal um resultado parecido com este:
{"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"}}
Isso confirma que a solicitação está agora passando pelos servidores proxy da Bright Data.
Conclusão
Neste artigo, você aprendeu como usar servidores proxy com C# para web scraping.
Embora os servidores proxy locais possam ser úteis em alguns cenários, eles geralmente apresentam limitações para projetos de web scraping. Felizmente, servidores proxy podem ajudar. Com sua extensa rede global e uma ampla variedade de opções de proxy, incluindo proxies residenciais, de ISPs, de datacenters e móveis, a Bright Data garante um alto grau de flexibilidade e confiabilidade. Notavelmente, o recurso de rotação de proxies é inestimável para tarefas de extração de dados em grande escala, ajudando a manter o anonimato e reduzir o risco de banimentos de IP.
Ao continuar sua jornada de web scraping, considere usar as soluções da Bright Data como uma forma poderosa e escalável de coletar dados com eficiência e, ao mesmo tempo, seguir as melhores práticas de extração de dados da web.
Todo o código deste tutorial está disponível neste repositório do GitHub.
