Kurs Angular · Moduł 12: Bezpieczeństwo i wydajność

Trzej strażnicy bramy - autentykacja

4 min czytania ·
W tej lekcji3

Forteca samuraja ma jedną bramę i trzech strażników, którzy razem pilnują, kto wchodzi. W aplikacji Angular jest tak samo, a te trzy role poznasz w tej lekcji: service trzyma klucz (token), interceptor stempluje nim każde żądanie do serwera, a guard nie wpuszcza nikogo bez klucza na chronioną trasę. Idą po kolei.

Strażnik pierwszy: service trzyma klucz

Po zalogowaniu serwer wydaje token - cyfrowy klucz potwierdzający, kim jesteś. AuthService przechowuje go i wie, czy jesteś zalogowany.

@Injectable({ providedIn: 'root' })
export class AuthService {
  private http = inject(HttpClient);
  private currentUser = signal<User | null>(null);
  readonly isLoggedIn = computed(() => !!this.currentUser());
  readonly user = this.currentUser.asReadonly();

  login(credentials: LoginCredentials): Observable<AuthResponse> {
    return this.http.post<AuthResponse>('/api/auth/login', credentials).pipe(
      tap(response => {
        localStorage.setItem('access_token', response.accessToken);
        this.currentUser.set(response.user);
      })
    );
  }

  getToken(): string | null {
    return localStorage.getItem('access_token');
  }
}

Zwróć uwagę na dwie rzeczy. Token trafia do localStorage, żeby przetrwał odświeżenie strony - inaczej po każdym F5 użytkownik byłby wylogowany. A isLoggedIn to computed z sygnału currentUser - dzięki temu cała aplikacja reaguje na logowanie automatycznie: zmieni się użytkownik, zmieni się isLoggedIn, odświeży się każdy widok, który go czyta.

Strażnik drugi: interceptor stempluje żądania

Serwer przy każdym żądaniu pyta "pokaż klucz". Zamiast dopisywać token ręcznie w stu miejscach, interceptor przechwytuje każde wychodzące żądanie i dokłada nagłówek z tokenem.

export const authInterceptor: HttpInterceptorFn = (req, next) => {
  const authService = inject(AuthService);
  const token = authService.getToken();

  if (token) {
    req = req.clone({
      headers: req.headers.set('Authorization', `Bearer ${token}`)
    });
  }
  return next(req);
};

Kluczowe jest req.clone - żądania w Angularze są niezmienne, więc nie dopisujesz nagłówka do oryginału, tylko tworzysz jego kopię z dodanym Authorization. Jedno miejsce, a token trafia automatycznie do każdego żądania w całej aplikacji. To dlatego interceptor jest lepszy niż ręczne dopisywanie.

Prawdziwa siła interceptora ujawnia się, gdy token wygasa. Zamiast wylogować użytkownika, możesz po cichu odświeżyć klucz i ponowić żądanie.

return next(req).pipe(
  catchError((error: HttpErrorResponse) => {
    if (error.status === 401) {          // token wygasł
      return authService.refreshToken().pipe(
        switchMap(response => {
          const newReq = req.clone({
            headers: req.headers.set('Authorization', `Bearer ${response.accessToken}`)
          });
          return next(newReq);           // ponów z nowym kluczem
        }),
        catchError(() => {
          authService.logout();          // odświeżenie też padło - wyloguj
          return throwError(() => error);
        })
      );
    }
    return throwError(() => error);
  })
);

Prześledź logikę: status 401 znaczy "klucz nieważny". Wtedy refreshToken prosi serwer o nowy, a switchMap ponawia pierwotne żądanie z nowym tokenem - użytkownik niczego nie zauważa. Dopiero gdy i odświeżenie zawiedzie, wewnętrzny catchError wylogowuje. To różnica między aplikacją, która co godzinę wyrzuca cię do logowania, a taką, która działa płynnie.

Strażnik trzeci: guard pilnuje trasy

Interceptor chroni żądania, ale samą trasę (np. panel admina) pilnuje guard - funkcja, która musi zwrócić true, żeby wpuścić na stronę.

export const authGuard: CanActivateFn = (route, state) => {
  const authService = inject(AuthService);
  const router = inject(Router);

  if (authService.isLoggedIn()) {
    return true;
  }
  return router.createUrlTree(['/login'], { queryParams: { returnUrl: state.url } });
};

export const roleGuard: CanActivateFn = (route) => {
  const authService = inject(AuthService);
  const requiredRoles = route.data['roles'] as string[];
  const user = authService.user();
  return !!user && requiredRoles.some(role => user.roles.includes(role));
};

Dwa guardy pełnią różne role. authGuard sprawdza, czy jesteś zalogowany, a jeśli nie - przekierowuje do logowania, zapisując returnUrl, byś po zalogowaniu wrócił tam, gdzie chciałeś. roleGuard idzie dalej i pyta, kim jesteś: czy masz odpowiednią rolę. Zamiast false strażnik może zwrócić UrlTree: router.createUrlTree(['/access-denied']) buduje taki adres, a Angular czyta go jako "nie wpuszczam, idź tutaj" i sam przekierowuje - tak robi authGuard powyżej. Nie wołaj w strażniku navigate(): jak pamiętasz z modułu o szlakach, uruchamia ono drugą nawigację, zanim skończy się pierwsza. Wpinasz je do trasy razem:

const routes: Routes = [
  {
    path: 'admin',
    canActivate: [authGuard, roleGuard],
    data: { roles: ['admin', 'moderator'] },
    loadComponent: () => import('./admin.component')
  }
];

Angular uruchomi oba guardy po kolei i wpuści na /admin dopiero, gdy oba zwrócą true - najpierw "czy zalogowany", potem "czy admin lub moderator". Pole data przekazuje guardowi listę dozwolonych ról, więc ten sam roleGuard obsłuży każdą trasę, zmieniasz tylko listę.

Pamiętaj z tej lekcji trzech strażników: service trzyma klucz, interceptor stempluje nim żądania (i po cichu go odświeża), a guard pilnuje wejścia na trasę. Razem tworzą jedną, szczelną bramę fortecy.

Kod do tej lekcji: src/app/app.component.ts
import { Component, signal, computed, ChangeDetectionStrategy } from '@angular/core';
import { CommonModule } from '@angular/common';

