In most programs with large workflows, especially those composed of multiple microservices, proper organization and management is complicated: you have to consider their current state, the system's fault tolerance, and its proper operation from start to finish. It's undeniable that every application strives for maximum stability, security, and reliability, but achieving these goals isn't always easy.
What does Temporal.io offer?
Once the general functionality of the Temporal Orchestrator has been defined, we can go into more detail about all the advantages it offers in a more concrete way:
- Temporal manages the execution state of all flows at any given time, achieving the benefits of a state machine without its added complexity. It is capable of coordinating multiple distributed services, ensuring various qualities discussed in the following points.
- Retry policies can be easily defined, allowing you to react to execution failures even within the desired timeframe without having to program them directly. These retries are automatic, and policies can be defined for them, specifying specific characteristics of what, when, and how to retry processes.
- Just as the time limits for execution retries can be customized to the developer's liking, Temporal can also be used to set timers within the Workflow, pausing its execution or defining timeouts for activities or entire flows.
- With Temporal, you can also forget about cron jobs in most cases, as the tool allows you to organize workflows with this same function. Furthermore, their status is automatically persisted step by step, and they can be resumed after the last step executed after a process interruption.
- One of Temporal's greatest strengths is the nature of its operation: The entire workflow is defined with imperative code , making its creation considerably easier.
- Temporal also offers the possibility of being used in Go, Java, TypeScript, .NET, PHP, Python and Ruby SDKs.
How your Temporary Web UI Works
Temporal has a web interface that allows users to view the status and metadata of their workflows and their respective executions at any time for debugging purposes. Details on how it works are provided below.
To run it, you must create a Temporary service that includes its web interface, a namespace, and a database (although if it is for testing, you can create a service that uses the computer's memory as a database, making it non-persistent).
Command to lift the service:temporal server start-dev –ui-port PUERTO –db-filename BD_Temporal.db
Command to start the service without data persistence (test):temporal server start-dev
Once this is done, in addition to having launched the program that uses Temporal, you can access it from the specified port, for example http://localhost:8080.
Once there, you have access to a series of metrics and logs. We'll break down each section to explain what it's all about:
- Workflows: This tab manages the execution of workflows. You can view detailed information about them, such as recorded inputs and results, as well as a history of events performed along with a list of each, including dates and details for each. In addition to viewing this information, you can cancel, terminate, or signal running workflows from here.
- Schedules: Here you will find the Workflows that have been scheduled (cron-style) and where they can be paused, resumed, edited, or deleted.
- Batch: Batch actions can be performed on many Workflows at the same time.
- Deployments: This is where workflow deployments, code version control, and support for both rollbacks and upgrades are managed.
- Archive : Displays archived workflows, stored long-term but no longer present in memory.
From here there are other more generic tabs that are not directly related to Workflows:
- Namespaces: Here you can see a list of the namespaces where the workflows run and some information about them. By default, the Default namespace will be used.
- Nexus: New functionality that allows you to connect to external services (such as APIs or DBs) using connectors to consume external data such as Activities without code.
- Import: Load previously exported or defined Workflows.
- Docs: Takes you directly to the official Temporal documentation.
- Feedback: This is simply a form to send suggestions or report problems with the UI.
Next, we'll explain in more detail the most interesting tab: the Workflows tab. But before that, you must launch one to view it. A small example of a payment transaction will be used to get started with the web application.
The first thing you need to do is have a functional Temporal project ready. In this case, you have a Java program that launches the MoneyTransferWorkflow workflow. This workflow represents a money transfer between two accounts (in a simplified way).
Main function where the Workflow will start
Once you've broken down all the code for the main function, you can run the program and see what's displayed in the Temporal Web UI. To launch it, in addition to having the Temporal service started, as explained above, you also need to run the workflow:
mvn compile exec:java -Dexec.mainClass="moneytransferapp.TransferApp" -Dorg.slf4j.simpleLogger.defaultLogLevel=warn
Once this is done, a transaction will have been performed that will serve as an example for using the Web UI:
Compilation result of TransferApp.java
Viewing the Workflow generated when compiling the TransferApp.java application
We now have information about the launched workflow, but as Temporal points out, there are no workers running, and without them, the workflows cannot be executed. The following must be executed:
mvn compile exec:java -Dexec.mainClass="moneytransferapp.MoneyTransferWorker" -Dorg.slf4j.simpleLogger.defaultLogLevel=warn
Now that you have a Worker listening to the running Workflow task queue, it will return the results to the Temporal server.
Result obtained after enabling a Worker to process Workflow activities in TransferApp.java
Comparison between Temporal and Camunda 8
Currently, there are several tools that offer the same capabilities as Temporal, and one of the most recognized in this regard is Camunda 8. Therefore, one of the biggest challenges when choosing how to orchestrate applications is comparing the different features of each product on the current market. Below, we compare the different features of both:
- Interface VS Code: While Temporal has a web interface that provides information to the user, everything we need to implement is done through code. In contrast, Camunda uses a visual editor (BPMN) where we can drag and drop different functions to create our own workflows, having a simpler difficulty curve but sacrificing some flexibility compared to Temporal's programmatic approach.
- Centralized VS Decentralized: Camunda 8 uses an event queue-based workflow engine, designed for scalability, but with a clear separation between the engine and services, while Temporal uses a decentralized workflow execution model where each Worker can be distributed across multiple machines and locations with greater decentralization.
- Event-driven vs. non-event-driven: Temporal, unlike Camunda 8, places a strong emphasis on creating reactive workflows, with listeners and executions based on external events. While Camunda also allows event-driven workflows, it places less emphasis on them.
- Scalable approach vs. non-scalable approach: As with the previous feature, Camunda also supports horizontal scalability, but it wasn't specifically designed for this until version 8, when it is now possible. Temporal, on the other hand, is prepared for large-scale workflows that require high scalability and fault tolerance, with an even greater focus on this task than Camunda 8.
- Longevity VS Novelty: One of the areas where Camunda 8 undoubtedly surpasses Temporal is its community, as it has been in operation longer, thus providing better integrations with other systems and tools, better overall support, and more information and documentation related to its use.
Conclusion
We were able to see firsthand the advantages offered by Temporal's software, in addition to its code-level orchestration. It's a tool that unifies the extensive needs of applications with complex workflows and large volumes, facilitating their proper management in a simple and highly intuitive manner thanks to its Web UI.
From error handling, controlled pauses, and easy work distribution to data processing and metrics observability, Temporal positions itself as an orchestrator that empowers teams with microservices and distributed business logic, turning chaos into maintainable, resilient, and scalable code.
Want to know more about Hunters?
Being a Hunter means accepting the challenge of testing new solutions that deliver differentiated results. Join the Hunters program and become part of a cross-functional group capable of generating and transferring knowledge.
Get ahead of the digital solutions that will drive our growth. Find more information about Hunters on the website.
Francisco Fernández
Software Technician
Altia
