Redis und Memcached Installation: Cache-Schicht Leitfaden

Eine Cache-Schicht ist eine kritische Infrastrukturkomponente, die die Leistung von Webanwendungen dramatisch verbessert. Durch das Speichern von Datenbankabfragen, API-Antworten und Berechnungsergebnissen im Arbeitsspeicher werden Millisekunden-Antwortzeiten bei wiederholten Anfragen ermoeglicht. Dieser Leitfaden behandelt die Installation, Konfiguration und Anwendungsintegration von Redis und Memcached.

Redis vs Memcached

Beide Systeme bieten hochleistungsfahige In-Memory-Datenspeicherung, richten sich jedoch an unterschiedliche Anwendungsfalle:

Funktion	Redis	Memcached
Datenstrukturen	String, Hash, List, Set, ZSet	Nur String
Persistenz	RDB + AOF	Keine
Replikation	Master-Replica + Cluster	Keine
Pub/Sub	Ja	Nein
Lua-Scripting	Ja	Nein
Multi-Threading	Teilweise (I/O)	Vollstandig
Speichereffizienz	Mittel	Hoch

Redis wird fur neue Projekte empfohlen. Mit umfangreichen Datenstrukturen, Persistenz und Replikationsunterstutzung deckt es weitaus mehr Anwendungsfalle ab. Memcached wird nur bevorzugt, wenn einfaches String-Caching und maximale Multi-Thread-Leistung benotigt werden.

Redis Installation (Ubuntu/Debian)

Installation aus dem Paket-Repository

hljs bash

# Paketliste aktualisieren
apt update

# Redis installieren
apt install -y redis-server

# Dienststatus pruefen
systemctl status redis-server

# Autostart aktivieren
systemctl enable redis-server

Installation aus dem offiziellen Redis-Repository (Neueste Version)

hljs bash

# Erforderliche Tools installieren
apt install -y curl gpg

# Redis GPG-Schlussel hinzufuegen
curl -fsSL https://packages.redis.io/gpg | gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg

# Repository hinzufuegen
echo 'deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb '$(lsb_release -cs)' main' | tee /etc/apt/sources.list.d/redis.list

# Aktualisieren und installieren
apt update
apt install -y redis

Redis-Version verifizieren

hljs bash

redis-server --version
# Ausgabe: Redis server v=7.x.x ...

redis-cli --version
# Ausgabe: redis-cli 7.x.x

Redis Installation (CentOS/AlmaLinux/Rocky Linux)

hljs bash

# EPEL-Repository aktivieren
dnf install -y epel-release

# Redis installieren
dnf install -y redis

# Dienst starten und aktivieren
systemctl start redis
systemctl enable redis

# Status pruefen
systemctl status redis

Redis Konfiguration

Grundlegende Konfigurationsdatei

hljs bash

# Konfigurationsdatei bearbeiten
nano /etc/redis/redis.conf

hljs ini

# Lausch-Adresse (nur localhost)
bind 127.0.0.1

# Port (Standard 6379)
port 6379

# Passwortschutz
requirepass StarkesRedisPasswort123!

# Maximale Speichernutzung
maxmemory 512mb

# Raumungsrichtlinie bei vollem Speicher
maxmemory-policy allkeys-lru

# Als Daemon ausfuhren
daemonize yes

# Log-Datei
logfile /var/log/redis/redis-server.log

# Anzahl der Datenbanken
databases 16

Konfiguration anwenden

hljs bash

systemctl restart redis-server

# Konfiguration verifizieren
redis-cli -a StarkesRedisPasswort123! ping
# Ausgabe: PONG

Redis Grundbefehle

Verbindung und Grundoperationen

hljs bash

# Mit Redis CLI verbinden
redis-cli

# Mit Passwort verbinden
redis-cli -a StarkesRedisPasswort123!

# Mit Remote-Server verbinden
redis-cli -h 192.168.1.100 -p 6379 -a passwort

hljs redis

# Verbindungstest
PING
# Antwort: PONG

# String-Wert setzen
SET benutzer:1:name 'Max Mustermann'

# Wert lesen
GET benutzer:1:name

# Wert mit TTL setzen (in Sekunden)
SETEX sitzung:abc123 3600 'benutzer_daten'

# Verbleibende Zeit pruefen
TTL sitzung:abc123

# Wert loeschen
DEL benutzer:1:name

# Pruefen ob Schlussel existiert
EXISTS benutzer:1:name

# Alle Schluessel auflisten (in Produktion vorsichtig verwenden)
KEYS *

# Mit Muster suchen
KEYS benutzer:*

Hash-Befehle

hljs redis

# Hash setzen
HSET benutzer:1 name 'Max' email 'max@example.com' alter 30

# Hash-Feld lesen
HGET benutzer:1 name

# Alle Hash-Felder lesen
HGETALL benutzer:1

# Hash-Feld loeschen
HDEL benutzer:1 alter

# Pruefen ob Hash-Feld existiert
HEXISTS benutzer:1 email

Listen-Befehle

hljs redis

# Element zur Liste hinzufuegen (links)
LPUSH aufgaben 'aufgabe1' 'aufgabe2'

# Element zur Liste hinzufuegen (rechts)
RPUSH aufgaben 'aufgabe3'

# Element aus Liste holen (links)
LPOP aufgaben

# Listenlaenge
LLEN aufgaben

# Listenbereich
LRANGE aufgaben 0 -1

Set- und Sorted-Set-Befehle

hljs redis

# Element zu Set hinzufuegen
SADD tags 'redis' 'cache' 'nosql'

# Set-Mitglieder auflisten
SMEMBERS tags

# Zu Sorted Set mit Score hinzufuegen
ZADD bestenliste 1500 'spieler1' 2300 'spieler2' 800 'spieler3'

# Sortiert auflisten (aufsteigend)
ZRANGE bestenliste 0 -1 WITHSCORES

# Sortiert auflisten (absteigend)
ZREVRANGE bestenliste 0 2 WITHSCORES

Redis Persistenz-Einstellungen

RDB (Redis Database) Snapshot

RDB schreibt in bestimmten Intervallen einen Snapshot des gesamten Datensatzes auf die Festplatte:

hljs ini

# /etc/redis/redis.conf

# Speichern wenn 1 Aenderung in 900 Sekunden
save 900 1

# Speichern wenn 10 Aenderungen in 300 Sekunden
save 300 10

# Speichern wenn 10000 Aenderungen in 60 Sekunden
save 60 10000

# RDB-Dateiname
dbfilename dump.rdb

# RDB-Verzeichnis
dir /var/lib/redis

AOF (Append Only File)

AOF fuegt jeden Schreibvorgang an eine Log-Datei an und bietet zuverlassigere Persistenz:

hljs ini

# AOF aktivieren
appendonlyfile yes

# AOF-Dateiname
appendfilename 'appendonly.aof'

# Synchronisierungsrichtlinie
# always: Bei jedem Schreibvorgang (sicherste, langsamste)
# everysec: Jede Sekunde (empfohlen)
# no: Dem OS uberlassen (schnellste, unsicherste)
appendsync everysec

# AOF-Neuschreib-Schwellenwert
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

In der Produktion wird empfohlen, sowohl RDB als auch AOF zu verwenden. RDB ermoeglicht schnelle Neustarts, wahrend AOF den Datenverlust minimiert.

Memcached Installation

Installation auf Ubuntu/Debian

hljs bash

# Paketliste aktualisieren
apt update

# Memcached installieren
apt install -y memcached libmemcached-tools

# Dienststatus pruefen
systemctl status memcached

# Autostart aktivieren
systemctl enable memcached

Installation auf CentOS/AlmaLinux

hljs bash

# Memcached installieren
dnf install -y memcached

# Dienst starten und aktivieren
systemctl start memcached
systemctl enable memcached

Memcached Konfiguration

hljs bash

