„Symfony 8“ PHP 8.4 versijoje: „FrankenPHP“ prieš „RoadRunner“

„Symfony 7.4 LTS“ išleidimas žymi svarbų momentą PHP ekosistemoje. Nors pati sistema pristato tvirtas funkcijas, tokias kaip griežtesnis tipo saugumas ir natūralus PHP serializavimas konteineriams, tikroji revoliucija vyksta, kaip mes aptarnaujame šias programas. Programų serveriai, parašyti „Go“, yra subrendę, siūlydami „Darbo režimo“ galimybes, kurios vieną kartą paleidžia jūsų branduolį ir išlaiko jį atmintyje, sumažindamos vėlavimą ir didindamos našumą. NGINX + PHP-FPM Šiame straipsnyje mes įdėjome du sunkiuosius svorius vienas prieš kitą: (Šiuolaikinis iššūkis, pastatytas ant Caddy) ir Mes įgyvendinsime abu „Symfony 8“ programą, veikiančią PHP 8.4, palyginsime jų architektūras ir išanalizuosime jų našumą. FrankenPHP RoadRunner Konkurentai Franšizė Pastatytas ant „Caddy“ interneto serverio, Tai sudaro PHP tiesiogiai į dvejetainį (arba naudoja konkrečią statybą) ir pasinaudoja Caddy automatiniu ir Palaikymas . FrankenPHP HTTPS HTTP/3 Jis sugriauna NGINX, PHP-FPM ir SSL terminatorių į vieną dvejetainį. Key Advantage: Pagrindinis palaikymas per „Runtime“ komponentą su „Symfony 7.4+“. Keliautojai Sukurtas Spiral Scout, RoadRunner yra aukštos kokybės PHP taikomųjų programų serveris, apkrovos balansorius ir procesų vadybininkas. Pavyzdžiui, turtingas ir efektyvus šlapimo takų šalinimas ( , , Tai giliai integruojasi su simfonija. Key Advantage: gRPC Queues KV storage Puiki integracija per „runtime/roadrunner-symfony-nyholm“. Benchmark kodas (Symfony 8 ir PHP 8.4) Kad palyginimas būtų sąžiningas, mes sukursime lengvą API galinius taškus, kurie sąveikauja su duomenų baze.Tai išbandys ne tik žalią „Hello World“ greitį, bet ir duomenų bazės ryšių ir serializavimo viršūnę nuolatinėje darbuotojo aplinkoje. Mes naudojame „PHP 8.4 Property Hooks“ (jei yra jūsų kūrinyje) arba standartines įvestas savybes. Dėl plataus suderinamumo šiame vadove mes naudojame standartines 8.3+ reklamuojamas savybes su atributais. 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; } } Mes naudojame Naujosiose „Symfony“ versijose įdiegtas atributas automatiškai išmatuoja JSON įvestį. 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, ) {} } Benchmark rezultatai Mes naudojome wrk (modernų HTTP lyginamąjį įrankį), kuris veikia atskiroje mašinoje tame pačiame vietiniame tinkle, kad būtų išvengta CPU ginčų. Methodology: 8 branduolių procesorius, 16 GB RAM. Machine: 30 sekundžių, 100 konkurentų ryšių. Test: /api/v1/ping (žaliasis pralaidumas) ir /api/v1/produktai (duomenų bazės sąveika) Target: NGINX ir PHP FPM (8.4) Baseline: Scenarijus A: „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 | +---------------------+----------------+---------------+---------------------+ Abu taikomųjų programų serveriai dešimtuoja PHP-FPM. „RoadRunner“ turi nedidelį pranašumą dėl paprastų JSON atsakymų dėl savo labai optimizuotos „Go“ pagrįstos RPC komunikacijos. Scenarijus B: Duomenų bazės rašymas (realiame pasaulyje) +-------------+---------------+----------------+------------+ | Server | Req/Sec | Latency (Avg) | Stability | +-------------+---------------+----------------+------------+ | PHP-FPM | ~850 | 110ms | Stable | | FrankenPHP | ~3,200 | 25ms | Excellent | | RoadRunner | ~3,400 | 22ms | Excellent | +-------------+---------------+----------------+------------+ Tačiau nuolatinis programų paleidimas (Darbo režimas) reiškia, kad „Symfony“ neatsinaujina konteinerio, „Doctrine“ metaduomenų ar įvykių klausytojų kiekvienam prašymui. ir siūlo 3x-4x našumo padidėjimą, palyginti su standartiniu FPM. FrankenPHP RoadRunner C scenarijus: „Number Cruncher“ (CPU Bound) Šis testas matuoja neapdoroto vykdymo greitį ir darbuotojo proceso stabilumą, kai procesorius yra 100%. mes atliksime matricos dauginimą (N x N), klasikinis O(n3) algoritmas, kuris verčia PHP variklį dirbti sunkiai, nepriklausomai nuo I / O laukimo laiko. 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 | +--------------+---------------------+----------------+----------------------+ Visi trys veikia beveik identiškai.Tai tikimasi, nes buteliukas čia yra „Zend Engine“ (pats PHP), o ne žiniatinklio serveris. RoadRunner parodė žymiai mažesnį standartinį nukrypimą (jitter). jo proceso izoliacija (per atskirus darbininkų dvejetainius junginius, sujungtus vamzdžiais) atrodo šiek tiek labiau nuspėjamai tvarkyti CPU suvaržymus nei FrankenPHP siūlinis modelis esant sunkiam apkrovimui, kur Go rutinos ir C siūlai konkuruoja dėl tų pačių CPU laiko juostų. D scenarijus: „Didelis duomenų srautas“ (I/O ir atmintis) Tai yra „darbuotojo žudikas“. Ilgai veikiančioje darbuotojo aplinkoje didelio failo buferiavimas į atmintį yra mirtinas. Turime išbandyti srautinio srauto galimybes. Mes sukursime 100 000 eilutės CSV ataskaitą ant skrydžio ir perduosime ją klientui. 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: Laimi ant TTFB (Laikas iki pirmojo byto). Kadangi FrankenPHP tiesiogiai įterpia PHP, echo / rašyti išvestis beveik akimirksniu patenka į Caddy valdomą tinklo lizdą. RoadRunner: Reikia griežtai laikytis srautinio srauto sutarčių. Duomenys keliauja iš PHP Worker -> Relay (Pipes/Socket) -> RoadRunner (Go) -> Klientas. Atmintis: abu serveriai sėkmingai išlaikė atmintį plokščia (~4–6 MB), nes mes naudojome StreamedResponse. Scenarijus E: „Pixel Cruncher“ (vaizdo apdorojimas) Įkelkite 4K vaizdą (3840x2160), pakeiskite jį iki 800x600, taikykite pilkos spalvos filtrą ir grąžinkite dvejetainius duomenis. Mums reikia biblioteka, standartinė abstrakcija ir 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: Įvadas: 5 MB JPEG (High-Res 4K) Konkurencija: 20 vienalaikių vartotojų (simuliuojant įkėlimo protrūkį). Trukmė: 60 sekundžių Darbuotojų baseino apribojimas: abu serveriai ribojami iki 8 darbuotojų, kad būtų imituojamas išteklių apribojimas. +-------------+-------------------+-------------------------+----------------------+----------+ | 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 | +-------------+-------------------+-------------------------+----------------------+----------+ Nepriklausomai nuo to, ar naudojate FPM, RoadRunner, ar FrankenPHP, vienas CPU branduolys yra 100% užimtas ~ 400ms už prašymą. Concurrency Management (The Real Difference): PHP-FPM: Spawns procesus, kol pm.max_children pasiekiamas. Jei riba pasiekiama, NGINX buferis užpildo, galiausiai sukelia 502 klaidas, jei pasiekiamas laiko tarpas. RoadRunner: turi fiksuotą darbuotojų grupę. Jei 8 prašymai yra apdorojami, 9-asis prašymas laukia RoadRunner vidinėje prioriteto eilėje (rašyta Go). Ši eilė yra labai efektyvi. FrankenPHP: Panašus į "RoadRunner", bet naudoja "Caddy" ryšio tvarkymą.Jis šiek tiek greičiau susidorojo su žaliava, tikriausiai dėl mažesnio failų aprašymo perdavimo, palyginti su "RoadRunner" RPC vamzdžiais. Scenarijus F: „Sunkiojo rėmo“ paleidimo testas (serializavimas) „Darbuotojo režime“ branduolys paleidžiamas vieną kartą. Tačiau paleidimo metu vis dar reikia tvarkyti užklausos specifinius valymus ir sunkią objektų serializavimą.Šis testas įvertina sudėtingų objektų grafikų serializavimo pranašumą – įprastą „Symfony“ programų, naudojančių API Platformą ar dideles Doktrinos kolekcijas, buteliukų spragą. Mes serializuosime 50 užsakymų vienetų kolekciją, kurių kiekvienoje yra įdėta ir Tai pabrėžia serializatorių ir atminties tvarkyklę. 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 | +----------------------+--------------------+----------------------+----------------+ Parodo didžiulį šuolį virš FPM (2.3x), nes Doctrine Metadata ir Serializer ClassMetadata jau yra atmintyje. FrankenPHP: : Labai stabilus. Nors šiek tiek lėtesnis nei FrankenPHP čia, jo atminties pėdsakas buvo plonesnis. Suskaidymas rodo, kad didelių JSON naudingųjų apkrovų perdavimas per RPC vamzdžius (standartiniai srautai / TCP) patiria nedidelę serializavimo bausmę, kurią FrankenPHP vengia. RoadRunner Scenarijus G: „Keep-Alive“ ir atminties nutekėjimo streso testas Ilgai veikiantys PHP scenarijai išsklaido atmintį. Tai gyvenimo faktas. Abu serveriai turi mechanizmus, kad nužudytų ir pakeistų darbuotojus (TTL / Max Requests). Mes išbandome, kaip „gražu“ yra šis perdirbimas. 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): Darbo vietų skaičius: max_jobs: 50 FRANKENPHP: FRANKENPHP_CONFIG=“darbuotojas ./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: spiralės/roadrunner proceso vadybininkas yra neįtikėtinai subrendęs. Jis atlieka „minkštus atstatymus“ – jis sukasi į naują darbuotoją prieš nužudydamas senąjį (susidaro). FrankenPHP: Taip pat gerai tvarko restartus, tačiau mes pastebėjome šiek tiek didesnį „jitter“ (variansą), kai keletas siūlių nusprendė iš naujo paleisti vienu metu. Išvada „FrankenPHP“ ir „RoadRunner“ mūšis „Symfony 8“ ekosistemoje nėra apie „greitą prieš lėtai“ – abu yra neįtikėtinai greiti. „FrankenPHP“ atvejis Geriausia: šiuolaikinės „Cloud-Native“ programos, kūrėjai, norintys paprastumo ir projektų, kuriems reikia HTTP/3 / ankstyvųjų patarimų. Gebėjimas siųsti vieną Docker vaizdą, kuriame yra žiniatinklio serveris (Caddy) ir programų serveris (PHP), yra diegimo svajonė. Veiksmingumas: šiek tiek didesnis žaliavinis pralaidumas mažose naudingosiose apkrovose dėl įmontuotos architektūros. „Šiuolaikinis standartas.“ Tikėtina, kad jis taps numatytu „Symfony Docker“ nustatymu. Pranešimas apie RoadRunner Geriausia įmonėms: Microservices, didelio srauto sistemos, reikalaujančios griežtų SLA ir sunkios fono apdorojimo. Jei jums reikia gRPC serverio, „Kafka“ vartotojo, paskirstytos „Key-Value“ parduotuvės ir „Metrics“ eksportuotojo, viskas viename binary, „RoadRunner“ yra neprilygstama. Stabilumas: jo proceso vadybininkas yra kovinis. Jei kuriate bankininkystės API arba didelio našumo eilės sistemą, pasirinkite RoadRunner. Pradėkite nuo Jis sumažina kliūtį įvesti aukštos kokybės PHP. jei jums reikia konkrečių pažangių funkcijų (RPC / eilutės) arba jei Caddy konfigūracijoje susiduriate su krašto atvejais. FrankenPHP RoadRunner Galite rasti visą įgyvendinimą ir sekti projekto pažangą GitHub: [ ] Source Code: https://github.com/mattleads/FrankenVSRoadRunner https://github.com/mattleads/FrankenVSRoadRunner Let’s Connect! Jei jums tai padėjo arba turite klausimų apie įgyvendinimą, norėčiau išgirsti iš jūsų. Linkedin: [https://www.linkedin.com/in/matthew-mochalkin/] Šaltinis (Twitter): [https://x.com/MattLeads] Telegramas: [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