Home ADC Five Leading Practices for Dynamic Application Delivery in the Cloud

Five Leading Practices for Dynamic Application Delivery in the Cloud

By Jason Dover, KEMP Technologies

Moving your businesses’ infrastructure, including the application layer and associated APIs, to the cloud, is a daunting task given today’s plethora of digital tools available and heightened concerns over data protection, application performance and data integrity.

One of the most conveniently accessible options is Software-as-a-Service (SaaS) delivery via cloud computing, which offers businesses a reliable, cost-effective way to manage and track company IT consumption without the burden of managing physical servers. When moving in this direction it’s key to first scrutinize how best to optimize application delivery and accurately measure return-on-investment.

Enterprises are increasingly moving their consumer applications and services to a delivery model directly over the Internet, i.e. through a “public cloud” topology, due to massive computing infrastructures by leading PaaS/IaaS providers such as Amazon, Microsoft and Google being readily available with attractive cost structure. But leveraging the public cloud introduces inherent challenges with regards to quality of application delivery and performance because a company’s data now traverses through a series of externally maintained systems. Accordingly, enterprises looking to move to a SaaS app-delivery cloud model should consider the following:

  1. Application design should be as simple as possible to support the principles of a cloud model. Some older application architectures still used in the typical mature enterprise data center consist of complex webs of explicit one-to-one relationships between front-end and middle-tier server instances. As a result, many steps of configuration are required when adding new instances to scale the environment, multiplying the chances of configuration mistakes. Additionally, the elastic scalability associated with cloud environments becomes more difficult to implement because of these static dependencies. The model used for the development of new applications should instead allow requests from front-end instances to be dynamically steered to any middle-tier instance based on the performance and activity of the entire application framework.
  2. Applications should be stateless at the transport layer. This enables load sharing across as many front-end servers as possible as application needs grow without a contingency for particular servers to be responsible for particular user requests. Statelessness removes the need for special coding in the application to maintain state information about a stream of requests. Because of its lightweight nature, it’s ideal for environments where application instances must respond to large numbers of small queries or where large numbers of users are involved. When stateless transport communication to the front-end application tier is not a viable option based on the inner plumbing of the application, a load balancer/application controller (ADC) has the ability to ensure that client requests are directed back to the individual instance where client-specific session information is available.
  3. Applications should be architected with compatibility for self-service. To enable lines of business with agility and quick time-to-market for their application services, applications should be designed to be instantiated via a self-service provisioning “store” model available in private and public cloud frameworks. This provides the following benefits:
    • Simplified provisioning for application administrators
    • A forum for a holistic view of how application services are being consumed
    • Reduced time-to-market for business critical applications
    • Framework for business unit chargeback

    By taking the steps required to introduce this concept into an organization’s private cloud, it also prepares the application infrastructure for adoption of other public cloud principles as the transition is made to hybrid and public cloud.

  4. Application front-ends should have a loose coupling to backend databases. Similar to Microsoft’s architecture for Lync 2013, the utilization of modern enhancements in database technology should be adopted so that there is a loose coupling between front-end/middle-tiers and backend databases. This allows the application to continue to function if database replication between locations fails or other unexpected disruption occurs. In the past, database performance or availability issues would always result either in an immediate application outage or a slow degradation of functionality and performance with eventual culmination in a full service interruption. Taking advantage of the latest advancements in database technology and utilizing lazy writes and rehydration techniques, applications can be built so that they rely on the backend with less dependency and without the requirement for constant communication. Based on the fact that challenges still do exist with presentation of the correct iteration of database data in all possible locations across cloud boundaries at any given point in time, there is compelling reason to adopt this methodology when planning the architecture of new applications.
  5. Build your applications to support easy scalability and dynamic instantiation. The process needed to add new application instances to a pool should be reduced to “spinning up” the new server instances, making required DNS changes and adjusting the settings on the responsible load balancer/ADC to receive and steer traffic for the new instance, ideally through an orchestration platform. The need for complex changes inside the application and supporting web services beyond basic security setting updates to acknowledge the new IP address, should be avoided where possible. This allows for better support of the dynamic nature of cloud models.

For business-critical apps that may have PID (personally-identifiable data) or compliance concerns like PCI (Payment Card Industry) standards, public-private hybrid cloud models are gaining currency and are readily available in live-production, enterprise-class topologies. Having a true private cloud model already in place with applications utilizing cloud-optimization principles provides the framework for successfully moving to this model.

Jason Dover is global Product Marketing Manager for KEMP Technologies based in New York City.

You may also like

This website uses cookies to improve your experience. We'll assume you're ok with this, but you can opt-out if you wish. Accept Read More

Privacy & Cookies Policy