El procesamiento de vídeo es una de las tareas más pesadas que una aplicación web puede manejar. Dentro de un controlador, es probable que estés bloqueando tus threads PHP-FPM, frustrando a tus usuarios y arriesgando temporadas. shell_exec(‘ffmpeg …’) En 2026, no lo hacemos.Tratamos el procesamiento de vídeo como un , de . asynchronous distributed pipeline Con el lanzamiento de Symfony 7.4, tenemos nuevas herramientas que hacen esto robusto y nativo. , de Y el Orquestación de tuberías paralelas. edicated #[Video] validation constraint native support for shared directories, mature Messenger component En este artículo, construiremos una arquitectura de procesamiento de vídeo de nivel de producción que: 
 
 
 
 Validates sube instantáneamente utilizando las nuevas restricciones de Symfony 7.4. Descarga el levantamiento pesado a los trabajadores de fondo. Paraleliza tareas (transcodificación, miniaturas, análisis) simultáneamente. Precondiciones 
 
 
 
 
 PHP 8.2+ (PHP 8.4 recomendado) Sinfonía 7.4 (Symfony / esqueleto y sinfonía / paquete de aplicaciones web). FFmpeg instalado en su servidor / contenedor (sudo apt install ffmpeg). Paquetes de Compositor:php-ffmpeg/php-ffmpeg(v1.3+)symfony/messenger\symfony/validator La arquitectura: Estrategia de directorio compartido Cuando un usuario carga un vídeo a su contenedor web, su contenedor de trabajadores (que puede estar en un servidor diferente) necesita acceder a él. En la Sinfonía 7.4, nos inclinamos hacia el “ patrón: una ubicación estandarizada para los datos estatales compartidos entre nodos (como NFS Monts o Docker Volumes). Shared Directory Infrastructure setup (Conceptual): 
 
 
 Nodo web: Monta /mnt/shared_storage a ./var/storage. Nodo de trabajador: monta el mismo volumen a ./var/almacenamiento. Esta ruta se configurará en para garantizar que nuestro código sea agnóstico de la ubicación física. 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%'
 Validación: La nueva #[Video] Constraint En las versiones anteriores, teníamos que confiar en el genérico Contener y adivinar tipos de MIME, o escribir validadores personalizados complejos para comprobar la duración y los codecs. File Symfony 7.4 introduce el nativo Contenido: se utiliza Encuentros (via ) to validate metadata before you even accept the business logic. #[Video] FFmpeg ffprobe Vamos a crear un DTO para nuestro 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
    ) {}
}
 Esta restricción requiere que el binario ffprobe sea ejecutable por el usuario web. Archivo de la etiqueta: messenger pipelines Para procesar el vídeo de manera eficiente, no deberíamos simplemente ejecutar un script gigante. Debemos dividir el trabajo en Pipelines.Cuando se cargue un vídeo, enviaremos un “Mensajero de Mensaje”, que luego envía sub-tareas a ejecutarse en paralelo. Los mensajes (DTOs) Usamos clases readonly para objetos de mensajes inmutables. // 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
    ) {}
}
 Configuración del transporte Necesitamos al menos dos medios de transporte: 
 
 
 async_priority: Para tareas rápidas (miniaturas, actualizaciones de bases de datos). async_heavy: Para tareas de larga duración (transcodificación). Esto evita que un código 4K de 10 minutos bloquee su generación de miniaturas. # 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 lógica del procesamiento Nosotros utilizaremos el En primer lugar, instalarlo: php-ffmpeg composer require php-ffmpeg/php-ffmpeg
 El gestor manejador Este manipulador recibe el evento de carga inicial y “fans” el trabajo. // 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.");
    }
}
 El trabajador pesado manejador Ahora, implementamos la lógica real usando . 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");
    }
}
 El controlador: vinculándolo juntos El trabajo del controlador ahora es increíblemente simple: 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);
    }
}
 ejecutando las tuberías Para ver este paralelismo en acción, necesitas ejecutar a tus trabajadores.En un entorno de producción (como Kubernetes o Docker Swarm), escalarías estas implementaciones de forma independiente. Gestionar el despacho y las miniaturas. Terminal 1 (The Priority Worker): php bin/console messenger:consume async_priority -vv
 Gestiona la codificación de vídeo real. Puede ejecutar 4 o 5 de estos contenedores. Terminal 2 (The Heavy Worker): php bin/console messenger:consume async_heavy -vv
 Verificación 
 
 
 
 
 POST un archivo MP4 de 50 MB a /api/videos/upload. Observe Terminal 1: Recibe ProcessVideoUpload, luego casi instantáneamente envía 5 nuevos mensajes (3 miniaturas, 2 transcodes). Observe Terminal 2: Recoge TranscodeVideo. Verá el aumento del uso de la CPU a medida que se ejecuta FFmpeg. Compruebe su ./var/storage/processed/ directory. Verá que las miniaturas aparecen rápidamente, seguidas más tarde por los archivos de vídeo transcodificados. Conclusión Al aprovechar Symfony 7.4, hemos transformado un problema complejo en una arquitectura limpia y gestionable. 
 
 
 
 Fiabilidad: La restricción #[Video] garantiza que ningún archivo inválido nunca entre en nuestra tubería. Escalabilidad: Separando async_priority y async_heavy, la generación de miniaturas nunca se bloquea por la codificación de vídeo grande. Puede cambiar la biblioteca de transcodificación o el motor de almacenamiento (por ejemplo, a S3 utilizando Flysystem) sin tocar el controlador o la lógica de validación. Esta arquitectura es "preparada para la producción", pero permite el crecimiento.A medida que escalas, puedes reemplazar la arquitectura local Con un (utilizando league/flysystem-aws-s3-v3), pero los conceptos de canal de mensajería siguen siendo exactamente los mismos. Shared Directory Object Storage abstraction El procesamiento de vídeo no tiene que ser aterrador.Con las restricciones correctas y la arquitectura de la cola, se vuelve previsible y observable. ¿Tienes preguntas sobre el escalado de las tuberías de Symfony? conectémonos. comparto consejos diarios sobre la arquitectura PHP moderna. Linkedin: Conectar conmigo [ ] 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!

Cómo escalar videos: procesamiento paralelo, mensajería y más

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Navegando por las aguas: desarrollo de aplicaciones RAG de nivel de producción con lagos de datos

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

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

Crecimiento de las criptomonedas: creación de perfiles de usuarios eficaces

Navegando por las aguas: desarrollo de aplicaciones RAG de nivel de producción con lagos de datos

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

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

Crecimiento de las criptomonedas: creación de perfiles de usuarios eficaces

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps