Bird
Raised Fist0
Microservicessystem_design~10 mins

Aggregates and entities in Microservices - Interactive Code Practice

Choose your learning style10 modes available

Start learning this pattern below

Jump into concepts and practice - no test required

or
Recommended
Test this pattern10 questions across easy, medium, and hard to know if this pattern is strong
Practice - 5 Tasks
Answer the questions below
1fill in blank
easy

Complete the code to define an aggregate root in a microservice.

Microservices
class Order([1]):
    def __init__(self, order_id):
        self.order_id = order_id
        self.items = []
Drag options to blanks, or click blank then click option'
AAggregateRoot
BEntity
CService
DRepository
Attempts:
3 left
💡 Hint
Common Mistakes
Using 'Entity' instead of 'AggregateRoot' causes loss of aggregate control.
Using 'Service' or 'Repository' confuses domain concepts with infrastructure.
2fill in blank
medium

Complete the code to add an entity inside an aggregate.

Microservices
class OrderItem:
    def __init__(self, product_id, quantity):
        self.product_id = product_id
        self.quantity = [1]
Drag options to blanks, or click blank then click option'
Aprice
Border_id
Cquantity
Dstatus
Attempts:
3 left
💡 Hint
Common Mistakes
Assigning 'price' or 'status' instead of 'quantity' causes incorrect data storage.
Using 'order_id' here is wrong because it's not part of the item itself.
3fill in blank
hard

Fix the error in the method that adds an entity to the aggregate.

Microservices
class Order:
    def __init__(self):
        self.items = []

    def add_item(self, item):
        if item.product_id not in [i.product_id for i in self.items]:
            self.items.[1](item)
Drag options to blanks, or click blank then click option'
Aextend
Bappend
Cinsert
Dremove
Attempts:
3 left
💡 Hint
Common Mistakes
Using 'extend' causes an error because it expects an iterable.
Using 'remove' deletes items instead of adding.
4fill in blank
hard

Fill both blanks to correctly check entity existence and update quantity.

Microservices
def update_item_quantity(self, product_id, quantity):
    for item in self.items:
        if item.[1] == product_id:
            item.[2] = quantity
            return True
    return False
Drag options to blanks, or click blank then click option'
Aproduct_id
Bquantity
Cstatus
Dorder_id
Attempts:
3 left
💡 Hint
Common Mistakes
Using 'status' or 'order_id' causes wrong attribute access.
Mixing up the attributes leads to logic errors.
5fill in blank
hard

Fill all three blanks to create a dictionary of product IDs and quantities from entities.

Microservices
def get_items_summary(self):
    return {item.[1]: item.[2] for item in self.items if item.[3] > 0}
Drag options to blanks, or click blank then click option'
Aproduct_id
Bquantity
Dstatus
Attempts:
3 left
💡 Hint
Common Mistakes
Using 'status' instead of 'quantity' breaks the filter logic.
Mixing keys and values causes incorrect dictionary structure.

Practice

(1/5)
1. In microservices, what is the main role of an aggregate root entity?
easy
A. It acts as a database for all microservices.
B. It stores unrelated data from different services.
C. It handles user interface rendering.
D. It controls all changes within the aggregate to keep data consistent.

Solution

  1. Step 1: Understand aggregate root responsibility

    The aggregate root is the main entity that manages all changes inside its aggregate to ensure consistency.
  2. Step 2: Eliminate unrelated options

    Options A, B, and D describe roles unrelated to aggregate roots in microservices.
  3. Final Answer:

    It controls all changes within the aggregate to keep data consistent. -> Option D
  4. Quick Check:

    Aggregate root controls changes = C [OK]
Hint: Aggregate root manages changes inside its group [OK]
Common Mistakes:
  • Confusing aggregate root with database or UI component
  • Thinking aggregate root stores unrelated data
  • Assuming aggregate root handles external service data
2. Which of the following correctly represents an aggregate in a microservice domain model?
easy
A. Order (root) -> OrderItems (entities) -> PaymentDetails (entity)
B. OrderItems (root) -> Order -> PaymentDetails
C. PaymentDetails (root) -> Order -> OrderItems
D. Order -> PaymentDetails -> OrderItems (all roots)

Solution

  1. Step 1: Identify the aggregate root

    In an order system, the Order is the root entity controlling related entities like OrderItems and PaymentDetails.
  2. Step 2: Check the hierarchy correctness

    Order (root) -> OrderItems (entities) -> PaymentDetails (entity) shows Order as root with related entities under it, which is correct. Other options misplace roots or treat all as roots.
  3. Final Answer:

    Order (root) -> OrderItems (entities) -> PaymentDetails (entity) -> Option A
  4. Quick Check:

    Root entity is Order controlling others = A [OK]
Hint: Root entity leads related entities in aggregate [OK]
Common Mistakes:
  • Assigning wrong entity as root
  • Treating all entities as roots
  • Ignoring aggregate boundaries
3. Given the aggregate root Customer with entities Address and Order, which operation should only be performed through Customer?
medium
A. Deleting Order independently from Customer
B. Directly updating an Order without Customer involvement
C. Adding a new Address via the Customer aggregate root
D. Querying Order data directly from the database

Solution

  1. Step 1: Understand aggregate root control

    The aggregate root Customer controls all changes to its entities like Address and Order to maintain consistency.
  2. Step 2: Identify allowed operations

    Adding a new Address should go through Customer. Direct updates or deletes bypassing root break consistency.
  3. Final Answer:

    Adding a new Address via the Customer aggregate root -> Option C
  4. Quick Check:

    Changes go through root entity = A [OK]
Hint: All changes pass through aggregate root only [OK]
Common Mistakes:
  • Updating entities directly without root
  • Deleting entities independently
  • Confusing querying with updating
4. You have a microservice with an aggregate root Invoice and entities LineItem. The code allows direct modification of LineItem without Invoice. What is the main problem?
medium
A. Performance will improve due to direct access.
B. Data consistency may break because changes bypass the aggregate root.
C. It will reduce network calls between services.
D. It simplifies the codebase without side effects.

Solution

  1. Step 1: Identify aggregate root role in consistency

    The aggregate root Invoice ensures all changes to LineItem are consistent and valid.
  2. Step 2: Analyze direct modification impact

    Directly modifying LineItem bypasses Invoice, risking inconsistent or invalid data.
  3. Final Answer:

    Data consistency may break because changes bypass the aggregate root. -> Option B
  4. Quick Check:

    Bypassing root risks consistency = B [OK]
Hint: Bypass root risks data consistency [OK]
Common Mistakes:
  • Assuming direct access improves design
  • Ignoring consistency importance
  • Confusing performance with correctness
5. You design a microservice for a shopping cart system. The cart is an aggregate root with entities like CartItem and Discount. Which design choice best ensures data consistency and scalability?
hard
A. Make Cart the aggregate root controlling all CartItem and Discount changes.
B. Use a single database table for Cart, CartItem, and Discount without aggregates.
C. Store CartItem and Discount in separate microservices with no coordination.
D. Allow CartItem and Discount to be updated independently without Cart involvement.

Solution

  1. Step 1: Apply aggregate root principle for consistency

    Cart as aggregate root should control all changes to CartItem and Discount to keep data consistent.
  2. Step 2: Consider scalability and design best practices

    Centralizing changes through Cart allows easier management and scaling of the microservice without data conflicts.
  3. Step 3: Evaluate other options

    Options A and C risk inconsistency; B ignores aggregate design and can cause complexity.
  4. Final Answer:

    Make Cart the aggregate root controlling all CartItem and Discount changes. -> Option A
  5. Quick Check:

    Aggregate root controls changes for consistency and scale = D [OK]
Hint: Aggregate root controls related entities for consistency and scale [OK]
Common Mistakes:
  • Allowing independent updates breaking consistency
  • Splitting tightly coupled entities into separate services
  • Ignoring aggregate design principles