API-Ratenbegrenzung über Node+Redi

Ratenbegrenzung schützt und verbessert die Verfügbarkeit von API-basierten Diensten. Wenn Sie mit einer API kommunizieren und den Antwortstatuscode „HTTP 429 Too Many Requests“ erhalten, wurde die Rate begrenzt. Dies bedeutet, dass Sie die Anzahl der zulässigen Anfragen in einem bestimmten Zeitraum überschritten haben. Alles, was Sie tun müssen, ist langsamer zu fahren, einen Moment zu warten und es erneut zu versuchen.

Video-Tutorial-Empfehlung: nodejs-Tutorial

Warum Ratenbegrenzung?

Wenn Sie erwägen, Ihre eigenen API-basierten Dienste einzuschränken, müssen Sie die Kompromisse zwischen Benutzererfahrung, Sicherheit und Leistung abwägen.

Der häufigste Grund für die Kontrolle des Datenflusses besteht darin, API-basierte Dienste verfügbar zu halten. Es gibt aber auch Sicherheitsvorteile, da ein versehentlicher oder absichtlicher Anstieg des eingehenden Datenverkehrs wertvolle Ressourcen beanspruchen und die Verfügbarkeit für andere Benutzer beeinträchtigen kann.

Durch die Kontrolle der Rate eingehender Anfragen können Sie:

• Garantie stellen, dass Dienste und Ressourcen nicht „überflutet“ werden.
• Brute-Force-Angriffe abschwächen
• Distributed-Denial-of-Service-Angriffe (DDOS) verhindern

Wie implementiert man eine Ratenbegrenzung?

Ratenbegrenzung kann auf Client-Ebene, Anwendungsebene, Infrastrukturebene oder irgendwo dazwischen implementiert werden. Es gibt mehrere Möglichkeiten, den eingehenden Datenverkehr zu einem API-Dienst zu steuern:

• Nach Benutzer : Verfolgen Sie die Aufrufe, die ein Benutzer mithilfe eines API-Schlüssels, eines Zugriffstokens oder einer IP-Adresse tätigt.
• Nach geografischer Region : Zum Beispiel niedriger jede Ratenbegrenzung nach geografischer Region während der Spitzenzeiten des Tages
• Nach Server: Wenn Sie über mehrere Server verfügen, die unterschiedliche Aufrufe an Ihre API verarbeiten, können Sie strengere Ratenbeschränkungen für den Zugriff auf teurere Ressourcen implementieren.

Sie können jedes dieser Ratenlimits (oder sogar eine Kombination) verwenden.

Egal, wie Sie es implementieren, das Ziel der Ratenbegrenzung besteht darin, einen Kontrollpunkt einzurichten, der Anfragen zum Zugriff auf Ihre Ressourcen ablehnt oder weiterleitet. Viele Programmiersprachen und Frameworks verfügen über integrierte Funktionen oder Middleware, um dies zu erreichen, sowie über Optionen für verschiedene Algorithmen zur Ratenbegrenzung.

Hier ist eine Möglichkeit, Ihren eigenen Ratenbegrenzer mit Node und Redis zu erstellen:

• Erstellen Sie eine Node-App

• Fügen Sie einen Ratenbegrenzer mit Redis hinzu

• Testen Sie in Postman

in Codebeispiele anzeigen auf GitHub.

Bevor Sie beginnen, stellen Sie sicher, dass Node und Redis auf Ihrem Computer installiert sind.

Schritt 1: Knotenanwendung erstellen

Richten Sie eine neue Knotenanwendung über die Befehlszeile ein. Akzeptieren Sie die Standardoptionen über die CLI-Eingabeaufforderung oder fügen Sie das Flag -yes hinzu. —yes 标志来接受默认选项。

$ npm init --yes

如果在项目设置过程中接受了默认选项，则为入口点创建一个名为 index.js 的文件。

$ touch index.js

安装Express Web框架，然后在 index.js 中初始化服务器。

const express = require('express')
const app = express()
const port = process.env.PORT || 3000

app.get('/', (req, res) => res.send('Hello World!'))
app.listen(port, () => console.log(`Example app listening at http://localhost:${port}`))

从命令行启动服务器。

$ node index.js

回到 index.js 中，创建一个路由，先检查速率限制，如果用户没有超过限制再允许访问资源。

app.post('/', async (req, res) => {
  async function isOverLimit(ip) {
    // to define
  }
  // 检查率限制
  let overLimit = await isOverLimit(req.ip)
  if (overLimit) {
    res.status(429).send('Too many requests - try again later')
    return
  }
  // 允许访问资源
  res.send("Accessed the precious resources!")
})

在下一步中，我们将定义速率限制器函数 isOverLimit。

步骤2：使用Redis添加速率限制器

Redis是一个内存中键值数据库，因此它可以非常快速地检索数据。使用Redis实施速率限制也非常简单。

• 存储一个像用户IP地址一样的key。
• 增加从该IP发出的调用数量
• 在指定时间段后使记录过期

下图所示的限速算法是一个滑动窗口计数器的例子。一个用户如果提交的调用数量适中，或者随着时间的推移将它们分隔开，就永远不会达到速率限制。超过10秒窗口内最大请求的用户必须等待足够的时间来恢复其请求。

从命令行为Node安装一个名为ioredis的Redis客户端。

$ npm install ioredis

在本地启动Redis服务器。

$ redis-server

然后在 index.js

const redis = require('ioredis')
const client = redis.createClient({
  port: process.env.REDIS_PORT || 6379,
  host: process.env.REDIS_HOST || 'localhost',
})
client.on('connect', function () {
  console.log('connected');
});

async function isOverLimit(ip) {
  let res
  try {
    res = await client.incr(ip)
  } catch (err) {
    console.error('isOverLimit: could not increment key')
    throw err
  }
  console.log(`${ip} has value: ${res}`)
  if (res > 10) {
    return true
  }
  client.expire(ip, 10)
}

rrreee

Schritt 2: Hinzufügen eines Ratenbegrenzers mit Redis 🎜🎜Redis ist eine In-Memory-Schlüsselwertdatenbank, sodass Daten sehr schnell abgerufen werden können. Auch die Implementierung einer Ratenbegrenzung mit Redis ist sehr einfach. 🎜🎜🎜Speichert einen Schlüssel wie die IP-Adresse des Benutzers. 🎜🎜Erhöhen Sie die Anzahl der von dieser IP getätigten Anrufe. 🎜🎜Lassen Sie Datensätze nach einem bestimmten Zeitraum ab. 🎜🎜🎜Der im Bild unten gezeigte Ratenbegrenzungsalgorithmus ist ein Beispiel für einen „Schiebefensterzähler“. Ein Benutzer wird niemals das Ratenlimit erreichen, wenn er eine mäßige Anzahl von Anrufen tätigt oder diese über einen längeren Zeitraum verteilt. Benutzer, die die maximale Anforderung innerhalb des 10-Sekunden-Fensters überschreiten, müssen ausreichend Zeit warten, um ihre Anforderungen fortzusetzen. 🎜🎜🎜🎜Installieren Sie über die Befehlszeile einen Redis-Client namens ioredis für Node. 🎜rrreee🎜Starten Sie den Redis-Server lokal. 🎜rrreee🎜Dann fordern und initialisieren Sie den Redis-Client in index.js. 🎜rrreee🎜 Definieren Sie die Funktion isOverLimit, die wir im vorherigen Schritt geschrieben haben. Gemäß diesem Modus von Redis wird ein Zähler entsprechend der IP gespeichert. 🎜rrreee🎜Das ist der Ratenbegrenzer. 🎜

Wenn ein Benutzer die API aufruft, überprüfen wir Redis, um zu sehen, ob der Benutzer das Limit überschritten hat. Wenn dies der Fall ist, gibt die API sofort einen HTTP-Statuscode 429 mit der Meldung Zu viele Anfragen – versuchen Sie es später noch einmal zurück. Wenn sich der Benutzer innerhalb der Grenzen befindet, fahren wir mit dem nächsten Codeblock fort, in dem wir den Zugriff auf eine geschützte Ressource (z. B. eine Datenbank) ermöglichen können. Too many requests — try again later 。如果用户在限制之内，我们将继续执行下一个代码块，在该代码块中，我们可以允许访问受保护的资源（例如数据库）。

在进行速率限制检查期间，我们在Redis中找到用户的记录，并增加其请求计数，如果Redis中没有该用户的记录，那么我们将创建一个新记录。最后，每条记录将在最近一次活动的10秒内过期。

在下一步中，请确保我们的限速器正常运行。

步骤3：在Postman中进行测试

保存更改，然后重新启动服务器。我们将使用Postman将 POST 请求发送到我们的API服务器，该服务器在本地运行，网址为 http:// localhost:3000。

继续快速连续发送请求以达到你的速率限制。

关于限速的最终想法

这是Node和Redis的速率限制器的简单示例，这只是开始。有一堆策略和工具可以用来架构和实现你的速率限制。而且还有其他的增强功能可以通过这个例子来探索，比如：

• 在响应正文或作为 Retry-after
Während der Überprüfung der Ratenbegrenzung finden wir den Datensatz des Benutzers in Redis und erhöhen die Anzahl seiner Anfragen. Wenn für diesen Benutzer kein Datensatz in Redis vorhanden ist, erstellen wir einen neuen Datensatz. Schließlich läuft jeder Datensatz innerhalb von 10 Sekunden nach der letzten Aktivität ab.
• Bitte stellen Sie im nächsten Schritt sicher, dass unser Geschwindigkeitsbegrenzer ordnungsgemäß funktioniert.

• Schritt 3: Test in Postman

Änderungen speichern und den Server neu starten. Wir werden Postman verwenden, um POST-Anfragen an unseren API-Server zu senden, der lokal unter http://localhost:3000 läuft.

Senden Sie weiterhin schnell hintereinander Anfragen, um Ihr Ratenlimit zu erreichen.

Abschließende Gedanken zur Ratenbegrenzung

Dies ist ein einfaches Beispiel für eine Ratenbegrenzung für Node und Redis, und das ist gerechtfertigt der Anfang. Es gibt eine Reihe von Strategien und Tools, mit denen Sie Ihre Tariflimits strukturieren und umsetzen können. Und es gibt weitere Verbesserungen, die mit diesem Beispiel untersucht werden können, wie zum Beispiel:

Das obige ist der detaillierte Inhalt vonAPI-Ratenbegrenzung über Node+Redi. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!