Proxys in Ruby: Net::HTTP, Faraday, Rails und Skripte

Wenn Sie einen Parser schreiben, eine externe API integrieren oder die Datensammlung in Ruby automatisieren – werden Sie früher oder später mit IP-Sperren konfrontiert. Wildberries, Ozon, Instagram und Dutzende anderer Dienste blockieren Anfragen von einer Adresse bereits nach mehreren Hundert Zugriffsversuchen. Die Lösung ist einfach – Proxy. In diesem Artikel werden wir besprechen, wie man Proxys in ein Ruby-Projekt über die Standardbibliothek Net::HTTP und den beliebten HTTP-Client Faraday einbindet, IP-Rotation einrichtet und Fehler korrekt behandelt – sowohl in einer Rails-Anwendung als auch in einfachen Skripten.

Warum Ruby-Entwickler Proxys benötigen: Hauptszenarien

Ruby wird aktiv für Aufgaben eingesetzt, bei denen man ohne Proxys einfach nicht auskommt. Bevor wir zum Code übergehen, ist es wichtig zu verstehen, in welchen Situationen sie benötigt werden – das hilft, den richtigen Typ und die Architektur der Lösung auszuwählen.

Parsing und Datensammlung. Dies ist das häufigste Szenario. Sie schreiben ein Skript in Ruby, das die Seiten von Wildberries, Ozon oder Avito durchläuft und Preise und Eigenschaften von Produkten sammelt. Ohne Proxy wird ein solches Skript bereits nach wenigen Minuten aufgrund von IP-Sperren blockiert. Die Websites erkennen Hunderte von Anfragen von einer Adresse und aktivieren automatisch den Schutz – CAPTCHA, temporäre Sperren oder vollständige Dienstverweigerung.

Integration mit geoabhängigen APIs. Einige externe Dienste liefern unterschiedliche Inhalte, je nach dem Land der Anfrage. Wenn Ihre Rails-Anwendung auf eine solche API zugreift, ermöglicht ein Proxy, Anfragen aus der gewünschten Region zu simulieren. Beispielsweise um die Suchergebnisse für verschiedene Länder zu überprüfen oder Preise zu erhalten, die für einen bestimmten Markt aktuell sind.

Testing und QA. Entwickler verwenden Proxys, um das Verhalten der Anwendung bei Anfragen aus verschiedenen IP-Adressen und Ländern zu testen. Dies ist besonders relevant für Dienste mit Geo-Blockierungen oder Rate-Limiting nach IP.

Marketingautomatisierung. Ruby-Skripte werden häufig zur Überwachung von Werbekampagnen, zur Überprüfung von Positionen in den Suchergebnissen oder zur Verfolgung der Aktivitäten von Wettbewerbern eingesetzt. Hier sind Proxys erforderlich, um die Last zu verteilen und Einschränkungen zu umgehen.

Arbeiten mit mehreren Konten. Wenn Ihr Skript mehrere Konten auf einer Plattform verwaltet, muss jedes Konto über eine separate IP-Adresse arbeiten – andernfalls erkennt die Plattform leicht die Verbindung und sperrt alles auf einmal.

Welchen Proxy-Typ für Ruby-Aufgaben wählen

Nicht alle Proxys sind gleichermaßen gut für verschiedene Aufgaben geeignet. Die Wahl des Typs hat direkten Einfluss auf den Erfolg Ihres Skripts. Lassen Sie uns die Hauptoptionen im Hinblick auf die Ruby-Entwicklung durchgehen.

Proxy-Typ	Beste Aufgaben in Ruby	Geschwindigkeit	Umgehung von Schutzmaßnahmen
Rechenzentrums-Proxys	Parsing ohne strengen Schutz, API-Anfragen, Tests	Hoch	Mittel
Residential Proxys	Parsing von geschützten Websites, Arbeiten mit sozialen Netzwerken, Marktplätzen	Mittel	Hoch
Mobile Proxys	Facebook, Instagram, TikTok API, Arbeiten mit Konten	Mittel	Maximal

