Używanie poleceń Redis Scan na Linuxie: Kompletny przewodnik

Redis to wysokowydajny, otwartoźródłowy magazyn struktur danych w pamięci, szeroko stosowany jako baza danych klucz-wartość, cache i broker wiadomości. Wśród jego najpotężniejszych — choć często niedoocenianych — funkcji znajdują się komendy scan, które umożliwiają przyrostową iterację przez duże zestawy danych bez blokowania serwera ani degradacji wydajności.

Jeśli uruchamiasz Redis na serwerze opartym na Linux, opanowanie komend scan jest niezbędne do budowania skalowalnych, gotowych do produkcji aplikacji. W przeciwieństwie do niebezpiecznej komendy KEYS, która pobiera wszystkie pasujące klucze w jednej operacji blokującej, komendy scan zwracają dane w małych, łatwych do zarządzania partiach — co czyni je prawidłowym narzędziem dla każdego środowiska obsługującego znaczne ilości danych.

W tym kompleksowym przewodniku dowiesz się dokładnie, jak używać SCAN, SSCAN, HSCAN i ZSCAN w Redis na Linux, wraz z rzeczywistymi przykładami, skryptami powłoki i najlepszymi praktykami dla wdrożeń produkcyjnych.

Czym są komendy Redis Scan?

Komendy Redis scan zapewniają mechanizm oparty na kursorze, bez blokowania do iteracji po kluczach, zestawach, hashach i posortowanych zestawach. Każda komenda zwraca mały podzbiór elementów na wywołanie wraz z wartością kursora, którą używasz do kontynuowania iteracji w kolejnych wywołaniach. Gdy kursor powraca do 0, cały zestaw danych został przeskanowany.

To podejście jest fundamentalnie bezpieczniejsze i bardziej efektywne niż KEYS, które blokuje cały serwer Redis do czasu zakończenia skanowania — krytyczny problem w środowiskach produkcyjnych z milionami kluczy.

Cztery podstawowe komendy Scan

Podstawowa składnia poleceń skanowania

Wszystkie cztery polecenia skanowania mają spójną strukturę składni:

SCAN cursor [MATCH pattern] [COUNT count]
SSCAN key cursor [MATCH pattern] [COUNT count]
HSCAN key cursor [MATCH pattern] [COUNT count]
ZSCAN key cursor [MATCH pattern] [COUNT count]

Wyjaśnienie parametrów

• cursor — Liczba całkowita reprezentująca bieżącą pozycję w iteracji. Zawsze zacznij od 0 aby rozpocząć nowe skanowanie. Redis zwraca nowy kursor z każdą odpowiedzią; użyj go w następnym wywołaniu, aby kontynuować.
• MATCH pattern *(opcjonalnie)* — Filtruje wyniki przy użyciu dopasowania wzorca w stylu glob (np. user:*, *session*). Uwaga: filtrowanie odbywa się *po* pobraniu, więc dopasowania o niskiej gęstości mogą wymagać wielu iteracji.
• COUNT count *(opcjonalnie)* — Wskazówka dla Redis sugerująca, ile elementów zwrócić na iterację. To nie jest limit twardy; Redis może zwrócić więcej lub mniej. Domyślnie jest to 10.

Instalowanie Redis na Linux

Przed użyciem poleceń scan musisz mieć zainstalowany i uruchomiony Redis na serwerze Linux. Niezależnie od tego, czy pracujesz w środowisku produkcyjnym o wysokim ruchu, czy na maszynie deweloperskiej, proces instalacji jest prosty.

> Wskazówka: W przypadku obciążeń produkcyjnych wymagających Redis na dużą skalę, rozważ wdrożenie na planie VPS Hosting lub Dedicated Server, aby zapewnić pamięć, CPU i zasoby I/O, których wymaga Redis.

Instalowanie Redis na Debian/Ubuntu

sudo apt update
sudo apt install redis-server -y

Instalowanie Redis na CentOS/RHEL

sudo yum install redis -y

Uruchamianie usługi Redis

sudo systemctl start redis
sudo systemctl enable redis

Weryfikacja instalacji

sudo systemctl status redis

Powinieneś zobaczyć active (running) w wynikach. Teraz połącz się z Redis CLI:

redis-cli

Po wejściu do CLI przetestuj połączenie:

127.0.0.1:6379> PING
PONG

Jesteś gotowy, aby zacząć używać poleceń scan.

Używanie komendy SCAN

Komenda SCAN iteruje po wszystkich kluczach w przestrzeni kluczy Redis. Jest to ogólne zastępstwo dla komendy KEYS w środowiskach produkcyjnych.

