Detaillierte Schritte zur Installation von Tomcat, MySQL und Redis mit Docker

Docker-Suche Tomcat 

Docker zieht Tomcat

docker run -it -p 8080:8080 Tomcat

Docker-Pull MySQL:5.6

docker run -p 12345:3306 --name mysql -v /zzyyuse/mysql/conf:/etc/mysql/conf.d -v /zzyyuse/mysql/logs:/logs -v /zzyyuse/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.6
 
Befehlserklärung:
-p 12345:3306: Ordnet den Port 12345 des Hosts dem Port 3306 des Docker-Containers zu.
--name mysql: Dienstname ausführen -v /zzyyuse/mysql/conf:/etc/mysql/conf.d: conf/my.cnf im Hostverzeichnis /zzyyuse/mysql in die Datei /etc/mysql/conf.d des Containers einhängen
-v /zzyyuse/mysql/logs:/logs: Mounten Sie das Verzeichnis „logs“ unter dem Hostverzeichnis /zzyyuse/mysql in den Ordner /logs des Containers.
-v /zzyyuse/mysql/data:/var/lib/mysql: mounten Sie das Datenverzeichnis unter dem Hostverzeichnis /zzyyuse/mysql in das Verzeichnis /var/lib/mysql des Containers. 
-e MYSQL_ROOT_PASSWORD=123456: Initialisiert das Passwort des Root-Benutzers.
-d mysql:5.6 : Das Hintergrundprogramm führt mysql5.6 aus

docker exec -it MySQL-Container-ID nach erfolgreichem Vorgang /bin/bash 

Docker exec MySQL-Dienstcontainer-ID sh -c ' exec mysqldump --all-databases -uroot -p"123456" ' > /zzyyuse/all-databases.sql

docker run -p 6379:6379 -v /zzyyuse/myredis/data:/data -v /zzyyuse/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf -d redis:3.2 redis-server /usr/local/etc/redis/redis.conf --appendonly yes 

vim /zzyyuse/myredis/conf/redis.conf

# 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.
#daemonisieren 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 120 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.
 
# Ein Redis-Master kann die Adresse und den Port des angeschlossenen
# Slaves auf unterschiedliche Weise. Zum Beispiel der Abschnitt "INFO Replikation"
# bietet diese Informationen an. Sie werden unter anderem genutzt von
# Redis Sentinel, um Slave-Instanzen zu entdecken.
# Ein weiterer Ort, an dem diese Informationen verfügbar sind, ist die Ausgabe des
# „ROLE“-Befehl eines Masters.
#
# Die aufgelistete IP und Adresse, die normalerweise von einem Slave gemeldet wird, wird abgerufen
# folgendermaßen:
#
# IP: Die Adresse wird automatisch durch Überprüfung der Peer-Adresse erkannt
# des Sockets, der vom Slave zur Verbindung mit dem Master verwendet wird.
#
# Port: Der Port wird vom Slave während der Replikation mitgeteilt
# Handshake und ist normalerweise der Port, den der Slave verwendet, um
# Liste für Verbindungen.
#
# Wenn jedoch Portweiterleitung oder Network Address Translation (NAT)
# verwendet, der Slave kann tatsächlich über eine andere IP und einen anderen Port erreichbar sein
# Paare. Die folgenden beiden Optionen können von einem Slave verwendet werden, um
# meldet seinem Master einen bestimmten Satz von IP und Port, so dass sowohl INFO
# und ROLE melden diese Werte.
#
# Es ist nicht notwendig, beide Optionen zu verwenden, wenn Sie nur
# der Port oder die IP-Adresse.
#
# Slave-Announce-IP 5.5.5.5
# Slave-Ankündigungs-Port 1234
 
########################################### 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 foobared
 
# 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 #####################################
#
# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
# WARNUNG EXPERIMENTELL: Redis Cluster wird als stabiler Code angesehen, jedoch
# um es als "reif" zu markieren, müssen wir auf einen nicht unerheblichen 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.
#
# Clusterkonfigurationsdatei nodes-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.
#
# Clusterknoten-Timeout 15000
 
# Ein Slave eines ausgefallenen Masters vermeidet den Start eines Failovers, wenn seine Daten
# sieht zu alt aus.
#
# Es gibt keine einfache Möglichkeit für einen Sklaven, tatsächlich eine genaue Messung zu haben
# sein „Datenalter“, daher werden die folgenden beiden Prüfungen durchgeführt:
#
# 1) Wenn mehrere Slaves über eine Failover-Funktion verfügen, tauschen sie Nachrichten aus
# um zu versuchen, dem Sklaven mit der besten
# Replikationsoffset (mehr Daten vom Master verarbeitet).
# Slaves versuchen, ihren Rang durch Offset zu ermitteln und wenden ihn auf den Start an
# des Failovers, eine Verzögerung proportional zu ihrem Rang.
#
# 2) Jeder einzelne Slave berechnet den Zeitpunkt der letzten Interaktion mit
# sein Master. Dies kann der letzte empfangene Ping oder Befehl sein (wenn der Master
# noch im "verbunden"-Zustand ist), oder die Zeit, die seit dem
# Trennung der Verbindung zum Master (wenn die Replikationsverbindung aktuell unterbrochen ist).
# Wenn die letzte Interaktion zu alt ist, wird der Slave keinen Failover-Versuch durchführen
# überhaupt.
#
# Der Punkt "2" kann vom Benutzer eingestellt werden. Insbesondere wird ein Slave nicht ausführen
# das Failover, wenn seit der letzten Interaktion mit dem Master die Zeit
# verstrichen ist größer als:
#
# (Knoten-Timeout * Slave-Gültigkeitsfaktor) + Repl-Ping-Slave-Periode
#
# Wenn also beispielsweise das Knoten-Timeout 30 Sekunden beträgt und der Slave-Gültigkeitsfaktor
# ist 10, und unter der Annahme einer Standard-Repl-Ping-Slave-Periode von 10 Sekunden, die
# Der Slave wird keinen Failover-Versuch durchführen, wenn er nicht mit dem Master kommunizieren konnte.
# länger als 310 Sekunden.
#
# Ein großer Slave-Gültigkeitsfaktor kann dazu führen, dass Slaves mit zu alten Daten ausfallen
# ein Master, während ein zu kleiner Wert den Cluster daran hindern kann,
# überhaupt einen Sklaven wählen.
#
# Für maximale Verfügbarkeit ist es möglich, den Slave-Gültigkeitsfaktor einzustellen
# auf den Wert 0, was bedeutet, dass Slaves immer versuchen werden, ein Failover durchzuführen.
# Master, unabhängig davon, wann sie zuletzt mit dem Master interagiert haben.
# (Sie werden jedoch immer versuchen, eine Verzögerung anzuwenden, die proportional zu ihrer
# Offset-Rang).
#
# Null ist der einzige Wert, der garantiert, dass, wenn alle Partitionen geheilt sind
# Der Cluster kann immer fortgesetzt werden.
#
# Cluster-Slave-Gültigkeitsfaktor 10
 
# Cluster-Slaves können zu verwaisten Mastern migrieren, die Master sind
# die ohne funktionierende Slaves übrig bleiben. Dies verbessert die Clusterfähigkeit
# um Ausfällen zu widerstehen, da sonst ein verwaister Master nicht durch ein Failover ersetzt werden kann
# im Fehlerfall, wenn es keine funktionierenden Slaves hat.
#
# Slaves migrieren nur dann zu verwaisten Mastern, wenn noch mindestens ein
# bestimmte Anzahl anderer Arbeitssklaven für ihren alten Master. Diese Zahl
# ist die "Migrationsbarriere". Eine Migrationsbarriere von 1 bedeutet, dass ein Slave
# wird nur migriert, wenn es mindestens einen anderen funktionierenden Slave für seinen Master gibt
# und so weiter. Es spiegelt normalerweise die Anzahl der Slaves wider, die Sie für jeden
# Master in Ihrem Cluster.
#
# Standard ist 1 (Slaves migrieren nur, wenn ihre Master mit mindestens
# ein Slave). Um die Migration zu deaktivieren, stellen Sie einfach einen sehr großen Wert ein.
# Der Wert 0 kann gesetzt werden, ist aber nur zum Debuggen sinnvoll und gefährlich
# in Produktion.
#
# Cluster-Migrationsbarriere 1
 
# Standardmäßig akzeptieren Redis Cluster-Knoten keine Abfragen mehr, wenn sie feststellen, dass
# ist mindestens ein Hash-Slot nicht abgedeckt (kein verfügbarer Knoten stellt ihn bereit).
# Auf diese Weise, wenn der Cluster teilweise ausgefallen ist (zum Beispiel ein Bereich von Hash-Slots
# werden nicht mehr abgedeckt) wird der gesamte Cluster schließlich nicht mehr verfügbar.
# Es ist automatisch wieder verfügbar, sobald alle Slots wieder belegt sind.
#
# Manchmal möchten Sie jedoch die Teilmenge des Clusters, die funktioniert,
# um weiterhin Anfragen für den Teil des Schlüsselraums anzunehmen, der noch
# abgedeckt. Setzen Sie dazu einfach den Cluster-Require-Full-Coverage
# Option auf Nein.
#
# Cluster erfordert vollständige Abdeckung ja
 
# Um Ihren Cluster einzurichten, lesen Sie unbedingt die Dokumentation
# verfügbar auf der Website http://redis.io.
 
############################################ LANGSAMES LOG ######################################
 
# Das Redis Slow Log ist ein System zum Protokollieren von Abfragen, die eine bestimmte
# Ausführungszeit. Die Ausführungszeit beinhaltet nicht die I/O-Operationen
# wie das Gespräch mit dem Kunden, das Senden der Antwort usw.,
# sondern nur die Zeit, die benötigt wird, um den Befehl tatsächlich auszuführen (das ist die einzige
# Phase der Befehlsausführung, in der der Thread blockiert ist und nicht ausgeführt werden kann
# andere Anfragen in der Zwischenzeit).
#
# Sie können das Slow-Log mit zwei Parametern konfigurieren: Einer teilt Redis mit,
# welche Ausführungszeit in Mikrosekunden muss überschritten werden, damit die
# Befehl zum Protokollieren, und der andere Parameter ist die Länge des
# langsames Protokoll. Wenn ein neuer Befehl protokolliert wird, wird der älteste aus dem
# Warteschlange der protokollierten Befehle.
 
# Die folgende Zeit wird in Mikrosekunden ausgedrückt, also ist 1000000 gleich
# auf eine 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. Beachten Sie jedoch, dass Speicher verbraucht wird.
# Mit SLOWLOG RESET können Sie den vom langsamen Protokoll verwendeten Speicher zurückfordern.
slowlog-max-len 128
 
####################################### LATENZ-MONITOR ####################################
 
# Das Redis-Latenzüberwachungssubsystem prüft verschiedene Vorgänge
# zur Laufzeit, um Daten zu möglichen Quellen von
# Latenz einer Redis-Instanz.
#
# Über den LATENCY-Befehl stehen diese Informationen dem Benutzer zur Verfügung, der
# Diagramme drucken und Berichte erhalten.
#
# Das System protokolliert nur Vorgänge, die in einer Zeit von oder durchgeführt wurden
# größer als die Anzahl der Millisekunden, die über den
# Konfigurationsanweisung für Latenzmonitorschwelle. Wenn der Wert gesetzt ist
# auf Null, der Latenzmonitor wird ausgeschaltet.
#
# Standardmäßig ist die Latenzüberwachung deaktiviert, da sie meist nicht benötigt wird
# wenn Sie keine Latenzprobleme haben und das Sammeln von Daten eine Leistung hat
# Auswirkungen, die zwar sehr gering sind, aber unter großer Belastung gemessen werden können. Latenz
# Die Überwachung kann einfach zur Laufzeit mit dem Befehl aktiviert werden
# „CONFIG SET latency-monitor-threshold <Millisekunden>“, falls erforderlich.
Latenz-Monitor-Schwellenwert 0
 
##################################### EREIGNISBENACHRICHTIGUNG #################################
 
