El componente Symfony Cache es a menudo la herramienta más poco utilizada en el arsenal de un desarrollador.La mayoría de las implementaciones se detienen en “instalar Redis” y envuelven algunas llamadas de base de datos en una Si bien es funcional, esto apenas arranca la superficie de lo que el componente puede hacer en entornos distribuidos de alto rendimiento. $cache->get() En Symfony 7.3, el componente de caché no es sólo un almacén de valor clave; es un sistema sofisticado capaz de arquitectura nivelada, protección de estampilla probabilística y cifrado transparente. Este artículo explora estrategias importantes de caché que resuelven costosos problemas arquitectónicos: , de (El rebaño de los rebaños), (en el ), y . latency concurrency security GDPR distributed invalidation La arquitectura de la latencia: Caching nivelado (Chain) En las arquitecturas de microservicios o monolitos de alto tráfico, una llamada de red a Redis (típicamente 1–3ms) puede eventualmente convertirse en una barrera en comparación con la memoria local (nanosegundos). La solución es a actuar de manera efectiva como un Cache para su aplicación. , de . Chain Cache L1/L2 CPU L1 is local (APCu) L2 is shared (Redis) La configuración Configuraremos un pool que lea desde APCu primero. Si se pierde, lee desde Redis, luego popula APCu. composer require symfony/cache symfony/orm-pack redis
 Configuración ( ) de : config/packages/cache.yaml framework:
    cache:
        # Prefix all keys to avoid collisions in shared Redis instances
        prefix_seed: '%env(APP_SECRET)%'

        pools:
            # L2 Cache: Redis (Shared)
            cache.redis:
                adapter: cache.adapter.redis
                provider: 'redis://%env(REDIS_HOST)%:6379'
                default_lifetime: 3600 # 1 hour

            # L1 Cache: APCu (Local Memory)
            cache.apcu:
                adapter: cache.adapter.apcu
                default_lifetime: 60 # Short TTL to prevent stale local data

            # The Chain: L1 + L2
            cache.layered:
                adapter: cache.adapter.chain
                provider: [cache.apcu, cache.redis]
 Uso Injecte el pool específico utilizando el atributo Target. namespace App\Service;

use Symfony\Component\DependencyInjection\Attribute\Target;
use Symfony\Contracts\Cache\CacheInterface;
use Symfony\Contracts\Cache\ItemInterface;

class DashboardService
{
    public function __construct(
        #[Target('cache.layered')]
        private readonly CacheInterface $cache
    ) {}

    public function getStats(): array
    {
        // 1. Checks APCu. Hit? Return.
        // 2. Miss? Checks Redis. Hit? Populate APCu & Return.
        // 3. Miss? Run Callback. Populate Redis & APCu.
        return $this->cache->get('stats_v1', function (ItemInterface $item): array {
            $item->expiresAfter(3600);
            return $this->computeHeavyStats();
        });
    }
    
    private function computeHeavyStats(): array 
    { 
        // Simulation of heavy work
        return ['users' => 10500, 'revenue' => 50000]; 
    }
}
 Verificación 
 
 
 
 
 
 Caché limpio: bin/console cache:pool:clear cache.layered Solicite la página Verifique Redis (CLI): KEYS * (Verá la clave). Verifique APCu (Panel Web): Verá la clave. Desconectar Redis. La aplicación continuará sirviendo desde APCu durante 60 segundos. Solucionar el rebaño de tormentas: expiración temprana probabilística El “Cache Stampede” (o Thundering Herd) ocurre cuando una clave de caché caliente expira. De repente, 1.000 solicitudes simultáneas pierden la caché simultáneamente y golpean su base de datos para calcular el mismo valor. Sinfonía resuelve esto mecanismos de bloqueo complejos (como Semaphore) mediante el uso de . without Probabilistic Early Expiration Cómo funciona En lugar de expirar exactamente a las 12:00, la caché afirma estar vacía ligeramente antes de la expiración, pero sólo para algunas solicitudes.Cuanto más cerca de la expiración, mayor es la probabilidad de una falta. La implementación No necesitas una nueva configuración; necesitas utilizar el Parámetros del contrato. $beta // $beta of 1.0 is standard. 
