Es gibt viele Informationen zu diesem Thema im Internet, aber trotzdem meiden viele es. Der Zweck dieses Beitrags besteht darin, auf einen Blick die Grundlagen der Interaktion mit Memcached zu erklären.

Was ist Memcache und was hat es mit PHP zu tun?

Memcache dient zum Zwischenspeichern von Daten, deren Generierung viele Ressourcen erfordert. Diese Art von Daten kann alles enthalten, von den Ergebnissen einer Datenbankabfrage bis hin zu einem umfangreichen Teil einer Vorlage. Memcached ist nicht im Kernsatz der mit PHP gelieferten Module enthalten, ist aber im pecl-Repository verfügbar.

Installation und Konfiguration

Ich habe mich für Debian als Distribution entschieden, da es am häufigsten beim Erstellen von Webservern verwendet wird. Das Memcached-Modul für PHP ist im bereits kompilierten Repository verfügbar (php5-memcached), aber ich werde den Installationsprozess anhand des Quellcodes beschreiben, da nicht alle Repositorys so umfangreich sind wie das Debian-Repository.

Installieren des Memcached-Servers

#apt-get install memcached
Für den Anfang reicht Ihnen die folgende Konfiguration:

#/etc/memcached.conf
#Memcached wird wie ein Dämon funktionieren
-D
#Das Protokoll wird dort hinzugefügt
Protokolldatei /var/log/
#Wir werden 256 Megabyte RAM für die Speicherung bereitstellen
-m 256
#Dieser Port wird lauschen
-p 11211
#Später empfiehlt sich ein Wechsel
-Du, niemand
#Lokalhost anhören
-l 127.0.0.1

#/etc/init.d/memcached Neustart

Überprüfung

# netstat -tap | grep memcached
tcp 0 0 localhost:11211 * :* LISTEN 13036 /

Kompilieren und installieren Sie das Modul für PHP

apt-get install php5-dev libmemcache-dev

Pecl lädt den Memcache herunter
tar xzvf memcache-2.2.6.tgz
cd memcache-2.2.6/
phpize && ./ configure --enable-memcache && make
cp-Module/ / usr/ lib/ php5/ 20060613 /

echo „extension=memcache.so“ >> / etc/ php5/ apache2/ php.ini
/etc/init.d/apache2 neu starten

Das ist alles! Es ist überhaupt nicht schwierig.

Anwendungsbeispiele

1. Grundlegende Operationen

2. //Erstelle ein neues Objekt. Sie können auch in einem prozeduralen Stil schreiben
3. = neu ;
4. -> verbinden ("127.0.0.1", 11211) oder sterben ("Verbindung konnte nicht hergestellt werden");
5. //Versuchen Sie, ein Objekt mit dem Schlüssel our_var abzurufen
6. $var_key = @ -> get ("our_var" );
7. if (! empty ($var_key) )
8. //Wenn das Objekt zwischengespeichert ist, seinen Wert ausgeben
9. echo $var_key ;
10. anders
11. //Wenn sich im Cache kein Objekt mit dem Schlüssel our_var befindet, erstellen Sie es
12. //Unser_var-Objekt wird 5 Sekunden lang gespeichert und nicht komprimiert
13. -> set ("our_var" , date ("G:i:s" ) , false , 5 );
14. //Gespeicherte Daten ausgeben
15. echo -> get ("our_var" );
16. ->close();

Durch die Ausführung dieses Codes wird die Uhrzeit jedes Mal sekundengenau angezeigt. Es wird jedoch alle 5 Sekunden aktualisiert, bis der Cache geleert wird. Dieses Beispiel veranschaulicht die einfachsten Vorgänge, aber es ist wahrscheinlicher, dass wir an Leistung verlieren als gewinnen. Schließlich müssen wir uns jedes Mal mit dem Server verbinden ...

2. Steigern Sie die Produktivität

2.1 Mit Caching

