Otimizar cache Redis para aplicações PHP no Ubuntu 22.04

15 min de leitura  ·  Guia técnico

Otimizar cache Redis para aplicações PHP significa configurar o servidor Redis para maximizar a performance e reduzir o tempo de resposta das aplicações web. Para otimizar o Redis no Ubuntu 22.04, siga estes passos:

1. Instalar e configurar o Redis Server com parâmetros otimizados
2. Ajustar configurações de memória e persistência no redis.conf
3. Instalar e configurar a extensão PHP Redis
4. Implementar estratégias de cache eficientes no código PHP
5. Monitorar performance e ajustar configurações conforme necessário
6. Configurar backup e recuperação de dados em cache

Pré-requisitos

• Servidor Ubuntu 22.04 LTS com acesso root ou sudo
• PHP 8.1 ou superior instalado e configurado
• Mínimo de 1GB de RAM disponível para o Redis
• Aplicação PHP existente que se beneficiará do cache
• Conhecimento básico de linha de comando Linux

Instalação e configuração inicial do Redis Server

O primeiro passo para otimizar cache Redis é realizar uma instalação limpa e configurar os parâmetros básicos. O Redis no Ubuntu 22.04 pode ser instalado através dos repositórios oficiais, garantindo compatibilidade e estabilidade.

Atualize o sistema e instale o Redis:

sudo apt update && sudo apt upgrade -y
sudo apt install redis-server -y

Verifique se o serviço está ativo:

sudo systemctl status redis-server

Output esperado:

● redis-server.service - Advanced key-value store
     Loaded: loaded (/lib/systemd/system/redis-server.service; enabled; vendor preset: enabled)
     Active: active (running) since Mon 2024-01-15 10:30:45 UTC; 2min ago

Configure o Redis para iniciar automaticamente:

sudo systemctl enable redis-server

Teste a conectividade básica:

redis-cli ping

Se retornar "PONG", a instalação foi bem-sucedida. Agora configure a segurança básica editando o arquivo de configuração:

sudo nano /etc/redis/redis.conf

Localize e modifique as seguintes linhas para melhorar a segurança:

bind 127.0.0.1 ::1
requirepass sua_senha_segura_aqui

Reinicie o serviço para aplicar as alterações:

sudo systemctl restart redis-server

Otimização de configurações de memória Redis

A configuração adequada da memória é crucial para maximizar a performance do cache Redis. O arquivo redis.conf contém parâmetros específicos que determinam como o Redis gerencia a memória disponível.

Abra o arquivo de configuração:

sudo nano /etc/redis/redis.conf

Configure o limite máximo de memória. Para um servidor com 4GB de RAM, aloque 1GB para o Redis:

maxmemory 1gb

Defina a política de remoção quando o limite de memória for atingido:

maxmemory-policy allkeys-lru

Configure o número de databases. Para aplicações PHP típicas, 16 databases são suficientes:

databases 16

Otimize as configurações de TCP para melhor performance de rede:

tcp-keepalive 300
tcp-backlog 511
timeout 0

Para aplicações com muitas conexões simultâneas, aumente o limite:

maxclients 10000

Configure a persistência baseada nas necessidades da aplicação. Para cache puro sem necessidade de persistência:

save ""

Para aplicações que precisam de alguma persistência, configure snapshots:

save 900 1
save 300 10
save 60 10000

Aplique as configurações reiniciando o serviço:

sudo systemctl restart redis-server

Verifique se as configurações foram aplicadas:

redis-cli -a sua_senha_segura_aqui config get maxmemory

Instalação e configuração da extensão PHP Redis

Para que aplicações PHP possam se comunicar eficientemente com o Redis, é necessário instalar a extensão PHP Redis. Esta extensão oferece melhor performance comparada a clientes Redis implementados em PHP puro.

Instale as dependências necessárias:

sudo apt install php-dev php-pear build-essential -y

Instale a extensão Redis via PECL:

sudo pecl install redis

Durante a instalação, quando perguntado sobre igbinary e msgpack, responda "no" para manter a compatibilidade:

enable igbinary serializer support? [no] : no
enable lzf compression support? [no] : no
enable zstd compression support? [no] : no

Adicione a extensão ao arquivo de configuração do PHP:

echo "extension=redis.so" | sudo tee -a /etc/php/8.1/cli/php.ini
echo "extension=redis.so" | sudo tee -a /etc/php/8.1/apache2/php.ini

Para PHP-FPM, também adicione:

echo "extension=redis.so" | sudo tee -a /etc/php/8.1/fpm/php.ini

Reinicie os serviços web:

sudo systemctl restart apache2
sudo systemctl restart php8.1-fpm

Verifique se a extensão foi carregada corretamente:

php -m | grep redis

Output esperado:

redis

Teste a conectividade PHP com Redis criando um script de teste:

