Paano i-optimize ang PHP Laravel Web Application para sa Mataas na Pagganap?

Maraming bagay si Laravel. Ngunit ang mabilis ay hindi isa sa kanila. Alamin natin ang ilang mga trick ng kalakalan upang mapabilis ito!


Walang nag-develop na PHP na hindi nasasaktan Laravel sa mga araw na ito. Sila ay alinman sa isang developer ng junior o mid-level na gustong-gusto ang mabilis na pag-unlad na inaalok ng Laravel, o sila ay isang senior developer na pinipilit na malaman si Laravel dahil sa mga pressure sa merkado..

Alinmang paraan, walang pagtanggi na muling binuhay ni Laravel ang ekosistema ng PHP (ako, sigurado, ay iiwan ko ang mundo ng PHP kung wala si Laravel).

Isang snippet ng (medyo nabigyang-katwiran) na papuri sa sarili mula kay Laravel

Gayunpaman, dahil ang Laravel ay yumuko paatras upang gawing madali para sa iyo, nangangahulugan ito na sa ilalim nito ay gumagawa ng mga tonelada at toneladang trabaho upang matiyak na mayroon kang isang komportableng buhay bilang isang nag-develop. Ang lahat ng mga “mahiwagang” tampok ng Laravel na tila gumagana ay may mga layer sa mga layer ng code na kailangang ma-whipped up sa bawat oras na tumatakbo ang isang tampok. Kahit na isang simpleng pagsubaybay sa kung gaano kalalim ang butas ng kuneho (pansinin kung saan nagsisimula ang pagkakamali, hanggang sa pangunahing kernel):

Para sa kung ano ang tila isang error sa compilation sa isa sa mga tanawin, mayroong 18 mga tawag na function upang masubaybayan. Ako ay personal na nakatagpo ng 40, at madali itong higit kung gumagamit ka ng iba pang mga aklatan at plugin.

Ang point pagiging, sa pamamagitan ng default na mga layer na ito sa mga layer ng code, ay naging mabagal ang Laravel.

Gaano kabagal ang Laravel?

Matapat, imposible na sagutin ang tanong na ito sa maraming kadahilanan.

Una, walang tinatanggap, layunin, makatuwirang pamantayan para sa pagsukat ng bilis ng Web apps. Mas mabilis o mabagal kumpara sa kung ano? Sa ilalim ng anong mga kondisyon?

Pangalawa, Ang isang Web app ay nakasalalay sa napakaraming bagay (database, filesystem, network, cache, atbp.) na malinaw na tahimik na pag-usapan ang bilis. Ang isang napakabilis na Web app na may napakabagal na database ay isang napakabagal na web app. ��

Ngunit ang kawalan ng katiyakan na ito ay tiyak kung bakit popular ang mga benchmark. Kahit na wala silang ibig sabihin (tingnan ito at ito), nagbibigay sila ng ilang mga frame ng sanggunian at makakatulong sa amin mula sa galit na galit. Samakatuwid, sa ilang mga pinch ng asin na handa na, hayaan ang isang mali, magaspang na ideya ng bilis ng mga PHP frameworks.

Pagpunta sa pamamagitan ng ito ay kagalang-galang GitHub pinagmulan, narito kung paano ang linya ng PHP frameworks kapag inihambing:

Maaaring hindi mo rin napansin si Laravel dito (kahit na masidhi kang tunay na mahirap) maliban kung itapon mo ang iyong kaso nang tama sa dulo ng buntot. Oo, mahal na mga kaibigan, huling darating si Laravel! Ngayon, ipinagkaloob, ang karamihan sa mga “frameworks” na ito ay hindi masyadong praktikal o kahit na kapaki-pakinabang, ngunit sinasabi nito sa amin kung paano ang tamad na Laravel kung ihahambing sa iba pang mga mas sikat.

Karaniwan, ang “pagka-antar” na ito ay hindi nagtatampok sa mga application dahil bihira ang aming pang-araw-araw na web app na bihirang matumbok ang mga mataas na numero. Ngunit sa sandaling gawin nila (sabihin, pataas ng 200-500 concurrency), ang mga server ay nagsisimulang mabulabog at mamatay. Ito ang oras na kahit na ibinabato pa ang mas maraming hardware sa problema ay hindi gupitin ito, at mabilis na umakyat ang mga panukalang-batas na imprastraktura na ang iyong mataas na ideals ng cloud computing ay bumagsak.

Ngunit hey, magsaya! Ang artikulong ito ay hindi tungkol sa kung ano ang hindi magagawa, ngunit tungkol sa kung ano ang magagawa. ��

Magandang balita ay, marami kang magagawa upang mas mabilis ang iyong Laravel app. Maraming beses na mabilis. Oo, walang kidding. Maaari kang gumawa ng parehong codebase go ballistic at makatipid ng ilang daang dolyar sa imprastraktura / pag-host ng mga bayarin bawat buwan. Paano? Hayaan mo na.

Apat na uri ng pag-optimize

Sa palagay ko, ang pag-optimize ay maaaring gawin sa apat na natatanging antas (pagdating sa mga aplikasyon ng PHP, iyon ay):

  1. Antas ng Wika: Nangangahulugan ito na gumamit ka ng isang mas mabilis na bersyon ng wika at maiwasan ang mga tukoy na tampok / estilo ng coding sa wika na nagpapabagal sa iyong code.
  2. Antas ng Framework: Ito ang mga bagay na tatalakayin natin sa artikulong ito.
  3. Antas ng imprastraktura: Pag-tun sa iyong manager ng proseso ng PHP, web server, database, atbp.
  4. Antas ng Hardware: Ang paglipat sa isang mas mahusay, mas mabilis, mas malakas na provider ng hosting ng hardware.

Ang lahat ng mga uri ng mga pag-optimize na ito ay may kanilang lugar (halimbawa, ang pag-optimize ng php-fpm ay medyo kritikal at malakas). Ngunit ang pokus ng artikulong ito ay magiging mga pag-optimize ng uri ng 2: mga nauugnay sa balangkas.

Sa pamamagitan ng paraan, walang katwiran sa likod ng pag-numero, at hindi ito tinanggap na pamantayan. Ginagawa ko lang ito. Mangyaring huwag hilingin sa akin at sabihin, “Kailangan namin ang uri-3 pag-optimize sa aming server,” o ang pinuno ng iyong koponan ay papatayin ka, hanapin ako, at pagkatapos ay papatayin mo rin ako. ��

At ngayon, sa wakas, nakarating kami sa ipinangakong lupain.

Magkaroon ng kamalayan ng mga query sa database n + 1

Ang problema sa query sa n + 1 ay isang pangkaraniwan kapag ginagamit ang mga ORM. Ang Laravel ay may malakas na ORM na tinatawag na Magaling, na napakaganda, maginhawa, na madalas nating kalimutan na tingnan kung ano ang nangyayari.

Isaalang-alang ang isang pangkaraniwang senaryo: ipinapakita ang listahan ng lahat ng mga order na inilagay ng isang listahan ng mga customer. Ito ay medyo pangkaraniwan sa mga sistema ng e-commerce at anumang mga interface ng pag-uulat sa pangkalahatan kung saan kailangan nating ipakita ang lahat ng mga nilalang na nauugnay sa ilang mga nilalang.

Sa Laravel, maaari nating isipin ang isang function ng controller na gumagawa ng trabaho tulad nito:

ang OrdenController ng klase ay nagpapalawak ng Controller
{
// …

pampublikong pag-andar makakuhaAllByCustomers (Humiling ng $ kahilingan, hanay ng mga $ id) {
$ customer = Customer :: findMany ($ ids);
$ order = mangolekta (); // bagong koleksyon

unahan ($ customer bilang $ customer) {
$ order = $ order->pagsamahin ($ customer->mga order);
}

bumalik view (‘admin.reports.order’, [‘mga order’ => $ order]);
}
}

