L'elaborazione di video è uno dei compiti più pesanti che un'applicazione web può gestire. All'interno di un Controller, è probabile che tu stia bloccando i tuoi thread PHP-FPM, frustrando i tuoi utenti e rischiando tempi di sospensione. shell_exec(‘ffmpeg …’) Nel 2026 non lo faremo, trattiamo il video come un di . asynchronous distributed pipeline Con il rilascio di Symfony 7.4, abbiamo nuovi strumenti che lo rendono robusto e nativo. di e il per la costruzione di pipeline parallele. edicated #[Video] validation constraint native support for shared directories, mature Messenger component In questo articolo, costruiremo un'architettura di elaborazione video di livello di produzione che: 
 
 
 
 Validates carica istantaneamente utilizzando le nuove restrizioni Symfony 7.4. Scarica il sollevamento pesante ai lavoratori di fondo. Parallelizza attività (transcodifica, miniature, analisi) contemporaneamente. Prerequisiti 
 
 
 
 
 PHP 8.2+ (PHP 8.4 consigliato) Symfony 7.4 (symfony/scheleton & symfony/webapp-pack) FFmpeg installato sul tuo server/contenitore (sudo apt install ffmpeg). Compositor pacchetti:php-ffmpeg/php-ffmpeg(v1.3+)symfony/messenger\symfony/validator L'architettura: strategia di directory condiviso Quando un utente carica un video al tuo Web Container, il tuo Worker Container (che potrebbe essere su un server diverso) ha bisogno di accedervi. Nella Sinfonia 7.4 ci appoggiamo alla “ ” pattern – una posizione standardizzata per i dati statali condivisi tra nodi (come i montamenti NFS o i Volumi Docker). Shared Directory Infrastructure setup (Conceptual): 
 
 
 Nodo Web: Monta /mnt/shared_storage a ./var/storage. Nodo del lavoratore: Monta lo stesso volume a ./var/storage. Creeremo questo percorso in per garantire che il nostro codice sia agnostico della posizione fisica. services.yaml # config/services.yaml
parameters:
    # The absolute path to the shared storage (mapped volume)
    app.storage_dir: '%kernel.project_dir%/var/storage'

services:
    _defaults:
        autowire: true
        autoconfigure: true
        bind:
            $storageDir: '%app.storage_dir%'
 Validazione: il nuovo #[Video] Constraint Nelle versioni precedenti, dovevamo fare affidamento sul generico limitare e indovinare i tipi MIME, o scrivere complessi validatori personalizzati per controllare la durata e i codec. File Symfony 7.4 introduce il nativo Contenuto: si utilizza Interiore (via Valutare i metadati prima di accettare la logica aziendale. #[Video] FFmpeg ffprobe Creiamo un DTO per il nostro upload. // src/Dto/VideoUploadDto.php
namespace App\Dto;

use Symfony\Component\HttpFoundation\File\UploadedFile;
use Symfony\Component\Validator\Constraints as Assert;

final readonly class VideoUploadDto
{
    public function __construct(
        #[Assert\NotBlank]
        #[Assert\Video(
            maxSize: '500M',
            mimeTypes: ['video/mp4', 'video/quicktime', 'video/webm'],
            minWidth: 1280,
            maxWidth: 3840, // 4K limit
            minDuration: 5, // Seconds
            maxDuration: 3600,
            allowPortrait: false, // Enforce landscape
            suggestedExtensions: ['mp4', 'mov']
        )]
        public UploadedFile $file,

        #[Assert\NotBlank]
        #[Assert\Length(min: 5, max: 255)]
        public string $title
    ) {}
}
 Questa restrizione richiede che il binario ffprobe sia eseguibile dall'utente web. Titolo originale: Messenger Pipelines Per elaborare il video in modo efficiente, non dovremmo solo eseguire uno script gigante. Dovremmo suddividere il lavoro in Pipelines. Quando un video viene caricato, invieremo un "Messaggio di Gestione", che invierà poi i sottotatti da eseguire in parallelo. I messaggi (DTOs) Utilizziamo le classi readonly per gli oggetti dei messaggi immutabili. // src/Message/ProcessVideoUpload.php
namespace App\Message;

/**
 * The Trigger: Dispatched immediately after upload.
 */
final readonly class ProcessVideoUpload
{
    public function __construct(
        public string $videoId,
        public string $filename
    ) {}
}
 // src/Message/TranscodeVideo.php
namespace App\Message;

/**
 * Sub-Task: Heavy encoding work.
 */
final readonly class TranscodeVideo
{
    public function __construct(
        public string $videoId,
        public string $filename,
        public string $targetFormat // e.g., 'hls', 'mp4-720p'
    ) {}
}
 // src/Message/GenerateThumbnail.php
namespace App\Message;

/**
 * Sub-Task: Image extraction.
 */
final readonly class GenerateThumbnail
{
    public function __construct(
        public string $videoId,
        public string $filename,
        public int $timestamp
    ) {}
}
 Configurazione dei trasporti Abbiamo bisogno di almeno due mezzi di trasporto: 
 
 
 async_priority: per attività veloci (miniature, aggiornamenti di database). async_heavy: per attività di lunga durata (transcoding). Questo impedisce a un codice 4K di 10 minuti di bloccare la generazione di miniature. # config/packages/messenger.yaml
framework:
    messenger:
        failure_transport: failed

        transports:
            # Fast lane
            async_priority:
                dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
                options:
                    queue_name: priority_queue

            # Slow lane (Heavy video processing)
            async_heavy:
                dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
                options:
                    queue_name: video_encoding_queue
                    # Increase timeout for workers on this queue
                    auto_setup: true

            failed: 'doctrine://default?queue_name=failed'

        routing:
            'App\Message\ProcessVideoUpload': async_priority
            'App\Message\GenerateThumbnail': async_priority
            'App\Message\TranscodeVideo': async_heavy
 La logica del trattamento Utilizzeremo il Per iniziare, installare la scheda: php-ffmpeg composer require php-ffmpeg/php-ffmpeg
 Il gestore gestore Questo gestore riceve l'evento di caricamento iniziale e "fan out" il lavoro. // src/MessageHandler/ProcessVideoUploadHandler.php
namespace App\MessageHandler;

use App\Message\GenerateThumbnail;
use App\Message\ProcessVideoUpload;
use App\Message\TranscodeVideo;
use Psr\Log\LoggerInterface;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;
use Symfony\Component\Messenger\MessageBusInterface;

#[AsMessageHandler]
final readonly class ProcessVideoUploadHandler
{
    public function __construct(
        private MessageBusInterface $bus,
        private LoggerInterface $logger
    ) {}

    public function __invoke(ProcessVideoUpload $message): void
    {
        $this->logger->info("Starting pipeline for video: {$message->videoId}");

        // 1. Dispatch Thumbnail Generation (Fast)
        // We generate 3 thumbnails in parallel by dispatching 3 messages
        $this->bus->dispatch(new GenerateThumbnail($message->videoId, $message->filename, 5));
        $this->bus->dispatch(new GenerateThumbnail($message->videoId, $message->filename, 30));
        $this->bus->dispatch(new GenerateThumbnail($message->videoId, $message->filename, 60));

        // 2. Dispatch Transcoding (Slow/Heavy)
        // These will go to the 'async_heavy' transport
        $this->bus->dispatch(new TranscodeVideo($message->videoId, $message->filename, 'mp4-720p'));
        $this->bus->dispatch(new TranscodeVideo($message->videoId, $message->filename, 'webm-720p'));

        $this->logger->info("Pipeline dispatched successfully.");
    }
}
 Il lavoratore pesante Si utilizza la logica attuale . FFmpeg // src/MessageHandler/TranscodeVideoHandler.php
namespace App\MessageHandler;

use App\Message\TranscodeVideo;
use FFMpeg\FFMpeg;
use FFMpeg\Format\Video\X264;
use Psr\Log\LoggerInterface;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;

#[AsMessageHandler]
final readonly class TranscodeVideoHandler
{
    public function __construct(
        private string $storageDir,
        private LoggerInterface $logger,
    ) {}

    public function __invoke(TranscodeVideo $message): void
    {
        $inputFile = $this->storageDir . '/' . $message->filename;
        $outputFile = $this->storageDir . '/processed/' . $message->videoId . '-' . $message->targetFormat . '.mp4';

        // 1. Verify existence (Robustness)
        if (!file_exists($inputFile)) {
            // In a shared dir setup, there might be a slight sync delay or error.
            // Throwing exception triggers Messenger retry policy.
            throw new \RuntimeException("File not found: $inputFile");
        }

        $this->logger->info("Transcoding {$message->videoId} to {$message->targetFormat}...");

        // 2. Initialize FFMpeg
        $ffmpeg = FFMpeg::create();
        $video = $ffmpeg->open($inputFile);

        // 3. Configure Format (x264 codec, AAC audio)
        $format = new X264();
        $format->setKiloBitrate(1000)
               ->setAudioChannels(2)
               ->setAudioKiloBitrate(128);

        // 4. Save
        // This is a blocking process that can take minutes.
        // Because it's in a worker, the user is not waiting.
        $filesystem = new Filesystem();
        $filesystem->mkdir(dirname($outputFile));
        
        $video->save($format, $outputFile);

        $this->logger->info("Transcoding complete: $outputFile");
    }
}
 Titolo originale: Binding It Together Il lavoro del controllore è ora incredibilmente semplice: Validate -> Move to Storage -> Dispatch -> Return 202 Accepted. // src/Controller/VideoController.php