1. < ? php
2. Funktion LoadCPU()
3. //Funktion, die den Prozessor laden soll
4. $image = imagecreate(800, 600);
5. //Weiße Hintergrundfarbe
6. $color = imagecolorallocate($image, 255 , 255 , 255 ) ;
7. //Schwarz
8. $color2 = imagecolorallocate($image, 0 , 0 , 0 ) ;
9. für ($i = 0; $i< 10000 ; $i++ ) {
10. imagesetpixel($image, rand (0 , 800 ) , rand (0 ,600 ) , $color2) ;
11. //Wirf den Zeiger weg
12. return $image;
13. //Erstelle ein neues Memcache-Objekt
14. = neu ;
15. //Mit unserem Server verbinden
16. -> connect("127.0.0.1" , 11211 ) or die("Verbindung konnte nicht hergestellt werden" );
17. //Versuchen Sie, ein Objekt mit dem Schlüsselbild zu erhalten
18. $image_bin = - > get("image" );
19. if (empty($image_bin) ) (
20. //Wenn sich kein Bild im Cache befindet, generieren Sie es und speichern Sie es im Cache
21. imagepng(LoadCPU() ,getcwd() ."/tmp.png" ,9 ) ;
22. $image_bin = file_get_contents(getcwd() ."/tmp.png" );
23. unlink(getcwd() ."/tmp.png" );
24. -> set("image" , $image_bin, false , 30 ) ;
25. //Das Bild aus dem Cache abrufen
26. header("Inhaltstyp: image/png" );
27. echo $image_bin;
28. //Schließen Sie die Verbindung zum Memcached-Server
29. -> schließen();
30. ? >

Dieses Beispiel zeigt eine Funktion, die ein 800x600-Bild erstellt und 10.000 Punkte darauf platziert. Nachdem wir ein solches Bild einmal erstellt haben, zeigen wir es in Zukunft nur noch auf dem Bildschirm an, ohne es erneut zu generieren.

2.2 Kein Caching

2. Funktion LoadCPU()
3. //Funktion, die den Prozessor laden soll
4. //Erstelle ein 800x600-Bild
5. $image = imagecreate(800, 600);
6. //Weiße Hintergrundfarbe
7. $color = imagecolorallocate($image, 255, 255, 255);
8. //Schwarz
9. $color2 = imagecolorallocate($image, 0, 0, 0);
10. für ($i = 0; $i< 10000 ; $i ++ ) {
11. // Ordnen Sie 10.000 Punkte in zufälliger Reihenfolge an
12. imagesetpixel($image, rand(0, 800), rand(0, 600), $color2);
13. //Wirf den Zeiger weg
14. $image zurückgeben;
15. //Zeigt das Bild ohne Zwischenspeicherung an
16. header("Inhaltstyp: image/png");
17. imagepng (LoadCPU(), "", 9);

Hier ist alles viel einfacher und vertrauter: Wir generieren das Bild jedes Mal neu.

Ergebnisse

Ich habe beide Skripte auf Leistung getestet. Dieselbe Maschine erzeugte im ersten Fall 460 Antworten pro Sekunde, im zweiten nur 10. Was zu erwarten war.

Einige weitere nützliche Funktionen

addServer – Wenn Ihnen mehrere Caching-Server zur Verfügung stehen, können Sie einen Cluster erstellen, indem Sie Server zum Pool hinzufügen. Sie sollten auf den Parameter achten Gewicht. Es gibt an, wie viel Speicher Ihnen auf einem bestimmten Server zur Verfügung steht.
delete – aus dem Namen geht hervor, dass diese Methode ein Objekt mit einem bestimmten Schlüssel aus dem Cache löscht.
ersetzen – ersetzt den Wert eines Objekts durch den angegebenen Schlüssel. Verwenden Sie es, wenn Sie den Inhalt eines Objekts ändern müssen, bevor seine Lebensdauer abläuft.

Endeffekt

Aus meiner Sicht sollte Caching nur bei stark ausgelasteten Ressourcen eingesetzt werden. Schließlich verschwenden Sie jedes Mal, wenn Sie eine Verbindung zum Memcached-Server herstellen, wertvolle Zeit, die höchstwahrscheinlich nicht gerechtfertigt ist. Bei großen Projekten ist es besser, mehrere Codezeilen auf einmal zu schreiben, als es in Eile zu tun, mit dem Gedanken, dass Ihr Dienst lügt. Vergessen Sie auch nicht den Speicherverbrauch! Bitte beachten Sie, dass Sie durch das Platzieren von 300 Megabyte im Cache 300 Megabyte RAM weggenommen haben ...
Abschließend möchte ich sagen, dass dieser Artikel nicht alle Vorzüge der Technologie offenbart, aber ich hoffe, dass er Sie zur Selbstverbesserung anregt. Vielen Dank fürs Lesen, lieber %username%!

UPD: Ein weiterer interessanter Punkt. Memcached, es gibt eine PHP-API für libmemcached. Und Memcache, eine Bibliothek für PHP, die libmemcached nicht verwendet.

Das Memcache-Modul bietet praktische prozedurale und objektorientierte Schnittstellen zur Memcached-Caching-Engine. Memcache ist ein sehr effizienter Caching-Daemon, der speziell zur Reduzierung der Datenbanklast für dynamische Webanwendungen mit hoher Auslastung entwickelt wurde.

Das Memcache-Modul stellt außerdem einen Sitzungshandler bereit. Weitere Informationen zu Memcached finden Sie unter memcached.org

Im Prinzip liegt die Beschreibung zur Installation und Konfiguration in russischer Sprache bereits vor und Sie können sich damit vertraut machen.

Beachten Sie, dass Sie jede Art von Daten im Cache speichern können: Variablen, Objekte und Arrays. ABER KEINE RESSOURCEN!

Wenn ein Objekt eine Eigenschaft enthält – eine Ressource, beispielsweise eine Verbindung zu einer Datenbank, oder ein anderes Objekt mit ähnlichen Eigenschaften enthält, muss diese Situation separat behandelt werden, beispielsweise durch Überschreiben der __sleep()-Methode, in der diese Ressource benötigt wird „getötet“ werden und die __wakeup-Methode (), in der diese Ressource wiederbelebt werden muss.

Tatsächlich lassen sich alle diese Methoden in drei Gruppen einteilen:

1. Mit Werten arbeiten
2. Arbeiten mit Servern und Verbindungen
3. Erhalt der Informationen

Mit Werten arbeiten

Mit den Methoden in dieser Gruppe können Sie Folgendes tun:

• Werte festlegen
• Löschen Sie diese Werte
• Ersetzen Sie diese Werte
• Greifen Sie per Schlüssel auf diese Werte zu
• Verwalten Sie die Wertlebensdauer

Ein paar spezifische Methoden zum Inkrementieren und Dekrementieren von Ganzzahlwerten.

Memcache::set()
Memcache::add()

Ermöglicht Ihnen, einen Wert sowie die Komprimierung und Lebensdauer für diesen Wert festzulegen. Der einzige Unterschied im Verhalten dieser Methoden besteht darin, dass die Methode Memcache::add FALSE zurückgibt, wenn bereits ein Wert mit demselben Schlüssel festgelegt ist.

bool Memcache::add
bool Memcache::set(string $key , gemischt $var [, int $flag [, int $expire ]])

• string $key ist der Schlüssel des Werts, mit dessen Hilfe wir den Wert bearbeiten.
• gemischt $var - Wert.
• Konstanten

connect("localhost", 11211, 30); $cache->add("myfirst", 1000, MEMCACHE_COMPRESSED, 15); $cache->set("mysecond", 2000, MEMCACHE_COMPRESSED, 15);

Memcache::get()

Gibt den angeforderten Wert oder FALSE zurück, wenn dies nicht erfolgreich war oder der Wert mit diesem Schlüssel noch nicht festgelegt wurde.

Sie können ein Array von Wertschlüsseln übergeben, dann gibt Memcache::get auch ein Array zurück, das die gefundenen Schlüssel-Wert-Paare enthält.

Warnungen!

Wenn der Schlüsselname einen Backslash enthält, dann Die Ergebnisse der Arbeit werden unvorhersehbar sein!

Memcached hat auch einige Probleme: Berichten zufolge ist es (manchmal) anfällig für Pufferüberlauffehler, was gelegentlich zum Überschreiben von [teilweisen] Daten führt und daher die Deserialisierung von Strukturen unmöglich macht. Überprüfen Sie unbedingt, ob Memcache::get als Ergebnis des Abrufens eines Arrays oder Objekts einen Bool-, Dobule- oder Long-Wert zurückgibt. Dann ist ein Fehler aufgetreten.

Zeichenfolge Memcache::get(string $key [, int &$flags ])
Array Memcache::get(Array $keys [, Array &$flags])

• string $key – Wertschlüssel oder ein Array von Schlüsseln, deren Werte abgerufen werden müssen.
• int $flag – der Zweck dieses Parameters bleibt mir ein Rätsel. Ich habe versucht, einige ganzzahlige Werte zu verwenden, aber es hatte keine Wirkung. Und die Beispiele werden größtenteils ohne Verwendung gegeben, woraus ich geschlossen habe: Man kann auch ohne es gut arbeiten :)

connect("localhost", 11211, 30); $cache->add("myfirst", 1000, MEMCACHE_COMPRESSED, 15); $cache->set("mysecond", 2000, MEMCACHE_COMPRESSED, 15); print_r($cache->get(array("myfirst","mysecond")));

Ergebnis:

Array ( => 1000 => 2000)

Memcache::delete()

Entfernen Sie einen Wert aus dem Cache.

Kommentar:

Diese Methode funktioniert nicht immer (abhängig von der Softwareversion)! Am Ende der Seite gibt es Fälle, in denen Memcache::delete funktioniert und in denen nicht.

Nun, die einzige stabile Option besteht darin, unnötige Werte zurückzusetzen:

$cache->set("drei", NULL);

Es gibt nur ein Minus – der Schlüssel geht in diesem Fall nirgendwo hin

Zeichenfolge Memcache::löschen(string $key [, int $timeout = 0 ])

• string $key – der zu löschende Schlüsselwert.
• int $timeout – Dieser Parameter ist ebenfalls veraltet und wird nicht unterstützt, der Standardwert ist 0 Sekunden. Verwenden Sie diese Option nicht.

Memcache::replace()

Vorhandenen Wert überschreiben.

Zum Ersetzen sollte Memcache::replace() verwendet werden vorhandener Wert. Wenn ein Wert mit einem solchen Schlüssel nicht existiert, gibt Memcache::replace() FALSE zurück. Ansonsten verhält sich Memcache::replace() genauso wie Memcache::set(). Sie können auch die Funktion memcache_replace() verwenden

Zeichenfolge Memcache::replace(string $key , gemischt $var [, int $flag [, int $expire ]])

• string $key – der Schlüssel, dessen Wert ersetzt werden muss.
• gemischt $var – neuer Wert.
• int $flag – Flag, das angibt, ob für den gespeicherten Wert eine Komprimierung (hier kommt Zlib ins Spiel) verwendet werden soll. Konstanten können verwendet werden
• int $expire – Wertlebensdauer (Cache). Wenn gleich Null, dann auf unbestimmte Zeit. Sie können auch einen Zeitstempel oder die Anzahl der Sekunden seit der aktuellen Zeit verwenden, die Anzahl der Sekunden darf dann jedoch 2592000 (30 Tage) nicht überschreiten.

connect("localhost", 11211, 30); $cache->add("one", 111, 0, 15); $cache->add("two", 222, 0, 15); $cache->add("drei", 333, 0, 15); $cache->replace("drei", 777); print_r($cache->get(array("eins", "zwei", "drei"))); Array ( => 111 => 222 => 777)

Memcache::increment()

Erhöht den Wert des angegebenen Schlüssels um den angegebenen Wert. Wenn der Wert des angegebenen Schlüssels nicht numerisch ist und nicht in eine Zahl umgewandelt werden kann, ändert er seinen Wert in den als zweiten Parameter angegebenen Wert. Memcache::increment() erstellt kein Element, wenn es noch nicht vorhanden ist.

Es wird nicht empfohlen, Memcache::increment() mit Werten zu verwenden, die komprimiert wurden (festgelegt mit dem Flag MEMCACHE_COMPRESSED), da es später zu Überraschungen kommt, wenn Sie versuchen, diese Werte mit Memcache::get() abzurufen.

Persönlich habe ich es überprüft und keine Störungen bemerkt :)

int Memcache::inkrementieren

• string $key – der Schlüssel, dessen Wert erhöht werden muss.
• int $value – Wert erhöhen.

connect("localhost", 11211, 30); $cache->set("someOne", 10, 0, 5); $cache->increment("someOne", 10, 0, 5); $cache->increment("someOne", 10, 0, 5); echo $cache->get("someOne");// wird 30 ausgeben

Memcache::decrement()

Dekrementiert den Wert des angegebenen Schlüssels um den angegebenen Wert. Ähnlich wie bei Memcache::increment() wird der aktuelle Wert des Elements in einen numerischen Wert umgewandelt und anschließend dekrementiert

int Memcache::dekrementieren(string $key [, int $value = 1 ])

• string $key – der Schlüssel, dessen Wert dekrementiert werden muss.
• int $value – Wert dekrementieren.

Memcache::flush()

Memcache::flush() macht alle vorhandenen Werte ungültig. Memcache::flush() gibt nicht wirklich Speicherressourcen frei, sondern markiert lediglich alle Elemente als veraltet, sodass der belegte Speicher für die Verwendung durch neue Werte verfügbar ist. Sie können auch die Funktion memcache_flush() verwenden

bool Memcache::flush(Leere)

Das folgende Beispiel gibt nichts aus.

connect("localhost", 11211, 30); $cache->set("someOne", 111, 0, 5); $cache->set("someTwo", 222, 0, 5); $cache->set("someTree", 333, 0, 5); $cache->flush(); //Löschen des Cache print_r($cache->get(array("someOne","someTwo","someTree")));

Arbeiten mit Servern und Verbindungen.

Memcache kann entweder mit einem einzelnen Server oder einem Pool (einer Gruppe) von Servern arbeiten.

Wenn Sie nur einen Server zum Bereitstellen des Caches verwenden, müssen Sie zum Initialisieren der Arbeit lediglich ein Cache-Objekt erstellen und die Methode verwenden Memcache::connect

Wenn Sie einen Serverpool erstellen möchten, müssen Sie zunächst ein Cache-Objekt erstellen und dann das verwenden Memcache::addServer Fügen Sie die erforderliche Anzahl von Servern hinzu.

Memcache::connect()

Stellt eine Verbindung zum Memcached-Server her. Eine Verbindung, die mit Memcache::connect() geöffnet wurde, wird automatisch geschlossen, wenn das Skript abgeschlossen ist. Sie können sie jedoch explizit mit Memcache::close() schließen. Sie können auch die Funktion memcache_connect() verwenden. Gibt bei Erfolg TRUE oder bei Fehler FALSE zurück.

bool Memcache::connect

connect("localhost", 11211, 30);

Memcache::pconnect()

Diese Methode ähnelt Memcache::connect() mit dem einzigen Unterschied, dass sie eine dauerhafte Verbindung aufbaut. Diese Verbindung wird nicht geschlossen, wenn das Skript abgeschlossen ist und Memcache::close() aufgerufen wird. Sie können auch die Funktion memcache_pconnect() verwenden. Gibt bei Erfolg ein Memcache-Objekt oder bei einem Fehler FALSE zurück.

gemischt Memcache::pconnect(string $host [, int $port [, int $timeout ]])

• Dieser Parameter kann auch andere Transporte wie unix:///path/to/memcached.sock angeben, d. h. Verwenden Sie UNIX-Sockets. In diesem Fall muss der Port auf 0 gesetzt werden.
• Setzen Sie diesen Parameter auf 0, wenn Sie Sockets verwenden möchten.
• int $timeout – Limit in Sekunden für die Verbindung zum Daemon. Denken Sie zweimal darüber nach, bevor Sie den Standardwert von 1 Sekunde ändern – Sie verlieren möglicherweise alle Vorteile des Cachings, wenn Ihre Verbindung zu lange dauert.

pconnect("localhost", 11211, 30);

Memcache::close()

Schließt die Verbindung zum Memcached-Server. Diese Funktion schließt keine dauerhaften Verbindungen, die nur geschlossen werden, wenn der Webserver heruntergefahren/neu gestartet wird. Sie können auch die Funktion memcache_close() verwenden.

bool Memcache::close(Leere)

Memcache::addServer()

Fügt einen Server zum Verbindungspool hinzu. Eine Verbindung, die mit Memcache::addServer() geöffnet wurde, wird automatisch geschlossen, wenn das Skript abgeschlossen ist, oder Sie können sie manuell mit Memcache::close() schließen. Sie können die Funktion memcache_add_server() verwenden

Bei Verwendung von Memcache::addServer (im Gegensatz zu Memcache::connect() und Memcache::PConnect()) wird die Netzwerkverbindung erst dann hergestellt, wenn sie tatsächlich benötigt wird. Auf diese Weise entsteht kein Overhead beim Hinzufügen einer großen Anzahl von Servern zum Pool, auch wenn diese überhaupt nicht benötigt werden.

Ein Serverpool bietet eine höhere Fehlertoleranz. Alle Socket-Fehler oder Memcached-Fehler auf Serverebene (außer Speicherfehlern) führen zu einer Neuzuweisung von Ressourcen. Clientfehler wie das Hinzufügen eines vorhandenen Schlüssels führen nicht zu Fehlern.

Kommentar:

Gibt TRUE bei Erfolg oder FALSE bei Fehler zurück.

bool Memcache::addServer(string $host [, int $port = 11211 [, bool $persistent [, int $weight [, int $timeout [, int $retry_interval [, bool $status [, callable $failure_callback [, int $timeoutms]]]] ]]]])

• string $host – Memcached-Host. Dieser Parameter kann auch andere Transporte wie unix:///path/to/memcached.sock angeben, d. h. Verwenden Sie UNIX-Sockets. In diesem Fall muss der Port auf 0 gesetzt werden.
• int $port – der Port, an dem Memcached auf Verbindungen lauscht. Setzen Sie diesen Parameter auf 0, wenn Sie Sockets verwenden möchten.
• bool $persistent – ​​Legt die Verwendung einer dauerhaften Verbindung fest. Der Standardwert ist TRUE.
• int $weight – Je größer der Wert, desto wahrscheinlicher ist es, dass dieser Server zum Speichern der Werte ausgewählt wird. Diese. Dabei handelt es sich um eine Art „Gewicht“ des Servers im allgemeinen Pool, indirekt auch um die erwartete Belastung des Servers.
• int $timeout – Limit in Sekunden für die Verbindung zum Daemon. Denken Sie zweimal darüber nach, bevor Sie den Standardwert von 1 Sekunde ändern – Sie verlieren möglicherweise alle Vorteile des Cachings, wenn Ihre Verbindung zu lange dauert.
• Zeichenfolge $timeoutms – nicht beschrieben.

Erhalt der Informationen

Memcache::getExtendedStats()

Gibt ein zweidimensionales, assoziatives Array von Serverstatistiken zurück. Ein Array von Server-Host:Port-Schlüsseln. Die Werte enthalten individuelle Statistikparameter. Ausgefallene Server haben den Wert FALSE. Sie können auch die Funktion memcache_get_extended_stats() verwenden

Kommentar:

Diese Funktion wurde Memcache in Version 2.0.0 hinzugefügt

Array Memcache::getExtendedStats([ string $type [, int $slabid [, int $limit = 100 ]]])

Und jetzt ein Witz:

Der Statistiktyp „cachedump“ wurde aus Sicherheitsgründen aus Memcached entfernt

Beispiel einer Informationsausgabe (Aufruf ohne Parameter):

Array ( => Array ( => 5179 => 966862 => 1336505233 => 1.4.5 => 64 => 160.302880 => 483.975109 => 6 => 358080 => 13 => 15037476 => 3501979 => 46 => 1 1507898 => 3529578 => 0 => 0 => 0 => 76 => 0 => 0 => 0 => 0 => 0 => 0 => 0 => 1643906080 => 11298732744 => 67108864 => 1 => 0 => 4 => 0 => 3295454 => 7623 => 3501915 => 0 => 1825755) ...)

Memcache::getServerStatus()

Gibt den Online-/Offline-Status des Servers zurück. Sie können die Funktion auch nutzen memcache_get_server_status()

Kommentar:

Diese Funktion wurde Memcache in Version 2.0.0 hinzugefügt

int Memcache::getServerStatus(string $host [, int $port = 11211 ])

• string $host – Memcached-Host.
• int $port – der Port, an dem Memcached auf Verbindungen lauscht.

Memcache::getStats()

Gibt ein assoziatives Array mit Serverstatistiken zurück. Ein Array von Schlüsseln, die Statistikparametern und Werten für den Parameterwert entsprechen. Sie können die Funktion auch nutzen memcache_get_stats()

Array Memcache::getStats s ([ string $type [, int $slabid [, int $limit = 100 ]]])

• string $type – Statistiktyp. Gültige Werte: (Reset, Malloc, Karten, Cachedump, Platten, Elemente, Größen). Gemäß der Memcached-Protokollspezifikation können diese zusätzlichen Argumente „zur Vereinfachung für Entwickler geändert werden“.
• int $slabid – Wird verwendet, wenn der erste Parameter auf „cachedump“ gesetzt ist. Gibt den Server an, der für das Debuggen verwendet werden soll.
• int $limit – Wird verwendet, wenn der erste Parameter auf „cachedump“ gesetzt ist, um die Anzahl der Einträge im Dump zu begrenzen.

Memcache::getVersion()

Gibt eine Zeichenfolge zurück – die Serverversionsnummer. Auch Sie können die Funktion nutzen memcache_get_version().

Zeichenfolge Memcache::getVersion(Leere)

Memcache::setCompressThreshold()

Bietet automatische Komprimierung großer Werte. Sie können die Funktion auch nutzen memcache_set_compress_threshold()

Kommentar:

Diese Funktion wurde Memcache in Version 2.0.0 hinzugefügt

bool Memcache::setCompressThreshold(int $threshold [, float $min_ savings ])

• int $threshold – Mindestlänge des Werts, der automatisch komprimiert werden muss.
• float $min_ Savings – Legt das Komprimierungsverhältnis fest. Der angegebene Wert muss zwischen 0 und 1 liegen. Der Standardwert ist 0,2, was einer Komprimierungsersparnis von mindestens 20 % entspricht.

Memcache::setServerParams()

Ändert Serverparameter zur Laufzeit. Sie können die Funktion auch nutzen memcache_set_server_params().

Gibt TRUE bei Erfolg oder FALSE bei Fehler zurück.

Kommentar:

Diese Funktion wurde Memcache in Version 2.0.0 hinzugefügt

bool Memcache::setServerParams(string $host [, int $port = 11211 [, int $timeout [, int $retry_interval = false [, bool $status [, callable $failure_callback]]]]])

• string $host – Memcached-Host.
• int $port – der Port, an dem Memcached auf Verbindungen lauscht.
• int $timeout – Limit in Sekunden für die Verbindung zum Daemon. Denken Sie zweimal darüber nach, bevor Sie den Standardwert von 1 Sekunde ändern – Sie verlieren möglicherweise alle Vorteile des Cachings, wenn Ihre Verbindung zu lange dauert.
• int $retry_interval – Legt fest, wie oft ein ausgefallener Server abgefragt wird. Der Standardwert ist 15 Sekunden. Wenn Sie diesen Parameter auf -1 setzen, wird die automatische Wiederholung von Anforderungen deaktiviert.
• bool $status – Markiert den Server als ONLINE. Wenn Sie diesen Parameter auf FALSE und retry_interval -1 setzen, kann der ausgefallene Server in einem Pool aktiver Server verbleiben, sodass die Schlüsselzuteilungsalgorithmen nicht beeinträchtigt werden. Anfragen an diesen Server werden auf die verbleibenden verfügbaren Server verteilt. Der Standardwert ist TRUE, was bedeutet, dass der Server als ONLINE betrachtet werden sollte.
• aufrufbar $failure_callback – Ermöglicht dem Benutzer die Angabe einer Rückruffunktion, die ausgeführt werden soll, wenn ein Fehler erkannt wird. Die Funktion muss zwei Parameter annehmen, den Hostnamen und den Port des ausgefallenen Servers.

Mit diesem Beitrag möchte ich eine kleine Reihe von Beiträgen eröffnen, die auf den Materialien des Berichts von HighLoad++-2008 basieren. Anschließend wird der gesamte Text als ein großes PDF veröffentlicht.

Einführung

Zunächst zum Titel der Beitragsreihe: In den Beiträgen geht es um Caching im Web (in Webprojekten mit hoher Auslastung), um die Verwendung von Memcached zum Caching und um andere Verwendungsmöglichkeiten von Memcached in Webprojekten. Das heißt, alle drei Bestandteile des Namens in verschiedenen Kombinationen werden in dieser Beitragsreihe behandelt.

Caching ist heutzutage ein integraler Bestandteil jedes Webprojekts, nicht unbedingt eines mit hoher Auslastung. Für jede Ressource ist die Antwortzeit des Servers ein kritisches Merkmal für den Benutzer. Eine Erhöhung der Serverantwortzeit führt zu einem Abfluss von Besuchern. Daher ist es notwendig, die Antwortzeit zu minimieren: Dazu ist es notwendig, die Zeit zu reduzieren, die zum Generieren einer Antwort an den Benutzer erforderlich ist, und die Antwort an den Benutzer erfordert den Empfang von Daten von einigen externen Ressourcen (Backend). Diese Ressourcen können entweder Datenbanken oder andere relativ langsame Datenquellen sein (z. B. ein Remote-Dateiserver, auf dem wir den freien Speicherplatz überprüfen). Um eine Seite einer ziemlich komplexen Ressource zu generieren, müssen wir möglicherweise Dutzende ähnlicher Aufrufe durchführen. Viele von ihnen werden schnell sein: 20 ms oder weniger, aber es gibt immer eine kleine Anzahl von Abfragen, deren Rechenzeit in Sekunden oder Minuten berechnet werden kann (selbst im optimiertesten System kann es eine geben, obwohl ihre Anzahl minimal sein sollte). . Wenn wir die Zeit zusammenzählen, die wir damit verbringen, auf Abfrageergebnisse zu warten (wenn wir Abfragen parallel ausführen, nehmen wir die Rechenzeit der längsten Abfrage), erhalten wir eine unbefriedigende Antwortzeit.

Die Lösung für dieses Problem ist Caching: Wir legen das Ergebnis der Berechnungen in einem Speicher (z. B. Memcached) ab, der hervorragende Eigenschaften hinsichtlich der Zugriffszeit auf Informationen aufweist. Anstatt auf langsame, komplexe und umfangreiche Backends zuzugreifen, müssen wir jetzt nur noch eine Anfrage an den schnellen Cache stellen.

Memcached und Caching

Lokalitätsprinzip

Wir sehen Cache oder den Caching-Ansatz überall in elektronischen Geräten und in der Softwarearchitektur: CPU-Cache (erste und zweite Ebene), Festplattenpuffer, Betriebssystem-Cache, Puffer in einem Autoradio. Was bestimmt den Erfolg des Cachings? Die Antwort liegt im Lokalitätsprinzip: Ein Programm oder Gerät neigt dazu, in einem bestimmten Zeitraum mit einer bestimmten Teilmenge von Daten aus der allgemeinen Menge zu arbeiten. Im Falle von RAM bedeutet dies, dass, wenn ein Programm mit Daten arbeitet, die sich auf der Adresse 100 befinden, der nächste Zugriff mit größerer Wahrscheinlichkeit auf der Adresse 101, 102 usw. erfolgt und nicht beispielsweise auf der Adresse 10000. Das Gleiche gilt für eine Festplatte: Ihr Puffer wird mit Daten aus Bereichen neben den zuletzt gelesenen Sektoren gefüllt, wenn unsere Programme zu einem bestimmten Zeitpunkt nicht mit einem relativ kleinen Satz von Dateien, sondern mit dem gesamten Inhalt der Festplatte arbeiteten , Puffer wären bedeutungslos. Der Autoradio-Puffer liest die nächsten Musikminuten von der Festplatte, da wir eine Musikdatei eher der Reihe nach anhören, als durch eine Musikgruppe usw. zu springen.

Bei Webprojekten wird der Erfolg des Cachings dadurch bestimmt, dass die Site immer über die beliebtesten Seiten verfügt, einige Daten auf allen oder fast allen Seiten verwendet werden, das heißt, es gibt einige Auswahlen, die viel häufiger abgefragt werden als andere. Wir ersetzen mehrere Aufrufe an das Backend durch einen Aufruf zum Erstellen eines Caches, und alle nachfolgenden Aufrufe werden dann über einen schnell arbeitenden Cache durchgeführt.

Der Cache ist immer besser als die ursprüngliche Datenquelle: Der CPU-Cache ist um Größenordnungen schneller als der RAM, aber wir können den RAM nicht so schnell machen wie den Cache – das ist kostenineffizient und technisch anspruchsvoll. Der Festplattenpuffer erfüllt Datenanfragen um Größenordnungen schneller als die Festplatte selbst, aber der Puffer ist nicht in der Lage, sich Daten zu merken, wenn der Strom ausgeschaltet ist – in diesem Sinne ist er schlechter als das Gerät selbst. Ähnlich verhält es sich mit dem Caching im Web: Der Cache ist schneller und effizienter als das Backend, kann aber im Falle eines Serverneustarts oder -absturzes normalerweise keine Daten speichern und verfügt auch nicht über die Logik, um Ergebnisse zu berechnen: Es kann nur das zurückgeben, was wir zuvor eingegeben haben.

Im Speicher gespeichert

Memcached ist eine riesige In-Memory-Hash-Tabelle, auf die über ein Netzwerkprotokoll zugegriffen werden kann. Es bietet einen Dienst zum Speichern von mit Schlüsseln verknüpften Werten. Wir greifen über ein einfaches Netzwerkprotokoll auf den Hash zu; der Client kann ein Programm sein, das in einer beliebigen Programmiersprache geschrieben ist (es gibt Clients für C/C++, PHP, Perl, Java usw.).

Die einfachsten Operationen bestehen darin, den Wert des angegebenen Schlüssels abzurufen (get), den Wert des Schlüssels festzulegen (set) und den Schlüssel zu löschen (del). Um eine Kette atomarer Operationen zu implementieren (vorbehaltlich des gleichzeitigen Zugriffs auf Memcached durch parallele Prozesse), werden zusätzliche Operationen verwendet: Inkrementieren/Dekrementieren eines Schlüsselwerts (incr/decr), Anhängen von Daten an den Schlüsselwert am Anfang oder Ende (append /prepend), atomare Verknüpfung zum Abrufen/Festlegen von Werten (gets/cas) und andere.

Memcached wurde von Brad Fitzpatrick im Rahmen seiner Arbeit am LiveJournal-Projekt implementiert. Es wurde verwendet, um die Datenbank bei der Bereitstellung von Seiteninhalten von Anfragen zu entlasten. Heutzutage findet Memcached seinen Einsatz im Kern vieler großer Projekte, zum Beispiel Wikipedia, YouTube, Facebook und anderen.

Im Allgemeinen sieht das Caching-Schema so aus: Das Frontend (der Teil des Projekts, der die Antwort an den Benutzer generiert) muss Daten von einem Beispiel empfangen. Das Frontend kontaktiert den Cheetah-Fast-Memcached-Server für den Abrufcache (Get-Anfrage). Wird der entsprechende Schlüssel gefunden, endet die Arbeit dort. Andernfalls müssen Sie auf ein schweres, schwerfälliges, aber leistungsstarkes Backend (wie ein Elefant) zurückgreifen, bei dem es sich in den meisten Fällen um eine Datenbank handelt. Das resultierende Ergebnis wird sofort als Cache in Memcached geschrieben (Set-Request). In diesem Fall wird dem Schlüssel in der Regel eine maximale Lebensdauer (Ablaufdatum) zugewiesen, die dem Zeitpunkt des Zurücksetzens des Caches entspricht.

Dieses Standard-Caching-Schema wird immer implementiert. Anstelle von Memcached verwenden einige Projekte möglicherweise lokale Dateien oder andere Speichermethoden (eine andere Datenbank, PHP-Beschleuniger-Cache usw.), wie jedoch weiter unten gezeigt wird, funktioniert dieses Schema in einem Projekt mit hoher Auslastung möglicherweise nicht auf die effizienteste Weise . Dennoch werden wir uns in unserer weiteren Geschichte auf dieses Schema verlassen.

Memcached-Architektur

Wie funktioniert Memcached? Wie schafft es es, so schnell zu arbeiten, dass selbst Dutzende von Anfragen an Memcached, die für die Verarbeitung einer Seite der Site erforderlich sind, nicht zu einer nennenswerten Verzögerung führen? Gleichzeitig ist memcached hinsichtlich der Rechenressourcen äußerst anspruchslos: Bei einer geladenen Installation übersteigt die Prozessorzeit selten 10 %.

Erstens ist Memcached so konzipiert, dass alle seine Operationen eine algorithmische Komplexität von O(1) haben, d. h. Die Ausführungszeit einer Operation hängt nicht von der Anzahl der im Memcached gespeicherten Schlüssel ab. Das bedeutet, dass einige Operationen (oder Fähigkeiten) fehlen, wenn ihre Implementierung nur lineare (O(n)) Zeit erfordert. Daher verfügt memcached nicht über die Möglichkeit, Schlüssel „in Ordnern“ zusammenzufassen, d. h. jede Gruppierung von Schlüsseln, und wir werden keine Gruppenoperationen für Schlüssel oder ihre Werte finden.

Die wichtigsten optimierten Vorgänge sind die Zuweisung/Freigabe von Speicherblöcken zum Speichern von Schlüsseln und die Definition der LRU-Richtlinie (Least Used Keys), um den Cache zu leeren, wenn nicht genügend Speicher vorhanden ist. Die Suche nach Schlüsseln erfolgt durch Hashing und weist daher eine Komplexität von O(1) auf.

Verwendet asynchrone E/A und keine Threads, was zusätzliche Leistungssteigerungen und geringere Ressourcenanforderungen bietet. Tatsächlich kann memcached Threads verwenden, dies ist jedoch nur notwendig, um bei zu hoher Auslastung alle auf dem Server verfügbaren Kerne oder Prozessoren zu nutzen – es wird in keinem Fall für jede Verbindung ein Thread erstellt.

Tatsächlich können wir sagen, dass die Antwortzeit des Memcached-Servers nur von den Netzwerkkosten bestimmt wird und fast der Zeit entspricht, die benötigt wird, um ein Paket vom Frontend zum Memcached-Server (RTT) zu übertragen. Solche Eigenschaften ermöglichen die Verwendung von Memcached in Webprojekten mit hoher Auslastung, um verschiedene Probleme zu lösen, einschließlich der Datenzwischenspeicherung.

Schlüssel verloren

Memcached ist kein zuverlässiger Speicher; es ist möglich, dass ein Schlüssel vor Ablauf seiner Lebensdauer aus dem Cache entfernt wird. Die Projektarchitektur muss auf eine solche Situation vorbereitet sein und flexibel auf den Verlust von Schlüsseln reagieren. Es gibt drei Hauptgründe für den Schlüsselverlust:

1. Der Schlüssel wurde vor seinem Ablaufdatum gelöscht, da nicht genügend Speicher zum Speichern der Werte anderer Schlüssel vorhanden war. Memcached verwendet eine LRU-Richtlinie. Dieser Verlust bedeutet also, dass der Schlüssel selten verwendet wurde und Cache-Speicher frei wird, um gängigere Schlüssel zu speichern.
2. Der Schlüssel wurde gelöscht, da seine Lebensdauer abgelaufen war. Diese Situation ist streng genommen kein Verlust, da wir selbst die Lebensdauer des Schlüssels begrenzt haben, aber für den Client-Code in Bezug auf Memcached ist ein solcher Verlust nicht von anderen Fällen zu unterscheiden – beim Zugriff auf Memcached erhalten wir die Antwort „dort.“ gibt es keinen solchen Schlüssel.“
3. Die unangenehmste Situation ist der Absturz des zwischengespeicherten Prozesses oder des Servers, auf dem er sich befindet. In dieser Situation verlieren wir alle im Cache gespeicherten Schlüssel. Durch die Cluster-Organisation können Sie die Folgen etwas glätten: viele zwischengespeicherte Server, auf denen die Projektschlüssel „verteilt“ sind: Auf diese Weise sind die Folgen des Zusammenbruchs eines Caches weniger spürbar.

Bei der Entwicklung von Software, die mit Memcached funktioniert, müssen alle beschriebenen Situationen berücksichtigt werden. Wir können die Daten, die wir im Memcached speichern, nach der Schwere ihres Verlusts einteilen.

„Du könntest es verlieren“. Diese Kategorie umfasst Caches von Datenbankauswahlen. Der Verlust solcher Schlüssel ist nicht so schlimm, da wir ihre Werte durch einen erneuten Zugriff auf das Backend problemlos wiederherstellen können. Häufige Cache-Verluste führen jedoch zu unnötigen Datenbankaufrufen.

„Ich möchte nicht verlieren“. Hier können Sie Zähler für Website-Besucher, Ressourcenansichten usw. angeben. Obwohl es manchmal unmöglich ist, diese Werte direkt wiederherzustellen, haben die Werte dieser Schlüssel eine zeitlich begrenzte Bedeutung: Nach einigen Minuten ist ihr Wert nicht mehr relevant und es wird ein neuer Wert berechnet.

„Wir sollten auf keinen Fall verlieren“. Memcached ist praktisch zum Speichern von Benutzersitzungen – alle Sitzungen sind von allen im Frontend-Cluster enthaltenen Servern gleichermaßen zugänglich. Daher möchte ich niemals den Inhalt von Sitzungen verlieren – sonst werden Benutzer auf der Website „abgemeldet“. Wie kann man es vermeiden? Sie können Sitzungsschlüssel auf mehreren zwischengespeicherten Servern eines Clusters duplizieren, sodass die Wahrscheinlichkeit eines Verlusts verringert wird.

Jedes mehr oder weniger in Entwicklung befindliche Webprojekt stößt früher oder später auf Probleme, die am besten durch Caching gelöst werden können. Beispielsweise das Speichern aggregierter Daten in einer Speichereinrichtung, deren Berechnung und/oder Abruf viel Zeit in Anspruch nimmt. Für das Zwischenspeichern von Daten gibt es mehrere Möglichkeiten: Speichern der Daten auf der Festplatte oder im RAM. Jede Option hat ihre Vor- und Nachteile. Das Speichern auf der Festplatte ist langsam; die Aufzeichnung erfolgt sequentiell mithilfe von Sperren, deren Anzahl normalerweise durch das Betriebssystem begrenzt ist. Die Daten werden jedoch dauerhaft gespeichert und sind nach einem Neustart des Servers verfügbar. RAM hingegen ist schnell, ohne Sperren, wird aber bei einem Neustart nicht gespeichert. Es ist gefährlich, darin nicht duplizierte Daten zu speichern. Wenn beim Speichern auf der Festplatte alles klar und einfach ist, ist die Arbeit mit dem Speicher komplexer. Es gibt Apps, die diese Aufgabe übernehmen. Eines davon ist Memcached. In diesem Artikel werden wir darüber sprechen.

Memcached ist ein Open-Source-Server, der es Ihnen ermöglicht, Daten im RAM zwischenzuspeichern. Hat eine hohe Geschwindigkeit. Beliebt. Es verfügt über eine große Menge an Client-Bibliotheken, die in verschiedenen Programmiersprachen geschrieben sind.

Es gibt zwei Versionen von Bibliotheken in PHP: php-memcache und php-memcached. Der erste ist alt und nicht mehr ausgebaut. Der zweite ist neu und verfügt über einen größeren Funktionsumfang. Es gibt weitere Unterschiede zwischen ihnen und es liegt an Ihnen, zu entscheiden, welche Sie verwenden möchten. In diesem Artikel wird PHP-Memcached verwendet.

Um Memcached besser kennenzulernen, erstellen wir eine kleine Anwendung, die die grundlegenden Funktionen nutzt. Wir werden einen Schutz gegen das Erraten von Passwörtern während der Autorisierung schreiben. Der Kern der Anwendung besteht darin, dass die Anwendung die Anzahl der erfolglosen Versuche im Cache speichert, wenn Autorisierungsversuche fehlschlagen. Wenn diese Anzahl den festgelegten Mindestwert überschreitet, wird die Autorisierungsmöglichkeit für eine bestimmte Zeit gesperrt. Für 2-3 Minuten. In diesem Fall reduzieren wir die Effizienz des Passwort-Erratens erheblich.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

require_once __DIR__. "/func.php" ; if (! extension_loaded ("memcached") ) ( die ( „Memcached-Erweiterung nicht installiert“); ) $USE_CACHE_PROTECTION = true ; $AUTH_MAX_ATTEMPTS = 5 ; $AUTH_LOGIN = "demo" ; $AUTH_PASSWORD = "demo" ; $error = array () ; if (IS_POST() ) ( $login = _POST("username" ) ; $password = _POST("password" ); if (! $login ) ( $error [ "username" ] = "required" ; ) if (! $password ) ( $error [ "password" ] = "required" ; ) // MEMCACHE INITIEREN if ($USE_CACHE_PROTECTION ) ( $cache = new Memcached() ; $cache -> addServer ("127.0.0.1" , 11211 ); $cacheKey = "prefix::login-protect-" . $login ; // Cache-Schutz prüfen if ($USE_CACHE_PROTECTION && ! $error ) ( $attempts = $cache -> get ($cacheKey ) ; // FEHLERHAFTE VERSUCHE PRÜFEN if ($attempts >= $AUTH_MAX_ATTEMPTS ) ( $error [ "global" ] = "max_attempts" ; ) ) //Authentifizierung prüfen, wenn (! $error) ( //TODO: db bro verwenden, wenn ($login == $AUTH_LOGIN && $password == $AUTH_PASSWORD ) ( // DATEN BEI ERFOLGREICHER AUTH LÖSCHEN if ($USE_CACHE_PROTECTION ) ( $cache -> delete ($cacheKey ) ; ) stopAndRedirect("success.php" ) ; ) if ($USE_CACHE_PROTECTION ) ( / / ERHÖHUNGSVERSUCHE if (! $cache -> inkrementieren ($cacheKey) ) ( $cache -> set ($cacheKey, 1, 60)); ) ) $error [ "global" ] = "auth_faild" ; ) )

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

Demo zur Verwendung von Memcached in PHP Genehmigung "> Betreten

Wie Sie dem Code entnehmen können, ist alles äußerst einfach. Es wird ein eindeutiger Schlüssel erstellt, der aus dem Site-Präfix, dem Namen der Aufgabe und dem eingegebenen Login besteht. Als nächstes lesen wir, erhöhen den Zähler, löschen. Es lohnt sich, auf den Codeabschnitt zu achten, in dem das Skript den Zähler für fehlgeschlagene Autorisierungsversuche erhöht. Die Inkrementierungsmethode gibt zurück FALSCH wenn kein Eintrag im Memcached vorhanden ist. Daher setzen wir im Fehlerfall den Eintrag für genau 60 Sekunden auf den Wert 1.

Es lohnt sich, sich auf die Tatsache zu konzentrieren, dass wir die Inkrementierungsmethode verwenden und nicht set(getted_value+1) . Die Sache ist, dass die Set-Methode es nicht ermöglicht, den Zähler korrekt zu erhöhen, da sich die Daten zwischen den Lese- und Schreibintervallen ändern können. Beispielsweise kann gleichzeitig ein anderer Benutzer das Passwort erraten. Die Inkrementierungsmethode erhöht den Zähler garantiert korrekt!

Durch die Anwendung der in diesem Artikel enthaltenen Informationen können Sie den Memcached-Server und die für die Interaktion mit ihm erforderliche PHP-Erweiterung sowie den Analyse- und Statistikdienst phpMemcachedAdmin installieren und konfigurieren

Die Installation erfolgt unter Debian mit einem Backend-Server. Wenn Sie ein funktionierendes Bundle + php5-fpm haben, ersetzen Sie einfach apache2 durch php5-fpm in den Befehlen
Arbeitswerkzeuge: Dateimanager zum Verbinden von Software mit integriertem Editor oder Putty.

Nehmen wir nun an, wir haben auf diesem Hosting bereits eine Website http://example.com

Zuerst müssen Sie feststellen, wie PHP konfiguriert ist (was ist, wenn Memcached bereits installiert ist?)). Dazu erstellen wir im Stammverzeichnis der Website vorübergehend eine info.php-Datei mit dem Code

Schauen wir uns das nun genauer an: http://example.com/info.php

Wenn wir sehen, dass es einen ähnlichen Eintrag gibt, ist alles in Ordnung, die erforderliche PHP-Erweiterung ist installiert.
Wenn nicht, müssen Sie arbeiten.

So installieren Sie den Memcached-Server

Vor der Installation müssen Sie das Repository aktualisieren

Apt-get update && apt-get upgrade

Jetzt installieren wir Memcached und das PHP-Modul dafür

Apt-get installiert memcached php5-memcache

Installation läuft. Nach der Fertigstellung prüfen wir, was passiert ist

Als Ergebnis werden wir so etwas sehen

Tcp 0 0 *:11211 *:* LISTEN 13053/memcached

Jetzt müssen Sie Apache oder PHP-FPM neu starten

Dienst Apache2 neu starten

Memcached einrichten

Nachdem der Server nun installiert ist, muss er konfiguriert werden. Es ist nicht schwierig und wird nicht viel Zeit in Anspruch nehmen

Schließen von Memcached vor Zugriff von außen

Wie Sie sehen können, hängt Memcached standardmäßig an Port 11211. Da memcached nicht über integrierte Authentifizierungsmechanismen verfügt, kann sich jeder von außen einloggen und es für seine eigenen Zwecke nutzen. Um dies zu vermeiden, können Sie entweder Port 11211 mithilfe einer Firewall schließen oder den Memcached-Server so konfigurieren, dass er nur von localhost aus verwendet werden kann. Die letzte Methode wird unten beschrieben.

1. Fügen Sie die Zeile -l 127.0.0.1 hinzu

Memcached neu starten

Neustart im Speicher des Dienstes

/etc/init.d/memcached neu starten

Und wir prüfen noch einmal

Netstat -tap | grep memcached

Am Ende sollten wir so etwas sehen

Tcp 0 0 localhost.localdo:11211 *:* LISTEN 13092/memcached

Vergessen Sie auch nicht, Apache nach allen Änderungen neu zu starten

Dienst Apache2 neu starten

Erhöhen der Menge des zwischengespeicherten Arbeitsspeichers

Standardmäßig ist Memcached für die Nutzung von 64 Megabyte RAM vorgesehen. Ich werde auf 1024 erhöhen, Sie gehen von Ihren Serverparametern aus

1. Öffnen Sie die vi-Konfigurationsdatei /etc/memcached.conf
2. Finden Sie den Wert -m 64
3. Ändern Sie es in -m 1024
4. Memcached-Dienst neu starten Memcached-Neustart

Speichern von PHP-Sitzungen in Memcached

Wenn mehrere verschiedene Sites denselben Memcached-Server oder -Cluster verwenden, können sie gegenseitig ihre Sitzungen abfangen und Zugriff auf ihre Benutzerkonten erhalten, was eine potenzielle Gefahr darstellt

Sie können PHP beschleunigen, indem Sie den Sitzungsspeicher mithilfe von Memcached von der Festplatte auf den RAM verschieben

Sie sollten wissen, welche PHP-Erweiterung Sie verwenden, Memcache oder Memcached. , und Sie können mit phpinfo() herausfinden, was Sie haben, es gibt Feinheiten in den Einstellungen, seien Sie vorsichtig

Methode zum Erweitern des Memcaches

1. Öffnen Sie /etc/php5/mods-available/memcache.ini
2. Fügen Sie session.save_handler = memcache session.save_path = "tcp://127.0.0.1:11211" hinzu

Methode zum Erweitern von memcacheD

1. Öffnen Sie /etc/php5/mods-available/memcached.ini
2. Fügen Sie session.save_handler = memcached session.save_path = "127.0.0.1:11211" hinzu.
3. Starten Sie den Apache-Dienst Apache2 neu

PHPInfo wird überprüft

Jetzt müssen wir überprüfen, was wir am Ausgang haben. Öffnen Sie dazu die Seite mit phpinfo() und suchen Sie im Code in der Spalte mit lokalen Werten nach session.save_path. Der Wert sollte tcp://127.0.0.1:11211 oder 127.0.0.1:11211 ..conf sein), und wir suchen
php_admin_value session.save_path

Übrigens können Sie mit der php_value-Direktive auch nicht den gesamten Server global konfigurieren, sondern nur bestimmte Sites. Dazu können Sie .htaccess im Stammverzeichnis Ihrer Site bearbeiten

PHP_value session.save_handler „memcache“ PHP_value session.save_path „tcp://127.0.0.1:11211“

Fertige, funktionsfähige Memcached-Konfigurationsdatei

Sie können auch alles an Ihre Bedürfnisse anpassen, die Konfigurationsdatei enthält detaillierte Kommentare:

# zwischengespeicherte Standardkonfigurationsdatei # 2003 – Jay Bonci< ># Diese Konfigurationsdatei wird vom start-memcached-Skript gelesen, das als # Teil der Debian GNU/Linux-Distribution bereitgestellt wird. # Memcached als Daemon ausführen. Dieser Befehl ist impliziert und für die Ausführung des # Daemons nicht erforderlich. Weitere # Informationen finden Sie in der Datei README.Debian, die diesem Paket beiliegt. -d # Memcached-Ausgabe in /var/log/memcached-Protokolldatei protokollieren /var/log/memcached.log # Seien Sie ausführlicher # -v # Seien Sie noch ausführlicher (drucken Sie auch Client-Befehle) # -vv # Beginnen Sie mit einem Großbuchstaben von 64 Megabyte Speicher. Das ist sinnvoll und der Daemon ist standardmäßig # Beachten Sie, dass der Daemon auf diese Größe anwächst, aber zunächst nicht so viel # Speicher enthält # Die Menge an Speicher in Megabyte, die für das Caching reserviert ist. Standardmäßig 64 Megabyte. #-m 64 -m 1024 # Der Port, an dem Memcached hängen bleibt, standardmäßig 11211 -p 11211 # Führen Sie den Daemon als Root aus. Der Start-Memcached wird standardmäßig als Root ausgeführt, wenn in dieser Konfigurationsdatei kein # -u-Befehl vorhanden ist. -u memcache # Geben Sie an, welche IP-Adresse überwacht werden soll. Standardmäßig werden alle IP-Adressen überwacht. # Dieser Parameter ist eine der wenigen Sicherheitsmaßnahmen, die Memcached hat. Stellen Sie daher sicher, dass # eine Firewall-Schnittstelle überwacht wird. -l 127.0.0.1 # Begrenzen Sie die Anzahl gleichzeitig eingehender Verbindungen. Der Daemon-Standardwert ist 1024 # # -c 1024 # Sperren Sie den gesamten ausgelagerten Speicher, bevor Sie dies tun. # -k # Fehler zurückgeben, wenn der Speicher erschöpft ist (anstatt Elemente zu entfernen) # -M # Kerndatei maximieren Grenze # -r

Installieren der Memcache-Erweiterung

Nachfolgend finden Sie Schritt-für-Schritt-Befehle, die Ihnen bei der manuellen Installation der Memcache-PHP-Erweiterung über die Konsole helfen

Apt-get install php5-dev libmemcache-dev pecl download memcache tar xzvf memcache-2.2.6.tgz cd memcache-2.2.6/ phpize && ./configure --enable-memcache && make cp module/memcache.so /usr/ lib/php5/20060613/ echo „extension=memcache.so“ >> /etc/php5/apache2/php.ini

Starten Sie Apache neu, damit die Änderungen wirksam werden.

Dienst Apache2 neu starten

So überprüfen Sie, ob Memcached funktioniert

Lassen Sie uns eine memcachetest.php-Datei im Stammverzeichnis der Site erstellen und dort den folgenden Code schreiben

connect("localhost", 11211) or exit("Es konnte keine Verbindung zum Memcached-Server hergestellt werden"); $version = $memcache->getVersion(); echo „Serverversion: „.$version.“
\n"; $tmp_object = new stdClass; $tmp_object->str_attr = "test"; $tmp_object->int_attr = 123; $memcache->set("key", $tmp_object, false, 10) or die ("Not Ich habe es geschafft, einen Eintrag in Memcached zu hinterlassen“); echo „Wir schreiben Daten in den Memcached-Cache (Daten werden 10 Sekunden lang gespeichert)
\n"; $get_result = $memcache->get("key"); echo "In Memcached geschriebene Daten:
\n"; var_dump($get_result); ?>

Jetzt müssen nur noch die Ergebnisse überprüft werden: http://example.com/memcachetest.php
Wenn Sie alles richtig gemacht haben, sehen Sie so etwas wie

phpMemcachedAdmin – Überwachung, Statistik und Verwaltung von Memcached

phpMemcachedAdmin ist eine Software, die eine Weboberfläche zur Überwachung und Verwaltung des Memcached-Dienstes unter Linux bereitstellt. Ermöglicht das Anzeigen von Echtzeitstatistiken für alle vom Server unterstützten Vorgänge: Abrufen, Festlegen, Löschen, Erhöhen, Dekrementieren, Zurückfordern, Räumungen, CAS sowie Serverstatistiken: Netzwerk, Positionen, Arbeitsversion, gekoppelt mit Diagrammen und intern Serverkonfiguration.

Installation und Konfiguration von phpMemcachedAdmin

Hier haben Sie mehrere Möglichkeiten: Weisen Sie für den Betrieb dieses Dienstes eine separate Domain oder Subdomain zu. Oder Sie können auf Ihrer Arbeitsseite ein Unterverzeichnis erstellen und dort ein Passwort eingeben oder . Die letzte Methode zum Festlegen eines Passworts für einen Ordner beschreibe ich als einfacher.

Nehmen wir also an, wir haben eine Website https://site