@Component({
  selector: 'app-root',
  standalone: true,
  imports: [CommonModule],
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: `
    <div class="performance-dojo">
      <h1>Optymalizacja Wydajności Angular</h1>

      <section class="strategies">
        <h2>Strategie Change Detection</h2>

        <div class="strategy-comparison">
          <div class="strategy default">
            <h3>Default</h3>
            <p>Sprawdza całe drzewo komponentów przy każdej zmianie</p>
            <code>changeDetection: ChangeDetectionStrategy.Default</code>
          </div>

          <div class="strategy onpush">
            <h3>OnPush Rekomendowane</h3>
            <p>Sprawdza tylko gdy zmieni się @Input reference, event lub async pipe</p>
            <code>changeDetection: ChangeDetectionStrategy.OnPush</code>
          </div>
        </div>
      </section>

      <section class="demo">
        <h2>Demo: Wydajność listy</h2>

        <div class="controls">
          <button (click)="addItems(100)">Dodaj 100 elementów</button>
          <button (click)="addItems(1000)">Dodaj 1000 elementów</button>
          <button (click)="clearItems()">Wyczyść</button>
        </div>

        <div class="stats">
          <div class="stat">
            <span class="value">{{ items().length }}</span>
            <span class="label">Elementów</span>
          </div>
          <div class="stat">
            <span class="value">{{ renderCount() }}</span>
            <span class="label">Renderowań</span>
          </div>
        </div>

        <div class="list-container">
          @for (item of items(); track item.id) {
            <div class="list-item">
              {{ item.name }} - {{ item.skill }}
            </div>
          }
        </div>
      </section>

      <section class="tips">
        <h2>Wskazówki optymalizacji</h2>

        <div class="tip-grid">
          <div class="tip">
            <h3>trackBy w @for</h3>
            <code>@for (item of items(); track item.id)</code>
            <p>Unikaj renderowania całej listy</p>
          </div>

          <div class="tip">
            <h3>OnPush + Signals</h3>
            <code>count = signal(0)</code>
            <p>Signals automatycznie powiadamiają o zmianach</p>
          </div>

          <div class="tip">
            <h3>Lazy Loading</h3>
            <code>loadComponent: () => import(...)</code>
            <p>Ładuj moduły na żądanie</p>
          </div>

          <div class="tip">
            <h3>@defer</h3>
            <code>@defer (on viewport) ...</code>
            <p>Opóźnij ładowanie komponentów</p>
          </div>

          <div class="tip">
            <h3>Pure Pipes</h3>
            <code>@Pipe({ pure: true })</code>
            <p>Cache'uj wyniki transformacji</p>
          </div>

          <div class="tip">
            <h3>Virtual Scrolling</h3>
            <code>&lt;cdk-virtual-scroll-viewport&gt;</code>
            <p>Renderuj tylko widoczne elementy</p>
          </div>
        </div>
      </section>

      <section class="code-example">
        <h2>Przykłady optymalizacji</h2>
        <pre><code>{{ optimizationCode }}</code></pre>
      </section>
    </div>
  `,
  styles: [`
    .performance-dojo {
      font-family: 'Segoe UI', sans-serif;
      padding: 20px;
      background: linear-gradient(135deg, #0f2027 0%, #203a43 50%, #2c5364 100%);
      min-height: 100vh;
      color: #ecf0f1;
    }

    h1 {
      text-align: center;
      color: #f39c12;
    }

    h2 {
      color: #f39c12;
      border-bottom: 2px solid #f39c12;
      padding-bottom: 10px;
    }

    section {
      background: rgba(255,255,255,0.05);
      border-radius: 10px;
      padding: 20px;
      margin: 20px 0;
    }

    .strategy-comparison {
      display: grid;
      grid-template-columns: 1fr 1fr;
      gap: 20px;
    }

    @media (max-width: 600px) {
      .strategy-comparison {
        grid-template-columns: 1fr;
      }
    }

    .strategy {
      padding: 20px;
      border-radius: 10px;
    }

    .strategy.default {
      background: rgba(231, 76, 60, 0.2);
      border: 2px solid #e74c3c;
    }

    .strategy.onpush {
      background: rgba(46, 204, 113, 0.2);
      border: 2px solid #2ecc71;
    }

    .strategy h3 {
      margin-top: 0;
    }

    .strategy code {
      display: block;
      background: rgba(0,0,0,0.3);
      padding: 10px;
      border-radius: 5px;
      font-size: 0.85em;
    }

    .controls {
      display: flex;
      gap: 10px;
      margin-bottom: 20px;
      flex-wrap: wrap;
    }

    button {
      padding: 10px 20px;
      background: #f39c12;
      color: #0f2027;
      border: none;
      border-radius: 5px;
      font-weight: bold;
      cursor: pointer;
    }

    button:hover {
      background: #f1c40f;
    }

    .stats {
      display: flex;
      gap: 30px;
      margin-bottom: 20px;
    }

    .stat {
      text-align: center;
    }

    .stat .value {
      display: block;
      font-size: 2em;
      font-weight: bold;
      color: #f39c12;
    }

    .stat .label {
      color: #888;
    }

    .list-container {
      max-height: 200px;
      overflow-y: auto;
      background: rgba(0,0,0,0.3);
      border-radius: 5px;
      padding: 10px;
    }

    .list-item {
      padding: 8px;
      margin: 2px 0;
      background: rgba(243, 156, 18, 0.1);
      border-radius: 3px;
      font-size: 0.9em;
    }

    .tip-grid {
      display: grid;
      grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
      gap: 15px;
    }

    .tip {
      background: rgba(0,0,0,0.3);
      padding: 15px;
      border-radius: 8px;
    }

    .tip h3 {
      margin-top: 0;
      color: #f39c12;
      font-size: 1em;
    }

    .tip code {
      display: block;
      background: rgba(243, 156, 18, 0.2);
      padding: 8px;
      border-radius: 4px;
      font-size: 0.8em;
      margin-bottom: 8px;
    }

    .tip p {
      margin: 0;
      color: #aaa;
      font-size: 0.9em;
    }

    pre {
      background: #0f2027;
      padding: 15px;
      border-radius: 8px;
      overflow-x: auto;
      border-left: 4px solid #f39c12;
    }

    pre code {
      color: #ecf0f1;
      font-family: 'Fira Code', monospace;
      font-size: 0.85em;
    }
  `]
})
export class AppComponent {
  items = signal<SamuraiItem[]>([]);
  renderCount = signal(0);

  optimizationCode = `// 1. OnPush Change Detection
@Component({
  changeDetection: ChangeDetectionStrategy.OnPush,
  // ...
})

// 2. trackBy w @for
@for (item of items(); track item.id) {
  <div>{{ item.name }}</div>
}

// 3. @defer dla lazy loading komponentów
@defer (on viewport) {
  <app-heavy-component />
} @placeholder {
  <div>Ładowanie...</div>
}

// 4. Virtual Scrolling dla długich list
<cdk-virtual-scroll-viewport itemSize="50" class="list">
  <div *cdkVirtualFor="let item of items">
    {{ item.name }}
  </div>
</cdk-virtual-scroll-viewport>

// 5. Signals zamiast Subject dla stanu
count = signal(0);
doubleCount = computed(() => this.count() * 2);

// 6. Pure Pipe dla transformacji
@Pipe({ name: 'filter', pure: true })
export class FilterPipe implements PipeTransform {
  transform(items: any[], predicate: (item: any) => boolean) {
    return items.filter(predicate);
  }
}`;

  addItems(count: number): void {
    const newItems: SamuraiItem[] = [];
    const startId = this.items().length;

    for (let i = 0; i < count; i++) {
      newItems.push({
        id: startId + i,
        name: `Samuraj #${startId + i}`,
        skill: Math.floor(Math.random() * 100)
      });
    }

    this.items.update(items => [...items, ...newItems]);
    this.renderCount.update(c => c + 1);
  }

  clearItems(): void {
    this.items.set([]);
    this.renderCount.update(c => c + 1);
  }
}

interface SamuraiItem {
  id: number;
  name: string;
  skill: number;
}

Hasła z dokumentacji w tej lekcji

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. Kiedy używamy DomSanitizer.bypassSecurityTrustHtml()?

  2. 2. Jaki typ ma nowoczesny functional guard chroniący trasę w Angular 19?

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

Zadania praktyczne w grze

  • Edytor kodu

    Uzupełnij guard sprawdzający rolę administratora.

  • Układanie w pionie

    Uporządkuj linie definiujące reaktywny stan zalogowania w AuthService (kolejność od góry):

  • Układanie w pionie

    Uporządkuj pola obiektu trasy chronionej guardem (kolejność od góry):

  1. PytanieDomSanitizer
  2. PytanieRola Auth Guard
  3. PytanieToken w interceptorze
  4. Zadanie z kodemPraktyka: Auth Guard
  5. Ułóż w kolejnościStan zalogowania przez signal
  6. Ułóż w kolejnościKonfiguracja chronionej trasy

Przydatne artykuły