Submit support requests and browse self-service resources.
Olaf van Gorp
Creating APIs doesn’t need to be difficult. In this blog, we walk through to create an API the easy way using the Akana API platform.
Here, we focus on API creation from a UI perspective, where a developer uses the UI to create the product.
Read along or jump ahead to the section that interests you most:
API creation is the process of creating and exposing APIs. This is a critical step to allow your application to connect to other applications, both internal to your enterprise and in its wider ecosystem.
There are two key aspects of API creation to consider. First, there’s the back-end resources that your API will be using (or reusing). What we mean by ‘resource’ is a service, or implementation of some business capability, as it is offered by your enterprise applications. Such a resource will typically be available as a RESTful service, a SOAP-based webservice, or even an AMQP-conformant message broker.
Second, and arguably most important, there’s the consumer-facing part of the API. A properly designed API is consumer-oriented. It allows for effective consumption by any client that is authorized to do so. So, an API essentially acts as a façade to the service(s) it provides access to. It provides a consumer-optimized interface while hiding back-end complexity – without compromising the integrity of the back-end systems and data.
API Lifecycle OverviewAPI creation is an important part of the API lifecycle. But do you know everything there is to know about controlling and consuming APIs? Explore the hub and become an expert today. 👉 API LIFECYCLE HUB
API creation is an important part of the API lifecycle. But do you know everything there is to know about controlling and consuming APIs? Explore the hub and become an expert today.
👉 API LIFECYCLE HUB
In this blog, we will focus on the consumer-facing side of creating API products.
The process of creating an API product is like creating any other software product. Unlike software in general, though, the actual development work should be largely declarative. The process in summary: determine your requirements first. Then design and develop your API. Test it to make sure it works. Once ok, deploy and publish the API. And monitor its performance.
It can take anywhere from minutes to months to create an API, depending on the complexity of your API and the tools you use to create it. With Akana, it’s minutes rather than months.
The process for creating APIs is straightforward. Here’s a quick walkthrough of how to create APIs — and what you’ll need to consider.
First, you’ll need to determine your API requirements. These will be a mix of functional requirements and nonfunctional requirements.
Your functional requirements represent what it is that you like your API to do. In other words, what business capabilities does the API expose to its consumers?
Your nonfunctional requirements will typically be a mix of service level concerns. This includes expected (or agreed) API performance and response time, among others. It also includes concerns with regard to data protection and downstream systems integrity.
To help you gather requirements, consider the following questions:
Once you’ve gathered requirements, you can move on to the next step: design.
Next, you’ll need to consider API design. How will you design your API? Are any internal rulebooks available to help guide your design? Will you design your API interface first, and then build the backend resources to connect to? Or do you want to publish an existing resource as an API product?
With Akana, you can take either approach.
Now, it’s time to start developing your API.
The essentials you’ll need to cover when developing your API are:
And, as example of non-functionals:
The API interface will be captured using a service description language. To describe RESTful APIs, you can use OAS, Swagger or RAML. To describe SOAP APIs, you can use WSDL.
The easiest way to develop your API is to use a tool. For instance, you can build your API using Akana. With Akana, you have two ways to develop your API:
You can also use an existing resource as a building block to create your API product.
Regardless of the approach selected, eventually your API will need to be connected to its downstream resource(s). Initially, it will point to these resources in a test environment.
After you’ve developed your API, it’s time to test it. Testing is ultimately done in a test environment. But there are some testing considerations as you create your API product.
The goal of testing is to make sure your API works as it should under different conditions. You should also test your API’s security and validate any other critical non-functional requirements.
In order to properly test it, your API should be connected to a resource that mimicks the eventual production resource. Alternatively, the API can be configured to return a mock-response, which is a convenient solution if downstream resources are not yet available.
One of the best approaches to API testing is to pair your API platform, like Akana, with a test automation platform, like Perfecto. Akana provides an integrated test client that allows for both functional testing as well as validating whether security policies are met. And Perfecto provides an automation platform that accelerates test execution.
Once your API has been tested and reviewed, it can be deployed in production. Enterprise APIs are typically hosted on API gateways that ensure the expected performance, security, and scalability requirements are met.
To facilitate adoption of the API, publish it in an API developer portal. You can enhance API adoption significantly by offering clear documentation that describes API functions and applicable use cases. In addition, it should clearly explain any API security constraints that may apply.
An interactive testing tool will surely help developers to gain proper understanding of the API and all its relevant features — both functional and from an API security perspective. Ideally, the testing tool presents the API in a sandbox environment. This allows for testing without connecting to production systems or using actual production data.
You can also offer your API in subscription plans, with tiered pricing to monetize your APIs.
After you’ve tested and deployed your API, your work isn’t done. You need to monitor your API to understand how it’s being used and how it performs.
Some metrics you want to monitor include:
There is a lot to API monitoring. Choosing a platform with built-in analytics, like Akana, makes monitoring APIs much easier.
Akana gives you two easy ways to create an API.
Watch the video below to see how it works — or keep reading for a full recap.
Do you want to publish an existing resource as an API product? Is a service description document (like OAS, Swagger, RAML, WSDL) available for the resource? Then the easiest way to create an API in Akana is to use this document.
Simply import the OAS/Swagger/RAML/WSDL document. You can either upload a file or import it from a URL:
Then hit save.
Your API will be automatically deployed to the Akana API gateway. In just a few seconds, you’ve created an API that can be found in your Akana developer portal — and used by app developers.
If you’re doing API-first design and you don’t have a backend resource or endpoint yet, it’s best to create your API from scratch in Akana first.
In this example, we’ll assume that your back-end API implementation will correspond with your API product interface
To get started, you’ll click the APIs dropdown in the top navigation bar and select “Add API”.
In the resulting page, give your API a name and add the target endpoint (if it’s yet available). If you don’t know the endpoint, you can always add it later.
You can then either use the GUI editor to define your operations or you can use the JSON editor to work with the source directly.
The example below shows operations in the GUI editor:
Save your design and that’s it! Your API will now be ready for review and test.
See for yourself how easy it is to create APIs with Akana.
You can try Akana free for 30 days. Put it to the test creating APIs and see how Akana’s unique developer portal makes it easy to consume and promote APIs, too.
Create APIs With Akana ▶️ Watch a Demo First
Technical Sales, Akana
Olaf has over 20 years’ experience with software development and architecture, helping organizations such as Compuware and Capgemini solve enterprise-level integration and governance issues. Olaf has supported the technical sales for Akana API management since 2014, diving deep into security challenges as well as issues specific to financial services, such as PSD2 and Open Banking.