Tag Archives: Spring Boot

How to Use Event Hubs and Service Bus Testcontainers in Spring Boot

Posted on by

Introduction

Testcontainers has released dedicated modules for Azure Event Hubs and Azure Service Bus emulators.

These modules greatly simplify the use of these emulators compared to the custom solutions I previously implemented using generic containers and docker compose in:
1. Using Azure Event Hubs Emulator as a Test Container
2. Using Azure Service Bus Emulator as a Test Container

In this article, I’ll show how to use these new modules in Spring Boot by applying the singleton containers pattern.

Singleton Containers Pattern

With the singleton containers pattern, containers are started only once and reused across all test classes.

This approach is especially valuable for Event Hubs and Service Bus emulators, as each depends on additional containers. Starting and stopping these dependencies for every test class—or worse, every individual test—would be highly inefficient and slow down the entire test suite.

In our setup, all required containers are started in a base test class, and all other test classes extend it. This ensures containers are initialized only once, while their configuration remains available everywhere.

We then inject the container connection properties into the Spring Boot application context using @DynamicPropertySource, which lets us define Spring properties dynamically at runtime based on container output.

Using Event Hubs Module

Dependencies:

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>azure</artifactId>
    <version>1.21.3</version>
    <scope>test</scope>
</dependency>

Base class (on GitHub):

abstract class AbstractIntegrationTest {
    public static final String AZURITE_IMAGE = "mcr.microsoft.com/azure-storage/azurite:3.33.0";
    public static final String EVENTHUBS_IMAGE = "mcr.microsoft.com/azure-messaging/eventhubs-emulator:2.0.1";

    private static final Network network = Network.newNetwork();

    private static final AzuriteContainer azurite = new AzuriteContainer(AZURITE_IMAGE)
            .withNetwork(network);

    private static final EventHubsEmulatorContainer emulator = new EventHubsEmulatorContainer(EVENTHUBS_IMAGE)
            .acceptLicense()
            .withNetwork(network)
            .withConfig(MountableFile.forClasspathResource("eventhub-emulator-config.json"))
            .withAzuriteContainer(azurite);

    static {
        azurite.start();
        emulator.start();
    }

    @DynamicPropertySource
    static void registerPgProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.cloud.azure.eventhubs.connection-string=", emulator::getConnectionString);
        registry.add("spring.cloud.azure.eventhubs.processor.checkpoint-store.connection-string", azurite::getConnectionString);
        registry.add("spring.cloud.azure.eventhubs.processor.checkpoint-store.endpoint", () -> String.format("http://localhost:%d/devstoreaccount1/", azurite.getMappedPort(10000)));
    }
}

Using Service Bus Module

Dependencies:

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>azure</artifactId>
    <version>1.21.3</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>com.microsoft.sqlserver</groupId>
    <artifactId>mssql-jdbc</artifactId>
    <version>12.8.1.jre11</version>
    <scope>test</scope>
</dependency>

Base class (on GitHub):

abstract class AbstractIntegrationTest {
    public static final String SQL_SERVER_IMAGE = "mcr.microsoft.com/mssql/server:2022-CU14-ubuntu-22.04";
    public static final String SERVICEBUS_IMAGE = "mcr.microsoft.com/azure-messaging/servicebus-emulator:1.1.2";

    private static final Network network = Network.newNetwork();

    public static MSSQLServerContainer<?> mssqlServerContainer = new MSSQLServerContainer<>(SQL_SERVER_IMAGE)
            .acceptLicense()
            .withPassword("yourStrong(!)Password")
            .withCreateContainerCmdModifier(cmd -> cmd.getHostConfig().withCapAdd(Capability.SYS_PTRACE))
            .withNetwork(network);

    public static ServiceBusEmulatorContainer emulator = new ServiceBusEmulatorContainer(SERVICEBUS_IMAGE)
            .acceptLicense()
            .withConfig(MountableFile.forClasspathResource("/servicebus-emulator-config.json"))
            .withNetwork(network)
            .withMsSqlServerContainer(mssqlServerContainer);

    static {
        mssqlServerContainer.start();
        emulator.start();
    }

    @DynamicPropertySource
    static void registerPgProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.cloud.azure.servicebus.connection-string", emulator::getConnectionString);
        registry.add("emulator-ampq-port", emulator::getFirstMappedPort);
    }
}

Summary

Use Testcontainers’ Azure Event Hubs and Service Bus modules with the singleton containers pattern to speed up Spring Boot integration tests.

Start emulators once in a base test class, inject their connection strings with @DynamicPropertySource, and extend that class in your tests for fast, consistent, and fully local testing.

For examples of extending and using the base class visit the GitHub repository: azure-testcontainers-in-spring-boot

Cloud Foundry: How to Autoscale a Spring Boot Application Using Custom Metrics

Posted on by

I have created a demo Spring Boot project showing how you can scale a Spring Boot application on Cloud Foundry using custom metrics.

Custom metrics scaling allows you to scale applications based on your own defined metrics, such as job queues or pending tasks, aligning scaling with business needs and workload patterns.

This demo shows an application that is autoscaled based on the custom metrics it provides to the autoscaler.

cf custom metrics autoscaling


For code and more details visit the GitHub repository: https://github.com/mirkoiv/cf-custom-metrics-autoscaling-demo

Concept

An Autoscaler service exposes a custom metrics URL and an endpoint for sending metrics.

The URL is defined in VCAP_SERVICES:

{
  "autoscaler": [
    {
      "credentials": {
        "custom_metrics": {
          "mtls_url": "https://autoscaler-metrics-mtls.cf.example.org"
        }
      }
    }
  ]
}

and the endpoint is:

{{mtls_url}}/v1/apps/{{appGuid}}/metrics

where appGuid is you application id defined in VCAP_APPLICATION[‘application_id’]

To authenticate, the app uses the X.509 certificate and private key provided in the environment variables CF_INSTANCE_CERT and CF_INSTANCE_KEY.

The custom metrics payload is:

{
  "instance_index": "{{instance_index}}",
  "metrics": [
    {
      "name":"my_counter",
      "value": 7
    }
  ]
}

where instance_index is available in the environment variable CF_INSTANCE_INDEX.

Using Azure Service Bus Emulator as a Test Container

Posted on by

This sample project shows how to use the Azure Service Bus emulator as a test container for local development and integration testing.

The Service Bus emulator, like the Event Hubs emulator, doesn’t have a dedicated Testcontainers module and relies on Azure SQL Edge.

You can initialize the Service Bus emulator as a test container in two ways:

1️⃣ Code Compose: Setting up containers programmatically with the GenericContainer class.
2️⃣ Docker Compose: Using a Docker Compose file for container orchestration.

For more details, visit the GitHub repository: https://github.com/mirkoiv/servicebus-emulator-as-testcontainer

Building Service Bus emulator as a Test Container

Service Bus emulator does not have a Testcontainers module (yet), and additionally the emulator requires Azure SQL Edge.

There are two ways to initialize the Service Bus Emulator as a test container:

1️⃣ code compose – Composing through code using the GenericContainer class – AbstractServiceBusContainerCodeCompose
2️⃣ docker compose – Using a Docker Compose file and ComposeContainer class – AbstractServiceBusContainerDockerCompose

Key Differences Between the Two Approaches

In the first case, tests or applications interact directly with the ports exposed by the generic emulator and storage test containers. In the second case, an additional ambassador container is created, serving as a proxy to the generic emulator and storage containers.

Code Compose:

Docker Compose:

For more details and run samples, visit the GitHub repository: https://github.com/mirkoiv/servicebus-emulator-as-testcontainer

Using Azure Event Hubs Emulator as a Test Container

Posted on by

This sample project demonstrates how to utilize the Azure Event Hubs emulator as a test container for local development and integration testing.

The Event Hubs emulator does not have a Testcontainers module and depends on the Azure Storage emulator (Azurite).

There are two ways to initialize the Event Hub Emulator as a test container:

1️⃣ Code Compose: Setting up containers programmatically with the GenericContainer class.
2️⃣ Docker Compose: Using a Docker Compose file for container orchestration.

For more details, visit the GitHub repository: https://github.com/mirkoiv/event-hubs-emulator-as-testcontainer

Building Event Hubs emulator as Test Container

Event Hubs emulator does not have a Testcontainers module (yet), and additionally the emulator requires Azure Storage emulator (azurite).

There are two ways to initialize the Event Hub Emulator as a test container:

1️⃣ code compose – Composing through code using the GenericContainer class – AbstractEventHubContainerCodeCompose
2️⃣ docker compose – Using a Docker Compose file and ComposeContainer class – AbstractEventHubContainerDockerCompose

Key Differences Between the Two Approaches

In the first case, tests or applications interact directly with the ports exposed by the generic emulator and storage test containers. In the second case, an additional ambassador container is created, serving as a proxy to the generic emulator and storage containers.

Code Compose:

eventhubs emulator - code compose

Docker Compose:

eventhubs emulator - docker compose