Scala for Backend Engineering & Functional Programming · Lektion

Die Anwendung bereitstellen

Betreiben Sie einen funktionalen Webserver.

Die Anwendung bereitstellen ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Ember-Server

http4s führt Ihre HttpApp[F] auf einem Backend aus. Die moderne Standardwahl ist Ember, ein in Scala implementierter Server auf Basis von cats-effect und fs2, verfügbar als org.http4s.ember.server.EmberServerBuilder.

Ältere Anwendungen verwenden möglicherweise Blaze, aber Ember ist künftig der empfohlene Weg.

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

Den Server erstellen

EmberServerBuilder.default[F] liefert einen Builder, den Sie fluent konfigurieren: Binden Sie Host und Port, hängen Sie die App an und rufen Sie anschließend .build auf, um eine Resource[F, Server] zu erhalten.

Die Verwendung einer Resource garantiert, dass der Socket beim Herunterfahren freigegeben wird.

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

ip4s-Literale

Ember verwendet ip4s-Typen für typsichere Netzwerke. Die Interpolatoren ipv4"..." und port"..." validieren bereits zur Compile-Zeit, sodass eine ungültige Adresse oder ein Port außerhalb des gültigen Bereichs nicht kompiliert werden kann.

Importieren Sie com.comcast.ip4s._, um darauf zuzugreifen.

import com.comcast.ip4s._

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

Lebenszyklus von Resource

Der Server ist eine Resource, weil er einen Socket besitzt, der ordnungsgemäß geöffnet und geschlossen werden muss. resource.use(_ => ...) hält ihn für die Dauer des inneren Effekts am Laufen.

Verwenden Sie IO.never, um ihn bis zur Unterbrechung des Prozesses auszuführen.

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

IOApp-Einstiegspunkt

Die Main-Klasse einer http4s-App erweitert IOApp, das eine verwaltete cats-effect-Laufzeitumgebung bereitstellt. Sie implementieren run, das IO[ExitCode] zurückgibt.

IOApp übernimmt Thread-Pools, Signalverarbeitung und das kontrollierte Herunterfahren für Sie.

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

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

Eine vollständige Main-Klasse

Zusammengeführt sieht es so aus: Erstellen Sie die Server-Resource und verwenden Sie sie anschließend mit IO.never, damit der Prozess weiterläuft und ExitCode.Success zurückgibt.

Dies ist der kanonische Einstiegspunkt für http4s.

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

Resources kombinieren

Reale Anwendungen beziehen mehr als nur einen Server: einen DB-Pool, einen HTTP-Client und Konfiguration. Kombinieren Sie sie in einer einzigen for-Comprehension über Resource, damit alle in umgekehrter Reihenfolge freigegeben werden.

Übergeben Sie die erworbenen Clients an die Routenerstellung.

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

Kontrolliertes Herunterfahren

Da der Server in einer Resource lebt, führt das Abbrechen des Fibers – beispielsweise bei SIGTERM unter IOApp – den Finalizer aus, der die Annahme neuer Verbindungen beendet und den Socket schließt.

Ember lässt laufende Anfragen innerhalb eines konfigurierbaren Zeitlimits zum Herunterfahren auslaufen.

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

Server-Middleware

Umschließen Sie die fertige HttpApp mit Server-Middleware, bevor Sie sie an den Builder übergeben. Häufig verwendet werden Logger, CORS, GZip und ErrorHandling.

Die Reihenfolge ist wichtig: Der äußerste Wrapper sieht die Anfrage zuerst und die Antwort zuletzt.

import org.http4s.server.middleware._

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

Konfiguration

Lesen Sie Host, Port und Geheimnisse mit einer Konfigurationsbibliothek wie ciris oder pureconfig aus der Umgebung und geben Sie die Konfiguration als Teil einer Resource oder eines Effekts zurück.

Vermeiden Sie fest codierte Ports, damit dasselbe Binary in verschiedenen Umgebungen ausgeführt werden kann.

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

Health und Observability

Stellen Sie eine Liveness-Route wie GET /health bereit, die 200 zurückgibt, damit Orchestratoren den Prozess prüfen können. Fügen Sie Middleware für Request-Logging und Metriken hinzu, um Einblick in das System zu erhalten.

Halten Sie Health-Checks kostengünstig und frei von Abhängigkeiten, damit sie den Zustand des Prozesses und nicht den nachgelagerter Systeme widerspiegeln.

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

Kurze Überprüfung

Erinnern Sie sich, warum der Server als Resource modelliert wird.

Zusammenfassung

Sie haben die App mit EmberServerBuilder bereitgestellt, sie mithilfe von ip4s-Literalen gebunden und aus einer IOApp mit build.use(_ => IO.never) ausgeführt.

Sie haben Resources kombiniert, Middleware vorgeschaltet, Konfiguration aus der Umgebung gelesen, eine Health-Route hinzugefügt und sich für ein kontrolliertes Herunterfahren auf Resource verlassen.

Häufig gestellte Fragen

Ist die Lektion „Die Anwendung bereitstellen“ kostenlos?

Ja — der vollständige Text von „Die Anwendung bereitstellen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Die Anwendung bereitstellen“?

Betreiben Sie einen funktionalen Webserver. Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?

Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Die Anwendung bereitstellen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?

Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Scala for Backend Engineering & Functional Programming