Matamis! At mas mahalaga, matikas, maganda. ����

Sa kasamaang palad, ito ay isang nakapipinsalang paraan upang magsulat ng code sa Laravel.

Narito kung bakit.

Kapag hiniling namin sa ORM na hanapin ang ibinigay na mga customer, ang isang query sa SQL tulad nito ay nabuo:

PUMILI * MULA SA mga customer na SAAN id IN (22, 45, 34,..);

Alin ang eksaktong inaasahan. Bilang isang resulta, ang lahat ng mga nagbalik na hilera ay naka-imbak sa koleksyon ng mga customer ng koleksyon sa loob ng function ng controller.

Ngayon ay nag-iikot kami sa bawat customer nang paisa-isa at nakuha ang kanilang mga order. Ginagawa nito ang sumusunod na query . . .

PUMILI * MULA SA mga order SAAN customer_id = 22;

. . . ng maraming beses na mayroong mga customer.

Sa madaling salita, kung kailangan nating makuha ang data ng order para sa 1000 mga customer, ang kabuuang bilang ng mga query sa database na naisagawa ay 1 (para sa pagkuha ng lahat ng data ng mga customer) + 1000 (para sa pagkuha ng data ng order para sa bawat customer) = 1001. kung saan nagmula ang pangalang n + 1.

Maaari ba tayong gumawa ng mas mahusay? Tiyak! Sa pamamagitan ng paggamit ng kilala bilang sabik na pag-load, maaari nating pilitin ang ORM na magsagawa ng isang SUMALI at ibalik ang lahat ng kinakailangang data sa isang solong query! Ganito:

$ order = Customer :: findMany ($ ids)->may (‘mga order’)->makuha ();

Ang nagresultang istraktura ng data ay isang nested, sigurado, ngunit ang data ng order ay madaling makuha. Ang nagresultang solong query, sa kasong ito, ay tulad nito:

PUMILI * MULA SA mga customer INNER SUMALI na mga order sa mga customer.id = order.customer_id SAAN mga customer.id IN (22, 45,..);

Ang isang solong query ay, siyempre, mas mahusay kaysa sa isang libong dagdag na mga query. Isipin kung ano ang mangyayari kung mayroong 10,000 mga customer upang maproseso! O ipinagbawal ng Diyos kung nais din nating ipakita ang mga item na nilalaman sa bawat pagkakasunud-sunod! Tandaan, ang pangalan ng pamamaraan ay sabik na mag-load, at halos palaging magandang ideya ito.

Cache ang pagsasaayos!

Ang isa sa mga kadahilanan para sa kakayahang umangkop ng Laravel ay ang tonelada ng mga file ng pagsasaayos na bahagi ng balangkas. Nais baguhin kung paano / kung saan naka-imbak ang mga imahe?

Well, baguhin lamang ang config / filesystems.php file (hindi bababa sa bilang ng pagsulat). Nais mong gumana sa maraming driver ng pila? Huwag mag-atubiling ilarawan ang mga ito sa config / queue.php. Nabilang ko lang at natagpuan na mayroong 13 mga file ng pagsasaayos para sa iba’t ibang mga aspeto ng balangkas, tinitiyak na hindi ka mabibigo kahit anong gusto mong baguhin.

Ibinigay ang likas na katangian ng PHP, sa tuwing darating ang isang bagong kahilingan sa Web, nagising si Laravel, bota ang lahat, at mga magulang lahat ng mga file na ito ng pagsasaayos upang malaman kung paano magagawa ang mga bagay na naiiba sa oras na ito. Maliban na kung ito ay tanga kung walang nagbago sa mga huling araw! Ang muling pagtatayo ng config sa bawat kahilingan ay isang basura na maaaring (talagang, dapat) iwasan, at ang paraan ay isang simpleng utos na inalok ni Laravel:

php artisan config: cache

Ano ang ginagawa nito ay pinagsama ang lahat ng magagamit na mga file ng config sa isang solong at ang cache ay sa isang lugar para sa mabilis na pagkuha. Sa susunod na mayroong isang kahilingan sa Web, babasahin lamang ni Laravel ang nag-iisang file na ito at pupunta.

