Alfonso Llanes, studied at Florida International University
The rise of cloud computing has spearheaded an era of unprecedented productivity for developers over the past several years. With the use of this point technology, gone are the days of long lead times for hardware procurement and installation, and architecture defined slow-moving hardware upgrades. As the barriers between development and delivery dissolve, new challenges have emerged that can disrupt the lives of developers and slow down conveyance of new products and features, giving back some of the efficiency gains that the Software-Defined Data Center has developed.
The cloud also bringing new challenges that emerge and can make troubleshooting applications more difficult.
There are four commonly recognized pain points:
Fluctuating Ownership
Adopting the cloud with limited support from an operations team. This is one of the growing numbers of areas where teams find themselves bridging both the operations and development worlds and life can become complicated.
The ability to spawn one’s own architecture without physical devices is refreshing and far more efficient. But, as developer tools, deployment tools, and cloud operations tools become inseparably linked to one another, the old boundaries between who is a developer and who is an operator become blurred or even removed altogether. The more time spend in the operations realm, especially, when it comes to troubleshooting an application or cloud resources the less time one is able to invest adding new value through code.
Burden of Responsibility
An old familiar buzzword when something went wrong with an app in production was for the responsibility to rest with the operations team that needed to prove the hardware was working and the network was healthy. That model has been reversed with the cloud: now the burden of responsibility is on the development team, because what is really hard is finding a problem that originates with someone else’s complex, abstracted, in a virtual data center.
Free Software Downloads
Such as database, queues, cache and the like, there is no any visibility into health other than the cloud provider’s status page and whatever you can directly observe. It’s either working correctly or it isn’t; if it isn’t, life gets a lot harder. On the other hand, servers can be monitored, but one can’t really tell why a virtual resource’s performance is lagging and if it is something environmental causing it and is out of any control.
Complexity and Temporality
Compounding the challenge of sorting through infrastructure issues vs. code issues is the simple fact that applications are becoming far more complex, and in many cases, portions of the overall architecture may be temporary in nature. Combine complexity with temporality and a recipe for investigative skills are borne to solve a real mystery at times.
The incredible thing about the cloud is that if one can imagine it, one can build it. Moreover if one needs to hug together .NET, Java, PHP, Node.js, Ruby, Database-as-a-Service for SQL and NoSQL, Message-Queues-as-a-Service, and Search-as-a-Service from a cloud deployment perspective is doable. This package has been made easy to get started and to deploy. But, a multilingual approach and a heavy reliance on software-defined services comes a new set of challenges:
Each of these new services comes with its own set of tricks for gaining insight into performance and availability, and each one may be different on how to monitor and troubleshoot.
Learning how to support a variety of different technologies creates a drag on delivery. It’s hard enough to learn the performance and reliability tricks of new technologies and trying it for a wide variety of goals; as well as, for adding new value and making the business more successful.
Dynamic resources, such as scale-on-demand servers, are likely to lose critical data that might be needed when troubleshooting a problem if prevention thought is not given to preserve critical insights that disappear with the server when it’s de-activated.
More Frequent Change
The increased agility that the cloud brings, especially when coupled with development tools that are integrated into the delivery cycle code can flow to production smoothly with greater frequency, and architecture changes can be made swiftly and easily. Unfortunately, with more frequent code releases and architecture changes that follow more frequent opportunities for error and break down occur.
There’s no denying that the cloud has impacted the life of many developers, mostly in a very positive way. Of course, with new technologies and capabilities always comes a new set of challenges for a learning curve. In the case of cloud-hosted applications, this includes challenges to effectively and efficiently support those applications in their new environments so that the gains in productivity aren’t given back in support of the application.
There are some basic steps that every development team should take to make supporting cloud-based applications easier.
Once an application is in production, there are several common questions that will need answers at a moment’s notice about this new application. For example, are users satisfied with the performance? Is anything silently failing and frustrating users without setting off alarms? If something failed, who is impacted, and what is the cause of the issue?
Closing Remarks
There’s no doubt that the cloud brings incredible capabilities to the lives of developers and operators alike: speed, agility, flexibility, scalability, and more. As with any new, disruptive technology, novel challenges also come for the ride. By applying some basic strategies on application management, monitoring and troubleshooting, one can have the advantages of the cloud without many of its inconveniences.
No comments:
Post a Comment