Microservices Architecture on AWS

This video will give you an overview about the course.

What are the main characteristics of the microservices architecture that distinguish it from other architectures and why should we consider using it?

• We give an introduction to the microservices architecture by looking at a simple definition

• We look at the evolution of previous architectural styles that led to the microservices architecture

• We understand the basic characteristics of each architectural style and the reasons for each step of the evolution

Why has the microservices architecture been so successful and widely adopted? What were the main factors that contributed to that success and why are they crucial to building a successful microservices architecture?

• We show which factors created an opportunity for the success of the microservices architecture, using a visualization

• We analyze the various technological practices that helped adoptmicroservices, and learn why the principles promoted by them are useful

• We explore the relation between software architecture and an organization’s function using Conway's law

How can we design our software so that we can easily add new features later on and make it easier for other developers to understand and extend? Are there any guidelines that can help us make better designs with these goals in mind?

• We introduce the concept of coupling and give some examples to understand the difference between loose and tight coupling

• We introduce the concept of cohesion and give some examples to understand the difference between low and high cohesion

• We discuss how we can create designs that take into consideration both of these concepts in order to create maintainable software

Software is built toserve a specific business purpose. However, a lot of times, software becomes complex and developers have a hard time understanding what purpose it serves. How can we write software that expresses its intent better?

• We introduce the concept of domain-driven design by looking at a simple definition

• We go through the basic concepts and building blocks of domain-driven design that we can use

• We give a practical example on how we can use the concepts explained previously in order to understand concretely how DDD can help us

How can we make use of all theoretical methodologies and principles from the previous parts in order to design a microservices architecture?

• We give an initial description of a practical problem that we will try to solve throughout the course

• We explain how the company involved in this problem operates in detail

• We sketch an initial design for part of that company's operation, using some of the principles covered in the previous parts

Having in our hands the design from the first section, we need to start developing our first microservice. Which technologies are we going to use and what will the architecture be?

• We create a high-level design showing the main endpoints of our service

• We explain the main tools we will use and the basic architecture of the service's software

• We go through the code of the service, explaining various decisions. After that, we build our service and test it

When working as part of a development team, you have to combine your code changes with those of your colleagues. How can we help developers do that in a quick and easy way without introducing bugs?

• We introduce the concept of Continuous Integrationby studying a simple definition

• We explore the main practices and benefits of Continuous Integration

• We show what a typical CI workflow looks like and how we can implement it in the cloud

Deploying a service in a single server is easy, but as we need to manage more servers, it becomes less practical doing deployments manually. How can we automate deployments?

• We explain the problem with manual deployments and why they don't scale, using some basic math

• We go through the basic benefits of automating our deployments

• We demonstrate how we can automate our deployment process using the cloud

As our service grows, we need to do more things as part of our release process, such as build software, run tests, and deploy to production. What can we do to make this as fast as possible?

• We introduce the concept of Continuous Delivery by looking at a simple definition

• We clarify the difference between Continuous Delivery and Continuous Deployment

• We show what a simple CI/CD workflow looks like and how we can implement it in the cloud

By automating more and more parts of our release process, we are removing the human from decision-making. Does that increase risk? How can we mitigate that risk?

• We explore the trade-off between speed and safety and what our mental model should be

• We analyze the basic methodologies for testing and deployment

• We go through a list of basic things we must keep in mind, when building our CI/CD pipeline

The goal of this part is to understand the ways to integrate multiple microservices. By the end of the section, it should be clear when each one is suitable and how we should make a decision ofselecting one of them.

• First, we'll need to look at the more generic problem of how two agents can communicate, namely synchronously and asynchronously

• Then, we'll look what that translates to when we have multiple systems, by looking at the basic workflows that are mainly used

• Last, we'll look at actual technologies and methodologies to implement the interaction between the systems. By combining all of these three concepts, we should be able to decide how to integrate two systems

The aim of this part is to understand what it really takes to add a gRPC endpoint to our service, the benefits, and the difficulties in doing that.

• We'll start by going through the basic concepts of gRPC and the main processes to use the gRPC tooling

• We'll then proceed by adding a gRPC interface to our existing service in practice

• We'll conclude by reviewing what we've done and establishing the pros and cons of this technique

The goal is to show an example where an asynchronous integration can be useful and demonstrate how it can be implemented in practice.

• In the beginning, we'll revisit our system architecture, explaining why asynchronous communication might be more suitable for this use case

• We'll then proceed in showing how this asynchronous integration can be implemented in code

• We'll finish by demonstrating how this integration would work in reallife, by running our services and seeing them communicate

The goal of this part is to understand the value of monitoring and logging in a large microservices architecture and understand the reasoning behind some best practices.

• We'll start by explaining why logging is useful for troubleshooting and go over some best practices

• We'll proceed by discussing the value that monitoring brings compared to logging and review some best practices

• We'll conclude by analyzing the concept of observability and explaining why logging and monitoring can together make a system more observable

The goal of this part is to see how monitoring can easily be applied in practice and see the value we can get out of it.

• Initially, we'll show how we can monitor our service using a platform in the cloud, which provides a lot of capabilities outofthebox

• In order to be able to see the value of monitoring, we'll have to generate data. So, we'll show how we can generate artificial traffic to our service

• In the end, we'll see the metrics emitted by our service, applying in practice some of the best practices presented earlier in the section

What are the main problems faced when trying to scale a system? How does a microservices architecture facilitate scaling? What are the main approaches we can use to scale a system? Are there any pitfalls we should keep in mind?

• Understand how does microservices architecture facilitate scaling by enabling independent scaling of systems

• Learn the main scaling modes and their limitations

• Understand shared-nothing architectures and load balancing can enable unbounded scaling

What is service discovery and why does it become crucial for success in a microservices architecture? What are the main mechanisms to implement it and their trade-offs?

• Explore the service discovery and why is it so important for a microservices architecture in comparison to monolithical systems

• Understand the main methodologies of implementing service discovery in a microservices architecture

• Learn the pros and cons of each approach and which one should we use

How can we enable automated scaling and service discovery for the microservices architecture we've build in this course?

• Get a high-level overview of the components and AWS services that we will use.We explain the role of each one

• Walk through the code required to implement the presented solution

• Demonstrate how our solution can scale our serviceautomatically, reacting to traffic changes

What are some of the other problems we face when our microservices architecture grows? Is there a common pattern between them? And is there a way to solve them all without duplicating effort between different services?

• We'll first discuss some of the basic concerns that are common between most of our services

• We'll explore two main approaches for solving all these concerns in an easy and maintainable way

• We'll compare the pros and cons of each approach and understand when each approach is a better fit

What is serverless computing? Why is it useful and how can we take advantage of it?

• We'll first study the definition of serverless computing and understand what it is

• We'll give a high-level overview of what a serverless application consists of and a few technical details of the implementation aspects

• We'll go over the major benefits of a serverless application and the options we have when building one

What is a usecase where we can take advantage of serverless computing? How can we build a serverless application in practice?

• We'll revisit our casestudy, looking at our architecture and discussing where we could use a serverless application

• We'll demonstrate how we can develop and deploy a serverless application using AWS Lambda

• We'll do a financial analysis of the benefits we would get, by replacing our regular application with a serverless one in real life

How does the software development lifecycle change when building a serverless application in comparison to a regular application? How does that affect software developers?

• We'll explain the main difference between regular applications and serverless applications and why that might affect the software development lifecycle

• We'll give an overview of the stages of the software development lifecycle we'll study

• We'll investigate what's the difference on each stage of the software development lifecycle, contemplating on what's the impact of software delivery

What are the caveats of serverless computing and are there situations where we should avoid using this model?

• We'll explain the existence of trade-offs in the world of software and why we should be aware of them and use them in our decision-making

• We'll explain some of the disadvantages of serverless computing

• After explaining the nature of each disadvantage, we'll explain what that means in terms of real-life use cases, where using a serverless application might not be very beneficial

What's the right way to design our microservices architecture? What's the way to decide how we split our services and how should we design each service internally?

• We'll first see some general guidelines that can help us decide how we will split our services, creating the correct structure for our microservices architecture

• We'll see some anti-patterns that can lead to problematic architectures and the ways to avoid them

• We'll explain how we can design our services internally so that they are easy to understand and maintain, introducing the concept of hexagonal architecture

How can we operate our microservices architecture in an easy and efficient way?

• We'll revisit the concept of DevOps and study the available models and their benefits

• We'll revisit the concept of observability, focusing on the value of alarming and how a culture of automation and constant learning can help us

• We'll explain several failure scenarios and how we can protect ourselves against these, introducing some basic resiliency patterns

Should we use the same technology for all our services? What's the way to choose the appropriate technology?

• We'll revisit the concept of decentralized governance, explaining why it's really valuable in a microservices architecture

• We'll give practical examples of polyglot programming to explain how we can go about selecting the appropriate programming language for a service

• We'll study some available data storage technologies, their pros, and their cons, explaining how we can choose the appropriate one for our service

What do I need to know when migrating from a monolithic architecture to a microservices architecture?

• We'll look at several basic principles that can help us decide how to decompose our monolith incrementally and where we should start from

• We'll take a deep dive into the technical aspect of migrating from a monolith to a microservices architecture, explaining several techniques that can facilitate this transition

• We'll conclude with some general tips that we should keep in mind when performing this migration

Is microservices architecture a silver bullet? Are there cases when a monolithical architecture might be more appropriate?

• We'll explain that a microservices architecture has both benefits and disadvantages, and we need to be aware of both to make the right decision

• We'll go through some of the caveats of a microservices architecture

• We'll elaborate on these caveats by giving concrete examples of caseswhere a monolith might be a better option

Why did Netflix choose to use microservices architecture? What problems did they face and how did they solve them? What are the lessons they learned during this transition?

• In this first part, we'll look at what led Netflix to consider moving to a microservices architecture

• Next, we'll dive deeper into this transition, looking at the different phases Netflix passed through and specific techniques and methodologies they used

• Lastly, we'll look at some of the lessons they learned during this transition

Why did Gilt choose to migrate from a monolithic architecture to a microservices architecture? What problems did microservices architecture help them face and what are the lessons they learned?

• In the first part, we'll look at what is special about Gilt's business domain and how a microservices architecture would benefit them

• Next, we'll learn in more detail how they re-architected their systems gradually and what changes they had to make in their organizational structure

• We'll conclude by looking at some of the takeaways they had at the end of this transition to microservices architecture