Présentation de Memcache

Cette page présente le service Memcache d'App Engine. Pour certaines tâches, les applications Web évolutives à hautes performances utilisent souvent un cache de données en mémoire distribué en plus ou à la place de solutions robustes de stockage permanent. App Engine fournit un service de cache mémoire à cette fin. Pour apprendre à configurer, surveiller et utiliser le service Memcache, consultez la page Utiliser Memcache.

Quand utiliser un cache mémoire ?

Un cache mémoire peut servir à accélérer les requêtes courantes de magasin de données. Si de nombreuses requêtes envoient la même requête avec des paramètres identiques et que les modifications des résultats ne doivent pas nécessairement apparaître immédiatement sur le site Web, l'application peut mettre en cache les résultats dans le cache mémoire. Les requêtes suivantes peuvent consulter le cache mémoire, et n'effectuer la requête de datastore que si les résultats ne s'y trouvent pas ou sont arrivés à expiration. Les données de session, les préférences utilisateur et les autres données renvoyées par les requêtes pour les pages Web sont de bons candidats pour la mise en cache.

Memcache peut être utile pour d'autres valeurs temporaires. Toutefois, lorsque vous envisagez de stocker une valeur dans le cache mémoire exclusivement, sans sauvegarde dans un autre emplacement de stockage permanent, assurez-vous que votre application réagit convenablement en cas de soudaine indisponibilité de la valeur. Les valeurs dans le cache mémoire peuvent expirer à tout moment et avant la date limite d'expiration définie. Par exemple, si l'absence soudaine des données liées à une session d'utilisateur est susceptible de causer un dysfonctionnement de la session, il serait préférable de stocker ces données dans le datastore en plus du cache mémoire.

Niveaux de service

App Engine accepte deux niveaux du service Memcache :

  • Memcache partagé : la valeur par défaut, gratuite pour les applications App Engine. La capacité de cache est fournie de la façon la plus optimale possible et soumise à la demande générale de toutes les applications App Engine utilisant le service Memcache partagé.

  • Memcache dédié : fournit une capacité de cache fixe exclusivement allouée à votre application. Le service est facturé par taille de cache utilisé, au Go par heure, et nécessite d'activer la facturation. Grâce au contrôle de la taille du cache, votre application peut fonctionner de manière plus prévisible et avec moins de lectures dans un stockage durable plus coûteux.

Les deux niveaux de service Memcache utilisent la même API. Afin de configurer le service Memcache pour votre application, consultez la section Utiliser Memcache.

Le tableau suivant résume les différences entre les deux niveaux de service Memcache :

Caractéristique Memcache dédié Memcache partagé
Prix 0,06 $ (par Go et par heure) Gratuit
Capacité
us-central
1 à 100 Go
autres régions
1 à 20 Go
Pas de capacité garantie
Performances Jusqu'à 10 000 lectures ou 5 000 écritures (exclusives) par seconde et par Go (éléments < 1 Ko). Pour en savoir plus, consultez la section Statistiques relatives au cache. Sans garantie
Stockage durable Non Non
Contrat de niveau de service Aucun Aucun

L'utilisation de Memcache dédié est facturée par tranches de 15 minutes. Si vous ne payez pas en USD, les tarifs indiqués dans votre devise sur la page relative aux SKU de Cloud Platform s'appliquent.

Si votre application nécessite davantage de capacité Memcache, contactez notre équipe commerciale.

Limites

Les limites suivantes s'appliquent à l'utilisation du service Memcache :

  • La taille maximale d'une valeur de données en cache est de 1 Mo (10^6 octets).
  • Une clé ne peut pas dépasser 250 octets. Dans l'environnement d'exécution Python, les clés qui sont des chaînes de plus de 250 octets sont hachées. (Le comportement est différent dans les autres environnements d'exécution.)
  • Les opérations multiples par lot peuvent comporter un nombre illimité d'éléments. La taille totale de l'appel et la taille totale des données extraites ne doivent pas dépasser 32 mégaoctets.
  • Une clé Memcache ne peut pas contenir un octet nul.

Expiration des données mises en cache

Memcache contient des paires clé/valeur. Les paires en mémoire changent à tout moment à mesure que les éléments sont écrits et récupérés à partir du cache.

Par défaut, les valeurs stockées dans le cache mémoire sont conservées le plus longtemps possible. Elles peuvent être éliminées du cache lorsqu'une nouvelle valeur est ajoutée au cache et que celui-ci manque de mémoire. Lorsque des valeurs sont supprimées du fait de la saturation de la mémoire, les valeurs utilisées le moins récemment sont éliminées en premier.

L'application peut fournir une date d'expiration lors du stockage d'une valeur, soit sous la forme d'un nombre de secondes à partir de la date d'ajout de la valeur, soit sous la forme d'une date absolue dans une époque Unix future (un nombre de secondes à partir du 1er janvier 1970 à minuit). La valeur est supprimée au plus tard à cette date, bien qu'elle puisse être éliminée plus tôt pour d'autres raisons. L'incrémentation de la valeur stockée pour une clé existante ne met pas à jour sa date d'expiration.

Dans de rares cas, des valeurs peuvent également disparaître du cache avant l'expiration pour des raisons autres que la saturation de la mémoire. Bien que Memcache soit résilient aux pannes de serveur, les valeurs Memcache ne sont pas enregistrées sur le disque. Par conséquent, une défaillance du service peut rendre les valeurs indisponibles.

De manière générale, une application ne doit pas compter sur la disponibilité permanente d'une valeur mise en cache.

Vous pouvez effacer l'intégralité du cache d'une application via l'API ou dans la section "Memcache" de la console Google Cloud Platform.

Statistiques relatives au cache

Opérations par seconde et par taille d'élément

Memcache dédié est évalué en opérations par seconde et par Go, une opération correspondant à un accès individuel à un élément du cache, tel que get, set ou delete. Le taux varie en fonction de la taille des éléments, conformément au tableau ci-dessous. Tout dépassement peut entraîner une augmentation de la latence de l'API ou des erreurs.

Les tableaux suivants indiquent le nombre maximal d'opérations get-hit ou set exclusives et durables par Go de cache. Notez qu'une opération get-hit est un appel get qui détecte une valeur stockée avec la clé spécifiée et la renvoie.

Taille de l'élément (Ko) Nombre maximal d'opérations get-hit/s Nombre maximal d'opérations set/s
≤1 10 000 5 000
100 2 000 1 000
512 500 250

Une application configurée pour plusieurs Go de cache peut théoriquement atteindre un taux de fonctionnement global équivalant au nombre de Go multiplié par le taux par Go. Par exemple, une application configurée pour un cache de 5 Go peut atteindre 50 000 opérations Memcache/s sur des éléments de 1 Ko. Ce niveau exige une bonne répartition de la charge dans l'espace de clés Memcache, comme décrit sur la page Bonnes pratiques relatives à App Engine Memcache.

Pour chaque modèle d'E/S, les limites répertoriées ci-dessus s'appliquent aux lectures ou aux écritures. Pour des lectures et écritures simultanées, les limites sont dégressives. Plus le nombre de lectures effectuées est élevé, moins le nombre d'écritures pouvant être effectuées est important, et inversement. Vous trouverez ci-dessous des exemples de limites d'IOPS pour les lectures et écritures simultanées de valeurs de 1 Ko par Go de cache :

IOPS de lecture IOPS d'écriture
10 000 0
8000 1000
5000 2500
1000 4500
0 5000

Unités de calcul Memcache (MCU)

Le débit de Memcache peut varier en fonction de la taille de l'élément auquel vous accédez et de l'opération que vous souhaitez effectuer sur cet élément. Vous pouvez globalement associer un coût approximatif aux opérations et estimer la capacité de trafic que vous pouvez attendre de Memcache dédié à l'aide d'une unité appelée "unité de calcul Memcache" (MCU). Le système des MCU est défini pour que vous puissiez vous attendre à un débit approximatif de 10 000 MCU par seconde et par Go de Memcache dédié. La console Google Cloud Platform indique la quantité de MCU actuellement utilisée par votre application.

Notez qu'une MCU fournit une estimation statistique approximative et qu'il ne s'agit pas d'une unité linéaire. Chaque opération de cache qui lit ou écrit une valeur a un coût MCU spécifique qui dépend de la taille de la valeur. La MCU d'une opération set dépend de la taille de la valeur : elle représente deux fois le coût d'une opération get-hit réussie.

Taille de l'élément de valeur (Ko) Coût MCU pour get-hit Coût MCU pour set
≤1 1,0 2,0
2 1,3 2,6
10 1,7 3.4
100 5,0 10,0
512 20,0 40,0
1 024 50,0 100,0

Les opérations qui ne lisent ou n'écrivent pas de valeur ont un coût MCU fixe :

Opération MCU
get-miss 1,0
delete 2,0
increment 2,0
flush 100,0
stats 100,0

Notez qu'une opération get-miss est un appel get qui détecte qu'aucune valeur n'est stockée avec la clé spécifiée.

Fonctionnalité Compare-And-Set

La fonctionnalité Compare-And-Set permet à plusieurs requêtes traitées simultanément de mettre à jour la valeur d'une même clé Memcache de manière atomique, ce qui empêche les conditions de concurrence.

Principaux composants logiques de la fonctionnalité Compare-And-Set

Si vous mettez à jour la valeur d'une clé Memcache susceptible de faire l'objet d'autres requêtes d'écriture simultanées, vous devez utiliser l'objet Memcache Client qui stocke certaines informations d'état exploitées par les méthodes compatibles avec la fonctionnalité Compare-And-Set. Vous ne pouvez pas utiliser les fonctions Memcache get() ni set(), car elles sont sans état. Comme la classe Client n'est pas sécurisée, vous ne devez pas utiliser le même objet Client dans plusieurs threads.

Lorsque vous récupérez des clés, vous devez utiliser les méthodes Memcache Client compatibles avec la fonctionnalité Compare-And-Set : gets() ou get_multi(), avec le paramètre for_cas défini sur True.

Lorsque vous mettez à jour une clé, vous devez utiliser les méthodes Memcache Client compatibles avec la fonctionnalité Compare-And-Set : cas() ou cas_multi().

L'autre principal composant logique est le service Memcache d'App Engine et son comportement vis-à-vis de la fonctionnalité Compare-And-Set. Le service Memcache d'App Engine se comporte de manière atomique. Ainsi, lorsque deux requêtes simultanées (pour le même ID application) utilisent Memcache, elles sont envoyées à la même instance de service Memcache. En outre, le service Memcache dispose d'un verrouillage interne suffisant pour que des requêtes simultanées associées à une même clé soient correctement sérialisées. Cela signifie par exemple que deux requêtes cas() associées à une même clé ne s'exécutent pas en parallèle. Le service traite en effet la première requête entrante jusqu'à ce qu'elle soit terminée (et que la valeur et l'horodatage soient mis à jour) avant de commencer à traiter la deuxième requête.

