This document discusses application orchestration with Kubernetes. It covers packaging applications for deployment on Kubernetes, satisfying performance constraints, and how Kubernetes can provide services to make developing and managing cloud native applications easier. It also discusses moving applications from VMs to containers on Kubernetes, including decomposing monolithic applications and implementing a DevOps approach using CI/CD pipelines. Key concepts discussed include labels, persistent volumes, infrastructure as code, and maintaining separate test, development and production environments.

1. Application orchestration
with Kubernetes
Glenn West, Principle Engineer
gwest@redhat.com

2. Overview
When moving from VM based applications to container based applications,
there are a number of things which change in the application is developed and
managed. This presentation will cover all aspects of deploying an application
on a Kubernetes-based container management platform, including packaging
applications for deployment, satisfying performance constraints of NFV
applications, and the ways in which container management platforms can
provide services which make the development and management of cloud native
applications easier.

3. Core Differences
• Containers provide lightweight alternative to vm’s
• Natural Separation of Code and State (Data)
• Share one copy of OS.
• Easy to deploy complex interconnected applications

4. Things To Watch Out For
• Kubernetes can be installed on bare metal
• Gives a Significant Advantage In Performance
• Virtualation Overhead is 20% vs Baremetal

5. Moving from VM’s
• Traditional VM implementations are monolithic
• Brute Force:
https://www.linkedin.com/pulse/how-difficult-move-applications-containers-glenn-
west

6. Brute Force
• Example: VOIP Switch
• Traditional Install
• One Big Applicaton In A Container
• Saving state after modifications to image
• Rebuilds are hard
• It Works

7. Decompose
• Look for:
• natural dividing lines of services
• Front-end Back-end Service Managers
• Different dependencies
• Language Differences
• Version Differences
• Is the dev team separate?

8. Moving to K-Native
• Moving to a Kubernetes Native Application
Implementation Has Several Advantages
• Easier Updates
• Natural Support for a DevOps Implementation
• Easier to put specific components on specific machines
• Better Security – Read Only Code
• Separation of Code and Data
• Support for Stateless and Stateful

9. Now What?

10. Kubernetes

11. Kubernetes

12. Concepts

13. Labels / Tagging

14. Tagging / Labels
• Often in a telco environment, getting the right code on the
right hardware is important.
• Applications need specific NIC’s, certain storage,
Kubernetes supports “Tagging”

15. Persistent Volumes

16. Transformation
• We now have a set of separate components
• Each component ideally has a small number of people
associated to it.
• Interdependencies are managed and minimised
• REST
• Message Bus
• Now we can run fast right?

17. DevOps

18. So How to Handle Rapid
Change

19. CI/CD Explained
• CI/CD merges development with testing, allowing
developers to build code collaboratively, submit it the
master branch, and checked for issues. This allows
developers to not only build their code, but also test their
code in any environment type and as often as possible to
catch bugs early in the applications development
lifecycle. Since Kubernetes can integrate with tools like
Jenkins and Git, developers can submit code in Git, test
the code and automatically trigger a build using Jenkins,
and once the image is complete, images can be added to
container registry.

20. Continuous Delivery

21. CI/CD Explained

22. DETAILS

23. Test/Dev/Prod
• Combining Labels, Pipelines, and Multiple Environments
• We can manage application changes across multiple
environments, with separate networks, with automated test.

24. CI/CD Pipeline

25. Developer to Operations
• Developer Creates Source
• S2I – Source 2 Image – Combines Source with a base
image
• Developer Commits source
• A Pipeline Starts
• Application is built
• Unit Test are run
• If Passing, move to integration test
• Integration Test are run
• If pass, rolling upgrade is performed.

26. Infrastructure As Code
• Some examples of Infrastructure:
• A Message Bus Driven Multi-Domain DNS Server
• Svcdns – Nodejs wrapper on top of a DNS Server
• A Cloud to DNS Bridge
• Svcpkt2dns – A nodejs that bridges a cloud provider into
svcdns

27. Summary
• Kubernetes solves several problems and issues
• Scale Out of infrastructure over multiple hosts
• Self Healing
• Support for Continues Integration and CD
• Microservices
• Improved Security
• Offers Rapid Development
• Better Testing