Best way to deploy play2 app using Amazon Beanstal

问题:

I found fragmented instructions here and some other places about deploying Play2 app on amazon ec2. But did not find any neat way to deploy using Beanstalk.

Play is a nice framework and AWS beanstalk is one of the most popular services then why is there no official instruction to do this?

Has anyone found any better solution?

回答1:

Deploying a Play2 app on elastic beanstalk is now easy with Docker Containers in combination with sbt's experimental docker feature.

In build.sbt specify the exposed docker ports:

dockerExposedPorts in Docker := Seq(9000)

You should automate the following steps, but you can try this out manually to test that it works:

Generate a Dockerfile for the project by running the command: sbt docker:stage. Go to the ./target/docker/ directory. Create an elastic beanstalk Dockerrun.aws.json file with the following contents:

{
   "AWSEBDockerrunVersion": "1",
   "Ports": [
       {
           "ContainerPort": "9000"
       }
   ]
}

Zip up everything in that directory, let's say into a file called play2-test-docker.zip. The zip file should contain the files: Dockerfile, Dockerrun.aws.json, and files/* directory.

Go to aws beanstalk console and create a new application using the m3.medium or any instance type with enough memory for the jvm to run. Any instance with too little memory will result in a JVM error.

Select "Docker Container" in the Predefined Configuration dropdown.

In the application selection screen, select "Upload" and select the zip file you created earlier. Launch the app and then go brew some tea. This can take a very long time. Minutes. Subsequent deployments of the same app version should be slightly quicker.

Once the app is running and green in the aws console, click on the app's url and you should see the welcome screen of the application (or whatever your index file is).

回答2:

Here's my solution that doesn't require any additional services/containers like Docker or Jenkins.

Create a dist folder in the root of your Play application's directory. Create a Procfile file containing the following contents and put it in the dist folder (EB requires port 5000):

web: ./bin/YOUR_APP_FILE_NAME -Dhttp.port=5000 -Dconfig.file=conf/application.conf

The YOUR_APP_FILE_NAME is the name of the executable in the bin directory, which is inside the .zip created by activator dist.

After running activator dist, you can just upload the created zip file into Elastic Beanstalk and it will automatically deploy the app. You also put whatever .ebextension folders and configuration files into the dist folder that you require for Elastic Beanstalk configuration. Ex. I have dist/.ebextensions/nginx/conf.d/proxy.conf for NGINX reverse proxy settings or dist/.ebextensions/env.config for environment variables.

回答3:

Edit 2016: There's now a much better way to deploy your Playframework apps onto ElasticBeanstalk using the new Java SE containers.

Here's an article that walks you through deploying step by step using Jenkins to build and deploy your project: https://www.davemaple.com/articles/deploy-playframework-elastic-beanstalk-jenkins/

---

You can use custom AMIs that I keep updated here: https://github.com/davemaple/playframework-nginx-elastic-beanstalk

These run Nginx + Playframework and support standard zip files created using "activator dist".

回答4:

We also saw this as being too much of a pain and have added native Play 2 support to Boxfuse to address this.

You can now simply do boxfuse run my-play-app-1.0.zip -env=prod and this will automatically:

• create a minimal AMI tailor-made for your Play 2 app
• create an elastic IP
• create a security group with the correct permissions
• launch an instance of your app

All future updates are performed as blue/green deployments with zero downtime.

This also works with Elastic Load Balancers and Auto-Scaling Groups and the Boxfuse free tier is designed to fit the AWS free tier.

You can read more about it here: https://boxfuse.com/blog/playframework-aws

Disclaimer: I'm the founder and CEO of Boxfuse

回答5:

I had some problems with other solutions found here and there. I guess that the problem is that I'm developing on Play 2.4.

Anyway, I could deploy the app to Beanstalk using Typesafe Activator and Docker:

• In build.sbt I added this lines:

import com.typesafe.sbt.packager.docker.{ExecCmd, Cmd}

// [...]

dockerCommands := Seq(
  Cmd("FROM","java:openjdk-8-jre"),
  Cmd("MAINTAINER","myname"),
  Cmd("EXPOSE","9000"),
  Cmd("ADD","stage /"),
  Cmd("WORKDIR","/opt/docker"),
  Cmd("RUN","[\"chown\", \"-R\", \"daemon\", \".\"]"),
  Cmd("RUN","[\"chmod\", \"+x\", \"bin/myapp\"]"),
  Cmd("USER","daemon"),
  Cmd("ENTRYPOINT","[\"bin/myapp\", \"-J-Xms128m\", \"-J-Xmx512m\", \"-J-server\"]"),
  ExecCmd("CMD")
)

• I went to the project's directory and ran this command in the terminal

$ ./activator clean docker:stage

• I opened the [project]/target/dockerdirectory and created the file Dockerrun.aws.json. This was its content:

{
  "AWSEBDockerrunVersion": "1",
  "Ports": [
    {
      "ContainerPort": "9000"
    }
  ]
}

• In the same target/docker directory, I tested the result, built, checked and ran the image:

$ docker build -t myapp .
$ docker images
$ docker run -p 9000:9000 myapp

• As everything was ok, I zipped the content:

$ zip -r myapp.zip *

My zip file had Dockerfile, Dockerrun.aws.json and stage/* files

• Finally, I created a new Beanstalk app and uploaded the zip created on the last step. I took care of select "Generic Docker" on "Predefined configuration", when I was creating the app.

回答6:

Beanstalk only supports WAR deployment and Play doesn't officially support WAR deployment. If you want to use EC2 then you should instead just create an EC2 instance and follow the deployment instructions: http://www.playframework.com/documentation/2.2.x/ProductionDist

回答7:

Deploying play 2.* apps in aws ec2 is very diffrent until you have found this much better way to do it. I mean ansible is promising a great solution to that. though it is still needed to work with new setup of ansible, and its playbook but that must be worthy. I have found these reads very recently and yet to apply them in my project. I hope following reads will help you to learn more:

Ansible + play + aws ec2

Read it to know more about Ansible to deply play in aws

Thanks! Hope this will help you to kick your start. Please do share more knowledge you gain during the procedure or if there is any simple way to solve this complicated deployment problem.