Kubernetes (k8s) is an ideal platform for running microservices due to its abilities to support heterogeneous technologies, independent development by small teams, efficient use of resources through scaling, rolling upgrades without outages, and high availability and fault tolerance. The presentation demonstrates running a sample three-tier microservices application on Kubernetes, including deploying the application pods and services, scaling pods, handling failures through replication, and performing rolling upgrades.

1. Kubernetes (k8s) and
Microservices

2. About me
Mahendra Laxaman
Senior Technical Consultant
IT Infrastructure Consultancy (ITIC) division
LSEG Technology (previously MIT)
https://www.linkedin.com/in/mahendra-
laxaman-b3771514/
Servers
Networking
OS and Containerized platforms
SAN
Databases
Cloud
Infrastructure Security
Other system software
We do consultancy for

3. Flow of the presentation
● Microservices architecture
● Ideal platform traits to run microservices
● Learn by reverse engineering
● First microservice in kubernetes
● Scaling
● High availability and FT
● Rolling upgrades

4. Microservice architecturere

5. One-thing that do everything - monolithic
mobile
app
web
browser
gateway
web
driver
account
function
inventory
function
shipping
function

6. Do one thing and do it right - microservices
mobile
app
web
browser
gateway
web frontend
account
service
inventory
service
shipping
service
account
db
inventory
db
Shipping
db
Tier 1 Tier 2 Tier 3

7. Ideal platform traits to run
microservices

8. Heterogeneous technologies coexists
Independently developed by
small teams
java 1.8
php
python3
java 1.9
python2
Oracle
mysql
redis

9. No resource overprovisioned
Cost efficient for cloud deployments
2C, 1GB
3C, 4GB
1C, 1GB
1C,2GB
5C,3GB
1C,5GB
2C,8GB
1C,1GB

10. Scalable
Provision resource for components
based on
demand

11. Host 1
Scalable ctd.
Host 2

12. Rolling upgrade
No service outage when upgrading
a component
0.9
1.0

13. Highly available and Fault tolerant
No service outage on replica
failure

14. Kubernetes
● Kubernetes being the state-of-the-art platform for microservices that support
above traits
● It is called the orchestration platform
current
state
desired
state
orchestration

15. Learn by reverse engineering

16. Let’s install kubernetes
Minikube
Linux:
curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
chmod +x minikube
./minikube start
Windows:
choco install minikube kubernetes-cli
minikube start
Use a cloud service
https://www.katacoda.com/courses/kubernetes
http://labs.play-with-k8s.com/

17. Minikube
● Easiest way to run Kubernetes locally
● Its a single-node Virtual Machine

18. Kubernetes dashboard

19. Lets install kubectl
● The Kubernetes command-line tool
● Run commands against Kubernetes clusters
Install
Linux:
curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.14.0/bin/linux/amd64/kubectl
chmod +x kubectl
Windows:
curl -LO https://storage.googleapis.com/kubernetes-release/release/v1.14.0/bin/windows/amd64/kubectl.exe

20. Helloworld to kubernetes
Install nginx
● kubectl run nginx --image=nginx:1.10.0 --requests=cpu=200m
● kubectl expose deployment nginx --port=80 --type=NodePort
Install tomcat
● kubectl run tomcat --image=tomcat --requests=cpu=100m
● kubectl expose deployment tomcat --port 8080 --type=NodePort
This is called imperative method

21. Deploy nginx using a config files
=
kubectl create -f nginx.yaml
nginx.yaml
This is called declarative method
kubectl run nginx --image=nginx:1.10.0 --requests=cpu=200m

22. Syntax
apiVersion: v1
kind:
metadata:
spec:
status:
Metadata, eg: labels, name
image, Desired state of the object
identifies the schema this resource
object follows, eg: Pod, Deployment
Running state of the object

23. First micro service

24. Deploy a three-tier microservice application
kubectl create -f tier1.yaml kubectl create -f tier2.yaml kubectl create -f tier3.yaml
1. Take the message in
2. Append my hostname
3. Pass to the next tier
client tier1 tier2 tier3

25. What is running
● These are called pods
● It’s a stripped-down version of VM
HW emulation
Kernel
Dependencies
Application
Dependencies
Application
VM
POD

26. Pod on rest is called ‘image’
kubectl run nginx --image=nginx:1.10.0 --requests=cpu=200m
dependencies
nginx Executable -> Process
Image -> POD
https://hub.docker.com/

27. Create the connectivity (service)
client tier1 tier2 tier3
tier2
tier1
Single next hop
kubectl create -f tier1_svc.yaml kubectl create -f tier2_svc.yaml kubectl create -f tier3_svc.yaml
client tier1 tier3
tier2
tier1 tier2 tier3
tier1 tier2
tier2
Load balancers between each tier

28. What is this ‘Service’
‘Services’ provide connectivity and load balancing

29. Let’s connect to our application
Auto assigned hostnames

30. Scaling

31. It’s not just the PODs and the Services
This is all that we provisioned so far
Deployments
Replicasets

32. Add 2 replicas to tiar1
client
tier
1
tier3
tier2
tier1

33. High availability

34. Let’s kill a process
kubectl delete pod tier2-7d65b94b7c-4bnxg
client
tier
1
tier1
tier3
tier2
tier1
tier1

35. Rolling upgrade

36. Let’s upgrade the tier2
kubectl set image deployment/tier2 tier2=multicloud/netcat
kubectl rollout status deployment/tier2
kubectl rollout history deployment/tier2
kubectl rollout undo deployment/tier2
replica 1
new
replica 2
new
replica 3
new
replica 1 replica 2 replica 3

37. Kubernetes in production
Amazon EKS
Google GKE
Azure AKS
node
(worker)
node
(worker)
node
(master)
node
(master)

38. Scaling
● Scaling
○ Manually adding new replicas
● Horizontal Pod Autoscaler (HPA)
○ Matric based automatic scale

39. Rolling updates and Rollbacks
● Update without outage
● If unsuccessful rollback to previous state