Skip to content

Not One Order Lost

Languages and backendIntermediate

By · co-founder and Chief Executive Officer of Hábil. This is how we teach those who build systems that cannot fail.

Start with lesson 0See the lessons

Who it is for: anyone who already uses the terminal and git, reads JSON and knows basic SQL, and wants to learn systems integration. You do not need to know Java or Camel: the routes are YAML and you learn them here.

What you will know by the end: how to make sure, with your own hands, that no order is lost, that everything is traceable, that a retry does not create a duplicate and that a destination that is down does not take the others with it.

What you need before you start: terminal and git, reading JSON and basic SQL, and Docker with Compose. Of Docker, docker compose up and down are enough; the rest comes written out. It works on Linux, macOS and Windows with WSL.

The project

A made-up store sells, and every order has to reach three systems that look nothing alike: a REST API, an ERP on MariaDB and a trading partner that receives EDI X12 documents over SFTP. Everything runs on your machine with Docker. It is an open, free course on systems integration with Apache Camel.

The lessons

There are 31 lessons, from 00 to 30, all on Docker Compose, plus an optional read-only appendix. They are done in order: each one starts from what the previous one left. Start with 00, which brings up the environment.

Part 1 — Make it arrive

# Lesson
00 Environment ready
01 My first route runs
02 The order reaches the API
03 Translating the order
04 To the ERP
05 All or nothing
06 Building the EDI
07 To the partner
08 The router
09 The thread between services
10 All the channels
11 Not everything goes to everyone
12 Growing in replicas

Part 2 — Make it move forward

# Lesson
13 The shipment arrives
14 One file, several orders
15 State lives outside the process
16 The delivery arrives
17 The delivery arrived before the tracking number

Part 3 — Make it not fail

# Lesson
18 When are two messages the same one?
19 The destination does not answer
20 Accepted, rejected or unknown
21 Sent is not confirmed
22 Taking a channel down
23 Reprocessing what failed
24 Do not knock the destination down
25 Waiting for the channels
26 Following an order
27 What the audit trail must not show

Part 4 — Make it scale

# Lesson
28 One topic, one group per integration
29 Do not lose when consuming
30 Do not lose when publishing

Optional appendix

The course ends at lesson 30. The appendix takes one integration to Kubernetes and compares it on the JVM and as a native executable; it asks for a machine with more memory and disk, and says so at the start.

# Lesson
31 From lab to project, on Kubernetes
32 JVM versus native, measured

The design decisions, with their reasons, are in decisiones/.

Lessons

  1. Lesson 0 — Environment ready
  2. Lesson 1 — My first route runs
  3. Lesson 2 — The order reaches the API
  4. Lesson 3 — Translating the order
  5. Lesson 4 — The order reaches the ERP
  6. Lesson 5 — All or nothing
  7. Lesson 6 — Building the EDI
  8. Lesson 7 — To the partner
  9. Lesson 8 — The router
  10. Lesson 9 — The thread between services
  11. Lesson 10 — All the channels
  12. Lesson 11 — Not everything goes to everyone
  13. Lesson 12 — Growing in replicas
  14. Lesson 13 — The shipment arrives
  15. Lesson 14 — One file, several orders
  16. Lesson 15 — State lives outside the process
  17. Lesson 16 — The delivery arrives
  18. Lesson 17 — The delivery arrived before the tracking number
  19. Lesson 18 — When are two messages the same one?
  20. Lesson 19 — The destination does not answer
  21. Lesson 20 — Accepted, rejected or unknown
  22. Lesson 21 — Sent is not confirmed
  23. Lesson 22 — Taking a channel down
  24. Lesson 23 — Reprocessing what failed
  25. Lesson 24 — Do not knock the destination down
  26. Lesson 25 — Waiting for the channels
  27. Lesson 26 — Following an order
  28. Lesson 27 — What the audit trail must not show
  29. Lesson 28 — One topic, one group per integration
  30. Lesson 29 — Do not lose when consuming
  31. Lesson 30 — Do not lose when publishing
  32. Lesson 31 — From lab to project, on Kubernetes
  33. Lesson 32 — JVM versus native, measured