הגדרת הגבלת קצב ועומק עבור GraphQL

GraphQL מעניק ללקוחות גמישות רבה, אך אותה גמישות הופכת את ה-API לפגיע. שאילתה אחת עם 50 רמות קינון ומאות כינויים יכולה לייצר מיליוני אובייקטים, ולהעמיס על המעבד ומסד הנתונים. נתקלנו במקרים שבהם נקודת קצה ללא הגבלות קרסה תחת מספר בקשות בודדות לדקה. לפי התיעוד הרשמי של GraphQL, הגנה מפני היבטים כאלה היא חובה עבור גרסאות production. הגנה מקיפה דורשת הגבלת עומק (הגבלת קינון), מורכבות שאילתה (עלות פעולה), והגבלת קצב (קצב בקשות) – שלושה מנגנונים מרכזיים שאנו מיישמים. הגבלת עומק יעילה פי 3 מהגבלות מבוססות זמן נאיביות. תוך 1-2 ימי עסקים, אנו מגדירים הגבלות אלה עבור ה-API שלך.

אילו בעיות אנו פותרים

ללא הגבלות, GraphQL API חשוף להתקפות DoS. תוקף יכול לשלוח שאילתה אחת עם קינון רקורסיבי (משתמש → חברים → חברים...) שמאלץ את מסד הנתונים לבצע אלפי JOIN. או דרך כינויים, הם מבקשים את אותו שדה 500 פעמים, ובכך מדמים DDoS. וקטור נוסף הוא פעולות יקרות כמו חיפוש או ייצוא שצורכות משאבים רבים. אנו פותרים בעיות אלה באופן מקיף באמצעות הגבלת עומק, מורכבות שאילתה והגבלת קצב. השילוב של שלוש שיטות אלה יעיל פי 10 נגד התקפות DoS מאשר כל שכבה בודדת. העלות של התקפות כאלה יכולה להגיע להפסד הכנסות עקב השבתה – לדוגמה, השבתה של 30 דקות עשויה לעלות $10,000 לאתר מסחר אלקטרוני, כך שההגנה משתלמת במהירות. עבור מערכת בגודל בינוני, הגדרה זו מפחיתה את עלויות האירוח בכ-$5,000 בשנה.

כיצד להגדיר הגבלת עומק?

הגבלת עומק מגבילה את רמת הקינון המקסימלית של עץ ה-AST של השאילתה. אנו קובעים סף של 7 רמות – מספיק עבור סכמות טיפוסיות אך חוסם שאילתות רקורסיביות. עבור רוב הסכמות, סף של 7 הוא אופטימלי: הוא מכסה 99% מהשאילתות הלגיטימיות.

import depthLimit from 'graphql-depth-limit'
import { ApolloServer } from '@apollo/server'

const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [
    depthLimit(7)
  ]
})

התקפה ללא הגבלת עומק נראית כך:

{ user { friends { friends { friends { friends { friends { id name } } } } } } } 

מדוע בדיקת מורכבות שאילתה חשובה?

העומק אינו מתחשב ברוחב השאילתה: שאילתה בעומק 2 אך מבקשת 10,000 רשומות דרך פגינציה היא גם מסוכנת. מורכבות שאילתה מחשבת את העלות הכוללת באמצעות מכפילים עבור ארגומנטים של פגינציה. השווה בין שלוש גישות בטבלה:

מורכבות שאילתה יעילה פי 5 עבור התקפות רוחב מאשר הגבלת עומק בלבד.

import { createComplexityLimitRule } from 'graphql-query-complexity'
import { fieldExtensionsEstimator, simpleEstimator } from 'graphql-query-complexity'

const complexityRule = createComplexityLimitRule(1000, {
  estimators: [
    fieldExtensionsEstimator(),
    ({ type, field, args, childComplexity }) => {
      if (args.limit) return args.limit * childComplexity
      if (args.first) return args.first * childComplexity
      return 1 + childComplexity
    },
    simpleEstimator({ defaultComplexity: 1 })
  ],
  onSuccess: (complexity) => console.log(`Query complexity: ${complexity}`),
  formatErrorMessage: (complexity) => `Query too complex (${complexity}). Max allowed: 1000`
})

השוואה של ספריות הגנה ל-GraphQL:

הגבלת קצב עם Redis

הגבלת קצב ב-GraphQL מתחשבת גם במספר הבקשות וגם במורכבות. אנו משתמשים ב-Redis עבור מונים: הגבלה על פעולות (200 פעולות/דקה) ועל מורכבות כוללת (10,000). עבור פעולות יקרות (SearchUsers, ExportData), אנו קובעים הגבלות נפרדות – עד 5 קריאות לדקה.

class GraphQLRateLimiter {
  constructor(redis) {
    this.r = redis
  }

  async checkRequest(userId, operationName, complexity) {
    const now = Math.floor(Date.now() / 1000)
    const minute = now - (now % 60)
    const opsKey = `gql:ops:${userId}:${minute}`
    const ops = await this.r.incr(opsKey)
    this.r.expire(opsKey, 120)
    if (ops > 200) {
      throw new GraphQLError('Too many requests', {
        extensions: {
          code: 'RATE_LIMITED',
          retryAfter: 60
        }
      })
    }
    const complexityKey = `gql:complexity:${userId}:${minute}`
    const totalComplexity = await this.r.incrby(complexityKey, complexity)
    this.r.expire(complexityKey, 120)
    if (totalComplexity > 10000) {
      throw new GraphQLError('Query complexity budget exceeded', {
        extensions: {
          code: 'COMPLEXITY_LIMITED',
          retryAfter: 60
        }
      })
    }
    const expensiveOps = ['SearchUsers', 'ExportData', 'GenerateReport']
    if (expensiveOps.includes(operationName)) {
      const expKey = `gql:expensive:${userId}:${minute}`
      const expCount = await this.r.incr(expKey)
      this.r.expire(expKey, 120)
      if (expCount > 5) {
        throw new GraphQLError(`Too many ${operationName} calls`, {
          extensions: {
            code: 'RATE_LIMITED'
          }
        })
      }
    }
    return {
      allowed: true,
      remainingOps: 200 - ops
    }
  }
}

import { createArmor } from '@escape.tech/graphql-armor'

const armor = createArmor({
  maxAliases: { n: 15 },
  maxDirectives: { n: 50 },
  maxDepth: { n: 7 },
  maxTokens: { n: 1000 },
  costLimit: {
    maxCost: 5000,
    objectCost: 2,
    scalarCost: 1,
    depthCostFactor: 1.5,
    ignoreIntrospection: true
  }
})

const server = new ApolloServer({
  typeDefs,
  resolvers,
  plugins: [...armor.plugins],
  validationRules: [...armor.validationRules]
})