DavidWittman.redis

ansible-redis

Ansible 2.4+
Compatible avec la plupart des versions d'Ubuntu/Debian et RHEL/CentOS 6.x

Contenu

Installation
Prise en main
Options avancées
Variables de rôle

Installation

$ ansible-galaxy install davidwittman.redis

Prise en main

Voici quelques exemples de playbooks et de configurations pour déployer différentes architectures Redis.

Ce rôle doit être exécuté en tant que root ou en tant qu'utilisateur avec des privilèges sudo.

Nœud Redis unique

Déployer un seul nœud serveur Redis est assez simple ; il suffit d'ajouter le rôle à votre playbook. Voici un exemple qui deviendra un peu plus intéressant en définissant l'adresse de liaison à 127.0.0.1 :

---
- hosts: redis01.example.com
  vars:
    - redis_bind: 127.0.0.1
  roles:
    - davidwittman.redis

$ ansible-playbook -i redis01.example.com, redis.yml

Remarque : Vous aurez peut-être remarqué que j'ai simplement passé un nom d'hôte comme fichier d'inventaire Ansible. C'est une manière facile d'exécuter Ansible sans avoir à créer d'abord un fichier d'inventaire ; il suffit d'ajouter une virgule après le nom d'hôte pour que Ansible sache quoi en faire.

Et voilà ! Vous aurez maintenant un serveur Redis à l'écoute sur 127.0.0.1 sur redis01.example.com. Par défaut, les binaires Redis sont installés sous /opt/redis, bien que cela puisse être modifié en définissant la variable redis_install_dir.

Réplikation Maître-Esclave

La configuration de la réplikation dans Redis se fait en déployant plusieurs nœuds et en définissant la variable redis_slaveof sur les nœuds esclaves, tout comme vous le feriez dans le fichier redis.conf. Dans l'exemple suivant, nous allons déployer un maître Redis avec trois esclaves.

Dans cet exemple, nous allons utiliser des groupes pour séparer les nœuds maître et esclaves. Commençons par le fichier d'inventaire :

[redis-master]
redis-master.example.com

[redis-slave]
redis-slave0[1:3].example.com

Et voici le playbook :

---
- name: configurer le serveur Redis maître
  hosts: redis-master
  roles:
    - davidwittman.redis

- name: configurer les esclaves Redis
  hosts: redis-slave
  vars:
    - redis_slaveof: redis-master.example.com 6379
  roles:
    - davidwittman.redis

Dans ce cas, je suppose que vous avez des enregistrements DNS configurés pour redis-master.example.com, mais ce n'est pas toujours le cas. Vous pouvez en fait configurer cela comme vous le souhaitez. Dans de nombreux cas, je dis à Ansible d'utiliser l'adresse IP eth1 pour le maître. Voici une valeur plus flexible à la postérité :

redis_slaveof: "{{ hostvars['redis-master.example.com'].ansible_eth1.ipv4.address }} {{ redis_port }}"

Ça y est, la machine est prête ! Exécuter ce playbook devrait avoir configuré un maître Redis et trois esclaves.

Redis Sentinel

Introduction

L'utilisation de la réplikation Maître-Esclave est excellente pour la durabilité et la distribution des lectures et écritures, mais pas tant pour la haute disponibilité. Si le nœud maître échoue, un esclave doit être promu manuellement au rôle de maître, et les connexions devront être redirigées vers le nouveau maître. La solution à ce problème est Redis Sentinel, un système distribué qui utilise Redis lui-même pour communiquer et gérer la bascule automatique dans un cluster Redis.

Sentinel utilise le même binaire redis-server que Redis, mais fonctionne avec le paramètre --sentinel et un fichier de configuration différent. Tout cela est bien sûr abstrait par ce rôle Ansible, mais c'est bon à savoir.

Configuration

Pour ajouter un nœud Sentinel à une déploiement existant, assignez ce même rôle redis à ce nœud et définissez la variable redis_sentinel sur True pour ce serveur en particulier. Cela peut se faire de plusieurs manières, et pour cet exemple, je vais m'appuyer sur le fichier d'inventaire utilisé ci-dessus dans la configuration Maître/Esclave :

[redis-master]
redis-master.example.com

[redis-slave]
redis-slave0[1:3].example.com

[redis-sentinel]
redis-sentinel0[1:3].example.com redis_sentinel=True

En haut, nous avons ajouté trois autres hôtes dans le groupe redis-sentinel (bien que ce groupe n'ait aucune fonction au sein du rôle, il sert simplement d'identifiant), et défini la variable redis_sentinel en ligne dans le fichier d'inventaire.

Maintenant, tout ce que nous avons à faire est de définir la variable redis_sentinel_monitors pour définir les maîtres Redis que Sentinel doit surveiller. Dans ce cas, je vais le faire dans le playbook :

- name: configurer le serveur Redis maître
  hosts: redis-master
  roles:
    - davidwittman.redis

- name: configurer les esclaves Redis
  hosts: redis-slave
  vars:
    - redis_slaveof: redis-master.example.com 6379
  roles:
    - davidwittman.redis

- name: configurer les nœuds redis sentinel
  hosts: redis-sentinel
  vars:
    - redis_sentinel_monitors:
      - name: master01
        host: redis-master.example.com
        port: 6379
  roles:
    - davidwittman.redis

Cela configurera les nœuds Sentinel pour surveiller le maître que nous avons créé ci-dessus en utilisant l'identifiant master01. Par défaut, Sentinel utilisera un quorum de 2, ce qui signifie qu'au moins 2 Sentinels doivent convenir qu'un maître est hors ligne pour qu'une bascule se produise. Cette valeur peut être remplacée en définissant la clé quorum dans votre définition de moniteur. Consultez la documentation sur Sentinel pour plus de détails.

Avec les variables listées ci-dessus, Sentinel a un certain nombre de paramètres qui lui sont propres, tout comme le serveur Redis. Ceux-ci sont préfixés par redis_sentinel_, et sont énumérés dans la section Variables de rôle ci-dessous.

Inclusion de plusieurs rôles

Si vous devez exécuter le rôle plusieurs fois, jetez un œil à test/test_all.yml pour voir comment procéder. Consultez ici et ici pour le contexte.

Options avancées

Vérification des sommes de contrôle

Définissez la variable redis_verify_checksum sur true pour utiliser l'option de vérification des sommes de contrôle pour get_url. Notez que cela ne vérifiera les sommes de contrôle que lorsque Redis est téléchargé depuis une URL, et non lorsqu'il est fourni dans une archive tar avec redis_tarball.

En utilisant Ansible 2.x, ce rôle vérifiera la somme de contrôle sha1 du téléchargement par rapport aux sommes de contrôle définies dans la variable redis_checksums dans vars/main.yml. Si votre version n'est pas définie ici ou si vous souhaitez remplacer la somme de contrôle par une des vôtres, il suffit de définir la variable redis_checksum. Comme dans l'exemple ci-dessous, vous devez préfixer la somme de contrôle avec le type de hachage que vous utilisez.

- name: installer redis sur ansible 1.x et vérifier les sommes de contrôle
  hosts: all
  roles:
    - role: davidwittman.redis
      redis_version: 3.0.7
      redis_verify_checksum: true
      redis_checksum: "sha256:b2a791c4ea3bb7268795c45c6321ea5abcc24457178373e6a6e3be6372737f23"

Installer à partir d'une archive locale

Si l'environnement dans lequel votre serveur se trouve ne permet pas les téléchargements (par exemple, si la machine se trouve dans une DMZ), définissez la variable redis_tarball sur le chemin d'une archive Redis téléchargée localement à utiliser plutôt que de télécharger via HTTP depuis redis.io.

N'oubliez pas de définir la variable de version sur la même version que l'archive pour éviter toute confusion ! Par exemple :

vars:
  redis_version: 2.8.14
  redis_tarball: /path/to/redis-2.8.14.tar.gz

Dans ce cas, l'archive source est copiée sur le serveur via SSH plutôt que téléchargée.

Compilation des binaires 32 bits

Pour compiler des binaires 32 bits de Redis (qui peuvent être utilisés pour optimisation de la mémoire), définissez redis_make_32bit: true. Cela installe les dépendances nécessaires (x86 glibc) sur RHEL/Debian/SuSE et définit l'option '32bit' lors de l'exécution de make.

Compilation avec prise en charge TLS

Pour compiler Redis avec prise en charge TLS (ajoutée dans la version 6), définissez redis_make_tls: true. Cela nécessite des bibliothèques de développement OpenSSL (par exemple, libssl-dev sur Debian/Ubuntu).

Variables de rôle

Voici une liste de toutes les variables par défaut pour ce rôle, qui sont également disponibles dans defaults/main.yml. Un de ces jours, je les formaterai en tableau ou quelque chose de similaire.

---
## Options d'installation
redis_version: 2.8.24
redis_install_dir: /opt/redis
redis_dir: /var/lib/redis/{{ redis_port }}
redis_config_file_name: "{{ redis_port }}.conf"
redis_download_url: "http://download.redis.io/releases/redis-{{ redis_version }}.tar.gz"
# Définissez ceci sur true pour valider la somme de contrôle de l'archive redis par rapport à vars/main.yml
redis_verify_checksum: false
# Définissez cette valeur sur un chemin local d'une archive à utiliser pour l'installation plutôt que de télécharger
redis_tarball: false
# Définissez ceci sur true pour compiler des binaires 32 bits de Redis
redis_make_32bit: false
# Définissez ceci sur true pour compiler Redis avec prise en charge TLS, disponible uniquement pour les versions >= 6 (nécessite des bibliothèques de développement OpenSSL)
redis_make_tls: false