# Konfigurationsdatei bearbeiten
nano /etc/memcached.conf

hljs ini

# Speicherlimit (MB)
-m 256

# Lausch-Adresse
-l 127.0.0.1

# Port
-p 11211

# Maximale Verbindungen
-c 1024

# Thread-Anzahl (basierend auf CPU-Kernen)
-t 4

# Maximale Objektgroesse (Bytes)
-I 1m

hljs bash

# Dienst neu starten
systemctl restart memcached

# Verbindung testen
echo 'stats' | nc 127.0.0.1 11211

Memcached Grundbefehle

hljs bash

# Verbindung via Telnet
telnet 127.0.0.1 11211

# Wert setzen (Schlussel, Flag, TTL Sekunden, Groesse Bytes)
set sitzung:xyz 0 3600 12
benutzer_daten

# Wert lesen
get sitzung:xyz

# Wert loeschen
delete sitzung:xyz

# Statistiken anzeigen
stats

# Alle Daten loeschen
flush_all

Anwendungsintegration

PHP mit Redis

hljs bash

# PHP Redis-Erweiterung installieren
apt install -y php-redis
systemctl restart php8.x-fpm

hljs php

<?php
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);
$redis->auth('StarkesRedisPasswort123!');

// In Cache schreiben
$redis->setex('benutzer:1', 3600, json_encode(['name' => 'Max', 'email' => 'max@example.com']));

// Aus Cache lesen
$daten = $redis->get('benutzer:1');
if ($daten) {
    $benutzer = json_decode($daten, true);
} else {
    // Aus Datenbank holen und cachen
    $benutzer = aus_datenbank_holen(1);
    $redis->setex('benutzer:1', 3600, json_encode($benutzer));
}

Node.js mit Redis

hljs bash

# ioredis-Paket installieren
npm install ioredis

hljs javascript

const Redis = require('ioredis');

const redis = new Redis({
  host: '127.0.0.1',
  port: 6379,
  password: 'StarkesRedisPasswort123!'
});

// In Cache schreiben
await redis.setex('produkt:42', 1800, JSON.stringify({ name: 'Laptop', preis: 999 }));

// Aus Cache lesen
const daten = await redis.get('produkt:42');
if (daten) {
  const produkt = JSON.parse(daten);
  console.log(produkt);
}

// Cache loeschen
await redis.del('produkt:42');

Python mit Redis

hljs bash

# redis-py-Paket installieren
pip install redis

hljs python

import redis
import json

r = redis.Redis(
    host='127.0.0.1',
    port=6379,
    password='StarkesRedisPasswort123!',
    decode_responses=True
)

# In Cache schreiben
r.setex('artikel:5', 7200, json.dumps({'titel': 'Redis Leitfaden', 'inhalt': '...'}))

# Aus Cache lesen
daten = r.get('artikel:5')
if daten:
    artikel = json.loads(daten)

Dienstverwaltung

hljs bash

# Redis Dienstverwaltung
systemctl start redis-server
systemctl stop redis-server
systemctl restart redis-server
systemctl status redis-server

# Redis-Logs anzeigen
journalctl -u redis-server -f
tail -f /var/log/redis/redis-server.log

# Redis-Informationen via CLI abrufen
redis-cli INFO server
redis-cli INFO memory
redis-cli INFO stats

# Memcached Dienstverwaltung
systemctl start memcached
systemctl stop memcached
systemctl restart memcached
systemctl status memcached

Fazit

Redis und Memcached sind leistungsstarke Cache-Loesungen, die die Anwendungsleistung erheblich verbessern. Die umfangreichen Datenstrukturen und Persistenzfunktionen von Redis machen es fuer die meisten Szenarien ideal, wahrend Memcached fuer einfache, hochleistungsfahige String-Caching-Anforderungen bevorzugt werden kann. Beide Systeme laufen problemlos auf REXE-Servern.

Redis und Memcached Installation: Cache-Schicht Leitfaden

Inhaltsverzeichnis