Techniki przyspieszania ładowania aplikacji internetowej nawet na telefonach komórkowych z funkcjami

Jak wykorzystaliśmy dzielenie kodu, wstawianie kodu i renderowanie po stronie serwera w PROXX.

Na konferencji Google I/O 2019 Mariko, Jake i ja zaprezentowaliśmy PROXX, nowoczesny klon Sapera na potrzeby internetu. Tym, co wyróżnia PROXX, jest nacisk na ułatwienia dostępu (można grać z czytnikiem ekranu) oraz możliwość uruchamiania gry zarówno na telefonie z podstawową przeglądarką, jak i na wysokiej klasy komputerze. Telefony z podstawową przeglądarką mają kilka ograniczeń:

  • Słabe procesory
  • słabe lub nieistniejące GPU,
  • małe ekrany bez dotykowego wprowadzania danych,
  • Bardzo ograniczona ilość pamięci

Są jednak wyposażone w nowoczesną przeglądarkę i bardzo przystępne cenowo. Z tego powodu telefony z podstawową przeglądarką zyskują na popularności na rynkach wschodzących. Ich cena pozwala zupełnie nowej grupie odbiorców, których wcześniej nie było na to stać, na korzystanie z internetu i nowoczesnych technologii internetowych. Przewiduje się, że w 2019 roku w samych Indiach zostanie sprzedanych około 400 milionów telefonów z podstawową przeglądarką, więc użytkownicy takich urządzeń mogą stanowić znaczną część Twoich odbiorców. Poza tym na rynkach wschodzących normą są szybkości połączenia zbliżone do 2G. Jak udało nam się sprawić, że PROXX działa dobrze na telefonach z podstawową przeglądarką?

Rozgrywka w PROXX.

Wydajność jest ważna, zarówno pod względem wczytywania, jak i czasu działania. Wykazano, że dobra wydajność koreluje ze zwiększonym utrzymaniem użytkowników, lepszymi konwersjami i – co najważniejsze – większą inkluzywnością. Jeremy Wagner ma znacznie więcej danych i statystyk na temat tego, dlaczego wydajność ma znaczenie.

Jest to pierwsza część dwuczęściowej serii. Część 1 dotyczy wydajności ładowania, a część 2 – wydajności w czasie działania.

Rejestrowanie stanu obecnego

Testowanie wydajności wczytywania na rzeczywistym urządzeniu ma kluczowe znaczenie. Jeśli nie masz pod ręką prawdziwego urządzenia, polecam WebPageTest, a konkretnie „prostą” konfigurację. WPT przeprowadza serię testów wczytywania na rzeczywistym urządzeniu z emulowanym połączeniem 3G.

3G to dobra szybkość do pomiaru. Być może korzystasz z sieci 4G, LTE, a wkrótce nawet 5G, ale rzeczywistość internetu mobilnego wygląda zupełnie inaczej. Może jesteś w pociągu, na konferencji, na koncercie lub w samolocie. W takich miejscach prędkość będzie prawdopodobnie zbliżona do 3G, a czasem nawet niższa.

W tym artykule skupimy się jednak na sieciach 2G, ponieważ PROXX jest przeznaczony dla telefonów z podstawową przeglądarką i rynków wschodzących, co wyraźnie wskazuje na jego docelowych odbiorców. Po zakończeniu testu WebPageTest otrzymasz wodospad (podobny do tego, który widzisz w Narzędziach deweloperskich) oraz pasek zdjęć u góry. Pasek filmu pokazuje, co widzi użytkownik podczas wczytywania aplikacji. W sieci 2G wczytywanie niezoptymalizowanej wersji PROXX jest dość powolne:

Pasek zdjęć pokazuje, co widzi użytkownik, gdy PROXX ładuje się na prawdziwym urządzeniu o niskich parametrach przez emulowane połączenie 2G.

W przypadku połączenia 3G użytkownik przez 4 sekundy widzi tylko biały ekran. W przypadku sieci 2G użytkownik nie widzi nic przez ponad 8 sekund. Jeśli wiesz, dlaczego wydajność ma znaczenie, zdajesz sobie sprawę, że straciliśmy właśnie sporą część potencjalnych użytkowników, którzy nie chcieli czekać. Aby na ekranie pojawiła się jakakolwiek treść, użytkownik musi pobrać wszystkie 62 KB kodu JavaScript. Pozytywnym aspektem tej sytuacji jest to, że wszystko, co pojawia się na ekranie, jest od razu interaktywne. A może jednak?

[Pierwsze wyrenderowanie elementu znaczącego][FMP] w niezoptymalizowanej wersji PROXX jest _technicznie_ [interaktywne][TTI], ale bezużyteczne dla użytkownika.

Po pobraniu około 62 KB skompresowanego kodu JS i wygenerowaniu modelu DOM użytkownik widzi naszą aplikację. Aplikacja jest technicznie interaktywna. Jednak wizualizacja pokazuje inną rzeczywistość. Czcionki internetowe nadal ładują się w tle, a dopóki nie będą gotowe, użytkownik nie widzi tekstu. Chociaż ten stan kwalifikuje się jako pierwsze wyrenderowanie elementu znaczącego (FMP), z pewnością nie kwalifikuje się jako prawidłowo interaktywny, ponieważ użytkownik nie może określić, czego dotyczą poszczególne dane wejściowe. W przypadku 3G aplikacja jest gotowa do działania po kolejnej sekundzie, a w przypadku 2G – po 3 sekundach. Łącznie aplikacja staje się interaktywna po 6 sekundach w sieci 3G i po 11 sekundach w sieci 2G.

Analiza kaskadowa

Wiemy już, co widzi użytkownik, więc teraz musimy się dowiedzieć, dlaczego tak jest. W tym celu możemy przyjrzeć się wodospadowi i przeanalizować, dlaczego zasoby są ładowane zbyt późno. W śladzie 2G dla PROXX widzimy 2 główne sygnały ostrzegawcze:

  1. Widocznych jest kilka cienkich, wielokolorowych linii.
  2. Pliki JavaScript tworzą łańcuch. Na przykład drugi zasób zaczyna się wczytywać dopiero po zakończeniu wczytywania pierwszego, a trzeci – dopiero po zakończeniu wczytywania drugiego.
Wodospad pokazuje, które zasoby są wczytywane, kiedy i jak długo to trwa.

Zmniejszanie liczby połączeń

Każda cienka linia (dns, connect, ssl) oznacza utworzenie nowego połączenia HTTP. Konfigurowanie nowego połączenia jest kosztowne, ponieważ zajmuje około 1 s w sieci 3G i około 2,5 s w sieci 2G. W wodospadzie widzimy nowe połączenie dla:

  • Prośba 1: index.html
  • Prośba 5. Style czcionek z fonts.googleapis.com
  • Prośba 8. Google Analytics
  • Prośba 9. Plik czcionki z witryny fonts.gstatic.com
  • Żądanie 14: manifest aplikacji internetowej

Nowe połączenie dla index.html jest nieuniknione. Przeglądarka musi utworzyć połączenie z naszym serwerem, aby pobrać zawartość. Nowego połączenia z Google Analytics można uniknąć, wstawiając w kodzie coś takiego jak Minimal Analytics, ale Google Analytics nie blokuje renderowania ani interaktywności naszej aplikacji, więc nie zależy nam na tym, jak szybko się ładuje. Najlepiej, aby Google Analytics wczytywało się w czasie bezczynności, gdy wszystko inne zostało już wczytane. Dzięki temu nie będzie on zajmować przepustowości ani mocy obliczeniowej podczas wczytywania początkowego. Nowe połączenie dla pliku manifestu aplikacji internetowej jest określone przez specyfikację pobierania, ponieważ plik manifestu musi zostać załadowany przez połączenie bez danych logowania. Ponownie: plik manifestu aplikacji internetowej nie blokuje renderowania aplikacji ani nie uniemożliwia jej interaktywności, więc nie musimy się tym przejmować.

Jednak 2 czcionki i ich style stanowią problem, ponieważ blokują renderowanie i interaktywność. Jeśli spojrzymy na kod CSS dostarczany przez fonts.googleapis.com, zobaczymy tylko 2 reguły @font-face, po jednej dla każdej czcionki. Style czcionki są tak małe, że zdecydowaliśmy się umieścić je w kodzie HTML, co pozwoliło usunąć jedno niepotrzebne połączenie. Aby uniknąć kosztów konfiguracji połączenia dla plików czcionek, możemy skopiować je na nasz serwer.

Równoległe wczytywanie

