'''You may continue to install Kubernetes on the vm you already installed docker. If you are installing this on a different machine make sure docker is already installed.
'''
== Part 1 ==

'''Installing kubeadm, kubelet, and kubectl:'''

1. Update the apt package index:

`sudo apt-get update`

2. Install packages needed to use the Kubernetes apt repository:

`sudo apt-get install -y apt-transport-https ca-certificates curl vim git`

3. Download the public signing key for the Kubernetes package repositories:

`curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg`

4. Add the Kubernetes apt repository:

`echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list`

Update the apt package index again:

`sudo apt-get update`

5. Install kubelet, kubeadm, and kubectl:`

`sudo apt-get install -y kubelet kubeadm kubectl`

6. Pin installed versions of kubelet, kubeadm, and kubectl to prevent them from being accidentally updated:

`sudo apt-mark hold kubelet kubeadm kubectl`

7. Check installed versions:

`kubectl version --client`

`kubeadm version`
 

'''Disable Swap Space'''

8. Disable all swaps from /proc/swaps.

`sudo swapoff -a`

`sudo sed -i.bak -r 's/(.+ swap .+)/#\1/' /etc/fstab`

9. Check if swap has been disabled by running the free command.

`free -h`


'''Install Container runtime'''

10. Configure persistent loading of modules 

{{{
#!sh
sudo tee /etc/modules-load.d/k8s.conf <<EOF
overlay
br_netfilter
EOF
}}}

11. Load at runtime 

`sudo modprobe overlay `

`sudo modprobe br_netfilter`

12. Ensure sysctl params are set

{{{
#!sh
sudo tee /etc/sysctl.d/kubernetes.conf <<EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF
}}}

13. Reload configs
`sudo sysctl --system `

14. Install required packages

`sudo apt install -y containerd.io `

15. Configure containerd and start service

`sudo mkdir -p /etc/containerd`

`sudo containerd config default | sudo tee /etc/containerd/config.toml`

16. Configuring a cgroup driver

Both the container runtime and the kubelet have a property called "cgroup driver", which is essential for the management of cgroups on Linux machines.

`sudo sed -i 's/SystemdCgroup \= false/SystemdCgroup \= true/g' /etc/containerd/config.toml`

17. Restart containerd

`sudo systemctl restart containerd`

`sudo systemctl enable containerd`

`systemctl status containerd`

'''Initialize control plane'''

18. Make sure that the br_netfilter module is loaded:

`lsmod | grep br_netfilter`

Output should similar to:

{{{
#!sh
br_netfilter           22256  0 
bridge                151336  1 br_netfilter
}}}

19. Enable kubelet service.

`sudo systemctl enable kubelet`

20. Pull container images (it will take some time):

`sudo kubeadm config images pull --cri-socket /run/containerd/containerd.sock`

21. Bootstrap the endpoint. Here we use 10.244.0.0/16 as the pod network:

`sudo kubeadm init   --pod-network-cidr=10.244.0.0/16   --cri-socket /run/containerd/containerd.sock`

You will see Your Kubernetes control-plane has initialized successfully!

'''You need to save the kubeadm join token string on a text document for future use.'''

22. To start the cluster, you need to run the following as a regular user (For this scenario we will only use a single master):
 
`mkdir -p $HOME/.kube`

`sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config`

`sudo chown $(id -u):$(id -g) $HOME/.kube/config`

23. Check cluster info:

`kubectl cluster-info`

24. Install a simple network plugin.

`wget https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml`

`kubectl apply -f kube-flannel.yml`

25. Check the plugin is working

`kubectl get pods -n kube-flannel`

26. Confirm master node is ready: (If you see the status as Notready, give it a around 10mins)

`kubectl get nodes -o wide`

27. On a master/ control node to query the nodes you can use:

`kubectl get nodes`

28. Connecting Worker nodes:
   a. Install docker on both worker nodes as per the guidelines [https://ws.learn.ac.lk/wiki/dockerdeployment2023#Part1: here] (Upto step 6).
   b. Install Kubernetes on each worker nodes. Follow above steps 1 to 20.
   c. Use previously saved kubeadm join token string to connect the workers. Run it with '''sudo'''.

      [OPTIONAL] If you forgot the token, run the following on your master to create a new token:

      `kubeadm token create --print-join-command`

      But remember, this will create a new token.

   d. After all workers are connected, check status of the cluster: Here after all commands should be run on the master.

      `kubectl get nodes -o wide`

== Part 2 ==
Create a file `simple-pod.yaml`

{{{
#!python
apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.14.2-alpine
    ports:
    - containerPort: 80
}}}

To create the Pod shown above, run the following command:

`kubectl apply -f simple-pod.yaml`

Check pod

`kubectl get pods`

Kill the Pod.

`kubectl delete pod nginx`

Pods are generally not created directly and are created using workload resources. 

See Working with Pods[https://kubernetes.io/docs/concepts/workloads/pods/#working-with-pods] for more information on how Pods are used with workload resources

== Part 3 ==

'''Deploying a Simple Web Application on Kubernetes'''

1. Create a Deployment Manifest:

A Deployment ensures that a specified number of pod replicas are running at any given time. Let's create a simple Deployment for a web application using the nginx image.
Save the following YAML to a file named `webapp-deployment.yaml`:

{{{
#!python
apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp-deployment
  labels:
    app: webapp
spec:
  replicas: 2
  selector:
    matchLabels:
      app: webapp
  template:
    metadata:
      labels:
        app: webapp
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80
}}}

2. Create a Service Manifest:

A Service is an abstraction that defines a logical set of Pods and enables external traffic exposure, load balancing, and service discovery. For our web application, we'll use a NodePort service.

Save the following YAML to a file named `webapp-service.yaml`:

{{{
#!python
apiVersion: v1
kind: Service
metadata:
  name: webapp-service
spec:
  selector:
    app: webapp
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
      nodePort: 30080
  type: NodePort
}}}

3. Deploy the Application:
Apply the Deployment and Service manifests:

`kubectl apply -f webapp-deployment.yaml`

`kubectl apply -f webapp-service.yaml`


4. Verify the Deployment:
Check the status of the Deployment and Service:

`kubectl get deployments`

`kubectl get services`


You should see your webapp-deployment with 2 replicas. Give it a time to take both replicas online.

5. Access the Web Application:

Since we used a !NodePort service, the web application should be accessible on node's IP at port 30080.
If you're unsure of your node IPs, you can get them with:

`kubectl get nodes -o wide`

Then, in a web browser or using a tool like curl, access the web application:

`curl http://<MASTER/NODE_IP>:30080`

