Beyond REST and CRUD - Integration patterns in Microservices

The flow of information and events through distributed systems goes well beyond HTTP, REST, and JSON. In this tech talk, we’ll use Apache Camel to explore integration patterns that add flexibility and resilience to your evolving architecture.

Transcript

1. Beyond REST and CRUD Integration patterns in Microservices ➕ Erin Schnabel, Red Hat ・ ・ Zineb Bendhiba, Red Hat ・ ・ github.com/ebullient www.ebullient.dev github.com/zbendhiba zinebbendhiba.com 1
2. Essential factors Autonomous Portable Disposable 2
3. Essential factors Autonomous Portable Disposable Independent 2
4. How do we adapt? Applications must evolve 3
5. How do we adapt? Applications must evolve Rarely ever a clean slate 3
6. How do we adapt? Applications must evolve Rarely ever a clean slate Decouple elements of the system 3
7. Systems Integration Different perspective 4
8. Systems Integration Different perspective Message Routing 4
9. Enterprise patterns Emergent "Design patterns" Best practices 5
10. Apache Camel Integration framework Anything to anything Fit for purpose: ... use what you need 6
11. Concise Application Messaging Exchange Language 7
12. Term Meaning Message data transferred by a route Exchange envelope; wraps the data Endpoint a channel; receiver or sender Component know-how; creates endpoints Processor Java API; custom logic Camel message routing... 8
13. Pockets Inventory management Command-line local-only Web UI 9
14. Pockets: The plan 10
15. Pockets: The plan 10
16. Pockets: The plan 10
17. Pockets: The plan 10
18. Pockets: The plan 10
19. Pockets: The plan 10
20. Pockets: The plan 10
21. Pockets: The plan 10
22. Pockets: The plan 10
23. REST and REST... @Path("/pockets") public class TheoreticalPockets { @GET public Response getProfiles() { // fetch some stuff } @GET @Path("{profile}") public Response getProfile(@PathParam("profile") String id) { // fetch specific stuff } @POST @Path("{profile}") public Response updateProfile(@PathParam("profile") String id, ...) { // do important things } } 11
24. REST and REST... REST component adds support for REST semantics, including a DSL. 12
25. Flow of data with Camel Route: REST rest("/pockets") .post("/{profile}") .to("direct:validateAndModifyPockets"); // <--- HERE 1 .get() 2 .to("direct:getProfiles") 3 4 .get("/{profile}") 5 .to("direct:getProfile") 6 7 8 9 13
26. Flow of data with Camel Route: REST 13
27. Flow of data with Camel Route: REST 13
28. Flow of data with Camel Route: REST 13
29. Flow of data with Camel Route: REST @Transactional public void validateProfile(Exchange exchange) { Message message = exchange.getMessage(); String profile = (String) message.getHeader(profileKey); profile = ProfileContext.validateProfile(profile); message.setHeader(profileKey, profile); 1 2 final String profileKey = "profile"; 3 4 5 6 7 // Update header with full name, may throw 8 9 10 11 } 12 13
30. Flow of data with Camel Route: REST 13
31. Flow of data with Camel Route: REST .bean(webRouteHandler, "doModification(`${body}, $`{header.profile})") @Transactional public ModificationResponse doModification( ModificationRequest modificationRequest, String profileName) { profileContext.setActiveProfile(profileName); return modifyPockets.modifyPockets(modificationRequest); 1 2 ~~~~~~ 3 4 5 6 7 8 9 10 11 12 } 13 13
32. Flow of data with Camel Route: REST 13
33. Flow of data with Camel Route: CLI @ActivateRequestContext @Transactional String activeProfile = activeProfileMixin.findActiveProfileId(); profileContext.setActiveProfile(activeProfile); return delegateCall(); // delegate to sub-command @Override 1 2 3 public final Integer call() { 4 try { 5 // Validate specified profile 6 7 8 if (activeProfile == null) { 9 return ExitCode.USAGE; 10 } 11 12 13 if (showTypes) { 14 showTypes(); 15 return ExitCode.OK; 16 } 17 18 19 } catch (...) { 20 ... 21 } 22 } 23 14
34. Flow of data with Camel Route: CLI public Integer delegateCall() { Modification modification = createModification(); ModificationRequest req = createModificationRequest( "Create " + modification.itemDetails.name) ModificationResponse response = modifyPocketRoute.modifyPockets(req); @Override 1 2 3 4 5 6 7 .add(modification); 8 9 // Make the modification 10 11 12 response.changes.stream().filter(c -> c.type == PostingType.CREATE) 13 .forEach(c -> { 14 ... 15 }); 16 17 return ExitCode.OK; 18 } 19 15
35. Flow of data with Camel Route: CLI // Make the modification ModificationResponse response = modifyPocketRoute.modifyPockets(req); public interface CliModifyPocket { ModificationResponse modifyPockets(ModificationRequest request); } @Produce("direct:modifyPockets") CliModifyPocket modifyPocketRoute; 1 2 3 ~~~~ 4 5 6 7 8 9 10 11 16
36. from("direct:modifyPockets") .to("log:dev.ebullient.pockets?level=DEBUG") .bean(modifyPockets, "modifyPockets(${body})") .process((e) -> emitHandler.setProfile(e)) .wireTap("direct:emitRoute") .to("log:dev.ebullient.pockets?level=DEBUG"); 1 .errorHandler(noErrorHandler()) 2 3 4 5 6 7 8 9 10 11 12 Flow of data with Camel Route: CLI 17
37. from("direct:modifyPockets") .to("log:dev.ebullient.pockets?level=DEBUG") .bean(modifyPockets, "modifyPockets(${body})") .process((e) -> emitHandler.setProfile(e)) .wireTap("direct:emitRoute") .to("log:dev.ebullient.pockets?level=DEBUG"); 1 .errorHandler(noErrorHandler()) 2 3 4 5 6 7 8 9 10 11 12 Flow of data with Camel Route: CLI 17
38. from("direct:modifyPockets") .to("log:dev.ebullient.pockets?level=DEBUG") .bean(modifyPockets, "modifyPockets(${body})") .process((e) -> emitHandler.setProfile(e)) .wireTap("direct:emitRoute") .to("log:dev.ebullient.pockets?level=DEBUG"); 1 .errorHandler(noErrorHandler()) 2 3 4 5 6 7 8 9 10 11 12 Flow of data with Camel Route: CLI 17
39. from("direct:modifyPockets") .to("log:dev.ebullient.pockets?level=DEBUG") .bean(modifyPockets, "modifyPockets(${body})") .process((e) -> emitHandler.setProfile(e)) .wireTap("direct:emitRoute") .to("log:dev.ebullient.pockets?level=DEBUG"); 1 .errorHandler(noErrorHandler()) 2 3 4 5 6 7 8 9 10 11 12 Flow of data with Camel Route: CLI 17
40. from("direct:modifyPockets") .to("log:dev.ebullient.pockets?level=DEBUG") .bean(modifyPockets, "modifyPockets(${body})") .process((e) -> emitHandler.setProfile(e)) .wireTap("direct:emitRoute") .to("log:dev.ebullient.pockets?level=DEBUG"); 1 .errorHandler(noErrorHandler()) 2 3 4 5 6 7 8 9 10 11 12 Flow of data with Camel Route: CLI public void setProfile(Exchange e) { ModificationResponse resp = msg.getBody(ModificationResponse.class); msg.setHeader("profile", resp.profileName); 1 Message msg = e.getMessage(); 2 3 4 5 6 } 7 17
41. from("direct:modifyPockets") .to("log:dev.ebullient.pockets?level=DEBUG") .bean(modifyPockets, "modifyPockets(${body})") .process((e) -> emitHandler.setProfile(e)) .wireTap("direct:emitRoute") .to("log:dev.ebullient.pockets?level=DEBUG"); 1 .errorHandler(noErrorHandler()) 2 3 4 5 6 7 8 9 10 11 12 Flow of data with Camel Route: CLI 17
42. Common path: WireTap What does this do? .wireTap("direct:emitRoute") 18
43. Common path: WireTap What does this do? .wireTap("direct:emitRoute") It kicks off a new route to transform content 18
44. Common path: WireTap What does this do? .wireTap("direct:emitRoute") It kicks off a new route to transform content from("direct:emitRoute") .bean(emitHandler, "emitRoute") 1 .to("log:dev.ebullient.pockets?level=DEBUG") 2 3 .recipientList(header("routes")) 4 .parallelProcessing(); 5 18
45. Common path: Recipient List public void emitRoute(Exchange exchange) { String profileName = msg.getHeader("profile", "default", String.class); List<String> emitters = new ArrayList<>(); if (localPocketsConfig.jsonEventLogEnabled(profileName)) { emitters.add("direct:jsonEmitter"); if (localPocketsConfig.markdownEnabled(profileName)) { emitters.add("direct:markdownEmitter"); msg.setHeader("routes", String.join(",", emitters)); @SuppressWarnings("unused") 1 2 Message msg = exchange.getMessage(); 3 4 5 6 7 EventLogConfiguration eventLogConfig = 8 localPocketsConfig.eventLogConfig(profileName); 9 msg.setHeader("jsonEventLogDirectory", 10 eventLogConfig.getDirectory().toString()); 11 12 } 13 14 15 } 16 17 } 18 19
46. Common path: Recipient List .recipientList(header("routes")) .parallelProcessing(); from("direct:emitRoute") 1 .to("log:dev.ebullient.pockets?level=DEBUG") 2 .bean(emitHandler, "emitRoute") 3 4 5 20
47. Common path: direct:jsonEmitter from("direct:jsonEmitter") .setHeader(FileConstants.FILE_NAME, simple("${header.profile}.events.jsonl")) .setBody((e) -> Transform.toJsonString(e.getMessage().getBody())) .toD("file:${header.jsonEventLogDirectory}?" + "fileExist=Append&appendChars=\n&allowNullBody=true") 1 .onException(InvalidPocketState.class) 2 .handled(true) 3 .process(new HandleInvalidPocketState()) 4 .end() 5 6 7 8 9 10 11 12 13 14 .to("log:dev.ebullient.pockets?level=DEBUG"); 15 21
48. Common path: Markdown emitter 22
49. Common path: Qute templates from("direct:markdownFile") .to("qute:dummy?allowTemplateFromHeader=true") .toD("file:${header.markdownDirectory}?" + "fileExist=Override&allowNullBody=true") 1 .onException(InvalidPocketState.class) 2 .handled(true) 3 .process(new EmitRouteHandler.HandleInvalidPocketState()) 4 .end() 5 6 7 8 9 10 11 .to("log:dev.ebullient.pockets?level=DEBUG"); 12 23
50. ➡ 24
51. Summary Apache Camel can help fill in the gaps Use it alongside your favorite messaging solution (Kafka or traditional message brokers) 25
52. Summary Apache Camel can help fill in the gaps Use it alongside your favorite messaging solution (Kafka or traditional message brokers) It applies to patterns far beyond REST and CRUD 25
53. Summary Apache Camel can help fill in the gaps Use it alongside your favorite messaging solution (Kafka or traditional message brokers) It applies to patterns far beyond REST and CRUD Use it with your favorite Java framework 25
54. Summary Apache Camel can help fill in the gaps Use it alongside your favorite messaging solution (Kafka or traditional message brokers) It applies to patterns far beyond REST and CRUD Use it with your favorite Java framework Use it with JBang for script nonsense 25
55. Summary Apache Camel can help fill in the gaps Use it alongside your favorite messaging solution (Kafka or traditional message brokers) It applies to patterns far beyond REST and CRUD Use it with your favorite Java framework Use it with JBang for script nonsense Use it with Kubernetes to make the best glue (Camel-K, Kamelets) 25
56. ➕ ~fin~ 26