Déployer Memcached sur Google Kubernetes Engine

Dans ce tutoriel, vous allez apprendre à déployer un cluster de serveurs Memcached distribués sur Google Kubernetes Engine (GKE) à l'aide de Kubernetes, Helm et Mcrouter. Memcached est un système de mise en cache Open Source populaire et polyvalent. Il est généralement utilisé pour stocker à titre temporaire les données fréquemment consultées de manière à accélérer les applications Web et à alléger les charges des bases de données.

Caractéristiques de Memcached

Memcached a deux objectifs de conception principaux :

  • Simplicité : Memcached fonctionne comme une grande table de hachage. Il propose une API simple pour stocker et récupérer des objets de forme arbitraire par clé.
  • Rapidité : Memcached conserve les données en cache dans une mémoire vive (RAM) exclusivement. Vous pouvez ainsi accéder aux données beaucoup plus rapidement.

Memcached est un système distribué qui permet d'effectuer un scaling horizontal de la capacité de sa table de hachage sur un pool de serveurs. Chaque serveur Memcached fonctionne de manière totalement isolée par rapport aux autres serveurs du pool. Par conséquent, vous devez effectuer le routage et l'équilibrage de charge entre les serveurs au niveau du client. Les clients Memcached appliquent un schéma de hachage cohérent pour sélectionner les serveurs cibles de manière appropriée. Ce schéma garantit les conditions suivantes :

  • Le même serveur est toujours sélectionné pour la même clé.
  • L'utilisation de la mémoire est répartie uniformément entre les serveurs.
  • Un nombre minimal de clés est déplacé lorsque le pool de serveurs est réduit ou développé.

Le diagramme suivant illustre les interactions générales entre un client Memcached et un pool distribué de serveurs Memcached.

Interactions entre Memcached et un pool de serveurs Memcached
Figure 1 : Interactions générales entre un client Memcached et un pool distribué de serveurs Memcached

Objectifs

  • Découvrir certaines caractéristiques de l'architecture distribuée de Memcached
  • Déployer un service Memcached sur GKE à l'aide de Kubernetes et Helm
  • Déployer Mcrouter, un proxy Memcached Open Source, pour améliorer les performances du système

Coûts

Ce tutoriel utilise les composants facturables suivants de Google Cloud :

  • Compute Engine

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Dans Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Cloud.

    Accéder à la page de sélection du projet

  3. Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Activez l'API Compute Engine.

    Activer l'API

  5. Démarrez une instance Cloud Shell.
    Ouvrir Cloud Shell

Déployer un service Memcached

Vous pouvez facilement déployer un service Memcached sur GKE à l'aide d'un chart Helm. Pour procéder au déploiement, suivez ces étapes dans Cloud Shell :

  1. Créez un cluster GKE avec trois nœuds :

    gcloud container clusters create demo-cluster --num-nodes 3 --zone us-central1-f
    
  2. Téléchargez l'archive binaire helm :

    cd ~
    wget https://kubernetes-helm.storage.googleapis.com/helm-v2.6.0-linux-amd64.tar.gz
    
  3. Décompressez le fichier d'archive sur votre système local :

    mkdir helm-v2.6.0
    tar zxfv helm-v2.6.0-linux-amd64.tar.gz -C helm-v2.6.0
    
  4. Ajoutez le répertoire du binaire helm à votre variable d'environnement PATH :

    export PATH="$(echo ~)/helm-v2.6.0/linux-amd64:$PATH"
    

    Cette commande rend le binaire helm visible à partir de n'importe quel répertoire au cours de la session Cloud Shell actuelle. Pour conserver cette configuration sur plusieurs sessions, ajoutez la commande au fichier ~/.bashrc de l'utilisateur Cloud Shell.

  5. Créez un compte de service dans lequel Tiller, le serveur Helm, dispose du rôle d'administrateur de cluster :

    kubectl create serviceaccount --namespace kube-system tiller
    kubectl create clusterrolebinding tiller --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
    
  6. Initialisez Tiller dans votre cluster, puis mettez à jour les informations des graphiques disponibles :

    helm init --service-account tiller
    helm repo update
    
  7. Installez une nouvelle version du chart Helm Memcached avec une instance dupliquée pour chacun des trois nœuds :

    helm install stable/memcached --name mycache --set replicaCount=3
    

    Le chart Helm Memcached utilise un contrôleur StatefulSet. L'avantage avec ce type de contrôleur est que les noms des pods sont triés et prévisibles. Dans le cas présent, les noms sont mycache-memcached-{0..2}. Cet ordre facilite le référencement des serveurs par les clients Memcached.

  8. Pour afficher les pods en cours, exécutez la commande suivante :

    kubectl get pods
    

    Le résultat Google Cloud Console ressemble à ceci :

    NAME                  READY     STATUS    RESTARTS   AGE
    mycache-memcached-0   1/1       Running   0          45s
    mycache-memcached-1   1/1       Running   0          35s
    mycache-memcached-2   1/1       Running   0          25s

