Learn to implement microservices across a range of common tech stacks.

Scalability & System Design for Developers

In this module, we’ll look at some fundamental concepts for implementing microservices. Within each concept, learn about the different technologies used to implement it. The technologies include front-end 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 is described and then demonstrated with real code.

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.

The Example in Detail

Setup