# Redis kann Pub/Sub-Clients über Ereignisse im Schlüsselraum benachrichtigen.
# Diese Funktion ist unter http://redis.io/topics/notifications dokumentiert.
#
# Wenn beispielsweise die Benachrichtigung über Keyspace-Ereignisse aktiviert ist und ein Client
# führt eine DEL-Operation für den Schlüssel "foo" aus, der in der Datenbank 0 gespeichert ist, zwei
# Nachrichten werden über Pub/Sub veröffentlicht:
#
# PUBLISH __keyspace@0__:foo del
# PUBLISH __keyevent@0__:del foo
#
# Es ist möglich, die Ereignisse auszuwählen, die Redis aus einer Reihe von
Anzahl der Klassen. Jede Klasse wird durch ein einzelnes Zeichen identifiziert:
#
# K Keyspace-Ereignisse, veröffentlicht mit dem Präfix __keyspace@<db>__.
# E Keyevent-Ereignisse, veröffentlicht mit dem Präfix __keyevent@<db>__.
# g Allgemeine Befehle (nicht typspezifisch) wie DEL, EXPIRE, RENAME, …
# $ String-Befehle
# Befehle auflisten
# s Befehle festlegen
# h Hash-Befehle
# z Sortierte Set-Befehle
# x Abgelaufene Ereignisse (Ereignisse, die jedes Mal generiert werden, wenn ein Schlüssel abläuft)
# e Ausgewiesene Ereignisse (Ereignisse, die generiert werden, wenn ein Schlüssel aus Gründen des maximalen Speichers ausgelagert wird)
# Ein Alias ​​für g$lshzxe, sodass die Zeichenfolge „AKE“ alle Ereignisse bedeutet.
#
# Das "notify-keyspace-events"-Argument verwendet einen String, der zusammengesetzt ist
# von null oder mehreren Zeichen. Die leere Zeichenfolge bedeutet, dass Benachrichtigungen
# sind deaktiviert.
#
# Beispiel: Listen- und generische Ereignisse zu aktivieren, aus der Sicht der
# Ereignisname, verwenden Sie:
#
# Benachrichtigungs-Keyspace-Ereignisse Elg
#
# Beispiel 2: um den Stream der abgelaufenen Schlüssel abzurufen, die den Kanal abonnieren
# Name __keyevent@0__:abgelaufen Verwendung:
#
# Benachrichtigungs-Keyspace-Ereignisse Beispiel
#
# Standardmäßig sind alle Benachrichtigungen deaktiviert, da die meisten Benutzer sie nicht benötigen
# diese Funktion und die Funktion hat einen gewissen Overhead. Beachten Sie, dass, wenn Sie nicht
# Geben Sie mindestens eines von K oder E an, es werden keine Ereignisse übermittelt.
Benachrichtigung über Keyspace-Ereignisse ""
 
####################################### ERWEITERTE KONFIGURATION ####################################
 
# Hashes werden mit einer speichereffizienten Datenstruktur kodiert, wenn sie eine
# kleine Anzahl von Einträgen, und der größte Eintrag überschreitet nicht einen bestimmten
# Schwellenwert. Diese Schwellenwerte können mit den folgenden Anweisungen konfiguriert werden.
Hash-Max-Ziplist-Einträge 512
Hash-Max-Ziplist-Wert 64
 
# Listen werden auch auf spezielle Weise codiert, um viel Platz zu sparen.
# Die Anzahl der erlaubten Einträge pro internem Listenknoten kann angegeben werden
# als feste Maximalgröße oder Maximalanzahl von Elementen.
# Für eine feste Maximalgröße verwenden Sie -5 bis -1, was bedeutet:
# -5: max. Größe: 64 KB <-- nicht empfohlen für normale Arbeitslasten
# -4: max. Größe: 32 Kb <-- nicht empfohlen
# -3: max. Größe: 16 Kb <-- wahrscheinlich nicht empfohlen
# -2: max. Größe: 8 Kb <-- gut
# -1: max. Größe: 4 Kb <-- gut
# Positive Zahlen bedeuten, dass bis zu _genau_ diese Anzahl an Elementen gespeichert werden
# pro Listenknoten.
# Die leistungsstärkste Option ist normalerweise -2 (8 KB Größe) oder -1 (4 KB Größe),
# aber wenn Ihr Anwendungsfall einzigartig ist, passen Sie die Einstellungen nach Bedarf an.
Liste-max-Ziplist-Größe -2
 
