DEV Community

Cover image for Scaling Symfony 7.4 in the Cloud: Mastering the New “Share Directory”
Matt Mochalkin
Matt Mochalkin

Posted on

Scaling Symfony 7.4 in the Cloud: Mastering the New “Share Directory”

#symfony #php #cloud #architecture

The release of Symfony 7.4 marks a pivotal moment for PHP developers, particularly those of us architecting high-performance, cloud-native applications. While the changelog is packed with the usual array of developer experience (DX) improvements and performance tweaks, one feature stands out as a game-changer for infrastructure teams and backend leads alike: the Share Directory.

For years, we’ve wrestled with the “Cache Dilemma” in multi-server environments. We’ve written hacky scripts, managed complex NFS mounts and accepted performance penalties — all to keep our application state synchronized. With Symfony 7.4, the core team has finally addressed this architectural friction point head-on.

In this artice, we will explore the new var/share directory, understand the critical problem it solves and implement a robust, production-ready configuration using Symfony 7.4, Doctrine and Flysystem.

The “Cache Dilemma”: A History of Performance Bottlenecks

To appreciate the elegance of the Share Directory, we must first revisit the pain of the past. In a standard Symfony application, the var/cache directory has historically been the dumping ground for two very different types of data:

  1. System Cache: This includes the compiled service container, URL matching routes, optimized Twig templates and class maps. This data is immutable (or should be) after the cache:warmup phase. It is specific to the version of the code currently running.
  2. Application Cache: This includes your cache.app pool, API responses, serialized objects and potentially temporary file storage. This data is volatile and shared. If Server A caches a heavy database query, Server B should be able to read it.

The Problem in a Cluster

Imagine you are deploying a Symfony app to a Kubernetes cluster with 10 pods.

  1. Scenario A (Local Cache): You keep var/cache local to each pod. Result: The System Cache is fast (local SSD). However, the Application Cache is fragmented. If a user hits Pod 1, their data is cached there. If their next request hits Pod 2, the cache is missed and the database is hit again. Data consistency is lost.
  2. Scenario B (Shared Storage): You mount var/cache to a shared volume (NFS, EFS). Result: The Application Cache is consistent across all pods. Great! But now, every time Symfony needs to load a class or check a route (System Cache), it has to traverse the network to read from the shared storage. This introduces significant I/O latency, often slowing down response times by 10–20% simply due to filesystem overhead.

We were stuck choosing between consistency and performance.

Enter the Share Directory (var/share)

Symfony 7.4 introduces a dedicated architectural concept to solve this: the Share Directory.

This feature formally decouples the location of system-specific files from application-shared files.

  • var/cache: Remains the home for System Cache. It should stay local to the server (ephemeral storage in K8s terms). It requires no synchronization.
  • var/share: The new home for Application Data. This directory is designed to be mounted on shared storage (like NFS, AWS EFS, or a persistent volume).

This separation allows us to have the best of both worlds: blazing-fast, local system caches and a consistent, shared application state.

Implementation Guide

Let’s get our hands dirty. We will build a Symfony 7.4 application that leverages the Share Directory for three common use cases:

  1. Shared Application Cache
  2. Shared File Storage (Uploads)
  3. Shared SQLite Database (for simple state)

Prerequisites and Installation

Ensure you are running PHP 8.2 or higher and have the Symfony CLI installed.

symfony new my_app --webapp
cd my_app
composer require symfony/framework-bundle:^7.4
Enter fullscreen mode Exit fullscreen mode

Basic Configuration

In a fresh Symfony 7.4 installation, the framework is already aware of this concept. Open your .env file. You will see a new environment variable:

# .env
APP_SHARE_DIR=$APP_PROJECT_DIR/var/share
Enter fullscreen mode Exit fullscreen mode

Under the hood, the Kernel class now implements a getShareDir() method. If you are upgrading an existing application, you might need to add this manually or rely on the default fallback (which points to the cache directory for backward compatibility).

To enforce this structure in an upgraded app, update your Kernel.php if necessary, or simply define the environment variable.

Configuring Shared Cache Pools

The most immediate win is moving your application cache to the shared directory. By default, Symfony’s file system cache adapter saves to var/cache/pools. We want to move this to var/share/pools.

Open config/packages/cache.yaml. We will configure the default app cache to use the new %kernel.share_dir% parameter.

# 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
Enter fullscreen mode Exit fullscreen mode

In standard Symfony 7.4, the default filesystem adapter might still default to cache_dir. By explicitly creating a service cache.adapter.shared_filesystem pointing to %kernel.share_dir%/pools, we ensure that our application cache is stored in the correct location.

To verify this, clear your cache and warm it up.

php bin/console cache:clear
php bin/console cache:pool:clear cache.app
Enter fullscreen mode Exit fullscreen mode

Then, generate some cache entries (e.g., by visiting a page). Check the directory structure:

ls -la var/share/pools
Enter fullscreen mode Exit fullscreen mode

You should see a folder structure created by the cache adapter.

Shared File Storage with Flysystem

Handling user uploads in a cluster is a classic use case for shared storage. We will use league/flysystem-bundle to map a storage adapter to var/share/storage.

Installation:

composer require league/flysystem-bundle
Enter fullscreen mode Exit fullscreen mode

Configuration: Open 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'
Enter fullscreen mode Exit fullscreen mode

Now, let’s create a service to handle file uploads using this storage. We will use PHP 8 Attributes for dependency injection.

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);
    }
}
Enter fullscreen mode Exit fullscreen mode

When you deploy this to Kubernetes, you will mount a Persistent Volume Claim (PVC) to /app/var/share. If Pod A uploads a file, it is written to the PVC. Pod B can immediately read that file via the same path, because they share the underlying storage volume.

Shared SQLite Database (The “Lite” Cluster)

While usually not recommended for heavy concurrent writes, using SQLite in var/share is a fantastic pattern for read-heavy, low-write data, or simple internal tooling dashboards that need to persist across deployments without a full MySQL/PostgreSQL setup.

Configuration: Open 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
Enter fullscreen mode Exit fullscreen mode

Ensure the directory exists:

mkdir -p var/share/db
Enter fullscreen mode Exit fullscreen mode

Now, when you run migrations:

php bin/console doctrine:migrations:migrate
Enter fullscreen mode Exit fullscreen mode

The .sqlite file is created in the shared directory. All servers in your cluster will read from this single file.

Warning: SQLite over NFS (Network File System) can have locking issues. Ensure your shared storage solution supports file locking correctly (e.g., AWS EFS with appropriate mounting options), or reserve this for scenarios with very low write frequency.

DevOps: The Deployment Strategy

To fully utilize this feature, your deployment manifest (e.g., docker-compose.yml or Kubernetes deployment.yaml) needs to be updated.

Docker Compose Example

Here is how you simulate the production environment locally.

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:
Enter fullscreen mode Exit fullscreen mode

In this setup:

  1. System Cache (var/cache) is inside the container (fast, isolated).
  2. Shared Data (var/share) is a named volume shared between app_1 and app_2.

Kubernetes (K8s) Strategy

In Kubernetes, you would use a 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
Enter fullscreen mode Exit fullscreen mode

Verification:

  1. Exec into Pod 1: kubectl exec -it symfony-app-pod-1 — bash
  2. Create a file: touch var/share/test.txt
  3. Exec into Pod 2: kubectl exec -it symfony-app-pod-2 — bash
  4. Check file: ls var/share/
  5. You should see test.txt.

Migration Guide: Upgrading to 7.4

If you are maintaining a legacy application, adopting the Share Directory requires a few careful steps.

  1. Update Composer: Update composer.json to allow symfony/: 7.4.. Run composer update “symfony/*”.
  2. Update .env: Add APP_SHARE_DIR to your .env and .env.test.
  3. Update .gitignore: You generally do not want to commit the contents of the share directory, but you might want to keep the gitkeep.
  4. Refactor Paths: Search your codebase for hardcoded references to kernel.cache_dir or var/cache. If the code was using the cache directory to store data that should be persisted or shared (like generated PDF reports, temporary exports), change it to use %kernel.share_dir%.

Conclusion

Symfony 7.4’s Share Directory is more than just a new folder structure; it is a maturity signal. It acknowledges that modern PHP applications live in the cloud, across clusters and need to scale horizontally without fighting the framework.

By adopting var/share, you simplify your infrastructure configuration, improve the performance of your system caches and provide a clear, standardized location for your application’s state.

Ready to scale? Start by upgrading a non-critical microservice to Symfony 7.4 today. Implement the var/share directory, remove those complex NFS mounts for your system cache and watch your average response times drop.

Keep in touch! Did this article help you clarify your upgrade path? Follow me on [LinkedIn:https://www.linkedin.com/in/matthew-mochalkin/]. Let’s build better software, together.

Top comments (0)