Découvrir les points de terminaison du service Memcached

Le chart Helm Memcached utilise un service sans adresse IP de cluster. Celui-ci expose les adresses IP de tous ses pods afin qu'ils puissent être découverts individuellement.

  1. Vérifiez que le service déployé ne contient pas d'adresse IP de cluster :

    kubectl get service mycache-memcached -o jsonpath="{.spec.clusterIP}"
    

    Le résultat None confirme que le service n'a pas de clusterIP et qu'il n'a donc pas d'adresse IP de cluster.

    Le service crée un enregistrement DNS pour le nom d'hôte sous la forme suivante :

    [SERVICE_NAME].[NAMESPACE].svc.cluster.local
    

    Dans ce tutoriel, le nom du service est mycache-memcached. Étant donné qu'aucun espace de noms n'a été explicitement défini, l'espace de noms par défaut est utilisé. Le nom d'hôte complet est donc mycache-memcached.default.svc.cluster.local. Ce nom d'hôte résout un ensemble d'adresses IP et de domaines pour les trois pods exposés par le service. Si vous ajoutez ultérieurement certains pods au pool ou si vous en supprimez, kube-dns met automatiquement à jour l'enregistrement DNS.

    Il incombe au client de découvrir les points de terminaison du service Memcached, comme décrit dans les étapes suivantes.

  2. Récupérez les adresses IP des points de terminaison :

    kubectl get endpoints mycache-memcached
    

    Le résultat ressemble à ce qui suit :

    NAME                ENDPOINTS                                            AGE
    mycache-memcached   10.36.0.32:11211,10.36.0.33:11211,10.36.1.25:11211   3m
    

    Notez que chaque pod Memcached a une adresse IP distincte, respectivement 10.36.0.32, 10.36.0.33 et 10.36.1.25. Ces adresses IP ne sont pas nécessairement les mêmes pour vos propres instances de serveur. Chaque pod écoute le port 11211, qui est le port par défaut de Memcached.

  3. Comme alternative à l'étape 2, vous pouvez récupérer ces mêmes enregistrements à l'aide d'une requête DNS standard en exécutant la commande nslookup :

    kubectl run -it --rm alpine --image=alpine:3.6 --restart=Never nslookup mycache-memcached.default.svc.cluster.local
    

    Le résultat ressemble à ce qui suit :

    Name:      mycache-memcached.default.svc.cluster.local
    Address 1: 10.36.0.32 mycache-memcached-0.mycache-memcached.default.svc.cluster.local
    Address 2: 10.36.0.33 mycache-memcached-2.mycache-memcached.default.svc.cluster.local
    Address 3: 10.36.1.25 mycache-memcached-1.mycache-memcached.default.svc.cluster.local
    

    Notez que chaque serveur dispose de son propre nom de domaine qui se présente sous la forme suivante :

    [POD_NAME].[SERVICE_NAME].[NAMESPACE].svc.cluster.local
    

    Par exemple, le domaine du pod mycache-memcached-0 est :

    mycache-memcached-0.mycache-memcached.default.svc.cluster.local
    
  4. Comme autre alternative à l'étape 2, vous pouvez effectuer la même inspection DNS à l'aide d'un langage de programmation tel que Python :

    1. Démarrez une console interactive Python dans votre cluster :

      kubectl run -it --rm python --image=python:3.6-alpine --restart=Never python
      
    2. Dans la console Python, exécutez les commandes suivantes :

      import socket
      print(socket.gethostbyname_ex('mycache-memcached.default.svc.cluster.local'))
      exit()
      

      Le résultat ressemble à ce qui suit :

      ('mycache-memcached.default.svc.cluster.local', [], ['10.36.0.32', '10.36.0.33', '10.36.1.25'])
  5. Testez le déploiement en ouvrant une session telnet avec l'un des serveurs Memcached en cours d'exécution sur le port 11211 :

    kubectl run -it --rm alpine --image=alpine:3.6 --restart=Never telnet mycache-memcached-0.mycache-memcached.default.svc.cluster.local 11211
    

    Dans l'invite de telnet, exécutez les commandes suivantes à l'aide du protocole ASCII Memcached :

    set mykey 0 0 5
    hello
    get mykey
    quit

    Le résultat obtenu est ici indiqué en gras :

    set mykey 0 0 5
    hello
    STORED
    get mykey
    VALUE mykey 0 5
    hello
    END
    quit

Mettre en œuvre la logique de détection de services

Vous êtes maintenant prêt à mettre en œuvre la logique de détection de services fondamentale, illustrée dans le diagramme suivant.

Logique de détection de services
Figure 2 : Logique de détection de services

La logique de détection de services comprend les étapes générales suivantes :

  1. L'application interroge kube-dns pour obtenir l'enregistrement DNS de mycache-memcached.default.svc.cluster.local.
  2. L'application récupère les adresses IP associées à cet enregistrement.
  3. L'application instancie un nouveau client Memcached et lui fournit les adresses IP récupérées.
  4. L'équilibreur de charge intégré au client Memcached se connecte aux serveurs Memcached aux adresses IP indiquées.

Vous allez maintenant mettre en œuvre cette logique de découverte du service à l'aide de Python :

  1. Déployez un nouveau pod compatible avec Python dans votre cluster, puis démarrez une session d'interface système à l'intérieur du pod :

    kubectl run -it --rm python --image=python:3.6-alpine --restart=Never sh
    
  2. Installez la bibliothèque pymemcache :

    pip install pymemcache
    
  3. Démarrez une console interactive Python à l'aide de la commande python.

  4. Dans la console Python, exécutez les commandes suivantes :

    import socket
    from pymemcache.client.hash import HashClient
    _, _, ips = socket.gethostbyname_ex('mycache-memcached.default.svc.cluster.local')
    servers = [(ip, 11211) for ip in ips]
    client = HashClient(servers, use_pooling=True)
    client.set('mykey', 'hello')
    client.get('mykey')
    

    Voici le résultat :

    b'hello'

    Le préfixe b correspond à un littéral d'octets. Il s'agit du format dans lequel Memcached stocke les données.

  5. Quittez la console Python :

    exit()
    
  6. Appuyez sur Control+D pour quitter la session d'interface système du pod.

Activer le regroupement de connexions

Vous pouvez rencontrer certaines limites à mesure que vos besoins en mise en cache augmentent et que des dizaines, des centaines voire des milliers de serveurs Memcached sont ajoutés au pool. Par exemple, un grand nombre de connexions ouvertes provenant de clients Memcached peut entraîner une charge importante sur les serveurs, comme le montre le diagramme suivant.

Nombre élevé de connexions ouvertes lorsque l'ensemble des clients Memcached accèdent directement à tous les serveurs Memcached
Figure 3 : Nombre élevé de connexions ouvertes lorsque l'ensemble des clients Memcached accède directement à tous les serveurs Memcached

Pour réduire le nombre de connexions ouvertes, vous devez utiliser un proxy afin d'activer le regroupement de connexions, comme indiqué dans le diagramme suivant.

Proxy pour activer le regroupement de connexions
Figure 4 : Utilisation d'un proxy pour réduire le nombre de connexions ouvertes

Mcrouter (prononcé "mick router") est un puissant proxy Memcached Open Source qui permet de regrouper les connexions. L'intégration de Mcrouter est transparente, car ce proxy utilise le protocole standard ASCII Memcached. Pour un client Memcached, Mcrouter se comporte comme un serveur Memcached normal. Pour un serveur Memcached, Mcrouter se comporte comme un client Memcached normal.

Pour déployer Mcrouter, exécutez les commandes suivantes dans Cloud Shell.

  1. Supprimez la version du chart Helm mycache précédemment installée :

    helm delete mycache --purge
    
  2. Installez une nouvelle version du chart Helm Mcrouter pour déployer les nouveaux pods Memcached et Mcrouter :

    helm install stable/mcrouter --name=mycache --set memcached.replicaCount=3
    

    Les pods du proxy sont maintenant prêts à accepter les requêtes des applications clientes.

  3. Testez cette configuration en vous connectant à l'un des pods du proxy. Exécutez la commande telnet sur le port 5000, qui est le port par défaut de Mcrouter.

    MCROUTER_POD_IP=$(kubectl get pods -l app=mycache-mcrouter -o jsonpath="{.items[0].status.podIP}")
    
    kubectl run -it --rm alpine --image=alpine:3.6 --restart=Never telnet $MCROUTER_POD_IP 5000
    

    À l'invite de telnet, exécutez les commandes suivantes :

    set anotherkey 0 0 15
    Mcrouter is fun
    get anotherkey
    quit

    Les commandes définissent et rappellent la valeur de votre clé.

Vous venez de déployer un proxy permettant de regrouper des connexions.

Réduire la latence

Pour augmenter la résilience, il est courant d'utiliser un cluster avec plusieurs nœuds. Dans ce tutoriel, nous utilisons un cluster avec trois nœuds. Toutefois, l'utilisation de plusieurs nœuds entraîne un risque d'augmentation de la latence en raison du trafic réseau plus important entre les nœuds.

Héberger des pods de proxy en colocation

