Desenvolvendo Microserviços em Scala: Um Guia Prático com Akka e Play Framework para Construção de Aplicações Escaláveis

Introdução

Neste tutorial, você será guiado pelo processo de desenvolvimento de microserviços utilizando Scala, Akka e Play Framework. Vamos explorar como cada uma dessas tecnologias se integra para criar aplicações escaláveis e resilientes. O enfoque será em conceitos práticos e exemplos de código prontos para uso, de modo que você possa criar uma aplicação microserviços do início ao fim. O uso do Akka fornece um poderoso modelo de programação reativa, enquanto o Play Framework oferece uma base sólida para construir APIs web. Ao final deste guia, você terá uma compreensão clara de como implementar microserviços escaláveis e estará preparado para expandir seus conhecimentos em desenvolvimento com Scala.

Etapas

Configuração do Ambiente de Desenvolvimento
Certifique-se de ter o JDK (Java Development Kit) e o SBT (Scala Build Tool) instalados na sua máquina. Verifique as versões instaladas utilizando os comandos `java -version` e `sbt -version`. Caso não possua as ferramentas necessárias, siga as instruções de instalação disponíveis nos sites oficiais do Java e do SBT.
commands
```
# Verificar versões instaladas
java -version
sbt -version
```
Criação do Projeto Play
Utilize o SBT para criar um novo projeto Play Framework. Execute o comando `sbt new playframework/play-scala-seed.g8` e siga as instruções para configurar seu projeto. O projeto será configurado para uma estrutura básica com uma aplicação de exemplo.
commands
```
# Criar o projeto com SBT
sbt new playframework/play-scala-seed.g8
```
Configuração do Akka
Adicione as dependências do Akka ao seu projeto. Edite o arquivo `build.sbt` para incluir o Akka. Isso permitirá que você utilize o modelo de ator do Akka em sua aplicação.
build.sbt
```
libraryDependencies += "com.typesafe.akka" %% "akka-actor" % "2.6.18"
```

Implementação do Modelo de Ator

Crie uma classe de ator simples para gerenciar um modelo de ‘Usuario’. Esta classe irá lidar com mensagens de criação e recuperação de usuários.

UsuarioActor.scala

import akka.actor.{Actor, Props}

case class Usuario(id: String, nome: String)

class UsuarioActor extends Actor {
  private var usuarios = Map.empty[String, Usuario]

  def receive = {
    case usuario: Usuario =>
      usuarios += (usuario.id -> usuario)
    case id: String =>
      sender() ! usuarios.get(id)
  }
}

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

Criação do Controlador Play

Crie um controlador em Play que utilize o ator que você implementou. Isso permitirá que você crie APIs RESTful para interagir com o modelo de usuários.

UsuarioController.scala

import javax.inject._
import play.api.mvc._
import akka.actor.{ActorSystem, Props}

@Singleton
class UsuarioController @Inject()(val controllerComponents: ControllerComponents)(implicit system: ActorSystem) extends BaseController {
  private val usuarioActor = system.actorOf(UsuarioActor.props)

  def createUsuario = Action { implicit request: Request[AnyContent] =>
    // Lógica para criar usuário e enviar para o ator
    Ok("Usuário criado")
  }

  def getUsuario(id: String) = Action { implicit request: Request[AnyContent] =>
    // Lógica para recuperar usuário do ator
    Ok("Usuário recuperado")
  }
}

Configuração do Roteamento
Configure as rotas no arquivo `conf/routes` para mapear as requisições HTTP para os métodos do controlador que você criou. Isso permite que o Play Framework conecte as requisições às suas ações.
routes
```
GET     /usuarios/:id         controllers.UsuarioController.getUsuario(id: String)
POST    /usuarios              controllers.UsuarioController.createUsuario
```

Implementação de Testes Unitários

Crie testes unitários para o controlador e o ator. Utilize o framework de testes do Scala para validar a lógica implementada e garantir que os usuários estão sendo manipulados corretamente.

UsuarioControllerSpec.scala

import org.scalatestplus.play.
import play.api.test._
import play.api.test.Helpers._

class UsuarioControllerSpec extends PlaySpec with OneAppPerTest {
  "UsuarioController" should {
    "create a user" in {
      val result = route(app, FakeRequest(POST, "/usuarios")).get
      status(result) mustBe OK
    }
  }
}

Executando a Aplicação e Testes

Use o SBT para compilar, executar a sua aplicação e executar os testes. Utilize uma ferramenta como Postman ou cURL para testar os endpoints da API e verificar se tudo está funcionando como esperado.

commands

# Compilar e executar a aplicação
sbt run
# Executar os testes
sbt test

curl_examples

# Criar um novo usuário
curl -X POST http://localhost:9000/usuarios -d '{"id":"1", "nome":"Usuario 1"}' -H 'Content-Type: application/json'
# Recuperar um usuário
curl -X GET http://localhost:9000/usuarios/1

Conclusão

Neste tutorial, você aprendeu a desenvolver microserviços escaláveis utilizando Scala, Akka e Play Framework. Abordamos desde a configuração do ambiente até a implementação de um serviço básico de usuários, incluindo a criação de controladores, configuração de rotas e testes unitários. Você agora possui uma base sólida para expandir suas aplicações e explorar mais profundamente os conceitos de programação reativa e sistemas escaláveis. Com essas ferramentas e técnicas, você está preparado para enfrentar desafios mais complexos em suas futuras implementações com microserviços.

Hashtags

#Scala #Akka #PlayFramework #Microserviços #DesenvolvimentoEscalável

copycoda.com.br