# Listen können auch komprimiert werden.
# Komprimierungstiefe ist die Anzahl der Quicklist-Ziplist-Knoten von *jeder* Seite von
# die Liste, die von der Komprimierung *ausgeschlossen* werden soll. Der Kopf und das Ende der Liste
# sind für schnelle Push/Pop-Operationen immer unkomprimiert. Einstellungen sind:
# 0: Deaktiviere die gesamte Listenkomprimierung
# 1: Tiefe 1 bedeutet „Beginnen Sie erst nach 1 Knoten in der Liste mit der Komprimierung,
# entweder vom Kopf oder vom Schwanz ausgehend"
# Also: [Kopf]->Knoten->Knoten->...->Knoten->[Ende]
# [head], [tail] werden immer unkomprimiert sein; innere Knoten werden komprimiert.
# 2: [Kopf]->[Weiter]->Knoten->Knoten->...->Knoten->[Vorherige]->[Ende]
# 2 bedeutet hier: Kopf oder Kopf->Weiter oder Ende->Vorheriges oder Ende nicht komprimieren,
# aber komprimieren Sie alle Knoten dazwischen.
# 3: [Kopf]->[Weiter]->[Weiter]->Knoten->Knoten->...->Knoten->[Vorherige]->[Vorherige]->[Ende]
# usw.
Listenkomprimierungstiefe 0
 
# Mengen haben nur in einem Fall eine spezielle Kodierung: wenn eine Menge zusammengesetzt ist
Anzahl von Zeichenfolgen, die zufällig Ganzzahlen mit Basis 10 im Bereich sind
Anzahl vorzeichenbehafteter 64-Bit-Ganzzahlen.
# Die folgende Konfigurationseinstellung legt die Grenze für die Größe des
# festgelegt, um diese spezielle speichersparende Kodierung zu verwenden.
set-max-intset-einträge 512
 
# Ähnlich wie Hashes und Listen werden auch sortierte Mengen speziell kodiert in
# um viel Platz zu sparen. Diese Kodierung wird nur verwendet, wenn die Länge und
# Elemente einer sortierten Menge liegen unter den folgenden Grenzen:
zset-max-ziplist-einträge 128
zset-max-ziplist-wert 64
 
# HyperLogLog Sparse-Darstellung Byte-Limit. Das Limit beinhaltet die
# 16 Byte Header. Wenn ein HyperLogLog die spärliche Darstellung verwendet, kreuzt
# dieser Grenze wird es in die dichte Darstellung umgewandelt.
#
# Ein Wert größer als 16000 ist völlig nutzlos, da an diesem Punkt die
# Eine dichte Darstellung ist speichereffizienter.
#
# Der empfohlene Wert ist ~ 3000, um die Vorteile von
# die platzsparende Kodierung ohne zu starke Verlangsamung von PFADD,
# was mit der Sparse-Kodierung O(N) ist. Der Wert kann erhöht werden auf
# ~ 10000, wenn die CPU kein Problem ist, der Speicherplatz jedoch schon, und der Datensatz
# bestehend aus vielen HyperLogLogs mit Kardinalität im Bereich 0 - 15000.
hll-sparse-max-bytes 3000
 
# Aktives Rehashing verbraucht 1 Millisekunde alle 100 Millisekunden CPU-Zeit in
# um beim erneuten Hashen der Haupt-Hash-Tabelle von Redis zu helfen (die die oberste Ebene abbildet
# Schlüssel zu Werten). Die Hash-Tabellen-Implementierung, die Redis verwendet (siehe dict.c)
# führt ein Lazy Rehashing durch: je mehr Operationen Sie in eine Hash-Tabelle ausführen
# das heißt, es wird erneut aufgewärmt, desto mehr „Schritte“ werden ausgeführt. Wenn also die
# Der Server ist im Leerlauf. Das erneute Hashing wird nie abgeschlossen und es wird etwas mehr Speicher verwendet.
# durch die Hash-Tabelle.
#
# Die Standardeinstellung ist, diese Millisekunde 10 Mal pro Sekunde zu verwenden, um
# Die Hauptwörterbücher aktiv neu aufbereiten und wenn möglich Speicher freigeben.
#
# Wenn Sie unsicher sind:
# verwenden Sie "activerehashing no", wenn Sie hohe Latenzanforderungen haben und es
# Es ist in Ihrer Umgebung nicht gut, dass Redis von Zeit zu Zeit antworten kann
# auf Abfragen mit 2 Millisekunden Verzögerung.
#
# verwenden Sie "activerehashing yes", wenn Sie keine so strengen Anforderungen haben, aber
# möchte möglichst schnell Speicher freigeben.
aktives Aufwärmen ja
 
