Thank you for reading this post, don't forget to subscribe!

1.Установка и настрой­ка кла­сте­ра redis
2.Защита Redis
3.Устранение непо­ла­док в redis
4.Управление хэша­ми
5.Управление спис­ка­ми
6.Управление стро­ка­ми
7.Подключение к базе redis
8.Управление база­ми дан­ных Redis

Redis – это откры­тое хра­ни­ли­ще дан­ных типа «ключ-зна­че­ние». Redis под­дер­жи­ва­ет тран­зак­ции, pub/sub, авто­ма­ти­че­ское ава­рий­ное пере­клю­че­ние и мно­же­ство дру­гих функций.

Раз­ра­бот­чи­ки реко­мен­ду­ют исполь­зо­вать Redis в сре­де про­из­вод­ства Linux и OS X. Redis предо­став­ля­ет мно­же­ство кли­ен­тов, напи­сан­ных на раз­ных язы­ках про­грам­ми­ро­ва­ния; подроб­ную инфор­ма­цию о кли­ен­тах мож­но най­ти на веб-сай­те Redis.

В про­из­вод­ствен­ной сре­де репли­ка­ция дан­ных даже все­го на две ноды счи­та­ет­ся полез­ным реше­ни­ем. Избы­точ­ность дан­ных поз­во­ля­ет вос­ста­но­вить утра­чен­ную инфор­ма­цию в слу­чае сбоя сре­ды; это осо­бен­но важ­но при уве­ли­че­нии поль­зо­ва­тель­ской базы приложения.

Дан­ное руко­вод­ство помо­жет настро­ить два сер­ве­ра Redis: один веду­щий (master) и один ведо­мый (slave). Так­же вы научи­тесь на вре­мя менять места­ми сер­ве­ра master и slave.

При­ме­ча­ние: При помо­щи дан­ных инструк­ций мож­но доба­вить в кла­стер боль­ше серверов.

Дан­ное руко­вод­ство сосре­до­то­че­но на созда­нии кла­сте­ра из двух серверов

1: Установка Redis

Уста­но­ви­те Redis на сер­вер master. Для это­го нуж­но вклю­чить репо­зи­то­рий EPEL.

При­ме­ча­ние: EPEL (Extra Packages for Enterprise Linux) – это репо­зи­то­рий, раз­ра­бо­тан­ный коман­дой Fedora, кото­рый предо­став­ля­ет каче­ствен­ные сто­рон­ние паке­ты для дис­три­бу­ти­вов RHEL.

wget http://dl.fedoraproject.org/pub/epel/7/x86_64/e/epel-release-7-5.noarch.rpm

Если коман­да wget не сра­бо­та­ла, воз­мож­но, она не уста­нов­ле­на. Уста­но­ви­те её:

yum install wget

После это­го сно­ва запустите:

wget http://dl.fedoraproject.org/pub/epel/7/x86_64/e/epel-release-7-5.noarch.rpm

После это­го введите:

sudo rpm -ivh epel-release-7-5.noarch.rpm

Затем исполь­зуй­те команду:

sudo yum -y update

Выпол­не­ние этой коман­ды может занять несколь­ко минут. После это­го мож­но уста­но­вить Redis:

sudo yum install redis -y

После завер­ше­ния уста­нов­ки запу­сти­те сер­вис Redis:

sudo systemctl start redis.service

Про­верь­те состо­я­ние хранилища:

sudo systemctl status redis.service

Коман­да вернёт:

Про­те­сти­руй­те уста­нов­ку Redis:

redis-cli ping

Коман­да долж­на вернуть:

PONG

Так­же про­ве­рить уста­нов­ку мож­но при помо­щи команды:

redis-benchmark -q -n 1000 -c 10 -P 5

Эта коман­да запу­стит redis-benchmark в тихом режи­ме (мак­си­маль­ное коли­че­ство запро­сов – 1000, 10 одно­вре­мен­ных под­клю­че­ний, пере­да­ча 5 запросов).

При­ме­ча­ние: Что­бы полу­чить подроб­ную инфор­ма­цию о redis-benchmark, введите:

redis-benchmark --help

Запу­сти­те эта­лон­ный тест. После его завер­ше­ния резуль­тат будет при­мер­но таким:

После это­го перей­ди­те на сер­вер slave и повто­ри­те все выше­пе­ре­чис­лен­ные действия.

При­ме­ча­ние: Если в вашем кла­сте­ре боль­ше сер­ве­ров, повто­ри­те этот раз­дел на всех серверах.

Итак, хра­ни­ли­ще Redis уста­нов­ле­но и запу­ще­но на двух нодах. Если вывод на любой из нод отли­ча­ет­ся от при­ве­дён­но­го выше выво­да, вни­ма­тель­но повто­ри­те инструк­ции по уста­нов­ке и убе­ди­тесь, что все тре­бо­ва­ния соблюдены.

2: Настройка ведущего сервера (Redis Master)

Итак, у вас есть кла­стер Redis из двух нод. Теперь нуж­но отре­дак­ти­ро­вать их кон­фи­гу­ра­ци­он­ные фай­лы. Меж­ду настрой­ка­ми веду­ще­го и ведо­мо­го сер­ве­ра суще­ству­ют неболь­шие различия.

Для нача­ла настрой­те сер­вер master.

Открой­те в тек­сто­вом редак­то­ре файл /etc/redis.conf:

sudo vi /etc/redis.conf

Отре­дак­ти­руй­те в нём сле­ду­ю­щие строки.

Уста­но­ви­те новое зна­че­ние тай­ме­ра keepalive для TCP:

tcp-keepalive 60

Открой­те доступ к сер­ве­ру в сети, рас­ком­мен­ти­ро­вав сле­ду­ю­щую строку:

#bind 127.0.0.1

Учи­ты­вая осо­бен­но­сти Redis (в част­но­сти, высо­кую ско­рость рабо­ты хра­ни­ли­ща), зло­умыш­лен­ник может очень быст­ро выпол­нить успеш­ную brute force ата­ку и полу­чить пароль досту­па. Поэто­му реко­мен­ду­ет­ся рас­ком­мен­ти­ро­вать стро­ку requirepass и ука­зать в ней слож­ный пароль.

requirepass your_redis_master_password

Сле­ду­ю­щую стро­ку нуж­но отре­дак­ти­ро­вать в зави­си­мо­сти от целей исполь­зо­ва­ния сер­ве­ра. Пред­по­ло­жим, клю­чи не буду уда­лять­ся из кла­сте­ра; тогда нуж­но рас­ком­мен­ти­ро­вать стро­ку и уста­но­вить такое значение:

maxmemory-policy noeviction

После это­го нуж­но настро­ить резерв­ное копи­ро­ва­ние дан­ных. Рас­ком­мен­ти­руй­те сле­ду­ю­щие строи и задай­те им новые значения:

appendonly yes
appendfilename "appendonly.aof"

Сохра­ни­те изменения.

Пере­за­пу­сти­те сер­вис Redis:

sudo systemctl restart redis.service

3: Настройка ведомого сервера (Redis Slave)

Теперь нуж­но настро­ить сер­вер slave. Открой­те /etc/redis.conf в тек­сто­вом редакторе:

sudo vi /etc/redis.conf

Неко­то­рые пара­мет­ры будут сов­па­дать с сер­ве­ром master.

Открой­те доступ к сер­ве­ру в сети; для это­го нуж­но рас­ком­мен­ти­ро­вать строку:

#bind 127.0.0.1

Сер­ве­ру slave так­же необ­хо­дим пароль. Рас­ком­мен­ти­руй­те сле­ду­ю­щую стро­ку и вве­ди­те надёж­ный пароль:

requirepass your_redis_slave_password

Затем рас­ком­мен­ти­руй­те сле­ду­ю­щую стро­ку и ука­жи­те IP-адрес сер­ве­ра master и порт (по мол­ча­нию – порт 6379):

slaveof your_redis_master_ip 6379

Рас­ком­мен­ти­руй­те masterauth и ука­жи­те пароль сер­ве­ра master.

masterauth your_redis_master_password

Сохра­ни­те и закрой­те файл. Пере­за­пу­сти­те сервис:

sudo systemctl restart redis.service

Эта коман­да пере­за­пу­стит Redis с новы­ми настройками.

Под­клю­чи­тесь к сер­ве­ру Redis:

redis-cli -h 127.0.0.1 -p 6379

Авто­ри­зуй­тесь при помо­щи паро­ля сер­ве­ра slave.

AUTH your_redis_slave_password

Итак, теперь маши­ны master и slave кла­сте­ра Redis настроены.

4: Репликация данных

Что­бы луч­ше понять пове­де­ние кла­сте­ра Redis, про­те­сти­руй­те его рабо­ту. Про­верь­те вза­и­мо­дей­ствие сер­ве­ров Redis.

На сер­ве­ре master под­клю­чи­тесь к Redis в терминале.

Сна­ча­ла под­клю­чи­тесь к локаль­ной копии на порт 6379.

При­ме­ча­ние: Если вы изме­ни­ли стан­дарт­ный порт, ука­жи­те новый номер порта.

redis-cli -h 127.0.0.1 -p 6379

Ука­жи­те пароль Redis:

AUTH your_redis_master_password

Коман­да долж­на вернуть:

OK

После это­го нуж­но запустить:

INFO

Эта коман­да предо­ста­вит все дан­ные о master-сер­ве­ре Redis. Осо­бен­но важен сей­час раз­дел #Replication. Он дол­жен выгля­деть при­мер­но так:

