Volume

• All data stored inside a container is deleted if the container crashes.
• The kubelet will restart it with a clean slate, which means that it will not have any of the old data.
• To overcome this problem, k8s uses Volumes.
• A Volume is essentially a directory backed by a storage medium.
• The storage medium content and access mode are dertrmined by the Volume Type.
• In k8s, a Volume is attatched to a Pod and can be shared among the containers of that Pod.
• The Volume has the same life span as the Pod
• Volume outlives the containers of the Pod - this allows data to be perserved accross container restarts.

Volume Types

• A directory which is mounted inside a Pod is backed by the underlying Volume Type.
• A Volume Type decides the properties of the directory, like size, content, default access modes,etc. Some example of volume Types are :
• emptyDir
  • An empty Volume is created for the Pod as soon as it is scheduled on the worker node.
  • The Volume's life is tighly coupled with the Pod.
  • If the Pod is terminated, the content of emptyDir is delete forever.
• hostPath
  • we can share a directory from the host to the Pod.
  • If the Pod is terminated, the content of the Volume is still available on the host.
• gcePersistentDisk
  • we can mount a Google Compute Engine (GCE) persistent disk into a Pod.
• awsElasticBlockStore
  • we can mount an AWS EBS Volume into a Pod
• azureDisk
  • we can mount Microsoft Azure Data Disk into a Pod
• azureFile
  • we cam mount Microsoft Azure File Volume into a Pod.
• cephfs
  • an existing CephFS Volume can be mounted into a Pod.
  • When a Pod terminates, the volume is unmounted and the contents of the volume are preserved.
• nfs
  • we can mount an NFS share into a Pod.
• iscsi
  • mount an iSCSI share into a Pod.
• secret
  • we can pass sensitive information, such as passwords, to Pods.
• configMap
  • we can provide configuration data, or shell commands and argument into a Pod.
• persistentVolumeClaim
  • we can attatch a PersistentVolume to a Pod using a persistentVolumeClaim
• Official Document

PersistentVolumes

• PersistentVolume(PV) provides APIs for users and administrators to manage and consume persistent sotrage.
• To manage the Volume, it uses the PersistentVolume API resoruce type.
• To consume it, it uses the PersistentVolumeClaim API resoruce Type.
• A Persistent Volume is a network-attached storage in the cluster, which is provisioned by the adminstrator.
• PersistentVolumes can be dynamically provisioned based on the StorageClass resource.
• A StorageClass contains pre-defined provisioners and parameters to create a PersistentVolume.
• Using PersistentVolumeClaims, a user sends the request for dymanic PV creation, which gets wired to the StorageClass resoruce.
• Some of the Volume Types that support managing storage using PersistentVolumes are :
  • GCEPersistentDisk
  • AWSElasticBlockStore
  • AzureFile
  • AzureDisk
  • CephFS
  • NFS
  • iSCSI
  • Complete list

PersistentVolumeClaims

• A PersistentVolumeClaim(PVC) is a reqeust for storage by a user.
• Users reqeust for PersistentVolume resoruce based on type, access mode, and size.
• There are three access modes:
  • ReadWriteOnce(read-write by a single node)
  • ReadOnlyMany(read-only by mana nodes)
  • ReadWriteMany(read-write by many nodes)
• Once a suitable PersistentVolume is found, it is bound to a PersistentVolumeClaim. PersistentVolumeClaim
• After a successful bound, the PersistentVolumeClaim resoruce can be used in a Pod.
• Once a user finishes its work, the attached PersistentVlumes can be released.
• The underlying PersistentVlumes can then be reclaimed (for an admin to verify and/or aggregate data), delete(both data and volume are deleted), or recycled for futher usage(only data is deleted).
• More details on

Container Storage Interface (CSI)

• Container orchestrator like K8s, Mesos, Docker or Colud Foundry used to have their own methods of managing external storage using Volumes.
• It was challenging for storage vendors to manage different Volume plugins for different orchestrators.
• Storage vendors and community members from different orchestrators started working together to standardize the Volume interface.
• a Vlume plugin build using a standardized CSI designed to work on different container orchestrators. Specifications here
• With CSI, thrid-party storage providers can develop solutions without the need to add them into the core Kubernetes codebase.

---

Demo

• create an empty directory in minikube vm

$ minikube ssh
                         _             _
            _         _ ( )           ( )
  ___ ___  (_)  ___  (_)| |/')  _   _ | |_      __
/' _ ` _ `\| |/' _ `\| || , <  ( ) ( )| '_`\  /'__`\
| ( ) ( ) || || ( ) || || |\`\ | (_) || |_) )(  ___/
(_) (_) (_)(_)(_) (_)(_)(_) (_)`\___/'(_,__/'`\____)

$ ls
$ mkdir pod-volume
$ ls
pod-volume
$ cd pod-volume/
$ pwd
/home/docker/pod-volume
$ exit
logout

• create Pod resources, by using kubectl to generate.

$ kubectl run --help
...
...
--restart='Always': The restart policy for this Pod.  Legal values [Always, OnFailure, Never].  If set to 'Always'
a deployment is created, if set to 'OnFailure' a job is created, if set to 'Never', a regular pod is created. For the
latter two --replicas must be 1.  Default 'Always', for CronJobs `Never`.

• so

$ kubectl run share-pod --image=nginx --restart=Never --port=80 --dry-run -o yaml

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: share-pod
  name: share-pod
spec:
  containers:
  - image: nginx
    name: share-pod
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

• write to file

$ kubectl run share-pod --image=nginx --restart=Never --port=80 --dry-run -o yaml > share-pod.yaml

• vim it to edit as follow

$ cat share-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  labels:
    run: share-pod
  name: share-pod
spec:
  volumes:
  - name: host-volume
    hostPath:
      path: /home/docker/pod-volume
  containers:
  - image: nginx
    name: nginx
    ports:
    - containerPort: 80
    volumeMounts:
    - mountPath: /usr/share/nginx/html
      name: host-volume
  - image: debian
    name: debian
    volumeMounts:
    - mountPath: /host-vol
      name: host-volume
    command: ["/bin/sh","-c", "echo Introduction to Kubernetes > /host-vol/index.html; sleep 3600"]

• creat it

$ kubectl create -f share-pod.yaml
pod/share-pod created

• show pods

$ kubectl get pods
NAME        READY   STATUS              RESTARTS   AGE
share-pod   0/2     ContainerCreating   0          4s

$ kubectl get pods
NAME        READY   STATUS    RESTARTS   AGE
share-pod   2/2     Running   0          46s

• export service

$ kubectl expose pod share-pod --port=80 --type=NodePort
service/share-pod exposed

• list services and endpoints

$ kubectl get services,endpoints
NAME                 TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
service/kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP        41h
service/share-pod    NodePort    10.110.127.14   <none>        80:31642/TCP   28s

NAME                   ENDPOINTS             AGE
endpoints/kubernetes   192.168.99.106:8443   41h
endpoints/share-pod    172.17.0.6:80         28s

• access nginx

$ minikube service share-pod
|-----------|-----------|-------------|-----------------------------|
| NAMESPACE |   NAME    | TARGET PORT |             URL             |
|-----------|-----------|-------------|-----------------------------|
| default   | share-pod |             | http://192.168.99.106:31642 |
|-----------|-----------|-------------|-----------------------------|
* Opening service default/share-pod in default browser...

• e.g

$ curl http://192.168.99.106:31642/
Introduction to Kubernetes

• Let's terminate the pod.

$ kubectl delete pod share-pod
pod "share-pod" deleted

• check pods

$ kubectl get pods
No resources found in default namespace.

• check services, and endpoints

$ kubectl get services,endpoints
NAME                 TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
service/kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP        41h
service/share-pod    NodePort    10.110.127.14   <none>        80:31642/TCP   6m12s

NAME                   ENDPOINTS             AGE
endpoints/kubernetes   192.168.99.106:8443   41h
endpoints/share-pod    <none>                6m12s

• Service is still running

• Endpoint doesn't show any more IPs, because the Pod has been terminated, and the Pod's IP has been released.

• Create a new Pod

$ kubectl run check-pod --image=nginx -l app=share-pod --restart=Never --dry-run -o yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    app: share-pod
  name: check-pod
spec:
  containers:
  - image: nginx
    name: check-pod
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Never
status: {}

• save and edit it

$ kubectl run check-pod --image=nginx -l app=share-pod --restart=Never --dry-run -o yaml > check-pod.yaml

• cat it

apiVersion: v1
kind: Pod
metadata:
  labels:
    app: share-pod
  name: check-pod
spec:
  volumes:
  - name: check-volume
    hostPath:
      path: /home/docker/pod-volume
  containers:
  - image: nginx
    name: nginx
    ports:
    - containerPort: 80
    volumeMounts:
    - mountPath: /usr/share/nginx/html
      name: check-volume

• create a pod

$ kubectl create -f check-pod.yaml
pod/check-pod created

• check Pods

$ kubectl get pods
NAME        READY   STATUS    RESTARTS   AGE
check-pod   1/1     Running   0          25s

• check services, endpoints

$ kubectl get services,endpoints
NAME                 TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
service/kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP        42h
service/share-pod    NodePort    10.110.127.14   <none>        80:31642/TCP   66m

NAME                   ENDPOINTS             AGE
endpoints/kubernetes   192.168.99.106:8443   42h
endpoints/share-pod    <none>                66m

• Problem : endpoints/share-pod is not up and running.
• Describe service share-pod

$ kubectl describe services share-pod
Name:                     share-pod
Namespace:                default
Labels:                   run=share-pod
Annotations:              <none>
Selector:                 run=share-pod
Type:                     NodePort
IP:                       10.110.127.14
Port:                     <unset>  80/TCP
TargetPort:               80/TCP
NodePort:                 <unset>  31642/TCP
Endpoints:                <none>
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

• describe endpoint share-pod

$ kubectl describe endpoints share-pod
Name:         share-pod
Namespace:    default
Labels:       run=share-pod
Annotations:  <none>
Subsets:
Events:  <none>

• describe check-pod

$ kubectl describe pod check-pod
Name:         check-pod
Namespace:    default
Priority:     0
Node:         minikube/192.168.99.106
Start Time:   Sat, 29 Feb 2020 13:42:48 +0700
Labels:       app=share-pod
Annotations:  <none>
Status:       Running
IP:           172.17.0.6
...
...

• solution we need check-pod label to have run=share-pod

$ kubectl label pods check-pod run=share-pod
pod/check-pod labeled

• describe pod one more time.

$ kubectl describe pod check-pod
Name:         check-pod
Namespace:    default
Priority:     0
Node:         minikube/192.168.99.106
Start Time:   Sat, 29 Feb 2020 14:30:38 +0700
Labels:       app=share-pod
              run=share-pod
Annotations:  <none>
Status:       Running
IP:           172.17.0.6
....
....

• now we have all labels we need, check service and ednpoint one more time.

$ kubectl get services,endpoints
NAME                 TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
service/kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP        42h
service/share-pod    NodePort    10.110.127.14   <none>        80:31642/TCP   79m

NAME                   ENDPOINTS             AGE
endpoints/kubernetes   192.168.99.106:8443   42h
endpoints/share-pod    172.17.0.6:80         79m

• got it.

$ curl 192.168.99.106:31642
Introduction to Kubernetes