An illustration of Akana at the center of API creation.
February 25, 2021

How to Easily Create an API With Akana

API Lifecycle Management

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:

First, What Is API Creation?

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 Overview

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.

How Is an API Product Made?

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.

How to Create an API

The process for creating APIs is straightforward. Here’s a quick walkthrough of how to create APIs — and what you’ll need to consider.

1. Determine Your Requirements

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:

  • Who is your audience — internal developers, external consumers, or both?
  • How can you incorporate their needs into the API?
  • What are the expectations in terms of API performance, availability, response time?
  • What concerns need to be addressed from an API security perspective?

Once you’ve gathered requirements, you can move on to the next step: design.

2. Design Your API

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.

3. Develop Your API

Now, it’s time to start developing your API.

The essentials you’ll need to cover when developing your API are:

  • Give your API a meaningful name and useful description.
  • Define operations for what your API will do.
  • Specify the data models that describe the request and response messages.

And, as example of non-functionals:

  • Implement applicable security constraints (security policies).
  • Ensure proper caching, rate limiting, and other types of behavior.

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:

  • Create an API that exposes an existing resource.
  • Create an API from scratch (and connect it to existing resources later).

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.

4. Test Your API

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. 

5. Publish/Deploy Your API

Once your API has been tested and reviewed, it can be deployed in production. Enterprise APIs, including cloud 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.

☁️Become an Expert. Explore the Cloud APIs Hub >>

 

6. Monitor Your API

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:

  • Operational metrics, like availability and throughput.
  • API metrics, like engagement and consumption.
  • Business metrics, like how the API is affecting the business.

There is a lot to API monitoring. Choosing a platform with built-in analytics, like Akana, makes monitoring APIs much easier.

How to Create APIs The Easy Way — With Akana

Akana gives you two easy ways to create an API.

  1. Create an API from an existing resource. Best for publishing existing resources as APIs.
  2. Create an API from scratch. Best for API-first design.

Watch the video below to see how it works — or keep reading for a full recap.

 

 

1.  Create an API From an Existing Resource

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:

 

This screenshot shows how to create APIs by importing an API definition document.

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.

2. Create an API From Scratch

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”.

This screenshot shows how to create an API from scratch in Akana, starting with the API name.

 

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.

Click save.

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:

This screenshot shows how to define operations when creating an API in Akana.

 

Save your design and that’s it! Your API will now be ready for review and test.

Get Started With Akana Today

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 promote and consume APIs, too.

Create APIs With Akana ️ Watch a Demo First

Send Feedback