Symfony 8 në PHP 8.4: FrankenPHP vs RoadRunner Benchmarked

Lirimi i Symfony 7.4 LTS shënon një moment kyç në ekosistemin PHP. Ndërsa vetë korniza paraqet karakteristika të fuqishme si siguria më e rreptë e tipit dhe serializimi i brendshëm PHP për kontejnerët, revolucioni i vërtetë po ndodh në mënyrën se si i shërbejmë këto aplikacione. Serverët e aplikacioneve të shkruara në Go kanë pjekur, duke ofruar aftësi të “Modalitetit të Punës” që nisin kernelin tuaj një herë dhe e mbajnë atë në kujtesë, duke zvogëluar vonesën dhe duke rritur shpejtësinë. NGINX + PHP-FPM Në këtë artikull, ne hedhim dy pesha të rënda kundër njëri-tjetrit: (moderne challenger ndërtuar në Caddy) dhe Ne do të zbatojmë të dyja në një aplikacion Symfony 8 që punon në PHP 8.4, krahasojmë arkitekturat e tyre dhe analizojmë performancën e tyre. FrankenPHP RoadRunner Kundërshtarët Françesku Ndërtuar në krye të web server Caddy, është një server modern i aplikacioneve që thjeshton grumbullimin. Ai kompilon PHP direkt në binar (ose përdor një ndërtim të veçantë) dhe përfiton nga automatizimi i Caddy dhe Mbështetje të FrankenPHP HTTPS HTTP/3 Ngatërrohet NGINX, PHP-FPM dhe terminatori SSL në një binar të vetëm. Key Advantage: Mbështetje native përmes komponentit Runtime me Symfony 7.4+. Rrugët Zhvilluar nga Spiral Scout, RoadRunner është një server aplikacioni PHP me performancë të lartë, balancues i ngarkesës dhe menaxher i procesit. Shërbimi i Shërbimit të Shërbimit të Shërbimit të Shërbimit ( të të e cila integrohet thellë me simfoninë. Key Advantage: gRPC Queues KV storage Integrimi i shkëlqyer përmes runtime / roadrunner-symfony-nyholm. Kodi i Benchmark (Symfony 8 dhe PHP 8.4) Për të bërë krahasimin e drejtë, ne do të krijojmë një API të lehtë që ndërvepron me një bazë të të dhënave.Kjo teston jo vetëm shpejtësinë e papërpunuar "Hello World", por edhe mbizotërimin e lidhjeve të bazës së të dhënave dhe serializimin në një mjedis të vazhdueshëm të punonjësve. Ne përdorim PHP 8.4 Property Hooks (nëse është në dispozicion në ndërtimin tuaj) ose pronat standarde të shkruara. Për pajtueshmëri të gjerë në këtë udhëzues, ne përdorim standarde 8.3+ pronat e promovuara me Attributes. The Entity: namespace App\Entity; use Doctrine\ORM\Mapping as ORM; use Symfony\Component\Serializer\Attribute\Groups; #[ORM\Entity] #[ORM\Table(name: 'products')] class Product { #[ORM\Id] #[ORM\GeneratedValue] #[ORM\Column] #[Groups(['product:read'])] private ?int $id = null; public function __construct( #[ORM\Column(length: 255)] #[Groups(['product:read'])] public string $name, #[ORM\Column] #[Groups(['product:read'])] public int $price, ) {} public function getId(): ?int { return $this->id; } } Ne përdorim të atribut të futur në versionet e fundit të Symfony për të hartuar hyrjen JSON automatikisht. The Controller: #[MapRequestPayload] namespace App\Controller; use App\DTO\ProductDto; use App\Entity\Product; use Doctrine\ORM\EntityManagerInterface; use Symfony\Bundle\FrameworkBundle\Controller\AbstractController; use Symfony\Component\HttpFoundation\JsonResponse; use Symfony\Component\HttpKernel\Attribute\MapRequestPayload; use Symfony\Component\Routing\Attribute\Route; #[Route('/api/v1')] class BenchmarkController extends AbstractController { #[Route('/products', methods: ['POST'])] public function create( #[MapRequestPayload] ProductDto $dto, EntityManagerInterface $em ): JsonResponse { // Simple logic to test throughput $product = new Product($dto->name, $dto->price); $em->persist($product); $em->flush(); return $this->json($product, 201, [], ['groups' => 'product:read']); } #[Route('/ping', methods: ['GET'])] public function ping(): JsonResponse { $this->counter->increment(); // Increment on each call return new JsonResponse([ 'status' => 'pong', 'timestamp' => time() ]); } } The DTO: namespace App\DTO; use Symfony\Component\Validator\Constraints as Assert; class ProductDto { public function __construct( #[Assert\NotBlank] #[Assert\Length(min: 3)] public string $name, #[Assert\Positive] public int $price, ) {} } Rezultatet e benchmark Ne kemi përdorur wrk (një mjet modern HTTP benchmarking) që funksionon në një makinë të veçantë në të njëjtën rrjet lokal për të shmangur contention CPU. Methodology: CPU 8 bërthamë, 16GB RAM Machine: 30 sekonda, 100 lidhje konkurruese. Test: /api/v1/ping (përhapja e papërpunuar) dhe /api/v1/products (interaksioni i bazës së të dhënave). Target: Nginx + PHP-FPM (8.4) Baseline: Skenari A: The “Ping” (Raw Overhead) +---------------------+----------------+---------------+---------------------+ | Server | Req/Sec | Latency (Avg) | Memory Usage | +---------------------+----------------+---------------+---------------------+ | PHP-FPM | ~2,100 | 45ms | Low (per process) | | FrankenPHP (Worker) | ~8,500 | 4ms | Moderate | | RoadRunner | ~9,200 | 3ms | Low | +---------------------+----------------+---------------+---------------------+ Të dy serverët e aplikacioneve decimojnë PHP-FPM. RoadRunner mban një avantazh të vogël në kalimin e papërpunuar për përgjigje të thjeshta JSON për shkak të komunikimit të tij shumë të optimizuar të bazuar në Go RPC. Skenari B: Database Write (Baza e të dhënave në botën reale) +-------------+---------------+----------------+------------+ | Server | Req/Sec | Latency (Avg) | Stability | +-------------+---------------+----------------+------------+ | PHP-FPM | ~850 | 110ms | Stable | | FrankenPHP | ~3,200 | 25ms | Excellent | | RoadRunner | ~3,400 | 22ms | Excellent | +-------------+---------------+----------------+------------+ Dallimi zvogëlohet kur baza e të dhënave bëhet një pengesë. megjithatë, nisja e vazhdueshme e aplikacioneve (Modi i Punës) do të thotë që Symfony nuk ri-initializon kontejnerin, metadat e Doktrinës ose dëgjuesit e ngjarjeve për çdo kërkesë. dhe ofrojnë një rritje të performancës 3x-4x mbi FPM standarde. FrankenPHP RoadRunner Skenari C: The “Number Cruncher” (CPU Bound) Ky test mat shpejtësinë e ekzekutimit të papërpunuar dhe qëndrueshmërinë e procesit të punonjësit kur CPU është e lidhur në 100%.Ne do të kryejmë një shumëzim matrix (N x N), një algoritëm klasik O(n3) që detyron motorin PHP të punojë fort pa u mbështetur në kohë pritjeje I / O. The Code (Matrix Service): namespace App\Service; class MathService { public function multiplyMatrix(int $size): array { $matrixA = $this->generateMatrix($size); $matrixB = $this->generateMatrix($size); $result = array_fill(0, $size, array_fill(0, $size, 0)); for ($i = 0; $i < $size; $i++) { for ($j = 0; $j < $size; $j++) { for ($k = 0; $k < $size; $k++) { $result[$i][$j] += $matrixA[$i][$k] * $matrixB[$k][$j]; } } } return $result; } private function generateMatrix(int $size): array { $matrix = []; for ($i = 0; $i < $size; $i++) { for ($j = 0; $j < $size; $j++) { $matrix[$i][$j] = rand(1, 100); } } return $matrix; } } The Controller: namespace App\Controller; use App\Service\MathService; use Symfony\Bundle\FrameworkBundle\Controller\AbstractController; use Symfony\Component\HttpFoundation\JsonResponse; use Symfony\Component\Routing\Attribute\Route; #[Route('/api/v1')] class MathController extends AbstractController { #[Route('/math/matrix/{size}', requirements: ['size' => '\d+'], methods: ['GET'])] public function matrix(int $size, MathService $service): JsonResponse { // $size = 100 creates 1,000,000 iterations. $start = microtime(true); $service->multiplyMatrix($size); $duration = microtime(true) - $start; return $this->json([ 'size' => $size, 'duration_ms' => $duration * 1000, 'memory_peak' => memory_get_peak_usage(true) ]); } } Results (Matrix Size: 150x150, 50 Concurrent Users): +--------------+---------------------+----------------+----------------------+ | Server | Avg Response Time | Std. Deviation | Throughput (Req/Sec) | +--------------+---------------------+----------------+----------------------+ | PHP-FPM | 210ms | 15ms | ~450 | +--------------+---------------------+----------------+----------------------+ | FrankenPHP | 205ms | 45ms | ~465 | +--------------+---------------------+----------------+----------------------+ | RoadRunner | 208ms | 8ms | ~460 | +--------------+---------------------+----------------+----------------------+ Të tre punojnë pothuajse në mënyrë identike.Kjo pritet sepse pengesa në shishe këtu është Zend Engine (PHP vetë), jo serveri i uebit. RoadRunner tregoi devijim të konsiderueshëm më të ulët standard (jitter). izolimi i procesit të tij (përmes binareve të ndara të punonjësve të lidhura me tubacionet) duket të trajtojë contention CPU pak më të parashikueshme se modeli i frenuar i FrankenPHP nën ngarkesë të rëndë, ku rutina Go dhe fije C konkurrojnë për të njëjtat faza kohore të CPU. Skenari D: “Rrjedha e madhe e të dhënave” (I/O & Memory Bound) Kjo është “Worker Killer.”Në një mjedis të gjatë të punonjësve, ruajtja e një skedari të madh në kujtesë është fatale.Ne duhet të testojmë aftësitë e transmetimit.Ne do të gjenerojmë një raport CSV me 100,000 rreshta në fluturim dhe do ta transmetojmë atë në klient. The Code (Streaming Response): namespace App\Controller; use Symfony\Bundle\FrameworkBundle\Controller\AbstractController; use Symfony\Component\HttpFoundation\StreamedResponse; use Symfony\Component\Routing\Attribute\Route; #[Route('/api/v1')] class ReportController extends AbstractController { #[Route('/report/stream', methods: ['GET'])] public function streamBigReport(): StreamedResponse { $response = new StreamedResponse(function () { $handle = fopen('php://output', 'w+'); fputcsv($handle, ['ID', 'Name', 'Email', 'Status', 'Created_At']); // Simulate 100k rows for ($i = 0; $i < 100_000; $i++) { fputcsv($handle, [ $i, "User $i", "user$i@example.com", $i % 2 === 0 ? 'Active' : 'Inactive', date('Y-m-d H:i:s') ]); // Crucial: Flush buffer to prevent memory explosion if ($i % 1000 === 0) { flush(); } } fclose($handle); }); $response->headers->set('Content-Type', 'text/csv'); $response->headers->set('Content-Disposition', 'attachment; filename="big_report.csv"_report.csv"'); // RoadRunner/FrankenPHP specific header to disable internal buffering if needed $response->headers->set('X-Accel-Buffering', 'no'); return $response; } } Results (Downloading 50MB CSVs): +------------+---------------------------+---------------------------+--------------+ | Server | Time to First Byte (TTFB) | Max Memory Usage (Worker) | Success Rate | +------------+---------------------------+---------------------------+--------------+ | PHP-FPM | 30ms | 4MB | 100% | | FrankenPHP | 5ms | 6MB | 100% | | RoadRunner | 12ms | 4MB | 100% | +------------+---------------------------+---------------------------+--------------+ FrankenPHP: Fiton në TTFB (Time To First Byte). Për shkak se FrankenPHP fut PHP direkt, echo / fwrite output shkon pothuajse menjëherë në socket rrjetit menaxhuar nga Caddy. RoadRunner: Kërkon respektimin e rreptë të kontratave të transmetimit. Të dhënat udhëtojnë nga PHP Worker -> Relay (Pipes/Socket) -> RoadRunner (Go) -> Client. Ndërsa jashtëzakonisht i shpejtë, ka një mbipeshë të vogël teorike në krahasim me qasjen e ndarë të kujtesës të FrankenPHP. Memoria: Të dy serverët e mbajtën me sukses kujtesën e sheshtë (~4-6MB) sepse ne përdorëm StreamedResponse.Nëse do ta kishim bufferuar këtë zinxhir në një variabël, të dy punonjësit do të kishin rrëzuar ose ndaluar për grumbullimin e mbeturinave, duke vrarë kalimin. Skenari E: “Pixel Cruncher” (përpunimi i imazhit) Ngarkoni një imazh 4K (3840x2160), ndryshoni madhësinë në 800x600, aplikoni një filtër në shkallë gri dhe ktheni të dhënat binare. Ne kemi nevojë për librarisë, një abstraksion standard për në PHP. imagine/imagine GD/Imagick The Code (Image Service): namespace App\Service; use Imagine\Gd\Imagine; use Imagine\Image\Box; class ImageProcessor { private Imagine $imagine; public function __construct() { // We use the GD driver as it is strictly CPU-bound and blocking $this->imagine = new Imagine(); } public function process(string $imagePath): string { $image = $this->imagine->open($imagePath); // Resize and apply effects (CPU Intensive) $image->resize(new Box(800, 600)); $image->effects()->grayscale(); // Return binary string (Memory Intensive) return $image->get('jpeg', ['quality' => 80]); } } The Controller: namespace App\Controller; use App\Service\ImageProcessor; use Symfony\Bundle\FrameworkBundle\Controller\AbstractController; use Symfony\Component\HttpFoundation\File\UploadedFile; use Symfony\Component\HttpFoundation\Request; use Symfony\Component\HttpFoundation\Response; use Symfony\Component\Routing\Attribute\Route; #[Route('/api/v1')] class MediaController extends AbstractController { #[Route('/media/process', methods: ['POST'])] public function process(Request $request, ImageProcessor $processor): Response { /** @var UploadedFile $file */ $file = $request->files->get('image'); if (!$file) { return new Response('No image provided', 400); } $processedImage = $processor->process($file->getPathname()); return new Response($processedImage, 200, [ 'Content-Type' => 'image/jpeg', // Prevent caching for benchmark accuracy 'Cache-Control' => 'no-cache, no-store, must-revalidate', ]); } } Benchmark Configuration: Hyrje: 5MB JPEG (High-Res 4K) Konkurrenca: 20 përdorues të njëkohshëm (simulimi i një shpërthimi të ngarkimeve). Kohëzgjatja: 60 sekonda Worker Pool Limit: Të dy serverët janë të kufizuar në 8 punëtorë për të simuluar kufizimin e burimeve. +-------------+-------------------+-------------------------+----------------------+----------+ | Server | Avg Response Time | 99th Percentile Latency | Throughput (Req/Sec) | Failures | +-------------+-------------------+-------------------------+----------------------+----------+ | PHP-FPM | 450ms | 1.2s | ~42 | 0 | | FrankenPHP | 430ms | 950ms | ~48 | 0 | | RoadRunner | 435ms | 880ms | ~47 | 0 | +-------------+-------------------+-------------------------+----------------------+----------+ Nëse përdorni FPM, RoadRunner, ose FrankenPHP, një bërthamë CPU është 100% e zënë për ~400ms për kërkesë. Concurrency Management (The Real Difference): PHP-FPM: Spawns proceset derisa pm.max_children është arritur. Nëse kufiri është goditur, buffer NGINX mbush, përfundimisht duke çuar në gabime 502 në qoftë se kohëzgjatja është arritur. RoadRunner: Ka një grup të caktuar të punonjësve. Nëse 8 kërkesa janë duke u përpunuar, kërkesa e nëntë pret në radhën e prioritetit të brendshëm të RoadRunner (shkruar në Go). Kjo radhë është shumë efikase. FrankenPHP: I ngjashëm me RoadRunner, por përdor menaxhimin e lidhjes së Caddy. ajo trajtoi shpërthimin pak më shpejt në kalimin e papërpunuar, ndoshta për shkak të mbivendosjes më të ulët në kalimin e përshkrimit të skedarit në krahasim me tuba RPC të RoadRunner. Skenari F: Testimi i nisjes së "kornizave të rënda" (Serializimi) Në “Modin e Punëtorit” kerneli fillon një herë. megjithatë, koha e ekzekutimit ende duhet të trajtojë pastrimet specifike të kërkesës dhe serializimin e rëndë të objektit. Ky test mat mbivendosjen e serializimit të grafikave komplekse të objektit – një pengesë e zakonshme në aplikacionet Symfony duke përdorur Platformën API ose koleksionet e gjera të Doktrinës. Ne do të serializojmë një koleksion prej 50 entiteteve të Urdhrit, secila prej të cilave përmban dhe Kjo thekson serializuesin dhe menaxherin e kujtesës. OrderItems Product The Code: namespace App\Entity; use App\Repository\OrderRepository; use Doctrine\Common\Collections\ArrayCollection; use Doctrine\Common\Collections\Collection; use Doctrine\ORM\Mapping as ORM; use Symfony\Component\Serializer\Attribute\Groups; #[ORM\Entity(repositoryClass: OrderRepository::class)] #[ORM\Table(name: 'orders')] class Order { #[ORM\Id, ORM\GeneratedValue, ORM\Column] #[Groups(['order:read'])] private ?int $id = null; #[ORM\OneToMany(targetEntity: OrderItem::class, mappedBy: 'orderRef', cascade: ['persist', 'remove'])] #[Groups(['order:read'])] public Collection $items; public function __construct() { $this->items = new ArrayCollection(); } public function getId(): ?int { return $this->id; } public function getItems(): Collection { return $this->items; } public function addItem(OrderItem $item): self { if (!$this->items->contains($item)) { $this->items[] = $item; $item->orderRef = $this; } return $this; } } The Controller: namespace App\Controller; use App\Repository\OrderRepository; use Symfony\Bundle\FrameworkBundle\Controller\AbstractController; use Symfony\Component\HttpFoundation\JsonResponse; use Symfony\Component\Routing\Attribute\Route; #[Route('/api/v1')] class HeavyController extends AbstractController { #[Route('/heavy/orders', methods: ['GET'])] public function list(OrderRepository $repo): JsonResponse { // Assume database is seeded with 50 complex orders $orders = $repo->findAll(); return $this->json($orders, 200, [], ['groups' => 'order:read']); } } Results (100 Concurrent Users): +----------------------+--------------------+----------------------+----------------+ | Metric | NGINX + FPM | FrankenPHP (Worker) | RoadRunner | +----------------------+--------------------+----------------------+----------------+ | Throughput (req/sec) | ~180 | ~420 | ~405 | | Memory per Worker | Low (Reset/req) | High (Accumulates) | Stable | | GC Overhead | Negligible | Moderate | Low | +----------------------+--------------------+----------------------+----------------+ Tregohet një kërcim masiv mbi FPM (2.3x) sepse Metadata e Doktrinës dhe Serializer ClassMetadata janë tashmë në kujtesë. Ajo e përjashton RoadRunner pak për shkak të mungesës së "CGO" (C-Go) në krye; FrankenPHP kalon drejtuesin direkt në motorin e integruar PHP. FrankenPHP: : Shumë i qëndrueshëm. Ndërsa pak më i ngadalshëm se FrankenPHP këtu, gjurma e kujtesës ishte më e sheshtë. shpërbërja sugjeron se kalimi i ngarkesave të mëdha JSON mbi tubacionet RPC (Standard Streams / TCP) kryen një ndëshkim të vogël serializimi që FrankenPHP shmanget. RoadRunner Skenari G: Testi i stresit “Keep-Alive” dhe Memory Leak Skenarët e PHP që funksionojnë gjatë rrjedhin kujtesën. Është një fakt i jetës. Të dy serverët kanë mekanizma për të vrarë dhe zëvendësuar punonjësit (TTL/Max Requests). Ne testojmë se sa “graceful” është ky riciklim. The “Leaky” Code: namespace App\Controller; use Symfony\Component\HttpFoundation\JsonResponse; use Symfony\Component\Routing\Attribute\Route; class LeakController { // Intentional static leak private static array $buffer = []; #[Route('/api/v1/leak', methods: ['GET'])] public function leak(): JsonResponse { // Leak 1MB per request self::$buffer[] = str_repeat('A', 1024 * 1024); return new JsonResponse(['memory' => memory_get_usage(true)]); } } Configuration (Restart every 50 requests): Pjesëmarrësit: pool.max_jobs: 50 FrankenPHP: FRANKENPHP_CONFIG=”punëtor ./public/index.php 16 50" Results (Sustained Load): +------------------------+-------------+--------------+ | Metric | RoadRunner | FrankenPHP | +------------------------+-------------+--------------+ | Restart Latency Spike | ~15ms | ~40ms | | Memory Reclamation | Instant | Instant | | Consistency | Smooth | Slight Jitter| +------------------------+-------------+--------------+ RoadRunner: Menaxheri i procesit spiral / roadrunner është jashtëzakonisht i pjekur. Ai kryen "reset të butë" - ai rrotullon një punëtor të ri para se të vrasë të vjetrin (sipërfaqen).Kjo rezulton në pikat pothuajse të padukshme të vonesës për përdoruesin. FrankenPHP: Gjithashtu menaxhon rifillimet mirë, por ne vërejmë një "jitter" pak më të lartë (variancë) kur disa fusha vendosën të rifillojnë në të njëjtën kohë. Konkludimi Beteja midis FrankenPHP dhe RoadRunner në ekosistemin Symfony 8 nuk ka të bëjë me “të shpejtë vs. të ngadalshëm” – të dyja janë tepër të shpejta. Çështja për FrankenPHP Më i mirë Për: Apps moderne “Cloud-Native”, zhvillues që duan Simplicity dhe projekte që kanë nevojë për HTTP/3 / Hints e hershme. Duke qenë në gjendje të dërgojë një imazh Docker që përmban Web Server (Caddy) dhe App Server (PHP) është një ëndërr e vendosjes. Performanca: Transporti i papërpunuar pak më i lartë në ngarkesa të vogla të dobishme për shkak të arkitekturës së integruar. “Modern Standard.” ndoshta do të bëhet default për konfigurimet e Symfony Docker. Fjalë kyçe RoadRunner Më i mirë Për: Microservices Enterprise, Sisteme me trafik të lartë që kërkojnë SLA të rrepta dhe përpunim të rëndë të sfondit. Nëse keni nevojë për një server gRPC, një konsumator Kafka, një dyqan të shpërndarë Key-Value dhe një eksportues Metrics të gjitha në një binar, RoadRunner është i pakrahasueshëm. Stabiliteti: Menaxheri i procesit është i ashpër në betejë. Zgjedhja "Industrial Grade".Nëse jeni duke ndërtuar një API bankare ose një sistem të radhës me kalim të lartë, zgjidhni RoadRunner. Filloni me Ajo ul pengesën e hyrjes për PHP me performancë të lartë. nëse keni nevojë për veçoritë specifike të avancuara (RPC/Queues) ose nëse hasni raste të kufijve në konfigurimin e Caddy. FrankenPHP RoadRunner Ju mund të gjeni implementimin e plotë dhe të ndiqni progresin e projektit në GitHub: [ ] Source Code: https://github.com/mattleads/FrankenVSRoadRunner https://github.com/mattleads/FrankenVSRoadRunner Let’s Connect! Nëse e keni gjetur këtë të dobishme ose keni pyetje në lidhje me zbatimin, do të doja të dëgjoja nga ju. LinkedIn: [https://www.linkedin.com/in/matthew-mochalkin/] X (Twitter): [https://x.com/MattLeads] Shërbimi: [https://t.me/MattLeads] GitHub: [https://github.com/mattleads] https://www.linkedin.com/in/matthew-mochalkin/ https://x.com/MattLeads https://t.me/MattLeads https://github.com/mattleads