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

# Setup 


The example is accessible at
<https://github.com/ewolff/microservice-kubernetes>. <https://github.com/ewolff/microservice-kubernetes/blob/master/HOW-TO-RUN.md>
explains in detail how to install the required software for running the example.

The following steps are necessary for running the example:

* [Minikube](https://github.com/kubernetes/minikube) as minimal
Kubernetes installation has to be installed. Instructions for this can
be found at <https://github.com/kubernetes/minikube#installation>.

* [kubectl](https://kubernetes.io/docs/user-guide/kubectl-overview/)
is a command line tool for handling Kubernetes and also has to be
installed. Its installation is described at
<https://kubernetes.io/docs/tasks/tools/install-kubectl/>.

* The script `docker-build.sh` generates the Docker images for
  the microservices and uploads them into the public Docker hub. This
  step is optional since the images are already available on the
  Docker hub. It only has to be performed when changes were introduced
  to the code or to the configuration of the microservices.
  Before starting the script, the Java code has to be compiled with
 `./mvnw clean package` (macOS, Linux) or `mvnw.cmd clean package`
(Windows) in directory `microservice-kubernetes-demo`.
  Then the script `docker-build.sh` creates the images with `docker
  build` and with `docker tag` they receive a globally unique name and
  `docker push` uploads them into the Docker hub. Using the public
  Docker hubs spares the installation of a Docker
  repository and thereby facilitates the handling of the example.

* The script `kubernets-deploy.sh` deploys the images from the public Docker hub in the 
  Kubernetes cluster and thereby generates the pods, the deployments, the
  replica sets, and the services. For this, the script uses the tool
`kubectl`. `kubectl run` serves to start the image which is downloaded at the indicated URL in the Docker hub. In addition, it is defined which port the Docker container should provide. So, `kubectl
run` generates the deployment, which creates the replica set and
thereby the pods. `kubectl expose` generates the service which
accesses the replica set and thus creates the IP address, node port
resp. load balancer and DNS entry.

This excerpt from `kubernetes-deploy.sh` shows the use of the tools
using the catalog microservice as an example.


```shell
#!/bin/sh
if [ -z "$DOCKER_ACCOUNT" ]; then
  DOCKER_ACCOUNT=ewolff
fi;
...
kubectl run catalog \\
 --image=docker.io/$DOCKER_ACCOUNT/microservice-kubernetes-demo-catalog:latest
  \\
 --port=80
kubectl expose deployment/catalog --type="LoadBalancer" --port 80
...
```



Let's look at an example of how Kubernetes can be used.

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

The Example in Detail

Setup #