A DevOps guide to Kubernetes

This
Page
Left
Intentionally
Blank

This
Page
Also
Left
Intentionally
Blank

© Copyright 2017 Pivotal Software, Inc. All rights Reserved.
A DevOps Guide to Kubernetes
Paul Czarkowski
@pczarkowski

Paul Czarkowski Developer Advocate at Pivotal Software
● Systems Administrator
● DevOps Practitioner
● Open Source Contributor

package main
...
...
func main() {
fmt.Println("starting hello world app")
healthHandler := health.NewHandler()
http.Handle("/health/", healthHandler)
http.HandleFunc("/", serve)
http.ListenAndServe(":8080", nil)
}
...
...

- name: install ntp
package:
name: ntp
- name: configure ntp
template:
src: ntp.conf
dest: /etc/ntp.conf
notify: restart ntp
- name: start ntp
service:
name: ntp
state: started

# -*- mode: ruby -*-
# vi: set ft=ruby :
# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
VAGRANTFILE_API_VERSION = "2"
Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
# https://vagrantcloud.com/ubuntu
config.vm.box = "ubuntu/xenial64"
config.vm.network "private_network", type: "dhcp"
# Forward ports
config.vm.network "forwarded_port", guest: 8080, host: 8080 # hello world
config.vm.provider "virtualbox" do |v|
v.memory = 4096
v.cpus = 2
end

variable "region" {
default = "europe-west1-d" // We're going to need it in several places in this config
}
provider "google" {
credentials = "${file("account.json")}"
project = "my-project"
region = "${var.region}"
}
resource "google_compute_instance" "test" {
count = 1 // Adjust as desired
name = "test${count.index + 1}" // yields "test1", "test2", etc. It's also the machine's name and hostname
machine_type = "f1-micro" // smallest (CPU & RAM) available instance
zone = "${var.region}" // yields "europe-west1-d" as setup previously. Places your VM in Europe
disk {
image = "debian-7-wheezy-v20160301" // the operative system (and Linux flavour) that your machine will run
}
network_interface {
network = "default"
access_config {
// Ephemeral IP - leaving this block empty will generate a new external IP and assign it to the machine
}
}
}

$ curl http://my-application.com
Hello World!

FROM golang:1.8
WORKDIR /go/src/app
COPY . .
RUN go-wrapper download
RUN go-wrapper build
EXPOSE 8080
ENTRYPOINT ["/hello-world"]

apiVersion: apps/v1beta1
kind: Deployment
metadata:
labels:
app: hello-world
name: hello-app
spec:
replicas: 2
template:
metadata:
labels:
app: hello-world
spec:
containers:
- image: paulczar/hello-world
name: hello-world

$ minikube start
$ docker build -t hello-world .
$ kubectl apply -f deployment.yaml
$ curl http://localhost:8080
Hello World!

Culture - Increased collaboration between Development and Operations
(and the rest of the business) and an attitude of shared responsibility.
Automation - Increases velocity, but just as importantly reduces
defects and creates consistency and repeatability.
Measurement - Need to measure in order to ensure that improvement is
happening.
Sharing - As we share tools, discoveries and lessons new opportunities to
collaborate will be discovered and duplicate work can be eliminated.

IT
Dev
QA
Rel
Eng
security
Jira
Tickets

Dev
Ops
IT
Dev
QA
Rel
Eng
security
Jira
Tickets

SRE
Dev
Ops
IT
Dev
QA
Rel
Eng
security
Jira
Tickets

Infrastructure Team
Platform Team
Application Team(s)

Infrastructure Team
Platform Team
Application Team(s)
S
R
E

Infrastructure Team
Platform Team
Application Team(s)
YOU
Google ( GKE, GCP )
}
}
S
R
E

Culture - Increased collaboration between Development and
Operations (and the rest of the business) and an attitude of shared
responsibility.
Automation - Increases velocity, but just as importantly reduces defects
and creates consistency and repeatability.
Measurement - Need to measure in order to ensure that improvement is
happening.
Sharing - As we share tools, discoveries and lessons new
opportunities to collaborate will be discovered and duplicate work
can be eliminated.

Popularized Linux Containers
Originated in 2013 by a small PaaS company called DotCloud.
Provided an easy to use interface to the [already existing] Linux Containers
Linux containers are like lightweight VMs that use the built in Linux features instead of virtualizing the
hardware.
Most linux containers contain a single application rather than a whole operating system.
100s of Containers per server vs a handful of VMs.
Easy to share artifacts called Images.
Friendly to Developer and Operator workflows alike.

