Tyk News

All the latest news & updates on the Tyk API Management Platform

Meet our Singapore team at CommunicAsia – May 23-25

23 - 25 May 2017, Tuesday to Thursday, Basement 2 to Level 5, Suntec Singapore <3 Day Show!>” />
    </td>
</tr>
<tr>
<td width= You Are Invited
CommunicAsia2017 EnterpriseIT2017
Stand No. BF2-10
Tyk Technologies Ltd would like to invite you to Stand No. BF2-10 at CommunicAsia2017 and EnterpriseIT2017 – Asia’s premier integrated info-communications technology event. Occupying Basement 2 to Level 5 of Marina Bay Sands, Singapore, both shows will feature an exciting line-up of the latest innovations, industry heavyweights and leading experts.
So drop by our stand to say hi and check out our latest products! To schedule an appointment or to get in touch with our team who will be at the show, contact Zane Lim at +65 6813 2083 / [email protected].
Tyk is a leading open source API Management platform comprising; API Gateway, Dashboard, Portal and Analytics. Tyk makes it simple and cost-effective to manage an organisation’s APIs with it`s distinctive features.
Download CommunicAsia's Visiting Brochure Download EnterpriseIT`s Visiting Brochure

When is Hypermedia and HATEOAS a Right Fit For Your API?


Previously, we discussed the value of offering events from your API that can extend the conversation you have with your consumers. Another consideration for extending your API conversation is to add hypermedia and HATEOAS support. Let’s understand more about these concepts and understand the value they bring to our APIs.

What is a Hypermedia API?

A hypermedia API is one driven by self-descriptive links that point to other, related API endpoints. Often, these links point to other resources that are related, e.g. the owner of a project, or to relevant endpoints based on the context of the consumer.

For example, the Github API offers hypermedia links whenever you request the details on a specific user:

GET https://api.github.com/users/launchany
{
  "login": "launchany",
  "id": 17768866,
  "avatar_url": "https://avatars3.githubusercontent.com/u/17768866?v=3",
  "gravatar_id": "",
  "url": "https://api.github.com/users/launchany",
  "html_url": "https://github.com/launchany",
  "followers_url": "https://api.github.com/users/launchany/followers",
  "following_url": "https://api.github.com/users/launchany/following{/other_user}",
  "gists_url": "https://api.github.com/users/launchany/gists{/gist_id}",

  ...
}

If an API supplies hypermedia links that are context-sensitive and change based on where the user is within the API and what features and functionality are currently available to the consumer, the API is said to apply the HATEOAS constraint. HATEOAS (“Hypermedia As The Engine Of Application State”) is a constraint within REST that originated in Fielding’s dissertation.

How Does Hypermedia Extend the API Conversation?

1. Hypermedia Informs Consumers About What Is Possible

Hypermedia helps connect the dots of your API, making it more like the web. Imagine using your favourite search engine to find some results, only to never click on any of the results. Unfortunately, that is the way we design most of our APIs – without offering the consumer the opportunity to explore the depth of the data and capabilities offered by your API.

APIs with hypermedia extend the conversation of your API by offering runtime discovery of capabilities. They help API consumers realise what is possible – and what isn’t – when using your API.

2. Hypermedia Enables API Evolvability

Not all APIs stay the same forever. APIs are like any other product – they have a product lifecycle that includes growing in maturity over time. Hypermedia links allow the API to evolve over time, exposing new capabilities as they emerge without disrupting existing API consumers.

Note: I didn’t mention anything about hypermedia protecting clients from changing URLs. That’s because preventing clients from having to think or compute URLs is a side effect, not the primary reason to select Hypermedia.

3. Hypermedia Encourages Loosely Coupling

By including hypermedia into resource representations, API designers are free to stop trying to include everything in every API response. API endpoints can focus on doing one thing properly, using hypermedia links to reference other details that may be fetched by API consumers if and when needed. This creates a loose-coupled API by separating out capabilities into separate, yet related, endpoints rather than forcing every piece of data to be included within each response.

Is Hypermedia a Fit For Your API?

Hypermedia is like “Choose Your Own Adventure” for API Consumers, allowing consumers to discover capabilities and drive execution. For all but the most basic of APIs, hypermedia will expand your API into a more dynamic conversation with your API consumers. It also enables your API to evolve and mature over time, by adding new capabilities as needed by your consumers.

5 Mistakes Your API Product Must Avoid

Many of my consulting engagements involve helping teams improve their API products. Over the last decade, I have seen some strategies work better than others. While not every product and circumstance is the same, there are some common mistakes that prevent teams from delivering a great API product. I want to share with you the top five mistakes teams make when it comes to their API product strategy and how you can avoid them.

Mistake #1: Solving the Wrong Problem

Many teams focus on the wrong problem, resulting in delivering an API product that fails to resonate with the target audience. To avoid this mistake, it helps to map out the API and how it fits into the common usage scenarios. This mapping exercise should capture the following:

  1. The typical pain point that your API solves, e.g. why your API needs to exist
  2. The overall workflow and how your API fits into it
  3. The target developer personas that your API targets
  4. How the API works in cooperation or competitively with other vendors
  5. How developers will likely discover and subsequently onboard with your API

Mistake #2: Lack of Clarity

Too often, our APIs start off as a series of isolated endpoints that don’t solve a larger problem. This can lead to confusion by developers considering the use of your API, as they may not be sure when and how it fits into their problem.

When first starting out, make sure your API is clear in the problem it is trying to solve, as well as what is isn’t trying to solve. An API that does one thing and does it well through clarity of focus far outweights an API loaded down with lots of disconnected features that doesn’t solve a single problem. Become hyper-focused on understanding the problem and then solving for that specific problem first, before you expand your API’s scope.

Mistake #3: Delivering Features Not Capabilities

Capabilities enable someone to achieve something they previously were not able, such as machine learning or SMS messaging. Features are the individual steps and/or mechanisms that allow them to achieve those outcomes.

As API product owners, we must be able to separate what we are helping our target audience achieve (the capabilities) vs. the features that help them get there (the API endpoints). If you are focused too much on the API design before you know what your audience is trying to achieve, then your API product will fall short. This is often the case for APIs built on top of a database, as the API simply focuses on data delivery rather than desired outcomes of what the API can do for the consumer.

Mistake #4: Lack of Product Ownership

Once your API is delivered into production, your job as API product owner is only getting started. APIs are just like any other product – they must operate on a product lifecycle that matures the product over time.

Most product owners find that there is a whole other world of opportunity that lies beyond the first version of a product. To get to this stage, you must always be focused on the next release. Define your API product roadmap, deliver continuously, and seek input from your stakeholders. Continuous feedback from stakeholders beyond the first release is critical for gaining traction and maturity.

Mistake #5: Long Design and Delivery Cycles

The longer your API takes to get into the hands of consumers, the longer your feedback loop with stakeholders. However, a rushed API often requires changes that will force consumers to adapt or die. How do API product teams balance the need for speed and consumer safety?

I recommend a design-first approach that identifies the capabilities to be delivered, designing the API to meet those capabilities, then delivering the API as fast as possible. To accelerate the delivery process, consider the following:

  1. Build an API delivery team using cross-functional resources: developers, QA, technical writers, and other roles necessary to deliver the API end-to-end
  2. Utilize API definition formats, such as the OpenAPI Specification, to communicate the API design to everyone involved
  3. Take advantage of mocking tools that allow for early experimentation with your OpenAPI definition to work out any design details early, before coding starts (when the cost of API design change is much lower)
  4. Keep stakeholders involved early and often through shared design documents and mockups
  5. Deliver the API continuously rather than all-at-once, using stakeholder feedback to prioritize the delivery schedule based on their needs

Remember: Once released, it is difficult to change an API design. Use this accelerated delivery process to expedite your learning and stakeholder feedback early, to avoid needing to make drastic design changes after your API is released.

API Eventing Is The Next Big Opportunity For API Providers

For the last decade, modern web APIs have grown from solutions like Flickr, to robust platforms that generate new business models. Throughout this period of growth, most APIs have been limited to request-response over HTTP. We are now seeing a move back to eventing with the popularity of webhooks to connect SaaS solutions, the introduction of technologies such as Kafka to drive internal messaging, and the need for integrating IoT devices.

API eventing completely changes the way API consumers interact with our APIs, creating new possibilities that request-response cannot. Let’s examine the driving factors contributing to the rise of API eventing in greater detail, along with the opportunities that may inspire you to consider adding API event support to your API.

Why Should Your APIs Support Events?

Reason #1: API Events Drive Innovation

With the introduction of WebHooks into the GitHub platform, software development changed dramatically. Teams were no longer required to explicitly start the build process by clicking a button. The idea of generating daily or hourly builds was a thing of the past. Instead, teams could kickstart the build process whenever new code was pushed to GitHub. Post-commit hooks have always been part of svn and git, but GitHub extended these event streams across the web. Combined with cloud vendor APIs, WebHooks enabled teams to build and deploy their code to any environment of their choosing, all driven by WebHooks.

Reason #2: API Events Enable Collaboration

Messaging platforms such as HipChat and Slack have changed the way team members collaborate. These team messaging platforms have opened up opportunities to integrate bots and command-line automation. The result is a new way to communicate that goes beyond traditional IRC and group chat. To make this work, these platforms offer a combination of request-response APIs and realtime event streaming to enable external apps, bots, and APIs to be integrated seamlessly into their platform.

Reason #3: API Events Drive Codeless Integration

Software-as-a-Service (SaaS) products are increasingly offering APIs for integration. Integration Platform as a Service (iPaaS) tools such as Zapier and IFTTT help connect them together to automate many common tasks without requiring copy-and-paste. Many iPaaS offerings even host the code on your behalf, removing the need to manage servers and infrastructure.

While this kind of integration does not always require writing code, it is limited by the types of triggers offered by an API. When an API only offers request/response support, clients are required to poll to see if there are any changes to important data. With API eventing, these tools can receive a trigger (the event) when data changes and execute the desired automation flow.

Reason #4: API Events Create Architectural Flexibility

More and more teams are exploring microservice architecture as a way to place boundaries around complex solutions, reducing the cognitive load required to understand a portion of the overall solution. All of this is done with the goal of speeding up delivery by being able to create smaller, independent teams that are able to deliver capabilities rapidly. As a result of a loosely coupled microservice architecture, services emit events to inform other microservices of data changes and key business events that drive business workflows.

Additionally, we are seeing the rise of function-as-a-service (FaaS) within the serverless world. Rather than deploying a complete application, smaller functions are deployed and then triggered through message-based events or through API gateways that provide a request/response style invocation.

Bear in mind that messaging brokers such as Kafka, RabbitMQ, or Amazon SNS/SQS are often used to drive microservice events and trigger function-based services. While these are valid solutions for your internal messaging, they are not designed for externalization. If you externalize events, you should consider how your consumers will need to consume them, perhaps with a combination of webhooks, event streaming, or perhaps the less efficient long-polling for some circumstances.

Reason #5: Events Are The Glue For IoT Devices and Edge Computing

Perhaps you have some smart devices around your home or office. These devices often talk to a cloud service to enable visualization of important data and events from the web or a mobile device. Integrating with IoT services via cloud-based APIs offered by vendors benefit from event streaming, as third-party automation solutions can extend the usefulness of these devices.

For some device integration scenarios, network connectivity to cloud resources may not be guaranteed or the amount of data produced may require evaluation and aggregation before being sent to the cloud. This is called ‘edge computing’ and has been commonplace for many years, particularly in manufacturing and the energy industry where high bandwidth isn’t always available.

There are now signs that edge computing will also start to emerge as part of the next generation IoT devices. Event streaming is required for edge devices to integrate with each other and with smart controller devices on local networks. If you are building APIs for IoT, event streaming will be essential to edge communication and computation.

Should Your API Offer Event Subscriptions?

