Following One Order
A gradual route through Mule flows, a working order API, recovery and Anypoint Platform.
MuleSoft from the Ground Up
Learn Mule one step at a time: a greeting, the event, small transformations and tests, then a complete order API, recovery and platform operations. Thirty focused chapters and four optional appendices connect named examples to runnable companion checkpoints.
Download as an EPUB 35 chapters — read offline on any e-reader
-
-
Hello Mule, One Request at a Time
Run a complete first Mule application, change its greeting and diagnose the first connection or deployment failure.
-
What Is in This Request?
Inspect payload and HTTP attributes, follow a selector and trace a payload replacement.
-
Build One Response
Construct a JSON object, follow nested selectors and calculate a single line before working with arrays.
-
One Line, Then Every Line
Introduce arrays and callbacks through line totals, then calculate a complete order summary.
-
Keep a Value, Name a Calculation
Retain event context, extract a subflow and compare ordinary and targeted Flow Reference calls.
-
Make the Result a Test
Write complete MUnit tests for a greeting and an order calculation before introducing dependency mocks.
-
Decide Which Requests Belong
Define a small HTTP contract, teach Boolean predicates and Choice, and reject invalid quantities before side effects.
-
Where a Failure Goes
Raise typed errors, share a public handler and trace Continue and Propagate through their owning scopes.
-
Call a Service You Can Control
Load connection properties, start a supplied customer service and inspect an HTTP Request result.
-
Keep the Order While Looking Things Up
Use HTTP targets, explicit optional fallbacks and target-aware MUnit mocks to preserve an order during enrichment.
-
Save It, Then Read It Back
Configure JDBC, bind SQL parameters, inspect insert results and query independently stored state.
-
Find the Transaction Owner
Observe rollback and commit with independent queries, then distinguish database participation from external side effects.
-
Give the Contract a Working Route
Describe a small order command with RAML, map it through APIkit and test malformed requests before persistence.
-
One Request Becomes a Stored Order
Assemble validation, catalogue pricing, persistence and retrieval into the first complete local order API.
-
Read and Write Order Files
Serialize deliberately, locate the filesystem boundary and normalize a small CSV input before processing it.
-
Process a Small Import
Trace For Each, record per-item outcomes and trigger the same bounded work with a Scheduler.
-
Run Independent Work in Parallel
Read Scatter-Gather and Parallel For Each results, handle composite failure and account for dependency capacity.
-
Repeat a Request Safely
Separate retry from business identity and implement concurrent, transactional command acceptance with recorded results.
-
Publish What the Database Committed
Implement an outbox and one-owner dispatcher, then recover from a receiver commit followed by a lost acknowledgement.
-
Give Unfinished Work an Owner
Compare Async, a transient VM queue and an account-dependent MQ consumer with explicit acknowledgement ownership.
-
Track Each Record in an Import
Run a bounded Batch Job with implemented success and rejection adapters, then reason about bulk outcomes and replay.
-
Cache an Answer Without Mixing Callers
Verify tenant-specific cache reuse and invalidation, then distinguish disposable state from business ledgers.
-
Know Who May Read the Order
Separate trusted caller identity, tenant ownership, server TLS and secret delivery, with explicit local and platform boundaries.
-
Govern the Entry to the Service
Associate API Manager with the real entry flow and test identity, quotas, resource selection and policy changes.
-
Move the Service to CloudHub
Prepare external persistence, trusted caller context and complete configuration before promoting an orders candidate.
-
Investigate an Unfinished Order
Connect honest transition logs with durable order, outbox and receiver state, then define useful operational measures.
-
Release the Bytes You Tested
Run a concrete validation workflow, require useful reports and retain an artifact identity through promotion and rollback.
-
Decide Where an API Boundary Belongs
Use the completed service to reason about ownership, System/Process/Experience responsibilities and the cost of another call.
-
Put a Gateway in the Request Path
Follow one Local Mode Omni route to the existing API and distinguish configuration ownership, policy behavior and upstream failure.
-
Demonstrate Acceptance and Recovery
Run the assembled order service through repeats, races, rollback, ownership and interrupted publication without introducing new mechanisms.
-
Appendix A: Setup, Versions and Evidence
Reproduce the local checkpoints, understand the build workaround and distinguish new runs from historical and account-dependent evidence.
-
Appendix B: Representation and Contract Workshops
Extend known boundaries with complete XML/module/message workshops and clearly separated historical runtime-format probes.
-
Appendix C: XA and Standalone Domains
Preserve the participation, recovery and shared-resource distinctions without expanding the local transaction promise.
-
Appendix D: Synchronization and Platform Variants
Keep SFTP completion, ordered watermarks, token refresh, managed state and Connected Mode governance as independent workshops.