Gain insights into real-world microservice implementation, exploring tech stacks, Kafka, Docker, Kubernetes, and more. Learn about synchronous and asynchronous integrations with hands-on coding demonstrations.

docker_ms2_v3.tar.gz

scs-esi

kafka

atom

links

netflix

consul

atom-kafka-scs-netflix-up

links-up

Microservices are one of the most important software architecture trends, but it’s one thing to define an architecture and quite another to implement it. 

This course focuses on the nitty-gritty details of real-world implementation. You’ll learn recipes for tech stacks that can be used to implement microservices, as well as the pros and cons of each. 

You’ll start by exploring some fundamental concepts for implementing microservices. Within each concept, you’ll learn about the different technologies used to implement it. The technologies include: Frontend Integration with Edge Side Includes (ESI), asynchronous microservices with Kafka and REST feeds, synchronous microservices with the Netflix stack and Consul, Docker, Kubernetes, Cloud Foundry. Each technology you learn about is described and then demonstrated with real code. 

By the end of this course, you’ll be a microservice pro. Whether you’re a software engineer or an engineering manager, this course will prove useful throughout your career.

Microservice Architecture: Practical Implementation

The domain structure is identical to the example in the Netflix
chapter ([chapter 10](https://www.educative.io/courses/microservice-architecture-practical-implementation/introduction-YVgRzwVEQy2)) (see
the drawing below) and consists of **three
microservices**.





* The **catalog** microservice manages the information such as price and name for the items that can be ordered.


* The **customer** microservice stores customer data.

* The **order** microservice can accept new orders. It uses the catalog
  and customer microservice.

# Architecture of the example

The example in this chapter uses [Consul](https://www.consul.io/) for
service discovery and [Apache httpd server](https://httpd.apache.org/)
for routing the HTTP requests.

An overview of the Docker containers is shown in the drawing below. The three microservices provide their UI and REST interfaces at the port 8080. They are only
accessible within the network between the Docker containers. Consul
offers port 8500 for the REST interface and the HTML UI as well as UDP
port 8600 for DNS requests. 

These two ports are bound to the Docker host and are accessible from other computers. The Docker host also provides the Apache httpd at port 8080. Apache httpd forwards calls to the microservices in the Docker network so that the microservices can also be accessed from outside.


In this lesson, we'll introduce an example.

Preface

Self-contained Systems

Concept: Frontend Integration

Recipe: Links and Client-side Integration

Recipe: Server-side Integration using Edge Side Includes (ESI)

Concept: Asynchronous Microservices

Recipe: Messaging and Kafka

Recipe: Asynchronous Communication with Atom and REST

Concept: Synchronous Microservices

Recipe: REST with the Netflix Stack

Recipe: REST with Consul and Apache httpd

Concept: Microservices Platforms

Recipe: Docker Containers with Kubernetes

Recipe: PaaS with Cloud Foundry

Appendix

Example

A