Обра­ти­те вни­ма­ние на стро­ку connected_slaves:1, кото­рая зна­чит, что ведо­мый сер­вер вза­и­мо­дей­ству­ет с сер­ве­ром master. Так­же здесь мож­но най­ти IP-адрес, порт, состо­я­ние, и мно­го дру­гих све­де­ний о сервере.

Теперь про­смот­ри­те раз­дел #Replication на машине slave. Под­клю­чи­тесь к это­му сер­ве­ру и выпол­ни­те коман­ду INFO.

Как види­те, здесь отме­че­но, что дан­ная маши­на испол­ня­ет роль ведо­мой и не име­ет под­чи­нён­ных ей машин.

5: Настройка аварийного переключения

Любой сер­вер slave мож­но повы­сить до ста­ту­са master. Такая архи­тек­ту­ра кла­сте­ра поз­во­ля­ет обра­ба­ты­вать сбои, обес­пе­чи­вая целост­ность дан­ных и наи­мень­шее вре­мя простоя.

Попро­буй­те выпол­нить такую настрой­ку вручную.

На сер­ве­ре slave под­клю­чи­тесь к Redis:

redis-cli -h 127.0.0.1 -p 6379

Авто­ри­зуй­тесь, ука­зав пароль:

AUTH your_redis_slave_password

Отклю­чи­те пове­де­ние slave:

SLAVEOF NO ONE

Коман­да ответит:

OK

После это­го введите:

INFO

Най­ди­те раз­дел # Replication:

Как и ожи­да­лось, slave-сер­вер стал сер­ве­ром master и теперь может при­ни­мать соеди­не­ния от дру­гих машин. Его мож­но исполь­зо­вать в каче­стве веду­ще­го сер­ве­ра на вре­мя устра­не­ния оши­бок на преды­ду­щем сер­ве­ре master.

Если в кла­сте­ре есть несколь­ко slave-сер­ве­ров, после изме­не­ния master-сер­ве­ра нуж­но соеди­нить их с новым сервером.

Для это­го мож­но создать скрипт, кото­рый в слу­чае сбоя сер­ве­ра master вне­сёт соот­вет­ству­ю­щие поправ­ки в настройки:

• Пере­на­пра­вит все запро­сы на сер­вер slave.
• Выпол­нит на этом сер­ве­ре коман­ду SLAVEOF NO ONE. Начи­ная с вер­сии Redis 1.0.0, эта коман­да отклю­ча­ет репли­ка­цию дан­ных на сер­ве­ре slave и запус­ка­ет его в каче­стве веду­ще­го сервера.
• Пере­под­клю­чит все суще­ству­ю­щие сер­ве­ры slave (SLAVEOF hostname port) к ново­му master-сер­ве­ру. Зна­че­ния hostname и port нуж­но заме­нить име­нем хоста и пор­том ново­го master-сервера.
• Устра­нив непо­лад­ки на ста­ром сер­ве­ре master, мож­но вос­ста­но­вить его статус.

Суще­ству­ет мно­же­ство средств для обес­пе­че­ния тако­го пове­де­ния кластера.

Выбе­ри­те наи­бо­лее под­хо­дя­щее для вашей сре­ды реше­ние и тща­тель­но про­те­сти­руй­те его, преж­де чем воз­ник­нут какие-либо сбои.

6: Восстановление статуса master

Теперь ста­рый master-сер­вер стал сер­ве­ром slave. Что­бы вос­ста­но­вить ста­рый сер­вер master, вой­ди­те на теку­щий сер­вер master, запу­сти­те Redis и вве­ди­те сле­ду­ю­щую команду:

SLAVEOF your_redis_master_ip 6379

Если теперь сно­ва запу­стить коман­ду INFO, вы уви­ди­те, что настрой­ки вер­ну­лись в исход­ное состояние.

 

2.Защита Redis

Эффек­тив­ный спо­соб защи­тить Redis – защи­тить сер­вер, на кото­ром он рабо­та­ет. Вы може­те сде­лать это, при­вя­зав Redis к локаль­но­му хосту или к внут­рен­не­му IP-адре­су и настро­ив брандмауэр.

Одна­ко если вы хоти­те настро­ить кла­стер Redis, вам нуж­но будет раз­ре­шить внеш­ние под­клю­че­ния, что не так без­опас­но, как при­вяз­ка к локаль­но­му хосту или внут­рен­не­му IP-адресу.

Открой­те файл Redis:

sudo vi /etc/redis.conf

Най­ди­те стро­ку bind и убе­ди­тесь, что она раскоментирована:

bind 127.0.0.1

Если вам нуж­но свя­зать Redis с дру­гим IP-адре­сом (напри­мер, если вы буде­те обра­щать­ся к Redis с отдель­но­го хоста), насто­я­тель­но реко­мен­ду­ем вам при­вя­зать его к внут­рен­не­му IP-адре­су. При­вяз­ка к внеш­не­му IP-адре­су под­вер­га­ет интер­фейс Redis посто­рон­не­му воздействию.

bind your_private_ip

Если вы выпол­ни­ли пред­ва­ри­тель­ные тре­бо­ва­ния к ману­а­лу и уста­но­ви­ли firewalld на свой сер­вер, и вы не пла­ни­ру­е­те под­клю­чать­ся к Redis с дру­го­го хоста, вам не нуж­но добав­лять допол­ни­тель­ные пра­ви­ла бранд­мау­э­ра для Redis. В кон­це кон­цов, любой вхо­дя­щий тра­фик по умол­ча­нию будет сбро­шен, если его явно не раз­ре­ша­ют пра­ви­ла бранд­мау­э­ра. Посколь­ку авто­ном­ная уста­нов­ка сер­ве­ра Redis по умол­ча­нию про­слу­ши­ва­ет толь­ко интер­фейс loopback (127.0.0.1 или localhost), вы може­те не пере­жи­вать по пово­ду вхо­дя­ще­го тра­фи­ка на порт по умолчанию.

Если, одна­ко, вы пла­ни­ру­е­те полу­чать доступ к Redis с дру­го­го хоста, вам нуж­но вне­сти неко­то­рые изме­не­ния в кон­фи­гу­ра­цию firewalld, исполь­зуя коман­ду firewall-cmd. Опять же, вы долж­ны раз­ре­шать доступ к сер­ве­ру Redis, исполь­зуя внут­рен­ние IP-адре­са кли­ен­тов, что­бы огра­ни­чить коли­че­ство хостов, у кото­рых есть доступ к сервису.

Добавь­те выде­лен­ную зону Redis в бранд­мау­эр firewalld:

sudo firewall-cmd --permanent --new-zone=redis

Затем ука­жи­те, какой порт вы хоти­те открыть. Redis исполь­зу­ет порт 6397 по умолчанию:

sudo firewall-cmd --permanent --zone=redis --add-port=6379/tcp

Затем ука­жи­те внут­рен­ние IP-адре­са, кото­рые могут прой­ти бранд­мау­эр и полу­чить доступ к Redis:

sudo firewall-cmd --permanent --zone=redis --add-source=client_server_private_IP

Затем пере­за­пу­сти­те бранд­мау­эр, что­бы обно­вить правила:

sudo firewall-cmd --reload

Когда бранд­мау­эр уви­дит пакет с IP-адре­са кли­ен­та, он при­ме­нит к это­му соеди­не­нию пра­ви­ла в выде­лен­ной зоне Redis. Все осталь­ные соеди­не­ния будут обра­ба­ты­вать­ся в зоне по умол­ча­нию public. Сер­ви­сы в зоне по умол­ча­нию при­ме­ня­ют­ся к каж­до­му соеди­не­нию, а не толь­ко к тем, кото­рые не соот­вет­ству­ют дру­гим зонам, поэто­му вам не нуж­но добав­лять дру­гие служ­бы (напри­мер, SSH) в зону Redis – эти пра­ви­ла будут при­ме­нять­ся к соеди­не­нию автоматически.

Если вы исполь­зу­е­те бранд­мау­эр Iptables, вам необ­хо­ди­мо предо­ста­вить кли­ен­там доступ к пор­ту Redis, для чего нуж­ны сле­ду­ю­щие команды:

sudo iptables -A INPUT -i lo -j ACCEPT
sudo iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
sudo iptables -A INPUT -p tcp -s client_servers_private_IP/32 --dport 6397 -m conntrack --ctstate NEW,ESTABLISHED -j ACCEPT
sudo iptables -P INPUT DROP

Обя­за­тель­но сохра­ни­те пра­ви­ла бранд­мау­э­ра Iptables с помо­щью меха­низ­ма, предо­став­ля­е­мо­го вашим дистрибутивом.

Для защи­ты Redis подой­дет любой бранд­мау­эр. Важ­но, что­бы бранд­мау­эр рабо­тал и защи­щал сер­вер от посто­рон­них пользователей.

Настройка пароля Redis

Если у ваше­го кла­сте­ра уже есть пароль, в этом раз­де­ле вы узна­е­те, как сде­лать его более надежным.

Настра­и­вая пароль, вы вклю­ча­е­те одну из встро­ен­ных функ­ций Redis – коман­ду auth, кото­рая тре­бу­ет у кли­ен­та прой­ти аутен­ти­фи­ка­цию, преж­де чем открыть ему доступ к БД. Как и пара­метр bind, паоль настра­и­ва­ет­ся в кон­фи­гу­ра­ци­он­ном фай­ле /etc/redis.conf.

