Key Concepts

Tyk Streams seamlessly integrates with the Tyk API Gateway to provide a unified platform for managing both synchronous and asynchronous APIs. This section will provide an overview of the architecture, integration points, and key capabilities. Please consult the glossary for explanations of key terminology.

Tyk Streams is natively integrated as part of Tyk API Gateway and has no third-party dependencies.

Key components in the architecture of Tyk Streams:

• Tyk API Gateway: The core API management platform that handles API requests, applies policies, and routes requests to the appropriate backend services.
• Tyk Streams: An extension to the Tyk API Gateway that enables support for asynchronous APIs and event-driven architectures.
• Event Brokers: External systems such as Apache Kafka, MQTT brokers, or WebSocket servers that produce and consume events.
• Backend Services: The underlying services and systems that expose APIs or consume events.

Tyk Streams as middleware in Tyk API Gateway

Tyk Streams operates as middleware within the Tyk API Gateway, providing the following functionalities:

• Middleware: Tyk Streams introduces new middleware components that handle async-specific functionality such as protocol mediation, event transformations, and pub/sub messaging.
• API Definitions: Tyk Streams is configured using the standard Tyk OAS format, including additional fields tailored for async protocols and event configurations.
• Analytics: Async API traffic is captured and reported via Prometheus, OpenTelemetry or StatsD, providing visibility into usage, performance, and errors.

Connectors and Protocol Mediation

Tyk Streams provides out-of-the-box connectors for popular event brokers and async protocols, including:

• Apache Kafka
• MQTT
• RabbitMQ
• Solace
• RedPanda
• AMQP
• WebSocket
• Server-Sent Events (SSE)
• Webhooks

In addition to the native protocol support, Tyk Streams offers powerful protocol mediation capabilities. This allows you to expose async APIs using different protocols than the backend event broker, making it easier to support a diverse client requirements.

For example, you can:

• Expose a Kafka topic as a WebSocket API
• Convert MQTT messages to HTTP webhooks
• Bridge between different async protocols (e.g., Kafka to MQTT)