Utiliser Memcache

Cette page explique comment configurer et surveiller le service Memcache pour votre application à l'aide de la console Google Cloud Platform. Elle montre également comment utiliser l'API Go Memcache d'App Engine pour mettre en cache des valeurs et les récupérer. Pour en savoir plus sur Memcache, consultez la page Présentation de Memcache.

Configurer Memcache

  1. Accédez à la page "Memcache" dans la console Google Cloud Platform.
    Accéder à la page "Memcache"
  2. Sélectionnez le niveau de service Memcache que vous souhaitez utiliser.

    • Partagé : (valeur par défaut) niveau de service gratuit qui attribue la capacité de cache de la manière la plus optimale possible.
    • Dédié : niveau de service facturé à l'heure et par Go de cache utilisé. Il fournit une capacité de cache fixe qui est attribuée exclusivement à votre application.

    Pour en savoir plus sur les classes de service disponibles, consultez la page Présentation de Memcache.

Importer l'API Go

Pour importer le package memcache, utilisez la commande suivante :

import "google.golang.org/appengine/memcache"

Mettre en cache des valeurs et les récupérer

Mettre en cache une valeur

Utilisez Add() afin de définir une valeur pour une clé uniquement si aucune valeur ne lui est déjà associée.

item := &memcache.Item{
        Key:   "[KEY]",
        Value: []byte("[VALUE]"),
}
memcache.Add(c, item)

c correspond à appengine.Context.

Pour en savoir plus sur Add et sur les autres fonctions permettant de définir des valeurs, consultez la documentation de référence sur l'API Memcache.

Rechercher des valeurs mises en cache

Utilisez Get() pour obtenir l'élément correspondant à une clé donnée.

memcache.Get(ctx, "[KEY]")

Pour en savoir plus sur Get et sur les autres fonctions permettant de rechercher des valeurs, consultez la documentation de référence sur l'API Memcache.

Exemple

L'exemple ci-dessous montre comment ajouter, définir et récupérer les valeurs Memcache à l'aide de l'API Go.

Supposons que ctx corresponde à appengine.Context.

// Create an Item
item := &memcache.Item{
	Key:   "lyric",
	Value: []byte("Oh, give me a home"),
}
// Add the item to the memcache, if the key does not already exist
if err := memcache.Add(ctx, item); err == memcache.ErrNotStored {
	log.Infof(ctx, "item with key %q already exists", item.Key)
} else if err != nil {
	log.Errorf(ctx, "error adding item: %v", err)
}

// Change the Value of the item
item.Value = []byte("Where the buffalo roam")
// Set the item, unconditionally
if err := memcache.Set(ctx, item); err != nil {
	log.Errorf(ctx, "error setting item: %v", err)
}

// Get the item from the memcache
if item, err := memcache.Get(ctx, "lyric"); err == memcache.ErrCacheMiss {
	log.Infof(ctx, "item not in the cache")
} else if err != nil {
	log.Errorf(ctx, "error getting item: %v", err)
} else {
	log.Infof(ctx, "the lyric is %q", item.Value)
}

Surveiller Memcache dans la console Google Cloud Platform

  1. Accédez à la page "Memcache" dans la console Google Cloud Platform.
    Accéder à la page "Memcache"
  2. Consultez les rapports ci-dessous :
    • Niveau de service Memcache : indique si l'application utilise le niveau de service partagé ou dédié. Si vous êtes propriétaire du projet, vous pouvez basculer de l'un à l'autre. En savoir plus sur les niveaux de service.
    • Taux de succès : affiche le pourcentage ainsi que le nombre brut de succès et de défauts de cache survenus dans Memcache.
    • Éléments en cache.
    • Âge du plus ancien élément : âge de l'élément en cache le plus ancien. Notez que l'âge d'un élément est réinitialisé chaque fois que ce dernier est utilisé, qu'il soit lu ou écrit.
    • Taille totale du cache.
  3. Vous pouvez effectuer l'une des actions suivantes :

    • Nouvelle clé : ajoute une clé au cache.
    • Trouver une clé : récupère une clé existante.
    • Vider la mémoire cache : supprime toutes les paires clé/valeur du cache.
  4. (Service Memcache dédié uniquement) Parcourez la liste des Clés fréquemment utilisées.

    • Les clés de cette liste reçoivent plus de 100 requêtes par seconde (RPS) dans Memcache.
    • Cette liste peut comporter jusqu'à 100 clés, triées par ordre décroissant en fonction du nombre de RPS reçues.
    • Consultez la page Bonnes pratiques relatives au service Memcache d'App Engine pour savoir comment répartir la charge de manière plus uniforme au sein de l'espace de clés.

Étapes suivantes

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

Envoyer des commentaires concernant…

Environnement standard App Engine pour Go