Python + Memcached:Effektiv cachelagring i distribuerede applikationer

Når du skriver Python-applikationer, er caching vigtigt. Brug af en cache til at undgå genberegning af data eller adgang til en langsom database kan give dig et fantastisk ydelsesboost.

Python tilbyder indbyggede muligheder for caching, fra en simpel ordbog til en mere komplet datastruktur såsom functools.lru_cache . Sidstnævnte kan cache ethvert element ved hjælp af en algoritme, der er brugt mindst for nylig for at begrænse cachestørrelsen.

Disse datastrukturer er dog pr. definition lokale til din Python-proces. Når flere kopier af din applikation kører på tværs af en stor platform, tillader brug af en datastruktur i hukommelsen ikke deling af det cachelagrede indhold. Dette kan være et problem for store og distribuerede applikationer.

Derfor, når et system er distribueret på tværs af et netværk, har det også brug for en cache, der er distribueret på tværs af et netværk. I dag er der masser af netværksservere, der tilbyder caching-kapacitet - vi har allerede dækket, hvordan man bruger Redis til caching med Django.

Som du vil se i denne tutorial, er memcached en anden god mulighed for distribueret caching. Efter en hurtig introduktion til grundlæggende memcached-brug lærer du om avancerede mønstre såsom "cache and set" og brug af reservecaches for at undgå problemer med ydelse af kold cache.

Installerer memcached

Memcached er tilgængelig for mange platforme:

• Hvis du kører Linux , kan du installere det ved at bruge apt-get install memcached eller yum install memcached . Dette vil installere memcached fra en forudbygget pakke, men du kan også bygge memcached fra kilden, som forklaret her.
• Til macOS , at bruge Homebrew er den enkleste mulighed. Bare kør brew install memcached efter du har installeret Homebrew-pakkehåndteringen.
• På Windows , skal du selv kompilere memcached eller finde præ-kompilerede binære filer.

Når den er installeret, memcached kan simpelthen startes ved at kalde memcached kommando:

$ memcached

Før du kan interagere med memcached fra Python-land, skal du installere en memcached klient bibliotek. Du vil se, hvordan du gør dette i næste afsnit, sammen med nogle grundlæggende cache-adgangsoperationer.

Lagring og hentning af cachelagrede værdier ved hjælp af Python

Hvis du aldrig har brugt memcached , det er ret nemt at forstå. Det giver dybest set en gigantisk netværkstilgængelig ordbog. Denne ordbog har nogle få egenskaber, der adskiller sig fra en klassisk Python-ordbog, hovedsagelig:

• Nøgler og værdier skal være bytes
• Nøgler og værdier slettes automatisk efter en udløbstid

Derfor er de to grundlæggende handlinger til interaktion med memcached er set og get . Som du måske har gættet, bruges de til henholdsvis at tildele en værdi til en nøgle eller til at få en værdi fra en nøgle.

Mit foretrukne Python-bibliotek til at interagere med memcached er pymemcache -Jeg anbefaler at bruge det. Du kan blot installere det ved hjælp af pip:

$ pip install pymemcache

Følgende kode viser, hvordan du kan oprette forbindelse til memcached og brug den som en netværksdistribueret cache i dine Python-applikationer:

>>> from pymemcache.client import base

# Don't forget to run `memcached' before running this next line:
>>> client = base.Client(('localhost', 11211))

# Once the client is instantiated, you can access the cache:
>>> client.set('some_key', 'some value')

# Retrieve previously set data again:
>>> client.get('some_key')
'some value'

memcached netværksprotokol er virkelig enkel og dens implementering ekstremt hurtig, hvilket gør det nyttigt at gemme data, som ellers ville være langsomme at hente fra den kanoniske datakilde eller at beregne igen:

Selvom det er ligetil nok, tillader dette eksempel lagring af nøgle/værdi-tupler på tværs af netværket og adgang til dem gennem flere, distribuerede, kørende kopier af din applikation. Dette er forenklet, men alligevel kraftfuldt. Og det er et godt første skridt mod at optimere din applikation.

Udløber automatisk cachelagrede data

Når du gemmer data i memcached , kan du indstille en udløbstid – et maksimalt antal sekunder for memcached at holde nøglen og værdien omkring. Efter denne forsinkelse memcached fjerner automatisk nøglen fra sin cache.

Hvad skal du indstille denne cachetid til? Der er ikke noget magisk tal for denne forsinkelse, og det vil helt afhænge af typen af ​​data og applikation, du arbejder med. Det kan være et par sekunder, eller det kan være et par timer.

Cache-invalidering , som definerer hvornår cachen skal fjernes, fordi den er ude af synkronisering med de aktuelle data, er også noget, din applikation skal håndtere. Især hvis du præsenterer data, der er for gamle eller forældede skal undgås.

Her er der igen ingen magisk opskrift; det afhænger af den type applikation, du bygger. Der er dog flere udestående sager, der bør håndteres - som vi endnu ikke har dækket i ovenstående eksempel.

En caching-server kan ikke vokse uendeligt - hukommelse er en begrænset ressource. Derfor vil nøgler blive skyllet ud af caching-serveren, så snart den har brug for mere plads til at gemme andre ting.

Nogle nøgler kan også være udløbet, fordi de nåede deres udløbstid (også nogle gange kaldet "time-to-live" eller TTL). I disse tilfælde går dataene tabt, og den kanoniske datakilde skal forespørges igen.

Det her lyder mere kompliceret, end det i virkeligheden er. Du kan generelt arbejde med følgende mønster, når du arbejder med memcached i Python:

from pymemcache.client import base


def do_some_query():
    # Replace with actual querying code to a database,
    # a remote REST API, etc.
    return 42


# Don't forget to run `memcached' before running this code
client = base.Client(('localhost', 11211))
result = client.get('some_key')

if result is None:
    # The cache is empty, need to get the value
    # from the canonical source:
    result = do_some_query()

    # Cache the result for next time:
    client.set('some_key', result)

# Whether we needed to update the cache or not,
# at this point you can work with the data
# stored in the `result` variable:
print(result)

from pymemcache.client import base
from pymemcache import fallback


def do_some_query():
    # Replace with actual querying code to a database,
    # a remote REST API, etc.
    return 42


# Set `ignore_exc=True` so it is possible to shut down
# the old cache before removing its usage from 
# the program, if ever necessary.
old_cache = base.Client(('localhost', 11211), ignore_exc=True)
new_cache = base.Client(('localhost', 11212))

client = fallback.FallbackClient((new_cache, old_cache))

result = client.get('some_key')

if result is None:
    # The cache is empty, need to get the value 
    # from the canonical source:
    result = do_some_query()

    # Cache the result for next time:
    client.set('some_key', result)

print(result)

def on_visit(client):
    result = client.get('visitors')
    if result is None:
        result = 1
    else:
        result += 1
    client.set('visitors', result)

def on_visit(client):
    while True:
        result, cas = client.gets('visitors')
        if result is None:
            result = 1
        else:
            result += 1
        if client.cas('visitors', result, cas):
            break