One Year of Boxfuse

Last month marked one year since the initial version of Boxfuse was released. We are now many many features and over 100 Boxfuse Client releases further. And what a ride it's been!

Boxfuse set out to make the deployment of applications to the cloud absolutely effortless by leveraging its three core principles:

1. Immutable Infrastructure Creating servers and never modifying them again by treating a server as one immutable unit that is regenerated after every change and promoted unchanged from environment to environment. This eliminates drift and increases reliability by ensuring you run the exact same code in production as the code you tested in test.
2. Minimal Images Analysing your application and generating minimal tailor-made Linux-based images on the fly that are 100x smaller than a typical Linux system and take just seconds to produce.
3. Blue/Green deployments Deploying a new version of an app in parallel to the existing one and only making the switch at the elastic IP or elastic load balancer level once the configured health checks of the new version have passed. Deployments are fully automated and effectively transactional, providing you with zero-downtime updates.

The humble beginnings

We had to start out somewhere and so we picked one problem and decided to solve it better than anyone else out there: deploying Dropwizard applications to AWS:

This provided us with a great testbed to both validate our innovative technology (generating minimal images on-the-fly in seconds) as well as to pioneer our deep integration features (extracting port and healthcheck configuration directly out of Dropwizard's native configuration files)

We launched with support for testing locally on VirtualBox and performing blue/green deployments atomically on AWS with zero downtime updates. We introduced this both for single instance applications (using an Elastic IP) as well as load balanced applications (using an Elastic Load Balancer).

We have always been strong proponents of Continuous Deployments and making Boxfuse a natural fit for this was a no-brainer. From day one we shipped both a cross-platform CLI (the Boxfuse Command-line Client) as well as a build tool plugin (the Boxfuse Maven plugin) to make it trivial to automate your deployment workflows.

Expanding to more JVM frameworks

Building upon the foundation laid out with Dropwizard, Boxfuse successively added deep integration for most common modern JVM application frameworks. Over the course of this first year, Boxfuse added support for Spring Boot, Play, Grails, plain executable Jars, Tomcat and even TomEE for JavaEE applications.

We also made sure it is easy for users of those frameworks to discover Boxfuse by contributing sections to the official documentation of both Spring Boot and the Play framework.

And we introduced the Boxfuse Gradle Plugin (available directly from the Gradle Plugin Portal) to make the integration even nicer.


Auto-scaling is one of those true innovations of the cloud and it fits Boxfuse's immutable minimal images like a glove. So it was only natural that we added first-class support to dynamically scale the capacity of your system based on either CPU or network usage:

Database auto-provisioning

As many users rely on relational databases to store their data, Boxfuse stepped in to make sure it became absolutely trivial to provision PostgreSQL and MySQL databases reliably across all environments from dev on VirtualBox to test and prod on AWS.

This also marked the introduction of the Boxfuse Dev VM on VirtualBox, providing you with fully configured database instances ready to be used by your application, without the need to install those yourself on your machine.

Wherever your framework of choices supports it, Boxfuse also automatically configures it to automatically use the correct database instance with the correct credentials in each environment.

And of course to easily and reliably evolve your database schema over time, our database migration tool Flyway is there to help you too.

Debugging and Profiling

To make it easier to see what's going on with your application, Boxfuse introduced first class support for debugging and profiling, both locally on VirtualBox and directly in the cloud for your instances running on AWS.

As many of those protocols are insecure, Boxfuse automatically makes use of its support for restricted ports to ensure that by default those interfaces are only accessible from your current IP.


Based on widespread demand from our customers, we added support for our first language platform beyond the JVM with first class Node.js support.

As the Node.js runtime is more compact this resulted in super fast fusing times with images as small as 15 MB!

This is just the beginning

To mark the beginning of our second year, we are kicking things off with a bang and have released support for three new features:

  1. Node.js LTS releases: you can now use all current Node.js releases with Boxfuse in addition to the latest one
  2. Instance auto-recovery: all single instance applications now automatically recover to new hardware with no manual intervention required if the current underlying EC2 hardware becomes impaired
  3. Subnets restrictions: load balanced applications can now restrict exactly which subnets they wish to use within a VPC


But remember, this is just the beginning. We are only getting started!

So if you haven't already, sign up for your Boxfuse account now (simply log in with your GitHub id, it's free) to start deploying your JVM and Node.js applications effortlessly on AWS in minutes.

Join us and stay updated about Boxfuse and Immutable Infrastructure

Interesting posts with low frequency. Unsubscribe at any time.

« Deploying 15 MB Node.js VMs effortlessly to AWS
Oracle JRE and Kernel Tuning »
Recent posts