DEV Community: Suraj Warbhe

Launching WordPress on AWS with RDS

Suraj Warbhe — Sun, 05 Sep 2021 05:06:28 +0000

USE-CASE

Create an AWS EC2 instance
Configure the instance with Apache webserver
Download php application name "WordPress".
Setup a MySQL server using AWS RDS service using Free Tier as a backend
Provide the endpoint/connection string to the WordPress application to make it work

Pre-requisite:

AWS Account

STEP 1 : Create an EC2 Instance

🔶 We need to launch an EC2 Instance on AWS which we will use to configure Apache Webserver and run WordPress.

🔶 Click on Launch Instance.

🔶 Select 'Amazon Linux` as a Instance Flavor.

🔶 Select t2.micro as a instance type. It is free for eligible.

🔶 Provide configuration details and click on Add Storage.

🔶 Add storage. I will keep it default. And click on Add Tag.

🔶 Add tag if you want. For this, click on Add another tag.

🔶 After this click on Configure Security Group.

🔶 Click on Add Rule. I will allow All traffic to avoid any firewall issue. Then click on Review and Launch.

🔶 Attach key pair then Instance will launched successfully.

🔶 Click on Instance ID. You will get all the details of your created instance.

🔶 You will get Public IP and Private IP from this.

Now you can use Public IP address any Key to connect this Instance. You can use Putty(Recommended) or CLI Browser provided by Amazon to Connect Instance.

Lets go for Next to Configure the instance as Apache Webserver:

STEP 2 : Configure the Instance with Apache Webserver

🔶 Here we are going to configure the Apache Web Server in Amazon Linux 2 Instance.

🔶 To run WordPress, we need to run a web server on our EC2 instance. The open source Apache web server is the most popular web server used with WordPress.
🔶 Install Apache Web Server.
`

sudo su -
yum install httpd -y

🔶 Then we are Starting Webserver and Enable it Permanently.

systemctl start httpd

systemctl enable httpd

STEP 3 : Installation and configuration of php software name `WordPress`

🔶 WordPress is a php Application, let’s install php 7.2.

🔶 With Amazon Linux 2, you can use the Extras Library to install application and software updates on your instances.

 amazon-linux-extras install -y php7.2

🔶 After that download WordPress file!

wget http://wordpress.org/latest.tar.gz

🔶 After download the "TAR" file "UNTAR" it.

tar -xvzf latest.tar.gz

🔶 Next you see wordpress name dir come up. So now you can copy all Content inside wordpress folder to Document Root /var/www/html.

cp -rf wordpress/* /var/www/html

Note:

Make Sure where you download your tar file and where you Untar it.

STEP 4 : Setup a MySQL server using AWS RDS service with Free Tier Account

🔶 Let’s now launch a MySql database using Amazon RDS.

🔶 Click on Create Database.

🔶 Choose Standard Create and MySQL as a engine option.

🔶 Select Version MySQL 8.0.20 and template as Free tier.

🔶 Provide DB Instance name, Username & Password

🔶 Here this DB instance have No Connectivity to Internet. We will access it through EC2 Instance.

🔶 Now after Launching this DB Instance mydb named Database will be created inside this DB server.

🔶 Now click on Launch Database. It will take around 10 minutes.

🔶 Once the Database is available, click on Connectivity & Security. You will get hostname and Port no. there.

STEP 5 : Provide the Endpoint/Connection string to the WordPress Application

🔶 Go to the created EC2 Instances instance. In the Description below, find the Public DNS (IPv4) of your instance.

🔶 Enter this IP Address into your web browser. And type Enter.

🔅 Provide Following Information:
🌀 Database Name: Provide Name of Database which created at time of launching DB!

🌀 Username: The username you given while launching DB Instance!

🌀 Password: Provide Password!

🌀 Database Host: Provide the ENDPOINT which you get from "wordpress-database"!

🔶 Now our WordPress is running on the AWS using AWS RDS as a service and in the backend it is using MySQL.
Let's check from CLI.
Use command

# mysql -h <endpoint_url> -u <username> -p

And provide our password.

🔶 Provide Following Details and Install WordPress!

🔶 After Login with the credentials and Login to WordPress!

Successfully done! We have Login in to WordPress and we can continue to write Blogs etc., All your Data will Be stored in RDS MySQL DB.

Automating Kubernetes Cluster on AWS using Ansible and deploying WordPress with MySQL on k8s cluster

Suraj Warbhe — Sat, 04 Sep 2021 09:17:44 +0000

USE-CASE

Create Ansible Playbook to launch 3 AWS EC2 Instance
Create Ansible Playbook to configure Docker over those instances
Create Playbook to configure K8S Master, K8S Worker Nodes on the above created EC2 Instances using kubeadm
Launch a WordPress and MySQL database connected to it in the respective slaves
Expose the WordPress pod and the client able to hit the WordPress IP with its respective port.

Pre-requisite: (FOR RHEL-8)

Controller node should be setup with ansible installation and configuration, when controller node is RHEL8
Create one IAM user having Administrator Access and note down their access key and secret key
Create one Key pair in (.pem) format on AWS Cloud, download it in your local system and transfer it over RHEL-8 through WinSCP.

STEP 1 : Ansible Installation and Configuration

Install Ansible on Base OS (RHEL8), configure ansible configuration file.
To do this use below commands-

yum install python3 -y

pip3 install ansible -y

vim /etc/ansible/ansible.cfg

NOTE: Python should be installed on your OS to setup Ansible.
Write below commands in your configuration ansible.cfg file. For this you can prefer any editor like vi, vim, gedit-

[defaults]
inventory=/root/ip.txt  #inventory path
host_key_checking=False
command_warnings=False
deprecation_warnings=False
ask_pass=False
roles_path= /root/roles      #roles path
force_valid_group_names = ignore
private_key_file= /root/awskey.pem   #your key-pair 
remote_user=ec2-user

[privilege_escalation]
become=True
become_method=sudo
become_user=root
become_ask_pass=False

STEP 2 : Create Ansible Roles

🔶 Go inside your roles workspace

cd /roles

Use Below commands to create 3 different roles

For Kubernetes Cluster
For Kubernetes Master
For Kubernetes Slaves

# ansible-galaxy init <role_name>

ansible-galaxy init kube_cluster
ansible-galaxy init k8s_master
ansible-galaxy init k8s_slave
ansible-galaxy init wordpress_mysql

STEP 3 : Write role for Kubernetes Cluster

🔶 Go inside the tasks folder. We have to write entire tasks inside this folder

cd /roles/kube_cluster/tasks

vim main.yml

🔶 I am going to create cluster over Amazon Linux instances.
Write below source code inside it-

- name: Installing boto & boto3 libraries
  pip:
    name: "{{ item }}"
    state: present
  loop: "{{ lib_names }}"

- name: Creating Security Group for K8s Cluster
  ec2_group:
    name: "{{ sg_name }}"
    description: Security Group for allowing all port
    region: "{{ region_name }}"
    aws_access_key: "{{ access_key }}"
    aws_secret_key: "{{ secret_key }}"
    rules:
    - proto: all
      cidr_ip: 0.0.0.0/0
    rules_egress:
    - proto: all
      cidr_ip: 0.0.0.0/0

- name: Launching three EC2 instances on AWS
  ec2:
    key_name: "{{ keypair }}"
    instance_type: "{{ instance_flavour }}"
    image: "{{ ami_id }}"
    wait: true
    group: "{{ sg_name }}"
    count: 1
    vpc_subnet_id: "{{ subnet_name }}"
    assign_public_ip: yes
    region: "{{ region_name }}"
    state: present
    aws_access_key: "{{ access_key }}"
    aws_secret_key: "{{ secret_key }}"
    instance_tags:
      Name: "{{ item }}"
  register: ec2
  loop: "{{ instance_tag }}"

- name: Add 1st instance to host group ec2_master
    add_host:
    hostname: "{{ ec2.results[0].instances[0].public_ip }}"
    groupname: ec2_master

- name: Add 2nd instance to host group ec2_slave
  add_host:
    hostname: "{{ ec2.results[1].instances[0].public_ip }}"
    groupname: ec2_slave

- name: Add 3rd instance to host group ec2_slave
  add_host:
    hostname: "{{ ec2.results[2].instances[0].public_ip }}"
    groupname: ec2_slave

- name: Waiting for SSH
  wait_for:
    host: "{{ ec2.results[2].instances[0].public_dns_name }}"
    port: 22
    state: started

Explanation of Source Code:

We are using pip module to install two packages — boto & boto3, because these packages has the capability to contact to AWS to launch the EC2 instances.
ec2_group module to create Security Group on AWS.
ec2 module to launch instance on AWS.

register keyword will store all the Metadata in a variable called ec2 so that in future we can parse the required information from it.

loop which again using one variable which contains one list.

item keyword we are calling the list values one after another.

add_host module which has the capability to create one dynamic inventory while running the playbook.

hostname keyword tells the values to store in the dynamic host group.

wait_for module to hold the playbook for few seconds till all the node’s SSH service started.

access key and secret key are stored inside vault files to hide it from other users.

🔶 Go inside the vars folder. We have to write entire variables inside this folder.

We can directly mention variables inside tasks file but it is good practice to write them inside vars files so that we can change according to our requirements.

cd /roles/kube_cluster/vars

vim main.yml

Write below source code inside it-

instance_tag:
        - master
        - slave1
        - slave2

lib_names:
        - boto
        - boto3

sg_name: Allow_All_SG
region_name: ap-south-1
subnet_name: subnet-49f0e521
ami_id: ami-010aff33ed5991201
keypair: awskey
instance_flavour: t2.small

STEP 4 : Write role for Kubernetes Master

🔶 Following are the steps which have to include in role for configuring the k8s master-

Installing docker and iproute-tc
Configuring the Yum repo for Kubernetes
Installing kubeadm, kubelet & kubectl program
Enabling the docker and Kubernetes
Pulling the config images
Configuring the docker daemon.json file
Restarting the docker service
Configuring the Ip tables and refreshing sysctl
Starting kubeadm service
Setting HOME directory for .kube Directory
Copying file config file
Installing Addons e.g flannel
Creating the token
Store output of token in a file.

🔶 Go inside the tasks folder. We have to write entire tasks inside this folder

cd /roles/k8s_master/tasks

vim main.yml

Write below source code inside it-

- name: "Installing docker and iproute-tc"
  package:
     name:
         - docker
         - iproute-tc
     state: present

- name: "Configuring the Yum repo for kubernetes"
  yum_repository:
     name: kubernetes
     description: Yum for k8s
     baseurl: https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
     enabled: yes
     gpgcheck: yes
     repo_gpgcheck: yes
     gpgkey: https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg

- name: "Installing kubeadm,kubelet kubectl program"
  yum:
     name:
        - kubelet
        - kubectl
        - kubeadm
     state: present

- name: "Enabling the docker and kubenetes"
  service:
     name: "{{ item }}"
     state: started
     enabled: yes
  loop:
        - kubelet
        - docker

- name: "Pulling the config images"
  shell: kubeadm config images pull

- name: "Confuring the docker daemon.json file"
  copy:
    dest: /etc/docker/daemon.json
    content: |
      {
      "exec-opts": ["native.cgroupdriver=systemd"]
      }

- name: "Restarting the docker service"
  service:
     name: docker
     state: restarted

- name: "Configuring the Ip tables and refreshing sysctl"
  copy:
    dest: /etc/docker/daemon.json
    content: |
      {
      "exec-opts": ["native.cgroupdriver=systemd"]
      }

- name: "systemctl"
  shell: "sysctl --system"

- name: "Starting kubeadm service"
  shell: "kubeadm init  --ignore-preflight-errors=all"

- name: "Creating .kube Directory"
  file:
     path: $HOME/.kube
     state: directory

- name: "Copying file config file"
  shell: "cp -i /etc/kubernetes/admin.conf $HOME/.kube/config"
  ignore_errors: yes

- name: "Installing Addons e.g flannel"
  shell: "kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml"

- name: "Creating the token"
  shell: "kubeadm token create --print-join-command"
  register: token

- debug:
       msg: "{{ token.stdout }}"

Explanation of Source Code:

1.We need to install kubeadm program on our master node to setup K8s cluster.

We are installing Docker, Kubeadm & iproute-tc packages on our Master Instance.
service module is used to start the docker & kubelet service.
command module to run kubeadm command which will pull all the Docker Images required to run Kubernetes Cluster.
We need to change our Docker default cgroup to systemd, otherwise kubeadm won't be able to setup K8s cluster. To do that at first using copy module we are creating one file /etc/docker/daemon.json & putting some content in it.
Next using command module we are initializing the cluster & then using shell module we are setting up kubectl command on our Master Node.
Next using command module I deployed Flannel on the Kubernetes Cluster so that it create the overlay network setup.
Also the 2nd command module is used to get the token for the slave node to join the cluster.
Using register I stored the output of 2nd command module in a variable called token. Now this token variable contain the command that we need to run on slave node, so that it joins the master node.

STEP 5 : Write role for Kubernetes Slaves

🔶 Following are the steps which have to include in role for configuring the k8s slaves-

Installing docker and iproute-tc
Configuring the Yum repo for Kubernetes
Installing kubeadm,kubelet kubectl program
Enabling the docker and Kubernetes
Pulling the config images
Configuring the docker daemon.json file
Restarting the docker service
Configuring the IP tables and refreshing sysctl
Copy the join command which we store while configuring master

🔶 Go inside the tasks folder. We have to write entire tasks inside this folder

cd /roles/k8s_slave/tasks

vim main.yml

Write below source code inside it-

- name: "Installing docker and iproute-tc"
  package:
     name:
         - docker
         - iproute-tc
     state: present

- name: "Configuring the Yum repo for kubernetes"
  yum_repository:
     name: kubernetes
     description: Yum for k8s
     baseurl: https://packages.cloud.google.com/yum/repos/kubernetes-el7-\$basearch
     enabled: yes
     gpgcheck: yes
     repo_gpgcheck: yes
     gpgkey: https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg

- name: "Installing kubeadm,kubelet kubectl program"
  yum:
     name:
        - kubelet
        - kubectl
        - kubeadm
     state: present

- name: "Enabling the docker and kubenetes"
  service:
     name: "{{ item }}"
     state: started
     enabled: yes
  loop:
        - kubelet
        - docker

- name: "Pulling the config images"
  shell: kubeadm config images pull

- name: "Confuring the docker daemon.json file"
  copy:
    dest: /etc/docker/daemon.json
    content: |
      {
      "exec-opts": ["native.cgroupdriver=systemd"]
      }

- name: "Restarting the docker service"
  service:
     name: docker
     state: restarted

- name: "Configuring the Ip tables and refreshing sysctl"
  copy:
    dest: /etc/sysctl.d/k8s.conf
    content: |
      net.bridge.bridge-nf-call-ip6tables = 1
      net.bridge.bridge-nf-call-iptables = 1

- name: "systemctl"
  shell: "sysctl --system"

- name: joining to Master
  command: "{{ hostvars[groups['ec2_master'][0]]['token']['stdout'] }}"

STEP 6 : Write role for Wordpress and MySQL Setup

🔶 Following are the steps which have to include in role for configuring the Wordpress-

🔶 Go inside the files folder of wordpress_mysql role. We have to write entire configuration files inside this folder.
🔶 We have to create 5 files here to create pods, setup of PVC and secrets' file.

cd /roles/wordpress_mysql/files

vim wordpress.yml

vim pvc_wordpress.yml

vim mysql.yml

vim pvc_mysql.yml

vim secret.yml

🔶 Write Below source to configure Wordpress installation part inside wordpress.yml file

apiVersion: v1
kind: Service
metadata:
  name: wordpress
  labels:
    app: wordpress
spec:
  ports:
    - port: 80
      nodePort: 30333
  selector:
    app: wordpress
    tier: frontend
  type: LoadBalancer
---
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:
      volumes:
      - name: wordpress-persistent-storage
        persistentVolumeClaim:
          claimName: wordpress-pv-claim
      containers:
      - image: wordpress:4.8-apache
        name: wordpress
        env:
        - name: WORDPRESS_DB_HOST
          value: wordpress-mysql
        - name: WORDPRESS_DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysqlsecret
              key: password
        ports:
        - containerPort: 80
          name: wordpress
        volumes:
        volumeMounts:
        - name: wordpress-persistent-storage
          mountPath: /var/www/html

🔶 Write Below source to setup PVC for Wordpress in pvc_wordpress.yml file.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
   name: wordpress-pv-claim
   labels:
        app: wordpress
        tier: frontend
spec:
   storageClassName: ""
   resources:
        requests:
             storage: 1Gi
   accessModes:
     - ReadWriteOnce
---

apiVersion: v1
kind: PersistentVolume
metadata:
  name: wordpress-pv
spec:
  storageClassName: ""
  capacity:
     storage: 1Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: /wordpressdata

🔶 Write Below source to configure MYSQL installation part inside mysql.yml file

apiVersion: v1
kind: Service
metadata:
  name: wordpress-mysql
  labels:
    app: wordpress
spec:
  ports:
    - port: 3306
  selector:
    app: wordpress
    tier: mysql
  clusterIP: None
---
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:
      volumes:
      - name: mysql-persistent-storage
        persistentVolumeClaim:
          claimName: mysql-pv-claim
      containers:
      - image: mysql:5.6
        name: mysql
        env:
        - name: MYSQL_ROOT_PASSWORD
          valueFrom:
            secretKeyRef:
              name: mysqlsecret
              key: password
        - name: MYSQL_USER
          value: udit
        - name: MYSQL_DATABASE
          value: task23db
        ports:
        - containerPort: 3306
          name: mysql
        volumeMounts:
        - name: mysql-persistent-storage
          mountPath: /var/lib/mysql

🔶 Write Below source to setup PVC for MySQL in pvc_mysql.yml file.

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
   name: mysql-pv-claim
   labels:
        app: wordpress
        tier: mysql
spec:
   storageClassName: ""
   resources:
        requests:
             storage: 1Gi
   accessModes:
     - ReadWriteOnce
---

apiVersion: v1
kind: PersistentVolume
metadata:
  name: msql-pv
spec:
  storageClassName: ""
  capacity:
     storage: 1Gi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: /mysqldata

🔶 Lastly, create a secrete file secret.yml which will contain the password of the MySQL database-

apiVersion: v1
kind: Secret
metadata:
  name: Suraj
data:
   password: Mysqlpass@2001

🔶 Go inside the tasks folder. We have to write entire tasks inside this folder

cd /roles/wordpress_mysql/tasks

vim main.yml

🔶 Write below source code inside it-

  - name: Copying Wordpress and MySQL files to K8s Master Node
    copy:
        src: "{{ item }}"
        dest: /root/
    loop:
        - mysql.yml
        - pvc_mysql.yml
        - pvc_wordpress.yml
        - secret.yml
        - wordpress.yml

  - name: Creating directory over which MySQL container mounts the PersistentVolume at /var/lib/mysql.
    file:
        path: /mysqldata
        state: directory

  - name: Creating directory over which WordPress container mounts the PersistentVolume at /var/www/html.
    file:
        path: /wordpressdata
        state: directory


  - name: Configuration and Setup of Wordpress and MySQL
    shell: "kubectl create -f /root/{{ item }}"
    loop:
        - mysql.yml
        - pvc_mysql.yml
        - pvc_wordpress.yml
        - wordpress.yml

STEP 7 : Write Ansible Vault Files

🔶 Go to your roles workspace
🔶 Run below command and create vault file

# ansible-vault create <filename>.yml

ansible-vault create cred.yml

🔶 It will ask to provide one vault password & provide as per your choice.
🔶 Then, open it with editor, create two variables in this file & put your AWS access key & secret key as values.
For example:

access_key: ABCDEFGHIJKLMN
secret_key: abcdefghijklmn12345

🔶 Save the file with command (:wq).

STEP 8 : Create Setup file

Now it's finally the time to create the setup.yml file inside same workspace which we gonna run to setup this entire infrastructure on AWS.

- hosts: localhost
  gather_facts: no
  vars_files:
         - cred.yml
  tasks:
         - name: "Running kube_cluster role"
           include_role:
                name: kube_cluster


- hosts: ec2_master
  gather_facts: no
  tasks:
    - name: Running K8s_Master Role
      include_role:
        name: k8s_master

- hosts: ec2_slave
  gather_facts: no
  tasks:
    - name: Running K8s_Slave Role
      include_role:
        name: k8s_slave

- hosts: ec2_master
  gather_facts: no
  tasks:
    - name: Running Wordpress-MySQL Role
      include_role:
        name: wordpress_mysql

🔶 Write proper hostname, vault file name and role name.

STEP 9 : RUN your Ansible Playbook

🔶 use below commands to run your ansible playbook.

ansible-playbook setup.yml --ask-vault-pass

🔶 Next it will prompt you to pass the password of your Ansible Vault (cred.yml file), provide your password.

YAY!, IT RUN SUCCESSFULLY AND SETUP ENTIRE INFRASTRUCTURE

STEP 8 : TESTING...

🔶 Now lets check our multi-node cluster is using below commands

kubectl get nodes

🔶 Here we can see our who cluster is launched successfully and our all nodes is ready phase.

🔶 Now once your pods are ready, then you can take the public of any node either master or slave with the exposed port you will landed to the Wordpress login page and then enter password and username of the mysql database and hit the run installation button.

🔶 YAY! Your Wordpress application is ready !!

GitHub Link: https://github.com/surajwarbhe/Ansible-Playbook-K8-Wordpress-MySQL

LinkedIn profile: https://www.linkedin.com/in/suraj-warbhe/

Deploying Multi-Node Kubernetes Cluster on AWS Using Ansible Automation

Suraj Warbhe — Wed, 01 Sep 2021 11:31:55 +0000

USE-CASE

Create Ansible Playbook to launch 3 AWS EC2 Instance
Create Ansible Playbook to configure Docker over those instances
Create Playbook to configure K8S Master, K8S Worker Nodes on the above created EC2 Instances using kubeadm

Pre-requisite: (FOR RHEL-8)

Controller node should be setup with ansible installation and configuration, when controller node is RHEL8
Create one IAM user having Administrator Access and note down their access key and secret key
Create one Key pair in (.pem) format on AWS Cloud, download it in your local system and transfer it over RHEL-8 through WinSCP.

STEP 1 : Ansible Installation and Configuration

Install Ansible on Base OS (RHEL8), configure ansible configuration file.
To do this use below commands-

yum install python3 -y

pip3 install ansible -y

vim /etc/ansible/ansible.cfg

NOTE: Python should be installed on your OS to setup Ansible.
Write below commands in your configuration ansible.cfg file. For this you can prefer any editor like vi, vim, gedit-

[defaults]
inventory=/root/ip.txt  #inventory path
host_key_checking=False
command_warnings=False
deprecation_warnings=False
ask_pass=False
roles_path= /root/roles      #roles path
force_valid_group_names = ignore
private_key_file= /root/awskey.pem   #your key-pair 
remote_user=ec2-user

[privilege_escalation]
become=True
become_method=sudo
become_user=root
become_ask_pass=False

STEP 2 : Create Ansible Roles

🔶 Go inside your roles workspace

cd /roles

Use Below commands to create 3 different roles

For Kubernetes Cluster
For Kubernetes Master
For Kubernetes Slaves

# ansible-galaxy init <role_name>

ansible-galaxy init kube_cluster
ansible-galaxy init k8s_master
ansible-galaxy init k8s_slave

STEP 3 : Write role for Kubernetes Cluster

🔶 Go inside the tasks folder. We have to write entire tasks inside this folder

cd /roles/kube_cluster/tasks

vim main.yml

🔶 I am going to create cluster over Amazon Linux instances.
Write below source code inside it-

- name: Installing boto & boto3 libraries
  pip:
    name: "{{ item }}"
    state: present
  loop: "{{ lib_names }}"

- name: Creating Security Group for K8s Cluster
  ec2_group:
    name: "{{ sg_name }}"
    description: Security Group for allowing all port
    region: "{{ region_name }}"
    aws_access_key: "{{ access_key }}"
    aws_secret_key: "{{ secret_key }}"
    rules:
    - proto: all
      cidr_ip: 0.0.0.0/0
    rules_egress:
    - proto: all
      cidr_ip: 0.0.0.0/0

- name: Launching three EC2 instances on AWS
  ec2:
    key_name: "{{ keypair }}"
    instance_type: "{{ instance_flavour }}"
    image: "{{ ami_id }}"
    wait: true
    group: "{{ sg_name }}"
    count: 1
    vpc_subnet_id: "{{ subnet_name }}"
    assign_public_ip: yes
    region: "{{ region_name }}"
    state: present
    aws_access_key: "{{ access_key }}"
    aws_secret_key: "{{ secret_key }}"
    instance_tags:
      Name: "{{ item }}"
  register: ec2
  loop: "{{ instance_tag }}"

- name: Add 1st instance to host group ec2_master
    add_host:
    hostname: "{{ ec2.results[0].instances[0].public_ip }}"
    groupname: ec2_master

- name: Add 2nd instance to host group ec2_slave
  add_host:
    hostname: "{{ ec2.results[1].instances[0].public_ip }}"
    groupname: ec2_slave

- name: Add 3rd instance to host group ec2_slave
  add_host:
    hostname: "{{ ec2.results[2].instances[0].public_ip }}"
    groupname: ec2_slave

- name: Waiting for SSH
  wait_for:
    host: "{{ ec2.results[2].instances[0].public_dns_name }}"
    port: 22
    state: started

Explanation of Source Code:

We are using pip module to install two packages — boto & boto3, because these packages has the capability to contact to AWS to launch the EC2 instances.
ec2_group module to create Security Group on AWS.
ec2 module to launch instance on AWS.

register keyword will store all the Metadata in a variable called ec2 so that in future we can parse the required information from it.

loop which again using one variable which contains one list.

item keyword we are calling the list values one after another.

add_host module which has the capability to create one dynamic inventory while running the playbook.

hostname keyword tells the values to store in the dynamic host group.

wait_for module to hold the playbook for few seconds till all the node’s SSH service started.

access key and secret key are stored inside vault files to hide it from other users.

🔶 Go inside the vars folder. We have to write entire variables inside this folder.

We can directly mention variables inside tasks file but it is good practice to write them inside vars files so that we can change according to our requirements.

cd /roles/kube_cluster/vars

vim main.yml

Write below source code inside it-

instance_tag:
        - master
        - slave1
        - slave2

lib_names:
        - boto
        - boto3

sg_name: Allow_All_SG
region_name: ap-south-1
subnet_name: subnet-49f0e521
ami_id: ami-010aff33ed5991201
keypair: awskey
instance_flavour: t2.small

STEP 4 : Write role for Kubernetes Master

🔶 Following are the steps which have to include in role for configuring the k8s master-

Installing docker and iproute-tc
Configuring the Yum repo for Kubernetes
Installing kubeadm, kubelet & kubectl program
Enabling the docker and Kubernetes
Pulling the config images
Configuring the docker daemon.json file
Restarting the docker service
Configuring the Ip tables and refreshing sysctl
Starting kubeadm service
Setting HOME directory for .kube Directory
Copying file config file
Installing Addons e.g flannel
Creating the token
Store output of token in a file.

🔶 Go inside the tasks folder. We have to write entire tasks inside this folder

cd /roles/k8s_master/tasks

vim main.yml

Write below source code inside it-

- name: "Installing docker and iproute-tc"
  package:
     name:
         - docker
         - iproute-tc
     state: present

- name: "Configuring the Yum repo for kubernetes"
  yum_repository:
     name: kubernetes
     description: Yum for k8s
     baseurl: https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
     enabled: yes
     gpgcheck: yes
     repo_gpgcheck: yes
     gpgkey: https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg

- name: "Installing kubeadm,kubelet kubectl program"
  yum:
     name:
        - kubelet
        - kubectl
        - kubeadm
     state: present

- name: "Enabling the docker and kubenetes"
  service:
     name: "{{ item }}"
     state: started
     enabled: yes
  loop:
        - kubelet
        - docker

- name: "Pulling the config images"
  shell: kubeadm config images pull

- name: "Confuring the docker daemon.json file"
  copy:
    dest: /etc/docker/daemon.json
    content: |
      {
      "exec-opts": ["native.cgroupdriver=systemd"]
      }

- name: "Restarting the docker service"
  service:
     name: docker
     state: restarted

- name: "Configuring the Ip tables and refreshing sysctl"
  copy:
    dest: /etc/docker/daemon.json
    content: |
      {
      "exec-opts": ["native.cgroupdriver=systemd"]
      }

- name: "systemctl"
  shell: "sysctl --system"

- name: "Starting kubeadm service"
  shell: "kubeadm init  --ignore-preflight-errors=all"

- name: "Creating .kube Directory"
  file:
     path: $HOME/.kube
     state: directory

- name: "Copying file config file"
  shell: "cp -i /etc/kubernetes/admin.conf $HOME/.kube/config"
  ignore_errors: yes

- name: "Installing Addons e.g flannel"
  shell: "kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml"

- name: "Creating the token"
  shell: "kubeadm token create --print-join-command"
  register: token

- debug:
       msg: "{{ token.stdout }}"

Explanation of Source Code:

1.We need to install kubeadm program on our master node to setup K8s cluster.

We are installing Docker, Kubeadm & iproute-tc packages on our Master Instance.
service module is used to start the docker & kubelet service.
command module to run kubeadm command which will pull all the Docker Images required to run Kubernetes Cluster.
We need to change our Docker default cgroup to systemd, otherwise kubeadm won't be able to setup K8s cluster. To do that at first using copy module we are creating one file /etc/docker/daemon.json & putting some content in it.
Next using command module we are initializing the cluster & then using shell module we are setting up kubectl command on our Master Node.
Next using command module I deployed Flannel on the Kubernetes Cluster so that it create the overlay network setup.
Also the 2nd command module is used to get the token for the slave node to join the cluster.
Using register I stored the output of 2nd command module in a variable called token. Now this token variable contain the command that we need to run on slave node, so that it joins the master node.

STEP 5 : Write role for Kubernetes Slaves

🔶 Following are the steps which have to include in role for configuring the k8s slaves-

Installing docker and iproute-tc
Configuring the Yum repo for Kubernetes
Installing kubeadm,kubelet kubectl program
Enabling the docker and Kubernetes
Pulling the config images
Configuring the docker daemon.json file
Restarting the docker service
Configuring the IP tables and refreshing sysctl
Copy the join command which we store while configuring master

🔶 Go inside the tasks folder. We have to write entire tasks inside this folder

cd /roles/k8s_slave/tasks

vim main.yml

Write below source code inside it-

- name: "Installing docker and iproute-tc"
  package:
     name:
         - docker
         - iproute-tc
     state: present

- name: "Configuring the Yum repo for kubernetes"
  yum_repository:
     name: kubernetes
     description: Yum for k8s
     baseurl: https://packages.cloud.google.com/yum/repos/kubernetes-el7-\$basearch
     enabled: yes
     gpgcheck: yes
     repo_gpgcheck: yes
     gpgkey: https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg

- name: "Installing kubeadm,kubelet kubectl program"
  yum:
     name:
        - kubelet
        - kubectl
        - kubeadm
     state: present

- name: "Enabling the docker and kubenetes"
  service:
     name: "{{ item }}"
     state: started
     enabled: yes
  loop:
        - kubelet
        - docker

- name: "Pulling the config images"
  shell: kubeadm config images pull

- name: "Confuring the docker daemon.json file"
  copy:
    dest: /etc/docker/daemon.json
    content: |
      {
      "exec-opts": ["native.cgroupdriver=systemd"]
      }

- name: "Restarting the docker service"
  service:
     name: docker
     state: restarted

- name: "Configuring the Ip tables and refreshing sysctl"
  copy:
    dest: /etc/sysctl.d/k8s.conf
    content: |
      net.bridge.bridge-nf-call-ip6tables = 1
      net.bridge.bridge-nf-call-iptables = 1

- name: "systemctl"
  shell: "sysctl --system"

- name: joining to Master
  command: "{{ hostvars[groups['ec2_master'][0]]['token']['stdout'] }}"

STEP 6 : Write Ansible Vault Files

🔶 Go to your roles workspace
🔶 Run below command and create vault file

# ansible-vault create <filename>.yml

ansible-vault create cred.yml

access_key: ABCDEFGHIJKLMN
secret_key: abcdefghijklmn12345

🔶 Save the file with command (:wq).

STEP 7 : Create Setup file

Now it's finally the time to create the setup.yml file inside same workspace which we gonna run to setup this entire infrastructure on AWS.

- hosts: localhost
  gather_facts: no
  vars_files:
         - cred.yml
  tasks:
         - name: "Running kube_cluster role"
           include_role:
                name: kube_cluster


- hosts: ec2_master
  gather_facts: no
  tasks:
    - name: Running K8s_Master Role
      include_role:
        name: k8s_master

- hosts: ec2_slave
  gather_facts: no
  tasks:
    - name: Running K8s_Slave Role
      include_role:
        name: k8s_slave

🔶 Write proper hostname, vault file name and role name.

STEP 8 : RUN your Ansible Playbook

🔶 use below commands to run your ansible playbook.

ansible-playbook setup.yml --ask-vault-pass

🔶 Next it will prompt you to pass the password of your Ansible Vault (cred.yml file), provide your password.

YAY!, IT RUN SUCCESSFULLY AND SETUP ENTIRE INFRASTRUCTURE

STEP 9 : TESTING...

🔶 Now lets check our multi-node cluster is using below commands

kubectl get nodes

🔶 Here we can see our who cluster is launched successfully and our all nodes is ready phase.

🔶 Now lets create a deployment on master node

kubectl create deployment myd --image=httpd

🔶 here we can see our deployment is created successfully

GitHub Link: https://github.com/surajwarbhe/K8s-master-slave-on-aws

LinkedIn profile: https://www.linkedin.com/in/suraj-warbhe/

Ansible Playbook that will configure Docker & dynamically update the inventory with newly created Docker Container IP

Suraj Warbhe — Tue, 31 Aug 2021 07:51:56 +0000

STEPS: (For RHEL 8)

Enable SSH in the Container using Dockerfile
Build and Push this image to the Docker Hub
Ansible Play that will launch and configure the Docker Container and webserver inside it

STEP 1: Enable SSH in the Container using Dockerfile

Dockerfile has two types of keyword that helps to configure Image.

Build Time: Executes at build time and in the build phase all run time commands are skipped. examples are FROM, RUN, etc.
Run Time: Run time commands are ENTRYPOINT, CMD, etc.

DockerFile

It is compulsory to give the docker/image file name as Dockerfile.

To use Base OS from container Image: Dockerfile Keyword: FROM

FROM centos:latest

To run OS Specific command: Dockerfile keyword: RUN

RUN yum install openssh-server -y

Installing OpenSSH-server

RUN yum install openssh-server -y

Configure SSH Server for password authentication By Default password authentication is disabled we need to add the below string in the SSHd service configuration file to enable password authentication.

RUN echo "PasswordAuthentication yes" >> /etc/ssh/sshd_config

Generating Keys For each of the key types (RSA, DSA, ECDSA, and ED25519) for which host keys do not exist, generate the host keys with the default key file path, an empty passphrase, default bits for the key type, and default comment.

RUN ssh-keygen -A

Changing the Password of the root user chpasswd command is used to change the password although passwd command can also do the same. But it changes the password of one user at a time so for multiple users, chpasswd is used.

# RUN echo "user_name:password" | chpasswd
RUN echo "root:centos" | chpasswd

Default password for this image will be centos

To start service at runtime

CMD ["/usr/sbin/sshd", "-D"]

Final Image:

FROM centos:latest
RUN yum install openssh-server -y
RUN yum install openssh-server -y
RUN echo "PasswordAuthentication yes" >> /etc/ssh/sshd_config
RUN ssh-keygen -A
RUN echo "root:centos" | chpasswd
CMD ["/usr/sbin/sshd", "-D"]

STEP 2 : Build and push Docker Image to the Docker Hub

Use below command this build your created image

docker build -t dockerhub_id/imagename:image_version fileLocation

To push the image to the Docker registry.

First, we need to give a username and password of the Docker Hub
For this run the below command-

docker login

Then run below command to push your created Image

docker push dockerhub_id/imagename:image_version

You can use my Docker Image to perform further task.
To Pull my Docker image, use below command-

docker pull surajwarbhe/ssh_centos:v1

STEP 3 : Ansible Configuration and Playbooks

1. Create an Inventory file

🔶 Create an inventory file with the extension (.txt) and leave it blank.

vim ip.txt

2. Create Ansible Configuration file

🔶 Create a file with the extension (.cfg) in the directory /etc/ansible/, here I have a configuration file with named ansible.cfg

vim  /etc/ansible/ansible.cfg

🔶 Write below statements in the configuration file.

[defaults]
inventory=/root/ip.txt
host_key_checking=false
deprecation_warnings=false
command_warnings=false

3. Create and Run Ansible Playbook (To setup Docker)

🔶 Create an Ansible playbook with an extension (.yml) or (.yaml), here I have created a playbook with named dockertask.yaml

- hosts: localhost
  vars_prompt:
      - name: container_name
        prompt: "Docker Container Name: "
        private: no

  vars:
          - image_name: surajwarbhe/ssh_centos:v1

  tasks:
      - name: Creating Repo for yum
        yum_repository:
            name: docker
            file: docker
            description: Docker Yum Repo
            baseurl: https://download.docker.com/linux/centos/7/x86_64/stable/
            gpgcheck: no

      - name: Installing Python3...
        command: "yum -y install python3"
      - name: Installing Docker Software...
        command: "yum install -y  docker-ce --nobest"

      - name: Starting Docker services...
        service:
            name: "docker"
            state: started
            enabled: yes

      - name: Installing Docker Library...
        command: "pip3 install docker-py"

      - name: pull an image
        docker_image:
            name: "{{ image_name }}"
            source: pull

      - name: "Launching {{ container_name }} Container"
        docker_container:
            name: "{{ container_name }}"
            image: "{{ image_name }}"
            state: started
            interactive: yes
            detach: yes
            tty: yes

      - name: "Container Info"
        docker_container_info:
            name: "{{ container_name }}"
        register: dinfo

      - name: "Printing IP of Docker container..."
        debug:
              msg: "{{ dinfo.container.NetworkSettings.IPAddress}}"

      - name: updating ansible inventory  with new docker info.......
        blockinfile:
            path: "/root/ip.txt"
            block: |
                    [docker]
                    {{ dinfo['container']['NetworkSettings']['IPAddress'] }} ansible_user=root ansible_ssh_pass=centos  ansible_connection=ssh

  handlers:
  - name: docker
    yum:
        name: docker-ce
        state: present
        allow_downgrade: yes
        skip_broken: yes

🔶 To run the playbook use the below command-

# ansible-playbook <filename>

ansible-playbook dockertask.yaml

Initially, it will ask us container name.
I have provided container name as Arth14

Yesss, Our playbook run successfully !

And we got a IP address of newly created Docker Container as 172.17.0.3

🔶 Let’s Check ip.txt file
Earlier, we had leave ip.txt as empty but now it is updated dynamically with newly created IP address Docker container.

STEP 4 : Check connectivity with Docker Container

We have to check ansible connectivity with newly created Docker Container so that we can perform SSH and perform further operations on that.
Use below command to check connectivity-

ansible all -m ping

If you get Success message in a green color and Ping Pong at the end, it means everything is OKAY!

STEP 5 : Configuration of Apache Webserver, Copying the testing Page, and Starting the Apache web service

🔶 Create an Ansible playbook with an extension (.yml) or (.yaml), here I have created a playbook with named webserver.yaml

- hosts: docker
  tasks:
    - name: "Installing Httpd service"
      package:
          name: "httpd"
          state: present

    - name: "Creating html file"
      copy:
          content : "<b><center>HEY! TASK 14.2 Done successfully </center></b>"
          dest: "/var/www/html/index.html"

    - name: "Starting Httpd Service"
      command: "/usr/sbin/httpd"

🔶 To run the playbook use the below command-

# ansible-playbook <filename>

ansible-playbook webserver.yaml

Yesss, Our playbook run successfully !

STEP 6 : Testing

Use below command to test your configuration OR you can directly type your Docker container's IP address over Browser-

# curl <ip_address_of_Docker_container>

curl 172.17.0.3

YAY! The Web-Server is configured successfully inside Container. 💥💥

GitHub Link: https://github.com/surajwarbhe/Ansible-Webser-inside-Docker-Container

Creating a Helm Chart for Grafana

Suraj Warbhe — Thu, 26 Aug 2021 07:32:45 +0000

What's Minikube ?

minikube is a tool that lets you run Kubernetes locally. minikube runs a single-node Kubernetes cluster on your personal computer (including Windows, macOS and Linux PCs) so that you can try out Kubernetes, or for daily development work.

🔸 Start the Minikube

minikube start --vm-driver=none

🔸 Our single node cluster is ready to use so run the below command to check the minikube status

minikube status

💠 you will get output such as:

C:\Users\Asus_1\minikube status
minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

Setup has been completed...
But before creating it, let's try to understand Helm and Grafana.

What's Grafana ?

Grafana is a multi-platform open source analytics and interactive visualization web application. It provides charts, graphs, and alerts for the web when connected to supported data sources and End users can create complex monitoring dashboards using interactive query builders. Grafana is divided into a front end and back end, written in TypeScript and Go, respectively.

What is Helm?

In simple terms, Helm is a package manager for Kubernetes. Helm is the K8s equivalent of yum or apt. Helm deploys charts, which you can think of as a packaged application. It is a collection of all your versioned, per-configured application resources which can be deployed as one unit. You can then deploy another version of the chart with a different set of configuration.

Helm helps in three key ways:
🔷 Improves productivity
🔷 Reduces the complexity of deployments of micro services
🔷 Enables the adaptation of cloud native applications

Why we need Helms?

Writing and maintaining Kubernetes YAML manifests for all the required Kubernetes objects can be a time-consuming and tedious task. For the simplest of deployments, you would need at least 3 YAML manifests with duplicated and hard-coded values. Helm simplifies this process and creates a single package that can be advertised to your cluster.

What are Charts?

In Kubernetes, we package all the running resources in a zip file known as the chart. A Helm chart can contain any number of Kubernetes objects, all of which are deployed as part of the chart. A Helm chart will usually contain at least a Deployment and a Service, but it can also contain an Ingress, Persistent Volume Claims, or any other Kubernetes object.

Installing Helm

🔷 Helm had the client-server architecture till version 2, We have to need to install a server-side program Tiller in the Kubernetes cluster.

🔷 In version 3 helm provides more facilities i.e. install helm on the client-side only. It provides more security than version 2. We can install helm in Mac, Windows, and Linux.

🔷 The URL where you can download helm according to your operating system. Link

🔷 In windows after downloading the helm, we got a zip file,
Extract the zip and go to folder that will come after extracting

🔷 Copy the path and add it into the environment variable because in the command line everywhere we can do access helm.

🔷 To check the helm installation run the command

helm version

💠 you will get output such as:

C:\Users\Asus_1>helm version
version.BuildInfo{Version:"v3.6.3", GitCommit:"d506314abfb5d21419df8c7e7e68012379db2354", GitTreeState:"clean", GoVersion:"go1.16.5"}

After successfully done the installation part, let’s create a chart for Grafana.

Create a Helm Chart

let's create a new Helm Chart from the scratch. Helm created a bunch of files for you that are usually important for a production-ready service in Kubernetes. To concentrate on the most important parts, we can remove a lot of the created files. Let’s go through the only required files for this example.

🔸 Create a Helm Chart for Grafana.

mkdir grafana
cd grafana

💠 But here we need a project file that is called Chart.yaml and contains all the metadata information.
🔸 So, create this file. Also, C should be capital in the Chart.yaml.
For Windows:

notepad Chart.yaml

For Linux:

vim Chart.yaml

🔸 Write the below code inside Chart.yaml.

apiVersion: v1
name: Grafana
description: A Helm chart to setup Grafana
type: application
version: 0.1.0
appVersion: 0.1.0

🔸 Make a templates folder inside grafana and go inside it.

mkdir templates
cd templates

🔸 You can use my image to download Docker image of Grafana.

https://hub.docker.com/repository/docker/surajwarbhe/grafana

🔸 Use below command to pull my docker image.

docker push surajwarbhe/grafana:v1

🔸 Use this command to create a code of the deployment.yaml file.

kubectl create deployment grafana --image=surajwarbhe/grafana:v1 --dry-run -o yaml > deployment.yaml

💠 The output should be similar to the following:

C:\Users\Asus_1\grafana\templates>kubectl create deployment grafana --image=surajwarbhe/grafana:v1 --dry-run -o yaml > deployment.yaml
W0826 09:59:25.756492    1640 helpers.go:535] --dry-run is deprecated and can be replaced with --dry-run=client.

🔸 Go outside the grafana directory and install the helm chart.

cd 
helm install grafana grafana/

NOTE: Here grafana is the name of Helm Chart and grafana/ is the path of the chart.
💠 After running above command, the output should be similar to the following:

C:\Users\Asus_1>helm install grafana grafana/
NAME: grafana
LAST DEPLOYED: Thur Aug 26 10:25:45 2021
NAMESPACE: default
STATUS: deployed
REVISION: 1
TEST SUITE: None

🔸 Now again go inside grafana/templates and use the below command to create a code of the service.yaml file.

cd grafana/templates/
kubectl expose deployment grafana --port=3000 --type=NodePort --dry-run -o yaml > service.yaml

💠 The output should be similar to the following:

C:\Users\Asus_1\grafana\templates>kubectl expose deployment grafana --port=3000 --type=NodePort --dry-run -o yaml > service.yaml
W0826 10:03:55.911918    6892 helpers.go:535] --dry-run is deprecated and can be replaced with --dry-run=client.

🔸 After it, run the below command for exposing the grafana pod.

kubectl apply -f service.yaml

💠 To ensure your pod is working well with the below commands.

kubectl get pods
kubectl get deployment
kubectl get svc

💠 After running these commands, the output should be similar to the following:

🔸 You can check the list of the helm you have using the helm list command. Now we can check the pods in which slaves are running in the Kubernetes cluster.

C:\Users\Asus_1>helm list
NAME            NAMESPACE       REVISION        UPDATED                                         STATUS          CHART                   APP VERSION
grafana         default         1               2021-08-25 09:38:04.967518153 -0400 -0400       deployed        Grafana-0.1.0           0.1.0

🔸 After running the command pick the port number that has been exposed Grafana service. And also run one more command if you run a single node cluster minikube.

minikube ip

So let's check that Grafana is working fine or not. For this, you have to take the minikube_ip and port no. of your pod.

eg. 192.168.99.102:30147

💠 After browsing it, login page will pop up. So login with by-default username and password admin.

🔸 After logging you will get the page for changing the username and password, So you can if you want.

Packing resources inside the Helm Chart.

So helm chart ready inside the grafana/ directory, but we can’t publish it as it is. Firstly, we have to create a package for this helm chart.

🔸 Create one directory named charts. Make sure this directory should be inside grafana directory.

mkdir charts

🔸 Now, run the following command to packages the chart and store it inside the charts/ directory.

helm package C:\Users\Asus_1\grafana -d charts\

💠 you will get output something like this:

Successfully packaged chart and saved it to: charts/Grafana-0.1.0.tgz

Creating an index.yaml file
For every Helm repository, we must require an index.yaml file. The index.yaml file contains the information about the chart that is present inside the current repository/directory.

🔸 For generating index.yaml file inside charts/ directory, run following command.

helm repo index charts/

Pushing the charts in the GitHub repository

🔸 Create a new repository in GitHub and upload charts/ source code into the GitHub repository.

Hosting Chart using Github Pages

🔸 We must require a URL where we had hosted our helm chart for publishing the Helm chart on artifacthub.io/. 🔸 One of the ways to host the charts is using GitHub pages.
🔸 So, we will first host our charts using GitHub pages.
🔸 Go to the settings of your Github repository and go down where you can see the GitHub Pages section.
🔸 Select main as a branch and click on save.

Publishing helm chart on artifact hub

🔸 Go to this URL artifacthub.io/

🔸 Sign in with your account if you have otherwise you have to need to create an account.

🔸 After signed in successfully, In the right top corner click on the face you have seen.

🔸 Now click on profile icon > control Panel> Add repository.

NOTE: Make sure your repository's url should be like https://username.github.io/repository_name/chart/ when you're adding repository in ArtifactHub. Otherwise, it can create some issues related to url.

🔸 After giving the required information to your Helm repository, click on Add. if you had provided the right information then it will create a Helm repository.

So, we had successfully published our Helm chart to the ArtifactHub.

Conclusion

In this tutorial, you created a helm chart for installing GRAFANA and How to upload our repository on ArtifactHub.

Keep learning keep sharing
Thank You

DEV Community: Suraj Warbhe

Launching WordPress on AWS with RDS

USE-CASE

Pre-requisite:

STEP 1 : Create an EC2 Instance

STEP 2 : Configure the Instance with Apache Webserver

STEP 3 : Installation and configuration of php software name WordPress

Note:

STEP 4 : Setup a MySQL server using AWS RDS service with Free Tier Account

STEP 5 : Provide the Endpoint/Connection string to the WordPress Application

Successfully done! We have Login in to WordPress and we can continue to write Blogs etc., All your Data will Be stored in RDS MySQL DB.

Automating Kubernetes Cluster on AWS using Ansible and deploying WordPress with MySQL on k8s cluster

USE-CASE

Pre-requisite: (FOR RHEL-8)

STEP 1 : Ansible Installation and Configuration

STEP 2 : Create Ansible Roles

STEP 3 : Write role for Kubernetes Cluster

Explanation of Source Code:

STEP 4 : Write role for Kubernetes Master

Explanation of Source Code:

STEP 5 : Write role for Kubernetes Slaves

STEP 6 : Write role for Wordpress and MySQL Setup

STEP 7 : Write Ansible Vault Files

STEP 8 : Create Setup file

STEP 9 : RUN your Ansible Playbook

YAY!, IT RUN SUCCESSFULLY AND SETUP ENTIRE INFRASTRUCTURE

STEP 8 : TESTING...

🔶 Here we can see our who cluster is launched successfully and our all nodes is ready phase.

GitHub Link: https://github.com/surajwarbhe/Ansible-Playbook-K8-Wordpress-MySQL

LinkedIn profile: https://www.linkedin.com/in/suraj-warbhe/

Deploying Multi-Node Kubernetes Cluster on AWS Using Ansible Automation

USE-CASE

Pre-requisite: (FOR RHEL-8)

STEP 1 : Ansible Installation and Configuration

STEP 2 : Create Ansible Roles

STEP 3 : Write role for Kubernetes Cluster

Explanation of Source Code:

STEP 4 : Write role for Kubernetes Master

Explanation of Source Code:

STEP 5 : Write role for Kubernetes Slaves

STEP 6 : Write Ansible Vault Files

STEP 7 : Create Setup file

STEP 8 : RUN your Ansible Playbook

YAY!, IT RUN SUCCESSFULLY AND SETUP ENTIRE INFRASTRUCTURE

STEP 9 : TESTING...

🔶 Here we can see our who cluster is launched successfully and our all nodes is ready phase.

GitHub Link: https://github.com/surajwarbhe/K8s-master-slave-on-aws

LinkedIn profile: https://www.linkedin.com/in/suraj-warbhe/

Ansible Playbook that will configure Docker & dynamically update the inventory with newly created Docker Container IP

STEPS: (For RHEL 8)

STEP 1: Enable SSH in the Container using Dockerfile

DockerFile

Final Image:

STEP 2 : Build and push Docker Image to the Docker Hub

To push the image to the Docker registry.

STEP 3 : Ansible Configuration and Playbooks

1. Create an Inventory file

2. Create Ansible Configuration file

3. Create and Run Ansible Playbook (To setup Docker)

STEP 4 : Check connectivity with Docker Container

STEP 5 : Configuration of Apache Webserver, Copying the testing Page, and Starting the Apache web service

STEP 6 : Testing

GitHub Link: https://github.com/surajwarbhe/Ansible-Webser-inside-Docker-Container

Creating a Helm Chart for Grafana

What's Minikube ?

What's Grafana ?

What is Helm?

Why we need Helms?

What are Charts?

Installing Helm

Create a Helm Chart

Packing resources inside the Helm Chart.

Pushing the charts in the GitHub repository

Hosting Chart using Github Pages

Publishing helm chart on artifact hub

Conclusion

STEP 3 : Installation and configuration of php software name `WordPress`