Przykład 1: Podstawowy SCAN

Aby rozpocząć skanowanie wszystkich kluczy w bazie danych, zacznij od kursora 0:

SCAN 0

Przykładowe wyjście:

1) "14"
2) 1) "session:abc123"
   2) "user:1001"
   3) "product:55"

Pierwszy element (14) to następny kursor. Użyj go w następnym wywołaniu SCAN. Gdy zwrócony kursor to 0, pełna iteracja jest zakończona.

Przykład 2: Filtrowanie kluczy za pomocą MATCH

Aby pobrać tylko klucze pasujące do określonego wzorca — na przykład wszystkie klucze z prefiksem user::

SCAN 0 MATCH user:*

To zwraca tylko klucze, których nazwy zaczynają się od user:. Kontynuuj iterację, aż kursor zwróci 0, aby upewnić się, że przeskanowałeś całą przestrzeń kluczy.

Przykład 3: Kontrolowanie rozmiaru partii za pomocą COUNT

Aby zasugerować Redis zwrócenie około 100 kluczy na iterację:

SCAN 0 COUNT 100

Pamiętaj: COUNT to *wskazówka*, nie gwarancja. Redis może zwrócić nieco więcej lub mniej wyników w zależności od wewnętrznych struktur danych.

Przykład 4: Pełna iteracja przestrzeni kluczy za pomocą skryptu powłoki

W rzeczywistych scenariuszach będziesz musiał pętlą przejść przez całą przestrzeń kluczy programowo. Oto gotowy do produkcji skrypt Bash, który iteruje po wszystkich kluczach pasujących do wzorca:

#!/bin/bash

cursor=0
echo "Starting full keyspace scan..."

while true; do
    # Execute SCAN and capture the result
    result=$(redis-cli SCAN $cursor MATCH user:* COUNT 100)

    # Extract the new cursor (first line of output)
    cursor=$(echo "$result" | head -n 1)

    # Extract and display the keys (remaining lines)
    keys=$(echo "$result" | tail -n +2)
    echo "Keys found:"
    echo "$keys"

    # Break the loop when cursor returns to 0
    if [[ "$cursor" == "0" ]]; then
        echo "Scan complete."
        break
    fi
done

Aby uruchomić ten skrypt:

chmod +x scan_keys.sh
./scan_keys.sh

Używanie polecenia SSCAN

SSCAN służy do przyrostowego iterowania przez elementy Redis Set. Następuje ten sam wzorzec oparty na kursorze co SCAN.

Krok 1: Utwórz Set i dodaj elementy

SADD myset "apple"
SADD myset "banana"
SADD myset "cherry"
SADD myset "date"
SADD myset "elderberry"
SADD myset "mango"
SADD myset "mango:tropical"
SADD myset "mango:dried"

Krok 2: Podstawowe SSCAN

Skanuj wszystkie elementy w myset rozpoczynając od kursora 0:

SSCAN myset 0

Krok 3: Filtrowanie elementów za pomocą MATCH

Aby pobrać tylko elementy pasujące do wzorca mango:*:

SSCAN myset 0 MATCH mango:*

Krok 4: Iterowanie przez Set za pomocą skryptu Shell

#!/bin/bash

cursor=0
echo "Scanning through myset:"

while true; do
    # Scan the set
    result=$(redis-cli SSCAN myset $cursor COUNT 10)

    # Update cursor
    cursor=$(echo "$result" | head -n 1)

    # Print elements returned
    elements=$(echo "$result" | tail -n +2)
    echo "Elements: $elements"

    # Stop when cursor returns to 0
    if [[ "$cursor" == "0" ]]; then
        echo "Set scan complete."
        break
    fi
done

Zapisz jako scan_myset.sh, ustaw uprawnienia wykonywania i uruchom:

chmod +x scan_myset.sh
./scan_myset.sh

Używanie polecenia HSCAN

HSCAN iteruje przez pola i wartości Redis Hash. Jest to szczególnie przydatne, gdy hash zawiera setki lub tysiące pól i trzeba je przetwarzać bez ładowania wszystkiego do pamięci na raz.

Krok 1: Utwórz Hash i dodaj pola

HSET myhash name "John Doe"
HSET myhash age "30"
HSET myhash occupation "Software Developer"
HSET myhash city "San Francisco"
HSET myhash country "USA"
HSET myhash email "john@example.com"

Krok 2: Podstawowe HSCAN

HSCAN myhash 0

Przykładowe wyjście:

1) "0"
2) 1) "name"
   2) "John Doe"
   3) "age"
   4) "30"
   5) "occupation"
   6) "Software Developer"
   ...

Wyniki są zwracane jako naprzemienne pary pole-wartość.

Krok 3: Filtrowanie pól Hash za pomocą MATCH

Aby pobrać tylko pola, których nazwy zawierają "city" lub pasują do wzorca:

HSCAN myhash 0 MATCH *city*

Krok 4: Iteracja przez Hash za pomocą skryptu powłoki

#!/bin/bash

cursor=0
echo "Scanning hash: myhash"

while true; do
    result=$(redis-cli HSCAN myhash $cursor COUNT 10)
    cursor=$(echo "$result" | head -n 1)
    fields=$(echo "$result" | tail -n +2)

    echo "Fields and values:"
    echo "$fields"

    if [[ "$cursor" == "0" ]]; then
        echo "Hash scan complete."
        break
    fi
done

Używanie polecenia ZSCAN

ZSCAN iteruje przez członków i wyniki Redis Sorted Set. Sorted sets są powszechnie używane do rankingów, kolejek priorytetowych i danych szeregów czasowych — wszystkie scenariusze, w których efektywne skanowanie dużych kolekcji jest krytyczne.

Krok 1: Utwórz Sorted Set i dodaj członków

ZADD mysortedset 1 "apple"
ZADD mysortedset 2 "banana"
ZADD mysortedset 3 "cherry"
ZADD mysortedset 4 "date"
ZADD mysortedset 5 "elderberry"

Krok 2: Podstawowy ZSCAN

ZSCAN mysortedset 0

Przykładowe wyjście:

1) "0"
2) 1) "apple"
   2) "1"
   3) "banana"
   4) "2"
   5) "cherry"
   6) "3"

Wyniki są zwracane jako naprzemienne pary członek-wynik.

Krok 3: Filtruj członków za pomocą MATCH

Aby znaleźć wszystkich członków, których nazwy zawierają literę "e":

ZSCAN mysortedset 0 MATCH *e*

Krok 4: Pełny skrypt iteracji Sorted Set

#!/bin/bash

cursor=0
echo "Scanning sorted set: mysortedset"

while true; do
    result=$(redis-cli ZSCAN mysortedset $cursor COUNT 10)
    cursor=$(echo "$result" | head -n 1)
    members=$(echo "$result" | tail -n +2)

    echo "Members and scores:"
    echo "$members"

    if [[ "$cursor" == "0" ]]; then
        echo "Sorted set scan complete."
        break
    fi
done

Porównanie poleceń Scan: Szybki przewodnik

Najlepsze praktyki używania poleceń Redis Scan w produkcji

1. Zawsze używaj SCAN zamiast KEYS w produkcji

Polecenie KEYS jest jednowątkowe i blokuje wszystkie inne operacje Redis do czasu jego zakończenia. W bazie danych z milionami kluczy może to spowodować poważne skoki opóźnień. Nigdy nie używaj KEYS w produkcji. SCAN jest prawidłową, nieblokującą alternatywą.

2. Dostosuj COUNT w zależności od rozmiaru zestawu danych

W przypadku małych zestawów danych (< 1 000 kluczy) domyślne COUNT 10 jest wystarczające. W przypadku dużych zestawów danych zwiększ COUNT do 100–1000, aby zmniejszyć liczbę podróży w obie strony, zachowując rozsądny rozmiar poszczególnych odpowiedzi.

3. Nie polegaj wyłącznie na MATCH dla efektywności

Filtr MATCH jest stosowany *po* wewnętrznym pobraniu elementów przez Redis. Jeśli Twój wzorzec pasuje tylko do małej części kluczy, Redis nadal skanuje pełny zestaw danych wewnętrznie. Używaj konwencji nazewnictwa kluczy (np. spójne prefiksy), aby uczynić MATCH bardziej efektywnym.

4. Przetwarzaj wyniki w partiach

Nigdy nie gromadź wszystkich wyników skanowania w pamięci przed przetworzeniem. Zamiast tego przetwarzaj każdą partię natychmiast po jej zwróceniu. Jest to szczególnie ważne na serwerach z ograniczoną pamięcią.

5. Ostrożnie obsługuj stan kursora

Zawsze inicjalizuj kursor na 0 i aktualizuj go przy każdej odpowiedzi. Jeśli Twoja aplikacja ulegnie awarii w trakcie skanowania, uruchom ponownie od 0. Kursory Redis nie są trwałe po ponownym uruchomieniu serwera.