// Higher = recompute earlier. 
// 0 = disable. 
// INF = force recompute.
$beta = 1.0; 

$value = $this->cache->get('stock_ticker_aapl', function (ItemInterface $item) {
    // The item ACTUALLY expires in 1 hour
    $item->expiresAfter(3600);
    
    return $this->stockApi->fetchPrice('AAPL');
}, $beta);
 Verificación matemática No hay un comando CLI para "probar" la probabilidad, pero puede registrar las recomputaciones. 
 
 
 
 Establezca $item->expiresAfter(10). Cree un loop que golpee esta clave de caché cada 100ms. Tenga en cuenta que la llamada de retorno se activa antes de que pasen 10 segundos y generalmente sólo una vez, asegurándose de que su backend esté protegido. La “caixa negra”: encriptación transparente con sodio Caché (PII) en Redis es una Si un atacante descarta su memoria Redis, tiene los datos. Personal Identifiable Information GDPR/security risk Symfony le permite envolver su adaptador de caché en un Nosotros utilizaremos el para cifrar transparentemente los datos antes de que salgan de PHP y descifrarlos al recuperarlos. Marshaller SodiumMarshaller asegurar es La extensión es En PHP 8.x libsodium installed enabled Configuración Necesitamos decorar el mariscal predeterminado. usaremos un “ “Marshaller (para comprimir datos) envuelto dentro de un “ “Marshaller (para cifrarlo) Deflate Sodium #config/services.yaml

services:
    # 1. Generate a key: php -r "echo bin2hex(random_bytes(SODIUM_CRYPTO_SECRETBOX_KEYBYTES));"
    # Store this in .env.local: CACHE_DECRYPTION_KEY=your_hex_key
    
    # 2. Define the Marshaller Service
    app.cache.marshaller.secure:
        class: Symfony\Component\Cache\Marshaller\SodiumMarshaller
        arguments: 
            - ['%env(hex2bin:CACHE_DECRYPTION_KEY)%']
            - '@app.cache.marshaller.deflate' # Chain encryption OVER compression

    app.cache.marshaller.deflate:
        class: Symfony\Component\Cache\Marshaller\DeflateMarshaller
        arguments: ['@default_marshaller']
        
    default_marshaller:
        class: Symfony\Component\Cache\Marshaller\DefaultMarshaller

    # 3. Use the custom marshaller in your cache adapter
    Symfony\Component\Cache\Adapter\RedisAdapter:
        arguments:
            $marshaller: '@app.cache.marshaller.secure'
 #config/packages/cache.yaml

framework:
    cache:
        pools:
            cache.secure:
                adapter: cache.adapter.redis
                # We need to point the 'default_marshaller' of this pool to our secure one?
                # Actually, defining the adapter service globally as we did above 
                # is the cleanest way if you want ALL redis caches encrypted.
                # Alternatively, use the provider syntax:
                
                # For specific pool encryption, we often have to define the service manually 
                # or use a factory because framework.yaml config is limited for complex DI.
 Enfoque refinado para la sinfonía (Mejor Práctica): En lugar de superar el adaptador global, define el servicio de la piscina explícitamente para inyectar el marshaller. # config/services.yaml
services:
    app.cache.secure_pool:
        class: Symfony\Component\Cache\Adapter\RedisAdapter
        arguments:
            $redis: 'redis://%env(REDIS_HOST)%:6379'
            $marshaller: '@app.cache.marshaller.secure'
        tags: ['cache.pool']
 Uso public function storeUserAddress(int $userId, string $address): void
{
    // This data is compressed and encrypted in Redis
    $cacheItem = $this->securePool->getItem('user_addr_' . $userId);
    $cacheItem->set($address);
    $this->securePool->save($cacheItem);
}
 Verificación 
 
 
 
 
 
 Guardar los datos en la caché. Conectarse a Redis a través de CLI: redis-cli. Tome la llave. Resultado: Verá la basura binaria (la cadena cifrada), no la dirección de texto simple. Recuperarlo a través de PHP: Obtén la dirección de texto simple. Invalidación distribuida: Tags & Messenger El problema más difícil en la ciencia de la computación es la invalidación de la caché. Se vuelve más difícil cuando tienes 5 servidores web (pods). Si Server A actualiza un producto, la caché APCu de Server B todavía mantiene el producto antiguo. Resolvemos esto transmitiendo mensajes de invalidación a través de Symfony Messenger. La estrategia 
 
 
 
 
 Escribe a Redis (Compartido) Cache localmente en APCu (para velocidad). Cuando los datos cambien, envíe un mensaje al autobús. Todos los servidores consumen el mensaje y limpian su APCu local para esa etiqueta específica. Configuración composer require symfony/messenger
 Necesitamos un transporte que soporte “Pub/Sub” (Fanout), para que cada servidor reciba el mensaje. #config/packages/messenger.yaml