sudo vi /etc/redis.conf

Най­ди­те раз­дел SECURITY и най­ди­те заком­мен­ти­ро­ван­ную директиву:

# requirepass foobared

Рас­ком­мен­ти­руй­те ее, уда­лив #, и ука­жи­те здесь надеж­ный пароль (жела­тель­но выбрать послож­нее). Вме­сто того что­бы само­сто­я­тель­но при­ду­мы­вать пароль, вы може­те исполь­зо­вать такой инстру­мент, как apg или pwgen. Если вы не хоти­те уста­нав­ли­вать при­ло­же­ние толь­ко для того, что­бы сге­не­ри­ро­вать один пароль, вы може­те исполь­зо­вать при­ве­ден­ную ниже команду.

Обра­ти­те вни­ма­ние, при каж­дом запус­ке эта коман­да будет гене­ри­ро­вать один и тот же пароль. Что­бы создать дру­гой пароль, изме­ни­те сло­во в кавычках.

echo "help-me" | sha256sum

Сге­не­ри­ро­ван­ный пароль будет выра­жен после­до­ва­тель­но­стью сим­во­лов, кото­рую слож­но запом­нить, но такой пароль очень наде­жен и он доста­точ­но длин­ный, что важ­но для Redis. Ско­пи­руй­те пароль из выво­да этой коман­ды и вставь­те его в каче­стве ново­го зна­че­ния requirepass:

requirepass password_copied_from_output

Если вы пред­по­чи­та­е­те более корот­кие паро­ли, исполь­зуй­те вме­сто это­го сле­ду­ю­щую коман­ду. Сно­ва изме­ни­те сло­во в кавыч­ках, что­бы она не гене­ри­ро­ва­ла тот же пароль.

echo "help-me" | sha1sum

Уста­но­вив пароль, сохра­ни­те и закрой­те файл.

Пере­за­пу­сти­те Redis:

sudo systemctl restart redis.service

Что­бы про­ве­рить, рабо­та­ет ли пароль, перей­ди­те в команд­ную стро­ку Redis:

redis-cli

Что­бы про­ве­рить рабо­то­спо­соб­ность паро­ля Redis, исполь­зуй­те такую после­до­ва­тель­ность команд. Пер­вая коман­да пыта­ет­ся при­сво­ить зна­че­нию без аутентификации.

set key1 10

Она не сра­бо­та­ет, так как для выпол­не­ния опе­ра­ции нужен пароль.

(error) NOAUTH Authentication required.

Сле­ду­ю­щая коман­да про­хо­дит аутен­ти­фи­ка­цию с паро­лем, ука­зан­ным в фай­ле кон­фи­гу­ра­ции Redis.

auth your_redis_password

Redis под­твер­жда­ет, что вы про­шли аутентификацию:

OK

После это­го повто­ри­те преды­ду­щую коман­ду, теперь опе­ра­ция будет выпол­не­на успешно:

set key1 10
OK

Эта коман­да извле­чет зна­че­ние ново­го ключа:

get key1
"10"

Эта коман­да закро­ет redis-cli:

quit

Мож­но так­же исполь­зо­вать exit.

Теперь будет очень труд­но полу­чить несанк­ци­о­ни­ро­ван­ный доступ к Redis. Обра­ти­те вни­ма­ние, что без SSL или VPN посто­рон­ние поль­зо­ва­те­ли могут пере­хва­тить неза­шиф­ро­ван­ный пароль, если вы под­клю­ча­е­тесь к Redis удаленно.

Переименование команд

Еще одна встро­ен­ная функ­ция без­опас­но­сти Redis поз­во­ля­ет вам пере­име­но­вы­вать или пол­но­стью отклю­чать опре­де­лен­ные коман­ды, кото­рые счи­та­ют­ся опас­ны­ми. Зло­умыш­лен­ни­ки могут исполь­зо­вать такие коман­ды для пере­на­строй­ки, уни­что­же­ния или повре­жде­ния дан­ных. Вот крат­кий спи­сок опас­ных команд:

• FLUSHDB
• FLUSHALL
• KEYS
• PEXPIRE
• DEL
• CONFIG
• SHUTDOWN
• BGREWRITEAOF
• BGSAVE
• SAVE
• SPOP
• SREM RENAME DEBUG

Это не пол­ный спи­сок, но для нача­ла доста­точ­но будет пере­име­но­вать или отклю­чить все коман­ды в этом списке.

Отклю­чать или пере­име­но­вы­вать коман­ду – это зави­сит от кон­крет­ной ситу­а­ции. Если вы зна­е­те, что нико­гда не буде­те исполь­зо­вать опас­ную коман­ду, вы може­те ее отклю­чить. В про­тив­ном слу­чае вы долж­ны пере­име­но­вать ее.

Как и пароль, пере­име­но­ва­ние или отклю­че­ние команд настра­и­ва­ет­ся в раз­де­ле SECURITY фай­ла /etc/redis.conf. Открой­те файл:

sudo vi  /etc/redis.conf

Важ­но! Далее в мануа­ле при­ве­де­ны общие при­ме­ры. Вы долж­ны отклю­чить или пере­име­но­вать коман­ды, кото­рые важ­ны в вашей кон­крет­ной ситу­а­ции. Вы може­те узнать боль­ше о вре­до­нос­ном исполь­зо­ва­нии команд на redis.io/commands.

Что­бы отклю­чить коман­ду, про­сто пере­име­нуй­те ее в пустую стро­ку, как пока­за­но ниже:

Что­бы пере­име­но­вать коман­ду, дай­те ей дру­гое имя, как в при­ве­ден­ных ниже при­ме­рах. Пере­име­но­ван­ные коман­ды дру­гим поль­зо­ва­те­лям долж­но быть труд­но уга­дать, а вам – лег­ко запомнить.

rename-command CONFIG ""
rename-command SHUTDOWN SHUTDOWN_MENOT
rename-command CONFIG ASC12_CONFIG

Сохра­ни­те и закрой­те файл. Пере­за­пу­сти­те Redis:

sudo service redis-server restart

Что­бы про­ве­рить новую коман­ду, открой­те команд­ную стро­ку Redis:

redis-cli

Прой­ди­те аутен­ти­фи­ка­цию, исполь­зуя пароль, кото­рый вы опре­де­ли­ли ранее:

auth your_redis_password
OK

Пред­по­ло­жим, что вы пере­име­но­ва­ли коман­ду CONFIG в ASC12_CONFIG; в таком слу­чае попыт­ка запу­стить коман­ду config долж­на завер­шить­ся ошибкой.

config get requirepass
(error) ERR unknown command 'config'

Теперь сра­бо­та­ет пере­име­но­ван­ная команда:

asc12_config get requirepass
1) "requirepass"
2) "your_redis_password"

Закрой­те redis-cli:

exit

Обра­ти­те вни­ма­ние, если вы пере­за­гру­жа­е­те Redis, не закрыв перед этим команд­ную стро­ку, вам необ­хо­ди­мо повтор­но прой­ти аутен­ти­фи­ка­цию. В про­тив­ном слу­чае вы полу­чи­те эту ошибку:

NOAUTH Authentication required.

Важ­но! Что каса­ет­ся пере­име­но­ва­ния команд, в кон­це раз­де­ла SECURITY в фай­ле /etc/redis.conf содер­жит­ся предо­сте­ре­га­ю­щее заявление:

Please note that changing the name of commands that are logged into the AOF file or transmitted to slaves may cause problems.

Это озна­ча­ет, что если пере­име­но­ван­ная коман­да не нахо­дит­ся в фай­ле AOF или этот файл не был пере­дан slave маши­нам, тогда про­блем не долж­но быть. Помни­те об этом при пере­име­но­ва­нии команд. Луч­шее вре­мя для пере­име­но­ва­ния коман­ды – это сра­зу после уста­нов­ки или когда вы не исполь­зу­е­те AOF (то есть перед раз­вер­ты­ва­ни­ем при­ло­же­ния, исполь­зу­ю­ще­го Redis).

Если вы исполь­зу­е­те AOF в уста­нов­ке master-slave, GitHub сове­ту­ет вот что:

Команды регистрируются в AOF и реплицируются на slave так же, как отправляются; поэтому если вы попытаетесь воспроизвести AOF на экземпляре, который не поддерживает таких же переименованных команд, вы можете столкнуться с конфликтом.

Луч­ший спо­соб избе­жать про­блем с пере­име­но­ва­ни­ем в таких слу­ча­ях – убе­дить­ся, что пере­име­но­ван­ные коман­ды при­ме­ня­ют­ся ко всем экзем­пля­рам уста­нов­ки master-slave.

Права на файлы и каталог данных

На этом эта­пе нуж­но изме­нить пра­ва соб­ствен­но­сти и досту­па к фай­лам, что­бы улуч­шить про­филь без­опас­но­сти уста­нов­ки Redis. Под­ра­зу­ме­ва­ет­ся, что пра­во на чте­ние фай­лов есть толь­ко у поль­зо­ва­те­ля, кото­ро­му такой доступ необ­хо­дим для рабо­ты. Этот поль­зо­ва­тель по умол­ча­нию – redis.

Что­бы про­ве­рить это, исполь­зуй­те grep:

ls -l /var/lib | grep redis
drwxr-xr-x 2 redis   redis   4096 Aug  6 09:32 redis

Вы уви­ди­те, что ката­лог дан­ных Redis при­над­ле­жит поль­зо­ва­те­лю redis и груп­пе redis. Такие пра­ва соб­ствен­но­сти без­опас­ны, но пра­ва досту­па к ката­ло­гу (755) – нет. Что­бы толь­ко поль­зо­ва­тель Redis имел доступ к пап­ке и ее содер­жи­мо­му, изме­ни­те пра­ва досту­па на 770:

sudo chmod 770 /var/lib/redis

Так­же нуж­но изме­нить пра­ва досту­па к кон­фи­гу­ра­ци­он­но­му фай­лу. По умол­ча­нию это 644, файл при­над­ле­жит поль­зо­ва­те­лю и груп­пе root:

ls -l /etc/redis.conf
-rw-r--r-- 1 root root 30176 Jan 14  2014 /etc/redis.conf

Такие пра­ва досту­па (644) поз­во­ля­ют всем поль­зо­ва­те­лям читать файл. Это очень рис­ко­ван­но, так как файл кон­фи­гу­ра­ции содер­жит неза­шиф­ро­ван­ный пароль, кото­рый вы настро­и­ли в раз­де­ле 4. Вам необ­хо­ди­мо изме­нить пра­ва соб­ствен­но­сти и пра­ва досту­па к фай­лу кон­фи­гу­ра­ции. В иде­а­ле, он дол­жен при­над­ле­жать поль­зо­ва­те­лю redis и груп­пе redis. Для это­го запу­сти­те сле­ду­ю­щую команду:

sudo chown redis:redis /etc/redis.conf

Теперь пере­дай­те все пра­ва на чте­ние и запись вла­дель­цу файла:

sudo chmod 660 /etc/redis.conf

Про­ве­рить пра­ва может эта команда:

ls -l /etc/redis.conf
total 40
-rw------- 1 redis redis 29716 Sep 22 18:32 /etc/redis.conf

Пере­за­пу­сти­те Redis:

sudo service redis-server restart

 

3.Устранение ошибок, связанных с памятью

Коман­да memory usage гово­рит, сколь­ко памя­ти в насто­я­щее вре­мя исполь­зу­ет­ся одним клю­чом. Она при­ни­ма­ет имя клю­ча в каче­стве аргу­мен­та и выво­дит коли­че­ство бай­тов, кото­рые он использует:

memory usage key_meaningOfLife
(integer) 42

Для более общей кар­ти­ны исполь­зо­ва­ния памя­ти сер­ве­ром Redis вы може­те выпол­нить коман­ду memory stats:

memory stats

Эта коман­да выво­дит мас­сив свя­зан­ных с памя­тью мет­рик и их зна­че­ний. Ниже при­ве­де­ны пока­за­те­ли, кото­рые выво­дит коман­да memory stats:

• peak.allocated: мак­си­маль­ное коли­че­ство бай­тов, потреб­ля­е­мых Redis.
• total.allocated: общее коли­че­ство бай­тов, выде­лен­ных Redis.
• startup.allocated: началь­ное коли­че­ство бай­тов, исполь­зо­ван­ных Redis при запуске.
• replication.backlog: раз­мер лога репли­ка­ции в байтах.
• client.slaves: общий раз­мер всех издер­жек репли­ки (буфе­ры выво­да и запро­сов и кон­тек­сты соединения).
• clients.normal: общий раз­мер всех наклад­ных рас­хо­дов клиента.
• aof.buffer: общий раз­мер теку­щих и пере­за­пи­сы­ва­е­мых буфе­ров толь­ко для запи­си.
• db.0: издерж­ки сло­ва­рей main и expiry для каж­дой базы дан­ных, исполь­зу­е­мой на сер­ве­ре, в байтах.
• overhead.total: сум­ма всех издер­жек, исполь­зу­е­мых для управ­ле­ния про­стран­ством клю­чей Redis.
• keys.count: общее коли­че­ство клю­чей во всех базах дан­ных на сервере.
• keys.bytes-per-key: соот­но­ше­ние исполь­зо­ва­ния памя­ти сер­ве­ра и коли­че­ства клю­чей из keys.count.
• dataset.bytes: раз­мер набо­ра дан­ных в байтах
• dataset.percentage: про­цент исполь­зо­ва­ния чистой памя­ти Redis, заня­тый dataset.bytes.
• peak.percentage: про­цент зна­че­ния peak.allocated в общем объ­е­ме total.allocated.
• fragmentation: отно­ше­ние объ­е­ма исполь­зу­е­мой в дан­ный момент памя­ти к физи­че­ской памя­ти, исполь­зу­е­мой Redis.

Коман­да memory malloc-stats предо­став­ля­ет внут­рен­ний ста­ти­сти­че­ский отчет от jemalloc, рас­пре­де­ли­те­ля памя­ти Redis в систе­мах Linux:

memory malloc-stats

Если кажет­ся, что ваши про­бле­мы свя­за­ны с памя­тью, но ана­лиз выход­ных дан­ных преды­ду­щих команд ниче­го полез­но­го не гово­рит, вы може­те попро­бо­вать запу­стить коман­ду memory doctor:

memory doctor

Эта функ­ция выво­дит все про­бле­мы, свя­зан­ные с исполь­зо­ва­ни­ем памя­ти, кото­рые она может най­ти, и пред­ла­га­ет воз­мож­ные решения.

Сбор общей информации об экземпляре Redis

Коман­да monitor – это коман­да отлад­ки, кото­рая не свя­за­на напря­мую с управ­ле­ни­ем памя­тью. Она поз­во­ля­ет посмот­реть на посто­ян­ный поток каж­дой коман­ды, обра­ба­ты­ва­е­мой сер­ве­ром Redis:

monitor
OK
1566157213.896437 [0 127.0.0.1:47740] "auth" "foobared"
1566157215.870306 [0 127.0.0.1:47740] "set" "key_1" "878"

Еще одна полез­ная для отлад­ки коман­да – это info, она воз­вра­ща­ет несколь­ко бло­ков инфор­ма­ции и ста­ти­сти­ки о сервере:

info
# Server
redis_version:4.0.9
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:9435c3c2879311f3
redis_mode:standalone
os:Linux 4.15.0-52-generic x86_64
. . .

Эта коман­да воз­вра­ща­ет мно­го дан­ных. Если вы хоти­те уви­деть толь­ко один кон­крет­ный блок, вы може­те ука­зать его в каче­стве аргу­мен­та коман­ды info:

info CPU
# CPU
used_cpu_sys:173.16
used_cpu_user:70.89
used_cpu_sys_children:0.01
used_cpu_user_children:0.04

Обра­ти­те вни­ма­ние: вывод коман­ды info будет зави­сеть от того, какую вер­сию Redis вы используете.

Использование команд keys

Коман­да keys полез­на в тех слу­ча­ях, когда вы забы­ли назва­ние клю­ча или, воз­мож­но, созда­ли его, но слу­чай­но ошиб­лись в назва­нии клю­ча. Коман­да keys ищет клю­чи, кото­рые соот­вет­ству­ют шаблону:

keys pattern

Коман­да под­дер­жи­ва­ет сле­ду­ю­щие гло­баль­ные переменные:

• ? – под­ста­но­воч­ный знак для одно­го сим­во­ла. Напри­мер, шаб­лон s?mmy соот­вет­ству­ет клю­чам sammy, sommy и sqmmy.
• – это под­ста­но­воч­ный знак для любо­го коли­че­ства сим­во­лов (вклю­чая 0 сим­во­лов). Напри­мер, шаб­лон sa*y сов­па­дет с клю­ча­ми sammy, say, sammmmmmy и salmony.
• Вы може­те ука­зать два или более сим­во­лов, кото­рые может вклю­чать шаб­лон, в квад­рат­ных скоб­ках. То есть, шаб­лон s[ai]mmy сов­па­дет с резуль­та­та­ми sammy и simmy, но не с summy.
• Что­бы игно­ри­ро­вать одну или несколь­ко букв, заклю­чи­те их в квад­рат­ные скоб­ки и поставь­те перед ними сим­вол ^. Напри­мер, шаб­лон s[^oi]mmy сов­па­дет с клю­чом sammy или sxmmy, но не с sommy или simmy.
• Что­бы задать диа­па­зон букв, ука­жи­те первую и послед­нюю бук­ву диа­па­зо­на и возь­ми­те их в квад­рат­ные скоб­ки. Шаб­лон s[a-o]mmy соот­вет­ству­ет клю­чам sammy, skmmy или sommy, но не соот­вет­ству­ет клю­чу srmmy

Важ­но! Доку­мен­та­ция Redis реко­мен­ду­ет исполь­зо­вать коман­ду keys в про­из­вод­ствен­ной сре­де толь­ко в исклю­чи­тель­ных слу­ча­ях, так как она может ока­зать суще­ствен­ное нега­тив­ное вли­я­ние на производительность.

 

4. Управление хэшами

Что­бы создать хэш, запу­сти­те коман­ду hset. Эта коман­да при­ни­ма­ет в каче­стве аргу­мен­тов ключ, поле и соот­вет­ству­ю­щую стро­ку значения:

hset poet:Verlaine nationality French

При­ме­ча­ние: В этом и сле­ду­ю­щих при­ме­рах poet:Verlaine – ключ хэе­ша. Точ­ки, тире и двое­то­чия обыч­но исполь­зу­ют­ся, что­бы сде­лать мно­го­слов­ные клю­чи и поля более чита­бель­ны­ми. Для запи­си клю­чей при­ня­то после­до­ва­тель­но исполь­зо­вать лег­ко чита­е­мый формат.

