Scala for Backend Engineering & Functional Programming · Aula

Disponibilizando o aplicativo

Execute um servidor web funcional.

Disponibilizando o aplicativo é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

Servidor Ember

O http4s executa seu HttpApp[F] em um back-end. A escolha moderna padrão é o Ember, um servidor escrito inteiramente em Scala e construído sobre cats-effect e fs2, disponível como org.http4s.ember.server.EmberServerBuilder.

Aplicações mais antigas podem usar o Blaze, mas o Ember é o caminho recomendado daqui em diante.

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

Construindo o servidor

EmberServerBuilder.default[F] fornece um construtor que você configura de forma encadeada: associa o servidor ao host e à porta, conecta a aplicação e então chama .build para obter um Resource[F, Server].

Usar um Resource garante que o soquete seja liberado durante o encerramento.

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

Literais do ip4s

O Ember usa tipos do ip4s para redes com segurança de tipos. Os interpoladores ipv4"..." e port"..." validam os valores em tempo de compilação, portanto um endereço inválido ou uma porta fora do intervalo não será compilado.

Importe com.comcast.ip4s._ para acessá-los.

import com.comcast.ip4s._

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

Ciclo de vida do Resource

O servidor é um Resource porque possui um soquete que precisa ser aberto e fechado corretamente. resource.use(_ => ...) mantém o servidor em execução durante toda a duração do efeito interno.

Use IO.never para executar até que o processo seja interrompido.

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

Ponto de entrada do IOApp

A classe principal de uma aplicação http4s estende IOApp, que fornece um ambiente de execução gerenciado pelo cats-effect. Você implementa run, retornando IO[ExitCode].

O IOApp gerencia conjuntos de threads, tratamento de sinais e encerramento normal para você.

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

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

Uma classe principal completa

Juntando tudo: construa o recurso do servidor e depois use use com IO.never para manter o processo ativo, retornando ExitCode.Success.

Este é o ponto de entrada canônico do http4s.

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

Compondo recursos

Aplicações reais adquirem mais do que um servidor: um conjunto de conexões de banco de dados, um cliente HTTP e configurações. Componha-os em uma única compreensão for sobre Resource para que todos sejam liberados na ordem inversa.

Passe os clientes adquiridos para a construção das rotas.

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

Encerramento normal

Como o servidor vive em um Resource, cancelar a fibra, por exemplo, ao receber SIGTERM sob o IOApp, executa o finalizador que interrompe a aceitação de conexões e fecha o soquete.

O Ember esvazia as requisições em andamento dentro de um tempo limite de encerramento configurável.

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

Middleware do servidor

Envolva o HttpApp final com o middleware do servidor antes de entregá-lo ao construtor. Alguns exemplos comuns são Logger, CORS, GZip e ErrorHandling.

A ordem importa: o invólucro mais externo vê a requisição primeiro e a resposta por último.

import org.http4s.server.middleware._

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

Configuração

Leia o host, a porta e os segredos do ambiente usando uma biblioteca de configuração, como ciris ou pureconfig, retornando a configuração como parte de um Resource ou efeito.

Evite codificar portas diretamente para que o mesmo binário seja executado em diferentes ambientes.

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

Integridade e observabilidade

Exponha uma rota de disponibilidade, como GET /health, que retorne 200 para que os orquestradores possam verificar o processo. Adicione registro de requisições e middleware de métricas para obter visibilidade.

Mantenha as verificações de integridade simples e sem dependências, para que reflitam o estado do processo, e não o estado dos serviços downstream.

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

Verificação rápida

Relembre por que o servidor é modelado como um Resource.

Recapitulação

Você disponibilizou a aplicação com EmberServerBuilder, associou-a usando literais do ip4s e a executou a partir de um IOApp com build.use(_ => IO.never).

Você compôs recursos, envolveu a aplicação com middleware, leu a configuração do ambiente, adicionou uma rota de integridade e confiou no Resource para o encerramento normal.

Perguntas Frequentes

A aula “Disponibilizando o aplicativo” é grátis?

Sim — o texto completo de “Disponibilizando o aplicativo” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

O que vou aprender em “Disponibilizando o aplicativo”?

Execute um servidor web funcional. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Disponibilizando o aplicativo”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming