If you’re interested in this topic (agree or disagree), we’d love to have you join the community.
When developing an application, leveraging external services is a great way to outsource parts of application development so as to better focus on core competencies. For example, when building a CRM application, it might not be ideal to focus a heavy engineering effort on building out sophisticated infrastructure for reliable push notifications. Choosing the right off-the-shelf components can have a significant impact on both the speed of delivery and the ease with which an app can be ported to a Modern On-prem environment.
Such external services include everything from externally managed database services like RDS and Cloud SQL to full-service components like Algolia Search and Pusher, all the way to runtimes like Kubernetes and AWS Lambda. When developing an application for deployment into a Modern On-prem environment, it’s important to choose external dependencies that are swappable and embeddable. Furthermore, it’s valuable to provide a clean offramp for advanced customers to bring their own instances of those dependencies.
Choose things that are more likely for the customer to be able to manage themselves. For example, rather than the newest shiny database like Spanner or MongoDB, try to prefer a database that an Enterprise’s DBA is likely to be able to provision. Battle-tested tools like MySQL and Postgres are good options when choosing a database. Similar things can be said about search services, identity providers, and more. In general, it’s valuable to rely on open standards like LDAP and todo wherever possible. Some of the best examples of swappable components are traditional SQL databases and Kubernetes. These tools can be deployed uniformly across datacenter and private cloud environments.
For a truly portable environment, it’s important any external dependencies can be vendored into the application. Good examples of this tend to be open source components, like Redis, MySQL, and Postgres.
In general, its advisable to avoid proprietary hosted services, especially core runtime providers like Lambda and Cloud Functions. Doing so limits potential deployment targets to environments where enterprise users have access to these services in their own infrastructure. This advice doesn’t preclude the use of advanced runtimes, in fact, even Kubernetes itself can embedded with an application. Rather, it’s merely necessary to ensure any runtime provider is open and portable. For example, Knative and OpenFaaS are great examples of serverless frameworks that can be easily embedded in Modern On-prem applications.
Off-ramps for Advanced Customers
Using components that are both swappable and embeddable allows for delivery of an application that can meet a variety of end-customer requirements, from trial and PoC all the way through to production. Embeddable components allow for delivering a fully self-contained application, without requiring an end user to bring external components to get it working. This is incredibly valuable when performing small proof-of-concept installations that aren’t going to serve production data. Using open, swappable components ensures that when an enterprise wants to go to production, they can deploy their own, internally-managed versions of these components to ensure reliability.
Below are some examples of tools that can be leveraged during application development to ensure being able to cleanly deploy to Modern On-prem environments.
- Open source traditional databases: Redis, MySQL, and Postgres
- Wire-compliant cloud-native Databases: (cockroachdb, Yugabyte, tidb, Vitess)
- Open-source orchestrators - Kubernetes and Docker
- Open serverless runtimes - OpenFaas, and Knative
- Service Mesh implementations - Istio, linkerd, Consul