Amazon API Gateway is a managed cloud service that allows developers to create, maintain, secure, and monitor APIs. The APIs you create with Amazon API Gateway act as a “front door” of sorts. They allow apps to access data and business logic and trigger functionality from your backend services, such as AWS Lambda, Amazon Elastic Compute Cloud (Amazon EC2), Amazon DynamoDB, and Amazon Kinesis.
With Amazon API Gateway you can create request-driven RESTful APIs and event-driven WebSocket APIs. RESTful APIs come in two flavors:
HTTP APIs. Designed with minimal features and recommended to be used for APIs that only require API proxy functionality (no API management). HTTP APIs are optimized for serverless workloads and HTTP backends, offering decreased latency compared to REST APIs.
REST APIs. Designed with additional features compared to HTTP API; you can use REST API if your API requires proxy functionality, as well as API management features (e.g, API keys, per-client rate limiting and usage throttling, request validation).
A WebSocket API acts as a stateful frontend for AWS services (like Lambda or DynamoDB) and HTTP endpoints. A WebSocket API supports low-latency two-way communication between client apps and your backend. This makes WebSocket APIs a good choice for realtime use cases like chat apps, streaming dashboards, multiplayer collaboration, and realtime alerts and notifications.
In addition to different types of APIs, Amazon API Gateway offers features such as:
Private integrations with AWS ELB and AWS Cloud Map.
API operations monitoring (for example, by integration with Amazon CloudWatch, you can monitor metrics like latency, error rates, number of API calls).
API keys with fine-grained access permissions.
API versioning and API lifecycle management.
If you’re a developer who’s looking to create, publish, maintain, secure, and monitor APIs, there are plenty of well-known alternatives you could use instead of Amazon API Gateway.
Microsoft Azure API Management. Hybrid, multi-cloud API management platform that supports the end-to-end API lifecycle. It consists of several components:
API gateway, which accepts API calls and routes them to the appropriate backends.
Management plane - allows you to provision resources, define API schemas, set up policies, package APIs into products, and manage users.
Developer portal - fully customizable website containing the documentation of your APIs.
IBM API Connect. Multi-cloud API management solution that allows you to:
Write and test APIs.
Package and deploy APIs.
Create and manage self-service portals to expose the API to your consumers.
Set up access control, monitoring, and logging.
Apigee Edge. A platform for developing and managing API proxies. You can think of an API proxy as an interface for developers who want to access your backend services. Apigee Edge provides diverse capabilities:
Security - OAuth, API key verification, JWT, access control, etc.
Traffic management (caching, quotas, and rate limits).
Data transformation; for example, XML to and from JSON, or SOAP to and from REST.
Multi-tenancy (both on-prem and in the cloud).
Kong. A cloud-native, platform-agostic API gateway that you can use for full lifecycle API management (design, run, secure, and govern APIs). Kong provides features and capabilities such as:
Kubernetes-native architecture and interfaces.
Fine-grained access and traffic policies.
Authentication and authorization using methods like JSON web tokens (JWTs), basic auth, OAuth, ACLs and more.
Plugins for enforcing traffic controls, rate limiting, logging, and monitoring.
MuleSoft Anypoint Platform. Full lifecycle API management solution that can be deployed in any environment, whether it’s cloud or on-prem. With the MuleSoft Anypoint Platform, you can:
Design, reuse, and test APIs.
Manage APIs & users and analyze traffic.
Deploy, monitor, and secure APIs.
Build connectors and implement integrations.
Other notable alternatives to Amazon API Gateway for API lifecycle management include: TIBCO Cloud API Management, Boomi API Management, Amplify API Management Platform, SAP Integration Suite, and Postman API Platform.
As previously mentioned, Amazon API Gateway allows you to create and use simplistic WebSocket APIs, for realtime use cases like chat apps, collaboration platforms, and multiplayer games.
However, if you don’t want to deal with creating and maintaining WebSocket APIs yourself, but would rather use pre-designed APIs to power realtime experiences for end-users, there are alternative solutions you can use instead of Amazon API Gateway. Here are the five alternatives we’ll cover, some of which offer more flexibility and richer capabilities compared to Amazon API Gateway WebSocket APIs:
Created back in 2010, Socket.IO is a well-known open-source library that enables low-latency, bi-directional communication between web clients and servers. Socket.IO is built on top of the WebSocket protocol and provides additional capabilities such as automatic reconnections, or falling back to HTTP long polling.
Multiplexing (namespaces), which enables you to minimize the number of TCP connections used, and broadcast support (rooms), to more efficiently distribute data to clients.
Disconnection detection (configurable Ping/Pong heartbeat mechanism) and automatic reconnections.
Integrations with various solutions for horizontal scaling: Redis, MongoDB, Postgres, AMQP / RabbitMQ. Note that you have to use one of these when you scale beyond a single Socket.IO server, to pass events between nodes, and ensure that events are properly routed to all clients.
Socket.IO does not guarantee exactly-once messaging semantics. By default, an at-most-once guarantee is provided. Socket.IO can also be configured to provide at-least-once guarantees, although this brings additional engineering complexity - you have to use acknowledgments, timeouts, assign a unique ID to each event, and persist events in the database.
Limited native security features - for example, Socket.IO doesn't provide end-to-end encryption, and it doesn't offer a mechanism to generate and renew tokens for authentication.
Designed to work in a single region, rather than a multi-region architecture. This can lead to issues such as increased latency (if you have users in different parts of the world), and system downtime - what happens if the datacenter/region where you have your Socket.IO servers goes through an outage?
SignalR is a technology that enables you to add realtime web functionality to apps, primarily over WebSockets. SignalR comes in several different flavors:
ASP .NET SignalR - a library for ASP. NET developers. Note that this version is largely outdated (only critical bugs are being fixed, but no new features are being added).
ASP .NET Core SignalR - an open-source SignalR library; unlike ASP. NET SignalR, this version is actively maintained.
Azure SignalR Service - the fully managed cloud version.
SignalR uses WebSockets wherever possible, but it also supports two fallback transports: Server-Sent Events, and HTTP long polling, for environments where the WebSocket transport is blocked/unsupported.
Multiple backplane options to choose from when scaling out: Redis, SQL Server, or Azure Service Bus (note that there’s no need for a backplane when using the fully managed version, Azure SignalR Service).
Part of the ASP.NET Framework, which makes it easy to use SignalR in combination with other ASP.NET features like authentication, authorization, and dependency injection.
SignalR offers rather weak messaging QoS; ordering and delivery are not guaranteed. You’d have to come up with your own mechanism to ensure robust messaging (e.g., adding sequencing information to messages themselves).
SignalR is designed to be a single-region service, which can negatively impact its performance, reliability, and availability.
Pusher provides hosted APIs to build realtime features for end-users. Pusher has two main products:
Channels - pub/sub channels over WebSockets.
Beams - an API for cross-platform push notifications for iOS, Android, and Web.
Pusher primarily uses WebSockets, but will also fall back to HTTP in environments where WebSockets aren’t supported.
SDKs for every major development platform and programming language, giving you the flexibility of integrating Pusher in your preferred language.
Features such as presence (useful, for example, for chat apps), webhooks to capture and respond to client events as they happen, and end-to-end encryption for enhanced security.
No superior QoS messaging guarantees; for example, if a message is published whilst a client is briefly disconnected (such as going through a tunnel or changing networks), then the message published over Pusher will never arrive to that client.
Pusher does not provide integrations with services such as event streaming platforms (e.g., Kafka) and serverless platforms (e.g., AWS Lambda, Azure Functions, etc.)
Pusher requires you to choose a single datacenter for an app to reside in. All realtime traffic must therefore be routed through that single datacenter, regardless of a user’s location. This has implications for performance, reliability, and availability.
AWS AppSync is a fully managed serverless service for realtime data querying, synchronization, and communication. AppSync provides two types of APIs:
GraphQL APIs, which allow frontends to query databases, microservices, and other backend components from a single GraphQL endpoint.
Pub/sub APIs, which allow you to push realtime updates to subscribers over serverless WebSockets.
AWS AppSync pros
Easy/native integration with many other AWS services, such as AWS Amplify, Amazon DynamoDB, AWS Lambda, and AWS CloudWatch.
Relatively easy to use, has good documentation, and removes the burden of having to host and manage realtime infrastructure yourself.
It allows you to flexibly and efficiently access data from one or more data sources via a single request.
AWS AppSync cons
It’s very much an AWS-centric solution. If your data stores run outside of AWS, or if you are using a type of database that isn’t supported by AppSync by default, you will likely have to spend extra time and resources implementing a data connection layer in your AWS Lambda functions just so you can use your data stores in AppSync.
There are some limitations when it comes to AppSync’s reliability: it’s a single-region service, which only provides a 99.95% uptime guarantee.
AppSync does not support fallback transports for WebSockets (such as long polling). This is a deal breaker if you expect users to connect from environments where WebSockets aren’t supported (like some corporate networks with proxy servers), as the UX of your app would be severely affected.
Ably is a serverless realtime experience infrastructure provider. Ably’s realtime APIs and SDKs help developers power multiplayer collaboration, chat, data synchronization, data broadcast, notifications, and realtime location tracking at internet scale, without having to worry about the underlying infrastructure.
Key Ably features and capabilities
Ably is underpinned by a globally-distributed network of datacenters and edge acceleration points of presence.
Client SDKs for every major programming language and development platform.
Pub/sub APIs with rich features, such as message delta compression, multi-protocol support (WebSockets, MQTT, Server-Sent Events), automatic reconnections with continuity, presence, and message history.
Integrations with many other systems, such as Apache Kafka, Amazon Kinesis, and Amazon SQS.
Cross-platform push notifications.
Guaranteed message ordering and delivery.
Global fault tolerance and a 99.999% uptime SLA.
< 65ms round-trip latency for 99th percentile.
Elastic scalability to handle millions of concurrent clients.
5 great Pusher alternatives to consider
Read about 5 Pusher alternatives for developing functionality like live chat, realtime location tracking, activity feeds, and realtime charts and graphs.
The best 5 SignalR alternatives
Discover the top 5 alternatives to SignalR for use cases such as collaborative apps, realtime dashboards, live chat, and push notifications.
Scaling AWS API Gateway WebSocket APIs - what you need to consider
AWS API Gateway WebSocket APIs allow you to power realtime communication for use cases like chat and live dashboards. But how well does AWS API Gateway scale?