Docker startet Redis und legt das Passwort fest

Version: '3.3'

Leistungen:
 Cache:
  Bild: redis:5-alpine
  Neustart: immer
  Häfen:
   - „6379:6379“

Version: '3.3'

Leistungen:
 Cache:
  Bild: redis:5-alpine
  Neustart: immer
  Häfen:
   - „6379:6379“
  Befehl: ["redis-server", "--appendonly", "yes", "--requirepass","123456"]

redis-cli -h 127.0.0.1 -p 6379 
redis 127.0.0.1:6379> 
redis 127.0.0.1:6379> Schlüssel * 
(Fehler) ERR-Operation nicht zulässig 
redis 127.0.0.1:6379> wähle 1 
(Fehler) ERR-Operation nicht zulässig 
redis 127.0.0.1:6379[1]>

redis 127.0.0.1:6379> wähle 1 
OK 
redis 127.0.0.1:6379[1]> Konfiguration abrufen requirepass

redis 127.0.0.1:6379[1]> Konfigurationssatz requirepass my_redis 
OK 
redis 127.0.0.1:6379[1]> Konfiguration abrufen requirepass

redis-cli -h 127.0.0.1 -p 6379 -a myRedis 
redis 127.0.0.1:6379> Konfiguration abrufen requirepass 
(Fehler) ERR-Operation nicht zulässig

sudo service redis neu starten 
Redis-Server wird gestoppt: [ OK ] 
Redis-Server wird gestartet: [ OK ] 
redis-cli -h 127.0.0.1 -p 6379 -a my_redis 
redis 127.0.0.1:6379> Konfiguration abrufen requirepass 
(Fehler) ERR-Operation nicht zulässig 
redis-cli -h 127.0.0.1 -p 6379 -a myRedis 
redis 127.0.0.1:6379> Konfiguration abrufen requirepass

redis-cli -h 127.0.0.1 -p 6379 
redis 127.0.0.1:6379> Konfiguration abrufen requirepass 
(Fehler) ERR-Operation nicht zulässig 
redis 127.0.0.1:6379> Authentizität myRedis 
OK 
redis 127.0.0.1:6379> Konfiguration abrufen requirepass

VON redis
WARTUNGSBEARBEITER „roamer <[email protected]>“
#Angepasste Konfigurationsdatei zum Ersetzen der ursprünglichen Image-Konfigurationsdatei KOPIEREN redis.conf /usr/local/etc/redis/redis.conf
CMD [ "redis-server", "/usr/local/etc/redis/redis.conf" ]
#RUN apt-get update && apt-get install vim -y

# Beispiel für eine Redis-Konfigurationsdatei.
#
# Beachten Sie, dass Redis zum Lesen der Konfigurationsdatei
# begann mit dem Dateipfad als erstes Argument:
#
# ./redis-server /Pfad/zu/redis.conf

# Hinweis zu Einheiten: Wenn Speichergröße benötigt wird, kann angegeben werden
# es in der üblichen Form von 1k 5GB 4M und so weiter:
#
# 1k => 1000 Bytes
# 1 KB => 1024 Bytes
# 1m => 1000000 Bytes
# 1 MB => 1024 x 1024 Bytes
# 1g => 1000000000 Bytes
# 1 GB => 1024*1024*1024 Bytes
#
# Einheiten unterscheiden nicht zwischen Groß- und Kleinschreibung, daher sind 1 GB, 1 Gb und 1 GB alle gleich.

########################################### BEINHALTET ######################################

# Fügen Sie hier eine oder mehrere andere Konfigurationsdateien ein. Dies ist nützlich, wenn Sie
# haben eine Standardvorlage, die an alle Redis-Server geht, brauchen aber auch
# um einige Einstellungen pro Server anzupassen. Include-Dateien können enthalten
# andere Dateien, also verwenden Sie dies mit Bedacht.
#
# Beachten Sie, dass die Option „include“ nicht durch den Befehl „CONFIG REWRITE“ überschrieben wird.
# von admin oder Redis Sentinel. Da Redis immer die zuletzt verarbeitete
# Zeile als Wert einer Konfigurationsanweisung, Sie sollten besser include einfügen
# am Anfang dieser Datei, um zu vermeiden, dass Konfigurationsänderungen zur Laufzeit überschrieben werden.
#
# Wenn Sie stattdessen Includes verwenden möchten, um die Konfiguration zu überschreiben
# Optionen, es ist besser, „include“ als letzte Zeile zu verwenden.
#
# include /Pfad/zu/local.conf
# include /Pfad/zu/anderer.conf

############################################ NETZWERK ##########################################

# Wenn keine Konfigurationsanweisung „Bind“ angegeben ist, hört Redis standardmäßig
# für Verbindungen von allen auf dem Server verfügbaren Netzwerkschnittstellen.
# Es ist möglich, nur eine oder mehrere ausgewählte Schnittstellen abzuhören mit
# die Konfigurationsdirektive „bind“, gefolgt von einer oder mehreren IP-Adressen.
#
# Beispiele:
#
# binden 192.168.1.100 10.0.0.1
# binden 127.0.0.1 ::1
#
# ~~~ WARNUNG ~~~ Wenn der Computer, auf dem Redis läuft, direkt dem
# Internet, die Bindung an alle Schnittstellen ist gefährlich und setzt die
# Instanz für alle im Internet. Standardmäßig entfernen wir also das Kommentarzeichen
# folgende Bind-Direktive, die Redis zwingt, nur in
# die IPv4-Lookback-Schnittstellenadresse (das bedeutet, dass Redis in der Lage sein wird,
# Akzeptiere nur Verbindungen von Clients, die auf demselben Computer laufen wie
# läuft).
#
# WENN SIE SICHER SIND, DASS IHRE INSTANZEN AUF ALLE SCHNITTSTELLEN HÖREN SOLL
# KOMMENTIEREN SIE EINFACH DIE FOLGENDE ZEILE.
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# binden 127.0.0.1

# Der geschützte Modus ist eine Sicherheitsebene, um zu verhindern, dass
# Auf im Internet offen gelassene Redis-Instanzen wird zugegriffen und sie werden ausgenutzt.
#
# Wenn der geschützte Modus aktiviert ist und wenn:
#
# 1) Der Server bindet sich nicht explizit an eine Reihe von Adressen mit dem
# "Bind"-Direktive.
# 2) Es ist kein Passwort konfiguriert.
#
# Der Server akzeptiert nur Verbindungen von Clients aus dem
# IPv4- und IPv6-Loopback-Adressen 127.0.0.1 und ::1 sowie von der Unix-Domäne
# Steckdosen.
#
# Standardmäßig ist der geschützte Modus aktiviert. Sie sollten ihn nur deaktivieren, wenn
# Sie sind sicher, dass Clients von anderen Hosts eine Verbindung zu Redis herstellen sollen
# auch wenn weder eine Authentifizierung noch ein bestimmter Satz von Schnittstellen konfiguriert ist
# werden mit der Direktive „Bind“ explizit aufgelistet.
geschützter Modus ja

# Akzeptieren Sie Verbindungen auf dem angegebenen Port, Standard ist 6379 (IANA #815344).
# Wenn Port 0 angegeben ist, hört Redis nicht auf einem TCP-Socket.
Port 6379

# TCP-Listen()-Rückstand.
#
# In Umgebungen mit vielen Anfragen pro Sekunde benötigen Sie einen hohen Rückstand, um
# um langsame Client-Verbindungsprobleme zu vermeiden. Beachten Sie, dass der Linux-Kernel
# wird es stillschweigend auf den Wert von /proc/sys/net/core/somaxconn kürzen, so
# Stellen Sie sicher, dass sowohl der Wert von somaxconn als auch der von tcp_max_syn_backlog erhöht wird
# um den gewünschten Effekt zu erzielen.
TCP-Rückstand 511

# Unix-Socket.
#
# Geben Sie den Pfad für den Unix-Socket an, der zum Abhören verwendet wird
# eingehende Verbindungen. Es gibt keinen Standardwert, daher hört Redis nicht zu
# auf einem Unix-Socket, wenn nicht angegeben.
#
# unixsocket /tmp/redis.sock
# unixsocketperm 700

# Schließen Sie die Verbindung, nachdem ein Client N Sekunden lang inaktiv war (0 zum Deaktivieren)
Zeitüberschreitung 0

# TCP-Keepalive.
#
# Wenn ungleich Null, verwenden Sie SO_KEEPALIVE, um TCP-ACKs an abwesende Clients zu senden
# der Kommunikation. Dies ist aus zwei Gründen nützlich:
#
# 1) Erkennen Sie tote Peers.
# 2) Nehmen Sie die Verbindung aus der Sicht des Netzwerks lebendig
# Ausrüstung in der Mitte.
#
# Unter Linux ist der angegebene Wert (in Sekunden) der Zeitraum, der zum Senden von ACKs verwendet wird.
# Beachten Sie, dass zum Schließen der Verbindung die doppelte Zeit benötigt wird.
# Bei anderen Kerneln hängt der Zeitraum von der Kernelkonfiguration ab.
#
# Ein sinnvoller Wert für diese Option ist 300 Sekunden, das ist der neue
# Redis-Standard ab Redis 3.2.1.
TCP-Keepalive 300

################################## ALLGEMEIN #######################################

# Standardmäßig wird Redis nicht als Daemon ausgeführt. Verwenden Sie „yes“, wenn Sie es benötigen.
# Beachten Sie, dass Redis bei der Daemonisierung eine PID-Datei in /var/run/redis.pid schreibt.
dämonisieren nein

# Wenn Sie Redis von Upstart oder Systemd aus ausführen, kann Redis mit Ihrem
# Überwachungsbaum. Optionen:
# beaufsichtigt nein - keine Aufsicht Interaktion
# überwachter Upstart - Signalisieren Sie den Upstart, indem Sie Redis in den SIGSTOP-Modus versetzen
# überwachtes systemd - signalisieren Sie systemd, indem Sie READY=1 in $NOTIFY_SOCKET schreiben
# überwachte automatische Erkennung von Upstart- oder Systemd-Methoden basierend auf
# UPSTART_JOB- oder NOTIFY_SOCKET-Umgebungsvariablen
# Hinweis: Diese Überwachungsmethoden signalisieren nur „Prozess ist bereit.“
# Sie ermöglichen keine kontinuierlichen Liveness-Pings zurück an Ihren Vorgesetzten.
beaufsichtigt nein

# Wenn eine PID-Datei angegeben ist, schreibt Redis sie beim Start an die angegebene Stelle
# und entfernt es beim Beenden.
#
# Wenn der Server nicht als Daemon ausgeführt wird, wird keine PID-Datei erstellt,
# in der Konfiguration angegeben. Wenn der Server als Daemon ausgeführt wird, wird die PID-Datei
# wird verwendet, auch wenn nicht angegeben, der Standardwert ist „/var/run/redis.pid“.
#
# Das Erstellen einer PID-Datei ist die beste Lösung: Wenn Redis sie nicht erstellen kann
# es passiert nichts Schlimmes, der Server wird gestartet und läuft normal.
pid-Datei /var/run/redis_6379.pid

# Geben Sie die Ausführlichkeitsstufe des Servers an.
# Dies kann eines der folgenden sein:
# debug (viele Informationen, nützlich für Entwicklung/Tests)
# ausführlich (viele selten nützliche Informationen, aber kein Durcheinander wie auf der Debug-Ebene)
# Hinweis (mäßig ausführlich, was Sie wahrscheinlich in der Produktion wollen)
# Warnung (nur sehr wichtige/kritische Meldungen werden protokolliert)
Loglevel-Hinweis

# Geben Sie den Namen der Protokolldatei an. Auch die leere Zeichenfolge kann verwendet werden, um
# Redis, um sich bei der Standardausgabe anzumelden. Beachten Sie, dass bei Verwendung von Standard
# Ausgabe für Protokollierung, aber Daemonisierung, Protokolle werden an /dev/null gesendet
Protokolldatei ""

# Um die Protokollierung im Systemlogger zu aktivieren, setzen Sie einfach 'syslog-enabled' auf yes,
# und aktualisieren Sie optional die anderen Syslog-Parameter entsprechend Ihren Anforderungen.
# syslog-enabled nein

# Geben Sie die Syslog-Identität an.
# Syslog-Identifikation Redis

# Geben Sie die Syslog-Einrichtung an. Muss USER oder zwischen LOCAL0-LOCAL7 sein.
# Syslog-Einrichtung local0

# Legen Sie die Anzahl der Datenbanken fest. Die Standarddatenbank ist DB 0, Sie können auswählen
# ein anderes für jede Verbindung mit SELECT <dbid>, wobei
# dbid ist eine Zahl zwischen 0 und 'Datenbanken'-1
Datenbanken 16

######################################## SCHNAPPSCHÜSSE ###################################
#
# Speichern Sie die Datenbank auf der Festplatte:
#
# speichern <Sekunden> <Änderungen>
#
# Speichert die Datenbank, wenn sowohl die angegebene Anzahl von Sekunden als auch die angegebene
# Anzahl der aufgetretenen Schreibvorgänge für die Datenbank.
#
# Im folgenden Beispiel besteht das Verhalten darin, Folgendes zu speichern:
# nach 900 Sek. (15 Min.), wenn mindestens 1 Schlüssel geändert wurde
# nach 300 Sekunden (5 Minuten), wenn mindestens 10 Schlüssel geändert wurden
# nach 60 Sekunden, wenn mindestens 10000 Schlüssel geändert wurden
#
# Hinweis: Sie können das Speichern vollständig deaktivieren, indem Sie alle „Speichern“-Zeilen auskommentieren.
#
# Es ist auch möglich, alle zuvor konfigurierten Save-
# Punkte durch Hinzufügen einer Speicherdirektive mit einem einzelnen leeren String-Argument
# wie im folgenden Beispiel:
#
# speichern ""

sparen 900 1
sparen 300 10
sparen 60 10000

# Standardmäßig akzeptiert Redis keine Schreibvorgänge mehr, wenn RDB-Snapshots aktiviert sind
# (mindestens ein Speicherpunkt) und die letzte Speicherung im Hintergrund ist fehlgeschlagen.
# Dadurch wird dem Benutzer (auf harte Weise) bewusst, dass die Daten nicht dauerhaft gespeichert werden
# auf der Festplatte richtig, sonst besteht die Möglichkeit, dass niemand es bemerkt und einige
#Eine Katastrophewirdpassieren.
#
# Wenn der Hintergrundspeichervorgang wieder funktioniert, wird Redis
# Schreibvorgänge automatisch wieder zulassen.
#
# Wenn Sie jedoch eine ordnungsgemäße Überwachung des Redis-Servers eingerichtet haben
# und Persistenz, möchten Sie diese Funktion möglicherweise deaktivieren, damit Redis
# weiter wie gewohnt arbeiten, auch wenn es Probleme mit der Festplatte gibt,
# Berechtigungen und so weiter.
Schreibvorgänge bei BGSave-Fehler stoppen, ja

# String-Objekte mit LZF komprimieren, wenn .rdb-Datenbanken gesichert werden?
# Standardmäßig ist dies auf „Ja“ eingestellt, da es fast immer ein Gewinn ist.
# Wenn Sie im Speicher-Child etwas CPU sparen wollen, setzen Sie es auf 'no', aber
# der Datensatz wird wahrscheinlich größer sein, wenn Sie komprimierbare Werte oder Schlüssel haben.
RDB-Komprimierung: ja

# Seit Version 5 von RDB wird am Ende der Datei eine CRC64-Prüfsumme platziert.
# Dadurch wird das Format widerstandsfähiger gegen Beschädigungen, es gibt jedoch
# Hit to Pay (ca. 10%) beim Speichern und Laden von RDB-Dateien, so dass Sie es deaktivieren können
# für maximale Leistung.
#
# RDB-Dateien, die mit deaktivierter Prüfsumme erstellt wurden, haben eine Prüfsumme von Null,
# Sagen Sie dem Ladecode, dass die Prüfung übersprungen werden soll.
RDB-Prüfsumme ja

# Der Dateiname, in den die Datenbank kopiert werden soll
Datenbankdateiname dump.rdb

# Das Arbeitsverzeichnis.
#
# Die Datenbank wird mit dem angegebenen Dateinamen in dieses Verzeichnis geschrieben
# oben mit der Konfigurationsdirektive „dbfilename“.
#
# Die Nur-Anhängen-Datei wird auch in diesem Verzeichnis erstellt.
#
# Beachten Sie, dass Sie hier ein Verzeichnis und keinen Dateinamen angeben müssen.
dir ./

########################################### REPLIKATION ######################################

# Master-Slave-Replikation. Verwenden Sie slaveof, um eine Redis-Instanz zu einer Kopie von
# ein weiterer Redis-Server. Einige Dinge, die Sie so schnell wie möglich über die Redis-Replikation wissen sollten.
#
# 1) Die Redis-Replikation ist asynchron, aber Sie können einen Master konfigurieren, um
# keine Schreibvorgänge mehr akzeptieren, wenn keine Verbindung besteht mit mindestens
# eine bestimmte Anzahl von Slaves.
# 2) Redis-Slaves können eine teilweise Resynchronisierung mit dem
# Master, wenn die Replikationsverbindung für eine relativ kurze Zeit verloren geht
# Zeit. Möglicherweise möchten Sie die Größe des Replikationsrückstands konfigurieren (siehe nächste
# Abschnitte dieser Datei) durch einen sinnvollen Wert, abhängig von Ihren Anforderungen.
# 3) Die Replikation erfolgt automatisch und erfordert keinen Benutzereingriff. Nach einer
# Netzwerkpartitions-Slaves versuchen automatisch, sich wieder mit den Mastern zu verbinden
# und synchronisieren Sie erneut mit ihnen.
#
# Slave von <MasterIP> <MasterPort>

# Wenn der Master durch ein Passwort geschützt ist (mit der Konfiguration „requirepass“
# Anweisung unten) ist es möglich, den Slave anzuweisen, sich zu authentifizieren, bevor
# Starten des Replikationssynchronisationsprozesses, sonst wird der Master
# die Slave-Anfrage ablehnen.
#
# masterauth <Master-Passwort>

# Wenn ein Slave die Verbindung zum Master verliert oder wenn die Replikation
# noch im Gange ist, kann der Slave auf zwei verschiedene Arten agieren:
#
# 1) wenn slave-serve-stale-data auf 'yes' (Standard) eingestellt ist, wird der Slave
# immer noch auf Client-Anfragen antworten, möglicherweise mit veralteten Daten, oder die
# Der Datensatz ist möglicherweise leer, wenn dies die erste Synchronisierung ist.
#
# 2) wenn slave-serve-stale-data auf 'no' gesetzt ist, antwortet der Slave mit
# ein Fehler "SYNC mit Master in Bearbeitung" bei allen Arten von Befehlen
# sondern an INFO und SLAVEOF.
#
Slave-Serve-Veraltete-Daten ja

# Sie können eine Slave-Instanz so konfigurieren, dass sie Schreibvorgänge akzeptiert oder nicht. Schreiben gegen
# eine Slave-Instanz kann nützlich sein, um einige kurzlebige Daten zu speichern (weil Daten
# auf einem Slave geschrieben wird leicht gelöscht werden nach resync mit dem Master), aber
# kann auch Probleme verursachen, wenn Clients darauf schreiben, weil
# Fehlkonfiguration.
#
# Seit Redis 2.6 sind Slaves standardmäßig schreibgeschützt.
#
# Hinweis: Nur-Lese-Slaves sind nicht dafür ausgelegt, nicht vertrauenswürdigen Clients ausgesetzt zu werden
# im Internet. Es ist lediglich eine Schutzschicht gegen Missbrauch der Instanz.
# Ein schreibgeschützter Slave exportiert standardmäßig alle administrativen Befehle
# wie CONFIG, DEBUG, und so weiter. In begrenztem Umfang können Sie verbessern
# Sicherheit von Read-Only-Slaves mit dem Befehl 'rename-command' zum Überschatten aller
# administrative / gefährliche Befehle.
Slave-Nur-Lesen ja

# Replikations-SYNC-Strategie: Festplatte oder Socket.
#
# -------------------------------------------------------
# WARNUNG: DIE REPLIKATION OHNE FESTPLATTE IST DERZEIT EXPERIMENTELL
# -------------------------------------------------------
#
# Neue Slaves und erneutes Verbinden von Slaves, die die Replikation nicht fortsetzen können
# Prozess nur Unterschiede empfangen, müssen tun, was eine sogenannte "voll
# Synchronisierung". Eine RDB-Datei wird vom Master an die Slaves übertragen.
# Die Übertragung kann auf zwei verschiedene Arten erfolgen:
#
# 1) Disk-backed: Der Redis-Master erstellt einen neuen Prozess, der den RDB schreibt
# Datei auf der Festplatte. Später wird die Datei vom übergeordneten
# den Prozess schrittweise an die Slaves weitergeben.
# 2) Diskless: Der Redis-Master erstellt einen neuen Prozess, der direkt die
# RDB-Datei zu Slave-Sockets, ohne die Festplatte überhaupt zu berühren.
#
# Bei der disk-backed Replication werden während der Generierung der RDB-Datei weitere Slaves
# kann in die Warteschlange gestellt und mit der RDB-Datei bedient werden, sobald das aktuelle Kind
# die RDB-Datei beendet ihre Arbeit. Bei der diskless Replikation statt einmal
# der Transfer beginnt, neu ankommende Slaves werden in die Warteschlange gestellt und ein neuer Transfer
# wird gestartet, wenn das aktuelle beendet wird.
#
# Bei Verwendung der festplattenlosen Replikation wartet der Master eine konfigurierbare Zeitspanne von
# Zeit (in Sekunden) vor dem Start der Übertragung in der Hoffnung, dass mehrere Slaves
# wird eintreffen und die Übertragung kann parallelisiert werden.
#
# Bei langsamen Festplatten und schnellen Netzwerken (mit großer Bandbreite) ist die Replikation ohne Festplatte möglich
# funktioniert besser.
repl-diskless-sync nein

# Wenn die plattenlose Replikation aktiviert ist, ist es möglich, die Verzögerung zu konfigurieren
# der Server wartet, um das Kind zu spawnen, das den RDB über den Socket überträgt
# an die Sklaven.
#
# Dies ist wichtig, da es nach Beginn der Übertragung nicht mehr möglich ist,
# neue Slaves kommen an, die für den nächsten RDB-Transfer in die Warteschlange gestellt werden, so dass der Server
# wartet eine Verzögerung, um weitere Slaves ankommen zu lassen.
#
# Die Verzögerung wird in Sekunden angegeben und beträgt standardmäßig 5 Sekunden. Zum Deaktivieren
# Stellen Sie es einfach vollständig auf 0 Sekunden ein und die Übertragung beginnt so schnell wie möglich.
repl-festplattenlose-Synchronisierungsverzögerung 5

# Slaves senden PINGs an den Server in einem vordefinierten Intervall. Es ist möglich,
# dieses Intervall mit der Option repl_ping_slave_period. Der Standardwert ist 10
# Sekunden.
#
# repl-ping-slave-periode 10

# Die folgende Option legt das Replikationstimeout fest für:
#
# 1) Massenübertragung von E/A während SYNC aus Sicht des Slaves.
# 2) Master-Timeout aus der Sicht der Slaves (Daten, Pings).
# 3) Slave-Timeout aus Sicht des Masters (REPLCONF ACK-Pings).
#
# Es ist wichtig sicherzustellen, dass dieser Wert größer ist als der Wert
# angegeben für repl-ping-slave-period, sonst wird ein Timeout erkannt
# jedes Mal, wenn zwischen dem Master und dem Slave wenig Verkehr herrscht.
#
# repl-timeout 60

# TCP_NODELAY auf dem Slave-Socket nach SYNC deaktivieren?
#
# Wenn Sie "ja" auswählen, verwendet Redis eine geringere Anzahl von TCP-Paketen und
# weniger Bandbreite zum Senden von Daten an Slaves. Dies kann jedoch zu einer Verzögerung führen für
# die Daten, die auf der Slave-Seite erscheinen sollen, bis zu 40 Millisekunden mit
# Linux-Kernel mit einer Standardkonfiguration.
#
# Wenn Sie „nein“ wählen, wird die Verzögerung bis zum Erscheinen der Daten auf der Slave-Seite
# reduziert werden, aber es wird mehr Bandbreite für die Replikation verwendet.
#
# Standardmäßig optimieren wir für geringe Latenz, aber bei sehr hohem Datenverkehr
# oder wenn Master und Slaves viele Hops voneinander entfernt sind, kann die Einstellung auf "yes"
# eine gute Idee sein.
repl-disable-tcp-nodelay nein

# Legen Sie die Größe des Replikationsrückstands fest. Der Rückstand ist ein Puffer, der
# Slave-Daten, wenn Slaves für einige Zeit getrennt sind, so dass, wenn ein Slave
# möchte sich erneut verbinden, oft ist keine vollständige Neusynchronisierung erforderlich, sondern eine teilweise
# Resync ist ausreichend, es wird nur der Teil der Daten weitergegeben, den der Slave verpasst hat, während
# getrennt.
#
# Je größer der Replikationsrückstand, desto länger kann der Slave
# getrennt und später in der Lage sein, eine teilweise Neusynchronisierung durchzuführen.
#
# Der Rückstand wird erst zugewiesen, wenn mindestens ein Slave angeschlossen ist.
#
# Repl-Backlog-Größe 1 MB

# Wenn ein Master für einige Zeit keine Slaves mehr angeschlossen hat, wird der Rückstand
# wird freigegeben. Die folgende Option konfiguriert die Anzahl der Sekunden, die
# muss ab dem Zeitpunkt der Trennung des letzten Slaves vergehen, für
# der freizugebende Backlog-Puffer.
#
# Ein Wert von 0 bedeutet, dass der Rückstand nie freigegeben wird.
#
# repl-backlog-ttl 3600

# Die Slave-Priorität ist eine von Redis in der INFO-Ausgabe veröffentlichte Ganzzahl.
# Es wird von Redis Sentinel verwendet, um einen Slave auszuwählen, der in einen
# Master, wenn der Master nicht mehr richtig funktioniert.
#
# Ein Slave mit einer niedrigen Prioritätsnummer wird als besser für die Beförderung angesehen, also
# Wenn es beispielsweise drei Slaves mit den Prioritäten 10, 100 und 25 gibt, wird Sentinel
# Wählen Sie die mit der niedrigsten Priorität 10.
#
# Eine spezielle Priorität von 0 kennzeichnet den Slave jedoch als nicht in der Lage, die
# Rolle des Masters, daher wird ein Slave mit Priorität 0 niemals ausgewählt von
# Redis Sentinel zur Beförderung.
#
# Standardmäßig beträgt die Priorität 100.
Slave-Priorität 100

# Es ist möglich, dass ein Master keine Schreibvorgänge mehr akzeptiert, wenn weniger als
# N Slaves verbunden, mit einer Verzögerung von weniger oder gleich M Sekunden.
#
# Die N Slaves müssen sich im Zustand „online“ befinden.
#
# Die Verzögerung in Sekunden, die <= dem angegebenen Wert sein muss, wird berechnet aus
# der letzte vom Slave empfangene Ping, der normalerweise jede Sekunde gesendet wird.
#
# Diese Option GARANTIERT nicht, dass N Replikate den Schreibvorgang akzeptieren, aber
# begrenzt das Zeitfenster für verlorene Schreibvorgänge, falls nicht genügend Slaves vorhanden sind
# sind für die angegebene Anzahl von Sekunden verfügbar.
#
# Um beispielsweise mindestens 3 Slaves mit einer Verzögerung <= 10 Sekunden anzufordern, verwenden Sie:
#
# min-Slaves zum Schreiben 3
# min-Slaves-max-Lag 10
#
# Wenn Sie das eine oder das andere auf 0 setzen, wird die Funktion deaktiviert.
#
# Standardmäßig ist min-slaves-to-write auf 0 gesetzt (Funktion deaktiviert) und
# min-slaves-max-lag ist auf 10 eingestellt.

########################################### SICHERHEIT #####################################

# Fordern Sie Clients auf, AUTH <PASSWORD> auszugeben, bevor Sie andere
# Befehle. Dies kann in Umgebungen nützlich sein, in denen Sie nicht vertrauen
# andere mit Zugriff auf den Host, auf dem der Redis-Server läuft.
#
# Dies sollte aus Gründen der Abwärtskompatibilität auskommentiert bleiben und weil die meisten
# Leute brauchen keine Authentifizierung (z. B. betreiben sie ihre eigenen Server).
#
# Warnung: Da Redis ziemlich schnell ist, kann ein externer Benutzer bis zu
# 150k Passwörter pro Sekunde gegen eine gute Box. Das bedeutet, dass Sie
# Verwenden Sie ein sehr sicheres Passwort, da es sonst sehr leicht zu knacken ist.
#
requirepass myRedis

# Befehlsumbenennung.
#
# Es ist möglich, den Namen gefährlicher Befehle in einem gemeinsam genutzten
# Umgebung. Beispielsweise kann der Befehl CONFIG in etwas umbenannt werden
# schwer zu erraten, damit es weiterhin für Tools zur internen Verwendung verfügbar ist
# aber nicht für allgemeine Kunden verfügbar.
#
# Beispiel:
#
# Umbenennungsbefehl CONFIG b840fc02d524045429941cc15f59e41cb7be6c52
#
# Es ist auch möglich, einen Befehl vollständig zu beenden, indem man ihn umbenennt in
# eine leere Zeichenfolge:
#
# Umbenennungsbefehl CONFIG ""
#
# Bitte beachten Sie, dass die Änderung des Namens von Befehlen, die in das
# AOF-Datei oder die Übertragung an Slaves kann Probleme verursachen.

########################################### GRENZEN #######################################

# Legen Sie die maximale Anzahl gleichzeitig verbundener Clients fest. Standardmäßig
# dieses Limit ist auf 10000 Clients festgelegt, wenn der Redis-Server jedoch nicht
# Kann das Prozessdateilimit so konfigurieren, dass das angegebene Limit zulässig ist
# die maximale Anzahl zulässiger Clients wird auf das aktuelle Dateilimit festgelegt
# minus 32 (da Redis einige Datei-Deskriptoren für interne Zwecke reserviert).
#
# Sobald das Limit erreicht ist, schließt Redis alle neuen Verbindungen und sendet
# ein Fehler „Maximale Anzahl an Clients erreicht“.
#
Anzahl der Clients: 10000

# Verwenden Sie nicht mehr Speicher als die angegebene Anzahl an Bytes.
# Wenn das Speicherlimit erreicht ist, versucht Redis, Schlüssel zu entfernen
# entsprechend der ausgewählten Räumungsrichtlinie (siehe Maxmemory-Policy).
#
# Wenn Redis Schlüssel nicht gemäß der Richtlinie entfernen kann oder wenn die Richtlinie
# auf „noeviction“ gesetzt, Redis beginnt, auf Befehle mit Fehlern zu antworten
# die mehr Speicher verbrauchen, wie SET, LPUSH usw., und werden fortgesetzt
# um auf schreibgeschützte Befehle wie GET zu antworten.
#
# Diese Option ist normalerweise nützlich, wenn Redis als LRU-Cache verwendet wird oder um
# ein festes Speicherlimit für eine Instanz (unter Verwendung der Richtlinie „Noeviction“).
#
# ACHTUNG: Wenn Sie Slaves an eine Instanz mit aktiviertem MaxMemory angeschlossen haben,
# die Größe der Ausgabepuffer, die zur Versorgung der Slaves benötigt werden, wird abgezogen
# vom verwendeten Speicherzähler, so dass Netzwerkprobleme / Resyncs
# löst keine Schleife aus, in der Schlüssel verdrängt werden, und die Ausgabe
# Der Puffer der Slaves ist voll mit DELs von Schlüsseln, die aussortiert wurden und die Löschung auslösen
Anzahl weiterer Schlüssel usw., bis die Datenbank vollständig geleert ist.
#
# Kurz gesagt... wenn Sie Slaves angeschlossen haben, wird empfohlen, dass Sie einen niedrigeren
# Limit für maximalen Speicher, damit auf dem System etwas freier RAM für den Slave vorhanden ist
# Ausgabepuffer (dies ist jedoch nicht erforderlich, wenn die Richtlinie „noeviction“ ist).
#
# maxmemory <bytes>

# MAXMEMORY POLICY: Wie Redis auswählt, was entfernt werden soll, wenn maxmemory
# ist erreicht. Sie können zwischen fünf Verhaltensweisen wählen:
#
# volatile-lru -> Entfernen Sie den Schlüssel mit einem Ablaufsatz mithilfe eines LRU-Algorithmus
# allkeys-lru -> entfernt alle Schlüssel gemäß dem LRU-Algorithmus
# volatile-random -> Entfernt einen zufälligen Schlüssel mit einem Ablaufdatum
# allkeys-random -> Entfernt einen zufälligen Schlüssel, einen beliebigen Schlüssel
# volatile-ttl -> entferne den Schlüssel mit der nächsten Ablaufzeit (minor TTL)
# noeviction -> läuft überhaupt nicht ab, gibt nur einen Fehler bei Schreibvorgängen zurück
#
# Hinweis: Bei jeder der oben genannten Richtlinien gibt Redis beim Schreiben einen Fehler zurück
# Operationen, wenn keine passenden Schlüssel zum Räumungsvorgang vorhanden sind.
#
# Zum Zeitpunkt des Schreibens sind dies die Befehle: set setnx setex append
# incr decr rpush lpush rpushx lpushx linsert lset rpoplpush sadd
# sintern sinternstore sunion sunionstore sdiff sdiffstore zadd zincrby
# zunionstore zinterstore hset hsetnx hmset hincrby incrby decrby
# getset mset msetnx exec sort
#
# Der Standardwert ist:
#
# maxmemory-policy keine Räumung

# LRU- und minimale TTL-Algorithmen sind keine präzisen Algorithmen, sondern angenäherte
# Algorithmen (um Speicher zu sparen), so dass Sie es auf Geschwindigkeit abstimmen können oder
# Genauigkeit. Standardmäßig überprüft Redis fünf Schlüssel und wählt den aus, der
# weniger häufig verwendet, können Sie die Stichprobengröße mit den folgenden
# Konfigurationsdirektive.
#
# Der Standardwert 5 liefert ausreichend gute Ergebnisse. 10 Kommt sehr nahe
# echtes LRU, kostet aber etwas mehr CPU. 3 ist sehr schnell, aber nicht sehr genau.
#
# maxmemory-samples 5

##################################### NUR ANHÄNGEN-MODUS ###################################

# Standardmäßig speichert Redis den Datensatz asynchron auf der Festplatte. Dieser Modus ist
# gut genug in vielen Anwendungen, aber ein Problem mit dem Redis-Prozess oder
# ein Stromausfall kann zu einem Verlust von einigen Minuten an Schreibvorgängen führen (abhängig von
# die konfigurierten Speicherpunkte).
#
# Der Append Only File-Modus ist ein alternativer Persistenzmodus, der
# viel bessere Haltbarkeit. Beispielsweise durch Verwendung der Standard-Daten-Fsync-Richtlinie
# (siehe weiter unten in der Konfigurationsdatei) Redis kann nur eine Sekunde an Schreibvorgängen verlieren in einem
# dramatisches Ereignis wie ein Server-Stromausfall oder ein einzelner Schreibvorgang, wenn etwas
# Fehler beim Redis-Prozess selbst, aber das Betriebssystem ist
# läuft immer noch ordnungsgemäß.
#
# AOF- und RDB-Persistenz können problemlos gleichzeitig aktiviert werden.
# Wenn die AOF aktiviert ist, lädt Redis beim Start die AOF, also die Datei
# mit den besseren Haltbarkeitsgarantien.
#
# Weitere Informationen finden Sie unter http://redis.io/topics/persistence.

nur anhängen nein

# Der Name der Nur-Anhängen-Datei (Standard: „appendonly.aof“)

Anhängedateiname „appendonly.aof“

# Der Aufruf von fsync() weist das Betriebssystem an, tatsächlich Daten auf die Festplatte zu schreiben
# anstatt auf weitere Daten im Ausgabepuffer zu warten. Einige Betriebssysteme werden wirklich
# Daten auf der Festplatte, einige andere Betriebssysteme versuchen es einfach so schnell wie möglich.
#
# Redis unterstützt drei verschiedene Modi:
#
# nein: kein fsync, lassen Sie das Betriebssystem die Daten einfach löschen, wenn es das möchte. Schneller.
# immer: fsync nach jedem Schreiben in das Nur-Anhängen-Protokoll. Langsam, am sichersten.
# everysec: fsync nur einmal pro Sekunde. Kompromiss.
#
# Der Standardwert ist "everysec", da dies normalerweise der richtige Kompromiss zwischen
# Geschwindigkeit und Datensicherheit. Es liegt an Ihnen, zu verstehen, ob Sie dies entspannen können, um
# „nein“, damit das Betriebssystem den Ausgabepuffer leeren kann, wenn
# es will, für bessere Leistungen (aber wenn Sie mit der Idee leben können,
# einige Datenverluste (berücksichtigen Sie den Standard-Persistenzmodus, d. h. Snapshots),
# oder im Gegenteil, verwenden Sie "immer", das ist sehr langsam, aber ein bisschen sicherer als
# jede Sekunde.
#
# Weitere Einzelheiten finden Sie im folgenden Artikel:
# http://antirez.com/post/redis-persistence-demystified.html
#
# Wenn Sie unsicher sind, verwenden Sie „everysec“.

# appendfsync immer
appendfsync jede Sekunde
# appendfsync nein

# Wenn die AOF-Fsync-Richtlinie auf „immer“ oder „jede Sekunde“ eingestellt ist und ein Hintergrund
# Der Speichervorgang (eine Hintergrundspeicherung oder eine Neuschreibung des AOF-Protokolls im Hintergrund) ist
# in einigen Linux-Konfigurationen viele I/O-Vorgänge auf der Festplatte ausführen
# Redis blockiert möglicherweise zu lange den fsync()-Aufruf. Beachten Sie, dass es keinen Fix für
# dies derzeit, da sogar die Ausführung von fsync in einem anderen Thread blockiert
# unser synchroner write(2)-Aufruf.
#
# Um dieses Problem zu mildern, ist es möglich, die folgende Option zu verwenden
# Dadurch wird verhindert, dass fsync() im Hauptprozess aufgerufen wird, während
# BGSAVE oder BGREWRITEAOF wird ausgeführt.
#
# Das bedeutet, dass während ein anderes Kind speichert, die Haltbarkeit von Redis
# das gleiche wie "appendfsync none". In der Praxis bedeutet dies, dass es
# Im schlimmsten Fall können bis zu 30 Sekunden des Logs verloren gehen (mit der
# Standard-Linux-Einstellungen).
#
# Wenn Sie Latenzprobleme haben, setzen Sie dies auf "Ja". Andernfalls lassen Sie es so
# „nein“, das ist vom Standpunkt der Haltbarkeit aus die sicherste Wahl.

kein-appendfsync-on-rewrite nein

# Automatisches Neuschreiben der Nur-Anhängen-Datei.
# Redis kann die Protokolldatei automatisch neu schreiben, indem es implizit aufruft
# BGREWRITEAOF, wenn die AOF-Protokollgröße um den angegebenen Prozentsatz wächst.
#
# So funktioniert es: Redis merkt sich die Größe der AOF-Datei nach dem
# letztes Umschreiben (wenn seit dem Neustart kein Umschreiben stattgefunden hat, die Größe von
# die AOF beim Start wird verwendet).
#
# Diese Basisgröße wird mit der aktuellen Größe verglichen. Wenn die aktuelle Größe
# größer als der angegebene Prozentsatz, wird das Umschreiben ausgelöst. Außerdem
# Sie müssen eine Mindestgröße für die neu zu schreibende AOF-Datei angeben.
# ist nützlich, um ein erneutes Schreiben der AOF-Datei zu vermeiden, selbst wenn der prozentuale Anstieg
# ist erreicht, aber immer noch ziemlich klein.
#
# Geben Sie einen Prozentsatz von Null an, um die automatische AOF zu deaktivieren
# Umschreibfunktion.

