İçerik Moderasyonunu Ölçeklendirme

Günde 1.000 mesajda işe yarayan bir moderasyon kurulumu, sayı bir milyona çıktığında aksar: hız limitleri devreye girer, çağrı başına gecikme birikir ve maliyetler şişer. Bu kılavuz, Discuse moderasyonunu yüksek hacimli işlem hatlarına nasıl bağlayacağınızı gösterir — ne zaman engelleyeceğinizi, ne zaman arka planda kontrol edeceğinizi, neleri önbelleğe alacağınızı ve yoğun yük anlarında trafiği nasıl yöneteceğinizi anlatır.

Moderasyon ölçeklendiğinde ne aksar?

Her ölçekleme sorununun belirli bir nedeni ve belirli bir çözümü vardır:

Zorluk	Etki	Çözüm
Hacim artışı	API hız sınırları, artan maliyetler	Eşzamansız işleme, önbellekleme
Gecikme gereksinimleri	Kötü kullanıcı deneyimi	Ön moderasyon, kuyruğa alma
Maliyet yönetimi	Bütçe kısıtları	Akıllı yönlendirme, önbellekleme
Tutarlılık	Dengesiz uygulama	Merkezi yapılandırma
Yoğunluk yönetimi	Hizmet kalitesinde düşüş	Otomatik ölçeklendirme, kuyruklar

Hangi mimari deseni kullanmalıyım?

Desen 1: Senkron ön moderasyon

En uygun olduğu durumlar: Düşük hacimli, yüksek riskli içerikler (ödemeler, hukuki konular)

User Input → API Call → Moderation → Decision → Response
                ↓
           (Blocking call)

// Simple synchronous flow
async function createPost(content) {
  // Check moderation before saving
  const result = await checkModeration(content);

  if (result.has_violations) {
    throw new ModerationError(result.message);
  }

  // Safe to publish
  return await savePost(content);
}

Artıları: Basit, anında geri bildirim sağlar Eksileri: Gecikme ekler, işlem kapasitesini sınırlar

Desen 2: Asenkron sonradan moderasyon

En uygun olduğu durumlar: Yüksek hacimli, daha düşük riskli içerikler (yorumlar, mesajlar)

User Input → Save (Pending) → Publish → Background Check → Action
                                              ↓
                                    ┌────────┴────────┐
                                    ↓                 ↓
                                  Safe            Violation
                                    ↓                 ↓
                                  Keep             Remove

// Async flow with queue
async function createPost(content) {
  // Save immediately with pending status
  const post = await savePost(content, { status: 'pending' });

  // Queue for async moderation
  await moderationQueue.add('check-content', {
    postId: post.id,
    content: content
  });

  return post;
}

// Background worker
moderationQueue.process('check-content', async (job) => {
  const result = await checkModeration(job.data.content);

  if (result.has_violations) {
    await removePost(job.data.postId);
    await notifyUser(job.data.postId, 'content_removed');
  } else {
    await updatePost(job.data.postId, { status: 'approved' });
  }
});

Artıları: Engellemesiz çalışır, yüksek hacmi kaldırır Eksileri: Zararlı içerik kısa süreliğine görünür olabilir

Desen 3: Katmanlı moderasyon

En uygun olduğu durumlar: Maliyet optimizasyonuyla dengeli bir yaklaşım

User Input → Quick Check → High Confidence? ──Yes──► Auto-decision
                              │
                              No
                              ↓
                         Full Analysis ──► Decision

async function tieredModeration(content) {
  // Tier 1: Fast local checks (regex, blocklists)
  const localResult = await quickLocalCheck(content);
  if (localResult.definiteViolation) {
    return { action: 'block', source: 'local' };
  }

  // Tier 2: Cached API results
  const cacheKey = hashContent(content);
  const cached = await cache.get(cacheKey);
  if (cached) {
    return { action: cached.action, source: 'cache' };
  }

  // Tier 3: Full API check
  const apiResult = await checkModeration(content);
  await cache.set(cacheKey, apiResult, TTL);

  return { action: determineAction(apiResult), source: 'api' };
}

Desen 4: Toplama ile fan-out

En uygun olduğu durumlar: Bağımsız ölçeklenen birden fazla kontrol türü

                    ┌──► Text Check ──┐
                    │                  │
User Input ──► Router ──► Image Check ──► Aggregator ──► Decision
                    │                  │
                    └──► Link Check ──┘

async function parallelModeration(content) {
  const checks = [];

  if (content.text) {
    checks.push(checkText(content.text));
  }

  if (content.images?.length) {
    checks.push(checkImages(content.images));
  }

  if (content.links?.length) {
    checks.push(checkLinks(content.links));
  }

  // Run all checks in parallel
  const results = await Promise.all(checks);

  // Aggregate results
  return aggregateResults(results);
}

