Wykrywanie efektu Slashdot w nginx

Czy jest sposób, aby zmusić Nginx do powiadamiania mnie, jeśli trafienia od strony odsyłającej przekroczą próg?

np. jeśli moja strona internetowa jest prezentowana na Slashdot i nagle mam godzinę 2 000 wyświetleń w ciągu godziny, chcę otrzymywać powiadomienia, gdy liczba wyświetleń przekroczy 1 000 godzin.

Czy będzie to możliwe w Nginx? Być może bez lua? (ponieważ mój prod nie jest skompilowany lua)

Najbardziej skutecznym rozwiązaniem może być napisać demona, który i śledzić na polu.tail -faccess.log$http_referer

Jednak szybkim i brudnym rozwiązaniem byłoby dodanie dodatkowego access_logpliku, rejestrowanie tylko $http_refererzmiennej za pomocą niestandardowej log_formati automatyczne obracanie dziennika co X minut.

• Można tego dokonać za pomocą standardowych skryptów logrotate, które mogą wymagać płynnego ponownego uruchomienia nginx w celu ponownego otwarcia plików (np. Standardowa procedura, spójrz na / a / 15183322 na SO przez prosty czas- oparty na skrypcie)…

• Lub, używając zmiennych wewnątrz access_log, być może poprzez wyciągnięcie najdrobniejszej specyfikacji $time_iso8601za pomocą dyrektywy maplub if(w zależności od tego, gdzie chcesz umieścić access_log).

Tak więc, z powyższym, możesz mieć 6 plików dziennika, z których każdy obejmuje okres 10 minut http_referer.Txx{0,1,2,3,4,5}x.log, np. Poprzez uzyskanie pierwszej cyfry minuty w celu odróżnienia każdego pliku.

Teraz wystarczy prosty skrypt powłoki, który mógłby uruchamiać się co 10 minut, catwszystkie powyższe pliki razem, potokować do sort, potokować do uniq -c, do sort -rn, do head -16i masz listę 16 najczęstszych Refererodmian - swobodnie decyduj, czy dowolne kombinacje liczb i pól przekraczają twoje kryteria, i dokonaj powiadomienia.

Następnie, po pojedynczym pomyślnym powiadomieniu, możesz usunąć wszystkie te 6 plików, aw kolejnych uruchomieniach nie wydawać żadnego powiadomienia, chyba że wszystkie sześć plików jest obecnych (i / lub pewna inna liczba, którą uważasz za stosowną).

Myślę, że lepiej byłoby to zrobić przy logtailu i grep. Nawet jeśli jest to możliwe w przypadku lua inline, nie chcesz tego narzutu dla każdego żądania, a szczególnie nie chcesz go, gdy jesteś Slashdotted.

Oto 5-sekundowa wersja. Umieść go w skrypcie i umieść wokół niego bardziej czytelny tekst, a będziesz złoty.

5 * * * * logtail -f /var/log/nginx/access_log -o /tmp/nginx-logtail.offset | grep -c "http://[^ ]slashdot.org"

Oczywiście całkowicie to ignoruje reddit.com i facebook.com oraz wszystkie miliony innych witryn, które mogą generować duży ruch. Nie wspominając o 100 różnych witrynach, z których każda odwiedza 20 osób. Prawdopodobnie powinieneś mieć zwykły stary próg ruchu, który spowoduje wysłanie wiadomości e-mail, niezależnie od strony polecającej.

Dyrektywa nginx limit_req_zone może opierać swoje strefy na dowolnej zmiennej, w tym $ http_referrer.

http {
    limit_req_zone  $http_referrer  zone=one:10m   rate=1r/s;

    ...

    server {

        ...

        location /search/ {
            limit_req   zone=one  burst=5;
        }

Będziesz także chciał zrobić coś, aby ograniczyć wymagany stan na serwerze WWW, ponieważ nagłówki strony odsyłającej mogą być dość długie i zróżnicowane, a może pojawić się nieskończona odmiana. Za pomocą funkcji split_clients nginx można ustawić zmienną dla wszystkich żądań opartą na haszu nagłówka strony odsyłającej. Poniższy przykład wykorzystuje tylko 10 bucków, ale równie łatwo możesz to zrobić z 1000. Więc jeśli zostaniesz slashdotowany, osoby, które skierowały się do hashowania do tego samego segmentu, co adres URL slashdot, również zostaną zablokowane, ale możesz ograniczyć to do 0,1% odwiedzających, używając 1000 segmentów w split_clients.

Wyglądałoby to mniej więcej tak (całkowicie nie przetestowane, ale poprawne kierunkowo):

http {

split_clients $http_referrer $refhash {
               10%               x01;
               10%               x02;
               10%               x03;
               10%               x04;
               10%               x05;
               10%               x06;
               10%               x07;
               10%               x08;
               10%               x09;
               *                 x10;
               }

limit_req_zone  $refhash  zone=one:10m   rate=1r/s;

...

server {

    ...

    location /search/ {
        limit_req   zone=one  burst=5;
    }

Tak, oczywiście jest to możliwe w NGINX!

Co możesz zrobić, to wdrożyć następujący DFA :

1. Zaimplementuj ograniczenie szybkości, oparte na $http_refererewentualnym użyciu wyrażeń regularnych poprzez a w mapcelu normalizacji wartości. Po przekroczeniu limitu pojawia się strona błędu wewnętrznego, którą można przechwycić przez error_pagemoduł obsługi zgodnie z powiązanym pytaniem , przechodząc do nowej lokalizacji wewnętrznej jako przekierowanie wewnętrzne (niewidoczne dla klienta).

2. W powyższej lokalizacji dla przekroczonych limitów wykonujesz żądanie alertu, pozwalając zewnętrznej logice wykonać powiadomienie; to żądanie jest następnie buforowane, zapewniając, że otrzymasz tylko 1 unikalne żądanie w danym oknie czasowym.

3. Złap kod stanu HTTP z poprzedniego żądania (zwracając kod stanu ≥ 300 i używając proxy_intercept_errors onlub, alternatywnie, skorzystaj z domyślnie niezbudowanego auth_requestlub add_after_bodyzrób „bezpłatne” żądanie) i wypełnij pierwotne żądanie, jakby poprzedni krok nie był zaangażowany. Pamiętaj, że aby error_pageto zadziałało , musimy włączyć obsługę rekurencyjną .

Oto mój PoC i MVP, również na https://github.com/cnst/StackOverflow.cnst.nginx.conf/blob/master/sf.432636.detecting-slashdot-effect-in-nginx.conf :

limit_req_zone $http_referer zone=slash:10m rate=1r/m;  # XXX: how many req/minute?
server {
    listen 2636;
    location / {
        limit_req zone=slash nodelay;
        #limit_req_status 429;  #nginx 1.3.15
        #error_page 429 = @dot;
        error_page 503 = @dot;
        proxy_pass http://localhost:2635;
        # an outright `return 200` has a higher precedence over the limit
    }
    recursive_error_pages on;
    location @dot {
        proxy_pass http://127.0.0.1:2637/?ref=$http_referer;
        # if you don't have `resolver`, no URI modification is allowed:
        #proxy_pass http://localhost:2637;
        proxy_intercept_errors on;
        error_page 429 = @slash;
    }
    location @slash {
        # XXX: placeholder for your content:
        return 200 "$uri: we're too fast!\n";
    }
}
server {
    listen 2635;
    # XXX: placeholder for your content:
    return 200 "$uri: going steady\n";
}
proxy_cache_path /tmp/nginx/slashdotted inactive=1h
        max_size=64m keys_zone=slashdotted:10m;
server {
    # we need to flip the 200 status into the one >=300, so that
    # we can then catch it through proxy_intercept_errors above
    listen 2637;
    error_page 429 @/.;
    return 429;
    location @/. {
        proxy_cache slashdotted;
        proxy_cache_valid 200 60s;  # XXX: how often to get notifications?
        proxy_pass http://localhost:2638;
    }
}
server {
    # IRL this would be an actual script, or
    # a proxy_pass redirect to an HTTP to SMS or SMTP gateway
    listen 2638;
    return 200 authorities_alerted\n;
}

Pamiętaj, że działa to zgodnie z oczekiwaniami:

% sh -c 'rm /tmp/slashdotted.nginx/*; mkdir /tmp/slashdotted.nginx; nginx -s reload; for i in 1 2 3; do curl -H "Referer: test" localhost:2636; sleep 2; done; tail /var/log/nginx/access.log'
/: going steady
/: we're too fast!
/: we're too fast!

127.0.0.1 - - [26/Aug/2017:02:05:49 +0200] "GET / HTTP/1.1" 200 16 "test" "curl/7.26.0"
127.0.0.1 - - [26/Aug/2017:02:05:49 +0200] "GET / HTTP/1.0" 200 16 "test" "curl/7.26.0"

127.0.0.1 - - [26/Aug/2017:02:05:51 +0200] "GET / HTTP/1.1" 200 19 "test" "curl/7.26.0"
127.0.0.1 - - [26/Aug/2017:02:05:51 +0200] "GET /?ref=test HTTP/1.0" 200 20 "test" "curl/7.26.0"
127.0.0.1 - - [26/Aug/2017:02:05:51 +0200] "GET /?ref=test HTTP/1.0" 429 20 "test" "curl/7.26.0"

127.0.0.1 - - [26/Aug/2017:02:05:53 +0200] "GET / HTTP/1.1" 200 19 "test" "curl/7.26.0"
127.0.0.1 - - [26/Aug/2017:02:05:53 +0200] "GET /?ref=test HTTP/1.0" 429 20 "test" "curl/7.26.0"
%

Widać, że pierwsze żądanie skutkuje jednym trafieniem frontonu i jednego backendu, zgodnie z oczekiwaniami (musiałem dodać fikcyjny backend do lokalizacji, która ma limit_req, ponieważ ponieważ return 200miałby pierwszeństwo przed limitami, prawdziwy backend nie jest konieczny do końca obsługi).

Drugie żądanie jest powyżej limitu, więc wysyłamy alert (otrzymujemy 200) i buforujemy go, zwracając 429(jest to konieczne ze względu na wspomniane ograniczenie, że żądania poniżej 300 nie mogą zostać przechwycone), które są następnie przechwytywane przez interfejs , który jest teraz wolny i może robić, co chce.

Trzecie żądanie wciąż przekracza limit, ale już wysłaliśmy alert, więc żaden nowy alert nie zostanie wysłany.

Gotowy! Nie zapomnij rozwidlić go na GitHub!