پروکسی برای ربات‌های دیسکورد: چگونه اتوماسیون را بدون مسدود شدن و محدودیت‌های نرخ تنظیم کنیم

مدیریت و نظارت بر سرور (1-3 ربات): پروکسی‌های مسکونی با IP ثابت. یک ربات — یک IP، بدون چرخش. این یک پروفایل پایدار از اتصال ایجاد می‌کند که دیسکورد آن را به عنوان یک کاربر عادی-مدیر درک می‌کند.

ارسال انبوه و دعوتنامه‌ها (10+ ربات): پروکسی‌های مسکونی با چرخش هر 5-10 دقیقه. بار را توزیع کنید: حداکثر 20 اقدام در ساعت از یک IP. از مجموعه‌ای از 50+ آدرس IP برای 10 ربات استفاده کنید.

تحلیل اعضا و سرورها: پروکسی‌های مسکونی با چرخش سریع (هر 1-3 دقیقه) یا پروکسی‌های موبایل. تحلیل یکی از پرخطرترین فعالیت‌ها است، دیسکورد به راحتی الگوهای اسکن را شناسایی می‌کند. از تأخیرهای تصادفی بین درخواست‌ها (30-120 ثانیه) استفاده کنید.

آزمایش و توسعه: پروکسی‌های دیتاسنتر برای اشکال‌زدایی عملکرد کافی هستند. اما قبل از راه‌اندازی در تولید حتماً به پروکسی‌های مسکونی تغییر دهید — رفتار دیسکورد می‌تواند برای انواع مختلف IP به شدت متفاوت باشد.

# مثال در Python (discord.py) با چرخش پروکسی در هنگام محدودیت نرخ

import discord
from discord.ext import commands
import aiohttp
import asyncio
import random

class ProxyRotator:
    def __init__(self, proxy_list):
        self.proxies = proxy_list  # ['http://user:pass@ip:port', ...]
        self.current_index = 0
        self.failed_proxies = set()
    
    def get_next_proxy(self):
        # پروکسی‌های غیرعملکردی را رد می‌کنیم
        available = [p for p in self.proxies if p not in self.failed_proxies]
        if not available:
            self.failed_proxies.clear()  # ریست پس از یک چرخه کامل
            available = self.proxies
        
        proxy = available[self.current_index % len(available)]
        self.current_index += 1
        return proxy
    
    def mark_failed(self, proxy):
        self.failed_proxies.add(proxy)

# راه‌اندازی
proxy_rotator = ProxyRotator([
    'http://user1:pass1@192.168.1.1:8080',
    'http://user2:pass2@192.168.1.2:8080',
    # ... 10-20 پروکسی برای عملکرد پایدار اضافه کنید
])

intents = discord.Intents.default()
bot = commands.Bot(command_prefix='!', intents=intents)

async def send_with_retry(channel, message, max_retries=3):
    """ارسال پیام با پردازش خودکار محدودیت‌های نرخ"""
    for attempt in range(max_retries):
        try:
            # در هر تلاش یک پروکسی جدید دریافت می‌کنیم
            proxy = proxy_rotator.get_next_proxy()
            
            # Discord.py از aiohttp درون استفاده می‌کند، پروکسی را تنظیم می‌کنیم
            connector = aiohttp.TCPConnector()
            async with aiohttp.ClientSession(connector=connector) as session:
                bot.http.connector = connector
                bot.http.proxy = proxy
                
                await channel.send(message)
                return True
                
        except discord.HTTPException as e:
            if e.status == 429:  # محدودیت نرخ
                retry_after = e.retry_after if hasattr(e, 'retry_after') else 5
                print(f"محدودیت نرخ! منتظر {retry_after} ثانیه، تغییر پروکسی...")
                
                # پروکسی را به عنوان موقتا غیرقابل دسترس علامت‌گذاری می‌کنیم
                proxy_rotator.mark_failed(proxy)
                
                # تأخیر تصادفی اضافه کنید
                await asyncio.sleep(retry_after + random.uniform(1, 3))
            else:
                print(f"خطا در ارسال: {e}")
                await asyncio.sleep(2)
    
    return False

@bot.event
async def on_ready():
    print(f'ربات راه‌اندازی شد: {bot.user}')

# مثال استفاده
@bot.command()
async def массовая_рассылка(ctx):
    channels = ctx.guild.text_channels[:5]  # اولین 5 کانال
    
    for channel in channels:
        success = await send_with_retry(channel, "پیام آزمایشی")
        if success:
            print(f"ارسال شده در {channel.name}")
        
        # تأخیر تصادفی بین کانال‌ها
        await asyncio.sleep(random.uniform(3, 7))
    

# Python (discord.py) - پروکسی ثابت
import discord
from discord.ext import commands

PROXY = 'http://username:password@192.168.1.100:8080'

intents = discord.Intents.default()
bot = commands.Bot(command_prefix='!', intents=intents, proxy=PROXY)

# پروکسی برای تمام درخواست‌های این ربات استفاده خواهد شد
bot.run('YOUR_BOT_TOKEN')
    