Коман­да hset воз­вра­ща­ет (integer) 1, если ука­зан­ное поле добав­ле­но и зна­че­ние уста­нов­ле­но правильно:

(integer) 1

Одна­ко если вы непра­виль­но ука­за­ли зна­че­ние, поле или имя клю­ча хэша, hset вер­нет ошибку.

Так­же обра­ти­те вни­ма­ние, что hset пере­за­пи­шет содер­жи­мое хэша, если такой хэш уже существует:

hset poet:Verlaine nationality Francais

Если поле уже суще­ству­ет и его зна­че­ние было успеш­но обнов­ле­но, hset вернет:

(integer) 0

Вы так­же може­те исполь­зо­вать hsetnx для добав­ле­ния полей в хэши, но эта коман­да сра­бо­та­ет толь­ко в том слу­чае, если поле еще не суще­ству­ет. Если ука­зан­ное поле уже суще­ству­ет, hsetnx ниче­го не сде­ла­ет и вер­нет (integer) 0:

hsetnx poet:Verlaine nationality French
(integer) 0

Что­бы уста­но­вить несколь­ко пар «поле/значение» для дан­но­го набо­ра, исполь­зуй­те коман­ду hmset, за кото­рой ука­жи­те необ­хо­ди­мые стро­ки «поле/значение»:

hmset poet:Verlaine born 1844 died 1896 genre Decadent

Коман­да hmset вер­нет OK, если все про­шло успешно.

Извлечение информации из хэшей

С помо­щью коман­ды hexists мож­но опре­де­лить, суще­ству­ет ли поле в дан­ном хэше:

hexists poet:Verlaine nationality

Коман­да hexists вер­нет (integer) 1, если поле суще­ству­ет, и (integer) 0, если нет.

Что­бы вер­нуть зна­че­ние поля, запу­сти­те коман­ду hget, а затем ука­жи­те ключ хэша и поле, зна­че­ние кото­ро­го вы хоти­те получить:

hget poet:Verlaine nationality
"Francais"

Коман­да hmget исполь­зу­ет тот же син­так­сис, но может воз­вра­щать зна­че­ния несколь­ких полей сразу:

hmget poet:Verlaine born died
1) "1844"
2) "1896"

Если хэш, кото­рый вы пере­да­е­те hget или hmget, не суще­ству­ет, обе коман­ды вер­нут (nil):

hmget poet:Dickinson born died
1) (nil)
2) (nil)

Что­бы полу­чить спи­сок всех полей, содер­жа­щих­ся в опре­де­лен­ном хэше, выпол­ни­те коман­ду hkeys:

hkeys poet:Verlaine
1) "nationality"
2) "born"
3) "died"
4) "genre"

Что­бы полу­чить спи­сок зна­че­ний, содер­жа­щих­ся в хэше, запу­сти­те hvals:

hvals poet:Verlaine
1) "French"
2) "1844"
3) "1896"
4) "Decadent"

Что­бы вер­нуть спи­сок всех полей в хэше и свя­зан­ных с ними зна­че­ний, запу­сти­те hgetall:

hgetall poet:Verlaine
1) "nationality"
2) "French"
3) "born"
4) "1844"
5) "died"
6) "1896"
7) "genre"
8) "Decadent"

Вы може­те узнать коли­че­ство полей в хэше, запу­стив hlen, что рас­шиф­ро­вы­ва­ет­ся как «hash length»:

hlen poet:Verlaine
(integer) 4

Вы може­те узнать дли­ну стро­ки зна­че­ния, свя­зан­ной с кон­крет­ным полем, с помо­щью коман­ды hstrlen, что рас­шиф­ро­вы­ва­ет­ся как «hash string length»:

hstrlen poet:Verlaine nationality

(integer) 8

Коман­да hlen вер­нет (integer) 0, если хэша не существует.

Удаление полей из хэшей

Что­бы уда­лить поле из хэша, выпол­ни­те коман­ду hdel. Она может при­ни­мать несколь­ко полей в каче­стве аргу­мен­тов и воз­вра­ща­ет целое чис­ло, ука­зы­ва­ю­щее, сколь­ко полей было уда­ле­но из хэша:

hdel poet:Verlaine born died
(integer) 2

Если вы пере­да­ди­те коман­де hdel несу­ще­ству­ю­щее поле, она будет игно­ри­ро­вать это поле, но уда­лит все дру­гие суще­ству­ю­щие поля, кото­рые вы укажете.

5.Управление списками

Создание списков

Ключ может содер­жать толь­ко один спи­сок. Спи­сок может содер­жать более четы­рех мил­ли­ар­дов эле­мен­тов. Redis чита­ет спис­ки сле­ва напра­во. Вы може­те поме­щать новые эле­мен­ты в нача­ло спис­ка (его «левый» конец) с помо­щью коман­ды lpush или в конец («пра­вый» конец) с помо­щью rpush. Вы так­же може­те исполь­зо­вать коман­ды lpush или rpush для созда­ния ново­го списка:

lpush key value

Обе коман­ды выве­дут целое чис­ло, пока­зы­ва­ю­щее, сколь­ко эле­мен­тов суще­ству­ет в дан­ном спис­ке. Что­бы уви­деть, как это рабо­та­ет, выпол­ни­те сле­ду­ю­щие коман­ды для созда­ния спис­ка, содер­жа­ще­го изре­че­ние «I think therefore I am»:

lpush key_philosophy1 "therefore"
lpush key_philosophy1 "think"
rpush key_philosophy1 "I"
lpush key_philosophy1 "I"
rpush key_philosophy1 "am"

Вывод послед­ней коман­ды будет выгля­деть так:

(integer) 5

Обра­ти­те вни­ма­ние: вы може­те доба­вить в спи­сок несколь­ко эле­мен­тов с помо­щью одно­го опе­ра­то­ра lpush или rpush:

rpush key_philosophy1 "-" "Rene" "Decartes"

Коман­ды lpushx и rpushx так­же поз­во­ля­ют добав­лять эле­мен­ты в спи­сок, но толь­ко в том слу­чае, если задан­ный спи­сок уже суще­ству­ет. Если любая из команд не может быть выпол­не­на, она вер­нет (integer) 0:

rpushx key_philosophy2 "Happiness" "is" "the" "highest" "good" "–" "Aristotle"
(integer) 0

Что­бы изме­нить суще­ству­ю­щий эле­мент в спис­ке, выпол­ни­те коман­ду lset, за кото­рой ука­жи­те имя клю­ча, индекс эле­мен­та, кото­рый вы хоти­те изме­нить, и новое значение:

lset key_philosophy1 5 "sayeth"

Если вы попы­та­е­тесь доба­вить новый эле­мент к суще­ству­ю­ще­му клю­чу, кото­рый не содер­жит спи­сок, это при­ве­дет к кон­флик­ту типов дан­ных и вер­нет ошиб­ку. Напри­мер, сле­ду­ю­щая коман­да set созда­ет ключ, содер­жа­щий стро­ку (а не спи­сок), поэто­му попыт­ка доба­вить эле­мент спис­ка с помо­щью lpush закон­чит­ся ошибкой:

set key_philosophy3 "What is love?"
lpush key_philosophy3 "Baby don't hurt me"
(error) WRONGTYPE Operation against a key holding the wrong kind of value

Пре­об­ра­зо­вать клю­чи Redis из одно­го типа дан­ных в дру­гой невоз­мож­но. То есть, что­бы пре­вра­тить key_philosophy3 в спи­сок, вам необ­хо­ди­мо уда­лить этот ключ и создать его сно­ва с помо­щью коман­ды lpush или rpush.

Извлечение элементов из списка

Что­бы полу­чить диа­па­зон эле­мен­тов в спис­ке, исполь­зуй­те коман­ду lrange, за кото­рой ука­жи­те началь­ное и конеч­ное сме­ще­ние. Каж­дое сме­ще­ние – это индекс с нуле­вой базой, то есть 0 явля­ет­ся пер­вым эле­мен­том в спис­ке, далее идет 1, 2 и т.д.

Сле­ду­ю­щая коман­да вер­нет все эле­мен­ты из наше­го при­ме­ра – спис­ка, создан­но­го в преды­ду­щем разделе:

lrange key_philosophy1 0 7
1) "I"
2) "think"
3) "therefore"
4) "I"
5) "am"
6) "sayeth"
7) "Rene"
8) "Decartes"

Сме­ще­ния, пере­да­ва­е­мые в lrange, так­же могут быть выра­же­ны отри­ца­тель­ны­ми чис­ла­ми. В этом слу­чае -1 пред­став­ля­ет послед­ний эле­мент в спис­ке, -2 – вто­рой в эле­мент и т.д. В сле­ду­ю­щем при­ме­ре коман­да воз­вра­ща­ет послед­ние три эле­мен­та спис­ка, хра­ня­щи­е­ся в key_philosophy1:

lrange key_philosophy1 -3 -1
1) "I"
2) "am"
3) "sayeth"

Что­бы извлечь из спис­ка отдель­ный эле­мент, вы може­те исполь­зо­вать коман­ду lindex. Одна­ко эта коман­да тре­бу­ет, что­бы вы ука­за­ли индекс эле­мен­та в каче­стве аргу­мен­та. Как и в слу­чае с lrange, индек­са­ция начи­на­ет­ся с нуля, что озна­ча­ет, что пер­вый эле­мент име­ет индекс 0, вто­рой – индекс 1 и т. д.