Rechenzentrums-Proxys sind die schnellste und günstigste Option. Sie eignen sich für das Parsing von Websites ohne aggressive Schutzmaßnahmen, massenhafte API-Anfragen und Lasttests. Allerdings erkennen große Plattformen (Facebook, Google, Cloudflare) sie leicht anhand der ASN des Rechenzentrums.

Residential Proxys verwenden IPs von echten Haushaltsnutzern. Für Ruby-Skripte, die Wildberries, Ozon oder geschützte Websites parsen – ist dies die optimale Wahl. Die Websites sehen einen normalen Benutzer und keinen Server.

Mobile Proxys arbeiten über IPs von Mobilfunkanbietern (4G/5G). Dies sind die vertrauenswürdigsten Adressen aus Sicht der Plattformen – eine mobile IP kann von Hunderten von echten Nutzern gleichzeitig verwendet werden, daher sind Sperren aufgrund dieser IP äußerst selten. Wenn Ihr Ruby-Skript mit sozialen Netzwerken oder Werbeplattformen arbeitet – reduzieren mobile Proxys das Risiko von Sperren auf ein Minimum.

Proxys in Net::HTTP: Grundkonfiguration

Net::HTTP ist die Standardbibliothek von Ruby für HTTP-Anfragen, die im Standardlieferumfang der Sprache enthalten ist. Sie unterstützt Proxys „out of the box“ über die spezielle Methode Net::HTTP::Proxy.

Der einfachste Weg ist, eine Proxy-Klasse zu erstellen und diese anstelle des normalen Net::HTTP zu verwenden:

require 'net/http'
require 'uri'

# Proxy-Daten
proxy_host = 'proxy.example.com'
proxy_port = 8080

# Erstellen einer Proxy-Klasse
proxy_class = Net::HTTP::Proxy(proxy_host, proxy_port)

# Anfrage über den Proxy ausführen
uri = URI('https://httpbin.org/ip')

proxy_class.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
  request = Net::HTTP::Get.new(uri)
  response = http.request(request)
  puts response.body
end

Die Methode Net::HTTP::Proxy akzeptiert vier Parameter: Proxy-Host, Port, Benutzername und Passwort. Die ersten beiden sind erforderlich, die letzten beiden optional für Proxys ohne Authentifizierung.

Eine alternative Methode besteht darin, die Proxy-Parameter direkt an die Methode Net::HTTP.new zu übergeben:

require 'net/http'

uri = URI('https://httpbin.org/ip')

http = Net::HTTP.new(
  uri.host,
  uri.port,
  'proxy.example.com',  # proxy_addr
  8080,                  # proxy_port
  nil,                   # proxy_user (nil, wenn keine Authentifizierung erforderlich)
  nil                    # proxy_pass
)

http.use_ssl = true

response = http.get(uri.path)
puts response.body

Dieser Ansatz ist praktisch, wenn Sie dasselbe HTTP-Objekt für mehrere Anfragen an denselben Host wiederverwenden müssen. Beachten Sie: Die Proxy-Parameter werden als dritter und vierter Argument übergeben, nicht über eine separate Methode.

Authentifizierung und HTTPS über Net::HTTP

Die meisten kommerziellen Proxys erfordern eine Authentifizierung – Benutzername und Passwort. Darüber hinaus ist bei der Arbeit mit HTTPS-Websites eine zusätzliche SSL-Konfiguration erforderlich. Lassen Sie uns beide Fälle durchgehen.

Proxys mit Benutzername und Passwort:

require 'net/http'
require 'uri'

proxy_host = 'proxy.example.com'
proxy_port = 8080
proxy_user = 'your_username'
proxy_pass = 'your_password'

# Erstellen einer Proxy-Klasse mit Authentifizierung
proxy_class = Net::HTTP::Proxy(proxy_host, proxy_port, proxy_user, proxy_pass)

uri = URI('https://httpbin.org/ip')

proxy_class.start(uri.host, uri.port, use_ssl: true) do |http|
  # SSL-Verifizierung deaktivieren (nur für Tests!)
  # http.verify_mode = OpenSSL::SSL::VERIFY_NONE
  
  request = Net::HTTP::Get.new(uri)
  request['User-Agent'] = 'Mozilla/5.0 (compatible; MyBot/1.0)'
  
  response = http.request(request)
  puts "IP: #{response.body}"
  puts "Status: #{response.code}"
end

Wichtiger Punkt: Bei der Verwendung von HTTPS-Proxys (Tunneling über CONNECT) stellt Net::HTTP automatisch eine SSL-Verbindung zum Zielserver über den Proxy-Tunnel her. Dies funktioniert korrekt für die meisten Proxy-Server.

Konfiguration über Umgebungsvariablen. Eine gute Praxis ist es, die Proxy-Daten nicht im Code hart zu kodieren, sondern sie aus Umgebungsvariablen zu lesen:

require 'net/http'
require 'uri'

# Proxy-Einstellungen aus ENV lesen
proxy_uri = URI(ENV.fetch('HTTP_PROXY', 'http://proxy.example.com:8080'))

proxy_class = Net::HTTP::Proxy(
  proxy_uri.host,
  proxy_uri.port,
  proxy_uri.user,
  proxy_uri.password
)

target_uri = URI('https://httpbin.org/ip')

proxy_class.start(target_uri.host, target_uri.port, use_ssl: true) do |http|
  response = http.get(target_uri.path)
  puts response.body
end

Die Umgebungsvariable kann im Format HTTP_PROXY=http://user:[email protected]:8080 festgelegt werden. Dieser Ansatz ermöglicht es, den Proxy zu ändern, ohne den Code zu ändern – es reicht aus, die Variable in der .env-Datei oder in den Servereinstellungen zu aktualisieren.

Proxy über Faraday einbinden

Faraday ist einer der beliebtesten HTTP-Clients im Ruby-Ökosystem. Er wird in vielen Rails-Anwendungen aufgrund seines bequemen Middleware-Ansatzes und der Unterstützung verschiedener Adapter (Net::HTTP, HTTParty, Typhoeus und andere) verwendet. Die Konfiguration von Proxys in Faraday unterscheidet sich je nach verwendetem Adapter.

Grundkonfiguration von Proxys in Faraday:

require 'faraday'

# Erstellen einer Faraday-Verbindung mit Proxy
conn = Faraday.new(url: 'https://httpbin.org') do |faraday|
  faraday.proxy = {
    uri: 'http://proxy.example.com:8080',
    user: 'your_username',
    password: 'your_password'
  }
  
  faraday.headers['User-Agent'] = 'Mozilla/5.0 (compatible; MyBot/1.0)'
  faraday.adapter Faraday.default_adapter
end

response = conn.get('/ip')
puts response.body
puts "Status: #{response.status}"

Der Parameter faraday.proxy akzeptiert einen Hash mit den Schlüsseln uri, user und password. Es ist auch möglich, eine URI-Zeichenfolge direkt zu übergeben, wenn der Proxy keine Authentifizierung erfordert.

Faraday mit dem Net::HTTP-Adapter und erweiterten Einstellungen:

require 'faraday'

conn = Faraday.new(url: 'https://httpbin.org') do |faraday|
  faraday.proxy = 'http://user:[email protected]:8080'
  
  # Timeout-Einstellungen
  faraday.options.timeout = 30
  faraday.options.open_timeout = 10
  
  # Middleware für Logging (praktisch beim Debuggen)
  faraday.response :logger
  
  # Retry bei Verbindungsfehlern
  faraday.request :retry, max: 3, interval: 1
  
  # Adapter
  faraday.adapter :net_http
end

begin
  response = conn.get('/ip')
  puts response.body
rescue Faraday::ConnectionFailed => e
  puts "Verbindungsfehler: #{e.message}"
rescue Faraday::TimeoutError => e
  puts "Timeout: #{e.message}"
end

Die Middleware :retry ist besonders nützlich bei der Arbeit mit Proxys – wenn eine Adresse vorübergehend nicht verfügbar ist, wiederholt Faraday automatisch die Anfrage. Dies ist entscheidend für die zuverlässige Ausführung des Skripts in der Produktion.

Faraday mit dem Typhoeus-Adapter (für parallele Anfragen):

# Gemfile: gem 'typhoeus'
require 'faraday'
require 'typhoeus/adapters/faraday'

conn = Faraday.new(url: 'https://httpbin.org') do |faraday|
  faraday.proxy = 'http://user:[email protected]:8080'
  faraday.adapter :typhoeus
end

# Parallele Anfragen über den Proxy
responses = []
conn.in_parallel do
  responses << conn.get('/ip')
  responses << conn.get('/headers')
  responses << conn.get('/user-agent')
end

responses.each { |r| puts r.body }

Proxy-Rotation: Automatischer IP-Wechsel

Eine Proxy-Adresse, selbst eine Residential, wird früher oder später bei intensivem Parsing unter Einschränkungen leiden. Die Lösung ist die Rotation: automatischer IP-Wechsel nach jeder Anfrage oder in bestimmten Intervallen. Lassen Sie uns einen einfachen Rotator für Ruby-Skripte implementieren.

Ein einfacher Rotator basierend auf einem Array von Proxys:

require 'net/http'
require 'uri'

class ProxyRotator
  def initialize(proxies)
    @proxies = proxies
    @index = 0
    @mutex = Mutex.new
  end

  def next_proxy
    @mutex.synchronize do
      proxy = @proxies[@index % @proxies.length]
      @index += 1
      proxy
    end
  end

  def random_proxy
    @proxies.sample
  end
end

# Liste der Proxys im Format [host, port, user, pass]
proxies = [
  ['proxy1.example.com', 8080, 'user1', 'pass1'],
  ['proxy2.example.com', 8080, 'user2', 'pass2'],
  ['proxy3.example.com', 8080, 'user3', 'pass3'],
]

rotator = ProxyRotator.new(proxies)

# Liste von URLs über verschiedene Proxys parsen
urls = [
  'https://httpbin.org/ip',
  'https://httpbin.org/headers',
  'https://httpbin.org/user-agent'
]

urls.each do |url|
  proxy = rotator.next_proxy
  proxy_class = Net::HTTP::Proxy(proxy[0], proxy[1], proxy[2], proxy[3])
  
  uri = URI(url)
  
  begin
    proxy_class.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
      http.read_timeout = 15
      response = http.get(uri.path)
      puts "#{url} -> Status: #{response.code}, Proxy: #{proxy[0]}"
    end
  rescue => e
    puts "Fehler mit Proxy #{proxy[0]}: #{e.message}"
    # Automatisch zum nächsten Proxy wechseln
  end
  
  sleep(rand(0.5..2.0)) # Zufällige Verzögerung zwischen Anfragen
end

Eine zufällige Verzögerung zwischen Anfragen (sleep(rand(0.5..2.0))) ist ein wichtiger Aspekt. Das Muster von Anfragen mit festen Intervallen wird leicht von Anti-Bot-Systemen erkannt. Zufällige Verzögerungen imitieren das Verhalten eines echten Benutzers.

Rotation über Faraday mit Middleware:

require 'faraday'

class ProxyMiddleware < Faraday::Middleware
  PROXIES = [
    'http://user1:[email protected]:8080',
    'http://user2:[email protected]:8080',
    'http://user3:[email protected]:8080',
  ].freeze

  def call(env)
    # Wählen Sie einen zufälligen Proxy für jede Anfrage
    proxy_uri = URI(PROXIES.sample)
    
    env[:request][:proxy] = {
      uri: proxy_uri,
      user: proxy_uri.user,
      password: proxy_uri.password
    }
    
    @app.call(env)
  end
end

# Middleware registrieren
Faraday::Middleware.register_middleware proxy_rotator: ProxyMiddleware

conn = Faraday.new(url: 'https://httpbin.org') do |faraday|
  faraday.use :proxy_rotator
  faraday.adapter :net_http