As I have written previously, API events expand the kinds of conversations that our APIs need to have as we use them to solve day-to-day problems. I encourage teams to consider how their API conversations can be enriched through the addition of API events. Without eventing support, APIs are simply left to wait for you to ask them something. With eventing support added, APIs are now able to have a two-way conversation with other APIs and applications. This produces a better user experience and greatly expands your API’s adoption and reduces consumer churn.

New WordPress API Portal plugin

We love it when a community comes together!

You can now use a simple, open-source, WordPress plugin to put the functionality of the Tyk API developer portal into any WordPress site. This innovation has been made possible by Liip, active contributors to the Tyk open-source community. The plugin brings together WordPress and Tyk to enable users to build “best of breed” API Developer portals that combine the API portal functionality of Tyk, with the CMS capability of WordPress.

Liip are one of Switzerland’s leading developers of web applications. They have developed and open-sourced this great new WP plugin to extend the possibilities around using the Tyk Developer portal. Thanks guys! The plugin is ready to use. Just follow the links below. It’s already used in production by the Swiss Federal Railways (SBB-CFF-FFS) and we can’t wait to see what you are going to do with it next!

Features:

  • Automatic developer registration on Tyk when developers sign up in WP
  • Configuration of API policies available for token registration
  • Developers may request an access token for the available API policies
  • Automatic or manual approval of key requests
  • Storage of token (references) by name and API policy
  • Revoking of tokens by developer
  • Display usage statistics per key (see screenshot)
  • Request quota usage per key (see screenshot)


What this plugin does not offer:

  • Management of Tyk API Gateway (the Tyk Dashboard is best suited for that)
  • WP user registration (there are enough plugins that do that quite well!)

2 easy ways to get the plugin:

  1. The public repo can be found on GitHub here.
  2. The plugin is also published on wordpress.org wordpress.org (although it is slightly behind the status on GitHub).

What future innovations would you like to see in Tyk? Let us know at community.tyk.io

When and How Do You Version Your API?

One of the most frequent questions I receive during API training and coaching engagements involves versioning. When to version. How to version. Whether to version at all. While not all APIs are exactly the same, I have found that there are certain patterns and practices that work for most team. I have pulled these together to provide a recommendation for a versioning strategy that will help most API providers – whether they are deploying internal, private APIs or public APIs outside the organization.

Do you really need to version your API?

APIs are contracts established between you and your API consumers. Ideally, you will never have to break this contract. This includes URI patterns, payload structures, field and parameter names, expected behavior, and everything else in between. The biggest benefit of this approach is obvious: An API consumer’s understanding never expires. Applications continue to work, making your consumers happy.

However, that may not be reality. There may be times when you need to make a breaking change. When this happens, you need to ensure that you never do anything that will cause your API consumers to fix code.

Breaking vs. non-breaking changes

Non-breaking changes tend to be additive: adding new fields or nested resources to your resource representations, adding new endpoints such as a PUT or PATCH that was previously unavailable. API consumers should build client code that is resilient to these kinds of non-breaking changes.

Breaking changes include:

  1. Renaming fields and/or resource paths – often for clarity after your API is released
  2. Changing payload structures to accommodate the following: renaming or removing fields (even if they are considered optional – contracts!); changing fields from a single value to a one-to-many relationship (e.g. moving from one email address per account to a list of email addresses for an account)
  3. Fixing poor choices of HTTP verbs, response codes, or inconsistent design across your API endpoints

In short, once you release your API into the wild, you have to live with it. If you encounter one or more of the items above, it may be time to version your API to prevent breaking your existing API consumers.

Defining Your API versioning strategy

Any evolving, growing API will require an API versioning strategy. When and how you version may vary based on the expectations of your API consumers. I generally recommend the following API versioning strategy as part of an overall API governance model:

  1. If your API is in an early preview release, perhaps to gain feedback from consumers, establish proper expectations that your API may change. At this stage, you will remain at version 1 for some time but your API design may change. Things are volatile as a consumer, so they should expect that changes may occur
  2. Once released, your API should be considered a contract and cannot be broken without a new version release
  3. API versions are major.minor, following the general principles of semantic versioning
  4. Non-breaking changes result in a bump in the minor version; clients are automatically migrated to the latest verison and should not experience any negative side-effects
  5. Breaking changes result in a new major version; clients must specifically migrate to this new version as it contains one or more breaking changes. You must establish an appropriate timeline and regular communication with your API consumers to ensure that they migrate to the new version. In some cases, this may not be possible and your team will be required to support the previous API version indefinitely

How to implement API versioning

Once you determine that you need a new version of your API, you need to decide how to handle it. Preferrably, you have decided ahead of time and encouraged API consumers to request version 1 of your API. There are three common approaches to implement API versioning:

  1. Resource versioning: the version is part of the Accept header in the HTTP request. e.g. Accept: application/vnd.github.v3+json is sent to GET /customers. This considered the preferred form of versioning by many, as the resource representations are versioned while keeping resource URIs the same. Some APIs choose to provide the latest version as the default, if not provided in the Accept header

  2. URI versioning: the version is part of the URI, either as a prefix or suffix. e.g. /v1/customers or /customers/v1. While URI-versioning isn’t as pure as content-based versioning, it tends to be the most common as it works across a variety of tools that may not support customized headers. The downside is that resource URIs change with each new version, which some consider counter to the intent of having a URI that never changes.

  3. Hostname versioning: the version is part of the hostname rather than the URI. e.g. https://v2.api.myapp.com/customers. This approach is used when technology limitations prevent routing to the proper backend version of the API based on the URI or Accept header.

No matter which option you choose, API versions should only include the major number. Minor numbers should not be required (e.g. /v1/customers, not /v1.1/customers).

Final thoughts

Remember, APIs are contracts with your consumers. Break your contract and a new version is required. Choose a strategy, have a plan, and communicate that plan with your API consumers. They will thank you for it.

Tyk API Gateway v2.3.2 and Tyk Dashboard 1.3.1.2 released

We are happy to announce a new version of Tyk Gateway and Tyk Dashboard.

This is a bug fix release and contains critical updates for our Tyk Hybrid users, as well as various fixes for all the users.

Tyk Gateway

  • Fixed memory and connection leak affecting our Hybrid users, it was causing Tyk Gateway to crash due to lack of available memory, or because of opening too many network connections to Tyk Cloud.

  • Now you can allow double slash “//” in your urls, by setting http_server_options.skip_url_cleaning option. It may be useful if you need to pass “urls” as parameters to your api, for example: “http://your.api.com/get/http://example.com”.

  • Fixed bug where JWT claims would not be included in the middleware context in subsequent requests

  • Fixed runtime panic when an OAuth client is added with an API that does not exist in the gateway yet

Tyk Dashboard

  • Added Organisation name to dashboard UI for multi-tenant installations

  • Fixed ‘Search by key” in the key analytics view

  • Fixed API Import schema to work with api_model field

  • Fixed import/export API for policies where the ACL would not be properly set on import

  • Fixed uptime tests UI issues for requests with multi-line bodies

Both releases are available via our package cloud repositories and as our official docker images.

API Developer Portals

Increasing API Adoption Through Developer Portals

Effective communication is a critical factor for API adoption. Since APIs do not have a user interface, your documentation is the primary method for communicating with developers on how to use your API. Your API documentation is your API’s user interface.

A developer portal helps bring together the different styles of communication that you need to ensure that APIs can be found, speak to the benefits of using your API, and guide developers on how to integrate your API.

The Value of API Documentation

API documentation is the primary communication medium between the API provider and consumer. Unless the API is open source, you will likely never see the source code behind it. Therefore, the only thing that developers consuming your API have is your documentation. Without clear and complete documentation, developers will struggle to use your API.

We use the term API documentation as if there is only one kind of documentation. Yes, you need to deliver a great API reference for developers. Tools such as Swagger, RAML, and Blueprint are just a few of the formats available to help build them. However, complete API documentation requires more than just your API reference in HTML or PDF form. It requires having a developer portal that pulls together everything that they will need to be successful.

What Makes a Great Developer Portal?

Every great developer portal includes the following content:

Features and Discovery – Provides an overview of the API, addressing concerns such as benefits, capabilities, and pricing of your API to qualify prospects.

