Changes between Version 1 and Version 2 of minikubedeployment2023

Timestamp:

Nov 15, 2023, 6:29:43 AM (17 months ago)

Author:

deepthi

Comment:

--

minikubedeployment2023

@@ -1 +1 @@
 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
+
+==== Part 1 ====
+
 Installing kubeadm, kubelet, and kubectl:
+
 1. Update the apt package index:
-sudo apt-get update
+
+`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
+
+`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
+
+`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
+
+`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
+
+`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
+
+`sudo apt-mark hold kubelet kubeadm kubectl`
+
 7. Check installed versions:
-kubectl version --client
-
-kubeadm version
+
+`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
+
+`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
+
+`free -h`
  
 Install Container runtime
 10. Configure persistent loading of modules 
+
+
 sudo tee /etc/modules-load.d/k8s.conf <<EOF
 overlay
 br_netfilter
 EOF 
+
 11. Load at runtime 
-sudo modprobe overlay 
-
-sudo modprobe br_netfilter 
+
+`sudo modprobe overlay `
+
+`sudo modprobe br_netfilter`
+
 12. Ensure sysctl params are set
+
 sudo tee /etc/sysctl.d/kubernetes.conf<<EOF
 
@@ -49 +77 @@
 
 EOF
+
 13. Reload configs
-sudo sysctl --system 
+`sudo sysctl --system `
+
 14. Install required packages
-sudo apt install -y containerd.io 
+
+`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
+
+`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
+
+`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
+
+`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
+
+`lsmod | grep br_netfilter`
+
 Output should similar to:
 br_netfilter           22256  0 
 bridge                151336  1 br_netfilter
+
 19. Enable kubelet service.
-sudo systemctl enable kubelet
+
+`sudo systemctl enable kubelet`
+
 20. Pull container images (it will take some time):
-sudo kubeadm config images pull --cri-socket /run/containerd/containerd.sock
+
+`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
+
+`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!
+
 22. To start the cluster, you need to run the following as a regular user (For this scenario we will only use a single host):
-  mkdir -p $HOME/.kube
-  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
-  sudo chown $(id -u):$(id -g) $HOME/.kube/config
+ 
+` 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
+
+`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
+
+`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
+
+`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
+
+`kubectl get nodes -o wide`
 27. On a master/ control node to query the nodes you can use:
-kubectl get nodes
+
+`kubectl get nodes`
+
 Scheduling Pods on Kubernetes Master Node
-28. By default, Kubernetes Cluster will not schedule pods on the master/control-plane node for security reasons. It is recommended you keep it this way, but for test environments you need to schedule Pods on control-plane node to maximize resource usage.
-kubectl taint nodes --all  node-role.kubernetes.io/control-plane-
-Part 2 
+28. By default, Kubernetes Cluster will not schedule pods on the master/control-plane node for security reasons. It is recommended you keep it this way, but for test environments you need to schedule Pods on 
+control-plane node to maximize resource usage.
+
+`kubectl taint nodes --all  node-role.kubernetes.io/control-plane-`
+
+==== Part 2 ====
 Create a file simple-pod.yaml
+
 apiVersion: v1
 kind: Pod
@@ -110 +171 @@
     ports:
     - containerPort: 80
+
 To create the Pod shown above, run the following command:
-kubectl apply -f simple-pod.yaml
+
+`kubectl apply -f simple-pod.yaml`
+
 Pods are generally not created directly and are created using workload resources. See Working with Pods 
 Links to an external site. for more information on how Pods are used with workload resources
-Part 3
+
+==== 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:
+
 apiVersion: apps/v1
 kind: Deployment
@@ -140 +207 @@
         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:
+
 apiVersion: v1
 kind: Service
@@ -156 +225 @@
       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
+
+`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
+
+`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
+
+`kubectl get nodes -o wide`
+
 Then, in a web browser (though ssh tunnel if you are in UiS cloud) or using a tool like curl, access the web application:
-curl http://<NODE_IP>:30080
+
+`curl http://<NODE_IP>:30080`
+
 You should see the default nginx welcome page, indicating that your web application is running.
  
@@ -178 +258 @@
 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
+
+`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"}}}'
+
+`kubectl patch storageclass local-path -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'`
 
 1. Create a PersistentVolumeClaim for MySQL:
@@ -196 +279 @@
     requests:
       storage: 1Gi
+
 Apply the PVC:
-kubectl apply -f mysql-pvc.yaml
+
+`kubectl apply -f mysql-pvc.yaml`
+
 2. Deploy MySQL:
 Save the following YAML to a file named mysql-deployment.yaml:
+
 apiVersion: apps/v1
 kind: Deployment
@@ -231 +318 @@
         persistentVolumeClaim:
           claimName: mysql-pvc
+
 Apply the Deployment:
-kubectl apply -f mysql-deployment.yaml
+
+`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:
+
 apiVersion: v1
 kind: Service
@@ -250 +340 @@
 
 Apply the Service:
-kubectl apply -f mysql-service.yaml
+`kubectl apply -f mysql-service.yaml`
 
 4. Deploy WordPress:
 Save the following YAML to a file named wordpress-deployment.yaml:
+
 apiVersion: apps/v1
 kind: Deployment
@@ -282 +373 @@
 
 Apply the Deployment:
-kubectl apply -f wordpress-deployment.yaml
+`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:
+
 apiVersion: v1
 kind: Service
@@ -301 +393 @@
 
 Apply the Service:
-kubectl apply -f wordpress-service.yaml
+
+`kubectl apply -f wordpress-service.yaml`
 
 6. Access WordPress:
@@ -308 +401 @@
 To find the NodePort assigned to WordPress:
 
-kubectl get svc wordpress
+`kubectl get svc wordpress`
 
 Then, in a web browser with the ssh tunnel, access WordPress:
 
-http://< INTERNAL-IP>:<NODE_PORT>
+`http://< INTERNAL-IP>:<NODE_PORT>`
  
 Part 5