Serverless - wprowadzenie

Wprowadzenie

Serverless to model wykonywania kodu, w którym dostawca chmury (AWS, Azure, Google Cloud) zarzadza cała infrastruktura serwerowa. Programista pisze tylko kod funkcji, a chmura automatycznie uruchamia go w odpowiedzi na zdarzenia.

Nazwa “serverless” (bezserwerowy) jest mylaca - serwery nadal istnieja, ale ich zarzadzanie jest całkowicie ukryte przed programista.

Kluczowe pojecia

Serverless

Model chmurowy, w którym:

Nie zarzadzasz serwerami
Płaciasz tylko za faktyczne użycie
Skalowanie jest automatyczne
Kod uruchamia się w odpowiedzi na zdarzenia

FaaS (Functions as a Service)

Usługa umozliwiajaca uruchamianie pojedynczych funkcji w chmurze:

AWS Lambda
Azure Functions
Google Cloud Functions
Cloudflare Workers

BaaS (Backend as a Service)

Gotowe usługi backendowe:

Firebase (baza danych, autentykacja)
Supabase
AWS Amplify

Porownanie modeli hostingu

┌─────────────────────────────────────────────────────────────────┐
│              TRADYCYJNY SERWER (VPS/Dedicated)                 │
├─────────────────────────────────────────────────────────────────┤
│  Ty zarzadzasz:                                                 │
│  - System operacyjny                                           │
│  - Aktualizacje bezpieczeństwa                                 │
│  - Skalowanie                                                  │
│  - Monitoring                                                  │
│  - Aplikacja                                                   │
└─────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────┐
│                    SERVERLESS (FaaS)                           │
├─────────────────────────────────────────────────────────────────┤
│  Ty zarzadzasz:                                                 │
│  - Tylko kod funkcji                                           │
│                                                                 │
│  Chmura zarzadza:                                              │
│  - Wszystkim innym (OS, skalowanie, bezpieczeństwo)            │
└─────────────────────────────────────────────────────────────────┘

Jak działa serverless?

┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│   ZDARZENIE  │────►│   CHMURA     │────►│   FUNKCJA    │
│  (trigger)   │     │   (Lambda)   │     │   (twoj kod) │
└──────────────┘     └──────────────┘     └──────────────┘
       │                    │                    │
       ▼                    ▼                    ▼
  HTTP request        Uruchomienie         Wykonanie
  Upload pliku        kontenera            i odpowiedz
  Cron (timer)        w ~100ms
  Wiadomość z kolejki

Cykl zycia funkcji

Zdarzenie - np. HTTP request, upload pliku, timer
Cold start - chmura uruchamia kontener (100-500ms)
Wykonanie - twoj kod przetwarza zdarzenie
Odpowiedz - funkcja zwraca wynik
Uspienie - kontener pozostaje aktywny przez kilka minut
Warm start - nastepne wywołanie używa tego samego kontenera

Przykład funkcji serverless

AWS Lambda (Node.js)

export const handler = async (event) => {
  // event zawiera dane wejsciowe (np. HTTP request)
  const name = event.queryStringParameters?.name || 'World';

  // Logika biznesowa
  const greeting = `Hello, ${name}!`;

  // Odpowiedz
  return {
    statusCode: 200,
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      message: greeting,
      timestamp: new Date().toISOString()
    })
  };
};

Cloudflare Workers

export default {
  async fetch(request) {
    const url = new URL(request.url);
    const name = url.searchParams.get('name') || 'World';

    return new Response(
      JSON.stringify({ message: `Hello, ${name}!` }),
      {
        headers: { 'Content-Type': 'application/json' }
      }
    );
  }
};

Model rozliczeniowy

Tradycyjny hosting

Miesieczna opłata: 50 PLN (niezależnie od użycia)
24h/7 dni - serwer działa cały czas

Serverless

Opłata za:
- Liczbe wywołań: np. 0.20 PLN za 1 milion
- Czas wykonania: np. 0.00001667 PLN za 1GB-sekunde
- Transfer danych: np. 0.09 PLN za GB

Przykład: 100,000 wywołań * 200ms * 128MB = ~0.50 PLN

Zalety serverless

Zaleta	Opis
Brak zarzadzania serwerami	Chmura zajmuje się wszystkim
Automatyczne skalowanie	Od 0 do milionow żądań
Pay-per-use	Płaciasz tylko za użycie
Szybki deployment	Deploy w sekundach
Wysoka dostepnosc	Wbudowana redundancja

Wady serverless

Wada	Opis
Cold start	Opoznienie pierwszego wywołania (100-500ms)
Limity czasowe	Max czas wykonania (AWS: 15 min)
Vendor lock-in	Zaleznosc od dostawcy chmury
Debugging	Trudniejsze debugowanie lokalne
Stan	Funkcje sa bezstanowe

Kiedy stosowac serverless?

Dobre zastosowania

API backendy (REST, GraphQL)
Przetwarzanie plikow (generowanie miniatur)
Webhooks i integracje
Zadania cron (scheduled jobs)
Chatboty i automatyzacje

Nieodpowiednie zastosowania

Aplikacje wymagajace stałego połączenia (WebSocket)
Długotrwałe obliczenia (>15 minut)
Aplikacje z dużym ruchem wymagajace niskiego opoznienia
Systemy wymagajace lokalnego stanu

Architektura serverless - przykład

┌─────────────────────────────────────────────────────────────┐
│                    APLIKACJA SERVERLESS                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   ┌─────────┐     ┌─────────────┐     ┌─────────────────┐  │
│   │ API     │     │   Lambda    │     │    DynamoDB    │  │
│   │ Gateway │────►│   Functions │────►│    (baza)      │  │
│   └─────────┘     └─────────────┘     └─────────────────┘  │
│        │                                                   │
│        │          ┌─────────────┐     ┌─────────────────┐  │
│        └─────────►│   Lambda    │────►│       S3       │  │
│                   │  (obrazki)  │     │   (storage)    │  │
│                   └─────────────┘     └─────────────────┘  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Najczestsze błędy

Podsumowanie

Serverless to model gdzie chmura zarzadza infrastruktura
FaaS (np. AWS Lambda) uruchamia kod w odpowiedzi na zdarzenia
Płacimy tylko za faktyczne użycie (pay-per-use)
Automatyczne skalowanie od zera do milionow żądań
Cold start to opoznienie pierwszego uruchomienia
Idealne dla API, webhookow, przetwarzania plikow
Nie nadaje się do aplikacji z długim czasem wykonania

Zasoby

AWS Lambda Dokumentacja AWS Lambda

Serverless Framework Framework do budowy aplikacji serverless

Cloudflare Workers Edge computing od Cloudflare

Vercel Functions Serverless functions od Vercel