Configurando o Redis no Webfaction

Introdução

Devido às restrições especiais de ambiente dos servidores Webfaction, as instruções de instalação não são tão diretas quanto seriam. No entanto, no final, você terá um servidor Redis totalmente funcional que permanece ativo mesmo após uma reinicialização. Eu pessoalmente instalei o Redis pelo seguinte procedimento há cerca de meio ano e ele está funcionando perfeitamente desde então. Uma pequena palavra de aviso, porém, meio ano não é muito tempo, especialmente porque o servidor não esteve sob uso pesado.

As instruções consistem em cinco partes:Instalação, Teste, Inicialização do Servidor, Gerenciamento do Servidor e Manutenção do Servidor em Execução.

Instalação

Faça login no seu shell da Webfaction

ssh [email protected]

Baixe o Redis mais recente do site de download do Redis.

> mkdir -p ~/src/
> cd ~/src/
> wget http://download.redis.io/releases/redis-2.6.16.tar.gz
> tar -xzf redis-2.6.16.tar.gz
> cd redis-2.6.16/

Antes da make, veja se seu servidor é Linux 32 ou 64 bits. O script de instalação não lida bem com ambientes de 32 bits, pelo menos nas máquinas CentOS 5 da Webfaction. O comando para bits é uname -m . Se o Linux for de 32 bits, o resultado será i686, se for de 64 bits, então x86_64. Veja esta resposta para detalhes.

> uname -m
i686

Se o seu servidor for de 64 bits (x86_64), basta fazer.

> make

Mas se o seu servidor é de 32 bits (i686), você deve fazer algumas coisas extras. Existe um comando make 32bit mas produz um erro. Edite uma linha no script de instalação para fazer make 32bit trabalhar.

> nano ~/src/redis-2.6.16/src/Makefile

Altere a linha 214 deste

$(MAKE) CFLAGS="-m32" LDFLAGS="-m32"

para isso

$(MAKE) CFLAGS="-m32 -march=i686" LDFLAGS="-m32 -march=i686"

e salve. Em seguida, execute o make com o sinalizador de 32 bits.

> cd ~/src/redis-2.6.16/  ## Note the dir, no trailing src/
> make 32bit

Os executáveis foram criados no diretório ~/src/redis-2.6.16/src/ . Os executáveis incluem redis-cli , redis-server , redis-benchmark e redis-sentinel .

Teste (opcional)

Como a saída da instalação sugere, seria bom garantir que tudo funcione conforme o esperado executando testes.

Hint: To run 'make test' is a good idea ;)

Infelizmente, o teste requer a instalação do tlc8.6.0, que não é o padrão, pelo menos na máquina web223. Portanto, você deve instalá-lo primeiro, a partir da fonte. Consulte as notas de instalação e notas de compilação do Tcl/Tk.

> cd ~/src/
> wget http://prdownloads.sourceforge.net/tcl/tcl8.6.0-src.tar.gz
> tar -xzf tcl8.6.0-src.tar.gz
> cd tcl8.6.0-src/unix/
> ./configure --prefix=$HOME
> make
> make test # Optional, see notes below
> make install

Testando Tcl com make test levará tempo e também falhará devido às restrições de ambiente do WebFaction. Eu sugiro que você pule isso.

Agora que temos o Tlc instalado, podemos executar os testes do Redis. Os testes levarão muito tempo e também usarão temporariamente uma quantidade bastante grande de memória.

> cd ~/src/redis-2.6.16/
> make test

Após os testes, você está pronto para continuar.

Iniciando o servidor

Primeiro, crie um aplicativo personalizado via Webfaction Control Panel (aplicativo personalizado (ouvindo na porta)). Nomeie-o, por exemplo, fooredis . Observe que você não precisa criar um domínio ou site para o aplicativo se o Redis for usado apenas localmente, ou seja, do mesmo host.

Segundo, anote o número da porta do soquete que foi fornecido para o aplicativo. Seja o exemplo 23015 .

Copie os executáveis compilados anteriormente para o diretório do aplicativo. Você pode optar por copiar todos ou apenas os que você precisa.

> cd ~/webapps/fooredis/
> cp ~/src/redis-2.6.16/src/redis-server .
> cp ~/src/redis-2.6.16/src/redis-cli .

Copie também o arquivo de configuração de amostra. Em breve você vai modificar isso.

> cp ~/src/redis-2.6.16/redis.conf .