# JavaScript (discord.js) - چرخش بر اساس زمان
const { Client, GatewayIntentBits } = require('discord.js');
const HttpsProxyAgent = require('https-proxy-agent');

const proxies = [
    'http://user1:pass1@ip1:port',
    'http://user2:pass2@ip2:port',
    'http://user3:pass3@ip3:port',
];

let currentProxyIndex = 0;

function getProxyAgent() {
    const proxy = proxies[currentProxyIndex];
    currentProxyIndex = (currentProxyIndex + 1) % proxies.length;
    return new HttpsProxyAgent(proxy);
}

const client = new Client({
    intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages],
    rest: { agent: getProxyAgent() }
});

// چرخش هر 5 دقیقه
setInterval(() => {
    console.log('تغییر پروکسی...');
    client.rest.setAgent(getProxyAgent());
}, 5 * 60 * 1000);

client.login('YOUR_BOT_TOKEN');
    

# Python - چرخش تطبیقی با لیست سیاه
import time
from collections import defaultdict

class AdaptiveProxyRotator:
    def __init__(self, proxies):
        self.proxies = proxies
        self.current = 0
        self.error_count = defaultdict(int)
        self.blacklist_until = {}  # {proxy: timestamp}
    
    def get_proxy(self):
        now = time.time()
        
        # پروکسی‌ها را در لیست سیاه فیلتر می‌کنیم
        available = [
            p for p in self.proxies 
            if p not in self.blacklist_until or self.blacklist_until[p] < now
        ]
        
        if not available:
            # اگر همه در لیست سیاه هستند، ریست کرده و منتظر می‌مانیم
            print("همه پروکسی‌ها در لیست سیاه هستند، منتظر 60 ثانیه...")
            time.sleep(60)
            self.blacklist_until.clear()
            available = self.proxies
        
        proxy = available[self.current % len(available)]
        self.current += 1
        return proxy
    
    def report_error(self, proxy, error_type):
        self.error_count[proxy] += 1
        
        # مسدودیت موقتی در صورت خطاهای مکرر
        if self.error_count[proxy] >= 3:
            blacklist_duration = 300  # 5 دقیقه
            self.blacklist_until[proxy] = time.time() + blacklist_duration
            print(f"پروکسی {proxy} به مدت {blacklist_duration} ثانیه در لیست سیاه است")
            self.error_count[proxy] = 0  # ریست شمارنده
    
    def report_success(self, proxy):
        # درخواست موفق - ریست شمارنده خطاها
        if proxy in self.error_count:
            self.error_count[proxy] = max(0, self.error_count[proxy] - 1)
    

pip install discord.py aiohttp aiohttp-socks
# aiohttp-socks برای پروکسی SOCKS5 نیاز است، برای HTTP/HTTPS الزامی نیست
    

import discord
from discord.ext import commands

# فرمت پروکسی: protocol://username:password@ip:port
PROXY = 'http://user:pass@192.168.1.100:8080'

intents = discord.Intents.default()
intents.message_content = True  # برای خواندن پیام‌ها

bot = commands.Bot(
    command_prefix='!',
    intents=intents,
    proxy=PROXY  # پروکسی برای تمام درخواست‌های HTTP
)

@bot.event
async def on_ready():
    print(f'ربات {bot.user} از طریق پروکسی متصل شد!')

@bot.command()
async def ping(ctx):
    await ctx.send(f'پونگ! تأخیر: {round(bot.latency * 1000)}ms')

bot.run('YOUR_BOT_TOKEN')
    

import discord
from discord.ext import commands, tasks
import aiohttp
import random

PROXIES = [
    'http://user1:pass1@ip1:port',
    'http://user2:pass2@ip2:port',
    'http://user3:pass3@ip3:port',
]

class ProxyBot(commands.Bot):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.current_proxy = random.choice(PROXIES)
        self.proxy_rotation.start()
    
    @tasks.loop(minutes=5)  # چرخش هر 5 دقیقه
    async def proxy_rotation(self):
        old_proxy = self.current_proxy
        self.current_proxy = random.choice([p for p in PROXIES if p != old_proxy])
        
        # جلسه HTTP را با پروکسی جدید دوباره ایجاد می‌کنیم
        await self.http.close()
        connector = aiohttp.TCPConnector(limit=0)
        self.http.connector = connector
        self.http.__session = aiohttp.ClientSession(connector=connector)
        
        print(f'پروکسی تغییر کرد: {old_proxy} -> {self.current_proxy}')
    
    async def close(self):
        self.proxy_rotation.cancel()
        await super().close()

intents = discord.Intents.default()
bot = ProxyBot(command_prefix='!', intents=intents)

bot.run('YOUR_BOT_TOKEN')
    

npm install discord.js https-proxy-agent
# برای SOCKS5: npm install socks-proxy-agent
    

const { Client, GatewayIntentBits } = require('discord.js');
const { HttpsProxyAgent } = require('https-proxy-agent');

