I have always seen a huge disconnect between development and operations when it comes to building and deploying applications. It’s typical for an application to be built on a single development server and to be handed off to operations to be deployed on a distributed cloud system with numerous servers, load balancers and cloud storage.
Operations are then expected to hack things together to make the application run on a distributed cloud system. There is usually no time to go back to development to redesign the application to take full advantage of cloud infrastructures. The result is that applications are deployed as is and scalability and high availability is either compromised or nonexistent.
What to discuss and address early on:
- How will shared storage be handled and will the application work with S3 like storage (NFS and similar are a poor fit for the cloud)
- How will user sessions be handled in a load-alanced environment (e.g. database or memcached)
- Will the application work with autoscaling (need logic to drain sessions upon scale down events)
- Does the application have the capacity to take advantage of “read only” database slaves, “database sharding” or NoSQL databases
- Do you use any software that doesn’t have a cloud licensing model (this could get expensive)
- Cloud servers are transient and often have ephemeral storage this means they need to be disposable and quickly recreated (applications can’t rely on the same servers always being there and persistent local storage)
- Server IPs are often subject to change and application can’t be dependent on fixed IPs
- Installation and configuration of the application needs to be scriptable (say goodbye to any GUI installers)
- All application components need to be horizontally scalable (SOA and Queue based architectures work great for this)
- All application components have to handle failures of alike components without losing sessions and cache (central cache and sessions may be needed)
I think many of these get missed, because operations and development don’t come together in the design phase of the project, but only start interacting towards the deployment phase when its often too late. It’s ok for developers and operations to think differently and have different goals and concerns, but they need to collaborate early on and throughout the project.
ClearScale is able to have application developers and systems engineers work under the same roof and the culture of scalability is deeply ingrained in the company. This level of collaboration and the culture produces highly scalable and highly available applications and systems that we all desire.