function aggregateResults(results) {
  // Most severe result wins
  const hasViolation = results.some(r => r.has_violations);
  const maxScore = Math.max(...results.map(r => r.max_score || 0));

  return {
    has_violations: hasViolation,
    max_score: maxScore,
    details: results
  };
}

Önbelleğe alma stratejileri

İçeriğe dayalı önbelleğe alma

Aynı içerikler için sonuçları önbelleğe alın:

const cache = new Redis();

async function checkWithCache(content) {
  const hash = crypto.createHash('sha256')
    .update(content.text || '')
    .update(JSON.stringify(content.images || []))
    .digest('hex');

  // Check cache first
  const cached = await cache.get(`mod:${hash}`);
  if (cached) {
    return { ...JSON.parse(cached), cached: true };
  }

  // API call
  const result = await callModerationAPI(content);

  // Cache for 24 hours
  await cache.setex(`mod:${hash}`, 86400, JSON.stringify(result));

  return { ...result, cached: false };
}

Kullanıcıya dayalı önbelleğe alma

Tekrarlayan ihlal sahipleri için kararları önbelleğe alın:

async function checkUserHistory(userId) {
  const recentViolations = await cache.get(`violations:${userId}`);

  if (recentViolations > 5) {
    // Flag for enhanced scrutiny
    return { enhancedModeration: true };
  }

  return { enhancedModeration: false };
}

async function recordViolation(userId) {
  await cache.incr(`violations:${userId}`);
  await cache.expire(`violations:${userId}`, 86400 * 7); // 7 days
}

Kuyruk yönetimi

Öncelik kuyrukları

Farklı içerik türlerini farklı önceliklerle yönetin:

const queues = {
  critical: new Queue('moderation-critical'),  // Reports, appeals
  high: new Queue('moderation-high'),          // Public posts
  normal: new Queue('moderation-normal'),      // Comments, DMs
  low: new Queue('moderation-low')             // Profile updates
};

async function queueForModeration(content, priority = 'normal') {
  const queue = queues[priority] || queues.normal;

  return queue.add('check', {
    contentId: content.id,
    type: content.type,
    data: content
  }, {
    priority: getPriorityNumber(priority),
    timeout: getTimeout(priority)
  });
}

Hız sınırlarına uyma

Her API anahtarının dakika başına istek sınırı vardır; bu sınırın aşılması, API'nin çağrıyı "rate limit exceeded" hatasıyla reddetmesine neden olur. Bu sınırın altında kalmak ve gereksiz çağrılarla kotanızı tüketmemek için kendi tarafınızda istekleri sınırlayın. Sınırlayıcının dakika başına üst sınırını, anahtarınız için yapılandırılmış RPM değeriyle eşleşecek şekilde ayarlayın:

const Bottleneck = require('bottleneck');

const limiter = new Bottleneck({
  maxConcurrent: 50,                   // Cap parallel requests
  minTime: 20,                         // Min 20ms between requests
  reservoir: YOUR_KEY_RPM,             // Match your API key's per-minute limit
  reservoirRefreshAmount: YOUR_KEY_RPM,
  reservoirRefreshInterval: 60 * 1000  // Refill each minute
});

async function rateLimitedCheck(content) {
  return limiter.schedule(() => checkModeration(content));
}

Kota, hız sınırından ayrıdır: Her çağrı, planınızın aylık API isteği hakkından düşülür ve yanıttaki usage nesnesi api_requests_used, api_requests_limit ve api_requests_remaining değerlerini bildirir; böylece kalan kapasiteyi takip edebilirsiniz.

Ölü mektup kuyrukları

Başarısız moderasyon denemelerini yönetin:

moderationQueue.process('check-content', async (job) => {
  try {
    const result = await checkModeration(job.data.content);
    await applyDecision(job.data.contentId, result);
  } catch (error) {
    if (job.attemptsMade < 3) {
      throw error; // Retry
    }

    // Move to dead letter queue after 3 attempts
    await deadLetterQueue.add('failed-moderation', {
      ...job.data,
      error: error.message,
      attempts: job.attemptsMade
    });

    // Apply safe default (hold for review)
    await holdForManualReview(job.data.contentId);
  }
});

Maliyet optimizasyonu

Akıllı yönlendirme

Ücretli API'leri yalnızca gerekli olduğunda çağırın:

async function smartModeration(content) {
  // Step 1: Free local checks
  const localResult = runLocalFilters(content);
  if (localResult.isDefinitelySpam) {
    return { action: 'block', cost: 0 };
  }

  // Step 2: Check cache (free)
  const cached = await getCachedResult(content);
  if (cached) {
    return { action: cached.action, cost: 0 };
  }

  // Step 3: Risk-based API call
  const riskScore = calculateRiskScore(content, localResult);

  if (riskScore < 0.2) {
    // Low risk: approve without API call
    return { action: 'approve', cost: 0 };
  }

  // Step 4: API call for uncertain content
  const apiResult = await checkModeration(content);
  return {
    action: determineAction(apiResult),
    cost: calculateApiCost(content)
  };
}

