Kurs Angular · Moduł 14: Zaawansowane wzorce

Droga ostrza na pole bitwy - SSR i Deployment

5 min czytania ·
W tej lekcji5

Twoja aplikacja jest gotowa w dojo - ale prawdziwy samuraj nie zostaje w sali treningowej. Ta lekcja to droga ostrza do walki: najpierw zdecydujesz, jak wykuwana jest każda strona (renderowanie), potem wykujesz gotowe ostrze (build), a na końcu wyślesz je w świat (deployment). Przejdziemy tę drogę bramami po kolei.

Brama pierwsza: gdzie powstaje strona (SSR)

Domyślnie Angular składa stronę dopiero w przeglądarce gościa - to jak wręczyć mu surową stal i kazać samemu wykuć miecz. Przy wolniejszym urządzeniu gość długo patrzy na pustą planszę, a wyszukiwarki widzą pustkę. Server-Side Rendering (SSR) przenosi wykuwanie na serwer: gość dostaje gotową stronę od razu.

# Dodaj SSR do istniejącego projektu
ng add @angular/ssr

# Lub od razu przy tworzeniu nowego
ng new my-app --ssr

Jedna komenda ng add @angular/ssr dokłada wszystko, co potrzebne - serwer, konfigurację i punkty startowe. Nie musisz pisać serwera ręcznie; Angular przygotowuje dojo za Ciebie.

Po instalacji rdzeniem SSR jest jeden dostawca, który mówi Angularowi "renderuj też po stronie serwera":

// app.config.server.ts
import { ApplicationConfig, mergeApplicationConfig } from '@angular/core';
import { provideServerRendering } from '@angular/platform-server';
import { appConfig } from './app.config';

const serverConfig: ApplicationConfig = {
  providers: [
    provideServerRendering()
  ]
};

export const config = mergeApplicationConfig(appConfig, serverConfig);

Zwróć uwagę na mergeApplicationConfig - nie tworzymy osobnej aplikacji na serwer, tylko dokładamy ustawienia serwerowe do wspólnej konfiguracji z app.config.ts. Dzięki temu ta sama aplikacja działa w przeglądarce i na serwerze, bez dwóch osobnych kodów do utrzymania.

Na tej bramie czeka jedna pułapka. Kod wykonywany na serwerze nie ma wokół siebie przeglądarki - obiekty takie jak localStorage czy window po prostu tam nie istnieją, a sięgnięcie po nie przerywa renderowanie. Przy okazji: trzymanie stanu w localStorage to magazyn przeglądarki, a nie sposób renderowania - nie ma nic wspólnego z tym, gdzie powstaje HTML. Żeby odróżnić oba światy, Angular daje token PLATFORM_ID z @angular/core oraz funkcje isPlatformBrowser() i isPlatformServer() z @angular/common:

// storage.service.ts
import { Injectable, inject, PLATFORM_ID } from '@angular/core';
import { isPlatformBrowser } from '@angular/common';

@Injectable({ providedIn: 'root' })
export class StorageService {
  private platformId = inject(PLATFORM_ID);

  setItem(key: string, value: string): void {
    if (isPlatformBrowser(this.platformId)) {
      localStorage.setItem(key, value);
    }
  }
}

isPlatformBrowser(this.platformId) odpowiada na jedno pytanie: czy właśnie działam w przeglądarce? Dopiero wewnątrz takiego warunku sięgasz po localStorage. Na serwerze sprawdzenie zwraca false, gałąź jest pomijana, a renderowanie przechodzi bez szwanku. Każde API dostępne tylko w przeglądarce należy w aplikacji z SSR schować za takim warunkiem.

Brama druga: wykuj z góry to, co się nie zmienia (SSG)

SSR wykuwa stronę przy każdym żądaniu. Ale strona "O nas" czy profil samuraja wygląda tak samo dla wszystkich - po co kuć ją za każdym razem? Prerendering (SSG) wykuwa takie strony raz, podczas builda, i zapisuje jako gotowe pliki HTML.

// angular.json
{
  "architect": {
    "prerender": {
      "builder": "@angular/build:prerender",
      "options": {
        "routes": [
          "/",
          "/about",
          "/samurai/1",
          "/samurai/2"
        ]
      }
    }
  }
}

