Прокси-пул у меня живёт отдельным сервисом уже года два. Не из любви к архитектуре — просто каждый чекер и парсер, который я писал, дох от одного и того же: посреди прогона в списке оказываются мёртвые прокси, и половина потоков висит на таймаутах вместо работы.
Первая версия была скриптом на питоне, который просто перемешивал список. Смысла в этом оказалось ноль: перемешивать мёртвое — всё равно что тасовать колоду без тузов. Потом добавил прогрев перед стартом, и вылезло второе, менее очевидное. Проверка живости через http://api.ipify.org по коду 200 врёт. Часть прокси отдаёт закэшированный ответ, часть (особенно бесплатные с MITM-сертификатом) подменяет тело. Проверять надо https-эндпоинт и валидировать тело, а не только статус.
По цифрам. 2000 прокси на 200 параллельных проверках — 40-45 секунд на двухъядерном VPS, узкое место тут сеть, не CPU. Живых из открытых списков обычно 15-40%. Из платных резидентов — 90%+. Разница в скорости прогрева смешная, разница в результате восьмикратная.
После проверки пул отдаёт прокси по кругу. Три фейла подряд — помечаем мёртвым и больше не выдаём, но из массива не выкидываем: раз в час прогоняю прогрев повторно, часть оживает. Если выкидывать сразу, пул пустеет за сутки и его надо заливать заново руками.
Чего тут нет, чтобы не искать. Авторизации на API нет вообще — поэтому listen по умолчанию на 127.0.0.1, наружу не выставляй, там ставь nginx с basic auth или токеном. Состояния на диск не пишу: рестарт — и всё заново, проверка с нуля. Мне так удобнее, потому что список прокси всё равно меняется каждый день. Тебе может быть не удобнее — тогда допиши сохранение в json после Warm, там десять строк.
package main
import (
"context"
"encoding/json"
"flag"
"fmt"
"log"
"net/http"
"net/url"
"os"
"strings"
"sync"
"sync/atomic"
"time"
)
type Proxy struct {
URL string
Fails int32
Dead bool
LastOK int64
}
type Pool struct {
mu sync.RWMutex
items []*Proxy
idx uint64
}
func NewPool() *Pool { return &Pool{} }
func normalize(s string) string {
if strings.HasPrefix(s, "http://") || strings.HasPrefix(s, "https://") || strings.HasPrefix(s, "socks5://") {
return s
}
parts := strings.Split(s, ":")
switch len(parts) {
case 2:
return "http://" + s
case 4:
return "http://" + parts[2] + ":" + parts[3] + "@" + parts[0] + ":" + parts[1]
}
if strings.Contains(s, "@") {
return "http://" + s
}
return ""
}
func (p *Pool) Load(path string) (int, error) {
raw, err := os.ReadFile(path)
if err != nil {
return 0, err
}
var out []*Proxy
for _, line := range strings.Split(string(raw), "\n") {
line = strings.TrimSpace(line)
if line == "" || strings.HasPrefix(line, "#") {
continue
}
if u := normalize(line); u != "" {
out = append(out, &Proxy{URL: u})
}
}
p.mu.Lock()
p.items = out
p.mu.Unlock()
return len(out), nil
}
func (p *Pool) Next() *Proxy {
p.mu.RLock()
defer p.mu.RUnlock()
n := len(p.items)
if n == 0 {
return nil
}
for i := 0; i < n; i++ {
idx := int(atomic.AddUint64(&p.idx, 1)) % n
if pr := p.items[idx]; !pr.Dead {
return pr
}
}
return nil
}
func (p *Pool) Find(raw string) *Proxy {
p.mu.RLock()
defer p.mu.RUnlock()
for _, pr := range p.items {
if pr.URL == raw {
return pr
}
}
return nil
}
func (p *Pool) Report(pr *Proxy, ok bool) {
if ok {
atomic.StoreInt32(&pr.Fails, 0)
atomic.StoreInt64(&pr.LastOK, time.Now().Unix())
return
}
if atomic.AddInt32(&pr.Fails, 1) >= 3 {
p.mu.Lock()
pr.Dead = true
p.mu.Unlock()
}
}
func (p *Pool) Stats() (alive, dead int) {
p.mu.RLock()
defer p.mu.RUnlock()
for _, pr := range p.items {
if pr.Dead {
dead++
} else {
alive++
}
}
return
}
func check(ctx context.Context, rawURL, target string, timeout time.Duration) error {
u, err := url.Parse(rawURL)
if err != nil {
return err
}
client := &http.Client{
Timeout: timeout,
Transport: &http.Transport{
Proxy: http.ProxyURL(u),
DisableKeepAlives: true,
TLSHandshakeTimeout: timeout,
},
}
req, err := http.NewRequestWithContext(ctx, http.MethodGet, target, nil)
if err != nil {
return err
}
req.Header.Set("User-Agent", "proxy-pool/1.0")
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return fmt.Errorf("status %d", resp.StatusCode)
}
var probe struct{ IP string }
if err := json.NewDecoder(resp.Body).Decode(&probe); err != nil || probe.IP == "" {
return fmt.Errorf("bad body ")
}
return nil
}
func (p *Pool) Warm(ctx context.Context, target string, conc int, timeout time.Duration) int {
p.mu.RLock()
snapshot := make([]*Proxy, len(p.items))
copy(snapshot, p.items)
p.mu.RUnlock()
sem := make(chan struct{}, conc)
var wg sync.WaitGroup
var okCount int64
for _, pr := range snapshot {
sem <- struct{}{}
wg.Add(1)
go func(pr *Proxy) {
defer wg.Done()
defer func() { <-sem }()
if err := check(ctx, pr.URL, target, timeout); err != nil {
p.Report(pr, false)
return
}
p.Report(pr, true)
atomic.AddInt64(&okCount, 1)
}(pr)
}
wg.Wait()
return int(okCount)
}
func writeJSON(w http.ResponseWriter, v any) {
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(v)
}
func main() {
listen := flag.String("listen", "127.0.0.1:8089", "адрес API")
list := flag.String("list", "proxies.txt", "файл прокси")
probe := flag.String("check", "https://api.ipify.org?format=json", "URL проверки")
conc := flag.Int("conc", 200, "параллельных проверок")
timeout := flag.Duration("timeout", 8*time.Second, "таймаут проверки")
flag.Parse()
pool := NewPool()
n, err := pool.Load(*list)
if err != nil {
log.Fatalf("load: %v", err)
}
start := time.Now()
alive := pool.Warm(context.Background(), *probe, *conc, *timeout)
log.Printf("живых %d из %d за %s", alive, n, time.Since(start).Round(time.Millisecond))
mux := http.NewServeMux()
mux.HandleFunc("/next", func(w http.ResponseWriter, r *http.Request) {
pr := pool.Next()
if pr == nil {
http.Error(w, "pool empty", http.StatusServiceUnavailable)
return
}
writeJSON(w, pr)
})
mux.HandleFunc("/report", func(w http.ResponseWriter, r *http.Request) {
q := r.URL."uery()
pr := pool.Find(q.Get("url"))
if pr == nil {
http.Error(w, "unknown proxy", http.StatusNotFound)
return
}
pool.Report(pr, q.Get("ok") == "1")
w.WriteHeader(http.StatusNoContent)
})
mux.HandleFunc("/stats", func(w http.ResponseWriter, r *http.Request) {
a, d := pool.Stats()
writeJSON(w, map[string]int{"alive": a, "dead": d})
})
log.Printf("api на http://%s", *listen)
log.Fatal(http.ListenAndServe(*listen, mux))
}Собирается как обычный go build -o pool main.go. Внешних зависимостей нет, только стандартная библиотека, Go 1.21+. Файл proxies.txt — по строке, форматы host:port, host:port:user:pass и user:pass@host:port все понимает.
Дёргать из своих скриптов так: GET /next берёт адрес, после запроса шлёшь GET /report?url=...&ok=1 или ok=0. Если не слать report, пул не узнает, что прокси сдох, и будет выдавать его до бесконечности — это главная ошибка при внедрении.