Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/2O7BN8T. Michael Bryzek highlights specific key decisions that very directly impact the quality and maintainability of a microservice architecture, covering infrastructure, continuous deployment, communication, event streaming, language choice and more, all to ensure that teams and systems remain productive and scale. Filmed at qconnewyork.com. Michael Bryzek is the CTO and co-founder of Flow Commerce, an enterprise SAAS platform that is the world’s most advanced solution for global ecommerce. Prior, he was the cofounder and CTO of Gilt Groupe, an innovative online shopping destination offering.

1. Design Micro Service
Architectures the
Right Way
Michael Bryzek
mike@flow.io / @mbryzek
Cofounder / CTO Flow
Cofounder / ex-CTO Gilt

2. InfoQ.com: News & Community Site
• 750,000 unique visitors/month
• Published in 4 languages (English, Chinese, Japanese and Brazilian
Portuguese)
• Post content from our QCon conferences
• News 15-20 / week
• Articles 3-4 / week
• Presentations (videos) 12-15 / week
• Interviews 2-3 / week
• Books 1 / month
Watch the video with slide
synchronization on InfoQ.com!
https://www.infoq.com/presentations/
microservices-arch-infrastructure-cd

3. Presented at QCon New York
www.qconnewyork.com
Purpose of QCon
- to empower software development by facilitating the spread of
knowledge and innovation
Strategy
- practitioner-driven conference designed for YOU: influencers of
change and innovation in your teams
- speakers and topics driving the evolution and innovation
- connecting and catalyzing the influencers and innovators
Highlights
- attended by more than 12,000 delegates since 2007
- held in 9 cities worldwide

4. A personal story
Could you change this URL from
https://foo.com/latest/bar.js to
https://foo.com/1.5.3/ bar.js ?
è Sorry – that would take weeks; we don’t have the resources to do that.

5. https://www.pinterest.com/pin/262264378280617506/
It’s just a friggin URL!!!

6. How does this happen?
• URL in a library
• 100s of services to update
• Some not touched in years,
requiring dependency updates
https://www.pinterest.com/pin/262264378280617506/

7. Great Architecture
Scales Development Teams
Delivers Quality
Enables High Performance / Low Cost
Supports Future Features Naturally

8. Not So Great Architecture
Tradeoffs:
http://ziogeek.com/wp-content/uploads/2013/07/spaghetti.jpg
Near term velocity
Future Paralysis

9. Design Micro Service Architectures the Right Way

10. About Me
www.flow.io
www.gilt.com

11. Let’s Start
With a few
Misconceptions

12. Misconception #1
Micro Services enable our teams to choose the best
programming languages and frameworks for their tasks
Reality:
We’ll demonstrate just how expensive this is.
Team size and investment are critical inputs.

13. Misconception #2
Code Generation is Evil
Reality:
What’s important is creating a defined
schema that is 100% trusted.
We’ll demonstrate one technique leveraging code generation

14. Misconception #3
The Event Log Must be the Source of Truth
Reality:
Events are critical parts of an interface.
But it’s okay for services to be the
system of record for their resources.

15. Misconception #4
Developers can maintain no more than 3 services each
Reality:
Wrong metric; we’ll demonstrate where automation shines.
Flow developers today each maintain ~5 services
Weekly maintenance <5% of time

16. Flow Commerce Architecture
Flow Platform ArchitectureExternalDataProviders
(e.g.,FX,IPGeo,IIN/BIN,etc.)
Catalog Payment Inventory Orders
100+
services
Event Bus (Kinesis)
Lambda Architecture / Data Mart
API Proxy
OMS
3PL / WMS,
Etc.
Ecommerce
Platform
Retail
Website
FLOW APIs
Flow.js
Flow Console Track.flow.io
Microservices
Integration Methods &
Services
Client Platform
Fulfillment
Shopify Magento
SFCC Solidus
Plugins & Cartridges
Direct Integrations
Checkout UI
Flow System
Client System
3rd Party Data
Data Flow
Key
FTP Webhook
Kinesis
Partner
API
Amazon Web Services
Client
Checkout

17. API Definition
Done correctly, even things like
GDPR compliance can be modeled

18. Resource Oriented

19. Definitions in Git, with Continuous Integration

20. Tests Enforce Consistency
Goal: It should feel like one person wrote the entire API

21. Tests Prevent Errors
https://app.apibuilder.io/history?org=flow&app=api
Verify potentially breaking changes
during API Design Phase

22. API Implementation Supported by Code Generation

23. Code Generation: Routes
Guarantee that API operations are actually defined
User friendly paths
Consistent naming for methods

24. Code Generation: Client

25. Code Generation: Mock Client
Mock and Client from Same Source
Enables High Fidelity, Fast Testing

26. Code Generation: Clients
The system of record IS the API specification
Code generation ensures that we actually adhere to the spec
Provide many common languages for our users
[https://app.apibuilder.io/generators/]

27. Now Let’s Implement
Goal: Code we actually write is simple, consistent

28. Database Architecture
Each micro service application owns its database
No other service is allowed to connect to the database
Other services use only the service interface (API + Events)

29. Create a Database
CLI as single interface for infra and
common development tasks

30. Define storage requirements in metadata
Describe ”scala” requirements
Describe “psql” requirements
Code generate the table definition
Code generate the Data Access Object
Note data tier independent from API,
Just uses same toolchain

31. Code generation: Create a Table
Consistent checks, metadata
Enable global features like ‘hash_code’ to minimize writes

32. Code generation: Scala Class
Normalize access to DB
Ensure proper indexes exist from start

33. Automated Tests
Use the generated mock client

34. Test Resource Operations
Use the generated mock clients to write simple tests

35. Time to Deploy

36. Continuous Delivery
“Continuous Delivery is a
prerequisite to managing micro
service architectures”
--@mbryzek

37. Continuous Delivery
Deploy triggered by a git tag
Git tags created automatically by a change on master (e.g. merge PR)
100% automated, 100% reliable

38. Continuous Delivery is Critical
https://github.com/flowcommerce/delta

39. Auto Deploy on New Commit on Master

40. Microservice Infrastructure – keep it simple

41. Standard Health Checks

42. Events

43. “We have an amazing API, but
please subscribe to our event
streams instead.”

44. Principles of an Event Interface
First class schema for all events
Producers guarantee at least once delivery
Consumers implement idempotency
Flow:
- End to end single event latency ~ 500 ms
- Based on postgresql – scaled to ~1B events / day / service

45. Events: Approach
Producers:
• Create a journal of ALL operations on table
• Record operation (insert, update, delete)
• On creation, queue the journal record to be published
• Real time, async, we publish 1 event per journal record
• Enable replay by simply requeuing journal record

46. Events: Approach
Consumers:
• Store new events in local database, partitioned for fast removal
• On event arrival, queue record to be consumed
• Process incoming events in micro batches (by default every 250ms)
• Record failures locally

47. Events: Schema First
1 model / event
N events in one union type
1 union type / stream
Stream owned by 1 service
Most services define exactly 1 stream

48. Events: Schema Linter

49. Producers: Database Journal
Document retention period
Code generate journal
Use partitions to manage storage
https://github.com/gilt/db-journaling

50. Producers: Streams
Reflection used to generate stream name
io.flow.v0.user_event.json

51. Producing an Event
Note the UserVersion class which is
also code generated.
Guarantees that all code in all
services looks the same.

52. Producers: Testing

53. Consumers: Processing Incoming Events

54. Consumers: Testing
Factories classes generated from the API Spec

55. Dependencies
Keeping things up to date

56. Dependencies
Goal: Automatically update all services to latest dependencies
• Critical for security patches / bug fixes in core libraries
• Takes hours (not weeks or months)
• Same process for internally developed libraries and open source
• Flow: we upgrade all services every week to latest dependencies

57. Dependencies: Tracking
https://dependency.flow.io/
https://github.com/flowcommerce/dependency

58. Dependencies: Updating

59. Dependencies & Continuous Delivery
Deploy Once the Build Passes

60. Summary: Critical Decisions
Design schema first for all APIs and Events
– consume events (not API) by default
Invest in automation
– deployment, code generation, dependency management
Enable teams to write amazing and simple tests
– drives quality, streamlines maintenance, enables continuous delivery

61. Thank You!
Go forth and Design Micro Service Architectures the Right Way
Michael Bryzek
mike@flow.io / @mbryzek
Cofounder / CTO Flow
Cofounder / ex-CTO Gilt
We’re hiring: https://www.flow.io/careers

62. Watch the video with slide
synchronization on InfoQ.com!
https://www.infoq.com/presentations/
microservices-arch-infrastructure-cd