{"id":269899,"date":"2024-01-05T11:22:05","date_gmt":"2024-01-05T16:22:05","guid":{"rendered":"https:\/\/www.webscale.com\/blog\/the-complexities-of-replicating-the-cloud-developer-experience-at-the-edge\/"},"modified":"2024-01-05T11:22:05","modified_gmt":"2024-01-05T16:22:05","slug":"the-complexities-of-replicating-the-cloud-developer-experience-at-the-edge","status":"publish","type":"post","link":"https:\/\/www.webscale.com\/blog\/the-complexities-of-replicating-the-cloud-developer-experience-at-the-edge\/","title":{"rendered":"The Complexities of Replicating the Cloud Developer Experience at the Edge"},"content":{"rendered":"
Over the last fifteen years or so, developers have become very familiar with cloud deployment. Whether using AWS, Azure, GCP, Digital Ocean, or a more niche provider, the dev experience is fairly similar, no matter which cloud you\u2019re on. For a developer, cloud workloads typically include:<\/span><\/p>\n These processes are fairly straightforward when all code and microservices are feeding into a single deployment endpoint. However, what happens when you add hundreds of edge endpoints to the mix, with different microservices being served from different edge locations at different times? In this kind of environment, how do you decide which edge endpoints your code should be running on at any given time? More importantly, how do you manage the constant orchestration across these nodes among a heterogeneous makeup of infrastructure from a host of different providers?<\/span><\/p>\n Image source:\u00a0Gartner<\/a><\/p>\n In this blog, we\u2019ll look at some of the complexities involved in streamlining the developer experience around edge deployment and ongoing management.<\/span><\/p>\n As edge computing gains traction both in its own right and as part of a <\/span>hybrid cloud infrastructure<\/span><\/a>, increasing numbers of developers are being asked to program in a new computing paradigm. Building for the edge is a complex and always shifting puzzle to be solved and then managed.<\/span><\/p>\n Some of the complexities surrounding the edge developer experience include:<\/span><\/p>\n Every application is unique. Developers need granular, code-level control over edge configuration to fit the unique needs of their application. At the same time, they require simple, streamlined workflows to continue to push the pace of innovation and maintain secure, dependable application delivery.<\/span><\/p>\n With various industry players competing for a share of the edge computing market, from hyperscalers to CDNs, there are many considerations for evolving the developer experience to adapt to edge nuances.<\/span><\/p>\n For example, many traditional CDNs have hard-coded proprietary software into their solutions (e.g. web application firewall technology), offering very limited configuration options. Thus, developers can find themselves backed into a corner with legacy CDNs offering edge services, forcing them to bolt on additional solutions that inevitably erase some of the benefits they were seeking to solve with the CDN solution in the first place.<\/span><\/p>\n Furthermore, developers are increasingly looking to migrate more application logic to the edge for performance, security, and cost-efficiency gains. A few examples of workloads moving to the edge include:<\/span><\/p>\n The types of workloads being considered for edge deployment are many and diverse. In order for developers to progress towards migrating more advanced workloads to the edge, they require flexible solutions that support distribution of code across programming languages and frameworks.<\/span><\/p>\n Runtime describes the final phase of the program lifecycle, which involves the machine executing the program\u2019s code. As more developers continue to adopt edge computing for modern applications, edge platforms and infrastructure will need to support different runtime environments.<\/span><\/p>\n Complexity factors into runtimes at the edge in relation to interoperability, i.e. the complexity of managing runtimes across distributed systems. Developers need to be able to run applications in their dedicated runtime environment with their programming language. Systems that support diverse developer needs, therefore, must be able to support this to be useful to all.<\/span><\/p>\n One of the most widely used runtime environments for JavaScript is Node.js, used by many businesses, large and small, to create applications that execute JavaScript code outside a web browser. Some other well-known <\/span>examples of runtime environments<\/span><\/a> include the Java Runtime Environment, a prerequisite for running Java programs, .NET Framework which is required for Windows .NET applications, and Cygwin, a runtime environment for Linux applications that allows them to run on Windows, macOS, and other operating systems.<\/span><\/p>\n With developers building across many different runtime environments, Edge as a Service offerings need to be able to support code portability. We can\u2019t expect developers to refactor their code base to fit into a rigid, pre-defined framework. Instead, multi-cloud and edge platforms and services must be flexible enough to adapt to different architectures, frameworks and programming languages.<\/span><\/p>\n It is critical for developers to be able to have a holistic understanding of the state of their application at any given time. Observability becomes increasingly complex when you consider distributed delivery nodes across a diverse set of infrastructure from different providers.<\/span><\/p>\n As reported in a <\/span>Dynatrace survey of 700 CIOs<\/span><\/a>, \u201cThe dynamic nature of today\u2019s hybrid, multicloud ecosystems amplifies complexity. 61% of CIOs say their IT environment changes every minute or less, while 32% say their environment changes at least once every second.\u201d To add to the complexities of trying to keep up with dynamic systems, that same report revealed that:<\/span><\/p>\n \u201cOn average, organizations are using 10 monitoring solutions across their technology stacks. However, digital teams only have full observability into 11% of their application and infrastructure environments.\u201d<\/span><\/p>\n An effective solution for multi-cloud\/edge observability should be able to provide a single pane of glass to draw together data from many locations and infrastructure providers. This kind of visibility is essential for developers to gain insight into the entire application development and delivery lifecycle. The right centralized telemetry solution will allow engineers to evaluate performance, diagnose problems, observe traffic patterns, and share value and insights with key stakeholders.<\/span><\/p>\n At Webscale, we conducted quite a bit of user research leading up to the build of our Traffic Monitor which gives engineers, application owners and business leaders a straightforward way to quickly see how traffic is flowing through their edge architecture. What we found across interviews with development teams is that they crave tooling that enables them to understand what\u2019s going on with their application traffic and edge\/multi-cloud workloads at a glance, while also giving them the ability to easily drill down deeper into individual logs when needed.<\/span><\/p>\n For example, the Traffic Monitor provides an easy way for DevOps teams to quickly observe errors across their edge stacks, then click to drill into the root cause of those errors without having to form complex queries to get the information they need.<\/span><\/p>\n Along with configuration flexibility\/control and comprehensive observability tooling, developers need to be able to easily manage their application lifecycle systems and processes. With a single developer or small team overseeing a small, centrally managed code base, this is fairly straightforward. However, when an application is broken up into hundreds of microservices that are managed across teams, coupled with a diverse makeup of deployment models within the application architecture, this can become exponentially complex and impact the speed of development cycles.<\/span><\/p>\n When we add the additional complexities of pushing code to a distributed Edge and maintaining code application cohesion across that distributed application delivery plane at all times (even during an application deployment cycle), application lifecycle management for edge becomes vastly more complex than the centralized approaches used to date with cloud.<\/span><\/p>\n\n
<\/p>\n
The Edge Developer Experience: Managing Complexity<\/b><\/h3>\n
\n
Code and Configuration Management<\/b><\/h4>\n
\n
Edge Runtimes<\/b><\/h4>\n
Distributed Diagnostics and Telemetry<\/b><\/h4>\n
<\/p>\n
Centralized Application Lifecycle<\/b><\/h4>\n
GitOps<\/b><\/h5>\n