Patrząc na wodospad, widzimy, że po zakończeniu wczytywania pierwszego pliku JavaScript natychmiast zaczynają się wczytywać nowe pliki. Jest to typowe w przypadku zależności modułów. Nasz główny moduł prawdopodobnie ma importy statyczne, więc JavaScript nie może się uruchomić, dopóki te importy nie zostaną załadowane. Ważne jest, aby pamiętać, że tego rodzaju zależności są znane w czasie kompilacji. Możemy użyć tagów <link rel="preload">, aby mieć pewność, że wszystkie zależności zaczną się ładować w momencie, gdy otrzymamy kod HTML.

Wyniki

Zobaczmy, co udało się osiągnąć dzięki wprowadzonym zmianom. Ważne jest, aby nie zmieniać żadnych innych zmiennych w konfiguracji testu, które mogłyby zniekształcić wyniki, dlatego w dalszej części tego artykułu będziemy używać prostej konfiguracji WebPageTest i przyjrzymy się paskowi zdjęć:

Używamy paska zdjęć WebPageTest, aby zobaczyć, co udało się osiągnąć dzięki wprowadzonym zmianom.

Te zmiany skróciły czas TTI z 11 do 8,5 sekundy, czyli o około 2,5 sekundy, które chcieliśmy zaoszczędzić na konfiguracji połączenia. Brawo my.

Renderowanie wstępne

Chociaż udało nam się skrócić TTI, nie wpłynęło to na długi czas wyświetlania białego ekranu, który użytkownik musi oglądać przez 8,5 sekundy. Prawdopodobnie największą poprawę FMP można osiągnąć, wysyłając sformatowane znaczniki w index.html. Powszechnie stosowane techniki, które pozwalają to osiągnąć, to renderowanie wstępne i renderowanie po stronie serwera. Są one ze sobą ściśle powiązane i zostały opisane w artykule Renderowanie w internecie. Obie techniki uruchamiają aplikację internetową w Node i serializują wynikowy DOM do HTML. Renderowanie po stronie serwera odbywa się na żądanie po stronie serwera, a renderowanie wstępne – podczas kompilacji, a wynik jest zapisywany jako nowy index.html. PROXX to aplikacja JAMStack, która nie ma strony serwera, dlatego zdecydowaliśmy się wdrożyć renderowanie wstępne.

Istnieje wiele sposobów na wdrożenie renderowania wstępnego. W PROXX zdecydowaliśmy się użyć Puppeteer, który uruchamia Chrome bez interfejsu i umożliwia zdalne sterowanie tą instancją za pomocą interfejsu Node API. Używamy go do wstawiania naszych znaczników i kodu JavaScript, a następnie odczytujemy DOM jako ciąg znaków HTML. Ponieważ używamy modułów CSS, możemy bezpłatnie wbudowywać potrzebne style CSS.

  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.setContent(rawIndexHTML);
  await page.evaluate(codeToRun);
  const renderedHTML = await page.content();
  browser.close();
  await writeFile("index.html", renderedHTML);

Dzięki temu możemy oczekiwać poprawy FMP. Nadal musimy wczytać i wykonać tę samą ilość kodu JavaScript co wcześniej, więc nie powinniśmy oczekiwać, że TTI znacząco się zmieni. Jeśli już, to nasz index.html się powiększył i może nieco opóźnić TTI. Jest tylko jeden sposób, aby się przekonać: uruchomienie WebPageTest.

Pasek zdjęć pokazuje wyraźną poprawę wskaźnika FMP. Nie ma to większego wpływu na TTI.

Czas do pierwszego wyrenderowania elementu znaczącego skrócił się z 8,5 sekundy do 4,9 sekundy, co jest ogromną poprawą. Nasz TTI nadal wynosi około 8,5 sekundy, więc ta zmiana nie miała na niego większego wpływu. W tym przypadku wprowadziliśmy zmianę percepcyjną. Niektórzy mogą nawet nazwać to sztuczką. Renderując pośredni obraz gry, poprawiamy postrzeganą wydajność wczytywania.

Wstawianie w tekście

Inne dane, które podają zarówno Narzędzia deweloperskie, jak i WebPageTest, to czas do pierwszego bajtu (TTFB). Jest to czas, który upływa od wysłania pierwszego bajtu żądania do otrzymania pierwszego bajtu odpowiedzi. Ten czas jest też często nazywany czasem błądzenia (RTT), chociaż technicznie istnieje różnica między tymi 2 wartościami: RTT nie obejmuje czasu przetwarzania żądania po stronie serwera. DevTools i WebPageTest wizualizują TTFB za pomocą jasnego koloru w bloku żądania/odpowiedzi.

Jasna sekcja żądania oznacza, że żądanie czeka na otrzymanie pierwszego bajtu odpowiedzi.

W naszym wodospadzie widzimy, że wszystkie żądania spędzają większość czasu na oczekiwaniu na nadejście pierwszego bajtu odpowiedzi.

Ten problem był pierwotnie przyczyną powstania HTTP/2 Push. Deweloper aplikacji wie, że potrzebne są określone zasoby, i może je przesłać. Zanim klient zorientuje się, że musi pobrać dodatkowe zasoby, są one już w pamięci podręcznej przeglądarki. Okazało się, że prawidłowe skonfigurowanie HTTP/2 Push jest zbyt trudne, dlatego nie zaleca się korzystania z tej funkcji. Ten problem zostanie ponownie przeanalizowany podczas standaryzacji protokołu HTTP/3. Na razie najprostszym rozwiązaniem jest umieszczenie w kodzie wszystkich zasobów o kluczowym znaczeniu kosztem wydajności buforowania.

Nasz krytyczny kod CSS jest już wbudowany dzięki modułom CSS i renderowaniu wstępnemu opartemu na Puppeteer. W przypadku JavaScriptu musimy wbudować nasze krytyczne moduły i ich zależności. Trudność tego zadania zależy od używanego bundlera.

Dzięki wstawieniu kodu JavaScript w treść strony udało nam się skrócić czas do pełnej interaktywności z 8,5 s do 7,2 s.

Dzięki temu skróciliśmy TTI o 1 sekundę. Dotarliśmy do punktu, w którym nasz index.html zawiera wszystko, co jest potrzebne do początkowego renderowania i uzyskania interaktywności. Kod HTML może być renderowany podczas pobierania, co pozwala na utworzenie FMP. Gdy tylko kod HTML zostanie przeanalizowany i wykonany, aplikacja stanie się interaktywna.

Agresywne dzielenie kodu

Tak, nasz index.html zawiera wszystko, co jest potrzebne do interaktywności. Jednak po bliższym przyjrzeniu się okazuje się, że zawiera również wszystko inne. Nasz plik index.html ma około 43 KB. Porównajmy to z tym, z czym użytkownik może wejść w interakcję na początku: mamy formularz do skonfigurowania gry zawierający kilka komponentów, przycisk startu i prawdopodobnie kod do zapisywania i wczytywania ustawień użytkownika. To właściwie wszystko. 43 KB to dużo.

Strona docelowa gry PROXX. Używane są tu tylko komponenty o znaczeniu krytycznym.

Aby dowiedzieć się, skąd bierze się rozmiar pakietu, możemy użyć eksploratora mapy źródłowej lub podobnego narzędzia, które pozwoli nam przeanalizować, z czego składa się pakiet. Zgodnie z przewidywaniami nasz pakiet zawiera logikę gry, silnik renderowania, ekran wygranej, ekran przegranej i kilka narzędzi. Na stronie docelowej potrzebny jest tylko niewielki podzbiór tych modułów. Przeniesienie wszystkiego, co nie jest ściśle wymagane do interaktywności, do modułu ładowanego leniwie znacznie skróci czas do pełnej interaktywności.

Analiza zawartości pliku `index.html` gry PROXX pokazuje wiele niepotrzebnych zasobów. Kluczowe zasoby są wyróżnione.

Musimy podzielić kod. Dzielenie kodu polega na rozbiciu monolitycznego pakietu na mniejsze części, które można ładować leniwie na żądanie. Popularne pakiety, takie jak Webpack, Rollup i Parcel, obsługują podział kodu za pomocą dynamicznego import(). Bundler przeanalizuje kod i wstawi wszystkie moduły, które są importowane statycznie. Wszystko, co importujesz dynamicznie, zostanie umieszczone we własnym pliku i pobrane z sieci dopiero po wykonaniu wywołania import(). Oczywiście korzystanie z sieci wiąże się z kosztami i powinno być wykonywane tylko wtedy, gdy masz na to czas. Zasada jest taka, aby statycznie importować moduły, które są krytycznie potrzebne w momencie wczytywania, a wszystko inne wczytywać dynamicznie. Nie należy jednak czekać do ostatniej chwili z leniwym ładowaniem modułów, które na pewno będą używane. Wzorzec Idle Until Urgent Phila Waltona to świetny kompromis między leniwym a gorliwym ładowaniem.

