API
API – Application Programming Interface - It’s a way of making request into a component. Here the component means Model, Views, Controllers, Services, Plugins and Data Access Objects …etc. So a component that can be reused across multiple systems and applications can be packaged and distributed as an API.
API Lifecycle​
Full API lifecycle management is the process of overseeing an API from its creation to retirement across its full life span. This includes everything from designing, publishing, documenting, securing, and analyzing APIs. An effective API strategy must include an API management solution that makes APIs easily discoverable and reusable, and ensures that they are properly governed and secured.
The 3 API lifecycle stages
- Design
- Implementation
- Management
Design — when the API is created​
API developers create the “user interface” of the API first, determining how the API looks and behaves – this is also known as the API contract.
Within this step, API developers perform these tasks:
- Design: Identify process and business requirements, create logical data model, translate into logical service, API groupings
- Simulate: Model API resources, model API operations/methods, model request/response payload/codes
- Feedback: Mock up the API, publish interactive console, create notebook use cases, receive developer feedback
- Validate: Modify API design as appropriate based on developer feedback, continue to validate
Any well-designed API will have repeatability across other APIs. This can easily be encapsulated into best practice patterns both at the structural level of the API (nouns resources), as well as at the method level (verbs). So as API developers go about the design process, it is important that they can discover and share repeatable patterns.
Implementation​
API implementation is a critical piece of enabling a next-generation enterprise. Enabling the connectivity of hundreds or thousands of APIs to a backend as well as to each other is key. This must be done in a systematic manner.
The two steps that go into the implementation stage are building and testing.
A systematic approach to building ensures that the API developer has the the following architectural patterns easily available to them:
- Orchestration
- Transformation
- Routing
- Data mapping
- Connectivity across systems
Once the API is built — it will go through rounds of API testing to ensure that it is functioning as expected. If the test is completed with no problems it can move on to the next lifecycle stage, but most often the API will go through several rounds of testing and adjusting before moving on to deployment.
Management​
It is critical to ensure your application building blocks are following best practices in security and architectural governance by applying policies to them at runtime. Monitoring all traffic via an API manager is equally critical because it just takes just one weak link to bring the ship down.
Within this lifecycle stage are the following steps:
- Secure
- Deploy
- Monitor
- Troubleshoot
- Manage
Additionally, these APIs need to be discoverable to be reused for other purposes. The ability to appropriately publish them so the consuming developer can find, research, and understand them easily could make or break your entire program.
Monolithic Application​
In monolithic architecture, all of the parts of an application are interdependent and they operate as a singular, complex unit. If one part of the application needs to be fixed or updated, then that impacts the rest of its components, resulting in outages or cumbersome experiences for the end user.
Monolithic Vs Micro Services Application​
