Compute Commoditization & App Deployment
Cloud compute has been commoditised with the influx of service providers. A potentially valuable approach would be to shift the development focus toward the aspects that are prone to user error and rely on developers’ particular deployment know-how.
The past years have witnessed a notable increase in the abstraction, availability, and reliability of computing resources — the infrastructure questions that pertain to rolling-updates, seamless deployment, and unbound* scaling have largely been answered.
This has resulted in a significant amount of crowding in the compute abstraction and application deployment space. To demonstrate, below are several potential solutions that are likely to surface during an inquisition:
- Claudia.js https://github.com/claudiajs/claudia
- Empire https://github.com/remind101/empire
- Deis http://deis.io/
- Various AWS services — -Lambda, ECS
- Flynn https://flynn.io/
- Octohost https://github.com/octohost
- Tsuru https://tsuru.io/
- Mesos http://mesos.apache.org/
After perusing available options, a common theme emerges — every other project is vaguely a potential solution to your compute management — whether it is in terms of clustering/abstracting resources, continuous integration, or what have you.
A rather intensive part of the process, which seems inadvertently left out, is the human effort that is required to identify the ideal combination of tools in order to serve your applications’ particular purposes.
As with any nascent tech subdiscipline — the landscape is evolving in a rather haphazard way. Most of the services that proliferate tend to fail in serving any purpose besides gratifying their creator’s misguided hubris, ultimately dismaying would-be users of the technology. Assuming prospective users aren’t specialists, or do not keep up with the developments that seem to be happening at breakneck speeds.
For the sake of this discussion, let us consider the constituents of a fully orchestrated container-based cloud:
- Infinitely scalable
- Continuously integrated
- End-to-end security
These features are predicated on either architecting a fully-functioning cloud, or relying upon hosted services — either way, it can be argued that a sizeable portion of application developers that deploy on such clouds fail to capitalise on the gains that these tools bring forward — as their applications must be architected with cloud-specific deployment considerations in mind, e.g. ephemerality (i.e. stateless servers) and microservice-orientation to achieve scalability.
In effect, it’s time to shift our focus to the deployment considerations that have *not* been eliminated.
The intent is to attain seamless application deployment, removing friction from the process. While several available services have created hosting & clustering solutions, potential pitfalls remain for developers.
These pitfalls could degrade the deployment process, its accompanying user experience and most importantly, the quality & efficacy of the deployment:
- Misconfiguration — (partially solved by the host of current service providers)
- Server misconfiguration — this can be potentially be eliminated altogether by relying on services that offer pre-assembled packages (e.g. container registries or custom build-packs on PaaS services).
- Application misconfiguration — typically deployment-specific configuration is required, which is removed from the development & programming education paradigms, making it an additional barrier to overcome for novice/intermediate programmers and a time-sink for product-focused devs.
- Build misconfiguration — variations in application-specific environments, or the common development-production chasm. Solved by container tools (e.g. docker).
2. Lack of Optimisation
- Devops as “incidental” — development-focused organisations might neglect optimising the deployment environment and the relevant architectural aspects of their applications. Moreover, these developers tend to hack together disparate deployment workflows that that could be unreliable.
- Core optimisation — An as of yet unexplored paradigm is utilising run-time information to deduce recommendations to improve core application performance based on inferences from operational patterns.
This pitfall resolution approach plays well into an angle constantly overlooked by the vast majority of techie founders & their enterprises, solving user problems in lieu of technical problems.