El lanzamiento de Symfony 7.4 marca un momento crucial para los desarrolladores de PHP, especialmente aquellos de nosotros que arquitectan aplicaciones nativas de nube de alto rendimiento.Mientras que el changelog está lleno de la serie habitual de mejoras de la experiencia del desarrollador (DX) y ajustes de rendimiento, una característica se destaca como un cambiador de juego para los equipos de infraestructura y los backend leads igualmente: el . Share Directory Durante años, hemos luchado con el “Dilema del caché” en entornos multi-servidor.Hemos escrito scripts hackeados, gestionado montajes complejos de NFS y aceptado sanciones de rendimiento, todo para mantener sincronizado el estado de nuestra aplicación.Con Symfony 7.4, el equipo central ha abordado finalmente este punto de fricción arquitectónico. En este artículo vamos a explorar el nuevo el directorio, entender el problema crítico que resuelve e implementar una configuración robusta y listo para la producción utilizando Symfony 7.4, Doctrine y Flysystem. var/share El “dilema del caché”: una historia de las carencias de rendimiento Para apreciar la elegancia del Share Directory, primero debemos revisitar el dolor del pasado. El directorio ha sido históricamente el terreno de dumping para dos tipos de datos muy diferentes: var/cache 
 
 
 Cache del sistema: Esto incluye el contenedor de servicio compilado, las rutas de correspondencia de URL, las plantillas optimizadas de Twig y los mapas de clase. Estos datos son inmutables (o deberían ser) después de la fase de cache:warmup. Cache de aplicaciones: Esto incluye su cache.app pool, respuestas de API, objetos serializados y almacenamiento de archivos potencialmente temporales. Estos datos son volátiles y compartidos. Si el servidor A cache una consulta de base de datos pesada, el servidor B debe ser capaz de leerla. El problema en un clúster Imagina que estás desplegando una aplicación Symfony en un clúster de Kubernetes con 10 pods. 
 
 
 Escenario A (Cache local):Tienes var/cache local para cada pod.Resultado: El Cache del sistema es rápido (SSD local). Sin embargo, el Cache de la aplicación está fragmentado.Si un usuario llega al Pod 1, sus datos se cachegan allí.Si su próxima solicitud llega al Pod 2, el cache se pierde y la base de datos se pierde de nuevo. Escenario B (Shared Storage):Usted monta var/cache a un volumen compartido (NFS, EFS).Resultado: El Cache de la aplicación es consistente en todos los pods. Excelente! Pero ahora, cada vez que Symfony necesita cargar una clase o comprobar una ruta (System Cache), tiene que cruzar la red para leer desde el almacenamiento compartido. Esto introduce una latencia I/O significativa, a menudo ralentizando los tiempos de respuesta en 10-20% simplemente debido a la sobrecarga del sistema de archivos. Estábamos dispuestos a elegir entre y . consistency performance Introduzca el directorio de compartir (var/share) Symfony 7.4 introduce un concepto arquitectónico dedicado para resolver esto: . Share Directory Esta característica desconecta formalmente la ubicación de los archivos específicos del sistema de los archivos compartidos por la aplicación. 
 
 
 var/cache: sigue siendo el hogar para la caché del sistema. Debe permanecer local al servidor (almacenamiento ephemeral en términos de K8). No requiere sincronización. var/share: La nueva casa de datos de aplicaciones. Este directorio está diseñado para ser montado en almacenamiento compartido (como NFS, AWS EFS, o un volumen persistente). Esta separación nos permite tener lo mejor de ambos mundos: cajas de sistema locales rápidas y un estado de aplicación compartido y consistente. Guía de Implementación Vamos a construir una aplicación Symfony 7.4 que aproveche el Share Directory para tres casos de uso comunes: 
 
 
 
 Cache de aplicaciones compartidas Almacenamiento de archivos compartidos (Upload) Base de datos compartida de SQLite (para el estado simple) Requisitos y instalación Asegúrese de que está ejecutando PHP 8.2 o superior y tenga el CLI de Symfony instalado. symfony new my_app --webapp
cd my_app
composer require symfony/framework-bundle:^7.4
 Configuración básica En una nueva instalación de Symfony 7.4, el marco ya es consciente de este concepto. Usted verá una nueva variable de entorno: .env # .env
APP_SHARE_DIR=$APP_PROJECT_DIR/var/share
 Bajo el hoyo, el La clase ahora aplica a Si está actualizando una aplicación existente, es posible que necesite añadirla manualmente o confiar en el fallback predeterminado (que apunta al directorio de caché para la compatibilidad retroactiva). Kernel getShareDir() Para aplicar esta estructura en una aplicación actualizada, actualice su si es necesario, o simplemente definir la variable ambiental. Kernel.php Configuración de piscinas de cache compartidas La ganancia más inmediata es mover la caché de su aplicación al directorio compartido. Por defecto, el adaptador de caché del sistema de archivos de Symfony se salva a Queremos trasladar esto a . var/cache/pools var/share/pools abierta Configuraremos la caché de la aplicación predeterminada para usar la nueva Los parámetros. config/packages/cache.yaml %kernel.share_dir% # config/packages/cache.yaml
framework:
    cache:
        # distinct_id helps avoid collisions if multiple apps share the same storage
        prefix_seed: 'my_app_%env(APP_ENV)%'

        # Default app cache
        app: cache.adapter.filesystem

        # System cache (stays in var/cache, FAST!)
        system: cache.adapter.system 

        # Configure filesystem adapter to use the share directory
        default_redis_provider: 'redis://localhost'
        
        pools:
            # We explicitly tell the 'cache.app' pool to use the share directory
            cache.app:
                adapter: cache.adapter.filesystem
                provider: ~
                # The 'directory' option is available for the filesystem adapter
                # We use the new container parameter
                default_lifetime: 3600
                provider: 'cache.default_marshaller' 
                
services:
    # We need to configure the specific directory for the filesystem adapter
    # Since we can't easily pass the directory in the simplified YAML above for the main adapter,
    # we can define a custom adapter or rely on the global default if Symfony 7.4 automates it.
    
    # However, for explicit control, let's define a shared pool:
    cache.adapter.shared_filesystem:
        parent: 'cache.adapter.filesystem'
        tags: ['cache.pool']
        arguments:
            $directory: '%kernel.share_dir%/pools'

framework:
    cache:
        app: cache.adapter.shared_filesystem
 En Symfony 7.4 estándar, el adaptador de sistema de archivos predeterminado todavía puede Creando explícitamente un servicio apuntando a , nos aseguramos de que nuestra caché de aplicación se almacene en el lugar correcto. cache_dir cache.adapter.shared_filesystem %kernel.share_dir%/pools Para comprobar esto, limpia tu caché y calienta. php bin/console cache:clear
php bin/console cache:pool:clear cache.app
 Luego, genera algunas entradas de caché (por ejemplo, visitando una página). ls -la var/share/pools
 Debe ver una estructura de carpetas creada por el adaptador de caché. Almacenamiento de archivos compartido con Flysystem El manejo de las cargas de usuario en un clúster es un caso de uso clásico para el almacenamiento compartido. Para mapear un adaptador de almacenamiento . league/flysystem-bundle var/share/storage Installation: composer require league/flysystem-bundle
 abierta . Configuration: config/packages/flysystem.yaml # config/packages/flysystem.yaml
flysystem:
    storages:
        default.storage:
            adapter: 'local'
            options:
                # Use the new kernel parameter
                directory: '%kernel.share_dir%/storage'
 Ahora, vamos a crear un servicio para manejar las cargas de archivos usando este almacenamiento. Injecciones de dependencia. PHP 8 Attributes namespace App\Service;

use League\Flysystem\FilesystemOperator;
use Symfony\Component\DependencyInjection\Attribute\Target;
use Symfony\Component\HttpFoundation\File\UploadedFile;

class FileManager
{
    public function __construct(
        #[Target('default.storage')]
        private readonly FilesystemOperator $storage
    ) {}

    public function uploadUserFile(UploadedFile $file, string $userId): string
    {
        $filename = sprintf('%s/%s.%s', $userId, uniqid(), $file->guessExtension());

        $stream = fopen($file->getPathname(), 'r');
        
        // Write to var/share/storage/...
        $this->storage->writeStream($filename, $stream);

        if (is_resource($stream)) {
            fclose($stream);
        }

        return $filename;
    }
    
    public function getFileContent(string $filename): string
    {
        return $this->storage->read($filename);
    }
}
 Cuando despliegue esto en Kubernetes, montará una reclamación de volumen persistente (PVC) en Si Pod A carga un archivo, se escribe al PVC. Pod B puede leer ese archivo inmediatamente a través del mismo camino, porque comparten el volumen de almacenamiento subyacente. /app/var/share Base de datos compartida de SQLite (el clúster “Lite”) Si bien generalmente no se recomienda para escritos simultáneos pesados, el uso de SQLite en es un patrón fantástico para datos de lectura pesada, de baja escritura o simples dashboards de herramientas internas que necesitan persistir en las implementaciones sin una configuración completa de MySQL / PostgreSQL. var/share abierta . Configuration: config/packages/doctrine.yaml doctrine:
    dbal:
        # Use the standard SQLite driver
        driver: 'pdo_sqlite'
        # Point the path to the share directory
        path: '%kernel.share_dir%/db/app.sqlite'
        charset: UTF8
 Asegúrese de que el directorio existe: mkdir -p var/share/db
 Ahora, cuando se ejecutan las migraciones: php bin/console doctrine:migrations:migrate
 El El archivo se crea en el directorio compartido. Todos los servidores de su clúster leerán de este archivo único. .sqlite Asegúrese de que su solución de almacenamiento compartido soporte el bloqueo de archivos correctamente (por ejemplo, AWS EFS con opciones de montaje adecuadas), o reserve esto para escenarios con una frecuencia de escritura muy baja. Warning: DevOps: Estrategia de implementación Para aprovechar plenamente esta característica, su implementación se manifiesta (por ejemplo, Los cubernetes ) Necesita ser actualizado. docker-compose.yml deployment.yaml Docker compone ejemplos Aquí está cómo simular el entorno de producción localmente. services:
  app_1:
    build: .
    environment:
      APP_SHARE_DIR: /app/var/share
    volumes:
      - shared_data:/app/var/share

  app_2:
    build: .
    environment:
      APP_SHARE_DIR: /app/var/share
    volumes:
      - shared_data:/app/var/share