Vous pouvez réduire ce risque en ne connectant les pods des applications clientes qu'à un pod de proxy Memcached qui se trouve sur le même nœud. Le diagramme suivant illustre cette configuration.

Topologie des interactions entre pods
Figure 5 : Topologie des interactions entre les pods d'applications, les pods Mcrouter et les pods Memcached sur un cluster à trois nœuds

Effectuez cette configuration comme suit :

  1. Assurez-vous que chaque nœud contient un pod de proxy en cours d'exécution. Une méthode courante consiste à déployer les pods de proxy avec un contrôleur DaemonSet. À mesure que les nœuds sont ajoutés au cluster, de nouveaux pods de proxy leur sont automatiquement ajoutés. Lorsque les nœuds sont supprimés du cluster, ces pods sont récupérés. Le chart Helm Mcrouter que vous avez déployé précédemment dans ce tutoriel utilise un contrôleur DaemonSet par défaut. Cette tâche est donc déjà effectuée.
  2. Définissez une valeur hostPort dans les paramètres Kubernetes du conteneur du proxy pour que le nœud écoute ce port et redirige le trafic vers le proxy. Dans ce tutoriel, le chart Helm Mcrouter utilise ce paramètre par défaut pour le port 5000. Cette tâche est donc également effectuée.
  3. Exposez le nom du nœud en tant que variable d'environnement à l'intérieur des pods de l'application en utilisant l'entrée spec.env et en sélectionnant la valeur fieldRef spec.nodeName. Pour en savoir plus sur cette méthode, consultez la documentation Kubernetes.

    1. Déployez des exemples de pods d'application :

      cat <<EOF | kubectl create -f -
      apiVersion: extensions/v1beta1
      kind: Deployment
      metadata:
        name: sample-application
      spec:
        replicas: 9
        template:
          metadata:
            labels:
              app: sample-application
          spec:
            containers:
              - name: alpine
                image: alpine:3.6
                command: [ "sh", "-c"]
                args:
                - while true; do sleep 10; done;
                env:
                  - name: NODE_NAME
                    valueFrom:
                      fieldRef:
                        fieldPath: spec.nodeName
      EOF
      
  4. Vérifiez que le nom du nœud est exposé en le recherchant dans l'un des exemples de pods d'application :

    POD=$(kubectl get pods -l app=sample-application -o jsonpath="{.items[0].metadata.name}")
    
    kubectl exec -it $POD -- sh -c 'echo $NODE_NAME'
    

    Cette commande affiche le nom du nœud au format suivant :

    gke-demo-cluster-default-pool-XXXXXXXX-XXXX

Connecter les pods

Les exemples de pods d'application sont maintenant prêts à se connecter au pod Mcrouter qui s'exécute sur leurs nœuds communs respectifs sur le port 5000 (port par défaut de Mcrouter).

  1. Établissez une connexion pour l'un des pods en ouvrant une session telnet :

    POD=$(kubectl get pods -l app=sample-application -o jsonpath="{.items[0].metadata.name}")
    
    kubectl exec -it $POD -- sh -c 'telnet $NODE_NAME 5000'
    
  2. À l'invite de telnet, exécutez les commandes suivantes :

    get anotherkey
    quit
    

    Résultat :

    Mcrouter is fun

Enfin, à titre d'illustration, le code Python suivant est un exemple de programme qui établit cette connexion. Pour ce faire, il récupère la variable NODE_NAME de l'environnement et utilise la bibliothèque pymemcache :

import os
from pymemcache.client.base import Client

NODE_NAME = os.environ['NODE_NAME']
client = Client((NODE_NAME, 5000))
client.set('some_key', 'some_value')
result = client.get('some_key')

Effectuer un nettoyage

Pour éviter que les ressources utilisées dans ce tutoriel soient facturées sur votre compte Google Cloud Platform :

  1. Exécutez la commande suivante pour supprimer le cluster GKE :

    gcloud container clusters delete demo-cluster --zone us-central1-f
    
  2. Supprimez éventuellement le binaire Helm :

    cd ~
    rm -rf helm-v2.6.0
    rm helm-v2.6.0-linux-amd64.tar.gz
    

Étapes suivantes

  • Découvrez les nombreuses autres fonctionnalités offertes par Mcrouter au-delà du simple regroupement de connexions, telles que les instances de basculement dupliquées, les flux de suppression fiables, le préchauffage du cache à froid et la diffusion multicluster.
  • Examinez les fichiers sources du chart Memcached et du chart Mcrouter pour en savoir plus sur les configurations Kubernetes spécifiques à ces éléments.
  • Découvrez des techniques efficaces pour utiliser Memcached sur App Engine. Certaines d'entre elles s'appliquent à d'autres plates-formes, telles que GKE.
  • Testez d'autres fonctionnalités de Google Cloud. Découvrez nos tutoriels.