Case Studies and Examples – Case studies highlight applications that have been built using your API.

Reference Docs – Provides a reference for each API endpoint to developers, including details on the URL, HTTP verb(s) supported, response codes, and data formats. This is where Swagger, RAML, and Blueprint formats are used to generate documentation from an API definition.

Guides and Concepts – As an API consumer, the most difficult part of using an API is the initial learning curve. Guides offer help with learning an API’s concepts and vocabulary during this critical stage.

Problem/Resolution – Documentation can help developers troubleshoot error response codes and ease the burden on your developers and support staff.

Changelog – Shows what has been added or improved recently, helping developers to find new ways to use your API.

Going Beyond Content

Beyond content, developer portals should include the following disciplines:

Easy Onboarding – APIs rarely gain adoption if you make it difficult to get started. Easy onboarding, from self-registration to a guided tour will help developers overcome the challenges to adopting a new API.

Operational Status – Is your API available or temporarily down? A simple status page that reflects your API’s availability will help to inform developers and operations staff that see increased errors in their applications.

Live Support – Including a chat solution, whether embedded into your developer portal or through communication platforms such as Slack will help provide direct access to those that can help resolve integration

How Secure Is Your API?

gandalf

You have researched the latest API design techniques. You have found the best framework to help you build it. You have all the latest tools in testing and debugging at your fingertips. Perhaps you even have an amazing developer portal setup. But, is your API protected against the common attack vectors?

Recent security breaches have involved APIs, giving anyone building out APIs to power their mobile apps, partner integrations, and SaaS products pause. By applying proper security practices and multiple layers of security, our API can be better protected.

Recent API Security Concerns

There have been several API security breaches that demonstrate some of the key vulnerabilities that can occur when using APIs. This includes:

These and other recent cases are causing API providers to pause and reassess their API security approach.

Essential API Security Features

Let’s first examine the essential security practices to protect your API:

Rate Limiting: Restricts API request thresholds, typically based on IP, API tokens, or more granular factors; prevents traffic spikes from negatively impacting API performance across consumers. Also prevents denial-of-service attacks, either malicious or unintentional due to developer error.

Protocol: Parameter filtering to block credentials and PII information from being leaked; blocking endpoints from unsupported HTTP verbs.

Session: Proper cross-origin resource sharing (CORS) to allow or deny API access based on the originating client; prevents cross site request forgery (CSRF) often used to hijack authorized sessions.

Cryptography: Encryption in motion and at rest to prevent unauthorized access to data.

Messaging: Input validation to prevent submitting invalid data or protected fields; parser attack prevention such as XML entity parser exploits; SQL and JavaScript injection attacks sent via requests to gain access to unauthorized data.

Taking a Layered Approach to Security

As an API provider, you may look at the list above and wonder how much additional code you’ll need to write to secure your APIs. Fortunately, there are some solutions that can protect your API from incoming requests across these various attack vectors – with little-to-no change to your code in most circumstances:

API Gateway: Externalizes internal services; transforms protocols, typically into web APIs using JSON and/or XML. May offer basic security options through token-based authentication and minimal rate limiting options. Typically does not address customer-specific, external API concerns necessary to support subscription levels and more advanced rate limiting.

API Management: API lifecycle management, including publishing, monitoring, protecting, analyzing, monetizing, and community engagement. Some API management solutions also include an API gateway.

Web Application Firewall (WAF): Protects applications and APIs from network threats, including Denial-of-Service (DoS) attacksand common scripting/injection attacks. Some API management layers include WAF capabilities, but may still require a WAF to be installed to protect from specific attack vectors.

Anti-Farming/Bot Security: Protect data from being aggressively scraped by detecting patterns from one or more IP addresses.

Content Delivery Network (CDN): Distribute cached content to the edge of the Internet, reducing load on origin servers while protecting them from Distributed Denial-of-Service (DDoS) attacks. Some CDN vendors will also act as a proxy for dynamic content, reducing the TLS overhead and unwanted layer 3 and layer 4 traffic on APIs and web applications.

Identity Providers (IdP): Manage identity, authentication, and authorization services, often through integration with API gateway and management layers.

Review/Scanning: Scan existing APIs to identify vulnerabilities before release

When applied in a layered approach, you can protect your API more effectively:

diagramf

How Tyk Helps Secure Your API

Tyk is an API management layer that offers a secure API gateway for your API and microservices. Tyk implements security such as:

  • Quotas and Rate Limiting to protect your APIs from abuse
  • Authentication using access tokens, HMAC request signing, JSON Web tokens, OpenID Connect, basic auth, LDAP, Social OAuth (e.g. GPlus, Twitter, Github) and legacy Basic Authentication providers
  • Policies and tiers to enforce tiered, metered access using powerful key policies

Carl Reid, Infrastructure Architect, Zen Internet found that Tyk was a good fit for their security needs:

“Tyk complements our OpenID Connect authentication platform, allowing us to set API access / rate limiting policies at an application or user level, and to flow through access tokens to our internal APIs.”

When asked why they chose Tyk instead of rolling their own API management and security layer, Carl mentioned that it helped them to focus on delivering value quickly:

“Zen have a heritage of purpose building these types of capabilities in house. However after considering whether this was the correct choice for API management and after discovering the capabilities of Tyk we decided ultimately against it. By adopting Tyk we enable our talent to focus their efforts on areas which add the most value and drive innovation which enhances Zen’s competitive advantage”

Find out more about how Tyk can help secure your API here.

How APIs Are Creating the Composable Enterprise

James Higginbotham recently spoke at APIStrat 2016 in Boston, where he shared some insights into how enterprises are using APIs and microservices as part of their digital transformation processes. What does this mean for software architects in today’s enterprise? Let’s first look at the transformations underway toward a composable, modular enterprise. Then we will consider some of the impacts it will have on our day-to-day efforts as software architects.

What is the Composable Enterprise?

The composable enterprise is one that strives to capture business and technical capabilities as APIs, seen as modular components across lines of business. Apps and integrations are built upon these APIs by the enterprise for internal, partner, or public use. A composable enterprise combines commercial off the shelf (COTS) packages, SaaS platforms, and custom development to address market needs quickly.

Coming from a software background, I tend to think of it more like a modular enterprise with APIs that can be combined to create new and interesting solutions:

Capital One is one enterprise moving in this direction by releasing a few public productized APIs, with the rest remaining for private or partner consumption.

Moving Toward an API-Centric Architecture

Within the enterprise, APIs are traditionally viewed as bolt-on solutions. They connect internal systems together, or offer enterprise data to remote mobile or web apps. However, reuse isn’t the goal of an integration API, resulting in one-off APIs scattered across the organization. In a composable enterprise, APIs are designed first, becoming the outward-facing contract that hides all of the internal details:

Legacy systems can then be transitioned to a new architecture or replaced with a new solution over time. Whether you are wrapping a commercial product, monolithic application, or a microservice architecture – it doesn’t matter.

APIs Should Focus on Capabilities

APIs in a composable enterprise focus on delivering business and technical capabilities. This requires that we shift our thinking from databases and code to helping people achieve their goals. Users don’t care how we organize our database schema, what programming languages we use, and what the current hot server or client-side framework may be. They want to get things done and move on. As architects, we need to focus on both the business and technology – APIs are the key deliverable that is shared between them. Our API designs should focus on delivering desired outcomes, not just data.

Manage Your API as a Product

The traditional view of APIs results in APIs being treated the same as internal code, with limited access or visibility. Applying product-thinking to APIs requires a shift toward developer portals, self on-boarding of developers, and a customer-driven approach. Most importantly, architects must monitor API usage, making adjustments to the API product based on consumption patterns.

At the center of a product-driven architecture is an API gateway and management layer. The gateway routes incoming API requests to internal processes or microservices. The management layer provides security, role-based enforcement, rate limiting, and usage metrics. A variety of commercial and open source solutions exist to fill this gap. Tyk is an open source solution that offers a cloud, hybrid or on-premise option to solving this problem.

Want to Learn More About the Composable Enterprise?

You can view the slide deck from the presentation, available via Slideshare.

Scroll to top