const PROXY = 'http://user:pass@192.168.1.100:8080';
const agent = new HttpsProxyAgent(PROXY);

const client = new Client({
    intents: [
        GatewayIntentBits.Guilds,
        GatewayIntentBits.GuildMessages,
        GatewayIntentBits.MessageContent
    ],
    rest: { agent: agent }  // پروکسی برای درخواست‌های REST API
});

client.on('ready', () => {
    console.log(`ربات ${client.user.tag} از طریق پروکسی متصل شد!`);
});

client.on('messageCreate', async (message) => {
    if (message.content === '!ping') {
        await message.reply(`پونگ! تأخیر WebSocket: ${client.ws.ping}ms`);
    }
});

client.login('YOUR_BOT_TOKEN');
    

const { Client, GatewayIntentBits } = require('discord.js');
const { HttpsProxyAgent } = require('https-proxy-agent');

const PROXIES = [
    'http://user1:pass1@ip1:port',
    'http://user2:pass2@ip2:port',
    'http://user3:pass3@ip3:port',
];

let currentProxyIndex = 0;

function getNextProxy() {
    const proxy = PROXIES[currentProxyIndex];
    currentProxyIndex = (currentProxyIndex + 1) % PROXIES.length;
    return new HttpsProxyAgent(proxy);
}

const client = new Client({
    intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages],
    rest: { agent: getNextProxy() }
});

// چرخش هر 10 دقیقه
setInterval(() => {
    const newAgent = getNextProxy();
    client.rest.setAgent(newAgent);
    console.log('پروکسی تغییر کرد');
}, 10 * 60 * 1000);

client.on('ready', () => {
    console.log(`ربات ${client.user.tag} راه‌اندازی شد`);
});

client.login('YOUR_BOT_TOKEN');
    

# Python - User-Agent سفارشی
import discord

class CustomBot(discord.Client):
    async def request(self, *args, **kwargs):
        # User-Agent را بازنویسی می‌کنیم
        if 'headers' not in kwargs:
            kwargs['headers'] = {}
        kwargs['headers']['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) Discord/1.0.9015'
        return await super().request(*args, **kwargs)
    

# Python - لاگ‌گذاری پیشرفته با معیارها
import logging
import time
from collections import defaultdict
import json

class BotMonitor:
    def __init__(self):
        self.metrics = {
            'requests_total': 0,
            'requests_success': 0,
            'errors_429': 0,
            'errors_403': 0,
            'errors_other': 0,
            'proxy_switches': 0,
            'avg_latency': []
        }
        self.proxy_stats = defaultdict(lambda: {
            'requests': 0,
            'errors': 0,
            'last_error': None
        })
        
        # تنظیم لاگر
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('bot_monitor.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger('BotMonitor')
    
    def log_request(self, proxy, status_code, latency):
        self.metrics['requests_total'] += 1
        self.metrics['avg_latency'].append(latency)
        self.proxy_stats[proxy]['requests'] += 1
        
        if 200 <= status_code < 300:
            self.metrics['requests_success'] += 1
        elif status_code == 429:
            self.metrics['errors_429'] += 1
            self.proxy_stats[proxy]['errors'] += 1
            self.logger.warning(f'محدودیت نرخ در پروکسی {proxy}')
        elif status_code == 403:
            self.metrics['errors_403'] += 1
            self.proxy_stats[proxy]['errors'] += 1
            self.proxy_stats[proxy]['last_error'] = time.time()
            self.logger.error(f'پروکسی {proxy} مسدود شده است (403)')
        else:
            self.metrics['errors_other'] += 1
            self.logger.error(f'خطا {status_code} در پروکسی {proxy}')
    
    def log_proxy_switch(self, old_proxy, new_proxy):
        self.metrics['proxy_switches'] += 1
        self.logger.info(f'تغییر پروکسی: {old_proxy} -> {new_proxy}')
    
    def get_report(self):
        total = self.metrics['requests_total']
        if total == 0:
            return "داده‌ای وجود ندارد"
        
        success_rate = (self.metrics['requests_success'] / total) * 100
        avg_latency = sum(self.metrics['avg_latency']) / len(self.metrics['avg_latency'])
        
        report = f"""
=== گزارش نظارت ربات ===
تعداد کل درخواست‌ها: {total}
موفق: {self.metrics['requests_success']} ({success_rate:.1f}%)
خطاهای 429 (محدودیت نرخ): {self.metrics['errors_429']}
خطاهای 403 (مسدودیت): {self.metrics['errors_403']}
سایر خطاها: {self.metrics['errors_other']}
میانگین تأخیر: {avg_latency:.0f}ms
تغییر پروکسی: {self.metrics['proxy_switches']}

=== آمار پروکسی ===
"""
        for proxy, stats in self.proxy_stats.items():
            error_rate = (stats['errors'] / stats['requests'] * 100) if stats['requests'] > 0 else 0
            report += f"{proxy}: {stats['requests']} درخواست، {stats['errors']} خطا ({error_rate:.1f}%)\n"
        return report