Microservices Architecture: Temporal Orchestration + Spring

In this lesson we will see how to set up a local development environment with everything needed to start programming workflows on Temporal.

In this lesson we will see how to integrate a Spring Boot microservice as a Temporal worker, and we will provide an example that will be developed throughout the course.

All examples and implementations will focus on using Temporal’s capabilities integrated with the Spring Framework. In other words, we will create configurations, manage beans, and establish a foundation to efficiently integrate Spring Boot with Temporal.

In this lesson we will see how to implement a workflow in a Spring Boot microservice and run it on Temporal. We will cover the essential annotations, as well as how to use all the configuration classes created as beans and integrated into a service, and how it is now possible to launch a workflow as part of a feature invoked from a REST request by a user.

In this lesson we will continue with the previous example, where a workflow was executed initialized with default values, and we will go deeper into a very important aspect: the handling of the workflowId, which, together with specifying the correct policy, will allow us to control concurrency over shared resources.

Through this example, we will observe Temporal’s behavior under different configuration scenarios.

In this lesson, continuing with the same example, we will delve into configuration aspects to gain fine-grained control over workflow execution in Temporal, focusing especially on timeouts and retry policies.

Using a practical example, we will see how Temporal behaves when exceptions occur and what the consequences are of executing retries at the workflow level.

In this lesson we will cover two very important concepts for interacting with running workflows: signals and query methods.

Building on our example, we will see how we can use signals to influence the execution of a workflow, including sending signals so that the workflow can make control decisions. We will also see how to perform queries on intermediate values that are important for implementing higher-level business logic based on the current state of workflows.

In this lesson we will do a brief retrospective to highlight how important it is to control the features covered in this section and not leave workflows with their default configuration in production environments, since we must be very clear about the expected behavior.

In this lesson we will take a deeper look at the concept of an Activity and how to use the SDK to define activities and methods with annotations so they can be instantiated from a workflow and executed.

In this lesson we will take a deeper look at Activities and the concepts of Local and Remote activities, and how Temporal orchestrates their execution.

As with the Workflows section, we will also go into detail on configuration parameters to manage retries and send heartbeats, giving us full control over the execution of activities.

In this lesson we will dive deeper into configuring activity execution timeouts in order to maintain control over how long an activity can run and avoid stalled workflow executions that consume resources indefinitely due to errors.

In this lesson we will cover asynchronous and parallel execution of activities by the workflow to increase concurrency and improve execution times in workflows where activities can be parallelized.

This class will cover the asynchronous and parallel execution of activities by the workflow to increase concurrency and improve execution times in workflows where activities can be parallelized.

In this lesson we will take a deeper look at the concept of namespaces in Temporal as a way to provide physical isolation for workflow executions, as well as a logical mechanism for separating responsibilities.

In this lesson we will use the SDK to implement a service that can manage namespaces and create new ones, taking into account criteria such as retention time and archiving.

In this lesson we will see how to use the SDK to query the execution history of a workflow and verify that we can access all relevant information, so that it can be leveraged for auditing, process synchronization, and other purposes.

In this lesson, through a practical example, we will verify Temporal’s ability to recover from failures both in the microservices and in the orchestrator, so that execution can be resumed from a specific point. This provides the key capability we are looking for: support for long-running workflows while preserving state and the exact execution point.

Retrospective class in which we will review everything covered so far and re-examine Temporal’s features now that we have seen them through concrete examples.

Class in which we introduce the next part of the course now that Temporal’s capabilities are understood. We will analyze patterns and scenarios where Temporal can help us implement complex use cases, reducing the risk of errors and accelerating our development.

In this lesson we will briefly review microservices architecture, its main characteristics, and the challenges that are difficult to address. From a design perspective, we will also examine how the use of Temporal fits into complex use cases in distributed architectures.

In this lesson we will review microservices architecture patterns that are necessary to address challenges such as batch processing and distributed transactions, and we will explore an architectural view of the challenges that need to be implemented.

In this lesson we will explore a new perspective on implementing an application using Event Sourcing, Event-Driven, and Orchestration patterns, analyzing the complexity and risks involved in choosing one model or another and their impact on a distributed architecture.

In this lesson we will examine, from both a design and behavioral perspective for our application and from a distributed architecture point of view, which scenarios involve greater complexity and how Temporal can help us reduce risk and accelerate development, since its features align naturally with the definition of architectural patterns from a design standpoint.

In this lesson we will validate the selection of a framework to facilitate the integration of Spring Boot microservices with Temporal, with the goal of accelerating application development.

In this lesson we will validate the official Temporal framework that facilitates the integration of Spring Boot microservices with Temporal, and we will review the acceptance criteria and risks of using it.

In this lesson we will explore how to develop our own framework in order to maintain full control over the SDK features, while assessing the risks and characteristics involved in supporting a custom framework.

In this lesson we will theoretically examine complex distributed transaction scenarios and the current validated patterns for efficiently implementing the complex use case that will later be validated from the perspective of an orchestrated SAGA implemented on top of Temporal.

In this lesson, using a code example, we will see how relying on Temporal fulfills all the requirements to implement the SAGA pattern, as well as how to use the abstractions provided by the Temporal SDK for the explicit implementation of the pattern.

In this lesson we will analyze the complexity of implementing batch processing in a microservices architecture without compromising scalability and resilience. We will also review the main patterns used for implementing batch processing and see how Temporal helps us in one of these patterns to provide robust support for batch workloads.

In this lesson we will dive deeper into the features provided by Temporal (Scheduler Workflows and Child Workflows) that help us implement batch processing in a way that can scale horizontally while giving us full control over the overall execution of the process.

In this lesson, using sample code, we will explain how to implement scheduler workflows and child workflows so that we can build a batch processing solution that parallelizes tasks, gives us full control over execution, and enables horizontal scalability for batch workloads.