Cd /var/www/site

Erstellen Sie ein Verzeichnis und gehen Sie dorthin

Mkdir phpMemcachedAdmin && cd phpMemcachedAdmin

Laden Sie die neueste Version der Distribution herunter

Wget http://phpmemcacheadmin.googlecode.com/files/phpMemcachedAdmin-1.2.2-r262.tar.gz

Entpacken und löschen Sie das Distributionsarchiv

Tar -xvzf phpMemcachedAdmin-1.2.2-r262.tar.gz && rm -rf phpMemcachedAdmin-1.2.2-r262.tar.gz

Legen Sie die erforderlichen Zugriffsrechte im aktuellen Verzeichnis rekursiv fest

Finden Sie ./ -type f -exec chmod 0644 () \; find ./ -type d -exec chmod 0755 () \;

AuthType Basic AuthName „Privater Bereich“ AuthUserFile .htpasswd Benutzer memcachedmanager erforderlich

Erstellen Sie.htpasswd

Htpasswd -c .htpasswd memcachedmanager

Geben Sie Ihr Passwort ein.

Das ist alles. Melden Sie sich beim memcachedmanager-Verzeichnis an, sofern Sie es nicht geändert haben. Öffnen Sie https://site/phpMemcachedAdmin (ändern Sie die Domain zu Ihrer), geben Sie Ihren Benutzernamen/Ihr Passwort ein und verwenden Sie

Abschließend

Ich empfehle, den Artikel über Memcached zu lesen. Es enthüllt allgemeine Informationen darüber und einige Feinheiten seiner Arbeit.
Das ist alles. Wenn etwas unklar ist, stellen Sie Fragen in den Kommentaren.