W PROXX utworzyliśmy plik lazy.js, który statycznie importuje wszystko, czego nie potrzebujemy. W głównym pliku możemy następnie dynamicznie zaimportować lazy.js. Jednak niektóre z naszych komponentów Preact trafiły do lazy.js, co okazało się nieco skomplikowane, ponieważ Preact nie obsługuje od razu komponentów ładowanych leniwie. Dlatego napisaliśmy mały komponent deferred, który pozwala nam renderować obiekt zastępczy, dopóki nie zostanie wczytany rzeczywisty komponent.

export default function deferred(componentPromise) {
  return class Deferred extends Component {
    constructor(props) {
      super(props);
      this.state = {
        LoadedComponent: undefined
      };
      componentPromise.then(component => {
        this.setState({ LoadedComponent: component });
      });
    }

    render({ loaded, loading }, { LoadedComponent }) {
      if (LoadedComponent) {
        return loaded(LoadedComponent);
      }
      return loading();
    }
  };
}

Dzięki temu możemy używać obietnicy komponentu w funkcjach render(). Na przykład komponent <Nebula>, który renderuje animowany obraz tła, zostanie zastąpiony pustym elementem <div> podczas ładowania komponentu. Gdy komponent zostanie wczytany i będzie gotowy do użycia, element <div> zostanie zastąpiony rzeczywistym komponentem.

const NebulaDeferred = deferred(
  import("/components/nebula").then(m => m.default)
);

return (
  // ...
  <NebulaDeferred
    loading={() => <div />}
    loaded={Nebula => <Nebula />}
  />
);

Dzięki tym wszystkim zmianom udało nam się zmniejszyć rozmiar index.html do zaledwie 20 KB, czyli o ponad połowę. Jak wpływa to na FMP i TTI? WebPageTest to sprawdzi.

Pasek zdjęć potwierdza, że TTI wynosi teraz 5,4 s. To ogromna poprawa w porównaniu z pierwotnymi 11 sekundami.

Różnica między FMP a TTI wynosi tylko 100 ms, ponieważ jest to tylko kwestia przeanalizowania i wykonania wbudowanego kodu JavaScript. Po zaledwie 5, 4 s w sieci 2G aplikacja jest w pełni interaktywna. Wszystkie pozostałe, mniej istotne moduły są ładowane w tle.

Więcej sztuczek

Jeśli spojrzysz na listę modułów krytycznych powyżej, zobaczysz, że silnik renderowania nie jest jednym z nich. Oczywiście gra nie może się rozpocząć, dopóki nie będziemy mieć silnika renderującego, który będzie ją renderować. Możemy wyłączyć przycisk „Start”, dopóki silnik renderowania nie będzie gotowy do rozpoczęcia gry, ale z naszego doświadczenia wynika, że użytkownik zwykle potrzebuje wystarczająco dużo czasu na skonfigurowanie ustawień gry, aby nie było to konieczne. W większości przypadków silnik renderowania i pozostałe moduły są już wczytane, gdy użytkownik klika „Rozpocznij”. W rzadkich przypadkach, gdy użytkownik jest szybszy niż połączenie sieciowe, wyświetlamy prosty ekran wczytywania, który czeka na zakończenie działania pozostałych modułów.

Podsumowanie

Pomiary są ważne. Aby uniknąć marnowania czasu na rozwiązywanie problemów, które nie są rzeczywiste, zalecamy, aby przed wdrożeniem optymalizacji zawsze najpierw przeprowadzić pomiary. Pomiary należy wykonywać na rzeczywistych urządzeniach z połączeniem 3G lub za pomocą narzędzia WebPageTest, jeśli nie masz pod ręką rzeczywistego urządzenia.

Pasek zdjęć może dać Ci wyobrażenie o tym, jak użytkownik odbiera wczytywanie aplikacji. Wodospad może wskazać, które zasoby są odpowiedzialne za potencjalnie długi czas wczytywania. Oto lista kontrolna, która pomoże Ci poprawić wydajność wczytywania:

  • Przesyłaj jak najwięcej zasobów przez jedno połączenie.
  • Wstępnie wczytaj lub nawet umieść w kodzie zasoby, które są wymagane do pierwszego renderowania i interaktywności.
  • Wstępnie renderuj aplikację, aby poprawić postrzeganą wydajność ładowania.
  • Zastosuj agresywne dzielenie kodu, aby zmniejszyć ilość kodu potrzebnego do interaktywności.

W części 2 omówimy, jak zoptymalizować wydajność w czasie działania na urządzeniach o bardzo ograniczonych zasobach.