Iyon ay sinabi, ang pag-configure sa caching ay isang napaka-pinong operasyon na maaaring sumabog sa iyong mukha. Ang pinakadakilang gotcha ay kapag naipalabas mo ang utos na ito, ang function ng env () ay tumatawag mula sa lahat ng dako maliban sa mga file ng config ay babalik na!

Makatuwiran kapag naiisip mo ito. Kung gumagamit ka ng cache ng pagsasaayos, sasabihin mo ang balangkas, “Alam mo kung ano, sa palagay ko ay naiayos ko ang mga bagay at 100% ako sigurado na hindi ko nais na baguhin sila.” Sa madaling salita, inaasahan mong manatiling static ang kapaligiran, na kung saan ay.

Sa sinabi nito, narito ang ilang mga iron-clad, sagrado, hindi nababagsak na mga patakaran ng caching ng pagsasaayos:

  1. Gawin lamang ito sa isang sistema ng produksyon.
  2. Gawin mo lang kung ikaw talaga, sigurado na nais mong i-freeze ang pagsasaayos.
  3. Kung sakaling may mali, alisin ang setting gamit ang php artisan cache: malinaw
  4. Manalangin na ang pinsala na ginawa sa negosyo ay hindi makabuluhan!

Bawasan ang mga serbisyo ng autoloaded

Upang maging kapaki-pakinabang, nag-load si Laravel ng isang tonelada ng mga serbisyo kapag nagising ito. Magagamit ang mga ito sa config / app.php file bilang bahagi ng ‘key’ array key. Tingnan natin kung ano ang mayroon ako sa aking kaso:

/ *
|————————————————————————–
| Mga Tagabigay ng Serbisyo ng Autoloaded
|————————————————————————–
|
| Ang mga service provider na nakalista dito ay awtomatikong mai-load sa
| humiling sa iyong aplikasyon. Huwag mag-atubiling idagdag ang iyong sariling mga serbisyo sa
| ang larong ito upang magbigay ng pinalawak na pag-andar sa iyong mga aplikasyon.
|
* /

‘provider’ => [

/ *
* Mga Tagabigay ng Serbisyo ng Framework ng Laravel…
* /
Iilaw ang \ May-akda \ AuthorServiceProvider :: klase,
Iilaw \ Broadcasting \ BroadcastServiceProvider :: klase,
Iilaw ang \ Bus \ BusServiceProvider :: klase,
Magaan ang \ Cache \ CacheServiceProvider :: klase,
Magaan ang \ Foundation \ Provider \ ConsoleSupportServiceProvider :: klase,
Magaan ang \ Cookie \ CookieServiceProvider :: klase,
Magaan ang \ Database \ DatabaseServiceProvider :: klase,
Magaan ang \ Encryption \ EncryptionServiceProvider :: klase,
Magaan ang \ Filesystem \ FilesystemServiceProvider :: klase,
Magaan ang \ Foundation \ Provider \ FoundationServiceProvider :: klase,
Iilaw ang \ Hashing \ HashServiceProvider :: klase,
Magaan ang \ Mail \ MailServiceProvider :: klase,
Magaan ang \ Abiso \ NotificationServiceProvider :: klase,
Iilaw ang \ Pagination \ PaginationServiceProvider :: klase,
Magaan ang \ Pipeline \ PipelineServiceProvider :: klase,
Magaan ang \ Queue \ QueueServiceProvider :: klase,
Iilaw \ Redis \ RedisServiceProvider :: klase,
Magaan ang \ May-akda \ Mga Password \ PasswordResetServiceProvider :: klase,
Magaan ang \ Session \ SessionServiceProvider :: klase,
Magaan ang Pagsasalin \ PagsasalinServiceProvider :: klase,
Iilaw \ Pag-iwas sa \ Pag-verify ngServiceProvider :: klase,
Iilaw \ View \ ViewServiceProvider :: klase,

/ *
* Mga Tagabigay ng Serbisyo ng Pakete…
* /

/ *
* Mga Nagbibigay ng Serbisyo ng Application…
* /
App \ Provider \ AppServiceProvider :: klase,
App \ Provider \ AuthorServiceProvider :: klase,
// App \ Provider \ BroadcastServiceProvider :: klase,
App \ Provider \ EventServiceProvider :: klase,
App \ Provider \ RutaServiceProvider :: klase,

],

