Objective

Today we will see about the EKS and its use cases and how it used and how it is configured and what will be the process for creating such kind of cluster ?We will also see how many type of cluster we can make and then after this we will Integrate it with EBS,EFS and ELB. After doing Integration we will launch a pod that will be WordPress with MySQL . For this setup we first have to configure MySQL and then WordPress for deployment. After this we can view the use case of HELM and how to configure it and much more integrations. Finally we will launch a Prometheus server on the EKS and then integrate it with Grafana and at last we will talk about the Fargate Cluster.

Pre Requisites :

  • AWS CLI

Here We GO..

First we have to create an IAM user with Administrator Access and use its credentials to login the AWSCLI and then download EKSCTL Software from internet to use EKSCTL command and then set its environment path to our system path in windows so we can use it from anywhere . EKSCTL work as a client for EKS service just like KUBECTL work for Kubernetes.

After this now we have to configure our cluster over the EKS we can use this following code to configure our EKS cluster for practice our work

apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: lwcluster
region: ap-south-1
nodeGroups:
- name: ng-1
instanceType: t2.micro
desiredCapacity: 2
ssh:
publicKeyName: mycloudkey
- name: ng-2
instanceType: t2.micro
desiredCapacity: 2
ssh:
publicKeyName: mycloudkey

In this LWCLUSTER we create 2 NodeGroup with t2 micro instance type that is in free-tier and then we used our key(cwcloudkey) to login and perform some task on our nodes.

eksctl create cluster -f cluster.yml

These are the Nodes of our cluster our master is managed by our AWS EKS here we will create our slave or nodes where our client can launch their apps. after Successfully creating clusters we have to update our kubeconfig file so that it can use the AWS EKS cluster instead of our minikube.

We need to understand that behind the scene eksctl will take the help of cloud formation so there will be some stack created for to launch nodes in the AWS.

Process Started
and then finally
aws eks update-kubeconfig  --name lwcluster#cmd to display nodes
kubectl get nodes

Now, we need to create one AWS Elastic file system. Go to your AWS console -> EFS and then create one file system.

Now i just check that our command is working or not run “kubectl get pods” .it works give output without any error it means it’s ok. Now I am gonna launch 3 things (WORDPRESS , MYSQL) , Prometheus , Grafana so i am creating 3 different namespaces for them its better for management.

kubectl create ns wordpress-mysql
kubectl create ns prometheus
kubectl create ns grafana

I have created “wp-mysql” as my current namesapce

kubectl config set-context  --current --namespace=wordpress-mysql

Use EFS provisioner to create deployment od pods.Code for Deploymrnt is

kind: Deployment
apiVersion: apps/v1
metadata:
name: efs-provisioner
spec:
selector:
matchLabels:
app: efs-provisioner
replicas: 1
strategy:
type: Recreate
template:
metadata:
labels:
app: efs-provisioner
spec:
containers:
- name: efs-provisioner
image: quay.io/external_storage/efs-provisioner:v0.1.0
env:
- name: FILE_SYSTEM_ID
value: fs-62de54b3
- name: AWS_REGION
value: ap-south-1
- name: PROVISIONER_NAME
value: gau-prov/aws-efs
volumeMounts:
- name: pv-volume
mountPath: /persistentvolumes
volumes:
- name: pv-volume
nfs:
server: fs-62de54b3.efs.ap-south-1.amazonaws.com
path: /

Do some changes in the above file like value of file_system_ID, server and your provisioner_name…etc.for your own efs cluster.

kubectl create -f efs.yml

After this, create one ClusterRoleBinding file too.

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
name: nfs-provisioner-role-binding
subjects:
- kind: ServiceAccount
name: default
namespace: wordpress-mysql
roleRef:
kind: ClusterRole
name: cluster-admin
apiGroup: rbac.authorization.k8s.io

in this we will create Rolebinding to run this i use command that is

kubectl create -f role.yml

After this we can create Storage Class

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
name: aws-efs
provisioner: gau-prov/aws-efs

By this code we can create our Storage Class that is used to create by running following cmd.

kubectl create -f storage.yml

Now EKS is integrated with EFS

NOW After this we can create Pvc code for pvc is given below

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
name: efs-wordpress
annotations:
volume.beta.kubernetes.io/storage-class: "aws-efs"
spec:
accessModes:
- ReadWriteMany
resources:
requests:
storage: 10Gi
---
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
name: efs-mysql
annotations:
volume.beta.kubernetes.io/storage-class: "aws-efs"
spec:
accessModes:
- ReadWriteMany
resources:
requests:

storage: 10Gi

IN THIS CODE WE WILL CREATE 2 PVC 1 FOR MYSQL AND 1 FOR WORDPRESS I CAN TAKE 10Gi AS A STORAGE WE CAN ALSO CHNGE OUR ACCESSMODE.COMMANDIS KUBECTL CREATE -F PVC.YML

We need secret IN mysql and wordpress so we will create a secret

kubectl create secret generic mysql-pass  --from-literal=password=redhat

Now can deploy my MySQL server

apiVersion: apps/v1 # for versions before 1.9.0 use apps/v1beta2
kind: Deployment
metadata:
name: wordpress-mysql
labels:
app: wordpress
spec:
selector:
matchLabels:
app: wordpress
tier: mysql
strategy:
type: Recreate
template:
metadata:
labels:
app: wordpress
tier: mysql
spec:
containers:
- image: mysql:5.6
name: mysql
env:
- name: MYSQL_ROOT_PASSWORD
valueFrom:
secretKeyRef:
name: mysql-pass
key: password
ports:
- containerPort: 3306
name: mysql
volumeMounts:
- name: mysql-persistent-storage
mountPath: /var/lib/mysql
volumes:
- name: mysql-persistent-storage
persistentVolumeClaim:

claimName: efs-mysql

by this code I create a MySQL pod or server by using deployment and use MySQL version 5.6 and get password of MySQL from secret and mount our pvc to its path. cmd is kubectl create -f mysql.yml

now we can create service od mysql

apiVersion: v1
kind: Service
metadata:
name: wordpress-mysql
labels:
app: wordpress
spec:
ports:
- port: 3306
selector:
app: wordpress
tier: mysql

clusterIP: None

here can make a service of MySQL and give a port 3306 and use the cmd kubectl create -f storage-mysql.yml

Now we need to deploy wordpress

apiVersion: apps/v1 # for versions before 1.9.0 use apps/v1beta2
kind: Deployment
metadata:
name: wordpress
labels:
app: wordpress
spec:
selector:
matchLabels:
app: wordpress
tier: frontend
strategy:
type: Recreate
template:
metadata:
labels:
app: wordpress
tier: frontend
spec:
containers:
- image: wordpress:4.8-apache
name: wordpress
env:
- name: WORDPRESS_DB_HOST
value: wordpress-mysql
- name: WORDPRESS_DB_PASSWORD
valueFrom:
secretKeyRef:
name: mysql-pass
key: password
ports:
- containerPort: 80
name: wordpress
volumeMounts:
- name: wordpress-persistent-storage
mountPath: /var/www/html
volumes:
- name: wordpress-persistent-storage
persistentVolumeClaim:
claimName: efs-wordpress

in this I can launch Wordpress which can joint with MySQL database and usedeplymentkind and version of wordpressis 4.8 code for running is kubectl create -f wordpress.yml

now to make Wordpress service we use a code

apiVersion: v1
kind: Service
metadata:
name: wordpress
labels:
app: wordpress
spec:
ports:
- port: 80
selector:
app: wordpress
tier: frontend

type: LoadBalancer

now we can see the Wordpress site First page

After this we have to Perform HELM task for that we have to download HELM software and configure its path so we can use it form any location and we also use thriller in backend f

or HELM .after this we can launch prometheus and grafana through this

kubectl -n kube-system create serviceaccount tiller
kubectl create cluster rolebinding tiller --clusterrole cluster-admin --serviceaccount=kube-system:tiller
helm init --service-account tiller
helm init --service-account tiller --upgrade

By These commands we will configure the helm now we can use helm to do our work fast .

Now to install prometheus in its namespace

helm install  stable/prometheus  --namespace prometheus  --set alertmanager.persistentVolume.storageClass="gp2"  --set server.persistentVolume.storageClass="gp2"

TO USE PORT FROWARDING :

kubectl get svc -n prometheus
kubectl -n prometheus port-forward svc/dull-bumblebee-prometheus-server 88

INSTALL GRAFANA IN ITS NAMESPACE

helm install grafana/stable  --namespace grafana  --set persistence.storageClassName="gp2"  --set adminPasswod=redhat  --set service.type=LooadBalancer

TO USE PORT FORWARDING IN GRAFANA :

kubectl get svc -n grafana
kubectl -n grafana port-forward svc/exasperated-seal-grafana 1234:80

this is the prove that we can launch our prmoetheus with grafana.

After this we have to delete our EKS cluster because it will take charge to us for running our cluster on there data center

eksctl delete cluster -f cluster.yml --region=ap-south-1 --name=vedcluste

THANK YOU
CyberWizard