Behandling af video er en af de tungeste opgaver en webapplikation kan håndtere. Inden for en controller blokerer du sandsynligvis dine PHP-FPM-tråde, frustrerer dine brugere og risikerer timeouts. shell_exec(‘ffmpeg …’) I 2026 gør vi ikke det. Vi behandler videobehandling som en , der . asynchronous distributed pipeline Med udgivelsen af Symfony 7.4 har vi nye værktøjer, der gør dette robust og indfødt. , der Og den Udvikling af parallelle rørledninger. edicated #[Video] validation constraint native support for shared directories, mature Messenger component I denne artikel vil vi opbygge en videobehandling arkitektur på produktionsniveau, der: 
 
 
 
 Validates uploader øjeblikkeligt ved hjælp af de nye Symfony 7.4-begrænsninger. Hævning af vægt til baggrundsarbejdere. Paralleliser opgaver (transcoding, miniaturer, analyse) samtidig. Forudsætninger 
 
 
 
 
 PHP 8.2+ (PHP 8.4 anbefales) Symfony 7.4 (symfoni / skeleton & symfoni / webapp-pakke) FFmpeg installeret på din server/container (sudo apt install ffmpeg). Kompositør pakker:php-ffmpeg/php-ffmpeg(v1.3+)symfony/messenger\symfony/validator Arkitektur: Delte katalogstrategier Når en bruger uploader en video til din Web Container, skal din Worker Container (som kan være på en anden server) få adgang til den. I Symfoni 7.4 læner vi os ind i » ” mønster – en standardiseret placering for statlige data, der deles på tværs af noder (såsom NFS-monteringer eller Docker Volumes). Shared Directory Infrastructure setup (Conceptual): 
 
 
 Webnode: Monterer /mnt/shared_storage til ./var/storage. Arbejdsknode: Monterer samme volumen til ./var/lagring. Vi vil indføre denne vej i at sikre, at vores kode er agnostisk af den fysiske placering. 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%'
 Validering: Den nye #[Video] Constraint I tidligere versioner måtte vi stole på den generiske begrænse og gætte MIME-typer eller skrive komplekse brugerdefinerede valideringsværktøjer til at kontrollere varighed og codecs. File Symfony 7.4 introducerer den indfødte Det er begrænset, det bruger Indenrigsministeriet (via ) for at validere metadata, før du endda accepterer forretningslogikken. #[Video] FFmpeg ffprobe Lad os lave en DTO til vores 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
    ) {}
}
 Denne begrænsning kræver, at ffprobe binær skal være eksekverbar af webbrugeren. Anmeldelse af Messenger Pipelines For at behandle video effektivt, bør vi ikke bare køre et kæmpe script. Vi bør opdele arbejdet i Pipelines. Når en video er uploadet, vil vi sende en "Manager Message", som derefter sender underopgaver til at køre parallelt. De budskaber (DTO’er) Vi bruger readonly-klasser til uforanderlige meddelelsesobjekter. // 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
    ) {}
}
 Konfiguration af transport Vi har brug for mindst to transportmidler: 
 
 
 async_priority: Til hurtige opgaver (thumbnails, databaseopdateringer). async_heavy: For langvarige opgaver (transcoding). Dette forhindrer en 10-minutters 4K-kodning i at blokere din miniature-generering. # 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
 Behandlingslogik Vi vil bruge den biblioteket. Først skal du installere det: php-ffmpeg composer require php-ffmpeg/php-ffmpeg
 Direktør Handler Denne håndtering modtager den oprindelige upload begivenhed og "fans ud" arbejdet. // 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.");
    }
}
 Den tunge arbejdstager håndterer Nu implementerer vi den faktiske logik ved hjælp . 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");
    }
}
 The Controller: Bind det sammen Kontrollerens opgave er nu utroligt enkel: 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);
    }
}
 Løber rørledningen I et produktionsmiljø (som Kubernetes eller Docker Swarm) ville du skalere disse implementeringer uafhængigt. Håndterer dispatching og miniaturer. Terminal 1 (The Priority Worker): php bin/console messenger:consume async_priority -vv
 Håndterer faktisk video kodning. Du kan køre 4 eller 5 af disse containere. Terminal 2 (The Heavy Worker): php bin/console messenger:consume async_heavy -vv
 Verifikation 
 
 
 
 
 POST en 50 MB MP4-fil til /api/videos/upload. Observe Terminal 1: Det modtager ProcessVideoUpload, så næsten øjeblikkeligt sender 5 nye beskeder (3 miniaturer, 2 transcoder). Observe Terminal 2: Det opfanger TranscodeVideo. Du vil se CPU-bruget stige, når FFmpeg kører. Tjek din ./var/storage/processed/ mappe. Du vil se miniaturerne vises hurtigt, efterfulgt senere af de transkodede videofiler. Konklusionen Ved at udnytte Symfony 7.4 har vi forvandlet et komplekst problem til en ren, håndterbar arkitektur. 
 
 
 
 Pålidelighed: Den #[Video] begrænsning sikrer, at ingen ugyldige filer nogensinde kommer ind i vores pipeline. Skalerbarhed: Ved at adskille async_priority og async_heavy blokeres miniaturegenerering aldrig af stor video kodning. Du kan ændre transkodebiblioteket eller lagringsenheden (f.eks. til S3 ved hjælp af Flysystem) uden at røre kontrolelementet eller valideringslogikken. Denne arkitektur er "produktionsklar", men giver mulighed for vækst. Når du skalerer, kan du erstatte den lokale Med en (ved hjælp af liga/flysystem-aws-s3-v3), men Messenger-rørledningskonceptet forbliver nøjagtigt det samme. Shared Directory Object Storage abstraction Videobehandling behøver ikke at være skræmmende.Med de rigtige begrænsninger og køarkitektur bliver det forudsigeligt og observerbart. Har du spørgsmål om at skalere Symfony-rørledninger? lad os forbinde. jeg deler daglige tips om moderne PHP-arkitektur. Linkedin: Kontakt mig [ ] 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

Denne lyd er produceret på historiens originalsprog!

Sådan skaleres videoer: Parallel behandling, messenger og mere

About Author

KOMMENTARER

HÆNG TAGS

DENNE ARTIKEL BLEV PRÆsenterET I

Related Stories

Meet HubSpot: HackerNoon Company of the Week

Yale Media Relations for Entrepreneurs with Journalist Walter Thompson & HackerNoon CEO David Smooke

Meet Surfshark: HackerNoon Company of the Week

Meet inDrive: The HackerNoon Company of the Week

Meet HubSpot: HackerNoon Company of the Week

Yale Media Relations for Entrepreneurs with Journalist Walter Thompson & HackerNoon CEO David Smooke

Meet Surfshark: HackerNoon Company of the Week

Meet inDrive: The HackerNoon Company of the Week

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps