Scott H. Davis, VP of Software Development, Limelight Networks
APIs have become a critical technology for our applications and services. They are fundamental to multiple aspects of the cloud native application world and are integral to the nature of Microservices-based applications; how these modern applications are constructed, how the components interact and how we access them. APIs are how we enable machine-to-machine communication of all types, including smart devices and IoT (Internet of Things).
Let’s start by considering user interfaces. Today, it is no longer adequate to only access applications and cloud native services through a single desktop application and its user interface. Instead, we access our services through a variety of different user interfaces in many forms, including web browsers, native mobile applications on smartphones and tablets, speech recognition interfaces, smart watches and even our thermostats; each with their own interface idiosyncrasies. The way to keep the complex cloud native services behind all these interfaces manageable is through an abstracted set of APIs. The logic behind delivering such services must be separate from these user interfaces and abstracted behind carefully considered APIs. However, that’s only one aspect of APIs in the cloud native world.
Cloud Native Applications are constructed using a technique known as microservices, which is an application architecture and methodology that decomposes the large, monolithic applications of the past into a set of small, discrete processes that facilitate both independent development and scale-out for each independent function.
APIs are the glue that hold together the world of cloud native applications and services. They are also key to enabling our smart devices. What these uses have in common is a strong emphasis on machine-to-machine communication in all of its forms
The key to this architecture is making sure that each microservice handles only one function, which is accessed via a well-defined API. To achieve the benefits of this architecture, microservices can’t have any dependencies on each other, except through their APIs. This means no shared data structures can be kept in memory or in databases that are used and modified by multiple services. When fully embraced, software development projects can build and ship microservices independently of each other – meaning separate teams can deploy software on their own schedules. The component APIs are the glue that holds these systems together as they evolve.
With older application design methodologies, it would take engineers months, or even years, to build and maintain large, monolithic software programs. Whenever the code that implemented a common function needed to be changed either to fix a bug or add a feature, it had to be updated in multiple places owned by different teams. For performance reasons, such functions would frequently share state with each other, leading to fragile and difficult to evolve systems. That’s where today’s microservices’ design methodology really shines and facilitates today’s cloud scale services; making it easier to develop systems with reusable component parts that can be utilized by multiple applications and services throughout the organization. This advance wasonly made possible by well-designed APIs and by adhering to microservices design principles.
To effectively implement this architecture, organizations need to ensure that microservices have a well formed, backward and forward compatible API, and only communicate with its peers through their APIs. Container technology is well suited to microservices, either in a serverless or longer-lived variant, as they provide operating systems an independent, portable envelope for the application code comprising each function. Each microservice executing in a container is self-contained, and can be rapidly provisioned or cloned via automation to scale out and back dynamically based on the load demands.
APIs are the glue that hold together the world of cloud native applications and services. They are also key to enabling our smart devices. What these uses have in common is a strong emphasis on machine-to-machine communication in all of its forms. APIs facilitate this communication in both the internal workings of these complex systems and services, as well as controlling their interactions with the external, physical world.