Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 8: Rate Limiting und Schutz

Ziel: Anfragen pro Minute begrenzen, je Client-IP und je Consumer, große Anfragen abweisen, die Admin API auf die eigene Maschine beschränken und Bots aussperren. · Dauer: ca. 60 min · Voraussetzung: Tag 7

Briefing

  • rate-limiting zählt Anfragen pro Zeitfenster und antwortet ab dem Limit mit 429.
  • limit_by legt fest, wen Kong zählt: ip, consumer, credential, header.
  • policy legt fest, wo gezählt wird: local im Speicher eines Knotens, cluster in Postgres, redis in Redis.
  • request-size-limiting, ip-restriction und bot-detection weisen Anfragen ab, bevor sie das Backend kosten.
  • Ab heute: Datei ändern, dann ksync (decK sync, dann 10 Sekunden warten).
 Anfrage ─► key-auth/jwt ─► request-size-limiting (951) ─► acl (950)
         ─► rate-limiting (910) ─► Backend         429 / 413 / 403 vorher

Drill 1: Ein Limit fürs Lesen

source ~/kong-lab/setup/env.sh
mkdir -p ~/kong-lab/tag08 && cd ~/kong-lab/tag08
cp ~/kong-lab/code/tag08/*.yaml .
grep -A6 'name: rate-limiting' limit-lesen.yaml
deck file add-plugins -s ~/kong-lab/kong/kong.yaml limit-lesen.yaml \
  -o ~/kong-lab/kong/kong.yaml
ksync | tail -3
for i in $(seq 1 7); do
  curl -s -o /dev/null -w '%{http_code} ' $PROXY/api/v1/notes
done
echo

Erwartet:

      - name: rate-limiting
        config:
          minute: 5
          policy: local
          limit_by: ip
  Created: 1
  Updated: 0
  Deleted: 0
200 200 200 200 200 429 429

decK darf in dieselbe Datei schreiben, die es liest. ksync spielt sie ein und wartet, bis die Worker sie haben. Die Warnung zu Passwörtern (Tag 5) gibt decK bei jedem Aufruf aus; ab hier lässt das Buch sie weg. Die sechste Anfrage in dieser Minute bekommt 429.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Was der Client erfährt

curl -si $PROXY/api/v1/notes | grep -i -E '^(HTTP|ratelimit|x-ratelimit|retry-after)'
curl -s $PROXY/api/v1/notes

Erwartet (gekürzt, die Sekunden weichen bei dir ab):

HTTP/1.1 429 Too Many Requests
Retry-After: 55
X-RateLimit-Remaining-Minute: 0
X-RateLimit-Limit-Minute: 5
RateLimit-Remaining: 0
RateLimit-Limit: 5
RateLimit-Reset: 55
{
  "message":"API rate limit exceeded",
  "request_id":"69065b54…"
}

Retry-After sagt dem Client, wann er es wieder versuchen darf. Gut gebaute Clients warten so lange, statt sofort erneut zu fragen. Die RateLimit-*-Header kommen auch bei erfolgreichen Antworten mit, damit Clients ihr Tempo vorher drosseln können.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Pro Consumer, gezählt in Postgres

Beim Schreiben zählt nicht die IP, sondern wer schreibt. limit-schreiben.yaml setzt 3 pro Minute je Consumer mit policy: cluster und dazu ein Größenlimit von 1 KB:

deck file add-plugins -s ~/kong-lab/kong/kong.yaml limit-schreiben.yaml \
  -o ~/kong-lab/kong/kong.yaml
ksync | tail -3
w() {
  curl -s -o /dev/null -w '%{http_code} ' -X POST -H 'Content-Type: application/json' \
    "$@" -d '{"text":"limit"}' $PROXY/api/v1/notes
}
for i in 1 2 3 4; do w -H 'apikey: lab-key-anna-456'; done; echo
T=$(token); for i in 1 2 3 4; do w -H "Authorization: Bearer $T"; done; echo
cd ~/kong-lab/kong
docker compose exec kong-db psql -U kong -d kong \
  -c "select identifier, period, value from ratelimiting_metrics"

Erwartet (gekürzt, IDs weichen bei dir ab):

  Created: 2
  Updated: 0
  Deleted: 0
201 201 201 429
201 201 201 429
              identifier              | period | value
--------------------------------------+--------+-------
 2e1392da-3e39-4aad-94d6-e63ee3aa6bf0 | minute |     3
 2b3ac38f-8971-4689-9a0c-c282dfd89a92 | minute |     3
(2 rows)

anna und der Consumer keycloak haben getrennte Zähler, erkennbar an ihren IDs. Die abgewiesene vierte Anfrage zählt nicht mit.

policy Zähler liegt Gut für
local im Speicher jedes Knotens ein Knoten, oder grobe Grenzen
cluster in Postgres mehrere Knoten mit Datenbank, geringe Last
redis in Redis mehrere Knoten, hohe Last, auch DB-less

Mit drei Knoten und local darf ein Client faktisch dreimal so viel. cluster belastet die Datenbank mit jeder Anfrage, darum ist bei viel Verkehr redis die übliche Wahl.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Zu große Anfragen

cd ~/kong-lab/tag08
head -c 2000 /dev/zero | tr '\0' 'a' > gross.txt
curl -s -w ' %{http_code}\n' -X POST -H 'apikey: lab-key-anna-456' \
  -H 'Content-Type: application/json' \
  --data-binary "{\"text\":\"$(cat gross.txt)\"}" $PROXY/api/v1/notes

Erwartet (gekürzt):

{
  "message":"Request size limit exceeded",
  "request_id":"a9913371…"
} 413

2 KB sind mehr als das erlaubte eine. request-size-limiting hat Priorität 951 und läuft vor rate-limiting: Auch wer sein Limit schon verbraucht hat, bekommt hier 413, nicht 429. Das Backend sieht die Anfrage nie.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Die Admin API nur von der VM

Seit Tag 5 ist die Admin API über /admin-api auch aus dem Netz erreichbar, mit Passwort. Besser: nur von der VM selbst. Erster Versuch mit 127.0.0.1:

grep -A3 'name: ip-restriction' admin-ip.yaml
deck file add-plugins -s ~/kong-lab/kong/kong.yaml admin-ip.yaml \
  -o ~/kong-lab/kong/kong.yaml
ksync | tail -3
curl -s -w ' %{http_code}\n' -u anna:lab-user-pw-123 $PROXY/admin-api/status

Erwartet:

      - name: ip-restriction
        config:
          allow: ["127.0.0.1"]
  Created: 1
  Updated: 0
  Deleted: 0
{
  "message":"IP address not allowed: 172.18.0.1",
  "request_id":"4d7e0431…"
} 403

Auch du kommst nicht mehr durch. Deine Anfragen an localhost:8000 kommen bei Kong über das Docker-Netz an, vom Gateway des Netzes lab. Die Meldung verrät die Adresse. Trag genau diese ein (deine kann abweichen, etwa 172.19.0.1):

P='$.services[?(@.name=="admin-api")].plugins[?(@.name=="ip-restriction")]'
deck file patch -s ~/kong-lab/kong/kong.yaml --selector "$P.config" \
  --value 'allow:["172.18.0.1"]' -o ~/kong-lab/kong/kong.yaml
ksync | tail -3
curl -s -o /dev/null -w '%{http_code}\n' -u anna:lab-user-pw-123 $PROXY/admin-api/status

Erwartet:

  Created: 0
  Updated: 1
  Deleted: 0
200

Vom Laptop aus, über die IP der VM, bleibt die Tür zu. Die normale API geht weiter:

curl -s -w ' %{http_code}\n' -u anna:lab-user-pw-123 \
  http://$KONG_IP:8000/admin-api/status
curl -s -o /dev/null -w '%{http_code}\n' http://$KONG_IP:8000/api/v1/notes

Erwartet (gekürzt, deine Adresse weicht ab):

{
  "message":"IP address not allowed: 192.168.64.1",
  "request_id":"e579d75e…"
} 403
200

Docker gibt die echte Adresse des Clients an Kong weiter. Steht ein Load Balancer davor, sieht Kong dessen Adresse; dann braucht es trusted_ips und real_ip_header.

Stand festhalten:

cd ~/kong-lab/kong
git add kong.yaml && git commit -qm "Tag 8: Rate Limits, Größe, IP-Sperre"

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

curl -s $ADMIN/plugins | jq -r '.data[] | select(.name | test("rate|size|ip-"))
  | .name' | sort

Erwartet: drei neue Plugin-Arten, rate-limiting zweimal.

ip-restriction
rate-limiting
rate-limiting
request-size-limiting
curl -si $PROXY/api/v1/notes | grep -i '^ratelimit-limit'

Erwartet: das Limit fürs Lesen.

RateLimit-Limit: 5
deck gateway diff ~/kong-lab/kong/kong.yaml 2>/dev/null | tail -3

Erwartet: Datei und Datenbank stimmen überein.

  Created: 0
  Updated: 0
  Deleted: 0

Challenge

In den Logs tauchen Anfragen mit dem User-Agent sqlmap auf, einem Werkzeug für SQL-Injection. Sperr es für den Service echo aus. Prüf vorher, was die eingebaute Liste von bot-detection schon abweist.

Hinweis: bot-detection hat allow und deny mit regulären Ausdrücken; curl -A setzt den User-Agent.

Lösung

cd ~/kong-lab/tag08
deck file add-plugins -s ~/kong-lab/kong/kong.yaml \
  --selector '$.services[?(@.name=="echo")]' \
  --config '{"name":"bot-detection","config":{}}' -o ~/kong-lab/kong/kong.yaml
ksync | tail -1
for ua in curl/8.5.0 Googlebot/2.1 sqlmap/1.8; do
  printf '%-15s' $ua; curl -s -o /dev/null -w '%{http_code}\n' -A $ua $PROXY/echo/get
done

Erwartet:

  Deleted: 0
curl/8.5.0     200
Googlebot/2.1  403
sqlmap/1.8     200

Die eingebaute Liste kennt Suchmaschinen und Crawler, sqlmap nicht. Also selbst eintragen:

P='$.services[?(@.name=="echo")].plugins[?(@.name=="bot-detection")]'
deck file patch -s ~/kong-lab/kong/kong.yaml --selector "$P.config" \
  --value 'deny:["(?i)sqlmap"]' -o ~/kong-lab/kong/kong.yaml
ksync | tail -1
curl -s -o /dev/null -w '%{http_code}\n' -A sqlmap/1.8 $PROXY/echo/get
git -C ~/kong-lab/kong commit -qam "echo: sqlmap gesperrt"

Erwartet:

  Deleted: 0
403

Ein User-Agent ist eine Behauptung des Clients. bot-detection hält Gelegenheitsbots auf, keinen Angreifer, der lügt.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • rate-limiting-advanced (Enterprise) zählt mit gleitenden Fenstern, mehreren Limits je Plugin und Consumer-Gruppen mit eigenen Grenzen.
  • Redis für Zähler gehört hochverfügbar betrieben; fällt er aus, entscheidet fault_tolerant, ob Kong Anfragen durchlässt oder abweist.
  • Hinter einem Load Balancer trusted_ips und real_ip_header setzen, sonst zählt limit_by: ip alle Clients als einen.
  • Schutz in Schichten: Rate Limits im Gateway ersetzen keinen DDoS-Schutz davor und keine Limits im Backend.