framework:
    messenger:
        transports:
            # Use a fanout exchange so ALL pods receive the message
            cache_invalidation: 
                dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
                options:
                    exchange:
                        type: fanout
                        name: cache_invalidation_fanout
 El Código 1. The Invalidation Message namespace App\Message;

final readonly class InvalidateTagsMessage
{
    public function __construct(
        public array $tags
    ) {}
}
 2. The Handler This handler runs on every server. namespace App\MessageHandler;

use App\Message\InvalidateTagsMessage;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;
use Symfony\Contracts\Cache\TagAwareCacheInterface;
use Symfony\Component\DependencyInjection\Attribute\Target;

#[AsMessageHandler]
final readonly class InvalidateTagsHandler
{
    public function __construct(
        #[Target('cache.layered')] // Target our Chain Cache
        private TagAwareCacheInterface $cache
    ) {}

    public function __invoke(InvalidateTagsMessage $message): void
    {
        // This invalidates the local APCu layer AND the shared Redis layer
        $this->cache->invalidateTags($message->tags);
    }
}
 3. The Service Triggering the Change namespace App\Service;

use App\Message\InvalidateTagsMessage;
use Symfony\Component\Messenger\MessageBusInterface;
use Symfony\Contracts\Cache\TagAwareCacheInterface;

class ProductService
{
    public function __construct(
        private TagAwareCacheInterface $cache,
        private MessageBusInterface $bus
    ) {}

    public function updateProduct(int $id, array $data): void
    {
        // 1. Update Database...
        
        // 2. Invalidate
        // We do NOT call $cache->invalidateTags() directly here.
        // Because that would only clear THIS server's APCu and the shared Redis.
        // Other servers would remain stale.
        
        $this->bus->dispatch(new InvalidateTagsMessage(["product_{$id}"]));
    }
}
 El atributo #[Cacheable] En lugar de escribir en cada método de servicio, vamos a crear un que manejan el cache automáticamente utilizando el o . $cache->get() PHP 8 Attribute Decorator Pattern Event Subscription A continuación se muestra una implementación limpia utilizando un escuchador, que es eficiente y fácil de razonar. Kernel::CONTROLLER_ARGUMENTS The Attribute namespace App\Attribute;

use Attribute;

#[Attribute(Attribute::TARGET_METHOD)]
final readonly class Cacheable
{
    public function __construct(
        public string $pool = 'cache.app',
        public int $ttl = 3600,
        public ?string $key = null
    ) {}
}
 Suscriptor del evento Este escuchador intercepta las llamadas del controlador, verifica el atributo y intenta servir desde la caché. Esta implementación simple asume que el controlador devuelve una respuesta serializable genérica (como JSON o un Array). namespace App\EventSubscriber;

use App\Attribute\Cacheable;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpKernel\Event\ControllerEvent;
use Symfony\Component\HttpKernel\KernelEvents;
use Symfony\Component\DependencyInjection\ServiceLocator;
use Symfony\Contracts\Cache\ItemInterface;

class CacheableSubscriber implements EventSubscriberInterface
{
    public function __construct(
        private ServiceLocator $cachePools // Inject locator to find pools dynamically
    ) {}

    public static function getSubscribedEvents(): array
    {
        return [
            // High priority to catch request before execution
            KernelEvents::CONTROLLER => ['onKernelController', 10], 
        ];
    }

    public function onKernelController(ControllerEvent $event): void
    {
        $controller = $event->getController();

        // Handle array callables [$object, 'method']
        if (is_array($controller)) {
            $method = new \ReflectionMethod($controller[0], $controller[1]);
        } elseif (is_object($controller) && is_callable($controller)) {
            $method = new \ReflectionMethod($controller, '__invoke');
        } else {
            return;
        }

        $attributes = $method->getAttributes(Cacheable::class);
        if (empty($attributes)) {
            return;
        }

        /** @var Cacheable $cacheable */
        $cacheable = $attributes[0]->newInstance();

        if (!$this->cachePools->has($cacheable->pool)) {
            return;
        }

        $pool = $this->cachePools->get($cacheable->pool);
        
        // Generate a key based on Controller Class + Method + Request Params
        // This is a simplified key generation strategy
        $request = $event->getRequest();
        $cacheKey = $cacheable->key ?? 'ctrl_' . md5($request->getUri());

        // We cannot easily "skip" the controller execution inside a Listener 
        // using the Cache Contract pattern nicely without replacing the controller.
        // 
        // For a TRULY robust attribute implementation, one should use 
        // a "Service Decorator" logic, but for Controllers, we can replace the 
        // controller callable with a closure that wraps the cache logic.
        
        $originalController = $event->getController();
        
        $newController = function() use ($pool, $cacheKey, $cacheable, $originalController, $request) {
            return $pool->get($cacheKey, function (ItemInterface $item) use ($cacheable, $originalController, $request) {
                $item->expiresAfter($cacheable->ttl);
                
                // Execute the original controller
                // Note: We need to manually resolve arguments or pass the request
                // This part is tricky in raw PHP. 
                // In Symfony we can simply execute the original callable 
                // IF we have the resolved arguments.
                
                // SIMPLIFICATION for article:
                // Assuming controller takes Request object or no args
                return $originalController($request);
            });
        };

        $event->setController($newController);
    }
}
 Usted tiene que tu caché polacos en a Para el Acceso a ellos de forma dinámica. register ServiceLocator Subscriber El código anterior muestra la modificación de la Idealmente, para los servicios, usted usaría en la definición de servicio, pero para Controladores, interceptar el evento es la forma de la Sinfonía. Kernel execution flow #[AsDecorator] Conclusión Implementación es fácil; arquitectar una estrategia de caché que sobreviva a las particiones de red, Auditorías y El espionaje es una disciplina. CacheInterface GDPR Black Friday traffic Las estrategias descritas aquí - En cuanto a la latencia, En cuanto a la competencia, Para la seguridad, y para la coherencia – mover su aplicación lejos de las optimizaciones frágiles y hacia la ingeniería robusta. Symfony proporciona estos primitivos fuera de la caja, lo que nos permite resolver problemas complejos de sistema distribuido sin introducir una infraestructura pesada de terceros. Chain Caching Probabilistic Expiration Sodium Encryption Messenger-based Invalidation Deja de tratar tu caché como un terreno de dumping temporal.Tratalo como una capa crítica y segura de tu estrategia de persistencia de datos. Continuaremos la discusión Si está refaccionando un monolito legado o diseñando un sistema distribuido en Symfony, me encantaría saber sobre los desafíos que se enfrentan. ¿Has implementado un Marshaller personalizado para necesidades específicas de cumplimiento? ¿Cómo gestiona la invalidación de la caché en las implementaciones multi-regionales? Contacta conmigo directamente en LinkedIn.Vamos a hablar de arquitectura, compartir historias de guerra y construir un software mejor.

Read My Stories

Este audio es producido en el idioma original de la historia!

Estrategias de caché importantes: Cómo crear caché resiliente en Symfony

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Telegram: el puente de Crypto Island hacia el continente

¿Quieres ganar un concurso de redacción de HackerNoon? Esto es lo que recomiendan los ganadores del concurso #crypto-api

Creación de productos criptográficos centrados en el usuario: la importancia de los comentarios de los clientes

De los foros a los feeds: cómo los algoritmos de las redes sociales influyen en la interacción digital

Telegram: el puente de Crypto Island hacia el continente

¿Quieres ganar un concurso de redacción de HackerNoon? Esto es lo que recomiendan los ganadores del concurso #crypto-api

Creación de productos criptográficos centrados en el usuario: la importancia de los comentarios de los clientes

De los foros a los feeds: cómo los algoritmos de las redes sociales influyen en la interacción digital

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps