kubernetes-getting-started.slide

Kubernetes Getting Started
Apr 2018

Ilias Dimos
DevOps Engineer, Pollfish
iliasdimos@gmail.com
@dosko64

* Docker Athens Meetup
.image images/docker.png


* About 
 

* What is Kubernetes?
- Open source  
: Google open-sourced the Kubernetes project in 2014

- Highly available
: Through scheduling and healthchecking

- Managing containers 

- Backed by a big community
- A lot of enteprises put effort on the project


.image images/kubernetes.png




* Why Kubernetes
- Run new code in production without setting up servers
- Fail over capabilities
- Easy see what you are running in the cluster
- Better use of your resources




* Setup 
- Local 
    - Minikube

- Tools to setup your cluster
    - kubeadm 
    - kops 
    - kubicorn

- Cli tool 
    - kubectl



* Providers 

- Cloud 
    - Google Kubernetes Engine
    - Microsoft ACS Engine and AKS Engine
    - Amazon EKS


Enterprise Solutions 

    - Juju by Canonical

    - Tectonic by CoreOS

    - Docker Enterprise

- More at: 
.link https://kubernetes.io/docs/setup/pick-right-solution/


    There are a lot of resources out there on how to setup you cluster




* Architecture
Node Types: 

- Master

: Master - Node Controllers - a component which manages various aspects of nodes
: health, scheduling
: availability, internal list of nodes up to date 

- Worker

: worker - reponsible for running our apps, our payloads

    kubectl get nodes



* Architecture

- kubelet
: - kubelet - The agent that runs on each node

- kube-apiserver
: - kube-apiserver - REST operations with the cluster

- kube-controller-manager
: kube controller-manager -  the core control loops shipped with Kubernetes 
: -- Watches the shared state of the cluster, throught the apiserver, and makes changes towards the desired state, 
: --- includes replication namespace serviceaccount controllers etc.

- kube-scheduler
: kube-scheduler  -  Watches over the cluster and acts accordingly to ensuer kube-controller-managere's requests. All are exposed through the API as necessary.

- etcd
: etcd -- key value store used to store the state of the cluster




* Components: 

- *Pod* 
: pod - The smallest deployable object, can contain 1 or more docker containers. 

- *ReplicationController* - Deprecated -  
: Replication Controller - enables you to easily create multiple pods, then make sure that that number of pods always exists

- *ReplicaSet* 
: ReplicaSet - Enables easily create multiple pods. Ensures a given nuber of pods always run. Keep history of deployments. Advance selector.

- *Deployment* 
: Deployment - Replacement of RC, replication through RS, Rollout/rollback abilities.



    kubectl get pods 
    kubectl get rs 
    kubectl get deployment 

    kubectl get rc 

    kubectl get all





* Okay, how i connect to this ?

Services

: Service - The entity that give us (loadbalanced) access to selected deployments/pods determined by labels 

: Service are of the following types:

    - ClusterIP
    - NodePort
    - LoadBalancer

Ingress

: Ingress -  a collection of rules that allow inbound connections to reach the cluster services.
: Imagine an Nginx in your cluster, with SSL termination and name-based routing

.code examples/ingress.yaml

    kubectl get svc 
    kubectl get ingress





* Namespace 

- Virtual clusters in the same physical cluster

    kubectl get namespace
    kubectl get all --all-namespaces

- Kubeconfig 
    Env Variables
    KUBECONFIG 
    Default ~/.kube/config

    kubectl config view
    kubectl config set-context prod --cluster='kluster' --namespace='production' --user='kubelet'
    kubectl config use-context prod


    kubeconfig is a yaml file, so you can edit it by hand


* Recap Components

.image images/Kube_basic_example.jpg


* Tools  
- kubectl 

: imperative

** Demo

Basic kubectl commands

    kubectl run nginx --image=nginx --port=80
    kubectl expose deployment nginx --target-port=80 --type=NodePort
    kubectl get pods | deployment | svc | all 
    kubectl describe <resource>
    kubectl logs <pod_name>
    kubectl exec <pod_name> cmd
    kubectl exec -it <pod_name> bash 

    kubectl proxy
: kubectl proxy, at http://localhost:8001/apis/ you can see the apis available in your cluster

* Working stack

- Use Yaml files (on git) for definitions for :

    Deployment (which includes -> ReplicaSet -> Pods)

    Service




* Deployment Simple Example 
.code -edit examples/deployment_simple.yaml


* Deployment Full Example
.code -edit examples/deployment1.yaml
    --> to be continued to editor deployment.yaml

* Service Example
.code -edit examples/service.yaml


* Components part. 2 

- Volumes 
: volumes: A way to persist data to some kind of disk
: based on the driver
: it's everything we expect from docker volumes to be, with a broader spectrum

- Configmaps

: Configmaps - Save your configurations to etcd and use them as a volume to pods

- Secrets 
: ---------
: Secrets
: Secrets contains a small amount of sensitive data such as a password
: use them as volumes in pods

- Daemonset
: --------- 
: Daemonset
: - A DaemonSet ensures that all (or some) Nodes run a copy of a Pod.

- StatefulSets 
: ---------
: StatefulSets
: -- provide guarantees about the ordering and uniqueness of these Pods.
: -- are valuable for applications that require one or more of the following.

: -- Stable, unique network identifiers.
: -- Stable, persistent storage.
: -- Ordered, graceful deployment and scaling.
: -- Ordered, graceful deletion and termination.
: -- Ordered, automated rolling updates.

- Jobs 
: ---------
: Jobs
: --- A job creates one or more pods and ensures that a specified number of them successfully terminate. 

- Cronjobs
: ---------
: Jobs
: ---- A Cron Job manages time based Jobs, namely:
: ---- Once at a specified point in time
: ---- Repeatedly at a specified point in time

* Configmaps 

.code examples/config.yaml

* Configmaps as Volume
.code examples/volume_config.yaml 


* Demo (2)

Deployment and service

: Create replace deployment 
    kubectl create -f examples/deployment_simple.yaml
    
    kubectl create -f examples/service.yaml

    kubectl replace -f examples/deployment_simple.yaml

    kubectl set image deployment/worker worker=goweb:0.2
: Scale 
    kubectl scale --replicas=3 -f examples/deployment_simple.yaml

    kubectl scale --replicas=1 deployment/worker
: Rollback deployment
    kubectl rollout status deployment app-deployment

    kubectl rollout history deployment app-deployment

    kubectl rollout undo worker





* Final Notes

- We need Service and Deployment definition for all your workloads

- Create your services wisely and before deployments 

- KubeDNS provide access to services in the form of: 
    <service-name>.<namespace>.svc

- For everyting up to creation time, in pods, all resources are available in environmental variables

- Environmental Variables for configuration in your apps (12 factor app)

- Create healthcheck in your apps

- Always apply limits for pods

- Version your docker images and don't use latest

* Usefull shortcuts
    alias k='kubectl'
    alias kg='kubectl get'
    alias kga='kubectl get all'
    alias kgan='kubectl get all --all-namespaces'
    alias kcc='kubectl config use-context'
    alias kl='kubectl logs'
    alias klf='kubectl logs -f'
    alias kd='kubectl describe'
    alias ksn='kubectl -n kube-system'


Tools Suggestions: 
- oh-my-zsh kubectl autocomplete 
- VSCode kubernetes plugin


* Next steps 

- RBAC
- Helm
- CI/CD consepts


* Presentation Available at 

.link https://go-talks.appspot.com/github.com/dosko64/kubernetes-getting-started/kubernetes-getting-started.slide


and code at 
.link https://github.com/dosko64/kubernetes-getting-started