cat > /tmp/redis_test.php << 'EOF'
<?php
try {
    $redis = new Redis();
    $redis->connect('127.0.0.1', 6379);
    $redis->auth('sua_senha_segura_aqui');
    $redis->set('test_key', 'Hello Redis!');
    echo $redis->get('test_key') . "\n";
    $redis->close();
    echo "Conexão Redis funcionando corretamente!\n";
} catch (Exception $e) {
    echo "Erro: " . $e->getMessage() . "\n";
}
?>
EOF

Execute o teste:

php /tmp/redis_test.php

Implementação de estratégias de cache PHP otimizadas

Implementar estratégias de cache eficientes requer compreender os padrões de acesso aos dados da aplicação. O Redis oferece diferentes estruturas de dados que podem ser utilizadas para otimizar cenários específicos de cache.

Crie uma classe wrapper para gerenciar conexões Redis de forma eficiente:

cat > /tmp/RedisCache.php << 'EOF'
<?php
class RedisCache {
    private $redis;
    private $prefix;
    
    public function __construct($host = '127.0.0.1', $port = 6379, $password = null, $prefix = 'app:') {
        $this->redis = new Redis();
        $this->redis->connect($host, $port);
        if ($password) {
            $this->redis->auth($password);
        }
        $this->prefix = $prefix;
    }
    
    public function set($key, $value, $ttl = 3600) {
        return $this->redis->setex($this->prefix . $key, $ttl, serialize($value));
    }
    
    public function get($key) {
        $value = $this->redis->get($this->prefix . $key);
        return $value !== false ? unserialize($value) : false;
    }
    
    public function delete($key) {
        return $this->redis->del($this->prefix . $key);
    }
    
    public function exists($key) {
        return $this->redis->exists($this->prefix . $key);
    }
    
    public function flush() {
        return $this->redis->flushDB();
    }
    
    public function getStats() {
        return $this->redis->info('memory');
    }
}
?>
EOF

Implemente cache de consultas de banco de dados:

cat > /tmp/DatabaseCache.php << 'EOF'
<?php
require_once '/tmp/RedisCache.php';

class DatabaseCache {
    private $cache;
    private $pdo;
    
    public function __construct($pdo, $cache) {
        $this->pdo = $pdo;
        $this->cache = $cache;
    }
    
    public function query($sql, $params = [], $ttl = 1800) {
        $cacheKey = 'query:' . md5($sql . serialize($params));
        
        $result = $this->cache->get($cacheKey);
        if ($result !== false) {
            return $result;
        }
        
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute($params);
        $result = $stmt->fetchAll(PDO::FETCH_ASSOC);
        
        $this->cache->set($cacheKey, $result, $ttl);
        return $result;
    }
    
    public function invalidatePattern($pattern) {
        // Implementar invalidação por padrão se necessário
        $keys = $this->cache->keys('app:query:*' . $pattern . '*');
        foreach ($keys as $key) {
            $this->cache->delete(str_replace('app:', '', $key));
        }
    }
}
?>
EOF

Configure cache de sessões PHP para usar Redis editando o php.ini:

sudo nano /etc/php/8.1/apache2/php.ini

Adicione ou modifique as seguintes linhas:

session.save_handler = redis
session.save_path = "tcp://127.0.0.1:6379?auth=sua_senha_segura_aqui"

Para aplicações com alto volume de sessões, configure múltiplos servidores Redis:

session.save_path = "tcp://127.0.0.1:6379?auth=senha1,tcp://127.0.0.1:6380?auth=senha2"

Reinicie o Apache para aplicar as configurações:

sudo systemctl restart apache2

Monitoramento e ajuste de performance

O monitoramento contínuo do Redis é essencial para manter a performance otimizada. Utilize ferramentas nativas do Redis para acompanhar métricas importantes como uso de memória, hit rate e latência.

Crie um script de monitoramento básico:

cat > /tmp/redis_monitor.sh << 'EOF'
#!/bin/bash

REDIS_PASSWORD="sua_senha_segura_aqui"

echo "=== Redis Status Monitor ==="
echo "Data: $(date)"
echo

echo "=== Informações de Memória ==="
redis-cli -a $REDIS_PASSWORD info memory | grep -E "(used_memory_human|used_memory_peak_human|maxmemory_human)"
echo

echo "=== Estatísticas de Conexão ==="
redis-cli -a $REDIS_PASSWORD info clients | grep -E "(connected_clients|blocked_clients)"
echo

echo "=== Hit Rate ==="
redis-cli -a $REDIS_PASSWORD info stats | grep -E "(keyspace_hits|keyspace_misses)"
echo

echo "=== Comandos por Segundo ==="
redis-cli -a $REDIS_PASSWORD info stats | grep "instantaneous_ops_per_sec"
echo

echo "=== Número de Chaves por Database ==="
redis-cli -a $REDIS_PASSWORD info keyspace
EOF

Torne o script executável:

chmod +x /tmp/redis_monitor.sh

Execute o monitoramento:

/tmp/redis_monitor.sh

Para monitoramento em tempo real, use o comando monitor do Redis:

redis-cli -a sua_senha_segura_aqui monitor

Atenção: O comando monitor pode impactar a performance em produção. Use apenas para debugging.