namespace App\Controller;

use App\Dto\VideoUploadDto;
use App\Message\ProcessVideoUpload;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Attribute\MapUploadedFile;
use Symfony\Component\Messenger\MessageBusInterface;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Uid\Uuid;

#[Route('/api/videos')]
class VideoController extends AbstractController
{
    public function __construct(
        private string $storageDir,
        private MessageBusInterface $bus
    ) {}

    #[Route('/upload', methods: ['POST'])]
    public function upload(
        // Validates automatically using our DTO constraints
        #[MapUploadedFile] VideoUploadDto $uploadDto
    ): JsonResponse {
        
        $file = $uploadDto->file;
        $videoId = Uuid::v7()->toRfc4122();
        
        // 1. Move file to Shared Directory
        // We use the ID as the filename to avoid collisions
        $filename = $videoId . '.' . $file->guessExtension();
        $file->move($this->storageDir, $filename);

        // 2. Dispatch the Manager Message
        $this->bus->dispatch(new ProcessVideoUpload($videoId, $filename));

        // 3. Immediate Response
        return $this->json([
            'status' => 'processing',
            'id' => $videoId,
            'message' => 'Video accepted. Processing pipelines initiated.'
        ], 202);
    }
}
 Gestire i gasdotti Per vedere questo parallelismo in azione, devi eseguire i tuoi lavoratori.In un ambiente di produzione (come Kubernetes o Docker Swarm), scaleresti queste implementazioni in modo indipendente. Gestione dei dispatch e delle miniature. Terminal 1 (The Priority Worker): php bin/console messenger:consume async_priority -vv
 Gestione dell'attuale codifica video. Potresti eseguire 4 o 5 di questi contenitori. Terminal 2 (The Heavy Worker): php bin/console messenger:consume async_heavy -vv
 Verificazione 
 
 
 
 
 POST un file MP4 da 50 MB a /api/videos/upload. Observe Terminal 1: riceve ProcessVideoUpload, quindi quasi istantaneamente invia 5 nuovi messaggi (3 miniature, 2 transcodi). Osservare Terminale 2: Si prende TranscodeVideo. Vedrete l'aumento dell'utilizzo della CPU come FFmpeg viene eseguito. Controllate il vostro ./var/storage/processed/ directory. Vedrete le miniature apparire rapidamente, seguite più tardi dai file video trascodificati. Conclusione Utilizzando Symfony 7.4, abbiamo trasformato un problema complesso in un'architettura pulita e gestibile. 
 
 
 
 Affidabilità: la restrizione #[Video] assicura che nessun file non valido entri mai nella nostra pipeline. Scalabilità: separando async_priority e async_heavy, la generazione di miniature non viene mai bloccata dalla codifica video di grandi dimensioni. Puoi cambiare la libreria di trascodifica o il motore di archiviazione (ad esempio, a S3 utilizzando Flysystem) senza toccare il Controller o la logica di convalida. Questa architettura è "pronta per la produzione" ma consente la crescita. man mano che si scala, si potrebbe sostituire il locale con un (utilizzando league/flysystem-aws-s3-v3), ma i concetti del pipeline Messenger rimangono esattamente gli stessi. Shared Directory Object Storage abstraction Con le giuste restrizioni e l'architettura di coda, diventa prevedibile e osservabile. Avete domande sulla scalabilità dei pipeline Symfony? legamiamoci. condivido consigli quotidiani sull'architettura PHP moderna. Linkedin: connettersi con me [ ] 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

Questo audio è prodotto nella lingua originale della storia!

Come scalare i video: elaborazione parallela, messaggeri e altro ancora

About Author

COMMENTI

CARTELLINI

QUESTO ARTICOLO È STATO PRESENTATO IN

Related Stories

Arron Goolsbey Talks Future of Gaming with AI and Blockchain at Mythical Games

Indian PM Woos Tech CEOs During U.S. State Visit

HackerNoon - A User Experience Analysis: Part 2

I Built an AI Copilot That Thinks in Exploits, Not Prompts

Arron Goolsbey Talks Future of Gaming with AI and Blockchain at Mythical Games

Indian PM Woos Tech CEOs During U.S. State Visit

HackerNoon - A User Experience Analysis: Part 2

I Built an AI Copilot That Thinks in Exploits, Not Prompts

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps