Scala for Backend Engineering & Functional Programming · Lekcja

Udostępnianie aplikacji

Uruchomi Pan/Pani funkcyjny serwer WWW.

Udostępnianie aplikacji to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Serwer Ember

http4s uruchamia aplikację HttpApp[F] na backendzie. Współczesnym wyborem domyślnym jest Ember — serwer napisany w całości w Scali, oparty na cats-effect i fs2, dostępny jako org.http4s.ember.server.EmberServerBuilder.

Starsze aplikacje mogą używać Blaze, ale w przyszłości zalecaną ścieżką będzie Ember.

// build.sbt
// "org.http4s" %% "http4s-ember-server" % http4sV

Budowanie serwera

EmberServerBuilder.default[F] udostępnia konstruktor, który można konfigurować łańcuchowo: powiązać hosta i port, dołączyć aplikację, a następnie wywołać .build, aby uzyskać Resource[F, Server].

Użycie Resource gwarantuje zwolnienie gniazda podczas zamykania serwera.

import com.comcast.ip4s._
import org.http4s.ember.server.EmberServerBuilder

EmberServerBuilder.default[IO]
  .withHost(ipv4"0.0.0.0")
  .withPort(port"8080")
  .withHttpApp(app)
  .build

Literały ip4s

Ember używa typów ip4s do zapewnienia bezpieczeństwa typów w sieci. Interpolatory ipv4"..." i port"..." sprawdzają wartości podczas kompilacji, więc niepoprawny adres lub port spoza dozwolonego zakresu uniemożliwi kompilację.

Aby uzyskać do nich dostęp, należy zaimportować com.comcast.ip4s._.

import com.comcast.ip4s._

val host = host"localhost"
val p    = port"8080"

Cykl życia Resource

Serwer jest obiektem Resource, ponieważ zarządza gniazdem, które musi być prawidłowo otwierane i zamykane. resource.use(_ => ...) utrzymuje serwer działający przez czas trwania efektu wewnętrznego.

Użyj IO.never, aby działać do momentu przerwania procesu.

server.use(_ => IO.never).void

Punkt wejścia IOApp

Klasa główna aplikacji http4s rozszerza IOApp, który udostępnia zarządzane środowisko uruchomieniowe cats-effect. Należy zaimplementować run zwracające IO[ExitCode].

IOApp zajmuje się pulami wątków, obsługą sygnałów i kontrolowanym zamykaniem aplikacji.

import cats.effect.{IO, IOApp, ExitCode}

object Main extends IOApp {
  def run(args: List[String]): IO[ExitCode] = ???
}

Kompletna metoda main

Podsumowując: należy zbudować zasób serwera, a następnie użyć go z IO.never, aby proces pozostał aktywny, zwracając ExitCode.Success.

To kanoniczny punkt wejścia aplikacji http4s.

def run(args: List[String]): IO[ExitCode] =
  EmberServerBuilder.default[IO]
    .withPort(port"8080")
    .withHttpApp(app)
    .build
    .use(_ => IO.never)
    .as(ExitCode.Success)

Komponowanie zasobów

Rzeczywiste aplikacje pozyskują więcej niż tylko serwer: pulę połączeń z bazą danych, klienta HTTP i konfigurację. Należy skomponować je w jednym wyrażeniu for nad Resource, aby wszystkie zostały zwolnione w odwrotnej kolejności.

Pozyskane klienty należy przekazać do konstrukcji tras.

for {
  client <- EmberClientBuilder.default[IO].build
  app     = buildApp(client)
  srv    <- serverResource(app)
} yield srv

Kontrolowane zamykanie

Ponieważ serwer znajduje się w obiekcie Resource, anulowanie włókna, na przykład po SIGTERM w ramach IOApp, uruchamia finalizator, który przestaje akceptować połączenia i zamyka gniazdo.

Ember obsługuje trwające żądania w ramach konfigurowalnego limitu czasu zamykania.

EmberServerBuilder.default[IO]
  .withShutdownTimeout(30.seconds)
  .withHttpApp(app)
  .build

Middleware serwera

Przed przekazaniem aplikacji do konstruktora należy opakować końcowy obiekt HttpApp w middleware serwera. Typowe elementy to Logger, CORS, GZip i ErrorHandling.

Kolejność ma znaczenie: najbardziej zewnętrzna warstwa widzi żądanie jako pierwsza, a odpowiedź jako ostatnia.

import org.http4s.server.middleware._

val finalApp = Logger.httpApp(true, false)(
  CORS.policy.withAllowOriginAll(app)
)

Konfiguracja

Hosta, port i dane uwierzytelniające należy odczytywać ze środowiska za pomocą biblioteki konfiguracyjnej, takiej jak ciris lub pureconfig, zwracając konfigurację jako część obiektu Resource albo efektu.

Należy unikać wpisywania portów na stałe, aby ten sam plik binarny działał w różnych środowiskach.

val port = sys.env.get("PORT")
  .flatMap(Port.fromString)
  .getOrElse(port"8080")

Kontrola stanu i obserwowalność

Należy udostępnić trasę sprawdzającą aktywność, taką jak GET /health, zwracającą 200, aby orkiestratory mogły sprawdzać proces. Dla lepszej widoczności należy dodać middleware do logowania żądań i zbierania metryk.

Kontrole stanu powinny być szybkie i niezależne od zależności, aby odzwierciedlały stan procesu, a nie usług downstream.

val health = HttpRoutes.of[IO] {
  case GET -> Root / "health" => Ok("UP")
}

Szybkie sprawdzenie

Proszę przypomnieć sobie, dlaczego serwer jest modelowany jako obiekt Resource.

Podsumowanie

Uruchomiono aplikację za pomocą EmberServerBuilder, powiązano ją przy użyciu literałów ip4s i uruchomiono z poziomu IOApp za pomocą build.use(_ => IO.never).

Skomponowano zasoby, opakowano aplikację w middleware, odczytano konfigurację ze środowiska, dodano trasę kontroli stanu i wykorzystano Resource do kontrolowanego zamykania.

Często zadawane pytania

Czy lekcja „Udostępnianie aplikacji” jest bezpłatna?

Tak — pełny tekst „Udostępnianie aplikacji” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Co nauczysz się w „Udostępnianie aplikacji”?

Uruchomi Pan/Pani funkcyjny serwer WWW. Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?

Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Udostępnianie aplikacji”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?

Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Scala for Backend Engineering & Functional Programming