automatischer Aof-Umschreibprozentsatz 100
Auto-Aof-Rewrite – Mindestgröße 64 MB

# Eine AOF-Datei kann am Ende während des Redis abgeschnitten werden
# Startvorgang, wenn die AOF-Daten wieder in den Speicher geladen werden.
# Dies kann passieren, wenn das System, auf dem Redis läuft
# stürzt ab, insbesondere wenn ein ext4-Dateisystem ohne die
# data=ordered Option (das kann jedoch nicht passieren, wenn Redis selbst
# stürzt ab oder wird abgebrochen, aber das Betriebssystem funktioniert weiterhin ordnungsgemäß).
#
# Redis kann entweder mit einem Fehler beendet werden, wenn dies geschieht, oder so viel laden
# Daten wie möglich (derzeit Standard) und starten, wenn die AOF-Datei gefunden wird
# am Ende abgeschnitten werden. Die folgende Option steuert dieses Verhalten.
#
# Wenn aof-load-truncated auf yes gesetzt ist, wird eine gekürzte AOF-Datei geladen und
# Der Redis-Server beginnt mit der Ausgabe eines Protokolls, um den Benutzer über das Ereignis zu informieren.
# Andernfalls, wenn die Option auf Nein gesetzt ist, bricht der Server mit einem Fehler ab
# und weigert sich zu starten. Wenn die Option auf Nein gesetzt ist, benötigt der Benutzer
# um die AOF-Datei mit dem Dienstprogramm "redis-check-aof" zu reparieren, bevor Sie neu starten
# der Server.
#
# Beachten Sie, dass, wenn die AOF-Datei in der Mitte beschädigt wird
# der Server wird trotzdem mit einem Fehler beendet. Diese Option gilt nur, wenn
# Redis wird versuchen, mehr Daten aus der AOF-Datei zu lesen, aber nicht genügend Bytes
# wird gefunden.
aof-load-truncated ja

####################################### LUA-SKRIPTIEREN ###################################

# Maximale Ausführungszeit eines Lua-Skripts in Millisekunden.
#
# Wenn die maximale Ausführungszeit erreicht ist, protokolliert Redis, dass ein Skript
# wird nach Ablauf der maximal zulässigen Zeit immer noch ausgeführt und beginnt
# auf Anfragen mit einem Fehler antworten.
#
# Wenn ein lang laufendes Skript die maximale Ausführungszeit überschreitet, wird nur die
# SCRIPT KILL und SHUTDOWN NOSAVE Befehle sind verfügbar. Der erste kann
# wird verwendet, um ein Skript zu stoppen, das noch keine Schreibbefehle aufgerufen hat. Die zweite
# ist die einzige Möglichkeit den Server herunterzufahren, falls ein Schreibbefehl
# bereits vom Skript ausgegeben, aber der Benutzer möchte nicht auf die natürliche
# Beendigung des Skripts.
#
# Setzen Sie es auf 0 oder einen negativen Wert für eine unbegrenzte Ausführung ohne Warnungen.
Lua-Zeitlimit 5000

######################################## REDIS-CLUSTER #####################################
#
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# Warning Experimental: Redis Cluster wird jedoch als stabiler Code angesehen
# Um es als "reif" zu markieren, müssen wir auf einen nicht trivialen Prozentsatz warten
Anzahl der Benutzer, um es in der Produktion bereitzustellen.
# +++++++++++++++++++++++++++++++++++++++++++++++++++++++ --+ --+ --+ - --++++ - - --+++ -
#
# Normale Redis-Instanzen können nicht Teil eines Redis-Clusters sein; nur Knoten, die
# gestartet werden, wie Clusterknoten können. Um eine Redis-Instanz als
# Clusterknoten aktiviert die Clusterunterstützung, indem er das Folgende auskommentiert:
#
# Cluster-fähig Ja

# Jeder Clusterknoten hat eine Clusterkonfigurationsdatei. Diese Datei ist nicht
# soll manuell bearbeitet werden. Es wird von Redis-Knoten erstellt und aktualisiert.
# Jeder Redis-Clusterknoten erfordert eine andere Clusterkonfigurationsdatei.
# Stellen Sie sicher, dass Instanzen, die im selben System laufen, nicht
# Überlappende Clusterkonfigurationsdateinamen.
#
# Cluster-Config-File-Knoten-6379.Conf

# Das Clusterknoten-Timeout ist die Anzahl der Millisekunden, die ein Knoten nicht erreichbar sein muss
# damit es als Fehlerzustand betrachtet wird.
# Die meisten anderen internen Zeitlimits sind ein Vielfaches des Knoten-Timeouts.
#
# Cluster-Node-Timeout 15000

# Ein Sklave eines fehlerhaften Meisters vermeiden es, ein Failover bei seinen Daten zu starten
# Sieht zu alt aus.
#
# Es gibt keine einfache Möglichkeit für einen Sklaven, tatsächlich ein genaues Maß an zu haben
# Sein "Datenalter", sodass die folgenden zwei Überprüfungen durchgeführt werden:
#
# 1) Wenn mehrere Sklaven failover sind, tauschen sie Nachrichten aus
# Um zu versuchen, dem Sklaven mit den Besten einen Vorteil zu verschaffen
# Replikationsversatz (mehr Daten aus dem Master -Verarbeiteten).
# Sklaven versuchen, ihren Rang nach Offset zu erhalten und sich für den Start zu bewerben
Anzahl der Failover eine Verzögerung proportional zu ihrem Rang.
#
# 2) Jeder einzelne Sklave berechnet die Zeit der letzten Interaktion mit
# Sein Meister. Dies kann der letzte Ping oder Befehl sein (wenn der Meister
# befindet sich immer noch im Status "verbunden") oder der Zeit, die seit dem verstrichen ist
# Trennung mit dem Master (wenn der Replikationsverbindungslink derzeit ausgefallen ist).
# Wenn die letzte Interaktion zu alt ist, versucht der Sklave nicht zu failover
# überhaupt.
#
# Der Punkt "2" kann vom Benutzer eingestellt werden.
# Das Failover if seit der letzten Interaktion mit dem Meister die Zeit
# verstrichen ist größer als:
#
# (Knoten-Timeout * Slave-Vality-Faktor) + Repl-ping-Slave-Periode
#
# Also zum Beispiel, wenn der Knoten-Timeout 30 Sekunden und der Sklavenvaliditätsfaktor beträgt
# ist 10, und unter der Annahme eines Standard-Repl-Ping-Slave-Periods von 10 Sekunden ist die
# Slave wird nicht versuchen, zu fällen, wenn er nicht mit dem Meister sprechen konnte
# länger als 310 Sekunden.
#
# Ein großer Sklavenvaliditäts-Faktor kann Sklaven mit zu alten Daten zum Failover ermöglichen
# Ein Meister, obwohl ein zu kleiner Wert den Cluster daran hindert, dazu in der Lage zu sein
# Wählen Sie überhaupt einen Sklaven.
#
# Für die maximale Verfügbarkeit ist es möglich, den Sklavenvaliditätsfaktor einzustellen
# zu einem Wert von 0, was bedeutet, dass Sklaven immer versuchen, das zu failoveren
# Meister unabhängig von dem letzten Mal, als sie mit dem Meister interagierten.
# (Wie auch immer sie immer versuchen, eine Verzögerung proportional zu ihrer anzuwenden
# Offset -Rang).
#
# Null ist der einzige Wert, der garantieren kann, dass wenn alle Partitionen heilen
# Der Cluster kann immer weitermachen.
#
# Cluster-Slave-Vality-Faktor 10

# Cluster -Sklaven können zu verwaisten Meistern migrieren, die Meister sind
#, die ohne Sklaven arbeiten. Dies verbessert die Cluster -Fähigkeit
# Misserfolge widerstehen, da sonst ein verwaster Meister nicht fehlgeschlagen werden kann
# Im Falle eines Scheiterns, wenn es keine arbeitenden Sklaven hat.
#
# Sklaven migrieren nur dann zu verwaisten Meistern, wenn es noch mindestens a gibt
# Anzahl anderer arbeitender Sklaven für ihren alten Meister
# ist die "Migrationsbarriere".
# wird nur migrieren, wenn mindestens 1 andere arbeitende Sklave für seinen Meister vorhanden ist
# und so weiter.
# Master in deinem Cluster.
#
# Standard ist 1 (Sklaven migrieren nur, wenn ihre Meister zumindest bleiben
# Ein Sklave).
# Ein Wert von 0 kann festgelegt werden, ist jedoch nur zum Debuggen und gefährlich nützlich
# in der Produktion.
#
# Cluster-Migration-Barrier 1

# Standardmäßig reduzieren die Clusterknoten nicht mehr an die Annahme von Abfragen, wenn sie dort erkennen
# ist mindestens ein Hash -Slot aufgedeckt (kein verfügbarer Knoten serviert es).
# Auf diese Weise, wenn der Cluster teilweise sinkt (zum Beispiel eine Reihe von Hash -Slots
# sind nicht mehr abgedeckt) Der gesamte Cluster wird schließlich nicht verfügbar.
# Es kehrt automatisch zur Verfügung, sobald alle Slots wieder abgedeckt sind.
#
# Manchmal möchten Sie jedoch, dass die Teilmenge des Clusters funktioniert,
# Um weiterhin Fragen für den Teil des Schlüsselraums zu akzeptieren, der sich noch befindet
# bedeckt.
# Option zu nein.
#
# Cluster-Require-Ful-Deckung Ja

# Um Ihren Cluster einzurichten, lesen Sie sicher, dass Sie die Dokumentation lesen
# verfügbar auf der Website http://redis.io.

################################## SLOW LOG ###################################

# Das Redis Slow Log ist ein System zum Protokollieren von Abfragen, die eine angegebene überschritten haben
# Ausführungszeit.
# Wie mit dem Kunden zu sprechen, die Antwort zu senden und so weiter,
# Aber nur die Zeit, die erforderlich ist, um den Befehl tatsächlich auszuführen (dies ist die einzige
# Phase der Befehlsausführung, in der der Thread blockiert ist und nicht dienen kann
# Andere Anfragen in der Zwischenzeit).
#
# Sie können das langsame Protokoll mit zwei Parametern konfigurieren: einer sagt Redis
# Was ist die Ausführungszeit in Mikrosekunden, um für die zu übertreffen?
# Befehl, um protokolliert zu werden, und der andere Parameter ist die Länge der Länge der
# Langsames Protokoll.
# Warteschlange der angemeldeten Befehle.

# Die folgende Zeit wird in Mikrosekunden ausgedrückt, sodass 1000000 gleichwertig sind
# zu einer Sekunde. Beachten Sie, dass eine negative Zahl das langsame Protokoll deaktiviert, während
# Ein Wert von Null erzwingt die Protokollierung jedes Befehls.
slowlog-log-langsamer-als-10000

# Es gibt keine Begrenzung für diese Länge.
# Sie können den Speicher des Slow -Logs mit Slowlog Reset zurückerhalten.
slowlog-max-len 128

############################################################################################### zu erhalten

# Die Redis -Latenzüberwachungs -Subsystemproben unterscheiden unterschiedliche Operationen
# zur Laufzeit, um Daten im Zusammenhang mit möglichen Quellen von zu sammeln
# Latenz einer Redisinstanz.
#
# Über den Befehl latenz diese Informationen sind dem Benutzer verfügbar, der kann
# Diagramme drucken und Berichte erhalten.
#
# Das System protokolliert nur Operationen, die in einer Zeit gleich oder in einer Zeit durchgeführt wurden
# größer als die Menge an Millisekunden, die über die angegeben sind
# Konfigurationsrichtlinie für Latency-Monitor-Schwellenwert.
# Zu Null ist der Latenzmonitor ausgeschaltet.
#
# Standardmäßig ist die Überwachung der Latenz deaktiviert, da sie meistens nicht benötigt wird
# Wenn Sie keine Latenzprobleme haben und das Sammeln von Daten eine Leistung hat
# Auswirkungen, die sehr klein, aber unter großer Läden gemessen werden können
# Die Überwachung kann leicht zur Laufzeit über den Befehl aktiviert werden
|
Latenz-Monitor-Schwellenwert 0

#################################################################################################### zu erhalten

# Redis kann Pub/Sub -Clients über Ereignisse im Schlüsselbereich benachrichtigen.
# Diese Funktion ist unter http://redis.io/topics/notifications dokumentiert
#
# Zum Beispiel, wenn die Benachrichtigung über Schlüsselspace -Ereignisse aktiviert ist und ein Client
# führt eine Del -Operation auf dem Schlüssel "foo" durch, das in der Datenbank 0, zwei, gespeichert ist
# Nachrichten werden über Pub/Sub veröffentlicht:
#
# Veröffentlichen __keyspace@0 __: foo del
# Veröffentlichen __keyevent@0 __: Del Foo
#
# Es ist möglich, die Ereignisse auszuwählen, die Redis unter einem Satz benachrichtigt werden
Anzahl der Klassen.
#
# K Keyspace -Events, veröffentlicht mit __keyspace@<db> __ Präfix.
# E KeyEvent Events, veröffentlicht mit __keyevent@<db> __ Präfix.
# G Generische Befehle (nicht spezifisch) wie Del, Ablauf, umbenennen, ...
# $ String -Befehle
# Befehle auflisten
# s Befehle festlegen
# H Hash -Befehle
# Z sortierte Set -Befehle
# x abgelaufene Ereignisse (Ereignisse, die jedes Mal erzeugt werden, wenn ein Schlüssel abläuft)
# E Event Ereignisse (Ereignisse, die generiert werden, wenn ein Schlüssel für MaxMemory vertrieben wird)
# Ein Alias ​​für G $ lshzxe, so dass die "Ake" -Skette alle Ereignisse bedeutet.
#
# Die "Notify-Keyspace-Events" nimmt als Argument eine String, die komponiert ist
# null oder mehrere Zeichen.
# sind deaktiviert.
#
# Beispiel: Aus dem Gesichtspunkt der Sicht des
# Ereignisname, Verwendung:
#
# Notify-Keyspace-Events Elg
#
# Beispiel 2: Um den Stream der abgelaufenen Schlüssel zu Kanal abonnieren zu lassen
# Name __keyevent@0 __: Abgelaufene Verwendung:
#
# Notify-Keyspace-Events ex
#
# Standardmäßig sind alle Benachrichtigungen deaktiviert, da die meisten Benutzer keine benötigen
# Diese Funktion und die Funktion haben einen Overhead.
# Geben Sie mindestens eines von K oder E an, es werden keine Veranstaltungen übermittelt.
Benachrichtigung über Keyspace-Ereignisse ""

######################################################################################################## zu erhalten

# Hashes werden unter Verwendung einer Speicher -effizienten Datenstruktur codiert, wenn sie a haben
# Eine kleine Anzahl von Einträgen, und der größte Eintrag überschreitet keine gegebene
# Schwellenwert.
Hash-Max-Ziplist-Einträge 512
Hash-Max-Ziplist-Wert 64

# Listen werden auch auf besondere Weise codiert, um viel Platz zu sparen.
# Die Anzahl der zulässigen Einträge pro interner Listenknoten kann angegeben werden
# als feste maximale Größe oder maximale Anzahl von Elementen.
# Verwenden Sie für eine feste maximale Größe -5 bis -1, was bedeutet:
# -5: Maximale Größe: 64 kb <-für normale Workloads nicht empfohlen
# -4: Maximale Größe: 32 KB <-Nicht empfohlen
# -3: Maximale Größe: 16 kb <-wahrscheinlich nicht empfohlen
# -2: maximale Größe: 8 kb <-gut
# -1: maximale Größe: 4 kb <-gut
# Positive Zahlen bedeuten, bis zu _exactly_ diese Anzahl von Elementen zu speichern
# pro Listenknoten.
# Die Option mit der höchsten Leistung beträgt normalerweise -2 (8 kb) oder -1 (4 kb).
# Wenn Ihr Anwendungsfall jedoch eindeutig ist, passen Sie die Einstellungen nach Bedarf an.
Liste-max-Ziplist-Größe -2

# Listen können auch komprimiert werden.
# Die Komprimierungstiefe ist die Anzahl der Quicklist -Ziplist -Knoten von * jeweils * Seite von
# Die Liste, die * von der Komprimierung ausgeschlossen werden soll.
# sind immer unkomprimiert für schnelle Push/Pop -Operationen.
# 0: Deaktivieren Sie alle Listenkomprimierung
Nr. 1: Tiefe 1 bedeutet "Starten Sie erst nach 1 Knoten in die Liste.
# vom Kopf oder Schwanz gehen "
# So: [Kopf]-> Knoten-> Knoten-> ...-> Knoten-> [Schwanz]
# [Kopf], [Schwanz] wird immer unkomprimiert sein;
# 2: [Kopf]-> [Weiter]-> Knoten-> Knoten-> ...-> Knoten-> [prev]-> [Schwanz]
# 2 hier bedeutet: weder Kopf noch Kopf-> Weiter oder Schwanz-> vorher oder schwanz,
# Aber komprimieren Sie alle Knoten zwischen ihnen.
# 3: [Head]-> [Weiter]-> [Weiter]-> Knoten-> Knoten-> ...-> Knoten-> [prep]-> [prep]-> [schwanz]
# usw.
Listenkomprimierungstiefe 0

# Sets haben in nur einem Fall eine spezielle Codierung: Wenn ein Satz komponiert ist
Anzahl der nur Zapfen, die zufällig Ganzzahlen in Radix 10 im Bereich sind
64 Bit signierte ganze Zahlen.
# Die folgende Konfigurationseinstellung legt die Grenze in der Größe des
# Setzen Sie, um diese spezielle Speicherspeichercodierung zu verwenden.
set-max-intset-einträge 512

# Ähnlich wie Hashes und Listen sind sortierte Sets speziell in speziell codiert in
# Um viel Platz zu sparen.
# Elemente eines sortierten Satzes liegen unter den folgenden Grenzen:
zset-max-ziplist-einträge 128
zset-max-ziplist-wert 64

# Hyperloglog -Sparse -Repräsentation Bytes Grenze.
# 16 Bytes -Header.
# Diese Grenze wird in die dichte Darstellung umgewandelt.
#
# Ein Wert von mehr als 16000 ist völlig nutzlos, da zu diesem Zeitpunkt die
# Dichte Darstellung ist speichereffizienter.
#
# Der empfohlene Wert beträgt ~ 3000, um die Vorteile von zu haben
# Die räumliche effiziente Codierung, ohne zu viel zu verlangsamen, PFADD,
#, was O (n) mit der spärlichen Kodierung ist.
# ~ 10000, wenn CPU kein Problem ist, aber Platz ist und der Datensatz ist
# besteht aus vielen Hyperloglogs mit Kardinalität im Bereich von 0 - 15000.
hll-sparse-max-bytes 3000

# Active Ro aufnutzt 1 Millisekunden alle 100 Millisekunden CPU -Zeit in
# Um die RED-RED-REDIS-Hash-Tabelle zu reservieren (die One-Mapping-Top-Ebene
# Schlüssel zu Werten).
# führt eine faule Wiederholung durch: Je mehr Betrieb Sie in einen Hash -Tisch treffen
# Das ist das Aufholen, desto mehr Wiederaufnahmen "Schritte" werden durchgeführt.
# Server ist im Leerlauf. Die Wiederholung ist nie vollständig und es wird ein weiterer Speicher verwendet
# durch die Hash -Tabelle.
#
# Die Standardeinstellung besteht darin, diese Millisekunde pro Sekunde 10 Mal zu verwenden, um zu
# Die wichtigsten Wörterbücher aktiv aufbauen und nach Möglichkeit den Gedächtnis befreien.
#
# Wenn unsicher:
# Verwenden Sie "ActiveReHashing No", wenn Sie harte Latenzanforderungen haben und dies ist
# Keine gute Sache in Ihrer Umgebung, die Redis von Zeit zu Zeit antworten kann
# Anfragen mit 2 Millisekundenverzögerung.
#
# Verwenden Sie "ActiveReHashing Ja", wenn Sie aber keine so schwierigen Anforderungen haben
# Ich möchte den Speicher so schnell wie möglich freigeben.
aktives Aufwärmen ja

# Die Grenzwerte für Client -Ausgangspuffer können verwendet werden, um die Trennung von Clients zu erzwingen
#, die aus irgendeinem Grund keine Daten vom Server schnell genug lesen (a
# Häufiger Grund ist, dass ein Pub/Sub -Client Nachrichten nicht so schnell konsumieren kann wie die
# Publisher kann sie produzieren).
#
# Die Grenze kann für die drei verschiedenen Klassen von Kunden unterschiedlich festgelegt werden:
#
# Normal -> Normale Clients einschließlich Monitor -Clients
# Slave -> Sklavenkunden
# PubSub -> Clients, die mindestens einen Pubsub -Kanal oder ein Muster abonniert haben
#
# Die Syntax jeder Client-Output-Buffer-Limit-Direktive ist die folgende:
#
# Client-Output-Buffer-limit <klasse> <hartlimit> <Soft Limit> <Soft Sekunden>
#
# Ein Kunde wird sofort getrennt, sobald die Hardgrenze erreicht ist oder ob
# Die Softgrenze wird erreicht und bleibt für die angegebene Anzahl von erreicht
# Sekunden (kontinuierlich).
# Zum Beispiel, wenn die Hardgrenze 32 Megabyte beträgt und die Softgrenze ist
# 16 Megabyte / 10 Sekunden, wird der Kunde sofort getrennt
# Wenn die Größe der Ausgangspuffer 32 Megabyte erreicht, wird aber auch erhalten
# getrennt, wenn der Kunde 16 Megabyte erreicht und kontinuierlich überwindet
# Die Grenze für 10 Sekunden.
#
# Standardmäßig sind normale Clients nicht begrenzt, da sie keine Daten erhalten
# ohne zu fragen (auf Push), aber kurz nach einer Anfrage, also nur
# Asynchrone Clients können ein Szenario erstellen, in dem Daten schneller angefordert werden
# als es lesen kann.
#
# Stattdessen gibt es ein Standardlimit für PubSub- und Slave -Clients, da seitdem
# Abonnenten und Sklaven empfangen Daten in einer Push -Mode.
#
# Sowohl das harte als auch das Softgrenze kann deaktiviert werden, indem sie auf Null gesetzt werden.
Client-Ausgabepufferlimit normal 0 0 0
Client-Ausgabepufferlimit Slave 256 MB 64 MB 60
Client-Ausgabepufferlimit Pubsub 32 MB 8 MB 60

# Redis ruft eine interne Funktion auf, um viele Hintergrundaufgaben auszuführen, wie wie
# Schließen von Kunden in Timeout und abgelaufene Schlüsseln spülen
# nie angefordert und so weiter.
#
# Nicht alle Aufgaben werden mit der gleichen Frequenz ausgeführt, aber Redis prüft
# Aufgaben, die nach dem angegebenen "Hz" -Wert ausgeführt werden sollen.
#
# Standardmäßig wird "Hz" auf 10 gesetzt. Die Erhöhung des Wertes wird mehr CPU verwendet, wenn
# Redis ist untätig, aber gleichzeitig wird Redis stärker reagiert, wenn
# Es gibt viele Schlüssel, die zur gleichen Zeit abläuft, und Zeitüberschreitungen können sein
# mit mehr Präzision behandelt.
#
# Der Bereich liegt zwischen 1 und 500, ein Wert über 100 ist jedoch normalerweise nicht
# Eine gute Idee.
# 100 nur in Umgebungen, in denen eine sehr geringe Latenz erforderlich ist.
Hz 10

# Wenn ein Kind die AOF -Datei umschreibt, wenn die folgende Option aktiviert ist
# Die Datei wird alle 32 MB Daten generiert
# um die Datei inkrementeller an die Festplatte zu verpflichten und zu vermeiden
# große Latenzspikes.
aof-rewrite-inkrementell-fsync ja