lindex key_philosophy1 4
"am"

Что­бы узнать, сколь­ко эле­мен­тов содер­жит­ся в дан­ном спис­ке, исполь­зуй­те коман­ду llen, кото­рая озна­ча­ет «list length»:

llen key_philosophy1
(integer) 8

Если зна­че­ние, хра­ня­ще­е­ся в задан­ном клю­че, не суще­ству­ет, llen вер­нет ошибку.

Удаление элементов из списка

Коман­да lrem уда­ля­ет пер­вое из опре­де­лен­но­го чис­ла вхож­де­ний, соот­вет­ству­ю­щих дан­но­му зна­че­нию. Что­бы попро­бо­вать пора­бо­тать с этим, создай­те сле­ду­ю­щий список:

rpush key_Bond "Never" "Say" "Never" "Again" "You" "Only" "Live" "Twice" "Live" "and" "Let" "Die" "Tomorrow" "Never" "Dies"

Сле­ду­ю­щая коман­да lrem уда­лит пер­вое вхож­де­ние зна­че­ния “Live”:

lrem key_Bond 1 "Live"

Эта коман­да выве­дет коли­че­ство эле­мен­тов, уда­лен­ных из списка:

(integer) 1

Коман­де lrem так­же мож­но пере­да­вать отри­ца­тель­ные чис­ла. В сле­ду­ю­щем при­ме­ре коман­да уда­лит два послед­них вхож­де­ния зна­че­ния “Never”:

lrem key_Bond -2 "Never"
(integer) 2

Коман­да lpop уда­ля­ет и воз­вра­ща­ет пер­вый – или «самый левый» – эле­мент из списка:

lpop key_Bond
"Never"

Что­бы уда­лить и вер­нуть послед­ний («самый пра­вый») эле­мент спис­ка, исполь­зуй­те rpop:

rpop key_Bond
"Dies"

Redis так­же вклю­ча­ет коман­ду rpoplpush, кото­рая уда­ля­ет послед­ний эле­мент из спис­ка и поме­ща­ет его в нача­ло дру­го­го списка:

rpoplpush key_Bond key_AfterToday
"Tomorrow"

Если исход­ный и целе­вой ключ, пере­дан­ные коман­де rpoplpush, сов­па­да­ют, они по сути роти­ру­ют эле­мен­ты в списке.

 

6.Управление строками

Создание строк

Клю­чи, содер­жа­щие стро­ки, могут содер­жать толь­ко одно зна­че­ние; нель­зя хра­нить более одной стро­ки в одном клю­че. Одна­ко стро­ки в Redis явля­ют­ся бинар­но-без­опас­ны­ми – то есть стро­ка Redis может содер­жать любые дан­ные, от бук­вен­но-циф­ро­вых сим­во­лов до изоб­ра­же­ний JPEG. Един­ствен­ное огра­ни­че­ние – дли­на стро­ки, она не долж­на пре­вы­шать 512 МБ.

Что­бы создать стро­ку, исполь­зуй­те коман­ду set. Напри­мер, сле­ду­ю­щая коман­да set созда­ет ключ key_Welcome1, кото­рый содер­жит стро­ку «Howdy»:

set key_Welcome1 "Howdy"
OK

Что­бы создать несколь­ко строк в одной коман­де, исполь­зуй­те mset:

mset key_Welcome2 "there" key_Welcome3 "partners,"

Так­же для созда­ния строк вы може­те исполь­зо­вать коман­ду append:

append key_Welcome4 "welcome to Texas"

Если стро­ка была созда­на успеш­но, append выве­дет целое чис­ло, рав­ное коли­че­ству сим­во­лов в строке:

(integer) 16

Обра­ти­те вни­ма­ние: коман­ду append так­же мож­но исполь­зо­вать для изме­не­ния содер­жи­мо­го строк. Подроб­нее мы пого­во­рим об этом чуть позже.

Извлечение строк

Что­бы извлечь стро­ку, исполь­зуй­те коман­ду get.

get key_Welcome1
"Howdy"

Что­бы извлечь несколь­ко строк, исполь­зуй­те mget:

mget key_Welcome1 key_Welcome2 key_Welcome3 key_Welcome4
1) "Howdy"
2) "there"
3) "partners,"
4) "welcome to Texas"

Если какой-либо из задан­ных клю­чей не содер­жит стро­ко­вое зна­че­ние или не суще­ству­ет, коман­да mget вер­нет nil.

Управление строками

Если стро­ка состо­ит из цело­го чис­ла, вы може­те запу­стить коман­ду incr, что­бы уве­ли­чить ее зна­че­ние на единицу:

set key_1 3
incr key_1
(integer) 4

Ана­ло­гич­ным обра­зом коман­ду incrby мож­но исполь­зо­вать, что­бы уве­ли­чить чис­ло­вое зна­че­ние стро­ки на опре­де­лен­ный шаг:

incrby key_1 16
(integer) 20

Коман­ды decr и decrby рабо­та­ют точ­но так же, толь­ко они умень­ша­ют целое чис­ло, хра­ня­ще­е­ся в чис­ло­вой строке:

decr key_1
(integer) 19
decrby key_1 16
(integer) 3

Если бук­вен­ная стро­ка уже суще­ству­ет, append доба­вит зна­че­ние в конец суще­ству­ю­ще­го зна­че­ния и вер­нет новую дли­ну стро­ки. К при­ме­ру, сле­ду­ю­щая коман­да добав­ля­ет «, y’all» к стро­ке, содер­жа­щей­ся в клю­че key_Welcome4, поэто­му теперь стро­ка будет выгля­деть так: “welcome to Texas, y’all”.

append key_Welcome4 ", y'all"
(integer) 15

Вы так­же може­те вста­вить целые чис­ла в стро­ку, содер­жа­щую чис­ло­вое зна­че­ние. В сле­ду­ю­щем при­ме­ре 45 встав­ля­ет­ся в конец зна­че­ния 3 (это целое чис­ло содер­жит­ся в key_1), поэто­му в резуль­та­те полу­чит­ся 345. В этом слу­чае append так­же воз­вра­тит новую дли­ну стро­ки, а не ее значение:

append key_1 45
(integer) 3

Посколь­ку этот ключ по-преж­не­му содер­жит толь­ко чис­ло­вое зна­че­ние, вы може­те выпол­нять над ним опе­ра­ции incr и decr. Вы так­же може­те доба­вить к цело­чис­лен­ной стро­ке бук­вен­ные сим­во­лы, но в таком слу­чае выпол­не­ние incr и decr для этой стро­ки при­ве­дет к ошиб­ке, посколь­ку ее зна­че­ние боль­ше не явля­ет­ся целым числом.

 

7.Подключение к базе redis

Подключение к Redis

Если вы рабо­та­е­те с локаль­ной уста­нов­кой redis-server, вы може­те под­клю­чить­ся к экзем­пля­ру Redis с помо­щью коман­ды redis-cli:

redis-cli

Это пере­ве­дет вас в интер­ак­тив­ный режим redis-cli, кото­рый предо­став­ля­ет REPL (read-eval-print loop), где вы може­те запус­кать встро­ен­ные коман­ды Redis и полу­чать ответы.

В интер­ак­тив­ном режи­ме пре­фикс команд­ной стро­ки изме­нит­ся: теперь в нем ука­зы­ва­ет­ся соеди­не­ние с локаль­ным экзем­пля­ром Redis (127.0.0.1) и порт Redis по умол­ча­нию (6379).

127.0.0.1:6379˃

Аль­тер­на­ти­вой интер­ак­тив­но­му режи­му Redis явля­ет­ся запуск команд в каче­стве  аргу­мен­тов коман­ды redis-cli. Дела­ет­ся это так:

redis-cli redis_command

Если вы хоти­те под­клю­чить­ся к уда­лен­но­му хра­ни­ли­щу дан­ных Redis, вы може­те ука­зать хосты и номе­ра пор­тов с помо­щью фла­гов -h и -p. Если вы настро­и­ли аутен­ти­фи­ка­цию Redis, вы може­те вклю­чить флаг -a и ука­зать ваш пароль:

redis-cli -h host -p port_number -a password

Если вы уста­но­ви­ли пароль Redis, кли­ен­ты смо­гут под­клю­чать­ся к базе дан­ных, даже если они не вклю­чат флаг -a в свою коман­ду redis-cli. Одна­ко они не смо­гут добав­лять, изме­нять или запра­ши­вать дан­ные до тех пор, пока не прой­дут аутен­ти­фи­ка­цию. Что­бы прой­ти аутен­ти­фи­ка­цию после под­клю­че­ния, исполь­зуй­те коман­ду auth и ука­жи­те пароль:

auth password

Если пароль, пере­дан­ный в коман­де auth, дей­стви­те­лен, коман­да вер­нет OK. В про­тив­ном слу­чае она вер­нет ошибку.

Если вы рабо­та­е­те с управ­ля­е­мой базой дан­ных Redis, ваш облач­ный про­вай­дер может предо­ста­вить вам URI, начи­на­ю­щий­ся с redis:// или rediss://, кото­рый вы може­те исполь­зо­вать для досту­па к ваше­му хра­ни­ли­щу дан­ных. Если стро­ка под­клю­че­ния начи­на­ет­ся с redis://, вы може­те вклю­чить ее в каче­стве аргу­мен­та в redis-cli.

Одна­ко если стро­ка под­клю­че­ния начи­на­ет­ся с rediss://, то вашей управ­ля­е­мой базе дан­ных тре­бу­ют­ся соеди­не­ния по TLS/SSL. Коман­да redis-cli не под­дер­жи­ва­ет соеди­не­ния TLS, поэто­му для соеди­не­ния по URI вам нуж­но исполь­зо­вать дру­гой инстру­мент с под­держ­кой это­го про­то­ко­ла – напри­мер, Redli.

Исполь­зуй­те сле­ду­ю­щий син­так­сис для под­клю­че­ния к базе дан­ных с помо­щью Redli. Обра­ти­те вни­ма­ние, этот при­мер вклю­ча­ет опцию –tls, кото­рая ука­зы­ва­ет, что соеди­не­ние долж­но быть уста­нов­ле­но через TLS, и флаг -u, кото­рый объ­яв­ля­ет, что сле­ду­ю­щий аргу­мент содер­жит URI соединения:

redli --tls -u rediss://connection_URI

Если вы попы­та­е­тесь под­клю­чить­ся к несу­ще­ству­ю­ще­му экзем­пля­ру, redis-cli перей­дет в отклю­чен­ный режим. Команд­ная стро­ка будет отра­жать это:

not connected˃

В этом режи­ме Redis будет пытать­ся вос­ста­но­вить соеди­не­ние при каж­дом новом запус­ке команды.

Тестирование соединений

Коман­да ping поз­во­ля­ет про­ве­рить рабо­то­спо­соб­ность соеди­не­ния с базой дан­ных. Обра­ти­те вни­ма­ние: это внут­рен­няя коман­да Redis, а не сете­вая ути­ли­та ping. Но рабо­та­ют эти две коман­ды оди­на­ко­во – обе они исполь­зу­ют­ся для про­вер­ки соеди­не­ния меж­ду дву­мя машинами.

Если соеди­не­ние уста­нов­ле­но, а коман­да ping запу­ще­на без аргу­мен­тов, она вер­нет PONG:

ping
PONG

Если вы предо­ста­ви­те коман­де аргу­мент, она вер­нет этот аргу­мент вме­сто PONG, если соеди­не­ние установлено:

ping "hello Redis!"
"hello Redis!"

Если вы запу­сти­те ping или любую дру­гую коман­ду в отклю­чен­ном режи­ме, вы уви­ди­те подоб­ный вывод:

ping
Could not connect to Redis at host:port: Connection refused

Обра­ти­те вни­ма­ние, ping так­же исполь­зу­ет­ся в Redis для изме­ре­ния задержки.

Отключение от Redis

Что­бы отклю­чить­ся от экзем­пля­ра Redis, исполь­зуй­те коман­ду quit:

quit

Коман­да exit так­же завер­шит соединение:

exit

Обе эти коман­ды закры­ва­ют соеди­не­ние, но толь­ко после того, как все ожи­да­ю­щие отве­ты будут запи­са­ны на клиентах.

 

8.Управление базами данных Redis

Экзем­пляр Redis «из короб­ки» под­дер­жи­ва­ет 16 логи­че­ских баз дан­ных. Эти базы дан­ных фак­ти­че­ски отде­ле­ны друг от дру­га – то есть, когда вы запус­ка­е­те коман­ду в одной базе дан­ных, это не вли­я­ет на дан­ные, хра­ня­щи­е­ся в дру­гих базах это­го экзем­пля­ра Redis.

Базы дан­ных Redis про­ну­ме­ро­ва­ны от 0 до 15. По умол­ча­нию при под­клю­че­нии к экзем­пля­ру Redis вы попа­да­е­те в базу дан­ных 0. Конеч­но, вы може­те изме­нить базу дан­ных, это дела­ет­ся после под­клю­че­ния с помо­щью коман­ды select:

select 15

Если вы выбра­ли дру­гую базу дан­ных вме­сто 0, она будет отра­же­на в пре­фик­се стро­ки redis-cli в квад­рат­ных скобках:

127.0.0.1:6379[15]˃

Что­бы заме­нить все дан­ные, хра­ня­щи­е­ся в одной базе дан­ных, на дан­ные, хра­ня­щи­е­ся в дру­гой, исполь­зуй­те коман­ду swapdb. В сле­ду­ю­щем при­ме­ре дан­ные, хра­ня­щи­е­ся в бд 6, будут заме­не­ны дан­ны­ми из бд 8, и все кли­ен­ты, под­клю­чен­ные к любой из этих баз, смо­гут сра­зу же уви­деть изменения:

swapdb 6 8

swapdb вер­нет OK, если заме­на про­шла успешно.

Если вы хоти­те пере­ме­стить ключ в дру­гой экзем­пляр Redis, вы може­те запу­стить коман­ду migrate. Эта коман­да про­ве­ря­ет ключ на целе­вом экзем­пля­ре, а затем уда­ля­ет его с исход­но­го экзем­пля­ра. При запус­ке коман­да migrate долж­на вклю­чать сле­ду­ю­щие эле­мен­ты в сле­ду­ю­щем порядке:

• Имя хоста или IP-адрес целе­вой базы данных
• Номер пор­та целе­вой базы данных
• Ключ, кото­рый вы хоти­те перенести
• Номер базы дан­ных, в кото­рой нуж­но сохра­нить ключ на целе­вом экземпляре
• Интер­вал вре­ме­ни в мил­ли­се­кун­дах, кото­рый опре­де­ля­ет мак­си­маль­ное вре­мя про­стоя меж­ду дву­мя маши­на­ми. Обра­ти­те вни­ма­ние: это не огра­ни­че­ние опе­ра­ции по вре­ме­ни (про­сто опе­ра­ция долж­на все­гда обес­пе­чи­вать опре­де­лен­ный уро­вень про­грес­са в тече­ние опре­де­лен­но­го пери­о­да времени).

Напри­мер:

migrate 203.0.113.0 6379 key_1 7 8000

Так­же коман­да migrate под­дер­жи­ва­ет несколь­ко опций, кото­рые мож­но ука­зать после послед­не­го аргумента:

• COPY: Ука­зы­ва­ет, что ключ нуж­но ско­пи­ро­вать и не нуж­но уда­лять с исход­но­го экземпляра.
• REPLACE: Если ключ уже суще­ству­ет в целе­вой БД, коман­да долж­на заме­нить его теку­щим ключом.
• KEYS: Вме­сто кон­крет­но­го клю­ча вы може­те вве­сти пустую стро­ку (“”), а затем исполь­зо­вать син­так­сис коман­ды keys – это поз­во­ля­ет пере­не­сти любой ключ, соот­вет­ству­ю­щий шаб­ло­ну. В буду­щих ману­а­лах  мы рас­смот­рим коман­ду keys подробнее.

Управление ключами

В Redis суще­ству­ет ряд команд для управ­ле­ния клю­ча­ми – они рабо­та­ют неза­ви­си­мо от того, какой тип дан­ных содер­жат клю­чи. Мы рас­смот­рим неко­то­рые из них.

Коман­да rename  пере­име­ну­ет ука­зан­ный ключ. Если опе­ра­ция выпол­не­на успеш­но, она вер­нет ОК:

rename old_key new_key

Вы може­те исполь­зо­вать коман­ду randomkey для воз­вра­та слу­чай­но­го клю­ча из теку­щей выбран­ной базы данных:

randomkey
"any_key"

Исполь­зуй­те коман­ду type, что­бы опре­де­лить, какой тип дан­ных содер­жит опре­де­лен­ный ключ. Вывод этой коман­ды может быть string, list, hash, set, zset, или stream:

type key_1
"string"

Если ука­зан­ный ключ не суще­ству­ет, type вер­нет none.

Вы може­те пере­ме­стить отдель­ный ключ в дру­гую базу дан­ных в вашем экзем­пля­ре Redis с помо­щью коман­ды move. Коман­да move при­ни­ма­ет в каче­стве аргу­мен­тов ключ и имя базы дан­ных, в кото­рую нуж­но пере­ме­стить ключ. Напри­мер, что­бы пере­ме­стить ключ key_1 в базу дан­ных 8, вы долж­ны выпол­нить сле­ду­ю­щую команду:

move key_1 8

Коман­да move вер­нет ОК, если пере­ме­ще­ние про­шло успешно.

Удаление ключей

Что­бы уда­лить один или несколь­ко клю­чей любо­го типа дан­ных, исполь­зуй­те коман­ду del, после кото­рой ука­жи­те один или несколь­ко клю­чей, кото­рые нуж­но удалить:

del key_1 key_2

Если уда­ле­ние клю­чей про­шло успеш­но, коман­да вер­нет (integer) 1. В про­тив­ном слу­чае она вер­нет (integer) 0.

Коман­да unlink выпол­ня­ет функ­цию, ана­ло­гич­ную del. Толь­ко del бло­ки­ру­ет кли­ен­та, пока сер­вер осво­бож­да­ет память, заня­тую клю­чом. Если уда­ля­е­мый ключ свя­зан с неболь­шим объ­ек­том, вре­мя, кото­рое del потре­бу­ет­ся для вос­ста­нов­ле­ния памя­ти, очень мало, и пото­му бло­ки­ров­ка прой­дет незаметно.