redis_user: redis
redis_group: "{{ redis_user }}"

# La limite des fichiers ouverts pour Redis/Sentinel
redis_nofile_limit: 16384

## Options de rôle
# Configurez Redis en tant que service
# Cela crée les scripts d'initialisation pour Redis et assure que le processus fonctionne
# S'applique également à Redis Sentinel
redis_as_service: true
# Ajoutez des faits locaux à /etc/ansible/facts.d pour Redis
redis_local_facts: true
# Nom du service
redis_service_name: "redis_{{ redis_port }}"

## Options de mise en réseau/connexion
redis_bind: false
redis_port: 6379
redis_password: false
# Options de réplique esclave
redis_min_slaves_to_write: 0
redis_min_slaves_max_lag: 10
redis_tcp_backlog: 511
redis_tcp_keepalive: 0
# Max clients connectés à la fois
redis_maxclients: 10000
redis_timeout: 0
# Options de socket
# Définissez socket_path sur le chemin souhaité du socket. Par exemple: /var/run/redis/{{ redis_port }}.sock
redis_socket_path: false
redis_socket_perm: 755

## Options de réplique
# Définissez slaveof tout comme vous le feriez dans redis.conf. (par exemple "redis01 6379")
redis_slaveof: false
# Rendez les esclaves en lecture seule. "oui" ou "non"
redis_slave_read_only: "yes"
redis_slave_priority: 100
redis_repl_backlog_size: false

## Journalisation
redis_logfile: '""'
# Activer syslog. "oui" ou "non"
redis_syslog_enabled: "yes"
redis_syslog_ident: "{{ redis_service_name }}"
# Installation syslog. Doit être USER ou LOCAL0-LOCAL7
redis_syslog_facility: USER

## Configuration générale
redis_daemonize: "yes"
redis_pidfile: /var/run/redis/{{ redis_port }}.pid
# Nombre de bases de données autorisées
redis_databases: 16
redis_loglevel: notice
# Journaliser les requêtes plus lentes que ce nombre de millisecondes. -1 pour désactiver
redis_slowlog_log_slower_than: 10000
# Nombre maximum de requêtes lentes à sauvegarder
redis_slowlog_max_len: 128
# Limite de mémoire Redis (par exemple 4294967296, 4096mb, 4gb)
redis_maxmemory: false
redis_maxmemory_policy: noeviction
redis_rename_commands: []
redis_db_filename: dump.rdb
# À quelle fréquence faire un snapshot de la base de données sur le disque
# par exemple "900 1" => 900 secondes si au moins 1 clé a changé
redis_save:
  - 900 1
  - 300 10
  - 60 10000
redis_stop_writes_on_bgsave_error: "yes"
redis_rdbcompression: "yes"
redis_rdbchecksum: "yes"
redis_appendonly: "no"
redis_appendfilename: "appendonly.aof"
redis_appendfsync: "everysec"
redis_no_appendfsync_on_rewrite: "no"
redis_auto_aof_rewrite_percentage: "100"
redis_auto_aof_rewrite_min_size: "64mb"
redis_notify_keyspace_events: '""'

## Options de configuration supplémentaires
# laissez vide si non requis. Utilisez un scalar de style bloc pour ajouter des options, par exemple
# redis_config_additional: |
#   io-threads 4
#   io-threads-do-reads yes
redis_config_additional: ""

## Configurations de sentinel Redis
# Définissez ceci sur true sur un hôte pour le configurer comme Sentinel
redis_sentinel: false
redis_sentinel_dir: /var/lib/redis/sentinel_{{ redis_sentinel_port }}
redis_sentinel_bind: 0.0.0.0
redis_sentinel_port: 26379
redis_sentinel_password: false
redis_sentinel_pidfile: /var/run/redis/sentinel_{{ redis_sentinel_port }}.pid
redis_sentinel_logfile: '""'
redis_sentinel_syslog_ident: sentinel_{{ redis_sentinel_port }}
redis_sentinel_monitors:
  - name: master01
    host: localhost
    port: 6379
    quorum: 2
    auth_pass: ant1r3z
    down_after_milliseconds: 30000
    parallel_syncs: 1
    failover_timeout: 180000
    notification_script: false
    client_reconfig_script: false
    rename_commands: []