Cross region import of EventBus is unable to import the target bus - aws-cdk

Question

I'm trying to translate my existing CDK project from Java to Typescript, and at the same time migrate from CDKv1, used by the older project, to CDK v2. I'm mostly done, but there is one last thing that's driving me crazy.
This project uses Chime, and I use its events for some application logic. AWS Chime events are produced in the us-east-1 region, and my application is in eu-west-1. The solution that I came up to was to create a Rule, listening to Chime events, in us-east-1, then redirect the events on an EventBus on eu-west-1: then I'd filter the events on that bus using rules for the events I'm interested in and execute my logic through lambdas.
This is the old project's code:
App.java
Environment env = Environment.builder()
.account(ACCOUNT_ID)
.region(REGION)
.build();
StackProps sp = StackProps.builder()
.env(env)
.build();
Environment envUsEast1 = Environment.builder()
.account(ACCOUNT_ID)
.region("us-east-1")
.build();
StackProps spUsEast1 = StackProps.builder()
.env(envUsEast1)
.build();
MonitoringStack eventsMonitoringStack = new MonitoringStack(app,
"EventMonitoringStack",
sp);
EventsOriginStack eventsOriginStack = new EventsOriginStack(app,
"EventOriginStack", spUsEast1);
chimeEventsOriginStack.addEventBridgeToOriginRule(eventsMonitoringStack.getListenerBus());
MonitoringStack.java
public class MonitoringStack extends Stack {
EventBus listenerBus;
public MonitoringStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
listenerBus = new EventBus(this, "listener-event-bus", EventBusProps
.builder()
.eventBusName("listener-event-bus")
.build());
Rule attendeeJoinedRule = new Rule(this, "attendee-joined-rule", RuleProps.builder()
.ruleName("attendee-joined-rule")
.eventBus(listenerBus)
.eventPattern(EventPattern.builder()
.detailType(Collections.singletonList("Chime Meeting State Change"))
.source(Collections.singletonList("aws.chime"))
.detail(Map.of("eventType", List.of("chime:AttendeeJoined")))
.build())
.build());
...more logic...
EventsOriginStack.java
public class EventsOriginStack extends Stack {
Rule chimeEventsRule;
public EventsOriginStack(#Nullable Construct scope, #Nullable String id, #Nullable StackProps props) {
super(scope, id, props);
chimeEventsRule = new Rule(this, "chime-all-events-rule", RuleProps.builder()
.ruleName("chime-all-events-rule")
.eventPattern(EventPattern.builder()
.detailType(Collections.singletonList("Chime Meeting State Change"))
.source(Collections.singletonList("aws.chime"))
.build())
.build());
}
public void addEventBridgeToOriginRule(EventBus eventBus) {
chimeEventsRule.addTarget(new software.amazon.awscdk.services.events.targets.EventBus(eventBus));
}
}
And now the same code is like this:
app.ts
const env: Environment = {
account: process.env.AWS_ACCOUNT_ID,
region: process.env.REGION
}
const props: StackProps = {
env: env
}
const envUsEast1: Environment = {
account: process.env.AWS_ACCOUNT_ID,
region: "us-east-1"
}
const propsUsEast1: StackProps = {
env: envUsEast1
}
const eventsMonitoringStack: EventsMonitoringStack = new EventsMonitoringStack(app,
"eventMonitoringStack", {
env: env
});
const eventsOriginStack: EventsOriginStack = new EventsOriginStack(app,
"EventOriginStack", propsUsEast1);
chimeEventsOriginStack.addEventBridgeToOriginRule(eventsMonitoringStack.listenerBus);
events-monitoring-stack.ts
export class EventsMonitoringStack extends Stack {
private _listenerBus: EventBus;
public get listenerBus(): EventBus {
return this._listenerBus;
}
public set listenerBus(value: EventBus) {
this._listenerBus = value;
}
constructor(scope: Construct, id: string, props: EventsMonitoringStackProps) {
super(scope, id, props);
this.listenerBus = new EventBus(this, "listener-event-bus", {
eventBusName: "listener-event-bus"
});
const attendeeJoinedRule = new Rule(this, "attendee-joined-rule", {
ruleName: "attendee-joined-rule",
eventBus: this.listenerBus,
eventPattern: {
detailType: [
"Chime Meeting State Change"
],
source: [
"aws.chime"
],
detail: {
"eventType": ["chime:AttendeeJoined"]
}
}
});
...more logic...
events-origin-stack.ts
//the naming choice is quite annoying
import { EventBus, Rule } from "aws-cdk-lib/aws-events";
import { EventBus as EventBusTarget } from "aws-cdk-lib/aws-events-targets";
export class EventsOriginStack extends Stack {
private _chimeEventsRule: Rule;
public get chimeEventsRule(): Rule {
return this._chimeEventsRule;
}
public set chimeEventsRule(value: Rule) {
this._chimeEventsRule = value;
}
constructor(scope: Construct, id: string, props: StackProps) {
super(scope, id, props);
this._chimeEventsRule = new Rule(this, "chime-all-events-rule", {
ruleName: "chime-all-events-rule",
eventPattern: {
detailType: ["Chime Meeting State Change"],
source: ["aws.chime"]
}
});
}
public addEventBridgeToOriginRule(eventBus: EventBus) {
this.chimeEventsRule.addTarget(new EventBusTarget(eventBus));
}
}
So,the problem: at cdk diff time, and on deploy, this comes out:
┌───┬───────────────────────────────────────────────────────────────────────────────────────┬────────┬──────────────────┬─────────────────────────────────────────┬───────────┐
│ │ Resource │ Effect │ Action │ Principal │ Condition │
├───┼───────────────────────────────────────────────────────────────────────────────────────┼────────┼──────────────────┼─────────────────────────────────────────┼───────────┤
│ + │ ${chime-all-events-rule/EventsRole.Arn} │ Allow │ sts:AssumeRole │ Service:events.amazonaws.com │ │
├───┼───────────────────────────────────────────────────────────────────────────────────────┼────────┼──────────────────┼─────────────────────────────────────────┼───────────┤
│ + │ arn:${AWS::Partition}:events:${AWS::Region}:<my-aws-account-id>:event-bus/listener-event-bus │ Allow │ events:PutEvents │ AWS:${chime-all-events-rule/EventsRole} │ │
└───┴───────────────────────────────────────────────────────────────────────────────────────┴────────┴──────────────────┴─────────────────────────────────────────┴───────────┘
Unlike before on Java and CDKv1, where the result was something like this:
IAM Statement Changes
┌───┬────────────────────────────────────────────────────────────────────┬────────┬──────────────────┬─────────────────────────────────────────┬───────────┐
│ │ Resource │ Effect │ Action │ Principal │ Condition │
├───┼────────────────────────────────────────────────────────────────────┼────────┼──────────────────┼─────────────────────────────────────────┼───────────┤
│ + │ ${chime-all-events-rule/EventsRole.Arn} │ Allow │ sts:AssumeRole │ Service:events.amazonaws.com │ │
├───┼────────────────────────────────────────────────────────────────────┼────────┼──────────────────┼─────────────────────────────────────────┼───────────┤
│ + │ arn:aws:events:eu-west-1:<my-aws-account-id>:event-bus/listener-event-bus │ Allow │ events:PutEvents │ AWS:${chime-all-events-rule/EventsRole} │ │
└───┴────────────────────────────────────────────────────────────────────┴────────┴──────────────────┴─────────────────────────────────────────┴───────────┘
And on deploying, the result I get is the two stacks, correctly deployed in their respective regions. The issue is the destination for the origin rule: instead of being the listener event bus on eu-west-1, it's some event bus with the same name in us-east-1:
So, instead of pointing to an event bus with an ARN like this:
arn:aws:events:eu-west-1:<my-account-id>:event-bus/listener-event-bus
it's something like this:
arn:aws:events:us-east-1:<my-account-id>:event-bus/listener-event-bus
I suspect is an issue with the CloudFormation references, and how they are resolved at deploy time, but I can't figure how can I solve this, especially because it worked fine in the older Java version.
Can anyone give me a pointer on how to solve this issue? For what matters, I've launched cdk bootstrap after updating cdk to version 2, and it seems the version is far beyond the required version 6.

Answer 1

Thank you #gshpychka, that was exactly what was going on! From the old Java code I left the variable REGION, which was actually initialized as private static final String REGION= System.getenv("AWS_REGION");. AWS_REGION is the actual environment variable where I put the default region.
Changing region: process.env.REGION to region: process.env.AWS_REGION solved my issues.