volumes:
  shared_data:
 En este establecimiento: 
 
 
 La caché del sistema (var/cache) se encuentra dentro del contenedor (rápido, aislado). Los datos compartidos (var/share) son un volumen nombrado compartido entre app_1 y app_2. La estrategia de Kubernetes (K8s) En Kubernetes, usaría un PersistentVolumeClaim. apiVersion: apps/v1
kind: Deployment
metadata:
  name: symfony-app
spec:
  replicas: 3
  template:
    spec:
      containers:
        - name: php
          image: my-symfony-app:7.4
          env:
            - name: APP_SHARE_DIR
              value: "/var/www/html/var/share"
          volumeMounts:
            - mountPath: "/var/www/html/var/share"
              name: shared-storage
      volumes:
        - name: shared-storage
          persistentVolumeClaim:
            claimName: efs-pvc
 Verification: 
 
 
 
 
 
 Exec en Pod 1: kubectl exec -it symfony-app-pod-1 — bash Crear un archivo: toque var/share/test.txt Exec en Pod 2: kubectl exec -it symfony-app-pod-2 — bash Archivo de la etiqueta: ls var/share/ Usted debe ver test.txt. Guía de migración: actualización a 7.4 Si está manteniendo una aplicación heredada, la adopción de Share Directory requiere unos pasos cuidadosos. 
 
 
 
 
 Actualizar Composer: Actualizar composer.json para permitir Symfony/*: 7.4. Actualización .env: Agregue APP_SHARE_DIR a su .env y .env.test. Actualización .gitignore: generalmente no desea comprometer el contenido del directorio de compartir, pero es posible que desee mantener el gitkeep. Pautas de refactor: Busque su base de código para encontrar referencias de código duro a kernel.cache_dir o var/cache. Si el código usaba el directorio de caché para almacenar datos que deberían persistir o ser compartidos (como informes PDF generados, exportaciones temporales), cambie el código para usar %kernel.share_dir%. Conclusión Sinfonía 7.4 Es más que una nueva estructura de carpetas; es una señal de madurez. Reconoce que las aplicaciones PHP modernas viven en la nube, a través de clusters y necesitan escalar horizontalmente sin luchar contra el marco. Share Directory Por la adopción Simplifica la configuración de tu infraestructura, mejora el rendimiento de tus cachés del sistema y proporciona una ubicación clara y estandarizada para el estado de tu aplicación. var/share Comience actualizando un microservicio no crítico a Symfony 7.4 hoy mismo. Descargue el directorio, elimine esos complejos montos de NFS para su caché del sistema y vea caer su tiempo de respuesta promedio. Ready to scale? var/share ¿Te ayudó este artículo a aclarar tu camino de actualización?Sígueme en [LinkedIn: Vamos a construir un software mejor, juntos. Keep in touch! https://www.linkedin.com/in/matthew-mochalkin/ https://www.linkedin.com/in/matthew-mochalkin/

This story contains AI-generated text. The author has used AI either for research, to generate outlines, or write the text itself. 

Read My Stories

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

Share Directory de Symfony 7.4 resuelve el problema de caché para las aplicaciones de Kubernetes

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Aumente su productividad con estas 18 herramientas para desarrolladores 🚀🔥

Liberando el poder de la IA. Una revisión sistemática de técnicas de vanguardia: resumen e introducción

Valhalla de Floki se une como patrocinador asociado de la gira de la India por Sri Lanka

Una breve introducción a la teoría del cerebro de Boltzmann

Aumente su productividad con estas 18 herramientas para desarrolladores 🚀🔥

Liberando el poder de la IA. Una revisión sistemática de técnicas de vanguardia: resumen e introducción

Valhalla de Floki se une como patrocinador asociado de la gira de la India por Sri Lanka

Una breve introducción a la teoría del cerebro de Boltzmann

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps