Blog
Kosteneffizientes Caching mit Amazon ElastiCache für Valkey
Senior Cloud Architect
Mit der Einführung von Amazon ElastiCache für Valkey bietet AWS eine leistungsstarke, kosteneffiziente und offene Alternative zu Redis OSS. Valkey ist ein moderner, von der Linux Foundation betreuter Key-Value-Datenspeicher, der als Drop-in Replacement für Redis entwickelt wurde – ideal für innovative Unternehmen, die auf technologische Offenheit setzen.
Was macht Valkey besonders?
Valkey spricht dieselbe Sprache wie Redis, punktet aber mit:
- einer aktiven, wachsenden Open-Source Community,
- modernen Architekturentscheidungen und
- einem deutlich attraktiveren Preismodell.
Für viele Organisationen ist das ein konkreter Schritt in Richtung digitaler Souveränität.
Serverless Valkey: Caching neu gedacht
Die Serverless-Variante von ElastiCache für Valkey senkt die Einstiegshürden drastisch:
- 33 % günstiger als andere unterstützte Engines
- 100 MB Mindestgröße – das sind 90 % weniger als bei Redis OSS
- Einstiegspreis: ab 6 USD pro Monat
Ideal geeignet für:
- kleine Datenmengen
- geringe Zugriffshäufigkeit
- niedriges Datenvolumen pro Anfrage
Typische Anwendungsfälle: Testumgebungen, Staging-Setups oder temporäre Workloads, bei denen Flexibilität und Kostenkontrolle im Fokus stehen.
Ist Serverless die richtige Wahl für Sie?
Analysieren Sie mit einem einfachen Python-Skript (Quelle: AWS), ob sich ein Wechsel zu Serverless Valkey für Sie lohnt. Es ermittelt die:
- durchschnittliche Cache-Größe (in GB)
- durchschnittliche Anfragenrate (in req/s)
- durchschnittlich übertragene Datenmenge pro Anfrage (in KB)
import boto3
import argparse
from datetime import datetime, timedelta
parser = argparse.ArgumentParser()
parser.add_argument('-i', '--id', required=True, help='NodeId or ClusterId')
args = parser.parse_args()
# Initialize boto3 clients
cloudwatch = boto3.client('cloudwatch')
# Define the time period
end_time = datetime.utcnow()
start_time = end_time - timedelta(days=30) # last 30 days
def get_metric_statistics(metric_name, namespace, period, start_time, end_time, statistics, dimensions):
response = cloudwatch.get_metric_statistics(
Namespace=namespace,
MetricName=metric_name,
StartTime=start_time,
EndTime=end_time,
Period=period,
Statistics=statistics,
Dimensions=dimensions
)
return response['Datapoints']
# Get average cache size in GB
bytes_used_for_cache = get_metric_statistics(
metric_name='BytesUsedForCache',
namespace='AWS/ElastiCache',
period=3600,
start_time=start_time,
end_time=end_time,
statistics=['Average'],
dimensions=[{'Name': 'CacheClusterId', 'Value': args.id}]
)
average_cache_size_gb = sum([datapoint['Average'] for datapoint in bytes_used_for_cache]) / len(bytes_used_for_cache) / (1024 ** 3)
# Get average request rate
cmd_get = get_metric_statistics(
metric_name='GetTypeCmds',
namespace='AWS/ElastiCache',
period=3600,
start_time=start_time,
end_time=end_time,
statistics=['Sum'],
dimensions=[{'Name': 'CacheClusterId', 'Value': args.id}]
)
cmd_set = get_metric_statistics(
metric_name='SetTypeCmds',
namespace='AWS/ElastiCache',
period=3600,
start_time=start_time,
end_time=end_time,
statistics=['Sum'],
dimensions=[{'Name': 'CacheClusterId', 'Value': args.id}]
)
average_request_rate = (sum([datapoint['Sum'] for datapoint in cmd_get]) + sum([datapoint['Sum'] for datapoint in cmd_set])) / (7 * 24 * 3600)
# Get average data transferred per request in KB
network_bytes_in = get_metric_statistics(
metric_name='NetworkBytesIn',
namespace='AWS/ElastiCache',
period=3600,
start_time=start_time,
end_time=end_time,
statistics=['Sum'],
dimensions=[{'Name': 'CacheClusterId', 'Value': args.id}]
)
network_bytes_out = get_metric_statistics(
metric_name='NetworkBytesOut',
namespace='AWS/ElastiCache',
period=3600,
start_time=start_time,
end_time=end_time,
statistics=['Sum'],
dimensions=[{'Name': 'CacheClusterId', 'Value': args.id}]
)
total_network_bytes = sum([datapoint['Sum'] for datapoint in network_bytes_in]) + sum([datapoint['Sum'] for datapoint in network_bytes_out])
total_requests = sum([datapoint['Sum'] for datapoint in cmd_get]) + sum([datapoint['Sum'] for datapoint in cmd_set])
average_data_per_request_kb = (total_network_bytes / total_requests) / 1024
print(f"Average Cache Size (GB): {average_cache_size_gb}")
print(f"Average Request Rate (requests/second): {average_request_rate}")
print(f"Average Data Transferred per Request (KB): {average_data_per_request_kb}")
Die Ergebnisse können Sie direkt im AWS Pricing Calculator eintragen, um realistische Kostenprognosen zu erhalten.
Beispielausgabe:
- Cache-Größe: 0,29 GB
- Anfragen: 21,5 req/s
- Daten pro Request: 2,7 KB
Ergebnis: Serverless Valkey ist in diesem Fall eindeutig kostengünstiger als ein vergleichbares Node-basiertes Setup.
Auch für Node-basierte Workloads interessant
Sie benötigen weiterhin eine klassische Node-basierte Architektur? Kein Problem: Auch hier bietet Valkey klare Kostenvorteile:
- 20 % günstiger als Redis – ohne Funktionsverlust
Valkey Serverless können Sie auch in produktiven Umgebungen sinnvoll einsetzen, sofern Datenmenge, Zugriffsmuster und Latenzanforderungen passen. Ist dies nicht der Fall – etwa bei konstant hoher Last oder komplexeren Betriebsanforderungen –, bietet die Node.js-basierte Variante eine stabile und skalierbare Alternative, beispielsweise in Staging-Setups oder beim dauerhaften Produktionsbetrieb mit hohem Ressourcenbedarf.
Fazit
Mit Amazon ElastiCache für Redis auf AWS steht Ihnen ein modernes, leistungsfähiges und kosteneffizientes Caching-Tool zur Verfügung – unabhängig davon, ob Sie sich für eine serverlose oder eine Node.js-basierte Lösung entscheiden. Gleichzeitig fördert Valkey mit seinem Open-Source-Modell Ihre technologische Unabhängigkeit und hilft Ihnen, Ihre Cloud-Kosten gezielt zu optimieren.
Gerne unterstützt Sie Skaylink bei der Analyse, ob Serverless Valkey oder eine Node.js-basierte Variante besser zu Ihrem Anwendungsszenario passt, und begleitet Sie auf Wunsch bei Migration und Betrieb. Mit unserem Managed-Valkey-Angebot kombinieren Sie Betriebssicherheit mit Flexibilität und behalten dabei die maximale Kontrolle bei minimalem Aufwand.
Sprechen Sie uns an – wir zeigen Ihnen, wie Sie Valkey effizient und sicher in Ihre AWS-Umgebung integrieren.