Como definir um proxy usando HttpClient em .NET com C#

Ao final deste guia de integração de proxy HttpClient C#, você saberá:

• O que é o HttpClient e sua função na realização de solicitações HTTP no .NET
• Por que você deve usar um proxy em C#
• Como configurar um proxy no HttpClient
• Como lidar com autenticação de proxy, erros de certificado SSL e rotação de IP com o HttpClient.

Vamos mergulhar de cabeça!

O que é HttpClient no .NET?

HttpClient é uma classe para fazer solicitações HTTP e receber respostas HTTP no .NET. Ela faz parte do namespace System.Net.Http, representando o cliente HTTP padrão em .NET e, portanto, em C#.

O HttpClient é compatível:

• Todos os métodos HTTP, incluindo GET, POST, PUT, PATCH e DELETE
• Comunicação assíncrona
• Personalização de cabeçalhos e cookies
• Personalização do corpo da solicitação
• Integração de proxy

Esses recursos, juntamente com seu suporte oficial na .NET Standard Library, fazem do HttpClient uma opção popular para solicitações HTTP em C#.

Por que você precisa definir um proxy no C# HttpClient

Ao trabalhar com raspagem da Web, coleta de dados ou outras tarefas relacionadas à Internet, é fundamental proteger sua identidade on-line. Uma maneira de conseguir isso é rotear seu tráfego por meio de um servidor proxy.

Um servidor proxy atua como um intermediário entre você e o site de destino, fornecendo esses benefícios ao HttpClient:

• IP e local ocultos: Os servidores de destino veem o IP do proxy, não o seu.
• Confidencialidade aprimorada: Os proxies adicionam uma camada de privacidade ao mascarar sua identidade real e dificultar o rastreamento.
• Evite proibições de IP: Os proxies ajudam você a contornar os limitadores de taxa, o que é fundamental na coleta de dados da Web com C#.
• Contornar restrições geográficas: Você pode usar servidores proxy localizados em regiões específicas para acessar conteúdo com restrição geográfica em sua casa.

Assim, o uso de proxies no HttpClient não apenas aumenta sua segurança on-line, mas também aprimora a confiabilidade de suas tarefas de raspagem.

Configurar um proxy com HttpClient em C#: Guia passo a passo

Siga as etapas abaixo para saber como integrar um proxy em HttpClient no .NET usando C#.

Pré-requisitos

Antes de começar, certifique-se de que você atende aos seguintes pré-requisitos:

• UM IDE C#: Você pode usar o Visual Studio ou o Visual Studio Code. Neste guia, usaremos o Visual Studio Code com a extensão C#.
• .NET 8+ instalado localmente: Você precisa da versão mais recente do .NET ou de qualquer versão LTS maior ou igual ao .NET 8. Este tutorial usará o .NET 9.

Se você não tiver as ferramentas necessárias, faça o download delas usando o link acima e siga o assistente de instalação.

Etapa 1: Configuração do projeto

Crie uma nova pasta para seu projeto .NET e navegue até ela no terminal com os seguintes comandos:

mkdir httpclient-proxy
cd httpclient-proxy

Em seguida, inicialize um novo aplicativo de console .NET dentro dele:

dotnet run console

O resultado deve ser:

The template "Console App" was created successfully.

Agora, abra a pasta do projeto em seu IDE:

Você deverá ver os arquivos gerados pelo modelo, sendo o Program.cs o mais importante. Atualmente, ele contém um simples script “Hello, World!”. No final desta seção, ele será um script de integração de proxy C# HttpClient.

Para garantir que tudo funcione conforme o esperado, tente iniciar o aplicativo C# com:

dotnet run

O resultado deve ser:

Hello, World!

Excelente! Agora você tem um projeto C# funcional no Visual Studio Code.

Etapa 2: configurar o HttpClient

Adicione as seguintes linhas de código ao Program.cs para enviar uma solicitação usando o HttpClient:

using System.Net;

class Program
{
  static async Task Main()
  {
    // initialize an HttpClient instance
    using HttpClient client = new HttpClient();

    // the target URL
    string url = "https://httpbin.org/ip";

    // send an async GET request to the endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // read the response content as a string
    string responseBody = await response.Content.ReadAsStringAsync();

    // print the response to the console
    Console.WriteLine(responseBody);
  }
}

O snippet inicializa uma instância HttpClient e usa seu método GetAsync() para se conectar ao endpoint /ip GET do projeto HTTPBin.io. Essa API retorna o endereço IP do chamador, o que a torna um alvo perfeito para verificar se a integração do proxy funciona conforme o esperado. O motivo? Quando você integra um proxy ao HttpClient, o IP retornado pelo ponto de extremidade /ip deve ser diferente do seu IP original.

Se você executar o script, o resultado deverá ser algo como:

{
  "origin": "55.17.80.196"
}

O endereço IP contido na origem representa seu IP de saída.

Incrível! É hora de obter um URL de proxy válido.

Etapa 3: Recuperar um proxy

Para integrar um proxy ao HttpClient, primeiro você precisa ter acesso a um servidor proxy.

Muitos portais on-line oferecem URLs de proxy gratuitos, mas seja cauteloso: a administração de uma infraestrutura de proxy é cara. Se um serviço estiver oferecendo proxies gratuitos, considere qual pode ser o modelo de negócios dele. Geralmente, eles se envolvem em roubo de dados ou outras práticas questionáveis.

Por esse motivo, é melhor usar proxies gratuitos apenas para fins de aprendizado e evitá-los para uso em produção!

Se você precisar de proxies confiáveis, considere os provedores de boa reputação que oferecem testes gratuitos ou planos gratuitos limitados. Por exemplo, você pode experimentar nossos proxies gratuitos.

Agora, um URL de proxy típico segue este formato:

<protocol>://<host>:<port>

Onde:

• protocol especifica o tipo de proxy (por exemplo, http, https, socks5, etc.)
• host: o domínio ou endereço IP do servidor proxy
• porta: O número da porta pela qual o tráfego é roteado

Neste exemplo, assumiremos que o URL do proxy é:

http://66.29.154.103:3128

Armazene isso em uma variável no arquivo Program.cs:

string proxyUrl = "http://66.29.154.103:3128";

É hora de ver como usar um proxy com o HttpClient!

Etapa 4: Integração de proxy

O HttpClient permite que você especifique um proxy por meio da classe HttpClientHandler. Isso fornece controle de baixo nível sobre as solicitações HTTP enviadas por uma instância HttpClient.

Em particular, o HttpClientHandler tem uma propriedade Proxy que aceita um objeto WebProxy que contém as configurações do servidor proxy:

WebProxy proxy = new WebProxy
{
  Address = new Uri(proxyUrl),
};

Em seguida, passe o proxy para uma instância de HttpClientHandler:

HttpClientHandler handler = new HttpClientHandler
{
    Proxy = proxy,
};

E, por fim, passe o HttpClientHandler para o construtor do HttpClient:

using HttpClient client = new HttpClient(handler);

Maravilhoso! Integração do proxy HttpClient C# concluída.

Etapa nº 5: Juntar tudo

Seu script final de integração do proxy HttpClient deve conter:

using System.Net;

class Program
{
  static async Task Main()
  {
    // initialize a new proxy object
    string proxyUrl = "http://66.29.154.103:3128"; // replace with a valid proxy URL
    WebProxy proxy = new WebProxy
    {
      Address = new Uri(proxyUrl),
    };

    // define an HTTP client handler with the given proxy
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = proxy,
    };

    // initialize an HttpClient instance with proxy integration
    using HttpClient client = new HttpClient(handler);

    // the target URL
    string url = "https://httpbin.org/ip";

    // send an async GET request to the endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // read the response content as a string
    string responseBody = await response.Content.ReadAsStringAsync();

    // print the response to the console
    Console.WriteLine(responseBody);
  }
}

Execute o script:

dotnet run

O resultado deve ser:

{
  "origin": "66.29.154.103"
}

Observe que o atributo origin na resposta do ponto de extremidade /ip exibe o endereço IP do servidor proxy. Isso confirma que seu IP real foi ocultado com êxito por trás do proxy.

Aviso: Os servidores proxy gratuitos geralmente têm vida curta e não são confiáveis. No momento em que você ler este guia, o proxy escolhido não funcionará mais. Para testar o código, substitua proxyUrl por um URL de proxy válido e funcional antes de executar o script.

Casos de uso avançados para integração do proxy HttpClient

Você acabou de aprender os conceitos básicos de integração de proxy com HttpClient em C#, mas há outros cenários mais avançados a serem considerados.

Autenticação de proxy

Os proxies premium são protegidos com autenticação para restringir o acesso a usuários autorizados. Em particular, o URL de um proxy autenticado segue este formato:

<protocol>://<username>:<password>@<host>:<port>

Em que nome de usuário e senha são as credenciais usadas para autenticação.

No HttpClient, a autenticação do proxy é tratada usando a propriedade Credentials do WebProxy. Essa propriedade aceita um objeto NetworkCredential da seguinte forma:

WebProxy proxy = new WebProxy
{
  Address = new Uri(proxyUrl),
  // specify proxy authentication
  Credentials = new NetworkCredential("<username>", "<password>"),
};

Extrair e do URL do proxy autenticado e substitua-os no código acima.

Portanto, o código para integração de proxy autenticado se torna:

using System.Net;

class Program
{
  static async Task Main()
  {
    // initialize a new proxy object
    string proxyUrl = "<protocol>://<host>:<port>";
    WebProxy proxy = new WebProxy
    {
      Address = new Uri(proxyUrl),
      // specify proxy authentication
      Credentials = new NetworkCredential("<username>", "<password>"),
    };

    // define an HTTP client handler with the given proxy
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = proxy,
    };

    // initialize an HttpClient instance with authenticated proxy integration
    using HttpClient client = new HttpClient(handler);

    // the target URL
    string url = "https://httpbin.org/ip";

    // send an async GET request to the endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // read the response content as a string
    string responseBody = await response.Content.ReadAsStringAsync();

    // print the response to the console
    Console.WriteLine(responseBody);
  }
}

Evite problemas com o certificado SSL

Ao configurar um proxy no HttpClient, suas solicitações podem falhar devido ao erro de verificação do certificado SSL abaixo:

Unhandled exception. System.Net.Http.HttpRequestException: The SSL connection could not be established, see inner exception.
 ---> System.Security.Authentication.AuthenticationException: The remote certificate is invalid because of errors in the certificate chain: UntrustedRoot

Isso geralmente acontece quando o proxy usa um certificado SSL autoassinado.

Se você confiar no seu servidor proxy – e somente nesse caso -, poderá desativar a verificação SSL para contornar esse problema usando a abordagem a seguir:

HttpClientHandler handler = new HttpClientHandler();
handler.ClientCertificateOptions = ClientCertificateOption.Manual;
handler.ServerCertificateCustomValidationCallback = (httpRequestMessage, cert, cetChain, policyErrors) =>
{
  return true;
};

using HttpClient client = new HttpClient(handler);

O snippet acima substitui o comportamento padrão de validação de certificado por uma callback personalizada que sempre retorna true.

Observação: a desativação da verificação SSL torna sua conexão vulnerável a ataques MITM (Man-in-the-Middle). Só use essa abordagem se você confiar totalmente no seu proxy e estiver ciente dos riscos de segurança.

Implementar rotação de proxy

Se você usar o mesmo servidor proxy repetidamente, o site de destino poderá eventualmente bloquear seu endereço IP. Para evitar isso, você pode alternar seus servidores proxy para cada solicitação, de modo que suas solicitações usem um servidor proxy diferente a cada vez.

Para implementar a rotação de proxy, siga este procedimento

1. Preencher uma lista com vários URLs de proxy
2. Escolha aleatoriamente um URL de proxy antes de cada solicitação
3. Definir o URL do proxy escolhido no HttpClient

O algoritmo acima se traduz no seguinte trecho:

using System.Net;

class Program
{  
  static async Task Main()
  {
    // get a random proxy URL
    string selectedProxyUrl = GetRandomProxyUrl();

    // configure the random proxy
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = new WebProxy
      {
        Address = new Uri(selectedProxyUrl),
      },
    };

    // perform a GET request through the random proxy
    using HttpClient client = new HttpClient(handler);
    string url = "https://httpbin.org/ip";
    HttpResponseMessage response = await client.GetAsync(url);

    // read the response content as a string and print it
    string responseBody = await response.Content.ReadAsStringAsync();
    Console.WriteLine(responseBody);
  }

  static string GetRandomProxyUrl()
  {
    // the list of proxy URL to rotate from
    List<string> proxyUrls = new List<string>
        {
            "<protocol_1>://<proxy_host_1>:<port_1>",
            // ...
            "<protocol_n>://<proxy_host_n>:<port_n>",
        };

    // return a random proxy URL from the list
    Random random = new Random();
    int index = random.Next(proxyUrls.Count);
    return proxyUrls[index];
  }
}

As principais desvantagens dessa abordagem são:

• Isso envolve código padrão
• Requer acesso a um pool de servidores proxy confiáveis, o que geralmente tem um custo

Felizmente, há uma solução mais eficiente para rotacionar um endereço IP em C#!

A Bright Data fornece proxies rotativos que alternam automaticamente os endereços IP de saída, eliminando a necessidade de rotação manual do proxy. Eles possuem cerca de 100 milhões de IPs, estão disponíveis em 195 países, têm um tempo de atividade de rede excepcional e garantem uma taxa de sucesso de 99,9%.

No próximo capítulo, você aprenderá como começar a usar os proxies rotativos da Bright Data no HttpClient.

Usar um proxy de dados Bright no httpClient

A Bright Data opera um dos maiores servidores proxy do mundo, atendendo a empresas da Fortune 500 e a mais de 20.000 clientes. Essa rede mundial de proxy inclui:

• Proxies de datacenter – Mais de 770.000 IPs de datacenter.
• Proxies residenciais – Mais de 72 milhões de IPs residenciais em mais de 195 países.
• Proxies de ISP – Mais de 700.000 IPs de ISP.
• Proxies móveis – Mais de 7 milhões de IPs móveis.

Siga as etapas abaixo para saber como usar os proxies residenciais da Bright Data com o HttpClient em C#.

Se você já tiver uma conta, faça login na Bright Data. Caso contrário, crie uma conta gratuitamente. Uma vez conectado, você será direcionado ao seu painel de usuário:

Clique no botão “View proxy products” (Exibir produtos proxy) para continuar:

Você será redirecionado para a página “Proxies & Scraping Infrastructure”:

Role a tela para baixo e encontre o cartão “Residential Proxies”. Clique no botão “Get started” (Começar):

Na página de configuração do proxy residencial, siga o assistente para personalizar o serviço de acordo com suas necessidades. Se tiver alguma dúvida, sinta-se à vontade para entrar em contato com o suporte 24 horas por dia, 7 dias por semana:

Vá para a guia “Access parameters” (Parâmetros de acesso) para recuperar o host, a porta, o nome de usuário e a senha do seu proxy:

Observe que o campo “Host” inclui a porta.

Agora que você tem os detalhes necessários, crie o URL do proxy e use-o com o objeto WebProxy em C#:

WebProxy proxy = new WebProxy
{
  Address = new Uri("http://<brightdata_proxy_host>:<brightdata_proxy_port>"),
  Credentials = new NetworkCredential("<brightdata_proxy_username>", "<brightdata_proxy_password>"),
};

Substitua os pelos espaços reservados com as informações de proxy da Bright Data.

Alterne a configuração “Active proxy” (Proxy ativo), siga as instruções restantes e pronto!

Use o seguinte trecho de código C# para integrar o proxy da Bright Data ao HttpClient:

using System.Net;

class Program
{
  static async Task Main()
  {
    // initialize a new proxy object
    WebProxy proxy = new WebProxy
    {
      // TODO: replace the placeholders with your Bright Data's proxy info
      Address = new Uri("http://<brightdata_proxy_host>:<brightdata_proxy_port>"),
      Credentials = new NetworkCredential("<brightdata_proxy_username>", "<brightdata_proxy_password>"),
    };

    // define an HTTP client handler with the given proxy
    HttpClientHandler handler = new HttpClientHandler
    {
      Proxy = proxy,
    };

    // disable SSL verification
    handler.ClientCertificateOptions = ClientCertificateOption.Manual;
    handler.ServerCertificateCustomValidationCallback = (httpRequestMessage, cert, cetChain, policyErrors) =>
    {
      return true;
    };

    // initialize an HttpClient instance with proxy integration
    using HttpClient client = new HttpClient(handler);

    // the target URL
    string url = "https://httpbin.org/ip";

    // send an async GET request to the endpoint
    HttpResponseMessage response = await client.GetAsync(url);

    // read the response content as a string
    string responseBody = await response.Content.ReadAsStringAsync();

    // print the response to the console
    Console.WriteLine(responseBody);
  }
}

Toda vez que executar o script acima, você verá um IP de saída diferente.

A rotação de proxy HttpClient nunca foi tão fácil com os proxies de rotação automática da Bright Data!

Conclusão

Neste tutorial de integração de proxy, você aprendeu por que o uso de proxies é importante e como integrá-los ao HttpClient em C#. Você descobriu como é fácil configurar um proxy no HttpClient, a biblioteca de cliente HTTP padrão do .NET.

Com este guia, você também entendeu por que confiar em serviços de proxy gratuitos é arriscado. Em vez disso, você precisa usar proxies confiáveis de um provedor de proxy respeitável. E quando se trata do melhor provedor de proxy rotativo do mercado, não precisa procurar mais do que a Bright Data.

Crie uma conta e comece a testar nossos proxies gratuitamente hoje mesmo!