W polu routes wypisujesz ścieżki, które mają zostać wykute z wyprzedzeniem. To najszybsza możliwa strona - serwer nic nie liczy, po prostu podaje gotowy plik. Zasada wyboru jest prosta: strony takie same dla każdego dawaj do prerenderu, a strony zależne od zalogowanego gościa zostaw dla SSR.

Zbroja na czas bez sieci: PWA

Prawdziwy wojownik walczy nawet, gdy zawiedzie zaopatrzenie. PWA (Progressive Web App) to zbroja, dzięki której aplikacja działa również bez internetu - przeglądarka zapamiętuje jej zasoby.

ng add @angular/pwa

Tak jak przy SSR, jedna komenda dokłada całą zbroję. Sercem PWA jest service worker - strażnik, który przechwytuje żądania i podaje zapamiętane zasoby, gdy sieci brak:

// Rejestracja service workera
import { isDevMode } from '@angular/core';
import { provideServiceWorker } from '@angular/service-worker';

export const appConfig: ApplicationConfig = {
  providers: [
    provideServiceWorker('ngsw-worker.js', {
      enabled: !isDevMode(),
      registrationStrategy: 'registerWhenStable:30000'
    })
  ]
};

Kluczowe jest enabled: !isDevMode() - strażnik działa tylko w wersji produkcyjnej. To celowe: podczas pracy w dojo chcesz widzieć każdą zmianę natychmiast, a zapamiętujący zasoby service worker podawałby Ci stare wersje i wprowadzał w błąd.

Brama trzecia: wykuj gotowe ostrze (build)

Zanim wyślesz aplikację w świat, musisz ją wykuć w wersji bojowej - ng build zbiera cały kod, usuwa zbędne fragmenty i optymalizuje rozmiar.

# Build produkcyjny z optymalizacjami
ng build --configuration=production

# Build z raportem, co waży najwięcej
ng build --stats-json
npx webpack-bundle-analyzer dist/browser/stats.json

# Podejrzyj gotową aplikację lokalnie
npx http-server dist/browser

Pierwsza komenda tworzy finalne ostrze w folderze dist/browser. Druga to nawyk dojrzałego wojownika: webpack-bundle-analyzer pokazuje na mapie, która biblioteka najbardziej obciąża aplikację - zanim gość poczuje to jako wolne ładowanie, Ty już wiesz, co przyciąć. Trzecia pozwala obejrzeć wynik lokalnie, dokładnie tak, jak zobaczy go świat.

Brama ostatnia: wyślij ostrze w świat (deployment)

Ostrze wykute - czas na pole bitwy. Deployment to wysłanie folderu dist/browser na platformę, która udostępni go światu. Każda z popularnych platform robi to jedną-dwiema komendami:

# Vercel
npm i -g vercel
vercel

# Netlify
npm i -g netlify-cli
netlify deploy --prod

# Firebase
ng add @angular/fire
ng deploy

Wszystkie trzy działają tak samo: instalujesz narzędzie platformy, a jedna komenda wysyła gotowy build. Wybór między nimi to głównie kwestia tego, gdzie masz już konto - ważne, że aplikacja z SSR potrzebuje platformy uruchamiającej Node (Vercel, Netlify), a czysto prerenderowane strony zadowolą się dowolnym hostingiem plików.

Pamiętaj z tej lekcji drogę, nie komendy: najpierw decydujesz jak powstaje strona (SSR dla treści zależnych od gościa, SSG dla stałych), potem wykuwasz ją ng build, a na końcu jedną komendą wysyłasz w świat. To ta sama droga dla każdej aplikacji Angulara.

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Jaka komenda dodaje Server-Side Rendering do projektu Angular?

  2. 2. Na czym polega Server-Side Rendering (SSR) w Angular?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż komendę dodającą obsługę PWA do projektu (jedna linia, od lewej):

  • Edytor kodu

    Uzupełnij serwis bezpiecznie używający localStorage w SSR.

  • Układanie w pionie

    Uporządkuj etapy przygotowania aplikacji Angular do wdrożenia (od pierwszego do ostatniego):

  1. PytanieAngular SSR
  2. PytanieCzym jest SSR
  3. Ułóż w kolejnościDodawanie PWA
  4. Zadanie z kodemPraktyka: SSR Guard
  5. Ułóż w kolejnościProces budowania i wdrożenia
  6. PytaniePrerendering (SSG)

Przydatne artykuły