Moderniser une application web avec Scala, Play et Mongo DB

Une présentation que j'ai donnée à Scala.io 2014.

Transcript

1. Moderniser une application web avec Scala, Play et Mongo DB Nouhoum Traoré arolla @nouhoumtraore
2. Plan • Contexte • Architecture • Migration des données • Tests • Bonnes pratiques • L’équipe et Scala
3. Qui suis-je ? blog.nouhoumtraore.com blog.arolla.fr
4. Contexte
5. keljob.com
6. Site d’emploi généraliste lancé en 2000
7. Quelque refontes depuis
8. 2008 : Struts, Spring, Hibernate, Resin...
9. 2011 : Changement de modèle
10. 2014 : Play, Scala, Mongo DB, Angular JS
11. Nos contraintes • Itérer rapidement • S’adapter à différents canaux de diffusion • Fournir une bonne expérience utilisateur
12. Pourquoi Play ? • Embrasse HTTP • Templating type safe et refactoring • Hot reload • Scala / JVM • Asynchrone (réactif) !
13. Pourquoi Mongo DB ? • Document / Objet • Flexibilité du schéma • Asynchrone (réactif) !
14. Architecture
15. L’architecture avant la refonte
16. Modèle de données DAO Batchs Actions Struts SQL Server App externe Home page Version Mobile Partenaires Espace Candidats Recherche et liste Service
17. Ce qui ne nous va pas ! • Peu de place laissée aux APIs • Adhésion à la base de données • Technologies vieillissantes • Application monolithique
18. Que faire ? Et comment ?
19. L’architecture cible REST API App externe Batchs Site responsive Apps mobile Mongo DB Partenaires
20. Mais pas de big bang !
21. Que faire et comment ? Modèle de données DAO Batchs Actions Struts SQL Server App externe Home page Version Mobile Partenaires Espace Candidats Recherche et liste Service
22. Espace candidats
23. Endetté Technique & UX
24. Que faire et comment ? Modèle de données DAO Batchs Actions Struts App externe Home page Partenaires Recherche et liste Service Espace Candidats Version Mobile REST API Mongo DB SQL Server
25. Vue macro Load balancer Struts monolithique REST API Play ! Espace Candidats Play ! Mongo DB SQL Server
26. L’application externe et la base SQL Server App externe
27. L’application externe et la base App externe Mongo DB Batch Akka Format pivot
28. L’architecture a un air de scène d'opération chirurgicale....
29. Migration des données L’autre challenge !
30. État des lieux • +10 ans de données candidats • Crucial pour le business • Interdit de mal faire
31. Stratégie • Migrer le plus tôt possible • Migrer souvent • Vérifier souvent
32. Mise en oeuvre • Un acteur par type de donnée • Paralléliser quand c’est possible • Arrêt de la base SQL au basculement vers la prod !
33. Tests
34. L’API dévient centrale dans la nouvelle architecture
35. Elle doit être bien testée
36. Test API : l’approche • Ne pas mocker la base • Mongo DB embarqué • Lancé une fois pour tous les tests
37. embedmongo https://github.com/flapdoodle-oss/de.flapdoodle.embed.mongo + play test
38. Test API : la mise en oeuvre import play.api.test._ object MongoSetup { lazy val Config = Map( "mongodb.servers" -> List("localhost:12345"), "mongodb.db" -> "test" ) def appWithEmbeddedMongo = FakeApplication( additionalConfiguration = Config ) }
39. Test API : la mise en oeuvre import mongo.MongoSetup._ import play.api.test.{WithServer, PlaySpecification} case class WithApiServer() extends WithServer( port = 3333, app = appWithEmbeddedMongo )
40. Test API : lancer Mongo testOptions in IntegrationTest += Tests.Setup( () => mongo.MongoLauncher.start ) testOptions in IntegrationTest += Tests.Cleanup( () => mongo.MongoLauncher.stop )
41. Test API import play.api.test._ trait ApiTest extends PlaySpecification { lazy val BaseUrl = "http://localhost:3333" lazy val injector = Guice.createInjector( new TestModule() ) def Api = WithApiServer() }
42. Test API : l’exemple class SignupApiSpec extends ApiTest { val RequestUrl = s"$BaseUrl/accounts" s"POST on $RequestUrl" should { "create an account with the provided email and password" in Api { val data = Json.obj( "email" -> "zanke@email.com", "password" -> "secret" ) val response = await(WS.url(RequestUrl).post(data)) response.status must be equalTo CREATED (response.json \ "message").as[String] === Messages("info.signup.success") } }
43. Bonnes pratiques
44. Le frontend • Client de l’API • Zéro accès à la DB • Essentiellement du JavaScript
45. Le frontend • 9 % Scala • 26.2 % CSS • 64.8 % JS
46. Le frontend : asset pipeline pipelineStages := Seq(rjs, digest, gzip)
47. Le frontend : asset pipeline curl http://keljob.com/assets/js/e454f1013e30b783818c8efaf3a8e3a5-startup.js HTTP/1.1 200 OK Cache-Control: public, max-age=31536000 Content-Length: 171997 Content-Type: application/javascript; charset=utf-8 Date: Tue, 14 Oct 2014 22:39:23 GMT ETag: e454f1013e30b783818c8efaf3a8e3a5 Last-Modified: Wed, 08 Oct 2014 12:35:10 GMT
48. Compresser les contenus import play.api.mvc._ import play.filters.gzip.GzipFilter object Global extends WithFilters(new GzipFilter()) { ... }
49. API : des liens dans le JSON implicit val AccountWrites = new Writes[Account] { override def writes(account: Account): JsValue = Json.obj( "id" -> account.id, "email" -> account.email, "creationDate" -> account.creationDate.toString(), "links" -> Json.obj( "self" -> routes.AccountDetailCtrl.get(account.id).url, "alerts" -> routes.JobAlertDetailCtrl.getAlertsOf(account.id).url, "cv" -> routes.CvDetailController.getCvOf(account.id).url ) )
50. Une responsabilité par objet
51. Les contrôleurs @Singleton class AccountValidationController @Inject() ( accountValidator: AccountValidator) extends Controller { def validateAccount(token: String) = Action.async { request => accountValidator.validate(token).map { case Some(account) => Ok(Json.toJson(account)) case _ => UnprocessableEntity(Json.toJson(InvalidToken)) } }
52. Les services class AccountAuthenticator @Inject() (...) class AccountValidator @Inject() (...) class AccountCreator @Inject() (...) class AccountSettingsUpdater @Inject() (...)
53. Les acteurs import akka.actor._ ... class CvExporter(...) extends Actor { def commonBehavior(): Receive = ??? def deleteBehavior(): Receive = ??? def updateBehavior(): Receive = ??? def receive = commonBehavior orElse updateBehavior orElse deleteBehavior }
54. Batch, un jar exécutable ! akka, sbt-assembly et scopt
55. Gestion des erreurs : services sealed trait NewsletterError case object InvalidNewsletterActivationToken extends NewsletterError case object NewsletterUpdateError extends NewsletterError class NewsletterActivator @Inject() (...) { def activate(code: String): Future[Either[NewsletterError, Boolean]] = ??? }
56. Gestion des erreurs : contrôleurs class NewsletterActivationController ( newsletterActivor: NewsletterActivator) extends Controller { def activate(token: String) = Action.async { request => newsletterActivor.activate(token).map { … case InvalidNewsletterActivationToken => ??? case NewsletterUpdateError => ??? … }.recoverApiError("Oops !!!") } }
57. Gestion des erreurs : contrôleurs implicit class ApiErrorRecover(result: Future[Result]) { def recoverApiError(message: String) = result recover { case NonFatal(e) => InternalServerError( Json.toJson(SimpleError(message)) ) } }
58. L’équipe devs : @mmagn, @karesti, @nouhoumtraore + les autres !
59. L’équipe : recette simple • Vouloir sortir de sa zone de confort • Préférer la simplicité… • Communiquer et s’entraider
60. Merci Des questions ?
61. Références • https://www.playframework.com • https://github.com/ReactiveMongo/ReactiveMongo • https://github.com/scopt/scopt • http://akka.io