{"id":20393,"date":"2023-03-29T05:00:00","date_gmt":"2023-03-29T03:00:00","guid":{"rendered":"https:\/\/sii.pl\/blog\/?p=20393"},"modified":"2024-07-22T15:04:26","modified_gmt":"2024-07-22T13:04:26","slug":"jak-wytrzymac-swiateczne-obciazenie-klasycznie-reaktywnie-czy-z-uzyciem-korutyn","status":"publish","type":"post","link":"https:\/\/sii.pl\/blog\/jak-wytrzymac-swiateczne-obciazenie-klasycznie-reaktywnie-czy-z-uzyciem-korutyn\/","title":{"rendered":"Jak wytrzyma\u0107 \u015bwi\u0105teczne obci\u0105\u017cenie? Klasycznie, reaktywnie czy z u\u017cyciem korutyn?"},"content":{"rendered":"\n

Buduj\u0105c aplikacj\u0119, nale\u017cy pami\u0119ta\u0107 o tym, by by\u0142a ona wydajna, niezawodna oraz odporna na obci\u0105\u017cenie. \u017beby to uzyska\u0107, stosuje si\u0119 skalowanie wertykalne (dodawanie RAM oraz CPU) i horyzontalne (dodawanie wi\u0119kszej liczby instancji w po\u0142\u0105czeniu z Load Balancerem). Oczekujemy, \u017ce aplikacja b\u0119dzie odpowiada\u0142a z mo\u017cliwie nisk\u0105 latencj\u0105 (czasem odpowiedzi). Wydajno\u015b\u0107 stron oraz przetwarzania \u017c\u0105da\u0144 wp\u0142ywa znacz\u0105co na odczucia u\u017cytkownika<\/strong>.<\/p>\n\n\n\n

Wed\u0142ug bada\u0144 Google\u2019a z 2018<\/a>, prawie 80% os\u00f3b robi\u0105cych zakupy online, kt\u00f3re spotka\u0142y si\u0119 z problemem wolnego \u0142adowania strony, zadeklarowa\u0142o, \u017ce nie wr\u00f3ci ju\u017c na zakupy na dan\u0105 stron\u0119. Blisko po\u0142owa klient\u00f3w oczekuje, \u017ce strona za\u0142aduje si\u0119 w ci\u0105gu 2 sekund lub kr\u00f3cej. Je\u015bli dana witryna nie otworzy si\u0119 w ci\u0105gu 3 sekund, 53% u\u017cytkownik\u00f3w j\u0105 opu\u015bci.<\/p>\n\n\n\n

To pokazuje, jak istotne jest dbanie o szybko\u015b\u0107 dzia\u0142ania aplikacji niezale\u017cenie od obci\u0105\u017cenia. Dla u\u017cytkownika nie ma znaczenia, \u017ce trwa akurat np. okres \u015bwi\u0105teczny, wi\u0119c jest wzmo\u017cony ruch na platformach zakupowych. Klient zawsze oczekuje, \u017ce strony oraz przetwarzanie \u017c\u0105da\u0144 b\u0119dzie realizowane mo\u017cliwie szybko.<\/p>\n\n\n\n

Tworz\u0105c aplikacj\u0119 wykorzystuj\u0105c\u0105 framework Spring, mamy do wyboru kilka API, kt\u00f3re odpowiadaj\u0105 na powy\u017csze potrzeby.<\/p>\n\n\n\n

Podej\u015bcie imperatywne \u2013 klasyczne<\/strong><\/h2>\n\n\n\n

Buduj\u0105c Springow\u0105 aplikacj\u0119 umo\u017cliwiaj\u0105c\u0105 komunikacj\u0119 REST-ow\u0105, najcz\u0119\u015bciej si\u0119gamy po rozwi\u0105zanie, jakim jest u\u017cycie webowego starteru wraz z wbudowanym kontenerem servlet\u00f3w Tomcat.<\/strong><\/p>\n\n\n

\n<dependency>\n   <groupId>org.springframework.boot<\/groupId>\n   <artifactId>spring-boot-starter-webflux<\/artifactId>\n<\/dependency>\n<\/pre><\/div>\n\n\n
Ka\u017cde \u017c\u0105danie HTTP przychodz\u0105ce do aplikacji jest w tym przypadku przypisywane do jednego w\u0105tku z puli. Tomcat domy\u015blnie posiada takich w\u0105tk\u00f3w 200.<\/p>\n\n\n\n
Gdy pula tych w\u0105tk\u00f3w zostanie wykorzystana, kolejne \u017c\u0105dania HTTP zostaj\u0105 zakolejkowane i oczekuj\u0105 na zwolnienie si\u0119 w\u0105tku. Mo\u017cemy obliczy\u0107 przybli\u017con\u0105 warto\u015b\u0107 obci\u0105\u017cenia (tzw. Throughput) liczon\u0105 w \u017c\u0105daniach na sekund\u0119 RPS (Requests Per Second), jak\u0105 jest w stanie przyj\u0105\u0107 aplikacja, stosuj\u0105c wz\u00f3r:<\/p>\n\n\n\n
throughput = liczba w\u0105tk\u00f3w \/ \u015bredni czas obs\u0142ugi \u017c\u0105dania<\/p>\n\n\n\n
W idealnej sytuacji, maj\u0105c do dyspozycji 200 w\u0105tk\u00f3w oraz czas obs\u0142ugi ka\u017cdego z nich wynosz\u0105cy 500ms, serwer jest w stanie obs\u0142u\u017cy\u0107: 200req\/500ms = 400RPS.<\/p>\n\n\n\n
Zostawiaj\u0105c domy\u015bln\u0105 pul\u0119 w\u0105tk\u00f3w na poziomie 200 oraz chc\u0105c obs\u0142u\u017cy\u0107 wi\u0119ksze obci\u0105\u017cenie, nale\u017cy albo skr\u00f3ci\u0107 czas obs\u0142ugi pojedynczego \u017c\u0105dania albo do\u0142o\u017cy\u0107 kolejn\u0105 instancj\u0119 serwisu. <\/p>\n\n\n\n
Podej\u015bcie reaktywne<\/strong><\/h2>\n\n\n\n
Wraz z projektem Reactor mo\u017cliwe jest pisanie kodu nieblokuj\u0105cego:<\/p>\n\n\n
\n<dependency>\n   <groupId>org.springframework.boot<\/groupId>\n   <artifactId>spring-boot-starter-webflux<\/artifactId>\n<\/dependency>\n<\/pre><\/div>\n\n\n
Domy\u015blnym kontenerem servlet\u00f3w jest w tym przypadku Netty. U\u017cywa on jednego w\u0105tku na serwer oraz liczb\u0119 w\u0105tk\u00f3w r\u00f3wn\u0105 liczbie rdzeni komputera (CPU Cores) na obs\u0142ug\u0119 \u017c\u0105da\u0144. W przypadku 4-rdzeniowego komputera b\u0119d\u0105 to 4 w\u0105tki.<\/p>\n\n\n\n
Podej\u015bcie to umo\u017cliwia asynchroniczne oraz nieblokuj\u0105ce przetwarzania \u017c\u0105da\u0144. Przy takim za\u0142o\u017ceniu podczas wywo\u0142ania operacji wej\u015bcia\/wyj\u015bcia, np. wywo\u0142ania bazy danych, w\u0105tek nie czeka na odpowied\u017a, tylko od razu wraca do puli w\u0105tk\u00f3w i jest gotowy do przyj\u0119cia kolejnego zdarzenia. Nast\u0119pnie, dzi\u0119ki mechanizmowi callback\u00f3w, aplikacja zostaje poinformowana o rezultacie zapytania.<\/p>\n\n\n\n
Przewag\u0105 podej\u015bcia reaktywnego<\/strong> jest wi\u0119c optymalne wykorzystanie dzia\u0142ania w\u0105tk\u00f3w bez czasu oczekiwania na odpowied\u017a, jak to ma miejsce w przypadku klasycznego podej\u015bcia.<\/p>\n\n\n\n
Korutyny<\/strong><\/h2>\n\n\n\n
Kolejn\u0105 opcj\u0105 napisanie nieblokuj\u0105cej aplikacji jest wykorzystanie j\u0119zyka Kotlin wraz z korutynami<\/a>. W odr\u00f3\u017cnieniu od projektu Reactor, mo\u017cliwe jest pisanie kodu w spos\u00f3b bardzo zbli\u017cony do podej\u015bcia klasycznego, co znacz\u0105co poprawia czytelno\u015b\u0107 kodu oraz \u0142atwo\u015b\u0107 testowania, wykorzystuj\u0105c zalety kodu nieblokuj\u0105cego.<\/p>\n\n\n\n
Korutyny cz\u0119sto nazywane s\u0105 r\u00f3wnie\u017c lekkimi w\u0105tkami. Spowodowane jest to tym, \u017ce ich utworzenie jest proste oraz wymaga niewielkich zasob\u00f3w. W przypadku tworzeniu nowego w\u0105tku zajmuje on oko\u0142o 1 MB pami\u0119ci. Korutyna potrzebuje jedynie kilkadziesi\u0105t bajt\u00f3w pami\u0119ci. Jeden w\u0105tek mo\u017ce tworzy\u0107 wiele korutyn.        <\/p>\n\n\n\n
W tym przypadku r\u00f3wnie\u017c pobieramy zale\u017cno\u015b\u0107 webfluxow\u0105, wi\u0119c ponownie domy\u015blnym kontenerem servlet\u00f3w b\u0119dzie Netty.<\/p>\n\n\n
\n<dependency>\n   <groupId>org.springframework.boot<\/groupId>\n   <artifactId>spring-boot-starter-webflux<\/artifactId>\n<\/dependency>\n<\/pre><\/div>\n\n\n
Poza klasycznymi zale\u017cno\u015bciami kotlinowymi, potrzebujemy r\u00f3wnie\u017c bibliotek do obs\u0142ugi korutyn.<\/p>\n\n\n
\n<dependency>\n   <groupId>org.jetbrains.kotlinx<\/groupId>\n   <artifactId>kotlinx-coroutines-core<\/artifactId>\n<\/dependency>\n<\/pre><\/div>\n\n
\n<dependency>\n   <groupId>org.jetbrains.kotlinx<\/groupId>\n   <artifactId>kotlinx-coroutines-reactor<\/artifactId>\n<\/dependency>\n<\/pre><\/div>\n\n\n
Testy obci\u0105\u017ceniowe<\/strong><\/h2>\n\n\n\n
Do przeprowadzenia test\u00f3w obci\u0105\u017ceniowych zosta\u0142o wykorzystane narz\u0119dzie Gatling umo\u017cliwiaj\u0105ce symulowanie produkcyjnego ruchu poprzez wywo\u0142ywanie wielu zapyta\u0144 r\u00f3wnolegle przez okre\u015blony czas.<\/p>\n\n\n\n
Testy zosta\u0142y przeprowadzone na 6-rdzeniowym Intel i7 oraz 32GB RAM, dysk SSD. W ramach test\u00f3w por\u00f3wnano czasy odpowiedzi aplikacji zbudowanej wed\u0142ug trzech przedstawionych wy\u017cej podej\u015b\u0107.<\/p>\n\n\n
\npublic class CustomerRequestsSimulation extends Simulation {\n\n    HttpProtocolBuilder httpProtocol = http\n            .baseUrl("http:\/\/localhost:8080")\n            .acceptHeader("application\/json")\n            .userAgentHeader("Gatling\/Performance Test");\n\n\n    ScenarioBuilder scn = CoreDsl.scenario("Load Test Scenario")\n            .forever()\n            .on(exec(http("create-customer-request")\n                    .get("\/endpoint")\n            ));\n\n    public CustomerRequestsSimulation() {\n        setUp(scn.injectClosed(\n                        incrementConcurrentUsers(256)\n                                .times(8)\n                                .eachLevelLasting(Duration.ofSeconds(20))\n                                .separatedByRampsLasting(Duration.ofSeconds(10))\n                                .startingFrom(0)\n                )\n        ).maxDuration(Duration.ofMinutes(2))\n                .protocols(httpProtocol);\n    }\n}\n<\/pre><\/div>\n\n\n
W tym scenariuszu trwaj\u0105cym 2 minuty 256 u\u017cytkownik\u00f3w b\u0119dzie dodawanych w ci\u0105gu 10 sekund. Pomi\u0119dzy kolejnymi inkrementacjami jest 20 sekund przerwy.<\/p>\n\n\n\n
\"Aktywni<\/a>
Ryc. 1 Aktywni u\u017cytkownicy w trakcie symulacji<\/figcaption><\/figure><\/div>\n\n\n\n
Bez op\u00f3\u017anie\u0144<\/strong><\/h3>\n\n\n\n
W tym przyk\u0142adzie aplikacje nie b\u0119d\u0105 posiada\u0142y \u017cadnych op\u00f3\u017anie\u0144 ani logiki wewn\u0105trz kontrolera. B\u0119d\u0105 wi\u0119c pr\u00f3bowa\u0107 odpowiada\u0107 na \u017c\u0105dania tak szybko, jak tylko jest to mo\u017cliwe.<\/p>\n\n\n\n
  1. podej\u015bcie imperatywne<\/li><\/ol>\n\n\n
    \n@RestController\nclass Controller {\n\n    @GetMapping("\/endpoint")\n    public ResponseEntity<Void> endpoint() {\n        return ResponseEntity.ok().build();\n    }\n}\n<\/pre><\/div>\n\n\n
    \"\"<\/a>
    Ryc. 2 Zakresy czasu reakcji<\/figcaption><\/figure><\/div>\n\n\n\n
    \"Rozk\u0142ad<\/a>
    Ryc. 3 Rozk\u0142ad czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
    1. reaktywne<\/li><\/ol>\n\n\n
      \n@RestController\nclass Controller {\n\n    @GetMapping("\/endpoint")\n    Mono<Void> endpoint() {\n        return Mono.empty();\n    }\n}\n<\/pre><\/div>\n\n\n
      \"Zakresy<\/a>
      Ryc. 4 Zakresy czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
      \"Rozk\u0142ad<\/a>
      Ryc. 5 Rozk\u0142ad czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
      1. korutyny<\/li><\/ol>\n\n\n
        \n@RestController\nclass Controller {\n\n    @GetMapping("\/endpoint")\n    suspend fun endpoint(): ResponseEntity&lt;Void> {\n        return ResponseEntity.ok().build()\n    }\n}\n\n<\/pre><\/div>\n\n\n
        \"Zakresy<\/a>
        Ryc. 6 Zakresy czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
        \"Rozk\u0142ad<\/a>
        Ryc. 7 Rozk\u0142ad czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
         <\/td>Liczba \u017c\u0105da\u0144<\/td>RPS<\/td>99th pct<\/td>\u015aredni czas odpowiedzi<\/td>Odchylenie standardowe<\/td><\/tr>
        Imperatywne<\/td>4 719 272<\/td>39 327<\/td>45<\/td>15<\/td>11<\/td><\/tr>
        Reaktywne<\/td>5 326 083<\/td>44 384<\/td>29<\/td>13<\/td>7<\/td><\/tr>
        Korutyny<\/td>4 972 563<\/td>41 438<\/td>26<\/td>14<\/td>8<\/td><\/tr><\/tbody><\/table>
        Tab. 1 Zestawienie wynik\u00f3w test\u00f3w bez op\u00f3\u017anie\u0144 dla 3 podej\u015b\u0107<\/figcaption><\/figure>\n\n\n\n
        W tym przypadku nie wida\u0107 znacz\u0105cych r\u00f3\u017cnic<\/strong> pomi\u0119dzy poszczeg\u00f3lnymi technologiami. Klasyczne podej\u015bcie jest wolniejsze, ale s\u0105 to na tyle ma\u0142e warto\u015bci, \u017ce nie maj\u0105 znacz\u0105cego wp\u0142ywu na u\u017cytkowanie aplikacji.<\/p>\n\n\n\n
        Ciekawiej zaczyna si\u0119 robi\u0107, gdy dodamy op\u00f3\u017anienia.<\/p>\n\n\n\n
        Op\u00f3\u017anienie 200 ms<\/strong><\/h3>\n\n\n\n
        W tym przyk\u0142adzie do aplikacji zosta\u0142y dodane op\u00f3\u017anienia 200 ms, kt\u00f3re symuluj\u0105 odpytywanie bazy danych lub innego serwisu.<\/p>\n\n\n\n
        1. imperatywne<\/li><\/ol>\n\n\n
          \n@RestController\nclass Controller {\n\n    @GetMapping("\/endpoint")\n    public ResponseEntity<Void> endpoint() throws InterruptedException {\n        Thread.sleep(200);\n        return ResponseEntity.ok().build();\n    }\n}\n<\/pre><\/div>\n\n\n
          \"Zakresy<\/a>
          Ryc. 8 Zakresy czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
          \"Rozk\u0142ad<\/a>
          Ryc. 9 Rozk\u0142ad czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
          1. relatywne<\/li><\/ol>\n\n\n
            \n@RestController\nclass Controller {\n\n    @GetMapping("\/endpoint")\n    Mono<Void> endpoint() {\n        return Mono.empty()\n                .delaySubscription(Duration.ofMillis(200))\n                .then();\n    }\n}\n<\/pre><\/div>\n\n\n
            \"Zakresy<\/a>
            Ryc. 10 Zakresy czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
            \"Rozk\u0142ad<\/a>
            Ryc. 11 Rozk\u0142ad czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
            1. korutyny<\/li><\/ol>\n\n\n
              \n@RestController\nclass Controller {\n\n    @GetMapping("\/endpoint")\n    suspend fun endpoint(): ResponseEntity&lt;Void> {\n        coroutineScope {\n            delay(200)\n        }\n        return ResponseEntity.ok().build()\n    }\n}\n<\/pre><\/div>\n\n\n
              \"Zakresy<\/a>
              Ryc. 12 Zakresy czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
              \"Rozk\u0142ad<\/a>
              Ryc. 13 Rozk\u0142ad czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
               <\/td>Liczba \u017c\u0105da\u0144<\/td>RPS<\/td>99th pct<\/td>\u015aredni czas odpowiedzi<\/td>Odchylenie standardowe<\/td><\/tr>
              Imperatywne<\/td>113 775<\/td>948<\/td>1088<\/td>625<\/td>289<\/td><\/tr>
              Reaktywne<\/td>339 739<\/td>2 831<\/td>226<\/td>211<\/td>7<\/td><\/tr>
              Korutyny<\/td>344 001<\/td>2 866<\/td>222<\/td>208<\/td>6<\/td><\/tr><\/tbody><\/table>
              Tab. 2 Zestawienie wynik\u00f3w test\u00f3w op\u00f3\u017anie\u0144 200 ms dla 3 podej\u015b\u0107<\/figcaption><\/figure>\n\n\n\n
              Ju\u017c w przypadku niewielkiego op\u00f3\u017anienia w aplikacji zaczyna by\u0107 wyra\u017anie widoczna r\u00f3\u017cnica w przepustowo\u015bci serwis\u00f3w na korzy\u015b\u0107 podej\u015bcia reaktywnego oraz z u\u017cyciem korutyn<\/strong>. W przypadku podej\u015bcia klasycznego przy op\u00f3\u017anieniu wynosz\u0105cym 200 ms \u015bredni czas odpowiedzi wynosi\u0142 nieco ponad 600 ms, a 99% \u017c\u0105da\u0144 mia\u0142o czas latencji wynosz\u0105cy poni\u017cej sekundy.<\/p>\n\n\n\n
              Op\u00f3\u017anienie 500 ms<\/strong><\/h3>\n\n\n\n
              1. imperatywne<\/li><\/ol>\n\n\n\n
                \"Zakresy<\/a>
                Ryc. 14 Zakresy czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
                \"Rozk\u0142ad<\/a>
                Ryc. 15 Rozk\u0142ad czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
                1. reaktywne<\/li><\/ol>\n\n\n\n
                  \"Zakresy<\/a>
                  Ryc. 16 Zakresy czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
                  \"Rozk\u0142ad<\/a>
                  Ryc. 17 Rozk\u0142ad czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
                  1. korutyny<\/li><\/ol>\n\n\n\n
                    \"Zakresy<\/a>
                    Ryc. 18 Zakresy czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
                    \"Rozk\u0142ad<\/a>
                    Ryc. 19 Rozk\u0142ad czasu odpowiedzi<\/figcaption><\/figure><\/div>\n\n\n\n
                     <\/td>Liczba \u017c\u0105da\u0144<\/td>RPS<\/td>99th pct<\/td>\u015aredni czas odpowiedzi<\/td>Odchylenie standardowe<\/td><\/tr>
                    Imperatywne<\/td>45 328<\/td>377<\/td>2692<\/td>1551<\/td>717<\/td><\/tr>
                    Reaktywne<\/td>139 261<\/td>1 160<\/td>521<\/td>513<\/td>4<\/td><\/tr>
                    Korutyny<\/td>139 293<\/td>1 160<\/td>519<\/td>512<\/td>4<\/td><\/tr><\/tbody><\/table>
                    Tab. 3 Zestawienie wynik\u00f3w test\u00f3w op\u00f3\u017anie\u0144 500 ms dla 3 podej\u015b\u0107<\/figcaption><\/figure>\n\n\n\n
                    W przypadku op\u00f3\u017anienia 500 ms wida\u0107 znaczne problemy ze sprawn\u0105 obs\u0142ug\u0105 \u017c\u0105da\u0144<\/strong> przez serwis napisany imperatywnie. Je\u015bli chodzi o podej\u015bcie reaktywne oraz z u\u017cyciem korutyn czas obs\u0142ugi \u017c\u0105dania jest \u015brednio o 13 ms d\u0142u\u017cszy ni\u017c zaprogramowane op\u00f3\u017anienie.<\/p>\n\n\n\n
                    Podsumowanie<\/strong><\/h2>\n\n\n\n
                    Im wi\u0119ksze symulowane op\u00f3\u017anienie, tym wi\u0119ksza przepustowo\u015b\u0107 w podej\u015bciu reaktywnym oraz z wykorzystaniem korutyn<\/strong> w stosunku do podej\u015bcia klasycznego. Nie oznacza to jednak, \u017ce trzeba wszystkie aktualne serwisy przepisa\u0107 z wykorzystaniem tych technologii, jak r\u00f3wnie\u017c, \u017ce wszystkie nowe serwisy musz\u0105 by\u0107 napisane w ten spos\u00f3b.<\/p>\n\n\n\n
                    Pisanie takiego kodu jest trudniejsze w przetestowaniu, trudniejsze w debuggowaniu oraz cz\u0119sto mniej czytelne ni\u017c w przypadku podej\u015bcia imperatywnego.<\/p>\n\n\n\n
                    Nale\u017cy wi\u0119c dobra\u0107 odpowiedni\u0105 technologi\u0119 do przypadku u\u017cycia. Gdy wi\u0119c pada pytanie, czy lepiej u\u017cy\u0107 podej\u015bcia imperatywnego, reaktywnego czy korutyn \u2013 odpowied\u017a brzmi\u2026 to zale\u017cy \ud83d\ude09<\/p>\n\n\n\n
                    *** <\/p>\n\n\n\n
                    A je\u015bli interesuje Ci\u0119, co testowa\u0107: wydajno\u015b\u0107 czy szybko\u015b\u0107 zdaniem naszych ekspert\u00f3w z CC Testing, zach\u0119camy do zapoznania z ich artyku\u0142em: Testowanie wydajno\u015bci czy szybko\u015bci? Google Lighthouse w praktyce<\/p>\n\n\n
                    \n            \n
                    \n    \n
                    \n            
                    \n            \n\n
                    <\/div>\n        <\/div>\n            
                    \n            \n\n
                    <\/div>\n        <\/div>\n            
                    \n            \n\n
                    <\/div>\n        <\/div>\n            
                    \n            \n\n
                    <\/div>\n        <\/div>\n            
                    \n            \n\n
                    <\/div>\n        <\/div>\n    <\/div>\n    \n
                    \n            
                    \n            \n\n
                    <\/div>\n        <\/div>\n            
                    \n            \n\n
                    <\/div>\n        <\/div>\n            
                    \n            \n\n
                    <\/div>\n        <\/div>\n            
                    \n            \n\n
                    <\/div>\n        <\/div>\n            
                    \n            \n\n
                    <\/div>\n        <\/div>\n    <\/div>\n<\/div>\n                \n\n
                    \n            5\/5    <\/div>\n    <\/div>\n","protected":false},"excerpt":{"rendered":"
                    Buduj\u0105c aplikacj\u0119, nale\u017cy pami\u0119ta\u0107 o tym, by by\u0142a ona wydajna, niezawodna oraz odporna na obci\u0105\u017cenie. \u017beby to uzyska\u0107, stosuje si\u0119 … Continued<\/a><\/p>\n","protected":false},"author":490,"featured_media":20442,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"_editorskit_title_hidden":false,"_editorskit_reading_time":6,"_editorskit_is_block_options_detached":false,"_editorskit_block_options_position":"{}","inline_featured_image":false,"footnotes":""},"categories":[1314],"tags":[2427,1659,1660,1661,930,146],"class_list":["post-20393","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-development-na-twardo","tag-digital","tag-podejscie-klasyczne","tag-podejscie-reaktywne","tag-korutyny","tag-e-commerce","tag-testing"],"acf":[],"aioseo_notices":[],"republish_history":[],"featured_media_url":"https:\/\/sii.pl\/blog\/wp-content\/uploads\/2023\/03\/Jak-wytrzymac-swiateczne-obciazenie-Klasycznie-reaktywnie-czy-z-uzyciem-korutyn.jpg","category_names":["Development na twardo"],"_links":{"self":[{"href":"https:\/\/sii.pl\/blog\/wp-json\/wp\/v2\/posts\/20393"}],"collection":[{"href":"https:\/\/sii.pl\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/sii.pl\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/sii.pl\/blog\/wp-json\/wp\/v2\/users\/490"}],"replies":[{"embeddable":true,"href":"https:\/\/sii.pl\/blog\/wp-json\/wp\/v2\/comments?post=20393"}],"version-history":[{"count":3,"href":"https:\/\/sii.pl\/blog\/wp-json\/wp\/v2\/posts\/20393\/revisions"}],"predecessor-version":[{"id":20483,"href":"https:\/\/sii.pl\/blog\/wp-json\/wp\/v2\/posts\/20393\/revisions\/20483"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/sii.pl\/blog\/wp-json\/wp\/v2\/media\/20442"}],"wp:attachment":[{"href":"https:\/\/sii.pl\/blog\/wp-json\/wp\/v2\/media?parent=20393"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/sii.pl\/blog\/wp-json\/wp\/v2\/categories?post=20393"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/sii.pl\/blog\/wp-json\/wp\/v2\/tags?post=20393"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}