# Die Client-Ausgabepuffergrenzen können verwendet werden, um die Trennung von Clients zu erzwingen
# die aus irgendeinem Grund nicht schnell genug Daten vom Server lesen (ein
# Der häufigste Grund ist, dass ein Pub/Sub-Client Nachrichten nicht so schnell verarbeiten kann wie der
# Verlag kann sie produzieren).
#
# Das Limit kann für die drei verschiedenen Client-Klassen unterschiedlich eingestellt werden:
#
# normal -> normale Clients einschließlich MONITOR-Clients
# Slave -> Slave-Clients
# pubsub -> Clients, die mindestens einen Pubsub-Kanal oder ein Pubsub-Muster abonniert haben
#
# Die Syntax jeder Client-Output-Buffer-Limit-Direktive ist die folgende:
#
# client-output-buffer-limit <Klasse> <hartes Limit> <weiches Limit> <weiche Sekunden>
#
# Ein Client wird sofort getrennt, sobald das harte Limit erreicht ist oder wenn
# das Soft-Limit ist erreicht und bleibt für die angegebene Anzahl von
# Sekunden (kontinuierlich).
# Wenn also beispielsweise das harte Limit 32 Megabyte beträgt und das weiche Limit
# 16 Megabyte / 10 Sekunden, die Verbindung zum Client wird sofort getrennt
# wenn die Größe der Ausgabepuffer 32 Megabyte erreicht, wird aber auch
# Verbindung wird getrennt, wenn der Client 16 Megabyte erreicht und kontinuierlich überschreitet
# das Limit für 10 Sekunden.
#
# Standardmäßig sind normale Clients nicht eingeschränkt, da sie keine Daten empfangen
# ohne Nachfrage (im Push-Verfahren), sondern direkt 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
# Abonnenten und Slaves erhalten Daten im Push-Verfahren.
#
# Sowohl das harte als auch das weiche Limit können 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
# Schließen von Clientverbindungen im Timeout, Löschen abgelaufener Schlüssel, die
# nie angefordert, und so weiter.
#
# Nicht alle Aufgaben werden mit der gleichen Häufigkeit ausgeführt, aber Redis prüft
# Aufgaben, die entsprechend dem angegebenen „hz“-Wert ausgeführt werden sollen.
#
# Standardmäßig ist "hz" auf 10 eingestellt. Eine Erhöhung des Wertes führt zu mehr CPU-Verbrauch, wenn
# Redis ist im Leerlauf, aber gleichzeitig wird Redis reaktionsfähiger, wenn
# Es laufen viele Schlüssel gleichzeitig ab, und es kann zu Timeouts kommen
# mit größerer Präzision gehandhabt.
#
# Der Bereich liegt zwischen 1 und 500, jedoch ist ein Wert über 100 normalerweise nicht
# eine gute Idee. Die meisten Benutzer sollten den Standardwert 10 verwenden und diesen Wert auf
# 100 nur in Umgebungen, in denen eine sehr geringe Latenz erforderlich ist.
Hz 10
 
# Wenn ein Kind die AOF-Datei neu schreibt und die folgende Option aktiviert ist
# die Datei wird alle 32 MB generierter Daten fsynced. Das ist nützlich
# um die Datei inkrementeller auf die Festplatte zu übertragen und zu vermeiden
# große Latenzspitzen.
aof-rewrite-inkrementell-fsync ja

docker exec -it Die Container-ID des Redis-Dienstes, auf dem redis-cli ausgeführt wird