Ruby'de Proxy: Net::HTTP, Faraday, Rails ve Scriptler

```html

Eğer bir parser yazıyorsanız, harici bir API entegre ediyorsanız veya Ruby ile veri toplama işlemini otomatikleştiriyorsanız - er ya da geç IP engelleri ile karşılaşacaksınız. Wildberries, Ozon, Instagram ve diğer birçok servis, birkaç yüz istektan sonra tek bir adresten gelen istekleri kesiyor. Tek çözüm - proxy. Bu makalede, Ruby projesine standart Net::HTTP ve popüler HTTP istemcisi Faraday üzerinden proxy nasıl bağlanır, IP döngüsü nasıl ayarlanır ve hatalar nasıl doğru bir şekilde işlenir - hem Rails uygulamasında hem de basit scriptlerde inceleyeceğiz.

Ruby geliştiricisi için proxy: temel senaryolar

Ruby, proxy olmadan yapamayacağınız görevler için aktif olarak kullanılmaktadır. Koda geçmeden önce, proxy'lerin hangi durumlarda gerekli olduğunu anlamak önemlidir - bu, doğru türü ve çözüm mimarisini seçmenize yardımcı olacaktır.

Veri toplama ve parsing. Bu en yaygın senaryodur. Ruby'de bir script yazıyorsunuz, Wildberries, Ozon veya Avito sayfalarını geziyor, fiyatları ve ürün özelliklerini topluyorsunuz. Proxy olmadan böyle bir script birkaç dakika içinde IP engeli ile karşılaşır. Siteler, tek bir adresten gelen yüzlerce isteği görür ve otomatik olarak koruma devreye alır - captcha, geçici yasak veya tamamen hizmet vermeme.

Coğrafi bağımlı API'lerle entegrasyon. Bazı harici servisler, isteğin yapıldığı ülkeye bağlı olarak farklı içerikler döndürmektedir. Eğer Rails uygulamanız böyle bir API'ye erişiyorsa, proxy, gerekli bölgeden gelen istekleri taklit etmenizi sağlar. Örneğin, farklı ülkeler için arama motoru sonuçlarını kontrol etmek veya belirli bir pazar için geçerli fiyatları almak.

Test etme ve QA. Geliştiriciler, uygulamanın farklı IP adreslerinden ve ülkelerden gelen isteklere karşı davranışını test etmek için proxy kullanır. Bu, coğrafi engelleme veya IP bazlı rate-limiting olan servisler için özellikle önemlidir.

Pazarlama otomasyonu. Ruby scriptleri, reklam kampanyalarını izlemek, sıralamaları kontrol etmek veya rakiplerin aktivitelerini takip etmek için sıkça kullanılır. Burada proxy, yük dağılımı ve kısıtlamaların aşılması için gereklidir.

Birden fazla hesapla çalışma. Eğer scriptiniz aynı platformda birden fazla hesabı yönetiyorsa, her hesap ayrı bir IP üzerinden çalışmalıdır - aksi takdirde platform bağlantıyı kolayca tespit eder ve hepsini birden yasaklar.

Ruby görevleri için hangi proxy türünü seçmelisiniz

Tüm proxy'ler farklı görevler için aynı derecede uygun değildir. Tür seçimi, scriptinizin başarısını doğrudan etkiler. Ruby geliştirme bağlamında ana seçenekleri inceleyelim.

Proxy Türü	Ruby'de En İyi Görevler	Hız	Koruma Aşma
Veri Merkezi Proxy'leri	Sıkı koruma olmadan parsing, API istekleri, test etme	Yüksek	Orta
Konut Proxy'leri	Korunan siteleri parsing, sosyal medya ile çalışma, pazar yerleri	Orta	Yüksek
Mobil Proxy'ler	Facebook, Instagram, TikTok API, hesaplarla çalışma	Orta	Maksimum

Veri Merkezi Proxy'leri - en hızlı ve en ucuz seçenektir. Sıkı koruma olmayan siteleri parsing, toplu API istekleri ve yük testi için uygundur. Ancak büyük platformlar (Facebook, Google, Cloudflare) bunları veri merkezi ASN üzerinden kolayca tanır.

Konut Proxy'leri, gerçek ev kullanıcılarının IP'lerini kullanır. Wildberries, Ozon gibi siteleri parsing yapan Ruby scriptleri için en iyi seçimdir. Siteler, bir sunucu değil, normal bir kullanıcıyı görür.

Mobil Proxy'ler, mobil operatörlerin IP'leri (4G/5G) üzerinden çalışır. Bu, platformlar açısından en güvenilir adreslerdir - bir mobil IP, yüzlerce gerçek kullanıcı tarafından aynı anda kullanılabilir, bu nedenle bu IP'ler üzerinden yasaklanma olasılığı son derece düşüktür. Eğer Ruby scriptiniz sosyal medya veya reklam platformları ile çalışıyorsa - mobil proxy'ler, yasaklanma riskini en aza indirecektir.

Net::HTTP'de proxy: temel ayar

Net::HTTP - HTTP istekleri için Ruby'nin standart kütüphanesidir ve dilin standart dağıtımına dahildir. Proxy'yi "kutudan çıkar çıkmaz" destekler ve özel bir yöntem olan Net::HTTP::Proxy aracılığıyla kullanılır.

En basit yol, bir proxy sınıfı oluşturmak ve bunu normal Net::HTTP yerine kullanmaktır:

require 'net/http'
require 'uri'

# Proxy verileri
proxy_host = 'proxy.example.com'
proxy_port = 8080

# Proxy sınıfını oluştur
proxy_class = Net::HTTP::Proxy(proxy_host, proxy_port)

# Proxy üzerinden istek yap
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

Net::HTTP::Proxy yöntemi dört parametre alır: proxy'nin host'u, port'u, kullanıcı adı ve şifre. İlk ikisi zorunludur, son ikisi ise kimlik doğrulaması gerekmeyen proxy'ler için isteğe bağlıdır.

Alternatif bir yol, proxy parametrelerini doğrudan Net::HTTP.new yöntemine iletmektir:

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 (kimlik doğrulaması yoksa nil)
  nil                    # proxy_pass
)

http.use_ssl = true

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

Bu yaklaşım, aynı HTTP nesnesini birden fazla istekte yeniden kullanmanız gerektiğinde kullanışlıdır. Dikkat edin: proxy parametreleri üçüncü ve dördüncü argüman olarak iletilir, ayrı bir yöntem aracılığıyla değil.

Kimlik doğrulama ve HTTPS üzerinden Net::HTTP

Çoğu ticari proxy, kimlik doğrulaması gerektirir - kullanıcı adı ve şifre. Ayrıca, HTTPS siteleri ile çalışırken ek SSL ayarları gereklidir. Her iki durumu inceleyelim.

Kullanıcı adı ve şifre ile proxy:

require 'net/http'
require 'uri'

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

# Kimlik doğrulaması ile proxy sınıfı oluştur
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 doğrulamasını devre dışı bırak (sadece test için!)
  # 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 "Durum: #{response.code}"
end

Önemli bir nokta: HTTPS proxy kullanırken (CONNECT üzerinden tünelleme) Net::HTTP, hedef sunucu ile proxy tüneli üzerinden otomatik olarak bir SSL bağlantısı kurar. Bu, çoğu proxy sunucusu için doğru çalışır.

Ortam değişkenleri aracılığıyla ayarlama. Proxy verilerini kodda hardcode etmek yerine ortam değişkenlerinden okumak iyi bir uygulamadır:

require 'net/http'
require 'uri'

# Proxy ayarlarını ENV'den okuma
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

Ortam değişkenini HTTP_PROXY=http://user:[email protected]:8080 formatında ayarlayabilirsiniz. Bu yaklaşım, kodu değiştirmeden proxy'yi değiştirmeyi sağlar - yeter ki .env dosyasında veya sunucu ayarlarında değişiklik yapın.

Faraday üzerinden proxy bağlantısı

Faraday, Ruby ekosisteminde en popüler HTTP istemcilerinden biridir. Birçok Rails uygulamasında, kullanışlı middleware yaklaşımı ve farklı adaptörlerin (Net::HTTP, HTTParty, Typhoeus ve diğerleri) desteği sayesinde kullanılmaktadır. Faraday'de proxy ayarlamak, kullanılan adaptöre bağlı olarak biraz farklılık gösterir.

Faraday'de proxy'nin temel ayarı:

require 'faraday'

# Proxy ile Faraday bağlantısı oluştur
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 "Durum: #{response.status}"

faraday.proxy parametresi, uri, user ve password anahtarları ile bir hash alır. Ayrıca, kimlik doğrulaması gerekmeyen proxy'ler için URI dizesini doğrudan iletebilirsiniz.

Net::HTTP adaptörü ile Faraday ve gelişmiş ayarlar:

require 'faraday'

conn = Faraday.new(url: 'https://httpbin.org') do |faraday|
  faraday.proxy = 'http://user:[email protected]:8080'
  
  # Zaman aşımı ayarları
  faraday.options.timeout = 30
  faraday.options.open_timeout = 10
  
  # Hata ayıklama için loglama middleware'i
  faraday.response :logger
  
  # Bağlantı hatalarında yeniden deneme
  faraday.request :retry, max: 3, interval: 1
  
  # Adaptör
  faraday.adapter :net_http
end

begin
  response = conn.get('/ip')
  puts response.body
rescue Faraday::ConnectionFailed => e
  puts "Bağlantı hatası: #{e.message}"
rescue Faraday::TimeoutError => e
  puts "Zaman aşımı: #{e.message}"
end

:retry middleware'i, proxy ile çalışırken özellikle faydalıdır - eğer bir adres geçici olarak erişilemezse, Faraday otomatik olarak isteği tekrar eder. Bu, üretimde scriptin güvenilir çalışması için kritik öneme sahiptir.

Typhoeus adaptörü ile Faraday (eşzamanlı istekler için):

# 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

# Proxy üzerinden eşzamanlı istekler
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 döngüsü: otomatik IP değişimi

Tek bir proxy adresi, hatta konut proxy'si, yoğun parsing sırasında er ya da geç kısıtlamalara maruz kalacaktır. Çözüm - döngü: her istektan sonra veya belirli aralıklarla otomatik IP değişimi. Ruby scriptleri için basit bir döngü oluşturacağız.

Proxy dizisi tabanlı basit bir döngü:

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

# [host, port, user, pass] formatında proxy listesi
proxies = [
  ['proxy1.example.com', 8080, 'user1', 'pass1'],
  ['proxy2.example.com', 8080, 'user2', 'pass2'],
  ['proxy3.example.com', 8080, 'user3', 'pass3'],
]

rotator = ProxyRotator.new(proxies)

# Farklı proxy'ler üzerinden URL listesini parsing
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} -> Durum: #{response.code}, Proxy: #{proxy[0]}"
    end
  rescue => e
    puts "Proxy ile ilgili hata #{proxy[0]}: #{e.message}"
    # Otomatik olarak bir sonraki proxy'ye geç
  end
  
  sleep(rand(0.5..2.0)) # İstekler arasında rastgele gecikme
end

İstekler arasındaki rastgele gecikme (sleep(rand(0.5..2.0))) önemli bir unsurdur. Sabit aralıklarla yapılan istekler, anti-bot sistemleri tarafından kolayca tespit edilir. Rastgele gecikmeler, gerçek bir kullanıcının davranışını taklit eder.

Faraday üzerinden middleware ile döngü:

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)
    # Her istek için rastgele bir proxy seç
    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'i kaydet
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

Rails uygulamasında proxy entegrasyonu

Rails uygulamasında proxy genellikle harici HTTP istekleri için gereklidir: API entegrasyonu, arka plan parsing görevleri veya webhook'lar. Bazı pratik desenleri inceleyelim.

Desen 1: Faraday ile servis nesnesi. Tüm harici HTTP isteklerini proxy üzerinden yapan temel bir servis sınıfı oluşturun:

# app/services/http_client.rb
class HttpClient
  def self.connection(base_url)
    Faraday.new(url: base_url) do |faraday|
      # Rails ortam değişkenlerinden proxy
      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

# Kontrolcüde veya serviste kullanım:
# client = HttpClient.connection('https://api.example.com')
# response = client.get('/products', { category: 'electronics' })

Desen 2: Rails kimlik bilgileri aracılığıyla ayarlama. Proxy verilerini saklamak için şifrelenmiş Rails kimlik bilgilerini kullanın:

# config/credentials.yml.enc (rails credentials:edit ile düzenlenir)
# 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

Desen 3: Sidekiq ile arka plan görevleri. Eğer parsing veya API istekleri arka plan işçileri tarafından gerçekleştiriliyorsa, proxy ayarı aynı kalır ancak rekabeti dikkate almak önemlidir:

# app/workers/price_parser_worker.rb
class PriceParserWorker
  include Sidekiq::Worker
  
  sidekiq_options retry: 3, queue: :parsers
  
  def perform(product_url)
    # Her işçi için yeni bir bağlantı oluştur
    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 "Beklenmedik durum #{response.code} için #{product_url}"
      end
    end
  rescue Net::OpenTimeout, Net::ReadTimeout => e
    Rails.logger.error "Zaman aşımı #{product_url} için: #{e.message}"
    raise # Sidekiq görevi tekrar edecektir
  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 mantığı...
  end
end

Hata yönetimi ve zaman aşımı

Proxy üzerinden çalışma, belirli hatalar üretebilecek ek bir katman ekler. İstisna yönetimi, scriptin 5 dakika içinde çökmesi ile saatlerce müdahale gerektirmeyen bir script arasında fark yaratır.

Ruby'de proxy ile çalışırken karşılaşılabilecek ana hata türleri:

İstisna	Sebep	Ne yapmalı
`Net::OpenTimeout`	Proxy yanıt vermiyor	Proxy'yi değiştir, tekrar dene
`Net::ReadTimeout`	Proxy yavaş veya site yanıt vermiyor	Zaman aşımını artır veya proxy'yi değiştir
`Errno::ECONNREFUSED`	Proxy sunucusu bağlantıyı reddetti	Proxy verilerini kontrol et
`OpenSSL::SSL::SSLError`	Proxy üzerinden SSL ile ilgili sorun	SSL ayarlarını kontrol et
HTTP 407	Proxy için yanlış kullanıcı adı/şifre	Kimlik bilgilerini kontrol et
HTTP 403/429	IP, site tarafından engellendi	Proxy'yi değiştir, ara ver

Otomatik proxy değişimi ile kapsamlı hata yönetimi:

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 kimlik doğrulaması başarısız oldu #{proxy[0]}"
        when 403, 429
          rotate_proxy!
          raise "IP engellendi (#{response.code}), proxy değiştiriliyor"
        else
          raise "Beklenmedik HTTP durumu: #{response.code}"
        end
      end

    rescue *RETRIABLE_ERRORS => e
      Rails.logger.warn "Bağlantı hatası (deneme #{attempt}/#{retries}): #{e.message}"
      rotate_proxy!
      retry if attempt < retries
      raise "Başarısız oldu #{retries} denemeden sonra: #{e.message}"

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

  private

  def current_proxy
    @proxies.first || raise("Kullanılabilir proxy yok!")
  end

  def rotate_proxy!
    failed = @proxies.shift
    @failed_proxies << failed
    Rails.logger.info "Proxy değiştirildi. Kalan: #{@proxies.length}"
  end
end

Ruby'de SOCKS5 proxy: socksify üzerinden ayarlama

Standart Net::HTTP, SOCKS5'i yerel olarak desteklemez - sadece HTTP/HTTPS proxy'leri. SOCKS5 ile çalışmak için ek bir kütüphane gereklidir. En popüler seçenek, socksify gemidir.

Neden SOCKS5, HTTP proxy'lerden daha tercih edilebilir? SOCKS5 protokolü daha düşük bir seviyede çalışır - her türlü TCP trafiğini proxy'ler, sadece HTTP değil. Ayrıca, SOCKS5 kimlik doğrulamasını destekler ve istekle ilgili daha az meta veri iletir, bu da onu bot tespit sistemleri için daha az görünür hale getirir.

# Gemfile
# gem 'socksify'

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

# Global SOCKS5 proxy ayarı
TCPSocket::socks_server = 'proxy.example.com'
TCPSocket::socks_port = 1080

# İsteğe bağlı: kimlik doğrulama (SOCKS5 kullanıcı adı/şifre)
# TCPSocket::socks_username = 'your_user'
# TCPSocket::socks_password = 'your_pass'

# Artık tüm Net::HTTP istekleri SOCKS5 üzerinden gidiyor
uri = URI('https://httpbin.org/ip')
response = Net::HTTP.get_response(uri)
puts response.body

Dikkat edin: socksify kullanırken ayar, süreçteki tüm TCP bağlantılarına global olarak uygulanır. Daha esnek bir ayar gerekiyorsa, aynı gemden Net::HTTP.SOCKSProxy kullanın:

require 'socksify/http'

# SOCKS5 proxy sınıfı oluştur (HTTP için Net::HTTP::Proxy gibi)
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

SOCKS5 ile Faraday kullanmak için, bu protokolü destekleyen bir adaptör gereklidir. İyi bir seçenek, faraday-net_http ile socksify kombinasyonu veya SOCKS5'i libcurl üzerinden yerel olarak destekleyen curl tabanlı adaptör faraday-typhoeus kullanmaktır.

💡 Protokol seçimi için ipucu

Çoğu parsing ve API ile çalışma görevleri için HTTP/HTTPS proxy yeterlidir - ayarları daha basittir ve yerel olarak desteklenir. SOCKS5, yalnızca HTTP trafiğini proxy'lemek istediğinizde veya HTTP proxy'lerin hedef servis tarafından kolayca tespit edildiği durumlarda kullanılmalıdır. Mobil ve konut proxy'ler her iki protokolde de mevcuttur.

Sonuç ve öneriler

Ruby'de proxy ayarlamak karmaşık kütüphaneler gerektirmez - standart Net::HTTP, HTTP proxy'leri "kutudan çıkar çıkmaz" destekler ve Faraday, middleware mimarisi sayesinde entegrasyonu daha da kolaylaştırır. Bu kılavuzdan çıkarılacak ana noktalar:

Net::HTTP için Net::HTTP::Proxy kullanın - bu yerleşik ve güvenilir bir yöntemdir.
Faraday için faraday.proxy parametresi, URI dizesi veya kimlik bilgileri ile bir hash alır.
Proxy verilerini ortam değişkenlerinde veya Rails kimlik bilgilerinde saklayın - kodda hardcode etmeyin.
Güvenilir çalışma için proxy döngüsü ve hata yönetimi uygulayın.
Rastgele gecikmeler ekleyin ve User-Agent döngüsü uygulayarak insan davranışını taklit edin.
SOCKS5 için socksify gemini kullanın.

Proxy türü seçimi, göreve bağlıdır. Eğer Wildberries veya Ozon için bir parser yazıyorsanız - konut proxy'leri, hız ve koruma aşma arasında en iyi dengeyi sağlar: gerçek ev kullanıcılarının IP'leri nadiren engel listelerine düşer. Yüksek hacimli, daha az korumalı kaynaklara yönelik yoğun görevler için veri merkezi proxy'leri uygundur - bunlar daha hızlı ve isteğe göre daha ucuzdur. Eğer Ruby scriptiniz sosyal medya veya reklam API'leri ile çalışıyorsa - mobil proxy'lere dikkat edin: bu IP adresleri, çoğu platformda en yüksek güven düzeyine sahiptir.