Одна­ко если уда­ля­е­мый ключ свя­зан со мно­ги­ми объ­ек­та­ми (напри­мер, если это хэш с тыся­ча­ми или мил­ли­о­на­ми полей), бло­ки­ров­ка будет неудоб­ной. Уда­ле­ние тако­го клю­ча может занять ощу­ти­мо мно­го вре­ме­ни, и вам будет запре­ще­но выпол­нять любые дру­гие опе­ра­ции, пока ключ не будет пол­но­стью уда­лен из памя­ти сервера.

Коман­да unlink сна­ча­ла оце­ни­ва­ет сто­и­мость осво­бож­де­ния памя­ти, зани­ма­е­мой клю­чом. Если объ­ем памя­ти малень­кий, то unlink рабо­та­ет так же, как del – вре­мен­но бло­ки­руя кли­ен­та. Одна­ко если сто­и­мость осво­бож­де­ния памя­ти клю­ча высо­ка, unlink уда­лит ключ асин­хрон­но, создав дру­гой поток и посте­пен­но вос­ста­нав­ли­вая память в фоно­вом режи­ме, не бло­ки­руя клиента:

unlink key_1

Посколь­ку коман­да unlink рабо­та­ет в фоно­вом режи­ме, для уда­ле­ния клю­чей с ваше­го сер­ве­ра обыч­но реко­мен­ду­ет­ся исполь­зо­вать имен­но ее: это поз­во­ля­ет умень­шить коли­че­ство оши­бок на кли­ен­тах (хотя del так­же будет хоро­шо рабо­тать во мно­гих случаях).

Важ­но! Сле­ду­ю­щие две коман­ды могут быть опас­ны. Коман­ды flushdb и flushall без­воз­врат­но уда­ля­ют все клю­чи в рам­ках одной базы дан­ных или во всех БД на сер­ве­ре Redis соот­вет­ствен­но. Мы реко­мен­ду­ем запус­кать эти коман­ды толь­ко в том слу­чае, если вы абсо­лют­но уве­ре­ны, что дей­стви­тель­но хоти­те сде­лать это.

В ваших инте­ре­сах пере­име­но­вать эти коман­ды – выбе­ри­те име­на, кото­рые вряд ли запу­сти­те слу­чай­но. В мануа­ле Уста­нов­ка и защи­та Redis в в Ubuntu 18.04 есть спе­ци­аль­ный раз­дел о пере­име­но­ва­нии команд.

Что­бы уда­лить все клю­чи в выбран­ной базе дан­ных, исполь­зуй­те коман­ду flushdb:

flushdb

Что­бы уда­лить все клю­чи в каж­дой базе дан­ных на сер­ве­ре Redis (вклю­чая выбран­ную в дан­ный момент базу), запу­сти­те flushall:

flushall

И flushdb, и flushall при­ни­ма­ют опцию async, кото­рая поз­во­ля­ет асин­хрон­но уда­лять клю­чи в кла­сте­ре. Это поз­во­ля­ет им функ­ци­о­ни­ро­вать ана­ло­гич­но коман­де unlink – они созда­ют новый поток для посте­пен­но­го осво­бож­де­ния памя­ти в фоно­вом режиме.

Резервное копирование базы данных Redis

Что­бы создать резерв­ную копию выбран­ной базы дан­ных, вы може­те исполь­зо­вать коман­ду save:

save

Это поз­во­ля­ет экс­пор­ти­ро­вать снап­шот теку­ще­го набо­ра дан­ных в виде фай­ла .rdb, кото­рый пред­став­ля­ет собой дамп базы дан­ных и хра­нит дан­ные во внут­рен­нем сжа­том фор­ма­те сериализации.

Коман­да save выпол­ня­ет­ся син­хрон­но и бло­ки­ру­ет все кли­ен­ты, под­клю­чен­ные к базе дан­ных. Сле­до­ва­тель­но, доку­мен­та­ция коман­ды save не реко­мен­ду­ет выпол­нять ее в про­из­вод­ствен­ной сре­де. Вме­сто это­го она пред­ла­га­ет исполь­зо­вать коман­ду bgsave. С ее помо­щью Redis созда­ет форк базы дан­ных: роди­тель­ский про­цесс будет про­дол­жать обслу­жи­вать кли­ен­тов, пока дочер­ний про­цесс сохра­ня­ет базу дан­ных, после чего коман­да пре­кра­ща­ет работу:

bgsave

Обра­ти­те вни­ма­ние: если кли­ен­ты добав­ля­ют или изме­ня­ют дан­ные во вре­мя выпол­не­ния опе­ра­ции bgsave, эти изме­не­ния не будут зафик­си­ро­ва­ны в снапшоте.

Вы може­те отре­дак­ти­ро­вать кон­фи­гу­ра­ци­он­ный файл Redis, что­бы Redis авто­ма­ти­че­ски сохра­нял снап­шот (этот режим назы­ва­ет­ся snapshotting или RDB) – это дела­ет­ся через опре­де­лен­ный интер­вал вре­ме­ни, если в базу дан­ных было вне­се­но мини­маль­ное коли­че­ство изме­не­ний (это назы­ва­ет­ся точ­ка сохра­не­ния). Сле­ду­ю­щие настрой­ки точ­ки сохра­не­ния вклю­че­ны в файл redis.conf по умолчанию:

. . .
save 900 1
save 300 10
save 60 10000
. . .
dbfilename "nextfile.rdb"
. . .

С эти­ми настрой­ка­ми Redis будет экс­пор­ти­ро­вать снап­шот базы дан­ных в файл, опре­де­лен­ный пара­мет­ром dbfilename, каж­дые 900 секунд при усло­вии, если будет изме­нен хотя бы 1 ключ; каж­дые 300 секунд, если будет изме­не­но как мини­мум 10 клю­чей; каж­дые 60 секунд, если будет изме­не­но 10000 ключей.

Вы може­те исполь­зо­вать коман­ду shutdown для резерв­но­го копи­ро­ва­ния ваших дан­ных Redis, после кото­ро­го соеди­не­ние будет закры­то. Эта коман­да забло­ки­ру­ет всех кли­ен­тов, под­клю­чен­ных к базе дан­ных, а затем выпол­нит опе­ра­цию сохра­не­ния, если настро­е­на хотя бы одна точ­ка сохра­не­ния. То есть она будет экс­пор­ти­ро­вать базу дан­ных в файл .rdb в ее теку­щем состо­я­нии, не поз­во­ляя кли­ен­там вно­сить какие-либо изменения.

Кро­ме того, коман­да shutdown сбра­сы­ва­ет изме­не­ния в фай­ле толь­ко для запи­си перед выхо­дом, если вклю­чить ее в режи­ме append-only. Режим append-only file (AOF) вклю­ча­ет в себя созда­ние лога каж­дой опе­ра­ции запи­си на сер­ве­ре в фай­ле .aof после каж­до­го снап­шо­та. Режи­мы AOF и RDB мож­но вклю­чить на одном сер­ве­ре одно­вре­мен­но. Исполь­зо­ва­ние этих двух мето­дов сохра­не­ния явля­ет­ся эффек­тив­ным спо­со­бом резерв­но­го копи­ро­ва­ния ваших данных.

Коман­да shutdown по сути явля­ет­ся бло­ки­ру­ю­щей коман­дой save, кото­рая так­же сбра­сы­ва­ет все послед­ние изме­не­ния в файл толь­ко для запи­си и закры­ва­ет соеди­не­ние с экзем­пля­ром Redis:

shutdown

Важ­но! Коман­да shutdown счи­та­ет­ся опас­ной. Бло­ки­руя кли­ен­тов сер­ве­ра Redis, вы може­те сде­лать свои дан­ные недо­ступ­ны­ми для поль­зо­ва­те­лей и при­ло­же­ний, кото­рые зави­сят от них. Мы реко­мен­ду­ем вам запус­кать эту коман­ду толь­ко в том слу­чае, если вы тести­ру­е­те пове­де­ние Redis или вы абсо­лют­но уве­ре­ны, что хоти­те забло­ки­ро­вать все кли­ен­ты ваше­го сер­ве­ра Redis.

Опять же, в ваших инте­ре­сах пере­име­но­вать эту команду.

Если вы не настро­и­ли ни одной точ­ки сохра­не­ния, но по-преж­не­му хоти­те, что­бы Redis выпол­нял опе­ра­ции сохра­не­ния, добавь­те пара­метр save в коман­ду shutdown:

shutdown save

Если вы настро­и­ли хотя бы одну точ­ку сохра­не­ния, но хоти­те выклю­чить сер­вер Redis, ниче­го не сохра­няя, вы може­те доба­вить в коман­ду аргу­мент nosave:

shutdown nosave

Обра­ти­те вни­ма­ние: файл толь­ко для запи­си может со вре­ме­нем стать очень длин­ным, но вы може­те настро­ить Redis для пере­за­пи­си фай­ла на осно­ве опре­де­лен­ных пере­мен­ных. Для это­го нуж­но отре­дак­ти­ро­вать файл redis.conf. Вы так­же може­те пере­пи­сать файл толь­ко для запи­си, выпол­нив коман­ду bgrewriteaof:

:
bgrewriteaof

Эта коман­да создаст крат­чай­ший набор команд, необ­хо­ди­мых для воз­вра­та базы дан­ных в ее теку­щее состо­я­ние. Она будет рабо­тать в фоно­вом режи­ме. Одна­ко если в фоно­вом режи­ме уже выпол­ня­ет­ся дру­гая коман­да, Redis смо­жет выпол­нить bgrewriteaof толь­ко после того, как эта коман­да завер­шит работу.