Pour découvrir comment utiliser la fonctionnalité Compare-And-Set dans l'environnement Python, consultez la page Traiter les écritures simultanées.

Bonnes pratiques

Voici quelques pratiques recommandées pour l'utilisation de Memcache :

  • Gérez correctement les échecs de l'API Memcache. Les opérations Memcache peuvent échouer pour diverses raisons. Les applications doivent être conçues pour détecter les opérations ayant échoué, sans exposer ces erreurs aux utilisateurs finaux. Cette recommandation s'applique particulièrement aux opérations "set".

  • Utilisez si possible la fonctionnalité de traitement par lot de l'API, en particulier pour les petits éléments. Vous améliorerez ainsi les performances et l'efficacité de votre application.

  • Répartissez la charge sur votre espace de clés Memcache. Le fait d'avoir un ou plusieurs petits éléments Memcache représentant un volume de trafic disproportionné empêche le scaling de votre application. Ces recommandations concernent aussi bien les opérations par seconde que la bande passante. Ce problème est généralement résolu en effectuant un partitionnement explicite des données.

    Par exemple, vous pouvez fractionner un compteur fréquemment mis à jour entre plusieurs clés, pour les relire et les additionner lorsque vous avez besoin d'un total. De la même manière, vous pouvez fractionner un élément de données de 500 Ko qui doit être lu sur chaque requête HTTP et le relire à l'aide d'un seul appel d'API par lots. (Une meilleure solution serait de mettre en cache la valeur dans la mémoire d'instance.) Pour Memcache dédié, le taux d'accès de pointe sur une clé unique est généralement inférieur d'un à deux ordres de grandeur au taux par Go.

Pour obtenir d'autres informations et recommandations sur les questions de simultanéité, de performances et de migration, y compris le partage de Memcache entre différents langages de programmation, consultez la page Bonnes pratiques relatives à App Engine Memcache.

Étape suivante

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Environnement standard App Engine pour Python 2