Muli, binilang ko, at mayroong 27 mga serbisyo na nakalista! Ngayon, maaaring kailanganin mo silang lahat, ngunit hindi ito malamang.

Halimbawa, nangyayari ako sa pagbuo ng isang REST API sa sandaling ito, na nangangahulugang hindi ko kailangan ang Tagapagbigay ng Serbisyo ng Session, View Service Provider, atbp At dahil ako ay gumagawa ng ilang mga bagay sa aking paraan at hindi pagsunod sa mga balangkas ng default. , Maaari ko ring hindi paganahin ang Tagapagbigay ng Serbisyo ng May-akda, Pagbibigay ng Serbisyo ng Pagination, Tagapagbigay ng Serbisyo sa Pagsasalin, at iba pa. Lahat sa lahat, halos kalahati ng mga ito ay hindi kinakailangan para sa aking kaso sa paggamit.

Tumingin ng mahaba, mahirap tingnan ang iyong aplikasyon. Kailangan ba nito ang lahat ng mga service provider na ito? Ngunit para sa Diyos, mangyaring huwag nang bulag na magbigay ng puna sa mga serbisyong ito at itulak sa paggawa! Patakbuhin ang lahat ng mga pagsubok, suriin nang manu-mano ang mga bagay sa dev at staging machine, at maging napaka paranoid bago mo hilahin ang gatilyo. ��

Maging matalino sa mga stacks ng middleware

Kapag kailangan mo ng ilang pasadyang pagproseso ng papasok na kahilingan sa Web, ang paglikha ng isang bagong middleware ay ang sagot. Ngayon, nakatutukso na buksan ang app / Http / Kernel.php at idikit ang middleware sa web o api stack; sa ganoong paraan, magagamit ito sa buong app at kung hindi ito gumagawa ng isang nakakaabala (tulad ng pag-log o pag-abiso, halimbawa).

Gayunpaman, habang lumalaki ang app, ang koleksyon ng pandaigdigang middleware ay maaaring maging isang tahimik na pasanin sa app kung ang lahat (o nakararami) ay naroroon sa bawat kahilingan, kahit na walang dahilan sa negosyo para sa.

Sa madaling salita, mag-ingat sa kung saan mo idinagdag / mag-apply ng isang bagong middleware. Maaari itong maging mas maginhawa upang magdagdag ng isang bagay sa buong mundo, ngunit ang parusa ng pagganap ay napakataas sa katagalan. Alam ko ang sakit na dapat mong mararanasan kung pipiliin mo nang mag-aplay ang middleware sa tuwing may bagong pagbabago, ngunit ito ay isang sakit na nais kong gawin at inirerekumenda!

Iwasan ang ORM (minsan)

Habang ang Marunong gumawa ng maraming mga aspeto ng pakikipag-ugnay sa DB na nakalulugod, pagdating sa gastos ng bilis. Bilang isang mapper, ang ORM ay hindi lamang upang kumuha ng mga talaan mula sa database kundi pati na rin ang pag-instantiate ng mga bagay na modelo at hydrate (punan ang mga ito) ng mga ito ng data ng haligi.

Kaya, kung gumawa ka ng isang simpleng mga gumagamit ng $ = Gumagamit :: lahat () at mayroong, sabihin, 10,000 mga gumagamit, ang balangkas ay kukuha ng 10,000 hilera mula sa database at panloob na gumawa ng 10,000 bagong User () at punan ang kanilang mga katangian sa may-katuturang data . Ito ay napakalaking halaga ng trabaho na ginagawa sa likod ng mga eksena, at kung ang database ay kung saan ka nag-aapply ng application ay nagiging isang bottleneck, ang pag-bypass ng ORM ay isang magandang ideya sa mga oras.

Ito ay totoo lalo na para sa mga kumplikadong mga query sa SQL, kung saan kailangan mong tumalon ng maraming hoops at magsulat ng mga pagsara sa mga pagsara at magtatapos pa rin ng isang mahusay na query. Sa ganitong mga kaso, ang paggawa ng isang DB :: hilaw () at pagsulat ng query sa pamamagitan ng kamay ay ginustong.

Pagpunta sa pamamagitan ng ito pag-aaral ng pagganap, kahit na para sa mga simpleng pagsingit Mas mahusay na mas mabagal ang bilang ng mga rekord na tumataas:

Gumamit ng caching hangga’t maaari

Ang isa sa mga pinananatiling lihim ng pag-optimize ng aplikasyon sa Web ay ang caching.

Para sa mga hindi natuto, ang caching ay nangangahulugan ng pag-precompute at pag-iimbak ng mga mamahaling resulta (mahal sa mga tuntunin ng paggamit ng CPU at memorya), at simpleng ibabalik ang mga ito kapag ang parehong query ay paulit-ulit.

Halimbawa, sa isang tindahan ng e-commerce, maaaring makita nito ang sa 2 milyong mga produkto, sa karamihan ng oras na ang mga tao ay interesado sa mga sariwang stock, sa loob ng isang tiyak na saklaw ng presyo, at para sa isang partikular na pangkat ng edad. Ang pag-uusap ng database para sa impormasyong ito ay walang kabuluhan – dahil madalas na hindi nagbabago ang query, mas mahusay na iimbak ang mga resulta na ito kung saan maaari nating mai-access ng mabilis.

Laravel ay may built-in na suporta para sa ilang mga uri ng caching. Bilang karagdagan sa paggamit ng isang driver ng caching at pagbuo ng caching system mula sa ground up, baka gusto mong gumamit ng ilang mga Laravel packages na mapadali modelo ng caching, query sa caching, atbp.

Ngunit tandaan na lampas sa isang tiyak na pinasimple na kaso ng paggamit, ang mga itinayo na mga pakete ng caching ay maaaring magdulot ng higit pang mga problema kaysa malutas nila.

Mas gusto sa cache ng memorya

Kapag nag cache ka ng isang bagay sa Laravel, mayroon kang maraming mga pagpipilian kung saan mag-iimbak ng nagreresultang pagkalkula na kailangang mai-cache. Ang mga pagpipiliang ito ay kilala rin bilang mga driver ng cache. Kaya, bagaman posible at perpektong makatwirang gamitin ang file system para sa pag-iimbak ng mga resulta ng cache, hindi talaga kung ano ang ibig sabihin ng caching.

Sa isip, nais mong gumamit ng isang in-memorya (nakatira sa RAM ganap) cache tulad ng Redis, Memcached, MongoDB, atbp, upang sa ilalim ng mas mataas na naglo-load, ang caching ay nagsisilbing isang mahalagang gamit sa halip na maging isang bottleneck mismo.

Ngayon, maaari mong isipin na ang pagkakaroon ng isang SSD disk ay halos kapareho ng paggamit ng isang RAM stick, ngunit hindi rin ito malapit. Kahit impormal mga benchmark ipakita na ang RAM outperforms SSD sa pamamagitan ng 10-20 beses pagdating sa bilis.

Ang paborito kong sistema pagdating sa caching ay si Redis. Ito ay nakakatawa nang mabilis (100,000 mga nabasa na operasyon sa bawat segundo ay karaniwan), at para sa napakalaking sistema ng cache, maaaring ma-evolve sa a kumpol madali.

Cache ang mga ruta

Tulad ng application config, ang mga ruta ay hindi nagbabago nang maraming oras at isang mainam na kandidato para sa caching. Totoo ito lalo na kung hindi ka maaaring tumayo ng malalaking file tulad ko at magtatapos sa paghahati ng iyong web.php at api.php sa maraming mga file. Ang isang solong Laravel command pack up ang lahat ng magagamit na mga ruta at pinapanatili ang mga ito madaling gamitin para sa pag-access sa hinaharap:

ruta ng php artisan: cache

At kapag natapos mo ang pagdaragdag o pagbabago ng mga ruta, gawin mo lang:

ruta ng php artisan: malinaw

Pag-optimize ng imahe at CDN

Ang mga imahe ay ang puso-at-kaluluwa ng karamihan sa mga aplikasyon sa Web. Sa sinasadya, sila rin ang pinakamalaking mga mamimili ng bandwidth at isa sa mga pinakamalaking dahilan para sa mga mabagal na apps / website. Kung iimbak mo lang ang na-upload na mga imahe nang walang pasubali sa server at maipabalik ang mga ito sa mga tugon sa HTTP, pinapayagan mo ang isang napakalaking pagkakataon ng pag-optimize sa pamamagitan ng.

Ang aking unang rekomendasyon ay hindi ang pag-iimbak ng mga imahe nang lokal – mayroong problema ng pagkawala ng data upang makitungo, at depende sa aling geograpikong rehiyon na iyong customer, ang paglipat ng data ay maaaring mabagal.

Sa halip, pumunta para sa isang solusyon tulad ng Cloudinary na awtomatikong baguhin at i-optimize ang mga imahe nang mabilis.

Kung hindi iyon posible, gumamit ng isang bagay tulad ng Cloudflare upang cache at maghatid ng mga imahe habang naka-imbak ang mga ito sa iyong server.

At kung hindi iyon posible, ang pag-tweaking ng iyong web server software ng kaunti upang i-compress ang mga assets at idirekta ang browser ng bisita sa mga cache ng mga bagay, maraming pagkakaiba. Narito kung paano magiging hitsura ang isang snippet ng Nginx na pagsasaayos:

server {

# file na naputol

# Mga setting ng compression ng gzip
gzip sa;
gzip_comp_level 5;
gzip_min_length 256;
gzip_proxied anumang;
gzip_vary sa;

# control cache control
lokasyon ~ * \. (ico | css | js | gif | jpeg | jpg | png | woff | ttf | otf | svg | woff2 | eot) $ {
nag-expire ng 1d;
pag-access_log off;
add_header Pragma publiko;
add_header Cache-Control "pampubliko, pinakamataas na edad = 86400";
}
}

Alam ko na ang pag-optimize ng imahe ay walang kinalaman kay Laravel, ngunit ito ay isang simple at malakas na trick (at madalas na napapabayaan) na hindi makakatulong sa aking sarili.

Pag-optimize ng Autoloader

Ang Autoloading ay isang malinis, hindi luma na tampok sa PHP na arguably na-save ang wika mula sa tadhana. Iyon ay sinabi, ang proseso ng paghahanap at pag-load ng may-katuturang klase sa pamamagitan ng pag-decip ng isang naibigay na string ng namespace ay tumatagal ng oras at maiiwasan sa mga paglawak ng produksyon kung saan kanais-nais ang pagganap. Sa sandaling muli, si Laravel ay may isang solong utos na solusyon sa ito:

install ng kompositor –optimize-autoloader –no-dev

Makipagkaibigan sa mga pila

Mga Queue ay kung paano mo pinoproseso ang mga bagay kapag maraming sa kanila, at ang bawat isa sa kanila ay tumatagal ng ilang millisecond upang makumpleto. Ang isang mabuting halimbawa ay ang pagpapadala ng mga email – isang malawak na kaso ng paggamit sa mga web app ay ang pagbaril ng ilang mga email na notification kapag ang isang gumagamit ay nagsasagawa ng ilang mga aksyon.

Halimbawa, sa isang bagong inilunsad na produkto, maaari mong naisin ang pamunuan ng kumpanya (ilang 6-7 na mga email address) na ipaalam sa tuwing may maglagay ng isang order sa itaas ng isang tiyak na halaga. Sa pag-aakalang ang iyong email gateway ay maaaring tumugon sa iyong kahilingan sa SMTP sa 500ms, pinag-uusapan namin ang isang mahusay na 3-4 segundong paghihintay para sa gumagamit bago ang pagkumpirma ng pagkakasunud-sunod. sumang-ayon.

Ang lunas ay ang pag-iimbak ng mga trabaho sa pagpasok nila, sabihin sa gumagamit na ang lahat ay napunta nang maayos, at iproseso ang mga ito (ilang segundo) pagkaraan. Kung mayroong isang error, ang mga naka-pila na trabaho ay maaaring muling maulit ng ilang beses bago sila ipinahayag na nabigo.

Mga Kredito: Microsoft.com

Habang ang isang queuing system ay kumplikado ang pag-setup ng kaunti (at nagdaragdag ng ilang pag-monitor sa itaas), kinakailangan ito sa isang modernong aplikasyon sa Web.

Pag-optimize ng Asset (Laravel Mix)

Para sa anumang mga front-end assets sa iyong Laravel application, mangyaring tiyaking mayroong isang pipeline na pinagsama at binabawasan ang lahat ng mga file ng asset. Ang mga komportable sa sistema ng bundler tulad ng Webpack, Gulp, Parcel, atbp, ay hindi kailangang mag-abala, ngunit kung hindi mo ito nagagawa, Paghaluin ng Laravel ay isang matatag na rekomendasyon.

Ang halo ay isang magaan (at kasiya-siya, sa lahat ng katapatan!) Na pambalot sa paligid ng Webpack na nangangalaga sa lahat ng iyong CSS, SASS, JS, atbp. Ang isang karaniwang .mix.js file ay maaaring maging kasing liit nito at gumagawa pa rin ng mga kababalaghan:

const mix = nangangailangan (‘laravel-mix’);

mix.js (‘mga mapagkukunan / js / app.js’, ‘pampubliko / js’)
.sass (‘mga mapagkukunan / sass / app.scss’, ‘pampubliko / css’);

Ito ay awtomatikong nag-aalaga ng mga import, minification, optimization at buong shebang kapag handa ka na sa paggawa at magpapatakbo ng npm run production. Ang pag-aalaga ay nangangalaga sa hindi lamang tradisyonal na mga file ng JS at CSS, kundi pati na rin ang mga sangkap na Vue at React na maaaring mayroon ka sa iyong workflow ng aplikasyon.

Karagdagang impormasyon dito!

Konklusyon

Ang pag-optimize ng pagganap ay mas sining kaysa sa agham – alam kung paano at kung magkano ang dapat gawin kaysa sa gagawin. Sinabi nito, walang pagtatapos kung magkano at kung ano ang maaari mong mai-optimize sa isang application ng Laravel.

Ngunit anuman ang gagawin mo, nais kong iwanan ka ng ilang mga payo sa paghihiwalay – dapat gawin ang pag-optimize kapag mayroong isang matatag na dahilan, at hindi dahil sa ito ay mahusay o dahil ikaw ay paranoid tungkol sa pagganap ng app para sa 100,000+ mga gumagamit habang sa katotohanan may 10 lang.

Kung hindi ka sigurado kung kailangan mong i-optimize ang iyong app o hindi, hindi mo kailangang sipa ang pugad ng mga arrowet. Ang isang gumaganang app na nakakaramdam ng pagbubutas ngunit ginagawa mismo kung ano ang mayroon nito ay sampung beses na mas kanais-nais kaysa sa isang app na na-optimize sa isang mutant hybrid supermachine ngunit nahulog flat ngayon at pagkatapos.

At, para sa newbiew upang maging isang master ng Laravel, suriin ito kurso sa online.

Nawa ay tumakbo ang iyong mga apps, mas mabilis! ��

Jeffrey Wilson Administrator
Sorry! The Author has not filled his profile.
follow me
    Like this post? Please share to your friends:
    Adblock
    detector
    map