BridgeBus
Amazon EventBridge for Blueprints and C++

Overview

BridgeBus connects Unreal Engine 4.27 and 5.8 to Amazon EventBridge and EventBridge Scheduler. Your game publishes what happens — matches finished, purchases, achievements, telemetry — as events; EventBridge rules deliver them to Lambda functions, SQS queues, Step Functions, other buses or HTTP endpoints without the game knowing about any of them. Requests run on background worker threads with automatic retries; every result arrives on the game thread.

• Put Event and Put Events (any number of entries, split at the 10-entry API limit, per-entry results).
• BridgeBus Emitter component: queue events from gameplay, automatic batched flushing, retry of throttled events, stats.
• Buses, rules and targets: list, describe, create and delete buses; put, enable, disable and delete rules; put, list and remove targets with input transformers, retry policies and dead-letter queues.
• Archives and replays, including a latent Wait For Replay.
• EventBridge Scheduler: one-off at(), rate() and cron() schedules with time zones, flexible windows, start/end dates and self-deleting one-off schedules; Schedule Event emits an event at a given time.
• Pure helpers: event pattern builder, local pattern matcher, event envelope parser, ARN helpers, expression builders and validator, JSON helpers.

Requirements

Installation

1. Install BridgeBus from Fab into your engine, or copy the BridgeBus folder into your project's Plugins folder.
2. Enable BridgeBus in Edit > Plugins and restart the editor.
3. Open Project Settings > Plugins > BridgeBus and set Region, Identity Pool Id and Default Source.
4. C++ only: add PublicDependencyModuleNames.Add("BridgeBus"); to your Build.cs.

Setting up AWS

1. In Amazon Cognito create an identity pool (enable guest access if players publish before signing in).
2. Optional: create a custom event bus such as mygame-prod in the EventBridge console and set it as Default Event Bus Name.
3. Give the player role of the pool only what the game client needs — putting events with your own source:

{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Action": "events:PutEvents",
    "Resource": "arn:aws:events:us-east-1:123456789012:event-bus/mygame-prod",
    "Condition": { "StringEquals": { "events:source": "com.mygame" } }
  }]
}

If players create their own reminders with the scheduler, add a scoped scheduler statement (one schedule group per game) plus iam:PassRole on the scheduler execution role:

{
  "Effect": "Allow",
  "Action": ["scheduler:CreateSchedule", "scheduler:GetSchedule", "scheduler:DeleteSchedule"],
  "Resource": "arn:aws:scheduler:us-east-1:123456789012:schedule/mygame-reminders/*"
},
{
  "Effect": "Allow",
  "Action": "iam:PassRole",
  "Resource": "arn:aws:iam::123456789012:role/mygame-scheduler-role",
  "Condition": { "StringEquals": { "iam:PassedToService": "scheduler.amazonaws.com" } }
}

The scheduler execution role (Default Scheduler Role Arn) is trusted by scheduler.amazonaws.com and allowed to invoke its targets, for example events:PutEvents on your bus or lambda:InvokeFunction.

Quick start

Publish an event

1. Add Put Event to an Event Graph. Detail Type MatchFinished, Detail {"matchId":"42","winner":"blue"} (or build it with Struct To JSON).
2. From On Success, read Result > Event Id. From On Failure, print Error > Message.
3. In the EventBridge console create a rule on the bus with pattern {"source":["com.mygame"],"detail-type":["MatchFinished"]} and a Lambda target — or do the same from a tool with Make Event Pattern, Put Rule and Put Targets.

Telemetry with the emitter

1. Add a BridgeBus Emitter component to your GameState. Set Default Detail Type Telemetry, Auto Flush Interval 5.
2. Call Queue Event wherever something happens. The component sends batches in the background; bind On Failed to log lost events.

A timed event

1. Set Default Scheduler Role Arn in the settings.
2. Call Schedule Event with Fire Time = tomorrow 18:00 UTC, Event Bus Arn = Make Event Bus Arn, Detail Type TournamentStart. The schedule emits the event at that time and deletes itself.

Node reference

All 79 nodes, grouped by Blueprint category. Latent nodes run in the background, fire exactly one final pin on the game thread and can be stopped with Cancel. Nodes marked (admin) need admin IAM permissions.

Config and identity

Events

Buses

Rules and targets

Archives and replays

Schedules

Emitter (BridgeBus Emitter component)

JSON

Emitter component

BridgeBus Emitter keeps a queue of events and sends it when Auto Flush Interval elapses, when Max Batch Size events are waiting, or on Flush. One flush is in flight at a time (up to 100 events, sent 10 per request). Events rejected with a retryable error (throttling, internal failure, network) go back into the queue when Requeue Retryable is on; others are reported on On Failed. When the queue is full (Max Pending), the oldest events are dropped. With Flush On End Play the remaining events are sent when the actor ends play. Stamp Queue Time keeps the real event time even when batches are sent later.

Event patterns

Make Event Pattern (Sources = [com.mygame], Detail Types = [Purchase])
  -> Add Pattern Prefix Filter (Field Path = detail.sku, Prefix = "gem_")
  -> {"source":["com.mygame"],"detail-type":["Purchase"],"detail":{"sku":[{"prefix":"gem_"}]}}

Event Pattern Matches evaluates exact values, prefix, suffix, equals-ignore-case, exists, anything-but (values or prefix) and numeric ranges, on nested fields and array values. It is meant for client-side routing and tests; Test Event Pattern asks the service for the authoritative answer (it needs a complete event with id, account, time, region, source, detail-type and resources).

Schedule expressions

Options: time zone (IANA name), state, flexible window (the scheduler may fire up to N minutes late to spread load), start and end dates for recurring schedules, and Action After Completion = Delete for one-off schedules.

Credentials

C++ API

// Build.cs: PublicDependencyModuleNames.Add("BridgeBus");
#include "BridgeBusLibrary.h"

TArray<FBridgeBusEventEntry> Entries;
Entries.Add(UBridgeBusLibrary::MakeEventEntry(TEXT("MatchFinished"), TEXT("{\"matchId\":\"42\"}"),
    FString(), FString(), TArray<FString>(), FDateTime(0)));
UBridgeBusLibrary::PutEventsNative(Entries, FBridgeBusNativeDelegate::CreateLambda(
    [](const TArray<FBridgeBusPutResult>& Results, int32 FailedCount)
    {
        // runs on the game thread
    }));

All latent node classes (UBridgeBusPutEventAction and the others) can be created from C++ through their static factory functions; bind the delegates, then call Activate().

Types

Settings

Project Settings > Plugins > BridgeBus (saved to DefaultGame.ini). Changes apply to the next request.

Troubleshooting

Credits

© 2026 Alpha XP — alphaxp.net · Support: support@alphaxp.net. Includes the AWS SDK for C++ and the AWS Common Runtime (Apache License 2.0). Built for Unreal Engine 4.27 and 5.8.