Përpunimi i videove është një nga detyrat më të rënda që një aplikacion web mund të përballojë. Brenda një kontrolluesi, ju ndoshta jeni duke bllokuar thread tuaj PHP-FPM, duke frustruar përdoruesit tuaj, dhe duke rrezikuar timeouts. shell_exec(‘ffmpeg …’) Në vitin 2026, ne nuk e bëjmë këtë.Ne e trajtojmë përpunimin e videove si një të . asynchronous distributed pipeline Me lirimin e Symfony 7.4, ne kemi mjete të reja që e bëjnë këtë të fortë dhe të lindur. të dhe të Përdorimi i tubacioneve paralele. edicated #[Video] validation constraint native support for shared directories, mature Messenger component Në këtë artikull, ne do të ndërtojmë një arkitekturë të përpunimit të videove të nivelit të prodhimit që: 
 
 
 
 Validates ngarkon menjëherë duke përdorur kufizimet e reja të Symfony 7.4. Ngritja e ngarkesave të rënda për punëtorët e sfondit. Paralelizes detyrat (transcoding, miniaturë, analizë) në të njëjtën kohë. Parashikimet 
 
 
 
 
 PHP 8.2 + (PHP 8.4 rekomandohet) Symfony 7.4 (symfony / skeleton & symfony / webapp paketë) FFmpeg instaluar në serverin tuaj / kontejner (sudo apt install ffmpeg). Paketimet e kompozitorit:php-ffmpeg/php-ffmpeg(v1.3+)symfony/messenger\symfony/validator Arkitektura: Strategjia e Drejtorisë së Përbashkët Kur një përdorues ngarkon një video në kontejnerin tuaj Web, kontejneri juaj i Punëtorëve (i cili mund të jetë në një server tjetër) ka nevojë për të hyrë në të. Në Sinfoninë 7.4, ne mbështetemi në “ “pattern” – një vendndodhje e standardizuar për të dhënat statike të ndara në të gjithë nyjet (si NFS Monts ose Docker Volumes). Shared Directory Infrastructure setup (Conceptual): 
 
 
 Web Node: Mounts /mnt/shared_storage në ./var/storage. Punëtor Node: Monton të njëjtin vëllim në ./var/storage. Ne do ta ndërtojmë këtë rrugë në për të siguruar që kodi ynë është agnostik i vendndodhjes fizike. 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%'
 Vlerësimi: The New #[Video] Constraint Në versionet e mëparshme, ne kemi pasur për t'u mbështetur në gjenerike Kufizoni dhe gjeni llojet e MIME, ose shkruani validatorë kompleksë të përshtatur për të kontrolluar kohëzgjatjen dhe codecs. File Simfoni 7.4 paraqet origjinalin Përdoret - Përdoret të brendshme (via për të validuar metadata para se të pranoni logjikën e biznesit. #[Video] FFmpeg ffprobe Le të krijojmë një DTO për ngarkimin tonë. // 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
    ) {}
}
 Ky kufizim kërkon që ffprobe binary të jetë i ekzekutueshëm nga përdoruesi i internetit. Fjalë kyçe Messenger Pipelines Për të përpunuar video në mënyrë efikase, ne nuk duhet të drejtojmë vetëm një skenar gjigant. Ne duhet të ndajmë punën në Pipelines. Kur një video është ngarkuar, ne do të dërgojmë një "Mesazh Menaxheri", i cili pastaj dërgon nën-detyrat për të drejtuar në paralel. Mesazhe të ndryshme (DTOs) Ne përdorim klasat readonly për objektet e mesazheve të pandryshueshme. // 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
    ) {}
}
 Konfigurimi i transportit Ne kemi nevojë për të paktën dy transportet: 
 
 
 async_priority: Për detyra të shpejta (thumbnails, përditësimet e bazës së të dhënave). async_heavy: Për detyra të gjata (transcoding). Kjo parandalon një kodim 4K 10-minutëshe nga bllokimi i gjenerimit të miniaturave. # 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
 Logjika e përpunimit Ne do të përdorim Për të filluar, instaloni: php-ffmpeg composer require php-ffmpeg/php-ffmpeg
 Menaxheri Handler Ky menaxher merr ngjarjen fillestare të ngarkimit dhe "fan" punën. // 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.");
    }
}
 Trajtimi i punëtorëve të rënda Tani, ne zbatojmë logjikën reale duke përdorur . 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");
    }
}
 Kontrolluesi: Duke e lidhur atë së bashku Detyra e kontrolluesit tani është tepër e thjeshtë: 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);
    }
}
 Drejtimi i tubacioneve Në një mjedis të prodhimit (si Kubernetes ose Docker Swarm), ju do të shkallëzoni këto vendosje në mënyrë të pavarur. Menaxhimi i dispatching dhe miniaturave. Terminal 1 (The Priority Worker): php bin/console messenger:consume async_priority -vv
 Menaxhon kodimin aktual të videove.Ju mund të ekzekutoni 4 ose 5 prej këtyre kontejnerëve. Terminal 2 (The Heavy Worker): php bin/console messenger:consume async_heavy -vv
 Verifikimi 
 
 
 
 
 POST një skedar MP4 50MB në /api/videos/upload. Observe Terminal 1: Ajo merr ProcessVideoUpload, pastaj pothuajse menjëherë dërgon 5 mesazhe të reja (3 thumbnails, 2 transcodes). Observe Terminal 2: Ajo merr TranscodeVideo. Ju do të shihni rritjen e përdorimit të CPU si FFmpeg shkon. Kontrolloni ./var / storage / processed / directory. Ju do të shihni miniaturat shfaqen shpejt, e ndjekur më vonë nga fotografi video transcoded. Konkludimi Duke përdorur Symfony 7.4, ne kemi transformuar një problem kompleks në një arkitekturë të pastër dhe të menaxhueshme. 
 
 
 
 Besueshmëria: Kufizimi #[Video] siguron që asnjë skedar i pavlefshëm kurrë të hyjë në tubacionin tonë. Scalability: Duke ndarë async_priority dhe async_heavy, gjenerimi i miniaturës nuk bllokohet kurrë nga kodimi i madh i videove. Mund të ndryshoni bibliotekën e transkodimit ose motorin e ruajtjes (p.sh. në S3 duke përdorur Flysystem) pa prekur Kontrolluesin ose logjikën e Validimit. Kjo arkitekturë është “e gatshme për prodhim”, por lejon rritjen. si ju shkallë, ju mund të zëvendësoni Me një (duke përdorur ligë/flysystem-aws-s3-v3), por konceptet e tubacionit të Messenger mbeten saktësisht të njëjta. Shared Directory Object Storage abstraction Përpunimi i videove nuk duhet të jetë i frikshëm.Me kufizimet e duhura dhe arkitekturën e radhës, ajo bëhet e parashikueshme dhe e vëzhgueshme. A keni pyetje në lidhje me shkallëzimin e tubacioneve Symfony? Le të lidhemi. unë ndajnë këshilla të përditshme në arkitekturën moderne PHP. Linkedin: Lidhuni me mua [ ] 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

Kjo audio është prodhuar në gjuhën origjinale të tregimit!

Si të shkallëzoni videot: Përpunimi paralel, Messenger dhe më shumë

About Author

KOMENTE

VARUR TAGS

KY ARTIKU U PARAQIT NË

Related Stories

Rrjeti SQD sapo vrau emetimet e tokenëve.Ja çfarë paguan 16 miliardë dollarë në DeFi TVL

Rrjeti SQD sapo vrau emetimet e tokenëve.Ja çfarë paguan 16 miliardë dollarë në DeFi TVL

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps