• Play 2 Framework

    Play 2 ist ein modernes Open-Source Webframework. Play 2 ist für die Umsetzung von hochverfügbaren Webapplikationen von Lightbend entwickelt worden. Unternehmen wie Zalando, LinkedIn, TheGuardian, Wallmart oder Twitter nutzen diese Webtechnologie für den Betrieb ihrer Online-Plattformen. 

    In durchgeführten Studien zur Performance und anderen Faktoren für unsere Kunden, konnte sich das Framework klar gegen Konkurrenten aus dem .NET, Node.JS und Java EE Umfeld durchsetzen.

    Da Play in Scala, einer modernen JVM Sprache, programmiert worden ist, kann es in neueren Versionen auch mit der Programmiersprache Java verwendet werden. Mithilfe des Play 2 Frameworks lassen sich Applikationen leicht und ohne große Konfigurationen entwickeln. 

     

  • Lagom Microservices Framework

    Lagom ist ein modernes Open-Source Microservice Framework von Lightbend. Es basiert auf Technologien von Lightbend, wie dem Play 2 Framework oder akka. Mithilfe von Lagom können veraltete, große Softwaresysteme, die als Monolith in Java EE programmiert worden sind, mithilfe von moderner Microservice Architektur neu entwickelt und verbessert werden.

     

  • Für unser Produkt innCart benötigten wir eine mobile App für Android und iOS. Aufgrund der guten Erfahrungen mit React-Native haben wir uns für dieses Framework entschieden. Da unser Backendservice in Scala programmiert wird, galt es zu evaluieren, ob wir bei der Programmierung auf Scala mit ScalaJS setzen. Dieser Artikel soll das Ergebnis darstellen.

    React-Native

    Das JavaScript-Framework "React" von Facebook ist neben Angular eines der beliebtesten und spannendsten Frameworks für Webapplikationen, die es derzeit in der JavaScript-Welt gibt.

    React bietet mit der Ausprägung "React-Native" auch die Möglichkeit Mobile Apps in JavaScript zu schreiben - und zwar plattformübergreifend! Dies funktioniert in der Praxis so gut, dass zahlreiche Hersteller Ihre Apps mit dieser Technologie umsetzen. Facebook, Instragram, Airbnb oder auch MieterCast sind nur einige der bekannteren Beispiele. Auch die Community rund um React-Native wächst derzeit stark an. Es gibt mittlerweile für fast alle Bedürfnisse Bibliotheken und Beispiele. Und wenn es doch mal zu einem Problem kommt, hilft die React-Native Usergroup in München weiter.

    Eigentlich alles super - wäre da nur nicht JavaScript! Mit ES6 hat sich JavaScript zwar wieder ein großes Stück in die richtige Richtung bewegt, aber für größere Projekte wünscht man sich die Vorteile einer typisierten Sprache, auf die nachfolgend noch näher eingegangen wird.

    Scala

    Als Alternative zu TypeScript haben wir Scala genauer unter die Lupe genommen. Beide Sprachen ermöglichen eine typisierte Entwicklung. Der TypeScript bzw. Scala Sourcecode wird nach JavaScript transcompiliert und ist somit von jedem Browser interpretierbar und in Kombination mit React-Native auch als Smartphone App nutzbar. Wie eingangs erwähnt lassen wir TypeScirpt außen vor und beschäftigen uns nur mit der Frage, ob es für uns Sinn macht, bei der App-Entwicklung in React-Native auf Scala zu setzen oder stattdessen lieber direkt in JavaScript zu entwickeln.

    Um Scala-Code nach JavaScript zu übersetzen ist der Transcompiler Scala.js notwendig. Damit man in Scala auch React-Native verwenden kann, haben wir das Framework SRI (Scala React Interface) verwendet. In folgender Grafik wird der Technologie-Stack mit Scala (links) und ohne Scala (rechts) dargestellt:

    ScalaJS vs JavaScript React-Native Stack 

    Nach einer ausgiebigen Versuchsreihe mit der Verwendung von Scala in Kombination mit React-Native haben sich folgende Vor- und Nachteile herauskristallisiert:

     

    Vorteile

    Starke Typisierung

    Die Unterstützung von Typen, Klassen und Interfaces (bzw. Traits) wirkt sich besonders bei großen Projekten in Form von robusterer und besser wartbarer Software aus. Des Weiteren ist durch die Typisierung eine bessere IDE-Integration möglich, was erheblich zum Komfort bei der Entwicklung beiträgt und ein nicht zu unterschätzender Faktor ist.

    Optimierter JavaScript-Code

    Der Scala.js-Compiler optimiert den bei der Übersetzung den JavaScript-Output. Dies ergibt in der Regel eine bessere Performance.

    Scala als Sprache für Back- und Frontend

    Speziell bei innFactory setzen wir für Cloud- und Serveranwendung zunehmend auf Scala. Mit Scala und React-Native könnten wir ein Teil dieses Know-Hows auch in der Frontendentwicklung der mobilen Clients nutzen.

     

    Nachteile

    Viele Abhängigkeiten

    Wie die obige Grafik zeigt, ergeben sich neben React-Native noch zwei zusätzliche Abhängigkeiten, Scala und SRI. Zudem kommen noch externe Bibliotheken hinzu, die für Scala angepasst werden müssen. Bei einer neuen Version von nur einer einzelnen Komponente im Stack kann es zu Konflikten bei den anderen Abhängigkeiten kommen. Das Auffinden von Fehlerquellen ist nur dann leicht gegeben, wenn es sich um eine schlanke Architektur mit nur wenigen externen Bibliotheken handelt. 

    Kleine Community

    Da die Technologien bisher nur wenige Unterstützer auf github haben, wäre eine Einstellung des Supports ein weitaus größeres Risiko. Abgesehen von Scala.js steckt hinter dem Stack kein professioneller Support, sondern lediglich sehr gute Freizeitprojekte. Vor allem bei SRI besteht hier eine sehr große Unsicherheit, da es nur wenige Entwickler gibt. 

    Benötigtes Wissen in beiden Technologien (Scala und React-Native)

    Gute Scala-Entwickler sind schwer zu finden. Für React gibt es inzwischen etwas mehr. Aber Programmierer aufzuspüren, die beide Technologien beherrschen ist fast ein Ding der Unmöglichkeit.

    Während die Einarbeitungszeit für einen JavaScript-Entwickler in React-Native nur wenige Tage bis Wochen beträgt, erhöht sie sich in Kombination mit Scala auf einige Monate. Für Scala-Programmierer beträgt die Zeit zum Aufbau des Know-Hows nicht ganz so lange, aber auch hier müssen die Konzepte von React, wie z.B. die Redux-Architektur, erstmal verinnerlicht werden.

     

    Fazit

    Für uns hat Scala einen festen Platz, wenn es um Backend- und Cloudentwicklungen geht. Die Idee mit Scala auch JavaScript zu erzeugen ist sehr spannend. Aber für das anstehende Projekt überwiegen in unserem Fall die Nachteile eindeutig. Der Technologie-Stack ist leider noch zu wackelig. Auch die Aufstockung des Entwicklerteams könnte sich als extrem schwierig erweisen. Allein letzterer Punkt würde für uns als K.O.-Kriterium ausreichen.

    Wir finden, dass sich das Scala.js-Projekt in die richtige Richtung bewegt und werden es sehr genau im Auge behalten. Für unsere Produktentwicklung aber, werden wir auf reines React-Native für die App setzen und Scala als primäre Technologie im Backend verwenden.

     

  • Im Rahmen eines Kundenprojektes besuchte Tobias vergangene Woche die Scaladays in Kopenhagen. Zusätzlich besuchte er ein Meet-Up von Lightbend zum Thema Fast Data Plattform und die Typelevel Summits, die unmittelbar nach den Scaladays stattgefunden haben. In Zahlen konnte Tobias 25 verschiedene Talks von Speakern aus der ganzen Welt sehen. Insgesamt also sehr viel neuer Input in den Bereichen Scala, akka, play und co. 

    Neben vielen Themen in den Bereichen von Streaming Data (akka streaming, fast data plattform) und Microservices (CQRS, Datenvalidation mit Cats) war auch der neue Scala Compiler Dotty ein großes Thema der Konferenz. Die angesprochenen Verbesserungen sind alle sehr vielversprechend. Neben mehr Geschwindigkeit bei der Compilezeit wird die Sprache Scala an sich klarer und in unseren Augen weiter stark verbessert. 

    Ein für unser noch eher neues, aber dennoch sehr interessantes Framework ist scala meta. Das scala meta Livecoding in Form einer Erweiterung für REST APIs, war ein tolles Beispiel von Pathikrit Bhowmick. Der beste Talk der Konferenz kam in unseren Augen von Gabriele Petronella („Monad transformers down to earth“). Eine ähnlich gute Erklärung zu Monaden ist uns in Scala bisher nicht bekannt gewesen. 

    Für unser Projekt croGoDeal von großem Interesse waren auch die Talks von IBM zu Spark, sowie von Salesforce zu deren Plattform Einstein und der Spark Erweiterung namens Optimus Prime. Wir hoffen, dass diese typsichere Erweiterung von Spark in absehbarer Zeit als Open-Source Projekt veröffentlicht wird, sodass man dieses hervorragende Tool auch außerhalb von Salesforce benutzen kann.

    Alle Talks der Konferenz findet man auf dem YouTube Channel der ScalaDays.

     

     

     

     

  • Reaktive Systeme sind Computersysteme die kontinuierlich auf ihre Umgebung reagieren. Der in diesem Zusammenhang geprägte Begriff des Aktorenmodells wurde erstmals in den frühen 1970er Jahren von Carl Hewitt verwendet. Sein mathematisches Model beschreibt ein universales Verfahren zur parallelen Programmierung.  Er war seiner Zeit weit voraus, da zu diesem Zeitpunkt die Rechner noch nicht leistungsfähig genug waren. Das Modell wurde erstmals 1987 in der Programmiersprache Erlang von Ericsson verwendet. Durch den Einsatz der Technologie konnte Ericsson einen Switch mit einer Zuverlässigkeit von 99,999999999% bauen. Dies entspricht einer Ausfallzeit von unter 0.65 Sekunden in 20 Jahren. In den nachfolgenden Jahrzehnten stieg die Leistung der Computer immer weiter an. Anfang des neuen Jahrtausends erreichten die Prozessoren mit den eingesetzten Materialien ihre maximale Taktfrequenz. Prozessorhersteller, wie Intel und AMD, bauten fortan Prozessoren mit mehreren Prozessorkernen bei gleichbleibender Taktfrequenz. Einerseits kann die Hitzeentwicklung bei noch höheren Taktraten mit herkömmlichen Mitteln nicht mehr bewältigt werden. Andererseits kommt es bei immer kleineren Transistoren zu quantenmechanischen Seiteneffekten. Heute erhöhen die Hersteller die Anzahl der Kerne pro CPU, um dennoch eine Leistungssteigerung der CPUs zu erreichen. Dadurch steigt die Relevanz von paralleler Programmierung, da die Berechnung der Algorithmen auf mehrere CPU-Kerne verteilt werden muss. Die Entwicklung von Software mit mehreren Threads, oder über mehrere Rechner hinweg, ist für Entwickler mit vielen Problemen verbunden und kompliziert. Dies ist unter anderem auf die Speicherverwaltung der Threads und Prozesse zurückzuführen. Als Folge entstehen in den letzten Jahren immer mehr reaktive Frameworks für moderne Programmiersprachen, wie zum Beispiel akka für Scala und Java. Reaktive Frameworks bieten dem Entwickler aber weitaus mehr, als nur einfache Parallelisierung über mehrere Prozesse und physikalische Knoten. Mithilfe der Frameworks lassen sich hochskalierbare, fehlertolerante Systeme entwerfen. In diesem Blogbeitrag, wollen wir das Aktorenmodell genauer betrachten.


    Der Entwurf von nebenläufigen Anwendungen stellt seit Jahren eine Herausforderung dar, für die es keine einfache Lösung gibt. Das Aktorenmodell stellt eine erprobte und vergleichsweise einfache Weise dar, nebenläufige Algorithmen umzusetzen. Das Aktorenmodell ist ein Architekturmuster, dass auf Basis von Nachrichtenaustausch (=Message Passing) eine verteilte Applikation ermöglicht, ohne dabei einen geteilten Zustand (=Shared State) mit mehren Aktoren zu benötigen. Das Aktorenmodell ist vielfach implementiert, teils in funktionalen Sprachen wie Erlang, teils als Frameworks wie akka oder libcppa. Ein Aktor ist ein leichtgewichtiger und autonomer Prozess. Dem Aktor können Nachrichten geschickt werden, für die er ein eigenes Verhalten bereit hält, welches sich zur Laufzeit in der Regel nicht verändert. Ein Aktor arbeitet dabei immer nur eine Nachricht gleichzeitig ab. Das Aktormodell ist nicht an spezielle Datenstrukturen gebunden, sodass Aktoren lose gekoppelt untereinander kommunizieren können. Leichtgewichtig ist ein Aktor, da er kein eigenen Prozess besitzt, sondern zum Verarbeiten einer Nachricht einen Prozess zugewiesen bekommt. Aktoren nutzen die verfügbaren Ressourcen eines Threads optimal aus und blockieren die Verarbeitung nicht. 

    Aktorenmodell Actors akka

    Die Abbildung zeigt ein beispielhaftes Netz von Aktoren. Jeder Aktor hat seine eigene Mailbox und einen isolierten Zustand. Basierend auf seinem definierten Verhalten antwortet der Aktor mit dem versenden einer eigenen Nachricht oder erstellt eigene Aktoren und ändert sein zukünftiges Verhalten. Zusammengefasst definiert sich ein Aktorsystem durch folgende Eigenschaften:

    • Ein Aktor kann andere Aktoren erschaffen und mit ihnen kommunizieren.
    • Jeder Aktor hat einen eindeutigen Namen, der als Adresse bei der Kommunikation verwendet werden kann. (in akka)
    • Die Kommunikation zwischen Aktoren basiert auf dem Senden von asynchronen, unveränderbaren (=immutable) Nachrichten an andere Aktoren.
    • Die Nachrichten werden zur Verarbeitung in einer Mailbox gepuffert. Sie ist eine Queue mit n Produzenten (Senderaktor) und einem Konsumenten (Empfängeraktor)
    • Abhängig von der Reihenfolge, den Prioritäten oder dem internen Zustand werden die Nachrichten mittels Pattern Matching von internen Funktionen verarbeitet, die die Ergebnisse ihrerseits wieder als Nachrichten versenden. 

    Akka bildet das Aktorenmodell als Framework für die JVM ab. Es wird häufig in den Programmiersprachen Scala und Java verwendet und wurde erstmals im Juli 2009 bei GitHub von Jonas Bonér veröffentlicht. Ein Aktor ist in akka die kleinste Einheit im System und übernimmt in der Regel eine bestimmte Aufgabe. Dabei kann der Aktor seinen Zustand, und damit das Verhalten beim Eintreffen bei weiteren Nachrichten, verändern. Der Zustand eines Aktors wird durch die Werte seiner Variablen definiert. Diese Werte können ausschließlich durch eingehende Nachrichten anderer Aktoren geändert werden. Da es keine gemeinsamen Speicherbereiche mit anderen Aktoren gibt, ist gewährleistet, dass der Zustand eines Aktors nicht durch Zugriffe von außen manipuliert werden kann. Sollte ein Aktor durch einen Fehler zum Absturz gebracht werden, kann der Supervisor, also der Erzeuger des Aktors, den Aktor neu initialisieren und wiederherstellen. Das Verhalten eines Aktors bezeichnet die Logik die beim Eintreffen einer Nachricht ausgeführt wird. Die Logik kann jederzeit als Reaktion auf eine Nachricht verändert werden. Jeder Aktor hat genau eine Mailbox für den Empfang von Nachrichten. Die Mailbox ist standardmäßig eine First In – First Out (FiFo) Queue. Die Queue der Mailbox kann in akka so konfiguriert werden, dass bestimmte Nachrichten priorisiert bearbeitet werden. Auch die Größe der Queue ist frei definierbar.   

    akka bietet noch viele weiter Vorteile, die in vielen verschiedenen Blogbeiträgen im Internet und in einschlägigen Büchern beschrieben werden. Dazu zählen unter anderem der Remotezugriff oder das Clustering. Diese Fähigkeiten, macht akka zu einem hervorragendem Framework für moderne Microservices. Häufig findet man akka im sogenannten SMACK Stack wieder - SMACK steht hierbei für Spark, Mesos, akka, Cassandra, Kafka. Dieser Stack ist die Basis für unser Fast Data System bei croGoDeal.


    Reaktive Programmierung ist aktuell wie nie zuvor. Der Begriff ist allerdings nicht genau definiert. Somit bezeichnen sich viele Applikationen als reaktiv, die es gar nicht sind. Reaktive Programmierung wird häufig mehr als Buzzword für eine spezielle Art von asynchrone Programmierung verwendet. Die vermutlich am besten passende Beschreibung einer reaktiven Architektur liefert das Reactivo Manifesto. Das möglichst einfache Erreichen der Ziele des Reactivo Manifestos verfolgen diverse Frameworks. Eines der besten für Java und Scala ist derzeit akka. Es ist mit verhältnismäßig einfachen Mitteln möglich antwortbereite, widerstandsfähige, elastische und nachrichtenorientierte Systeme auf Basis der JVM zu implementieren. Ein Java oder Scala Softwarearchitekt für skalierbare Applikationen sollte sich unbedingt erweiterte Kenntnisse in akka aneignen und das Framework in seine Planung mit einbeziehen.   

  • Wir haben auf github eine erste Alpha Version unseres Machine Learning Tools "akka-lift-ml" unter der Apache 2.0 Lizenz veröffentlicht. Das Tool setzt nach der Arbeit eines Data Scientist an und übernimmt einen Großteil der Aufgaben im Betrieb von ML Systemen. Häufig spricht man auch von Data Engineering. akka-lift-ml ist in Scala geschrieben und erweitert eine lokale Spark Instanz für die Trainingsresultate. Das Training selbst kann auf jedem über das Netzwerk erreichbare Spark Cluster durchgeführt werden.

    Damit das Tool die Machine Learning Aufgaben erfolgreich umsetzten kann, müssen die Daten vollständig bereinigt worden sein. Dies lässt sich beispielsweise mit Spark Streaming oder akka Streaming in nahezu Echtzeit erledigen (FastData Processing). Wenn die Daten im richtigen Format, zum Beispiel csv auf HDFS oder S3, abgelegt worden sind, kann das Training direkt beginnen. Das gesamte Tool wird im Betrieb über REST Schnittstellen oder Aktoren gesteuert und als Docker Container ausgeliefert. So können beispielsweise über HTTP POST neue Trainingsläufe gestartet werden, neue beste Parameter gefunden werden und auch mit HTTP GET auf die Ergebnisse der vergangenen Trainingsdurchläufe zugegriffen werden. Sollte der Microservice abstürzen, wird automatisch das letzte trainierte Model von einer Quelle wie S3 oder HDFS geladen. 

    Derzeit unterstützt das Tool lediglich den ALS (Alternating Least Squares) Algorithmus für Collaborative-Filtering. Dieser wird sehr häufig im Bereich Recommendersysteme eingesetzt. Weiter Algorithmen wie für lineare Regression sollen ergänzt werden. 

    Wünsche, Anregungen und Verbesserungsvorschläge können Sie uns gerne über github zukommen lassen.

    Weitere Informationen und eine QuickStart Guide finden sie in der Beschreibung oder im Wiki System auf github:

    https://github.com/innFactory/akka-lift-ml

     

  • Der nachfolgende Blogbeitrag soll den Einstieg in die DevOps Welt mit Amazon Web Services vereinfachen. Wir werden alle notwendigen Schritte anhand von Screenshots in der AWS Konsole durchgehen und eine Pipeline mit AWS CodePipeline aufbauen. Die Pipeline soll mit einem GitHub Repostiory beginnen, mit CodeBuild gebuildet werden und über CodeDeploy im Echtbetrieb in einer Elastic Beanstalk Umgebung enden. Als Referenzprojekt für eine Microservice kann unser giter8 Template für akka-http oder akka-graphql verwendet werden. Bei beiden müssen allerdings kleine Änderungen vorgenommen werden. Die Pipeline soll akka Microservices, die das Buildtool sbt verwenden, in den Betrieb überführen. Für Java Server, wie Payara Micro oder Wildfly Swarm, können nur ein paar Schritte verwendet werden. Vor allem die Vorbereitung des Projektes auf GitHub unterscheidet sich von einem Scala/Java akka Projekt.


    Bevor wir mit den Anpassungen unserer Dateien in unserem GitHub Repository beginnen, müssen wir zuerst ein Docker Repository anlegen. Dazu wechseln wir in die Elastic Container Service Oberfläche und klicken auf „Create Repository“. Wir vergeben hier lediglich den Namen unseres Projektes (innfactory-akka-http-ci-test) und schreiben uns die Repository URI auf. Mehr müssen wir in diesem Dienst nicht machen.

    EC2 Container Registry


    Als nächstes benötigen wir eine neue Datei Dockerrun.aws.json für AWS CodeDeploy. Die Werte bei Image – Name müssen entsprechend unseres ECR Repositorys angepasst werden. In diesem Beispiel pushen wir unserer Docker Container immer auf latest. Für mehrere Branches in github sind weitere Anpassungen notwendig.

      "AWSEBDockerrunVersion": "1",
      "Image": {
        "Name": "149805022439.dkr.ecr.eu-central-1.amazonaws.com/innfactory-akka-http-ci:latest",
        "Update": "true"
      },
      "Ports": [
        {
          "ContainerPort": "8080"
        }
      ]
    }
    

    Für den Buildprozess mit AWS CodeBuild benötigen wir nun noch eine buildspec.yml Datei die wie folgt aussehen kann. Die Variablen bleiben leer, denn sie werden später mithilfe von Umgebungsvariablen von AWS ersetzt. Unsere giter8 Templates sind für Docker vorbereitet, somit können die benötigten Parameter beim sbt docker:publish Aufruf übergeben werden. 

    version: 0.2
    
    env:
      variables: 
        STAGE: "dev"
        SQLURL: ""
        SQLUSER: ""
        SQLPASSWORD: ""
    
    phases:
      install:
        commands:
          - echo "continuous delivery for stage[$STAGE]"
          - echo "selected db=$SQLURL"
          - echo "$(lsb_release -cs)"
          - apt-get update -y
          - apt-get install -y apt-transport-https ca-certificates software-properties-common
          - add-apt-repository -y ppa:openjdk-r/ppa
          - sudo apt-get update -y
          - apt-get install -y openjdk-8-jdk
          - echo "deb https://dl.bintray.com/sbt/debian /" | sudo tee -a /etc/apt/sources.list.d/sbt.list
          - apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 2EE0EA64E40A89B84B2DF73499E82A75642AC823
          - apt-get update -y
          - apt-get install -y sbt
          - pip install --upgrade awscli
      pre_build:
        commands:
          - $(aws ecr get-login --no-include-email --region eu-central-1) 
      build:
        commands:
          - sbt test
          - sbt -DSTAGE=$STAGE -DSQL_URL=$SQLURL -DSQL_USER=$SQLUSER -DSQL_PASSWORD=$SQLPASSWORD docker:publish
      post_build:
        commands:
          - echo Build completed on `date`
    artifacts:
      files:
        - Dockerrun.aws.json 

    Einrichtung einer Elastic Beanstalk Umgebung

    Bevor wir mit der Continuous Delivery Pipeline beginnen, starten wir zuerst eine neue Elastic Beanstalk Umgebung, da diese ein paar Minuten zum Start benötigt. 

    Hierzu wechseln wir in der AWS Konsole zum Dienst Elastic Benastalk und erstellen eine neue Applikation.

    Create new Elastic Beanstalk application

    In dieser Applikation erstellen wir wiederum eine neue Umgebung (Web server environment) und konfigurieren diese als Docker Platform und lassen erst einmal die Sample Application von Amazon darauf laufen. 

    Beanstalk Environment Tier wählen

    Wir müssen keine weiteren Anpassungen mehr vornehmen und können die Umgebung mit einem Klick auf „Create environment“ erstellen. Alle nicht vorhandenen, aber benötigten, Informationen werden von AWS automatisch ergänzt. 

    AWS Beanstalk Environment Einstellungen

    Sollten wir weitere Anpassungen vornehmen wollen, können wir dies unter „Configure more options“ tun. Hier können wir unter anderem die zu startenden Instanzengrößen wählen, die Load Balancer mit https konfigurieren, das Monitoring anpassen, das richtige VPC Netzwerk auswählen, eine RDS Datenbank hinzufügen und noch vieles mehr. Als Hinweis dazu sei erwähnt, dass man niemals eine RDS Datenbank für den produktiven Betrieb in Beanstalk konfigurieren sollte. Diese hängt sonst an der Umgebung und wird gegebenenfalls zusammen mit der Umgebung gelöscht. 

    Nach ein paar Minuten sollte unsere Elastic Benastalk Umgebung mit der Sample Application von AWS gestartet sein.

    Elastic Beanstalk Übersicht


    Erstellung der Pipeline mit AWS CodePipeline

    Beginnen wir mit der eigentlichen Pipeline. Zuerst müssen wir einen Namen vergeben. Dieser kann später nicht mehr verändert werden und sollte er sinnvoll gewählt werden. 

    AWS CodePipeline anlegen

    Als nächstes müssen wir die Quelle unserer Pipeline auswählen. Sollte unser Projekt in AWS CodeCommit gehostet sein, kann dies ebenso verwendet werden wie GitHub. Wir verwenden in diesem Beispiel unsere GitHub Organisation innFactory und ein beliebiges akka sbt Projekt. Unter Advanced müssen wir keine Einstellungen vornehmen und wir können die Pipeline automatisch bei einem neuen git push auf den master starten lassen.

    Code Pipeline Quelle (CodeCommit oder GitHub)

    Für die Buildphase nutzen wir CodeBuild von AWS. Hierzu wählen wir „Create a new build project“ und konfigurieren die Einstellungen wie auf den nachfolgenden Screenshots zu sehen. Wir können beliebige Umgebungsvariablen hinzufügen, die in der buildspec.yml Datei aufgelöst werden. Wir haben dies bereits für unsere Datenbankparameter verwendet und die Konfiguration unseres akka Projektes wird, wenn es als Docker Instanz läuft, mit diesen Variablen überschrieben. Für produktive Systeme sollten die Passwörter nicht als Plaintext übergeben werden, sondern ein EC2 Parameter Store verwendet werden.

    AWS CodeBuild konfiguration

    AWS CodeBuild Umgebungsvariablen für RDS Datenbank

    Auf der Seite für das Deployment können wir unsere Elastic Beanstalk Application und unsere Umgebung mit der Sample Application verwenden.

    CodePipeline Deployment zu Elastic Beanstalk

    Zum Schluss müssen wir noch noch eine Rolle für die Pipeline anlegen und alle bisher definierten Rollen über AWS IAM anpassen. Wichtig ist, dass unsere verwendeten Rollen Zugriff auf das Docker Repository und auf Beanstalk haben. Sollte dies nicht konfiguriert worden sein, wird die Pipeline mit entsprechender Meldung fehlschlagen.

    CodePipeline Service Rolle


    Nachdem wir die Pipeline nun vollständig konfiguriert haben, startet diese automatisch. Haben wir alles richtig gemacht und alle Berechtigungen richtig vergeben sollte das Ergebnis wie folgt aussehen und die Sample Application in Elastic Beanstalk durch unseren neuen Docker Container ersetzt worden sein. 

    AWS akka CodePipline Erfolgreicher Deploy