Monday , May 20 2024

Reactive Architecture: Reactive Microservices

Course Name :- Reactive Architecture: Reactive Microservices

Chapter Name :-The Software Spectrum

Question 1  : True or False: When building software you have to choose between building a monolith or building microservices. There is no in between.

  • True
  • False

Question 2: When deciding whether to build a system as a monolith or microservices we need to:

  • Remember that the size of the microservices is critical. All microservices should be less than 10 thousand lines of code.
  • Determine what kind of database will be backing our services. Relational is for Monoliths, NoSQL is for Microservices.
  • Realize that microservices are the future. Monoliths are archaic, and nobody is building them anymore.
  • Consider the benefits, and consequences of each, and try to find an appropriate balance between them.

Question 3  : How big is a microservices?

  • Small enough run in 256 Mb of ram.
  • No bigger than a single function.
  • Less than 10 thousand lines of code.
  • All of the above.
  • None of the above.

Question 4 : True or False: A single system can have some characteristics of a Monolith and other characteristics of Microservices.

  • False
  • True

Chapter name:- Monoliths

Question 1 : True or False: The term “ball of mud” is applicable to all monoliths. They are, by their very nature, a huge mess that is difficult to sort through and understand.

  • True
  • False

Question 2 : Another name for a “Ball of Mud” is :-

  • Bean Bag
  • Sludge Blossom
  • Lisp
  • Spaghetti Code

Question 3 : True or False: The ball of mud style of architecture suffers from too much isolation between components. As a result, over time the system becomes more disconnected, and harder to modify.

  • True
  • False

Question 4 : To clean up our monolith so that it looks less like a ball of mud, we could do which of the following:-

  • Ensure that every method, and class, has appropriate descriptive comments.
  • Capture our business logic in a rules engine.
  • Leverage Data Driven Design to isolate our behavior in configuration, instead of code.
  • Introduce domain boundaries in the form of libraries or packages.

Question 5 : Which of the following are characteristics of a monolith?

  • Single Shared Database
  • Teams operate independently
  • Communicate using Asynchronous Method Calls
  • Deep Coupling
  • Deployed as a single unit

Question 6 : A monolithic application is scaled using which of the following techniques?

  • Multiple copies of the monolith are deployed in a ring. These monoliths communicate with each other using a chatter protocol to ensure consistent state.
  • The monolith is broken into separate systems, each of which is deployed independently.
  • A single “master” instance is deployed along with several “slaves”. This allows the load to be distributed between the slaves.
  • Multiple copies of the monolith are deployed, relying on the database to maintain consistency between them.

Question 7 : True or False: Communication between instances of a monolith typically happens through the database.

  • True
  • False

Question 8 : What are some of the advantages of using a monolith?

  • Simple consistency model
  • Single deployment process
  • Nothing to monitor
  • Flexible scalability model
  • Strong coupling
  • Easy cross module refactoring

Question 9 : True or False: Failures in a monolith are isolated only to that instance of the monolith. We don’t have to worry that the failure may affect other instances.

  • True
  • False

Question 10 : What are some of the disadvantages of using a monolith?

  • Limited to Relational Databases
  • Weak consistency guarantees
  • Limited by the scalability of the database
  • Inflexibility due to deep coupling
  • Limited by the size of a single machine

Case study :  The Monolithic BBQ

Question 1 : If we were to make a change to the database table for Orders, which of the following models would we potentially need to edit? Note: Make sure you select all of the correct options—there may be more than one!

  • Delivery Model
  • Order Model
  • Customer Model

Question 2 :  The most likely cause of these issues is:-

  • Coincidence.
  • Poor cellular reception.
  • The reports are flooding the network with too much data.
  • Resource contention on the Orders tables in the database.

Question 3 : Why were the delivery drivers impacted by a change in the reservation data?

  • The Delivery Model wasn’t built to support the new field so it was unable to query the Customer table.
  • The database script put pressure on the CPU which slowed down the delivery system.
  • The system experienced a long GC pause which prevented the mobile application from reaching the server.
  • The Delivery Model relies on the Customer table so it was affected by the table lock.

Question 4 : We could mitigate this problem by:-

  • Deploying the Order service to it’s own hardware.
  • Deploying more copies of our application.
  • Deploying another replica of our database.
  • Upgrading the hardware on the database server (more CPU, more memory, faster disk).

Question 5 : Possible solutions to the memory problem are:-

  • Delete the other caches.
  • Deploy additional copies of the order service.
  • Move the orders service to it’s own hardware.
  • Increase the available memory on the machine.

Chapter Name :-Microservices

Module 1 :- Service Oriented Architecture Review.

Question 1 : True or False: A key principle of Service Oriented Architecture is that Services don’t share a database.

  • True
  • False

Question 2 : In a Service Oriented Architecture, if one service needs access to the data from another service, it can:-

  • Do nothing. SOA services don’t share data.
  • Read the data from the database table directly.
  • Read the data from the database indirectly via a database view.
  • Request the data by making an API call to the service that owns the data.

Question 3 : Which of the following are true for Service Oriented Architecture?

  • Services must live on the same physical (or virtual) machine.
  • Services may be deployed as a single unit (Monolith).
  • Services may be deployed independently (Microservices).
  • Services may share a database, as long as they never write to each other’s tables (Read is okay).
  • Service endpoints must be implemented with HTTP protocols.

Question 4 : We can characterize the relationship between Service Oriented Architecture and Microservices by saying:-

  • Service Oriented Architecture is a subset of Microservices. Some microservices systems are built using SOA.
  • Microservices and Service Oriented Architecture are different names for the same concept.
  • Microservices and Service Oriented Architecture are unrelated to each other.
  • Microservices are a subset of Service Oriented Architecture. Some SOA systems are built using microservices.

Module 2 :- Microservices Review.

Question 1 : True or False: Microservices should all be run in their own process (eg. JVM). As long as they are running in an independent process, a suitable way to deploy them would be to package them all into a single container so there is only one thing to deploy.

  • True
  • False

Question 2 : Microservices share which of the following characteristics with Service Oriented Architecture.

  • Services own their data, and don’t share a database.
  • Services are independently deployed.
  • Services communicate with each other through a clear API.
  • Individual services are packaged into a container and deployed as a group.
  • Services are separated along logical domain boundaries.
  • Services are independent and self governing.

Question 3 : Some of the characteristics of a microservices architecture include:-

  • Loose Coupling
  • Multiple, independent databases
  • Tightly coordinated release process
  • Strictly asynchronous communication
  • Rapid Deployments
  • Services are deployed independently

Question 4 : True or False: Systems built on Microservices never share code.

  • True
  • False

Question 5 : A DevOps approach means:-

  • Teams are split into Dev, Ops, and DevOps. Dev creates the application. Ops deploys the application. DevOps maintains it in production.
  • Teams are split into Dev and Ops. Dev creates the application. Ops deploys it and maintains it in production.
  • One DevOps team is responsible for creating the application, deploying it, and maintaining it in production.
  • Teams are split into Dev and Ops. Dev creates the application and packages it into a docker container. Ops deploys the docker container. The Dev team is then laid off as they are no longer needed.

Question 6 : Which of the following techniques are used to scale a system of microservices?

  • Microservices are divided into frontend and backend services. Frontend is scaled separately from backend.
  • Microservices are bundled together and then scaled as a group.
  • Microservices are small and lightweight and therefore don’t need to be scaled.
  • Each Microservice is scaled independently.

Question 7 : True or False: In a microservice system, each physical (or virtual) machine will host at least one copy of every microservice.

  • True
  • False

Question 8 : Which of the following are advantages to a microservice based system?

  • Individual services can be scaled as needed.
  • Easy cross module refactoring.
  • Fits well with existing organizational behaviors.
  • Failures are isolated to a single service.
  • Increases cross team coordination.

Question 9 : True or False: Microservices approaches often require organizational change to be successful.



Question 10 : Which of the following are disadvantages to a microservice based system?

  • May require multiple deployment processes.
  • Increased coupling reduces flexibility.
  • Cross module refactoring is challenging.
  • Requires supporting older API versions.
  • The organization may not be ready (or willing) to change.

Question 11 : True or False: When introducing microservices to your organization, the best way to overcome the shock is to introduce everything at the same time. That way the organization views it as a single change, rather than a bunch of changes, and they will be more likely to adopt it.

  • True
  • False

Module 3 :- Responsibilities of Microservices Review.

Question 1 : The original Single Responsibility Principle, from Robert C. Martin states:

  • A microservice should have only one reason to change.
  • A microservice is responsible for it’s own behaviour, not the behaviour of other services.
  • A microservice should be responsible for it’s own failures, rather than forcing them on the client.
  • A class should have only one reason to change.

Question 2 : Part of following the Single Responsibility Principle for microservices means:-

  • Your microservice reponds to only a single request at a time.
  • Ensuring that your microservice API maintains backwards compatibility.
  • Your microservice should be able to operate in isolation.
  • A change to the internals of your microservice, shouldn’t force a change on other services.

Question 3 : Determining where our microservice boundaries lie is a function of which aspect of Domain Driven Design:-

  • Anti-Corruption Layers (ACLs)
  • Entities
  • Value Objects
  • Bounded Contexts

Question 4: True or False: A microservice should never be smaller than a Bounded Context.

  • True
  • False

Case Study : Decomposing the Monolith

Question 1 : If we alter the Orders Database, which portions of the system will need to change?

  • The Client Application
  • The Customer Microservice
  • The Loyalty Microservice
  • The Order Microservice

Question 2 : If management runs a complicated report on the Orders database, which other parts of the system could potentially be affected?

  • Client Application
  • Customer Microservice
  • Loyalty Microservice
  • Order Microservice

Question 3 : If we run a script that locks the customer tables, which areas of the system will be affected?

  • Client Application
  • Customer Microservice
  • Loyalty Microservice
  • Order Microservice

Question 4 : If our microservices had completely independent databases, would we solve the contention problem?

  • Contention would be isolated to the Order Microservice.
  • Contention would still exist across all Microservices.

Question 5 : Which of the following are valid approaches to alleviate the memory pressure in the microservices design?

  • Increase the available memory on the machine.
  • Deploy additional copies of the order service.
  • Move the orders service to it’s own hardware.
  • Delete the other caches

Question 6 : In our microservices system, how many requests are required to display the delivery information?

  • One request to the Delivery microservice.
  • Two requests, one to the Order microservice, and one to the Customer microservice.
  • Three requests, one to the Order microservice, one to the Customer microservice, and one to the Loyalty microservice.
  • Four requests, one to the Order microservice, one to the Customer microservice, one to the Loyalty microservice, and one to the Delivery microservice.

Chapter Name : principle of isolation

Question 1 : How big should a microservice be?

  • It should encapsulate a bounded context, no more, no less.
  • The size of a single function.
  • It should include a single aggregate root.
  • Small enough that it can remain properly isolated from other services, but large enough that it can do it’s job.

Question 2 : Improving isolation provides benefits in:

  • Reduced code size and increased scalability.
  • Increased consistency and scalability.
  • Reduced coupling and increased coherency.
  • Reduced coupling and increased scalability.

Question 3 : The Principles of Isolation include isolation of:

  • Time
  • Durability
  • State
  • Failure
  • Consistency
  • Atomicity
  • Space
  • Database

Question 4 : Isolation of state means:

  • Access to a microservice’s data should be wrapped in a Repository.
  • Updates to a microservice’s state must meet the ACID properties.
  • Access to another service’s data must go through a database view.
  • All access to a microservice’s data must go through it’s API.

Question 5 : Isolation of Space provides us with what benefits?

  • Rapid iteration
  • Automatic failure recovery
  • Reduced disk usage
  • Support for auto-scaling

Question 6 : True or False: Latency should not be a factor in where a microservice is deployed.

  • True
  • False

Question 7 : If we send a request, and then block resources while we wait for a response, we are NOT isolated in:

  • Failure
  • Space
  • State
  • Time

Question 8 : True or False: Strong Consistency (Total Consistency) limits scalability?

  • True
  • False

Question 9 : Isolation of Failure means:

  • A failure in a microservice should only affect services that depend on it.
  • Microservices should never fail.
  • Failures should not exceed acceptable time limits (eg. 5 minutes).
  • A failure in one service should not cause a failure in another.

Case study : – Monolithic Violations

Question 1 : In what way is the state of this system poorly isolated?

  • The Delivery portion of the system has direct access to the data for the Orders and the Customers, without going through an exposed API.
  • It is impossible to separate the deployment of the Order Service and the Customer Service.
  • The Order model has a direct, synchronous dependency on the Customer data.
  • Evolving the database for Orders, or Customers, may require an update to Deliveries as well.

Question 2 : In what way is this system poorly isolated in space?

  • Client applications must be made aware of the shape of the deployed application (eg. delivery client application knows about controllers for customers, orders, and deliveries, not just deliveries).
  • Components of the system must be deployed to the same location, regardless of whether they have a dependency on each other or not (eg. Customers and Orders are deployed to the same hardware, but have no direct dependency).
  • Client applications must be made aware of the location of all instances of the application.
  • The structure of the application limits the number of copies of the application that we are able to deploy.

Question 3 : In what way is this system poorly isolated in time?

  • The caching layer pictured in the diagram demonstrates that we are using eventual consistency.
  • The system is deployed across multiple pieces of hardware and synchronizing the clocks will be difficult.
  • All calls are synchronous and blocking.
  • The system seeks strong consistency between different components using the database.

Question 4 : In what way is this system poorly isolated in failure?

  • Retries due to timeouts will put additional load on an already failing system.
  • Serious failure (eg. out of memory) will bring down an entire instance of the monolith.
  • Redistribution of load due to failure, could cause cascading failures, and take down the entire system.
  • A serious database failure will cause the loss of the entire system.

Chapter Name :-Isolation Techniques

Module 1 : Bulkheading Review

Question 1 : A bulkhead on a ship is used to:

  • Ensure that the people with the largest cranial capacity are kept safe if the ship is damaged.
  • Isolate the bulky parts of a ship, such as the engine, to the front of the ship.
  • Insulate the engine room to prevent a fire from spreading.
  • Create water-tight compartments that prevent a damaged ship from sinking.

Question 2 : In software, bulkheading is used to:

  • Partition memory for different areas of the application.
  • Ensure that a failed call is retried until it succeeds.
  • Provide a single thread per request.
  • Isolate failures to a specific area of the system.

Question  3: True or False: If an application is operating in a degraded state, then it has not been properly bulkheaded.

  • True
  • False

Question 4 : True or False: A properly bulkheaded system will prevent scenarios where a failure of one microservice cascades into other services.

  • True
  • False

Module 2 : Circuit Breakers Review

Question 1 : True or False: Circuit Breaker is originally a plumbing term.

  • True
  • False

Question 2 : Retries are problematic in an overloaded system because:

  • They are too slow to respond.
  • The system couldn’t respond to the first attempt, so it won’t respond to the retries either.
  • Too many concurrent calls could corrupt the system’s data.
  • They put additional load on the system which may lead to a failure.

Question 3 : True or False: If a call does not include retries, then a circuit breaker is unnecessary.

  • True
  • False

Question 4 : Which state is a circuit breaker in during normal operation?

  • Half Open
  • Open
  • Closed
  • None of the Above

Question 5 : When a circuit breaker is in the Open state, it’s behaviour is:

  • A single call is attempted. If it succeeds the circuit breaker is closed.
  • All calls are retried a limited number of times until they succeed.
  • Calls are throttled at a lower rate and buffered until they can be completed.
  • All calls are immediately failed without contacting the external service.

Question 6 : A circuit breaker in a Half Open state will:

  • Allow no requests through.
  • Allow half of the requests through.
  • Allow all requests through.
  • Allow a single request through.

Question 7 : In the Half Open state, if another failure is encountered the circuit breaker will go to which state?

  • Remain in Half Open
  • Closed
  • Open
  • None of the above

Question 8 : mWhen a circuit breaker is Half Open, if a request is successful it will transition to which state?

  • Half Open
  • Half Closed
  • Open
  • None of the Above

Question 9 :  Akka and Lagom feature support for circuit breakers.

  • True
  • False

Module 3 : Message Driven Architecture Review

Question 1: A Reactive System is built on a foundation of :-

  • Actors to maximize resource usage
  • Events published to a message bus
  • HTTP calls to link services
  • Asynchronous, non-blocking messages

Question 2 : True or False: In a Reactive, message driven system, services will send messages between each other. It is critical in that case that the receiving service reply back to the sending service immediately so that we can ensure all messages have been received.

  • True
  • False

Question 3 : Synchronous, blocking messages reduce productivity by:

  • Expecting a response when a message is sent.
  • Tying up a CPU core processing “wait” messages.
  • Allowing messages to fail silently.
  • Forcing the system to consume resources, even when it’s not doing anything useful.

Question 4 : When a response to a message is expected to come synchronously, if the receiver is unavailable we must:

  • Buffer the message and deliver it when the receiver is available.
  • Continue to retry the message until it succeeds.
  • Try alternative paths to the receiver.
  • Fail the sender.

Question 5 : Which of the following benefits do we gain by using Asynchronous, Non-Blocking Messages

  • Responses are guaranteed to be delivered.
  • Resources can be freed immediately.
  • Other messages can be processed while we wait for a request to complete.
  • Consistency of the system increases, eliminating user surprises.
  • Responses are allowed to take time, resulting in a less brittle system.

Module 4 :- Autonomy Review

Question 1 : Autonomy in a Reactive System means:

  • Services can automatically restart/recover in the event of a problem.
  • Services depend on each other in a way that is clear and predictable.
  • Services understand the ways that their dependencies can fail, and will react accordingly.
  • Services can operate independently from each other.

Question 2 : Which of the following things can a microservice guarantee?

  • The behaviour of their client services.
  • Their own behaviour through their API.
  • The behaviour of their dependencies.
  • The types of failures they will experience.

Question 3 : True or False: Isolation increases dependencies.

  • True
  • False

Question 4 : True or False: Fewer dependencies means more autonomy.

  • True
  • False

Question 5 : To make a service autonomous we need to ensure:

  • It responds in a consistent fashion, regardless how much load it is under.
  • It’s dependencies automatically recover in the event of a failure.
  • It is replicated to enough places so that we can tolerate a failure.
  • It has enough information to repair failures or resolve conflicts.

Question 6 : When a dependency exists on data from an external service, we can add autonomy by:-

  • Creating multiple copies of the external service so that we don’t have to worry about it failing.
  • Retrying calls to the service in the event of failure.
  • Reading from the service’s database directly if the service is unavailable.
  • Creating a local copy of the data from that service.

Question 7:  A fully autonomous system could be scaled indefinitely (assuming enough resources were available

  • True
  • False

Question 8 : True or False: A fully autonomous service can continue to operate, even if it is the only part of the system still running.

  • True
  • False

Question 9 : Synchronous Messages

  • Enable Autonomy by reducing back and forth traffic.
  • Enable Autonomy by ensuring consistency.
  • Prevent Autonomy by requiring knowledge of where the receiver is deployed.
  • Prevent Autonomy by introducing dependencies.

Module 4 :- Gateway Services Review

Question 1 : True or False: Microservice based systems are inherently less complex than monolithic systems.

  • True
  • False

Question 2 : Monolithic applications typically aggregate data by:

  • Leveraging a separate component or service that will make all the appropriate calls and aggregate the results.
  • Making separate API calls to different areas of the application and then aggregating the data in the monolith.
  • Requiring multiple API calls from the client which will then aggregate the data.
  • Collecting the data from the database using techniques such as “joins” or “views” where necessary.

Question 3 : In the absence of a gateway service, when data needs to be aggregated from multiple microservices, a client will typically:

  • Be unable to complete the request.
  • Request the data from a single microservice. That microservice will make the individual requests, and aggregate the results.
  • Perform a “join” on the data in the database.
  • Perform each request in the client, and then aggregate the results.

Question 4 : Increasing the complexity of a client (eg. Android app, iPhone app) is problematic because:

  • It becomes harder to deprecate old microservices or APIs.
  • Clients are not guaranteed to ever update.
  • Updates are controlled by a third party (Google, Apple etc.).
  • All of the above
  • None of the above

Question 5 :A gateway service is:

  • A microservice that is responsible for managing security and ensuring that only authorized users access the system.
  • A wrapper around an external service to prevent domain concerns from leaking between bounded contexts.
  • A microservice that knows how to aggregate data from other services in order to fulfill a request.
  • All of the above
  • None of the above

Question 6 : True or False: A Gateway Service is always tied to a particular area (eg. bounded context) of the domain.

  • True
  • False

Question 7 : True or False: Gateway Services increase isolation in the system.

  • True
  • False

Case study :- Reactive Microservices

Question 1 : True or false: Introducing microservices has given us a form of bulkheading since each microservice can act as a potential failure zone.

  • True
  • False

Question 2 : We could mitigate this by introducing:

  • A gateway service between the client, and the individual services.
  • An asynchronous message between the client, and the individual services.
  • A bulkhead between the client, and the individual services.
  • A circuit breaker between the client, and the individual services.

Question 3 : We can mitigate this by introducing:

  • A circuit breaker in the client application.
  • An fully independent database for each microservice.
  • Autonomy between the microservices.
  • An asynchronous message between the client and the microservices.

Question 4 : True or False: A circuit breaker is only valuable between the client and the microservices. It would not be helpful to add one between the microservice and it’s database.

  • True
  • False

Question 5 : Having an eventually consistent cache of the delivery data in the driver’s app would be unnacceptable because:

  • Stale data could result in incorrect loyalty information.
  • Stale data could result in missing, or incorrect order items.
  • Stale data could result in delivering to the wrong address.
  • The cache is acceptable. Most changes would not be allowed after the order has left the restaurant.

Question 6 : To mitigate this problem we could:

  • Record the loyalty information on the driver’s device, and upload it when the system is back online.
  • Reject the loyalty card.
  • Wait at the door until the system is back online.
  • Ask the customer to call in their loyalty information in an hour or two.

Reactive Architecture: Reactive Microservices Cognitive class Final Exam answer:-

Question 1 : This system is violating which of the principles of isolation? Isolation of _____:

  • Two Generals Video is an online video streaming service. They have built their system with a series of microservices. One microservice is responsible for streaming the video to users, while a separate microservice tracks information about the users watch history.
  • When a user finishes watching a video, the watch history is updated. This operation spans two different microservices. The team wants to ensure that users watch history is accurate. They want to avoid situations where a user finishes watching the video, but the watch history doesn’t show that. To that end they are doing a synchronous request when the user finishes watching the video in order to update the watch history.
  • Now they are looking at implementing additional information in that watch history. They want to include how far into a video a user has watched so that they can resume where they left off. This requires another synchronous call. However, this call seems to be impacting the video stream. Since they tried to introduce it the videos are now stuttering because the calls to update the watch history are taking too long.

Question 2 : This technique is known as:

  • Spectrum Messages has a mobile application that provides instant messaging and chat features.
  • There system has a “presence” microservice that has the responsibility of tracking when a user is online or offline. This information is then exposed to the user’s contacts.
  • They have built a Gateway which collects information from a variety of microservices, and builds a view of the data that is then exposed through the mobile application.
  • Recently, the Gateway experienced a problem which caused it to fail. They have a robust monitoring system in place which automatically restarted the Gateway. However, when it restarted, it had to pull data for all of their users in a very short period of time. This sudden influx of requests to the Presence service caused it to slow down, and eventually fail.
  • To mitigate this, they have implemented a technique in the Gateway Service so that when it sees a timeout in the presence service, it will stop trying to contact it for a period of time, instead simply failing any requests. The idea is to allow the Presence service time to recover.

Question 3 : This system is violating which of the principles of isolation? Isolation of _____:

  • Available Advertising has built a microservices platform to transform data from it’s advertising network and syndicate it to various partners.
  • They have built several different microservices, each of which has a different job. Some of their services import from the various data sources, while others syndicate that data. Then there are services responsible for specific transformations.
  • To simplify deployment, all of their services have been packaged into a single bundle so they can be deployed as one unit, rather than individually. This allows them to have a single deployment process and eliminates issues with API compatibility between services.
  • They have discovered that the scalability requirements of their services are very different and the bundled package is now hindering them because they can’t scale individual pieces of their system, only the system as a whole.

Question 4 : This system is violating which of the principles of isolation? Isolation of _____:

  • Scalable Games is an online gaming company that has built a new game that they hope will appeal to millions of users.
  • They have built their system using a series of microservices. The “Player Statistics” service manages information about a players performance across multiple games. Information about the players performance is periodically sent to the Player Statistics service.
  • Recently, the company experienced an outage of the Player Statistics service while they were beta testing the game. During this outage, players who were currently playing a game were suddenly disconnected as calls to update the Player Statistics failed.

Question 5 : By isolating these two systems, they are using the technique called:

  • Saga Electronics is an online electronics retailer.
  • They have built their system using a series of microservices. These microservices have in turn been grouped according to different domains within their business. The sales microservices handle the process of ushering a customer through the sales process. The inventory services manage the tracking of inventory.
  • Although there are touch points between sales and inventory, they have tried to keep them as separate as possible. The goal is that a failure in one part of the system should be isolated so that it doesn’t propagate to another part of the system. If the inventory management system is down, they want their customers to still be able to buy products, and vice versa.

Question 6 : This system is violating which of the principles of isolation? Isolation of _____:

  • Consistent Fitness has built a set of microservices in order to support their wearable fitness tracker.
  • They have deployed an “Import” microservice that accepts data from the users tracker and stores it in a SQL database.
  • They also have a “Aggregation” microservice that reads the imported data directly from the SQL database, and aggregates it by day/week/month etc. This data is then written back to the SQL database to be consumed by other microservices.
  • They are looking to introduce a new model of fitness tracker that will record more data than the old one. This will require them to update the tables that the data is being written to to store this new information. However they are realizing that update is not trivial because they also have to update not just the Aggregation service but other services that were using that data as well.

About Machine Learning

Check Also

Python for Data Science Cognitive Class Exam Answers:-

Course Name:- Python for Data Science Module 1. Python Basics Question 1. What is the …

Leave a Reply

Your email address will not be published. Required fields are marked *