DavidWittman.redis

ansible-redis

Ansible 2.4+
Kompatybilny z większością wersji Ubuntu/Debian oraz RHEL/CentOS 6.x

Spis treści

Instalacja
Pierwsze kroki
Pojedynczy węzeł Redis
Replikacja Master-Slave
Redis Sentinel
Opcje zaawansowane
Weryfikacja sum kontrolnych
Instalacja z lokalnego archiwum tar
Budowa binarnych plików 32-bitowych
Zmienne roli

Instalacja

$ ansible-galaxy install davidwittman.redis

Pierwsze kroki

Poniżej znajdują się przykładowe pliki playbook i konfiguracje do wdrażania różnych architektur Redis.

Ta rola powinna być uruchamiana jako root lub użytkownik z uprawnieniami sudo.

Pojedynczy węzeł Redis

Wdrożenie pojedynczego węzła serwera Redis jest dość proste; wystarczy dodać rolę do swojego playbooka i działać. Oto przykład, który uczynimy trochę bardziej interesującym, ustawiając adres bind na 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

Uwaga: Możesz zauważyć, że powyżej przekazałem nazwę hosta jako plik inwentarza Ansible. To łatwy sposób na uruchomienie Ansible bez konieczności tworzenia pliku inwentarza, wystarczy dodać przecinek, aby Ansible wiedział, co z tym zrobić.

I to wszystko! Teraz masz serwer Redis nasłuchujący na 127.0.0.1 na redis01.example.com. Domyślnie binaria Redis są instalowane w /opt/redis, chociaż można to nadpisać, ustawiając zmienną redis_install_dir.

Replikacja Master-Slave

Konfigurowanie replikacji w Redis polega na wdrożeniu wielu węzłów i ustawieniu zmiennej redis_slaveof na węzłach podrzędnych, tak jak w redis.conf. W przykładzie, który następuje, wdrożymy Redis master z trzema slave'ami.

W tym przykładzie użyjemy grup, aby oddzielić węzły master i slave. Zaczynamy od pliku inwentarza:

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

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

A oto playbook:

---
- name: skonfiguruj serwer master redis
  hosts: redis-master
  roles:
    - davidwittman.redis

- name: skonfiguruj slave'y redis
  hosts: redis-slave
  vars:
    - redis_slaveof: redis-master.example.com 6379
  roles:
    - davidwittman.redis

W tym przypadku zakładam, że masz skonfigurowane rekordy DNS dla redis-master.example.com, ale nie zawsze tak jest. Możesz dostosować to do swoich potrzeb. W wielu przypadkach mówię Ansible, aby używał adresu IP eth1 dla mastera. Oto bardziej elastyczna wartość:

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

Teraz jesteś gotowy do działania! Uruchamiając ten playbook, powinieneś mieć gotowego Redisa mastera i trzy slave'y.

Redis Sentinel

Wprowadzenie

Używanie replikacji Master-Slave jest świetne dla trwałości i rozdzielania odczytów i zapisów, ale nie dla wysokiej dostępności. Jeśli węzeł master ulegnie awarii, należy ręcznie promować jednego ze slave'ów do roli mastera, a połączenia muszą być przekierowywane do nowego mastera. Rozwiązaniem tego problemu jest Redis Sentinel, rozproszony system, który korzysta z samego Redisa do komunikacji i automatycznego przełączania awaryjnego w klastrze Redis.

Sentinel używa tego samego pliku binarnego redis-server, co Redis, ale działa z flagą --sentinel i innym plikiem konfiguracyjnym. Wszystko to, oczywiście, jest ukryte w tej roli Ansible, ale dobrze to wiedzieć.

Konfiguracja

Aby dodać węzeł Sentinel do istniejącego wdrożenia, przypisz tę samą rolę redis do niego i ustaw zmienną redis_sentinel na True na danym hoście. Można to zrobić na wiele sposobów, a dla potrzeb tego przykładu rozszerzę plik inwentarza użyty powyżej w konfiguracji Master/Slave:

[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

Powyżej dodaliśmy trzy dodatkowe hosty w grupie redis-sentinel (choć ta grupa nie pełni żadnej roli w ramach roli, jest jedynie identyfikatorem) i ustawiliśmy zmienną redis_sentinel w pliku inwentarza.

Teraz wystarczy ustawić zmienną redis_sentinel_monitors, aby określić mastery Redis, które Sentinel ma monitorować. W tym przypadku zrobimy to w playbooku:

- name: skonfiguruj serwer master redis
  hosts: redis-master
  roles:
    - davidwittman.redis

- name: skonfiguruj slave'y redis
  hosts: redis-slave
  vars:
    - redis_slaveof: redis-master.example.com 6379
  roles:
    - davidwittman.redis

- name: skonfiguruj węzły sentinel redis
  hosts: redis-sentinel
  vars:
    - redis_sentinel_monitors:
      - name: master01
        host: redis-master.example.com
        port: 6379
  roles:
    - davidwittman.redis

To skonfiguruje węzły Sentinel do monitorowania mastera, którego utworzyliśmy powyżej, używając identyfikatora master01. Domyślnie Sentinel używa kworum 2, co oznacza, że przynajmniej 2 Sentinels muszą zgodzić się, że master jest wyłączony, aby mogło dojść do przełączania awaryjnego. Można to nadpisać, ustawiając klucz quorum w definicji swojego monitora. Zobacz dokumentację Sentinel po więcej szczegółów.

Oprócz wymienionych powyżej zmiennych, Sentinel ma także swoje własne opcje konfiguracyjne, podobnie jak serwer Redis. Są one prefiksowane redis_sentinel_ i wymienione w sekcji Zmienne roli poniżej.

Wiele włączeń roli

Jeśli potrzebujesz wykonać rolę kilka razy, spójrz na test/test_all.yml, aby zobaczyć, jak to zrobić. Zobacz tutaj oraz tutaj w celu uzyskania kontekstu.

Opcje zaawansowane

Weryfikacja sum kontrolnych

Ustaw zmienną redis_verify_checksum na true, aby użyć opcji weryfikacji sum kontrolnych dla get_url. Należy zauważyć, że ta weryfikacja będzie miała miejsce tylko wtedy, gdy Redis jest pobierany z URL, a nie kiedy jest dostarczany w archiwum tar z redis_tarball.

Podczas korzystania z Ansible 2.x ta rola zweryfikuje sumę kontrolną sha1 pobranego pliku w porównaniu do sum kontrolnych zdefiniowanych w zmiennej redis_checksums w vars/main.yml. Jeśli Twoja wersja nie jest tu zdefiniowana lub chcesz nadpisać sumę kontrolną swoją, po prostu ustaw zmienną redis_checksum. Jak w poniższym przykładzie, musisz prefixować sumę kontrolną typem używanego hasha.

- name: zainstaluj redis w ansible 1.x i zweryfikuj sumy kontrolne
  hosts: all
  roles:
    - role: davidwittman.redis
      redis_version: 3.0.7
      redis_verify_checksum: true
      redis_checksum: "sha256:b2a791c4ea3bb7268795c45c6321ea5abcc24457178373e6a6e3be6372737f23"

Instalacja z lokalnego archiwum tar

Jeśli środowisko, w którym znajduje się Twój serwer, nie zezwala na pobieranie (np. jeśli maszyna jest w strefie DMZ), ustaw zmienną redis_tarball na ścieżkę do lokalnie pobranego archiwum Redis, aby użyć go zamiast pobierania przez HTTP z redis.io.

Nie zapomnij ustawić wersji na tę samą, co archiwum tar, aby uniknąć nieporozumień! Na przykład:

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

W tym przypadku archiwum źródłowe jest kopiowane na serwer przez SSH, zamiast być pobierane.

Budowa binarnych plików 32-bitowych

Aby zbudować 32-bitowe binaria Redis (które można wykorzystać do optymalizacji pamięci), ustaw redis_make_32bit: true. To zainstaluje wymagane zależności (x86 glibc) na systemach RHEL/Debian/SuSE i ustawi opcję '32bit' podczas uruchamiania make.

Budowa z obsługą TLS

Aby zbudować Redis z obsługą TLS (dodana w wersji 6), ustaw redis_make_tls: true. Wymaga to bibliotek deweloperskich OpenSSL (np. libssl-dev na Debianie/Ubuntu).

Zmienne roli

Oto lista wszystkich domyślnych zmiennych dla tej roli, które są również dostępne w defaults/main.yml. Kiedyś sformatuję to w tabelę lub coś podobnego.

---
## Opcje instalacji
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"
# Ustaw na true, aby zweryfikować sumę kontrolną archiwum redis w vars/main.yml
redis_verify_checksum: false
# Ustaw tę wartość na lokalną ścieżkę archiwum do użycia zamiast pobierania
redis_tarball: false
# Ustaw na true, aby zbudować 32-bitowe binaria Redis
redis_make_32bit: false
# Ustaw na true, aby zbudować redis z obsługą TLS, dostępne tylko dla wersji >= 6 (wymaga bibliotek deweloperskich OpenSSL)
redis_make_tls: false

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

# Limit otwartych plików dla Redis/Sentinel
redis_nofile_limit: 16384

## Opcje roli
# Skonfiguruj Redis jako usługę
# To tworzy skrypty inicjujące dla Redis i zapewnia, że proces działa
# Dotyczy również Redis Sentinel
redis_as_service: true
# Dodaj lokalne fakty do /etc/ansible/facts.d dla Redis
redis_local_facts: true
# Nazwa usługi
redis_service_name: "redis_{{ redis_port }}"

## Opcje sieciowe/połączenia
redis_bind: false
redis_port: 6379
redis_password: false
# Opcje replikacji slave
redis_min_slaves_to_write: 0
redis_min_slaves_max_lag: 10
redis_tcp_backlog: 511
redis_tcp_keepalive: 0
# Maksymalna liczba klientów połączonych w tym samym czasie
redis_maxclients: 10000
redis_timeout: 0
# Opcje gniazd
# Ustaw socket_path na żądaną ścieżkę do gniazda. Np. /var/run/redis/{{ redis_port }}.sock
redis_socket_path: false
redis_socket_perm: 755

## Opcje replikacji
# Ustaw slaveof tak, jak w redis.conf. (np. "redis01 6379")
redis_slaveof: false
# Ustaw, aby slave'y były tylko do odczytu. "tak" lub "nie"
redis_slave_read_only: "tak"
redis_slave_priority: 100
redis_repl_backlog_size: false

## Logowanie
redis_logfile: '""'
# Włącz syslog. "tak" lub "nie"
redis_syslog_enabled: "tak"
redis_syslog_ident: "{{ redis_service_name }}"
# Użycie syslog. Musi być USER lub LOCAL0-LOCAL7
redis_syslog_facility: USER

## Ogólna konfiguracja
redis_daemonize: "tak"
redis_pidfile: /var/run/redis/{{ redis_port }}.pid
# Liczba baz danych dozwolonych
redis_databases: 16
redis_loglevel: notice
# Loguj zapytania wolniejsze niż przez ten czas w milisekundach. -1, aby wyłączyć
redis_slowlog_log_slower_than: 10000
# Maksymalna liczba powolnych zapytań do zapisania
redis_slowlog_max_len: 128
# Limit pamięci Redis (np. 4294967296, 4096mb, 4gb)
redis_maxmemory: false
redis_maxmemory_policy: noeviction
redis_rename_commands: []
redis_db_filename: dump.rdb
# Jak często zapisywać bazę danych na dysk
# np. "900 1" => 900 sekund, jeśli przynajmniej 1 klucz się zmienił
redis_save:
  - 900 1
  - 300 10
  - 60 10000
redis_stop_writes_on_bgsave_error: "tak"
redis_rdbcompression: "tak"
redis_rdbchecksum: "tak"
redis_appendonly: "nie"
redis_appendfilename: "appendonly.aof"
redis_appendfsync: "co sekundę"
redis_no_appendfsync_on_rewrite: "nie"
redis_auto_aof_rewrite_percentage: "100"
redis_auto_aof_rewrite_min_size: "64mb"
redis_notify_keyspace_events: '""'

## Dodatkowe opcje konfiguracyjne
# zostaw puste, jeśli nie jest wymagane. Użyj skalarnego stylu bloku, aby dodać opcje, np.
# redis_config_additional: |
#   io-threads 4
#   io-threads-do-reads yes
redis_config_additional: ""

## Konfiguracje sentinela redis
# Ustaw na True na hoście, aby skonfigurować go jako 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: []