Every year, I set myself a trio of objectives: to learn a new skill, to relearn an old one, and to perfect a skill that I had initially acquired out of necessity. Building APIs falls into this last category. My journey into API development began in 2019 with a precision agriculture project using Flask. As a beginner, I was hesitant about showcasing my work, but encouragement from friends led me to publish my first API on GitHub [https://github.com/emclaniyi/ML-Precision-Agriculture-Web-App]. That was a turning point for me.
Since then, my skills have expanded to encompass Django, Flask, and FastAPI, each employed for distinct purposes. More recently, my focus has shifted towards constructing machine learning systems, which necessitated a deeper understanding of various software system designs and architectures.
This year, I've delved into the world of microservices, guided by Jose Haro Peralta's insightful book "Microservices API". In this article, I'll share the knowledge I've gained, exploring new concepts and refining old ones.
Introduction to Microservices API
Microservices represent an architectural style where system components are fashioned as independent, standalone, deployable applications. This approach enables the utilization of distributed applications, simplifies scaling of components, and accelerates release cycles.
However, microservices are not without challenges. They can be complex to monitor, operate, and trace. APIs serve as the interface through which we interact with these services. The essence of microservices lies in their autonomy and cooperation, fulfilling specific responsibilities efficiently and effectively.
My interpretation of a microservice aligns with its architectural essence: a component of a system designed as an independently deployable service. Microservices, built around well-defined subdomains, communicate through lightweight protocols like HTTP.
Understanding Monoliths Before Microservices
To appreciate microservices, one must first understand monolithic architectures. In a monolithic pattern, an entire application is deployed as a single unit. This approach is viable for small codebases that are unlikely to expand significantly. However, monoliths have limitations:
Larger monoliths lead to extended testing durations.
Deployment slows down as developers accumulate changes in a single release.
Identifying bugs becomes increasingly challenging.
Managing code changes turns riskier.
Defining an API
An API (Application Programming Interface) allows for programmatic interaction with an application. Interfaces come in various forms, such as Command Line Interfaces (CLI), Graphic User Interfaces (GUI), and Desktop interfaces.
An example of a CLI is the Client URL (Curl), which facilitates interacting with URLs via the command line, as shown in the provided commands.
Exploring Web APIs
Web APIs use the HTTP protocol to transfer data. HTTP, the foundational communication protocol of the Internet, facilitates the exchange of various media types across a network. Web APIs leverage technologies like SOAP, REST, GraphQL, and gRPC.
The Role of Documentation-Driven Development in APIs
Effective API integration hinges on comprehensive documentation. Documentation-Driven Development (DDD) emphasizes documentation as a crucial component of API development, consisting of three stages:
Designing and documenting the API.
Building both the API client and server according to the documentation.
Testing the API client and server against the documentation standards.
API documentation often adheres to standard interface description languages like OpenAPI for REST APIs and Schema Definition Language for GraphQL APIs.
In the next part of this series, we will delve into designing microservices through a practical project: CoffeMesh. Stay tuned for an engaging journey into the intricate world of microservices API development.