Skip to main content
Version: 8.8

Getting started

The Camunda Spring Boot Starter is the official way to integrate Camunda 8 APIs (gRPC and REST) into your Spring Boot project. It enables you to orchestrate microservices, manage human tasks, and interact with process data using idiomatic Spring Boot patterns.

Public API

The Camunda Spring Boot Starter is part of the Camunda 8 public API and follows Semantic Versioning (except for alpha features). Minor and patch releases will not introduce breaking changes.

Migration from Spring Zeebe SDK

The Camunda Spring Boot Starter replaces the Spring Zeebe SDK as of version 8.8.

  • Uses the new Camunda Java Client under the hood
  • REST is the default protocol (gRPC is configurable)
  • Spring Zeebe SDK will be removed in version 8.10
  • Migrate before upgrading to 8.10 to avoid breaking changes

See the migration guide for details.

What you can build with it​

With the Camunda Spring Boot Starter, you can build:

  • Job workers that perform automated tasks and call external systems (APIs, databases, file systems)
  • Integration services that connect Camunda processes with existing systems or third-party services
  • Data processing applications that use process data for visualization, analytics, or business intelligence

Version compatibility​

Camunda Spring Boot Starter versionJDKCamunda versionBundled Spring Boot version
8.8.x≥ 178.8.x3.5.x

Get started​

Step 1: Add the dependency​

Add the Camunda Spring Boot Starter to your project:

Maven:

<dependency>
  <groupId>io.camunda</groupId>
  <artifactId>camunda-spring-boot-starter</artifactId>
  <version>8.8.x</version>
</dependency>

Step 2: Enable the Java Compiler -parameters flag (optional)​

If you want to use parameter names for process variables without specifying annotation values, enable the Java compiler flag -parameters.

Maven:

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <configuration>
        <compilerArgs>
          <arg>-parameters</arg>
        </compilerArgs>
      </configuration>
    </plugin>
  </plugins>
</build>

If you are using Gradle:

tasks.withType(JavaCompile) {
    options.compilerArgs << '-parameters'
}

If you are using IntelliJ:

Settings > Build, Execution, Deployment > Compiler > Java Compiler

Step 3a: Configure the Orchestration Cluster connection for Self-Managed​

Set up your connection and authentication in application.yaml as shown below. Choose the mode and authentication method for your environment.

Choose the authentication method and gRPC/REST address for your environment:

By default, no authentication will be used.

camunda:
  client:
    mode: self-managed
    auth:
      method: none
    grpc-address: https://my-grpc-address
    rest-address: https://my-rest-address

Step 3b: Configure the Orchestration Cluster connection for SaaS​

Set up your connection and authentication in application.yaml as shown below:

camunda:
  client:
    mode: saas
    auth:
      client-id: <your client id>
      client-secret: <your client secret>
      token-url: https://my-oidc-provider/auth/realms/camunda-platform/protocol/openid-connect/token
    grpc-address: https://my-grpc-address
    rest-address: https://my-rest-address
note

Ensure all addresses use absolute URI format: scheme://host(:port).

Start building your process application​

With your project configured, you are ready to build your process application. Below are the core operations you’ll typically perform, along with guidance on the next steps.

Inject the Camunda client​

You can inject the Camunda client and work with it to create new workflow instances, for example:

@Autowired
private CamundaClient client;

Implement the job worker​

Declare a method like this on a bean:

@JobWorker(type = "foo")
public void handleJobFoo() {
  // do whatever you need to do
}

To learn about all options you have with job workers, check out the configuration page.

Deploy process models​

To deploy process models on application start-up, use the @Deployment annotation:

@SpringBootApplication
@Deployment(resources = "classpath:demoProcess.bpmn")
public class MySpringBootApplication {

To learn about all options about the usage of the @Deployment annotation, check out the configuration page.

Need help?