end

5.times do
  response = conn.get('/ip')
  puts response.body
end

Integration von Proxys in eine Rails-Anwendung

In einer Rails-Anwendung werden Proxys häufig für externe HTTP-Anfragen benötigt: Integration mit APIs, Hintergrundaufgaben für Parsing oder Webhooks. Lassen Sie uns einige praktische Muster betrachten.

Muster 1: Service-Objekt mit Faraday. Erstellen Sie eine grundlegende Service-Klasse, die alle externen HTTP-Anfragen über Proxys durchführt:

# app/services/http_client.rb
class HttpClient
  def self.connection(base_url)
    Faraday.new(url: base_url) do |faraday|
      # Proxys aus den Rails-Umgebungsvariablen
      if Rails.env.production? && ENV['PROXY_URL'].present?
        faraday.proxy = ENV['PROXY_URL']
      end
      
      faraday.headers['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
      faraday.options.timeout = 30
      faraday.options.open_timeout = 10
      
      faraday.request :retry, max: 3, interval: 2,
                      exceptions: [Faraday::ConnectionFailed, Faraday::TimeoutError]
      
      faraday.response :raise_error
      faraday.adapter :net_http
    end
  end
end

# Verwendung im Controller oder Service:
# client = HttpClient.connection('https://api.example.com')
# response = client.get('/products', { category: 'electronics' })

Muster 2: Konfiguration über Rails-Credentials. Verwenden Sie verschlüsselte Rails-Credentials zur Speicherung der Proxy-Daten:

# config/credentials.yml.enc (bearbeitet über rails credentials:edit)
# proxy:
#   host: proxy.example.com
#   port: 8080
#   username: your_user
#   password: your_pass

# app/services/proxy_service.rb
class ProxyService
  def self.faraday_proxy_config
    creds = Rails.application.credentials.proxy
    return nil unless creds
    
    {
      uri: "http://#{creds[:host]}:#{creds[:port]}",
      user: creds[:username],
      password: creds[:password]
    }
  end
  
  def self.net_http_proxy
    creds = Rails.application.credentials.proxy
    return Net::HTTP::Proxy(nil, nil) unless creds
    
    Net::HTTP::Proxy(
      creds[:host],
      creds[:port],
      creds[:username],
      creds[:password]
    )
  end
end

Muster 3: Hintergrundaufgaben mit Sidekiq. Wenn Parsing oder API-Anfragen in Hintergrundarbeitern ausgeführt werden, bleibt die Proxy-Konfiguration die gleiche, aber es ist wichtig, die Konkurrenz zu berücksichtigen:

# app/workers/price_parser_worker.rb
class PriceParserWorker
  include Sidekiq::Worker
  
  sidekiq_options retry: 3, queue: :parsers
  
  def perform(product_url)
    # Erstellen einer neuen Verbindung für jeden Worker
    proxy = ProxyService.net_http_proxy
    uri = URI(product_url)
    
    proxy.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
      http.read_timeout = 20
      
      request = Net::HTTP::Get.new(uri)
      request['User-Agent'] = random_user_agent
      
      response = http.request(request)
      
      if response.code == '200'
        parse_and_save(response.body, product_url)
      else
        Rails.logger.warn "Unerwarteter Status #{response.code} für #{product_url}"
      end
    end
  rescue Net::OpenTimeout, Net::ReadTimeout => e
    Rails.logger.error "Timeout für #{product_url}: #{e.message}"
    raise # Sidekiq wird die Aufgabe wiederholen
  end
  
  private
  
  def random_user_agent
    agents = [
      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
      'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36'
    ]
    agents.sample
  end
  
  def parse_and_save(html, url)
    # Parsing-Logik...
  end
end

Fehlerbehandlung und Timeouts

Die Arbeit über Proxys fügt eine zusätzliche Schicht hinzu, die spezifische Fehler erzeugen kann. Eine ordnungsgemäße Ausnahmebehandlung ist der Unterschied zwischen einem Skript, das nach 5 Minuten abstürzt, und einem Skript, das stundenlang ohne Eingreifen funktioniert.

Haupttypen von Fehlern bei der Arbeit mit Proxys in Ruby:

Ausnahme	Ursache	Was tun
`Net::OpenTimeout`	Proxy antwortet nicht	Proxy wechseln, erneut versuchen
`Net::ReadTimeout`	Proxy ist langsam oder die Website antwortet nicht	Timeout erhöhen oder Proxy wechseln
`Errno::ECONNREFUSED`	Proxy-Server hat die Verbindung abgelehnt	Proxy-Daten überprüfen
`OpenSSL::SSL::SSLError`	Problem mit SSL über Proxy	SSL-Einstellungen überprüfen
HTTP 407	Ungültiger Benutzername/Passwort für den Proxy	Credentials überprüfen
HTTP 403/429	IP von der Website blockiert	Proxy wechseln, Pause einlegen

Umfassende Fehlerbehandlung mit automatischem Proxy-Wechsel:

require 'net/http'
require 'uri'

class RobustHttpClient
  MAX_RETRIES = 3
  RETRIABLE_ERRORS = [
    Net::OpenTimeout,
    Net::ReadTimeout,
    Errno::ECONNREFUSED,
    Errno::ECONNRESET,
    OpenSSL::SSL::SSLError
  ].freeze

  def initialize(proxies)
    @proxies = proxies.dup
    @failed_proxies = []
  end

  def get(url, retries: MAX_RETRIES)
    uri = URI(url)
    attempt = 0

    begin
      attempt += 1
      proxy = current_proxy
      proxy_class = Net::HTTP::Proxy(*proxy)

      proxy_class.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
        http.open_timeout = 10
        http.read_timeout = 20

        request = Net::HTTP::Get.new(uri)
        request['User-Agent'] = 'Mozilla/5.0 (compatible; RubyBot/1.0)'

        response = http.request(request)

        case response.code.to_i
        when 200..299
          response
        when 407
          raise "Proxy-Authentifizierung fehlgeschlagen für #{proxy[0]}"
        when 403, 429
          rotate_proxy!
          raise "IP blockiert (#{response.code}), Proxy wechseln"
        else
          raise "Unerwarteter HTTP-Status: #{response.code}"
        end
      end

    rescue *RETRIABLE_ERRORS => e
      Rails.logger.warn "Verbindungsfehler (Versuch #{attempt}/#{retries}): #{e.message}"
      rotate_proxy!
      retry if attempt < retries
      raise "Nach #{retries} Versuchen fehlgeschlagen: #{e.message}"

    rescue RuntimeError => e
      Rails.logger.warn "HTTP-Fehler (Versuch #{attempt}/#{retries}): #{e.message}"
      retry if attempt < retries
      raise
    end
  end

  private

  def current_proxy
    @proxies.first || raise("Keine verfügbaren Proxys!")
  end

  def rotate_proxy!
    failed = @proxies.shift
    @failed_proxies << failed
    Rails.logger.info "Proxy gewechselt. Verbleibend: #{@proxies.length}"
  end
end

SOCKS5-Proxys in Ruby: Einrichtung über socksify

Die Standardbibliothek Net::HTTP unterstützt SOCKS5 nicht nativ – nur HTTP/HTTPS-Proxys. Für die Arbeit mit SOCKS5 ist eine zusätzliche Bibliothek erforderlich. Die beliebteste Option ist die Gem socksify.

Warum könnte SOCKS5 gegenüber HTTP-Proxys bevorzugt werden? Das SOCKS5-Protokoll arbeitet auf einer niedrigeren Ebene – es proxyiert jeden TCP-Verkehr, nicht nur HTTP. Darüber hinaus unterstützt SOCKS5 die Authentifizierung und überträgt weniger Metadaten über die Anfrage, was es weniger auffällig für Bot-Erkennungssysteme macht.

# Gemfile
# gem 'socksify'

require 'socksify'
require 'socksify/http'
require 'net/http'
require 'uri'

# Globale SOCKS5-Proxy-Konfiguration
TCPSocket::socks_server = 'proxy.example.com'
TCPSocket::socks_port = 1080

# Optional: Authentifizierung (SOCKS5 Benutzername/Passwort)
# TCPSocket::socks_username = 'your_user'
# TCPSocket::socks_password = 'your_pass'

# Jetzt gehen alle Net::HTTP-Anfragen über SOCKS5
uri = URI('https://httpbin.org/ip')
response = Net::HTTP.get_response(uri)
puts response.body

Beachten Sie: Bei der Verwendung von socksify wird die Konfiguration global für alle TCP-Verbindungen im Prozess angewendet. Wenn Sie eine flexiblere Konfiguration benötigen – verwenden Sie Net::HTTP.SOCKSProxy aus demselben Gem:

require 'socksify/http'

# Erstellen einer SOCKS5-Proxy-Klasse (analog zu Net::HTTP::Proxy für HTTP)
socks_proxy = Net::HTTP.SOCKSProxy('proxy.example.com', 1080)

uri = URI('https://httpbin.org/ip')

socks_proxy.start(uri.host, uri.port, use_ssl: true) do |http|
  response = http.get(uri.path)
  puts response.body
end

Für Faraday mit SOCKS5 ist ein Adapter erforderlich, der dieses Protokoll unterstützt. Eine gute Option ist faraday-net_http in Kombination mit socksify, oder die Verwendung des curl-basierten Adapters faraday-typhoeus, der SOCKS5 nativ über libcurl unterstützt.

💡 Tipp zur Auswahl des Protokolls

Für die meisten Parsing- und API-Arbeiten sind HTTP/HTTPS-Proxys ausreichend – sie sind einfacher einzurichten und werden nativ unterstützt. SOCKS5 sollte verwendet werden, wenn Sie nicht nur HTTP-Verkehr proxyieren müssen oder wenn HTTP-Proxys leicht von dem Zielservice erkannt werden. Mobile und Residential Proxys sind in beiden Protokollen verfügbar.

Fazit und Empfehlungen

Die Konfiguration von Proxys in Ruby erfordert keine komplexen Bibliotheken – die Standardbibliothek Net::HTTP unterstützt HTTP-Proxys „out of the box“, und Faraday macht die Integration dank der Middleware-Architektur noch bequemer. Die wichtigsten Erkenntnisse aus diesem Leitfaden:

Für Net::HTTP verwenden Sie Net::HTTP::Proxy – dies ist eine eingebaute und zuverlässige Methode.
Für Faraday akzeptiert der Parameter faraday.proxy eine URI-Zeichenfolge oder einen Hash mit Anmeldeinformationen.
Speichern Sie die Proxy-Daten in Umgebungsvariablen oder Rails-Credentials – hartkodieren Sie sie nicht im Code.
Implementieren Sie Proxy-Rotation und Fehlerbehandlung für eine zuverlässige Ausführung in der Produktion.
Fügen Sie Zufallsverzögerungen und Rotation des User-Agents hinzu, um menschliches Verhalten zu imitieren.
Für SOCKS5 verwenden Sie die Gem socksify.

Die Wahl des Proxy-Typs hängt von der Aufgabe ab. Wenn Sie einen Parser für Wildberries oder Ozon schreiben – Residential Proxys bieten das beste Gleichgewicht zwischen Geschwindigkeit und Umgehung von Schutzmaßnahmen: echte IPs von Haushaltsnutzern landen äußerst selten auf Blocklisten. Für hochbelastete Aufgaben mit einer großen Anzahl von Anfragen an weniger geschützte Quellen eignen sich Rechenzentrums-Proxys – sie sind schneller und günstiger pro Anfrage. Wenn Ihr Ruby-Skript jedoch mit sozialen Netzwerken oder Werbe-APIs arbeitet – achten Sie auf mobile Proxys: Ihre IP-Adressen haben das höchste Vertrauensniveau auf den meisten Plattformen.