Начало темыИсходник

Свой прокси-пул на Go: чекер, ротация, HTTP API

leonixxxleonixxxНовичок·10.11.2026· 0 ответов 0 реакций

Прокси-пул у меня живёт отдельным сервисом уже года два. Не из любви к архитектуре — просто каждый чекер и парсер, который я писал, дох от одного и того же: посреди прогона в списке оказываются мёртвые прокси, и половина потоков висит на таймаутах вместо работы.

Первая версия была скриптом на питоне, который просто перемешивал список. Смысла в этом оказалось ноль: перемешивать мёртвое — всё равно что тасовать колоду без тузов. Потом добавил прогрев перед стартом, и вылезло второе, менее очевидное. Проверка живости через 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, пул не узнает, что прокси сдох, и будет выдавать его до бесконечности — это главная ошибка при внедрении.

лучше один раз прогнать, чем сто раз подумать

Комментарии

0
Пока нет комментариев. Войдите, чтобы ответить первым.