6. Dokładnie testuj najpierw w środowisku programistycznym

Przed wdrożeniem logiki opartej na skanowaniu do produkcji, zweryfikuj ją w środowisku przejściowym z reprezentatywnym zestawem danych. Sprawdź, czy Twoja pętla prawidłowo się kończy, gdy kursor powraca do 0.

7. Zabezpiecz swoją instancję Redis

Redis nigdy nie powinien być narażony na publiczny internet bez uwierzytelnienia. Użyj requirepass w konfiguracji Redis, powiąż się z localhost lub prywatnym interfejsem sieciowym i użyj reguł zapory sieciowej, aby ograniczyć dostęp.

Wybór odpowiedniego środowiska hostingowego dla Redis

Wydajność Redis jest bezpośrednio związana z dostępną pamięcią RAM, szybkością CPU i opóźnieniem sieci. Wybór odpowiedniej infrastruktury hostingowej jest równie ważny jak pisanie wydajnych poleceń Redis.

• Projekty rozwojowe i małe: Hosting współdzielony może wystarczyć do lekkiego użytku Redis, chociaż dedykowane instancje Redis są zawsze preferowane.
• Rozwijające się aplikacje: Plan VPS Hosting zapewnia dedykowane zasoby, dostęp root i możliwość dostrojenia konfiguracji Redis (maxmemory, ustawienia trwałości itp.) do Twoich dokładnych potrzeb.
• Systemy produkcyjne o dużym ruchu: Serwery dedykowane zapewniają maksymalną pamięć RAM i zasoby CPU, które Redis może wykorzystać, całkowicie eliminując konkurencję o zasoby.
• Obciążenia AI i ML wykorzystujące Redis jako magazyn wektorów: GPU Hosting oferuje moc obliczeniową potrzebną do generowania osadzeń i wyszukiwania podobieństwa obok Redis.

W przypadku aplikacji, które wymagają również panelu kontroli sieci Web dla łatwiejszego zarządzania, VPS z cPanel zapewnia przyjazny dla użytkownika interfejs wraz z pełną kontrolą serwera.

Rozwiązywanie typowych problemów

SCAN zwraca 0 elementów wielokrotnie

Zwykle oznacza to, że Twój MATCH wzorzec nie pasuje do żadnych kluczy, lub zestaw danych jest pusty. Zweryfikuj nazewnictwo kluczy za pomocą DBSIZE aby sprawdzić całkowitą liczbę kluczy.

127.0.0.1:6379> DBSIZE
(integer) 15420

Kursor nigdy nie powraca do 0

Nie powinno się to zdarzyć w stabilnej instancji Redis. Jeśli tak się stanie, sprawdź zgodność wersji Redis (polecenia scan wymagają Redis 2.8+) lub przerwania połączenia resetujące śledzenie kursora.

Skrypt zawiesza się na czas nieokreślony

Upewnij się, że Twoja pętla prawidłowo odczytuje kursor z pierwszej linii danych wyjściowych redis-cli. Błąd analizy, który zawsze daje kursor niezerowy, spowoduje nieskończoną pętlę.

Podsumowanie

Komendy skanowania Redis — SCAN, SSCAN, HSCAN i ZSCAN — są niezbędnymi narzędziami dla każdego programisty lub administratora systemu pracującego z Redis na dużą skalę w systemie Linux. Zapewniają bezpieczny, nieblokujący mechanizm oparty na kursorze do iteracji przez duże zestawy danych bez ryzyka wydajności związanego z poleceniami takimi jak KEYS.

Łącząc komendy skanowania z wzorcami MATCH, odpowiednimi wskazówkami COUNT i dobrze ustrukturyzowanymi skryptami powłoki, możesz budować wydajne potoki przetwarzania danych, które skalują się elegancko wraz z rozmiarem zestawu danych. Postępowanie zgodnie z najlepszymi praktykami opisanymi w tym przewodniku — szczególnie w odniesieniu do bezpieczeństwa produkcji, zarządzania pamięcią i wyboru infrastruktury — zapewni, że wdrożenia Redis pozostaną wydajne i niezawodne.

Aby uzyskać najnowsze opcje poleceń i szczegóły zaawansowanej konfiguracji, zawsze zapoznaj się z oficjalną dokumentacją Redis. A gdy będziesz gotowy do wdrożenia Redis w produkcyjnym środowisku Linux, zapoznaj się z VPS Hosting i Dedicated Servers AlexHost, aby uzyskać infrastrukturę zbudowaną do obsługi wymagających obciążeń wymagających dużej ilości pamięci.