Agora o Redis já é executável. Há problemas de casal embora. Primeiro, a porta padrão do Redis 6379 pode já estar em uso. Segundo, mesmo que a porta estivesse livre, sim, você poderia iniciar o servidor, mas ele pararia de executar no mesmo momento em que você sair do shell. Para o primeiro o redis.conf deve ser editado e para o segundo, você precisa de um daemon que também é resolvido editando o redis.conf.

O Redis é capaz de executar sozinho no modo daemon. Para isso você precisa configurar um local onde o daemon armazena seus ids de processo, PIDs. Normalmente, os pidfiles são armazenados em /var/run/, mas devido às restrições do ambiente, você deve selecionar um local para eles em seu diretório inicial. Por uma razão explicada posteriormente na parte Gerenciando o Servidor, uma boa opção é colocar o pidfile no mesmo diretório dos executáveis. Você não precisa criar o arquivo sozinho, o Redis o cria automaticamente para você.

Agora abra o redis.conf para edição.

> cd ~/webapps/fooredis/
> nano redis.conf

Altere as configurações da seguinte maneira.

daemonize no -> daemonize yes
pidfile /var/run/redis.pid -> pidfile /home/foouser/webapps/fooredis/redis.pid
port 6379 -> port 23015

Agora, finalmente, inicie o servidor Redis. Especifique o arquivo conf para que o Redis escute a porta correta e execute como um daemon.

> cd ~/webapps/fooredis/
> ./redis-server redis.conf
>

Veja funcionando.

> cd ~/webapps/fooredis/
> ./redis-cli -p 23015
redis 127.0.0.1:23015> SET myfeeling Phew.
OK
redis 127.0.0.1:23015> GET myfeeling
"Phew."
redis 127.0.0.1:23015> (ctrl-d)
>

Pare o servidor se desejar.

> ps -u $USER -o pid,command | grep redis
  718 grep redis
10735 ./redis-server redis.conf
> kill 10735

> cat redis.pid | xargs kill

Gerenciando o servidor

Para facilitar o uso e como trabalho preparatório para a próxima parte, faça um script que ajude a abrir o cliente e iniciar, reiniciar e parar o servidor. Uma solução fácil é escrever um makefile. Ao escrever um makefile, lembre-se de usar tabulações em vez de espaços.

> cd ~/webapps/fooredis/
> nano Makefile

# Redis Makefile
client cli:
    ./redis-cli -p 23015

start restart:
    ./redis-server redis.conf

stop:
    cat redis.pid | xargs kill

As regras são bastante autoexplicativas. O especial sobre a segunda regra é que, enquanto estiver no modo daemon, chamar o ./redis-server não cria um novo processo se já houver um em execução.

A terceira regra contém alguma sabedoria silenciosa. Se redis.pid não fosse armazenado no diretório fooredis, mas por exemplo em /var/run/redis.pid, não seria tão fácil parar o servidor. Isso é especialmente verdadeiro se você executar várias instâncias do Redis simultaneamente.

Para executar uma regra:

> make start

Mantendo o servidor funcionando

Agora você tem uma instância do Redis em execução no modo daemon que permite encerrar o shell sem pará-lo. Isso ainda não é suficiente. E se o processo travar? E se a máquina do servidor for reinicializada? Para cobrir isso, você precisa criar dois cronjobs.

> export EDITOR=nano
> crontab -e

Adicione as duas linhas a seguir e salve.

*/5 * * * * make -C ~/webapps/fooredis/ -f ~/webapps/fooredis/Makefile start
@reboot make -C ~/webapps/fooredis/ -f ~/webapps/fooredis/Makefile start

O primeiro garante a cada cinco minutos que o fooredis está em execução. Como dito acima, isso não inicia um novo processo se um já estiver em execução. A segunda garante que fooredis seja iniciado imediatamente após a reinicialização da máquina servidora e muito antes da primeira regra entrar em ação.

Alguns métodos mais delicados para isso podem ser usados, por exemplo, para sempre. Veja também este tópico da Comunidade da Webfaction para saber mais sobre o tópico.

Conclusão

Agora você tem. Muitas coisas feitas, mas talvez mais venham. Coisas que você pode gostar de fazer no futuro que não foram abordadas aqui incluem o seguinte.

Definindo uma senha, evitando que outros usuários liberem seus bancos de dados. (Veja redis.conf)
Limitando o uso de memória (consulte redis.conf)
Registrando o uso e os erros (consulte redis.conf)
Fazer backup dos dados de vez em quando.

Alguma ideia, comentário ou correção?