You should see the default nginx welcome page, indicating that your web application is running.

Delete all the deployments, run below command:

`kubectl delete deployment <deployment name>`

Delete all the Services, run below command:

`kubectl delete service <service name>`
 

== Part 4 ==

'''Deploying !WordPress and MySQL on Kubernetes'''

Installing dependancies:

Download rancher.io/local-path storage class:

`kubectl apply -f https://raw.githubusercontent.com/rancher/local-path-provisioner/master/deploy/local-path-storage.yaml`

Check with `kubectl get storageclass`

Make this storage class (local-path) the default:

`kubectl patch storageclass local-path -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'`

1. Create a PersistentVolumeClaim for MySQL:

MySQL needs persistent storage to store its data. Save the following YAML to a file named `mysql-pvc.yaml`:

{{{
#!python
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
}}}

Apply the PVC:

`kubectl apply -f mysql-pvc.yaml`

2. Deploy MySQL:
Save the following YAML to a file named `mysql-deployment.yaml`:

{{{
#!python
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
      - name: mysql
        image: mysql:5.7
        env:
        - name: MYSQL_ROOT_PASSWORD
          value: "password"
        - name: MYSQL_DATABASE
          value: "wordpress"
        ports:
        - containerPort: 3306
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pvc
}}}

Apply the Deployment:

`kubectl apply -f mysql-deployment.yaml`

3. Create a Service for MySQL:

This will allow !WordPress to communicate with MySQL. Save the following YAML to a file named `mysql-service.yaml`:

{{{
#!python
apiVersion: v1
kind: Service
metadata:
  name: mysql
spec:
  selector:
    app: mysql
  ports:
    - protocol: TCP
      port: 3306
      targetPort: 3306
}}}

Apply the Service:
`kubectl apply -f mysql-service.yaml`

4. Deploy !WordPress:
Save the following YAML to a file named wordpress-deployment.yaml:

{{{
#!python
apiVersion: apps/v1
kind: Deployment
metadata:
  name: wordpress
spec:
  replicas: 1
  selector:
    matchLabels:
      app: wordpress
  template:
    metadata:
      labels:
        app: wordpress
    spec:
      containers:
      - name: wordpress
        image: wordpress:latest
        env:
        - name: WORDPRESS_DB_HOST
          value: mysql
        - name: WORDPRESS_DB_USER
          value: "root"
        - name: WORDPRESS_DB_PASSWORD
          value: "password"
        ports:
        - containerPort: 80
}}}

Apply the Deployment:
`kubectl apply -f wordpress-deployment.yaml`

5. Create a Service for WordPress:

This will expose !WordPress to external traffic. Save the following YAML to a file named `wordpress-service.yaml`:

{{{
#!python
apiVersion: v1
kind: Service
metadata:
  name: wordpress
spec:
  selector:
    app: wordpress
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: NodePort
}}}

Apply the Service:

`kubectl apply -f wordpress-service.yaml`

6. Access WordPress:

Since we used a !NodePort service, !WordPress should be accessible on node's IP at a dynamically allocated port above 30000.
To find the !NodePort assigned to !WordPress:

`kubectl get svc wordpress`

Then, in a web browser, access `WordPress`:

`http://< INTERNAL-IP>:<NODE_PORT>`
 

== Part 5 ==

Convert your Docker deployment into a Kubernetes deployment, you may compose your own service, deployment manifests as needed. Use the docker images you used previously when creating the pods/deployments. 
 

Additional ref:[ https://kubebyexample.com/]