You tell Docker how to build a container image via a fairly simple Dockerfile which should
generally live alongside your code in your version control system.
A build/test system (ex. Jenkins, Travis, Concourse) should be used to build and tag images
based on code changes and test results and push those images to a Registry.
There are a plethora of Registries to choose from and most have a decent UI, Access
Controls, and even vuln scanning.
● Docker Registry (either public in form of Docker Hub, or privately run)
● Your Cloud Provider (most public clouds have a Registry service)
● Harbor (extends opensource registry to have enterprise features)
● Artifactory (general purpose artifact repository manager)
● Quay ( one of the earliest third party registries )

A container orchestration system.
Greek for “Helmsman” or “Pilot”
A Borg like platform using Docker as the execution engine originally built by a small team of Google
engineers (Joe Beda, Brendan Burns and Craig McLuckie) and Open Sourced in 2014.
GIFEE (Google Infrastructure For Everybody Else).
Production ready! (for some definition of the word production.)
Has a rapid release cycle of a new minor version every three months. (version 1.9 at writing of this)
First project donated to the Cloud Native Compute Foundation.

An IaaS for Containers (CaaS)
Abstracts away your infrastructure and provides a declarative language for the user to declare their
desired state and then makes that actual state
Linux containers instead of VMs.
Applications not Operating Systems.
Provides a consistent user experience for providing Compute, Network and Storage resources and
running applications that consume them.
Extends Compute, Network and Storage resources with Controllers that create, monitor and
perform actions on them to create higher level abstractions.

Controllers are effectively a infinite loop that interacts with the
kubernetes API to ensure the actual state of a resource matches
the declared state.
#!/bin/bash
while true; do
count=$(kubectl get pods | grep nginx | wc -l)
if $count < 5; then
kubectl run --image=nginx nginx
fi
sleep 120
done

https://twitter.com/onsijoe/status/598235841635360768

Culture - Increased collaboration between Development and Operations
(and the rest of the business) and an attitude of shared responsibility.
Automation - Increases velocity, but just as importantly reduces defects
and creates consistency and repeatability.
Measurement - Need to measure in order to ensure that
improvement is happening.
Sharing - As we share tools, discoveries and lessons new opportunities to
collaborate will be discovered and duplicate work can be eliminated.

How to
Get an
Kubernetes
Are you
in the
“cloud”?
yes
Which
cloud ?
GKEAKS EKS
Azure
Google
Amazon
Do you
want
help?
no
GLHF
Pivotal Container Service
…
...
https://kubernetes.io/partners
no
yes
Other
A
laptop ?
minikube
no
yes

API Server
Kube Scheduler
K8s Master
Controller
Manager
Etcd
Kubelet
Kube-proxy
K8s Worker
Pod
Pod
Pod
K8s Worker
Pod
Pod
Pod
K8s Worker
Pod
Pod
Pod
CNI CNI CNI
Docker
Kubelet
Kube-proxy
Docker
Kubelet
Kube-proxy
Docker

one or more application containers that are tightly coupled, sharing network and storage.
Example: a web front-end Pod that consists of an NGINX container and a PHP-FPM container with a shared
unix socket and a “init” container to transform their config files based on environment variables.
deployment a controller that ensures a set number of replicas of a Pod is running and
provides update and upgrade workflows for your Pods.
Example: cloud native Node app that scales horizontally and upgrades 2 pods at a time.
statefulset a controller that manages stateful application Deployments by providing sticky
identity for pods and strict ordering and uniqueness.
Example: Cassandra database. First pod is ‘cassandra-0’ thus all other pods in the set can be told to cluster
to ‘cassandra-0’ and it will form a ring, plus the storage will survive pod restarts.

tracks Pods based on metadata and provides connectivity and service discovery (DNS, Env
variables) for them.
Published as
ClusterIP (default) exposes service on a cluster-internal IP.
NodePort extends ClusterIP to expose services on each node’s IP via a static port.
LoadBalancer extends NodePort to configure a cloud provider’s load balancer using the
cloud-controller-manager.
Ingress is a controller that manages an external entity to provide load balancing, SSL
termination and name-based virtual hosting to services based on a set of rules.

Is [effectively] a Directory, possibly with data in it, available to all containers in a Pod.
Usually Shares lifecycle of a Pod (Created when Pod is created, destroyed when Pod is
destroyed).
Can be mounted from local disk, or from a network storage device such as a EBS volume,
iscsi, NFS, etc.

