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

13 min de leitura  ·  Guia técnico

Para otimizar o cache Redis para aplicações PHP no Ubuntu 22.04, instale e configure o Redis, ajuste parâmetros de memória e persistência, e implemente conexões persistentes no PHP. Isso maximiza a performance e reduz a latência em aplicações web.

1. Instalar Redis e extensão PHP Redis
2. Configurar parâmetros de memória no redis.conf
3. Ajustar políticas de expiração de cache
4. Implementar conexão persistente no PHP
5. Configurar monitoramento de performance
6. Testar e validar otimizações

Pré-requisitos

• Ubuntu 22.04 LTS com acesso root ou sudo
• PHP 8.1 ou superior instalado
• Mínimo 1GB de RAM disponível
• Conhecimento básico de linha de comando Linux
• Aplicação PHP já em funcionamento

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

A instalação do Redis no Ubuntu 22.04 é o primeiro passo para implementar cache eficiente. O Redis oferece estruturas de dados avançadas que superam soluções básicas de cache em arquivo.

Atualize o sistema e instale o Redis:

sudo apt update
sudo apt install redis-server php-redis -y

Verifique se o Redis 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 e inicie o serviço:

sudo systemctl enable redis-server
sudo systemctl start redis-server

Teste a conexão básica:

redis-cli ping

Output esperado:

PONG

Configuração avançada de memória e performance

A configuração de memória Redis determina diretamente a performance da aplicação. Parâmetros mal ajustados podem causar lentidão ou perda de dados críticos.

Edite o arquivo de configuração principal:

sudo nano /etc/redis/redis.conf

Configure o limite máximo de memória (ajuste conforme sua RAM):

# Para servidor com 4GB RAM, use 1GB para Redis
maxmemory 1gb

# Política quando memória estiver cheia
maxmemory-policy allkeys-lru

# Otimização de TCP
tcp-keepalive 300
timeout 300

Configure persistência para dados críticos:

# Snapshot automático
save 900 1
save 300 10
save 60 10000

# Compressão de dados
rdbcompression yes
rdbchecksum yes

Ajuste parâmetros de rede para melhor throughput:

# Bind apenas localhost para segurança
bind 127.0.0.1

# Porta padrão
port 6379

# Buffer de saída para clientes
client-output-buffer-limit normal 0 0 0

Reinicie o Redis para aplicar as configurações:

sudo systemctl restart redis-server

Implementação de cache PHP com Redis

A integração PHP Redis requer configuração adequada de conexões e estratégias de cache. Conexões mal configuradas podem gerar overhead desnecessário.

Verifique se a extensão PHP Redis está carregada:

php -m | grep redis

Output esperado:

redis

Crie um script de teste de conexão PHP:

sudo nano /var/www/html/redis_test.php

Adicione o código de teste:

<?php
try {
    $redis = new Redis();
    $redis->pconnect('127.0.0.1', 6379, 0, 'my_app_id');
    
    // Teste de escrita
    $redis->set('test_key', 'Hello Redis!', 300);
    
    // Teste de leitura
    $value = $redis->get('test_key');
    echo "Valor recuperado: " . $value . "\n";
    
    // Informações de conexão
    echo "Redis conectado: " . ($redis->ping() ? 'SIM' : 'NÃO') . "\n";
    echo "Versão Redis: " . $redis->info()['redis_version'] . "\n";
    
} catch (Exception $e) {
    echo "Erro: " . $e->getMessage() . "\n";
}
?>

Execute o teste:

php /var/www/html/redis_test.php

Output esperado:

Valor recuperado: Hello Redis!
Redis conectado: SIM
Versão Redis: 6.0.16

Configuração de conexão persistente

Implemente conexão persistente para reduzir overhead de conexão:

sudo nano /var/www/html/redis_config.php

Adicione a classe de configuração:

<?php
class RedisConfig {
    private static $instance = null;
    private $redis;
    
    private function __construct() {
        $this->redis = new Redis();
        $this->redis->pconnect('127.0.0.1', 6379, 0, 'app_cache');
        $this->redis->setOption(Redis::OPT_SERIALIZER, Redis::SERIALIZER_JSON);
        $this->redis->setOption(Redis::OPT_PREFIX, 'app:');
    }
    
    public static function getInstance() {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance->redis;
    }
}
?>

Estratégias de cache e otimização de queries

As estratégias de cache Redis devem ser escolhidas conforme o padrão de acesso aos dados. Cache inadequado pode consumir memória desnecessariamente sem ganhos de performance.

Implemente cache de consultas de banco de dados:

sudo nano /var/www/html/database_cache.php

Adicione funções de cache inteligente:

<?php
require_once 'redis_config.php';

class DatabaseCache {
    private $redis;
    private $defaultTTL = 3600; // 1 hora
    
    public function __construct() {
        $this->redis = RedisConfig::getInstance();
    }
    
    public function cacheQuery($sql, $params = [], $ttl = null) {
        $cacheKey = 'query:' . md5($sql . serialize($params));
        
        // Tenta buscar no cache primeiro
        $cached = $this->redis->get($cacheKey);
        if ($cached !== false) {
            return json_decode($cached, true);
        }
        
        // Se não existe, executa query e armazena
        $result = $this->executeQuery($sql, $params);
        $this->redis->setex($cacheKey, $ttl ?: $this->defaultTTL, json_encode($result));
        
        return $result;
    }
    
    public function invalidatePattern($pattern) {
        $keys = $this->redis->keys($pattern);
        if (!empty($keys)) {
            $this->redis->del($keys);
        }
    }
    
    private function executeQuery($sql, $params) {
        // Simula execução de query
        // Substitua pela sua conexão de banco real
        return ['data' => 'resultado_da_query'];
    }
}
?>

Configure cache de sessões PHP no Redis:

sudo nano /etc/php/8.1/apache2/conf.d/99-redis-session.ini

Adicione a configuração de sessão:

session.save_handler = redis
session.save_path = "tcp://127.0.0.1:6379"
session.gc_maxlifetime = 3600

Reinicie o Apache para aplicar:

sudo systemctl restart apache2

Cache de objetos e fragmentos HTML

Implemente cache de fragmentos para reduzir processamento:

sudo nano /var/www/html/fragment_cache.php

<?php
class FragmentCache {
    private $redis;
    
    public function __construct() {
        $this->redis = RedisConfig::getInstance();
    }
    
    public function start($key, $ttl = 3600) {
        $content = $this->redis->get("fragment:$key");
        if ($content !== false) {
            echo $content;
            return false; // Não precisa gerar conteúdo
        }
        
        ob_start();
        return true; // Precisa gerar conteúdo
    }
    
    public function end($key, $ttl = 3600) {
        $content = ob_get_contents();
        ob_end_clean();
        
        $this->redis->setex("fragment:$key", $ttl, $content);
        echo $content;
    }
}
?>

Monitoramento e análise de performance

O monitoramento Redis é essencial para identificar gargalos e otimizar configurações. Métricas inadequadas podem mascarar problemas de performance críticos.

Configure script de monitoramento básico:

sudo nano /usr/local/bin/redis_monitor.sh

#!/bin/bash

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

# Informações básicas
echo "--- Informações Gerais ---"
redis-cli info server | grep -E "redis_version|uptime_in_seconds|process_id"

# Uso de memória
echo -e "\n--- Uso de Memória ---"
redis-cli info memory | grep -E "used_memory_human|used_memory_peak_human|maxmemory_human"

# Estatísticas de conexão
echo -e "\n--- Conexões ---"
redis-cli info clients | grep -E "connected_clients|blocked_clients"

# Estatísticas de comandos
echo -e "\n--- Comandos (últimos 60s) ---"
redis-cli info stats | grep -E "total_commands_processed|instantaneous_ops_per_sec"

# Chaves por database
echo -e "\n--- Databases ---"
redis-cli info keyspace

# Latência
echo -e "\n--- Latência (últimos 10 pings) ---"
redis-cli --latency -i 1 -c 10

Torne o script executável:

sudo chmod +x /usr/local/bin/redis_monitor.sh

Execute o monitoramento:

/usr/local/bin/redis_monitor.sh

Configure monitoramento contínuo com cron:

sudo crontab -e

Adicione entrada para log de performance:

# Monitor Redis a cada 5 minutos
*/5 * * * * /usr/local/bin/redis_monitor.sh >> /var/log/redis_performance.log 2>&1

Análise de chaves grandes e otimização

Identifique chaves que consomem muita memória:

redis-cli --bigkeys

Output esperado:

# Scanning the entire keyspace to find biggest keys as well as
# average sizes per key type.  You can use -i 0.1 to sleep 0.1 sec
# per 100 SCAN commands (not usually needed).

[00.00%] Biggest string found so far 'app:user:1001' with 2048 bytes
[00.00%] Biggest hash   found so far 'app:session:abc123' with 15 fields

Analise padrões de acesso em tempo real:

redis-cli monitor

Atenção: O comando monitor impacta performance em produção. Use apenas para debugging pontual.

Problemas comuns e como resolver

Redis consumindo muita memória

Causa: Configuração inadequada de maxmemory ou chaves sem expiração.
Solução: Configure maxmemory no redis.conf e implemente TTL em todas as chaves. Use redis-cli --bigkeys para identificar chaves grandes e otimize-as.

Conexões PHP falhando intermitentemente

Causa: Limite de conexões Redis atingido ou timeout inadequado.
Solução: Aumente maxclients no redis.conf para 10000 e configure timeout para 300 segundos. Use conexões persistentes no PHP com pconnect().

Performance degradada após algumas horas

Causa: Fragmentação de memória ou política de expiração inadequada.
Solução: Configure maxmemory-policy como allkeys-lru e reinicie o Redis periodicamente. Monitore fragmentação com redis-cli info memory.

Dados perdidos após reinicialização

Causa: Persistência não configurada adequadamente.
Solução: Configure RDB snapshots no redis.conf com save 900 1 e verifique se o diretório de dados tem permissões corretas para o usuário redis.

Perguntas frequentes sobre otimizar cache Redis

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

Redis oferece estruturas de dados mais complexas (listas, sets, hashes) e persistência opcional, enquanto Memcached é mais simples e focado apenas em cache key-value. Redis é melhor para aplicações que precisam de cache estruturado e backup de dados.

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 redis-cli monitor para ver comandos em tempo real ou phpinfo() para confirmar a extensão Redis carregada.

Quanto de RAM devo alocar para o Redis?

Aloque entre 10-25% da RAM total do servidor para Redis, dependendo do volume de cache. Para sites pequenos, 256MB são suficientes. Sites com alto tráfego podem precisar de 1-4GB. Configure maxmemory no redis.conf para evitar consumo excessivo.

Redis perde dados quando o servidor reinicia?

Por padrão, Redis mantém dados apenas em memória e perde tudo ao reiniciar. Para persistir dados, configure RDB snapshots ou AOF (Append Only File) no redis.conf. Para cache puro, a perda de dados não é crítica pois será reconstruído.

Como monitorar performance do Redis em produção?

Use redis-cli info stats para métricas básicas, redis-cli --latency para latência em tempo real, e redis-cli --bigkeys para identificar chaves grandes. Configure logs no redis.conf e monitore uso de CPU/memória com htop ou ferramentas específicas.

Conclusão

• Configure maxmemory adequadamente para evitar consumo excessivo de RAM e implemente políticas de expiração inteligentes
• Use conexões persistentes PHP e monitore performance regularmente com redis-cli info para identificar gargalos
• Implemente estratégias de cache específicas para queries de banco e fragmentos HTML para maximizar ganhos de performance

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

Nossa equipe especializada pode configurar e otimizar 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