Introdução

Neste tutorial, você aprenderá a implementar microserviços escaláveis utilizando Scala, Akka, Play Framework e Docker. Os microserviços têm se tornado uma arquitetura popular por sua capacidade de ajudar na escalabilidade e manutenção de sistemas complexos. O Akka fornece um modelo de programação reativa que facilita a construção de sistemas que são mais resilientes e responsivos. Por outro lado, o Play Framework oferece uma maneira simples e produtiva de criar aplicações web em Scala. Finalmente, o Docker permitirá que você empacote sua aplicação de maneira consistente em diferentes ambientes. Este guia é ideal para desenvolvedores iniciantes que desejam mergulhar no desenvolvimento de microserviços com essas tecnologias poderosas.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Certifique-se de que você tenha o Java, Scala e o SBT (Scala Build Tool) instalados em sua máquina. Para verificar as versões instaladas, use os comandos `java -version`, `scala -version` e `sbt sbtVersion`. Se você não tiver essas ferramentas instaladas, siga as instruções disponíveis em seus sites oficiais.

    commands
    # Verificar versões instaladas
    java -version
    scala -version
    sbt sbtVersion

  2. Criação do Projeto Play Framework

    Utilize o SBT para criar um novo projeto Play Framework. Execute o comando `sbt new playframework/play-scala-seed.g8`. Isso criará um novo projeto Scala pronto para desenvolvimento. Navegue até a pasta do projeto criador e abra a estrutura do projeto em seu IDE.

    commands
    sbt new playframework/play-scala-seed.g8
    cd nomeDoProjeto

  3. Configuração do Akka

    Adicione a dependência do Akka no arquivo `build.sbt` do seu projeto. O Akka é usado para estruturar a lógica do microserviço. Insira as seguintes linhas no arquivo `build.sbt`:

    build.sbt
    libraryDependencies += "com.typesafe.akka" %% "akka-actor" % "2.6.16"

  4. Criação de um Ator com Akka

    Implemente um ator que será responsável por gerenciar a lógica de negócio. Crie um arquivo chamado `HelloActor.scala` no diretório `app/actors` e adicione o seguinte código:

    HelloActor.scala
    package actors

import akka.actor.{Actor, ActorSystem, Props}

class HelloActor extends Actor {
  def receive = {
    case "hello" => sender() ! "Hello, World!"
  }
}

object HelloActor {
  def props: Props = Props[HelloActor]
}

  5. Integração do Ator na Aplicação

    Modifique o controlador padrão `HomeController` para incluir a lógica de invocação do ator. Altere `HomeController.scala` da seguinte maneira:

    HomeController.scala
    package controllers

import akka.actor.ActorSystem
import actors.HelloActor
import javax.inject._
import play.api.mvc._

import scala.concurrent.ExecutionContext

@Singleton
class HomeController @Inject()(cc: ControllerComponents)(implicit system: ActorSystem, ec: ExecutionContext) extends AbstractController(cc) {
  private val helloActor = system.actorOf(HelloActor.props)

  def index() = Action.async { implicit request: Request[AnyContent] =>
    (helloActor ? "hello").mapTo[String].map { response =>
      Ok(response)
    }
  }
}

  6. Criação de Dockerfile

    Crie um arquivo chamado `Dockerfile` na raiz do seu projeto. Este arquivo conterá as instruções para construir a imagem Docker da sua aplicação. Adicione o seguinte conteúdo:

    Dockerfile
    FROM openjdk:11

WORKDIR /app
COPY target/scala-2.13/*.jar app.jar

ENTRYPOINT ["java", "-jar", "app.jar"]

  7. Construção e Execução da Imagem Docker

    Execute os comandos abaixo para compilar seu projeto e criar a imagem Docker. Substitua `nomeDoProjeto` pela pasta do seu projeto:

    commands
    sbt assembly
    docker build -t meu-microservico .
    docker run -p 9000:9000 meu-microservico

  8. Testes Unitários

    Crie testes para o ator `HelloActor`. Crie um arquivo chamado `HelloActorTest.scala` na pasta `test/actors` e adicione o seguinte código:

    HelloActorTest.scala
    package actors

import akka.actor.ActorSystem
import akka.testkit.{TestActors, TestKit}
import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}

class HelloActorTest extends TestKit(ActorSystem("HelloActorTestSystem")) with WordSpecLike with Matchers with BeforeAndAfterAll {

  override def afterAll(): Unit = {
    TestKit.shutdownActorSystem(system)
  }

  "A HelloActor" should {
    "respond with 'Hello, World!' when it receives 'hello'" in {
      val helloActor = system.actorOf(HelloActor.props)
      helloActor ! "hello"
      expectMsg("Hello, World!")
    }
  }
}

  9. Executando Testes

    Para executar seus testes, utilize o comando SBT. Isso garantirá que todas as funcionalidades do ator e do controlador estejam validas.

    commands
    sbt test

Conclusão

Neste tutorial, você aprendeu a implementar microserviços escaláveis usando Scala, Akka, Play Framework e Docker. Desde a configuração do ambiente até a construção de containers Docker, você foi guiado por todo o processo. A estrutura de ator do Akka permite que sua aplicação seja mais responsiva e resiliente, enquanto o Play Framework facilita o desenvolvimento de aplicações web em Scala. Agora, você tem uma base sólida para continuar explorando microserviços e poderá evoluir seu conhecimento com projetos mais complexos.

Hashtags

#Scala #Akka #PlayFramework #Docker #Microservices #DesenvolvimentoDeSoftware