Provides key-value pairs to be injected into a pod much like user-data is injected into a Virtual
Machine in the cloud.
Allows you to do last minute configuration of applications running on Kubernetes such as
setting a database host, or a admin password.
ConfigMaps store values as strings, Secrets store them as byte arrays (serialized as base64
encoded strings).
Secrets are [currently] not encrypted by default. This is likely to change.
Can be injected as files in a Volume, or as Environment Variables.

apiVersion:
kind:
metadata:
spec:

apiVersion: v1
kind: Service
metadata:
name: hello-svc
spec:
ports:
- port: 80
protocol: TCP
targetPort: 8080
selector:
app: hello-world
type: NodePort
kind: Deployment
metadata:
labels:
app: hello-world
name: hello-app
spec:
replicas: 2
template:
metadata:
labels:
app: hello-world
spec:
containers:
name: hello-world
hello-app Pod
app=hello-world
hello-app Pod
app=hello-world
hello-svc Service
app=hello-world
http 80
http 8080 - load balanced

https://url
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
name: hello-goodbye
spec:
rules:
- http:
paths:
- path: /hello
backend:
serviceName: hello-svc
servicePort: 80
- http:
paths:
- path: /goodbye
backend:
serviceName: goodbye-svc
servicePort: 81
ingress-nginx
app=hello-world
hello-app Pod
app=hello-world
hello-svc Service
app=hello-world
http 8080
hello-app Pod
app=goodbye-world
goodbye-svc Service
app=goodbye-world
http 8080
http://url/hello http://url/goodbye

$ kubectl apply -f manifests/
deployment "hello-app" created
service "hello-svc" created
deployment "goodbye-app" created
service "goodbye-svc" created
ingress "hello-goodbye" created
$ curl -k https://$(minikube ip)/hello
Hello World!
$ curl -k https://$(minikube ip)/goodbye
Goodbye Cruel world!

apiVersion: v1
kind: ConfigMap
metadata:
name: hello-cm
data:
db: user:pass@host/db
kind: Deployment
metadata:
name: hello-app
labels:
app: hello-world
...
...
spec:
containers:
name: hello-world
volumeMounts:
- name: config
mountPath: /etc/hello
volumes:
- name: config
configMap:
name: hello-cm
apiVersion: v1
kind: Service
metadata:
name: hello-svc
labels:
app: hello-world
spec:
ports:
- port: 81
protocol: TCP
targetPort: 8080
selector:
app: hello-world
type: NodePort

Helm is the package manager for Kubernetes
Provides tooling to template, package, share, and run Kubernetes manifests for a given
application in the form of Charts.
Helm Client a CLI that helps you develop and run Charts.
Tiller Server runs in your cluster and translates Helm Charts into Running Applications.
~ 150 community managed Helm Charts at https://hub.kubeapps.com/
.
├── Chart.yaml
├── templates
│ ├── deployment.yaml
│ ├── ingress.yaml
│ ├── NOTES.txt
│ └── service.yaml
└── values.yaml

apiVersion: v1
kind: ConfigMap
metadata:
name: {{ .Chart.name}}-cm
data:
db: {{ .Value.db }}
kind: Deployment
metadata:
name: {{ .Chart.name}}-app
labels:
app: {{ .Chart.name}}
...
...
spec:
containers:
name: hello-world
volumeMounts:
- name: config
mountPath: /etc/hello
volumes:
- name: config
configMap:
name: {{ .Chart.name}}-cm
apiVersion: v1
kind: Service
metadata:
name: {{ .Chart.name}}-svc
labels:
app: {{ .Chart.name}}-world
spec:
ports:
- port: {{ .Value.port }}
protocol: TCP
targetPort: 8080
selector:
app: {{ .Chart.name}}-world
type: NodePort

$ helm install --name staging .
--set db=’user:pass@staging.mysql/dbname’
$ helm install --name production .
--set db=’user:pass@production.mysql/dbname’

Next Steps … Further reading.
● Kubernetes Docs, specifically the tutorials and troubleshooting sectiong
○ https://kubernetes.io/docs/home/
○ https://kubernetes.io/docs/tutorials/kubernetes-basics/
○ https://kubernetes.io/docs/tasks/debug-application-cluster/troubleshooting/
● Writing your first Helm Chart
○ https://medium.com/@pczarkowski/writing-your-first-helm-chart-f3433344f824
● Pivotal’s Enterprise Kubernetes Offering
○ https://pivotal.io/platform/pivotal-container-service
● Kelsey Hightower’s Kubecon Keynote showing CI/CD pipeline
○ https://www.youtube.com/watch?v=07jq-5VbBVQ

A DevOps guide to Kubernetes

More Related Content

What's hot

Similar to A DevOps guide to Kubernetes

Recently uploaded

A DevOps guide to Kubernetes