VL 6

Question 1

Monolithic App architecture

Answer 1

Design of a software Program which is composed of all in one piece

Question 2

Benefits of monolithic architecture

Answer 2

Easy to develop
Simple to test
Simple to deploy
Easy horizontal scaling

Question 3

Disadvantages of monolithic architecture

Answer 3

Limitation in size and complexity
Too large and complex
Slow start time
Re-deployment of complete app on updates
Reliability

Question 4

Micro services architecture

Answer 4

Single logical db per service
Built and deployed independently
Scalable
Stateless ( complete request and forget it)

Question 5

Advantages of micro services

Answer 5

Easier to understand and maintain
Independence of service
No barrier on adopting new technologies
Independent service deployment
Each service scaling

Question 6

Disadvantages of micro service

Answer 6

Complexity of creating a distributed system
Deployment complexity ( need to implement service discovery mechanism)

Question 7

Service Mesh

Answer 7

Configurable, low latency infrastructure layer
Handle a high volume of network based interprocess communication among application infrastructure services using API

Question 8

Micro services Application Framework Components: API Gateway

Answer 8

Server that is the single entry point into the system
Encapsulates internal system architecture and provides APU that is tailored to each client

Question 9

API Gateway: backends for frontends pattern

Answer 9

Defines separate API Gateway for each client

Question 10

Service Registry

Answer 10

Db containing. The network location of service instances

Question 11

Service Registration

Answer 11

Self registration: directly to service registry
3rd party registration: through service manager

Question 12

Service discovery: problem

Answer 12

In micro services app, each service instance is assigned IP Adress dynamically because of Autoscaling, failures, upgrades

Question 13

Client-side service discovery

Answer 13

Clients are responsible for determining the network locations of available service instances
Client queries a service registry
Client uses a load balancing algorithm to select one of the available instances and makes a request

Question 14

Client side service discovery: pros

Answer 14

Straightforward, no moving parts except of service registry
Client can make intelligent application-specific load balancing decisions as it knows about available services instances s

Question 15

Client side service discovery: Cons

Answer 15

Cons:
• Couples the client with the service registry.
• Implementation of client-side service discovery logic for each programming language and framework used by service clients.

Question 16

Server Side discovery

Answer 16

Client makes request to a service via load balancer
Load balancer queries the service registry and routes each request to an available service instance

Question 17

Server side service discovery: pros&cons

Answer 17

Pros:
• details of discovery are abstracted away from the client.
• Eliminates the need to implement discovery logic for each programming language and framework used by your service clients.
Cons:
• Requires load balancer

Question 18

Basic request flow

Answer 18

For each request there is assigned thread responsible for getting data and send response back to the client
Thread is freed after response is sent to user

Question 19

Immediate failure

Answer 19

Wrap the code in Order service around try catch block to handle exceptions.
Thread freed quickly after response is sent to user

Question 20

Timeout failure

Answer 20

All requests are waiting for response when payment service is overloaded or crashed
Reason: unconfigured timeout value

Question 21

Cascading failure

Answer 21

At high requests rate all threads are waiting

Question 22

Timeout failure: solution

Answer 22

Have default response to immediately return to keep the thread pool free

Add interceptor for all requests
Allow: change status after few failed requests in a time and after timeout check again
Problem: can be that service is still down => you get overload in payment service and want to know the reason( service down/ too many requests)

Allow partial with circuit breaker

Question 23

Micro services App deployment: multiple services instances per VM

Answer 23

All resources are shared: cpu, memory, VM

Question 24

Micro services app deployment: service instance per VM

Answer 24

Pay for resources you don’t use

Question 25

Micro services app deployment:
Multiple services containers per VM

Answer 25

Deploy with containers

Question 26

Micro services app deployment:
Service container per VM

Answer 26

Easily move from one machine to another, allows scalability

Question 27

Rolling updates: ramped

Answer 27

slow rollout

The number of instances of the old version is decreased and the new version is increased until the correct number of service instances is reached.

Pro:
- version is slowly released across instances
- convenient for stateful applications that can handle rebalancing of the data
Cons:
- rollout/rollback can take time
- supporting multiple APIs is hard
- no control over traffic

Question 28

Rolling updates: blue/green

Answer 28

Blue/Green
The “green” version of the application is deployed alongside the “blue” version.
After testing that the new version, update the load balancer to send traffic to the new version

Pro:
- instant rollout/rollback
- avoid versioning issue
Cons:
- requires double the resources
- proper test of the entire platform should be done before releasing to production

Question 29

Rolling updates: canary

Answer 29

A canary deployment consists of routing a subset of users to a new functionality.
For example: end 25% of traffic to new version

Pro:
- version released for a subset of users
- convenient for error rate and performance monitoring
- fast rollback

Cons:
- slow rollout
- fine tuned traffic distribution can be expensive

Question 30

Rolling updates: A/B testing

Answer 30

A/B testing
Distributing traffic amongst versions based on a few parameters (cookie, user agent, etc.).

Pro:
- intelligent load balancer
- several versions run in parallel
- full control over the traffic distribution

Cons:
- hard to troubleshoot errors for a given session, distributed tracing becomes mandatory
- not straightforward, you need to setup additional tools