Eşzamanlılık kontrolü

/api/v2/check uç noktası, her çağrıda tek bir gönderiyi puanlar. İşi "toplu" hale getirmek için tek bir çok öğeli istek beklemek yerine, öğeleri worker'ınızda gruplayın ve sınırlı bir havuz içinde eşzamanlı olarak dağıtın. Birden fazla medya URL'si içeren bir kontrol de bunların tamamını kapsayan tek bir çağrıdır — tek bir görsel ağırlıklı çağrı, çok sayıda tek görselli çağrıdan daha ucuzdur.

// Bounded concurrency: many items, capped parallel calls.
async function processBatch(items, concurrency = 10) {
  const results = [];
  for (let i = 0; i < items.length; i += concurrency) {
    const slice = items.slice(i, i + concurrency);
    const settled = await Promise.allSettled(
      slice.map(item => checkModeration(item.content))
    );
    results.push(...settled);
  }
  return results;
}

Tek bir istek en fazla 10 görsel URL'si, 5 GIF URL'si, 3 video URL'si, 5 belge URL'si ve 20 bağlantı taşıyabilir; ayrıca 10.000 karaktere kadar metin içerebilir — bu nedenle bir gönderinin medyasını bölmek yerine tek bir çağrıda birleştirin.

İzleme ve uyarılar

Temel metrikler panosu

const metrics = {
  // Volume metrics
  total_requests: new Counter('moderation_requests_total'),
  requests_per_second: new Gauge('moderation_rps'),

  // Latency metrics
  latency_p50: new Histogram('moderation_latency_p50'),
  latency_p99: new Histogram('moderation_latency_p99'),

  // Queue metrics
  queue_depth: new Gauge('moderation_queue_depth'),
  processing_time: new Histogram('moderation_processing_time'),

  // Cost metrics
  api_calls: new Counter('moderation_api_calls'),
  estimated_cost: new Counter('moderation_estimated_cost'),

  // Accuracy metrics
  violations_detected: new Counter('moderation_violations'),
  false_positives: new Counter('moderation_false_positives')
};

Uyarı kuralları

# Alert on queue backup
- alert: ModerationQueueBackup
  expr: moderation_queue_depth > 10000
  for: 5m
  labels:
    severity: warning
  annotations:
    summary: Moderation queue backing up

# Alert on high latency
- alert: ModerationLatencyHigh
  expr: moderation_latency_p99 > 5000
  for: 2m
  labels:
    severity: critical
  annotations:
    summary: Moderation latency exceeding 5 seconds

# Alert on high error rate
- alert: ModerationErrorRate
  expr: rate(moderation_errors_total[5m]) / rate(moderation_requests_total[5m]) > 0.01
  for: 5m
  labels:
    severity: critical
  annotations:
    summary: Moderation error rate above 1%

Altyapı ölçeklendirme

Yatay ölçeklendirme

# Kubernetes HPA for moderation workers
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: moderation-worker
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: moderation-worker
  minReplicas: 3
  maxReplicas: 50
  metrics:
  - type: External
    external:
      metric:
        name: queue_depth
      target:
        type: AverageValue
        averageValue: 100

Küresel kullanıcılar için gecikmeyi azaltma

Discuse API tek bir temel URL üzerinden erişilir: https://api.discuse.com. Küresel trafikte gecikmeyi düşük tutmak için kendi moderasyon worker’larınızı kullanıcılarınıza yakın konumlarda çalıştırın ve API çağrılarını onların yapmasını sağlayın; uzak bir bölgedeki kullanıcıya dönük istek yolundan senkron olarak çağırmayın. Bunu yukarıdaki asenkron sonradan moderasyon ve önbellekleme kalıplarıyla birleştirin; böylece yavaş bir gidiş-dönüş hiçbir zaman kullanıcıyı engellemez.

En iyi uygulamalar özeti

1. Agresif önbellekleme yapın: aynı içerik önbelleğe alınmış bir sonuç döndürür. API ayrıca kısa bir zaman aralığında proje başına aynı içeriği tekilleştirir ve cached: true döndürür.
2. Kuyruklar kullanın: yüksek hacim için asenkron işleme.
3. Katmanlar uygulayın: yerel → önbellek → API.
4. Her şeyi izleyin: kuyruk derinliği, gecikme süresi ve kotanıza göre kullanım.
5. Hatalara hazırlıklı olun: dead-letter kuyrukları ve güvenli yedek mekanizmalar.
6. Yatay ölçeklendirin: daha büyük makineler değil, daha fazla worker.
7. Maliyeti optimize edin: akıllı yönlendirme, daha az gereksiz çağrı ve istek başına birleştirilmiş medya.

Sonraki adımlar

• AI İçerik Moderasyonu Kılavuzu - AI moderasyonunu anlama
• Eşik Değerlerini Yapılandırma - Tespiti hassas biçimde ayarlama
• Hızlı Başlangıç Kılavuzu - Temel uygulama