Configure alertas automáticos criando um script de verificação:

cat > /tmp/redis_health_check.sh << 'EOF'
#!/bin/bash

REDIS_PASSWORD="sua_senha_segura_aqui"
MEMORY_THRESHOLD=80
EMAIL="[email protected]"

# Verifica uso de memória
MEMORY_USAGE=$(redis-cli -a $REDIS_PASSWORD info memory | grep used_memory_rss: | cut -d: -f2 | tr -d '\r')
MAX_MEMORY=$(redis-cli -a $REDIS_PASSWORD config get maxmemory | tail -1)

if [ "$MAX_MEMORY" != "0" ]; then
    USAGE_PERCENT=$((MEMORY_USAGE * 100 / MAX_MEMORY))
    if [ $USAGE_PERCENT -gt $MEMORY_THRESHOLD ]; then
        echo "ALERTA: Redis usando ${USAGE_PERCENT}% da memória" | mail -s "Redis Memory Alert" $EMAIL
    fi
fi

# Verifica conectividade
if ! redis-cli -a $REDIS_PASSWORD ping > /dev/null 2>&1; then
    echo "ALERTA: Redis não está respondendo" | mail -s "Redis Down Alert" $EMAIL
fi
EOF

Adicione o script ao crontab para execução a cada 5 minutos:

chmod +x /tmp/redis_health_check.sh
(crontab -l 2>/dev/null; echo "*/5 * * * * /tmp/redis_health_check.sh") | crontab -

Problemas comuns e como resolver

Redis consumindo muita memória

Causa: Configuração inadequada de maxmemory ou política de remoção ineficiente.
Solução: Ajuste o maxmemory para um valor apropriado e configure maxmemory-policy para allkeys-lru. Verifique se há chaves com TTL muito alto ou sem expiração.

Conexões PHP falhando intermitentemente

Causa: Limite de conexões simultâneas atingido ou timeout de conexão muito baixo.
Solução: Aumente o valor de maxclients no redis.conf e configure timeout adequado. Implemente pool de conexões na aplicação PHP para reutilizar conexões existentes.

Performance degradada após algumas horas

Causa: Fragmentação de memória ou acúmulo de chaves expiradas não removidas.
Solução: Configure activerehashing yes no redis.conf e ajuste hz para 100. Execute MEMORY PURGE periodicamente para desfragmentar a memória.

Perda de dados após reinicialização

Causa: Persistência desabilitada ou configuração inadequada de snapshots.
Solução: Configure save adequadamente ou habilite AOF com appendonly yes. Para dados críticos, use tanto RDB quanto AOF para redundância.

Alta latência em operações Redis

Causa: Operações bloqueantes ou configuração inadequada de rede.
Solução: Evite comandos KEYS em produção, use SCAN. Configure tcp-keepalive e verifique se não há swap ativo no sistema. Use redis-cli --latency para diagnosticar problemas de rede.

Perguntas frequentes sobre otimizar cache Redis

Qual a diferença entre Redis e Memcached para cache PHP?

Redis oferece estruturas de dados mais avançadas como listas e sets, persistência opcional e suporte a clustering. Memcached é mais simples e consome menos memória, mas oferece apenas cache chave-valor básico.

Como verificar se o Redis está funcionando corretamente?

Execute redis-cli ping no terminal. Se retornar PONG, o Redis está ativo. Para verificar conexões PHP, use phpinfo() e procure pela extensão redis ou execute um script de teste com new Redis().

Quanto de RAM devo alocar para o Redis?

Aloque entre 10-25% da RAM total do servidor para Redis. Para aplicações pequenas, 256MB são suficientes. Sites com alto tráfego podem precisar de 1-4GB, dependendo do volume de dados em cache.

O Redis pode causar perda de dados?

Por padrão, Redis mantém dados apenas em memória e pode perder informações em caso de reinicialização. Para dados críticos, configure persistência com RDB snapshots ou AOF logging, mas isso reduz a performance.

Como monitorar o uso de memória do Redis?

Use redis-cli info memory para ver estatísticas detalhadas. Monitore used_memory, used_memory_peak e maxmemory. Configure alertas quando o uso ultrapassar 80% do limite para evitar problemas de performance.

Conclusão

• Configure adequadamente os limites de memória e políticas de remoção para evitar problemas de performance
• Implemente monitoramento contínuo para identificar gargalos antes que afetem a aplicação
• Use estruturas de dados Redis apropriadas para cada caso de uso específico da aplicação

Leia também

• Otimizar cache Redis para aplicações PHP no Ubuntu 22.04
• Como otimizar PHP-FPM do zero em 20 minutos no Ubuntu 22.04
• Passo a passo para testar se o Redis está funcionando no Ubuntu 24.04

Precisa de ajuda com otimização de cache Redis?

Nossa equipe especializada pode configurar e otimizar o Redis em seu servidor VPS, garantindo máxima performance para suas aplicações PHP. Oferecemos suporte técnico completo e monitoramento proativo.

Conheça nossos planos de VPS otimizados