Distribuerad cachelagring med Redis/Memcached
Implementera och hantera distribuerade cachar med tekniker som Redis eller Memcached för LLM-applikationer i stor skala.
Distribuerad cachelagring med Redis/Memcached är en gratis lektion i LLM-applikationer i produktion (RAG + vektordatabaser + cachning) på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för LLM-applikationer i produktion (RAG + vektordatabaser + cachning), och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i LLM-applikationer i produktion (RAG + vektordatabaser + cachning) innehåller totalt 4 lektioner.
Distribuerad cachning: Varför
När ni bygger LLM-applikationer i stor skala kommer ni att möta utmaningar som hög fördröjning och ökade API-kostnader. Cachning hjälper, men vad händer när appen växer bortom en enda server?
Distribuerad cachning sprider cachen över flera servrar. Det gör att många instanser av applikationen kan dela samma cachade data, vilket förbättrar prestanda och konsekvens.
Skala LLM-appar
Föreställ er att LLM-appen körs på flera servrar. Om varje server har en egen cache i "minnet" delar de inte data. Det innebär:
- Duplicerat arbete: Server A kan generera ett LLM-svar på nytt som redan har cachats av Server B.
- Inkonsistenta data: Om en server uppdaterar sin cache får de andra inte veta det.
- Begränsad kapacitet: Varje servers minne är begränsat.
Distribuerade cacher löser detta genom att tillhandahålla ett gemensamt externt datalager.
Möt Redis: nyckel-värde-lager
Redis (Remote Dictionary Server) är ett datalager för datastrukturer i minnet med öppen källkod, som används som databas, cache och meddelandeförmedlare.
- Det är mycket snabbt eftersom data lagras i RAM.
- Det stöder olika datastrukturer som strängar, hashtabeller, listor, mängder och annat.
- Det är mycket flexibelt och används i stor utsträckning för cachning i distribuerade system.
Redis: lagra och hämta data
I grunden fungerar Redis som en ordlista eller en hash map. Ni lagrar data med en nyckel och hämtar den med samma nyckel.
I LLM-appar kan ni använda en unik identifierare (till exempel en hashad prompt) som nyckel och LLM:ets genererade svar som värde. Redis hanterar lagringen och hämtningen i er distribuerade miljö.
Cacha LLM-svar med Redis
Vi ska se hur biblioteket redis-py kan användas för att ansluta till en Redis-server och cacha ett simulerat LLM-svar. Exemplet förutsätter att Redis körs lokalt.
import redis
import hashlib
# Connect to Redis (default host/port)
r = redis.Redis(host='localhost', port=6379, db=0)
def get_llm_response(prompt):
# Simulate an LLM call
print(f"Simulating LLM call for: '{prompt}'")
return f"LLM response for '{prompt}'"
def get_cached_or_generate(prompt):
# Create a simple cache key from the prompt
cache_key = "llm_response:" + hashlib.md5(prompt.encode('utf-8')).hexdigest()
# Try to get from cache
cached_response = r.get(cache_key)
if cached_response:
print("Cache hit!")
return cached_response.decode('utf-8')
else:
print("Cache miss. Generating response...")
response = get_llm_response(prompt)
# Store in cache with a 60-second expiry (TTL)
r.setex(cache_key, 60, response)
return response
if __name__ == "__main__":
prompt1 = "Explain distributed caching in one sentence."
prompt2 = "What is the capital of France?"
print("--- First call for prompt1 ---")
print(get_cached_or_generate(prompt1))
print("\n--- Second call for prompt1 (should be cached) ---")
print(get_cached_or_generate(prompt1))
print("\n--- First call for prompt2 ---")
print(get_cached_or_generate(prompt2))
# Clean up (optional) - uncomment if you want to clear after running
# r.delete("llm_response:" + hashlib.md5(prompt1.encode('utf-8')).hexdigest())
# r.delete("llm_response:" + hashlib.md5(prompt2.encode('utf-8')).hexdigest())
Introduktion till Memcached
Memcached är ytterligare ett populärt, högpresterande, distribuerat system för cachning av minnesobjekt.
- Det är enklare än Redis och fokuserar helt på cachning av nyckel-värde-par.
- Det används ofta för att cacha resultat från databasfrågor, API-svar eller renderade HTML-fragment.
- Det är utformat för horisontell skalning, så att ni enkelt kan lägga till fler servrar.
Redis jämfört med Memcached: jämförelse
Båda passar utmärkt för distribuerad cachning, men har vissa skillnader:
- Redis: Har fler funktioner (datastrukturer, beständig lagring, pub/sub). Passar för många användningsområden utöver enkel cachning.
- Memcached: En enklare, renodlad cachningslösning. Är ofta mer minneseffektiv för mycket stora, enkla nyckel-värde-datamängder.
För LLM-applikationer gör Redis flexibilitet det ofta till det föredragna valet, särskilt vid mer komplexa cachningsbehov eller när andra Redis-funktioner önskas.
Utforma effektiva cache-nycklar
En bra cache-nyckel är avgörande. För LLM-svar behöver ni en nyckel som identifierar förfrågan unikt.
- Beräkna en hash av prompten: Använd en kryptografisk hash (till exempel MD5 eller SHA256) av hela promptsträngen.
- Inkludera parametrar: Om ert LLM-anrop har temperatur, modellnamn eller andra parametrar ska ni inkludera dem i hashen.
- Namnområde: Lägg till prefix i nycklarna (till exempel
"llm_response:...") för att organisera cachen.
Grundläggande cache-expirering (TTL)
Cachad data kan bli inaktuell. För att förhindra detta stöder distribuerade cacher Time-To-Live (TTL), vilket automatiskt gör data ogiltig efter en angiven tidsperiod.
Ni såg r.setex(key, 60, value) i koden. Det gör att nyckeln upphör att gälla efter 60 sekunder. Välj en TTL utifrån hur ofta de underliggande data ändras eller hur viktigt det är att data är aktuella.
Snabbkontroll: distribuerad cachning
Ni utformar en RAG-applikation i stor skala. Ni behöver cacha LLM-svar mellan flera instanser av applikationen. Varje instans ska kunna komma åt samma cachade data.
Vilket tillvägagångssätt passar bäst för detta krav?
Sammanfattning: Distribuerad cachning
Vi har undersökt hur distribuerad cachning är avgörande för att skala LLM-applikationer och hantera begränsningarna hos lokala cacher i minnet.
- Redis och Memcached är kraftfulla verktyg för att bygga gemensamma högpresterande cacher.
- Vi har lärt oss att använda Redis för grundläggande nyckel-värde-lagring och för att hämta LLM-svar.
- Effektiv utformning av cache-nycklar och användning av Time-To-Live (TTL) är avgörande för att hantera hur aktuella cachedata är.
Detta tillvägagångssätt förbättrar prestandan avsevärt och minskar driftskostnaderna för era LLM-distributioner.
Lär dig LLM-applikationer i produktion (RAG + vektordatabaser + cachning) med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 48
Vanliga frågor
Är lektionen ”Distribuerad cachelagring med Redis/Memcached” gratis?
Ja – hela texten till ”Distribuerad cachelagring med Redis/Memcached” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i LLM-applikationer i produktion (RAG + vektordatabaser + cachning), kan Ni uppgradera till CoddyKit PRO. Kursen i LLM-applikationer i produktion (RAG + vektordatabaser + cachning) innehåller totalt 4 lektioner.
Vad lär jag mig i ”Distribuerad cachelagring med Redis/Memcached”?
Implementera och hantera distribuerade cachar med tekniker som Redis eller Memcached för LLM-applikationer i stor skala. Ni övar på LLM-applikationer i produktion (RAG + vektordatabaser + cachning) med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig LLM-applikationer i produktion (RAG + vektordatabaser + cachning)?
Du behöver inga förkunskaper. Utbildningen i LLM-applikationer i produktion (RAG + vektordatabaser + cachning) på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Distribuerad cachelagring med Redis/Memcached”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här LLM-applikationer i produktion (RAG + vektordatabaser + cachning)-lektionen?
Ja. Varje LLM-applikationer i produktion (RAG + vektordatabaser + cachning)-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Distribuerad cachelagring med Redis/Memcached
- Sessionshantering och beständig kontext
- Avancerade strategier för cacheogiltigförklaring
- Semantisk caching för LLM-svar