{"id":8388,"date":"2015-11-13T16:15:25","date_gmt":"2015-11-13T14:15:25","guid":{"rendered":"http:\/\/www.webcodegeeks.com\/?p=8388"},"modified":"2015-12-16T10:45:45","modified_gmt":"2015-12-16T08:45:45","slug":"heroku-style-application-deployments-docker","status":"publish","type":"post","link":"https:\/\/www.webcodegeeks.com\/ruby\/heroku-style-application-deployments-docker\/","title":{"rendered":"Heroku Style Application Deployments with Docker"},"content":{"rendered":"

In this article, we describe how you can use Kontena\u2019s experimental features for deploying application with Kontena just like with Heroku!<\/em><\/p>\n

Developing and deploying applications to Heroku<\/a> was revolutionary when it was introduced. A developer could just focus on developing a killer app instead of configuring servers and build scripts.<\/p>\n

Heroku, just like many other platform-as-a-service<\/a> (PaaS) solutions, allows developers to deploy applications written in a supported programming language, to a hosted cloud platform. The deployment is typically made with git push<\/code> to a PaaS platform specific repository. On deploy, the platform will detect the programming language and build and run the application.<\/p>\n

With PaaS platforms, developers can enjoy highly automated deployment processes. Kontena<\/a> aims to enable the same convenience for people moving away from PaaS solutions to Docker containers. Since Heroku is one of the most polished and developer-friendly PaaS platforms out there, we wanted to see if it\u2019s possible to create a similar development workflow with Kontena.<\/p>\n

Getting an Application Running on Kontena<\/h2>\n

After you have provisioned Master node and host nodes, you\u2019re ready to start deploying applications to Kontena. See our Quick Start<\/a> guide for more details.<\/p>\n

The first step of running your application on Kontena is to Dockerize it. With Kontena it\u2019s easy: Just call kontena app init<\/code> command. It creates the necessary Dockerfile<\/code>, docker-compose.yml<\/code>, and kontena.yml<\/code> files.<\/p>\n

The generated Dockerfile is by default based on Buildstep<\/a> which enables Heroku-style application builds with Docker. Buildstep has a list of officially supported buildpacks<\/a> that are built-in and ready to be used.<\/p>\n

In addition to Dockerfile generation, Kontena parses the app.json<\/code> manifest file and Procfile<\/code>. Based on those files, it describes necessary application and add-on services in kontena.yml<\/code> and generates related environment variables in .env<\/code> file.<\/p>\n

When your application is Dockerized, you can deploy it with kontena app deploy<\/code> command. On deploy, Kontena builds a Docker image for your application automatically, detects your application type based on the source code, and prepares the required running environment for it.<\/p>\n

After the build is ready, Kontena pushes the created Docker image to image registry. By default, Kontena uses a built-in, self-hosted Docker registry<\/a>, but you can change it in kontena.yml<\/code>.<\/p>\n

On deployment, Kontena orchestrates Docker containers and deploys the app to host nodes.<\/p>\n

When the deploy completes, you have your app and all necessary add-on services up and running.<\/p>\n

Example<\/h2>\n

Let\u2019s try this out with a simple Heroku styled Ruby\/Sinatra application<\/a> that has one endpoint that shows how many times page has been visited:<\/p>\n

web.rb<\/h2>\n
require 'sinatra'  \r\nrequire 'redis'\r\n\r\nget '\/' do  \r\n  redis = Redis.new(:url => ENV['REDIS_URL']) \r\n  redis.incr \"count\" \r\n  \"Hello, world called #{redis.get(\"count\")} times\" \r\nend<\/pre>\n
Then we define our application in app.json<\/code> manifest with one openredis<\/code> addon:<\/p>\n
{ \r\n  \"name\": \"Sinatra example application\", \r\n  \"description\": \"This app is a basic Sinatra application.\", \r\n  \"keywords\": [ \r\n    \"kontena\", \r\n    \"ruby\", \r\n    \"sinatra\", \r\n    \"redis\" \r\n  ], \r\n  \"website\": \"http:\/\/www.kontena.io\", \r\n  \"repository\": \"https:\/\/github.com\/kontena\/redis-example\", \r\n  \"success_url\": \"\/\", \r\n  \"addons\": [ \r\n    \"openredis\" \r\n  ] \r\n}<\/pre>\n
We also need to introduce our processes in Procfile<\/code>:<\/p>\n
web: bundle exec ruby web.rb -p $PORT<\/pre>\n
Now we\u2019re ready to Dockerize our application by running:<\/p>\n
$ kontena app init<\/pre>\n
It creates all the necessary Docker and Kontena related files and services, and we can just deploy our app:<\/p>\n
$ kontena app deploy<\/pre>\n
Scaling the Application<\/h2>\n
In order to scale the application, we need to attach it to a Kontena Load Balancer<\/a>. To do that, we must first create a load balancer service to the grid:<\/p>\n
$ kontena service create --ports 80:80 internet_lb \r\nkontena\/lb:latest<\/pre>\n
Then we can edit the kontena.yml<\/code> file and set the number of running instances and attach service to the load balancer service. That can be done with external_links<\/code> property and environment variables:<\/p>\n
web:  \r\n  ... \r\n  instances: 2 \r\n  external_links: \r\n    - internet_lb \r\n  environment: \r\n    - KONTENA_LB_MODE=http \r\n    - KONTENA_LB_BALANCE=roundrobin \r\n    - KONTENA_LB_INTERNAL_PORT=5000 \r\n    - KONTENA_LB_VIRTUAL_HOSTS=www.yourdomain.com,yourdomain.com<\/pre>\n
See example kontena.yml<\/a> for the complete example.<\/p>\n
After that we can just re-deploy our web service:<\/p>\n
$ kontena app deploy web<\/pre>\n
Conclusion<\/h2>\n
We have demonstrated that it\u2019s possible to have a Heroku-like application development workflow when working with Docker containers. You can enjoy best parts of both worlds: a super-easy application development workflow combined with pure Docker containers.<\/p>\n
We\u2019re still working and experimenting with this feature, so expect to see some changes in the future. Some of the improvements we\u2019re thinking about include:<\/p>\n