Forem: Sagar Jadhav

Deploy a Microservice in Kubernetes with zero lines of code

Sagar Jadhav — Wed, 22 Sep 2021 05:26:51 +0000

In general, To deploy a Microservice in Kubernetes you have to perform the following tasks:

Build a Docker Image of a Microservice
Push that Docker Image into an Image Registry
Create a YAML's for different Kubernetes objects such as Deployment, Service, Secret, etc.
Apply those YAMLs using the following command:

   kubectl apply -f <FILE_NAME>

All the above tasks require you to write a lot of code. What If I do all this in a single command?

Yes, It is possible. Using gopaddle you can deploy a Microservice in Kubernetes without writing any extra code in just one command.

Let me show you How?

Before you start deploying, finish the below prerequisites:

I. Sign up for a free trial account in gopaddle

II. Import a Google Kubernetes Engine (GKE) into your gopaddle account.

III. Add an Image Registry in your gopaddle account.

IV. Add a source code repository in your gopaddle account that will have a source code of a Microservice that you want to deploy in Kubernetes. For this blog, I have used node-hello repository.

V. Install gpctl CLI using the below commands:

wget https://gpctl.s3-ap-southeast-1.amazonaws.com/gpctl

chmod +x gpctl

cp gpctl /usr/local/bin/

Note: Refer Official Documentation for more details.

Gear up yourself to deploy a Microservice in Kubernetes

Follow the below steps along with me.

I. Clone node-hello git repository using the following command:

git clone https://github.com/developersthought/node-hello.git

II. Go to the node-hello directory using the following command:

cd <path_to_node_hello_repo>/

III. Install dependencies using the following command:

sh buildScript.sh

IV. log in to gopaddle account using the following command:

gpctl login -emailID=<EMAIL> --password=<PASSWORD> --endPoint=https://portal.gopaddle.io

EMAIL: Email to connect to gopaddle account
PASSWORD: Password to connect to gopaddle account

V. Deploy Microservice in Kubernetes using the following command:

gpctl init --startScript=./runScript.sh --buildScript=./buildScript.sh --buildImage=node:8

The above command will prompt you to select the Cluster, Registry, and Policy. Please select appropriately to proceed further.

That's it !! with this, you have deployed a Microservice in Kubernetes without writing any deployment code.

Hope you like this blog and find it useful, If Yes then do consider buying me a coffee.

Introduction to Docker Compose

Sagar Jadhav — Sat, 07 Aug 2021 11:16:59 +0000

➡️ If you are running a multi-container application using Docker and looking for a solution to easily manage the application without any hustle then do check out my new YouTube video on Docker Compose.

➡️ I have covered the following in this video:

Create a custom network with the driver of type bridge in Docker
Run MySQL database in Docker Container
Run PHPMyAdmin application in Docker Container
Remove both MySQL & PHPMyAdmin Docker Container
Remove custom network
What is Docker Compose?
What is Infrastructure As A code?
Create a docker-compose.yaml
Run MySQL database and PHPMyAdmin docker containers using Docker Compose
Remove MySQL database and PHPMyAdmin docker containers using Docker Compose

➡️ You could buy me a coffee If you like the video and find it useful.

➡️ You can refer docker-compose.yaml here

A quick guide on How to extend kubectl with plugins?

Sagar Jadhav — Sat, 19 Jun 2021 05:31:33 +0000

kubectl
What is a plugin?
Why write a plugin?
- Restart a Pod
How to write a plugin?
Demo
Notes
Show Your Support

kubectl

kubectl is a command-line interface (CLI) used to interact with the Kubernetes cluster. With the help of kubectl you can perform the following operations on the Kubernetes cluster:

Deploy & Manage containerize application.
Connect to multiple Kubernetes clusters.
Get Kubernetes cluster information.
Many more...

Visit here for more detail on kubectl.

What is a plugin?

kubectl plugin is a standalone executable file used to enhance the functionality of kubectl with new subcommands.
With plugins, you can add new features to kubectl as per your requirement.

Why write a plugin?

To build a complex use case using existing kubectl commands. Let us understand this with the following use case:

Restart a Pod

To restart a Pod you can use the following methods:

Method 1:

Retrieve the Pod name using the following command:

kubectl get pods

Delete the Pod using the following command:

kubectl delete pod <POD_NAME>

Method 2:

Retrieve the Deployment name using the following command:

kubectl get deployment

Scale down the replica to zero using the following command:

kubectl scale --replicas=0 deploy/<DEPLOYMENT_NAME>

Scale up the replica to one using the following command:

kubectl scale --replicas=1 deploy/<DEPLOYMENT_NAME>

Note: Both the methods are valid only If Pod is created through Deployment.

In both the methods to restart a Pod You have to execute multiple kubectl commands. But can you achieve the same using a single command? The answer is YES. Through plugins, you can wrap the above kubectl commands into a single command. For example, You can have a command like kubectl restart pod nginx where nginx is the name of the Deployment.

How to write a plugin?

Let us understand the whole process step by step by writing a plugin for the Restart a Pod use case.

Create a file called kubectl-restart-pod.sh by using the following command:

touch kubectl-restart-pod.sh

Add the following content into the kubectl-restart-pod.sh file:

#!/bin/bash

# Logging script execution start
echo "-------------------------"

DEPLOYMENT=$1
NAMESPACE=default

if [ ! -z $2 ]; then
 if [ $2 == "-n" ]; then
    NAMESPACE=$3
  fi
fi


# Logging name of the Deployment
echo "Deployment: $DEPLOYMENT"

# Logging name of the Namespace
echo "Namespace: $NAMESPACE"

# Retrieving Deployment
DEPLOYMENT_DETAILS={}

{
 DEPLOYMENT_DETAILS=$(kubectl get deploy $DEPLOYMENT -o json -n $NAMESPACE)
} || {
 echo "-------------------------"
 exit 1
}

# Retrieving the current replicas
CURRENT_REPLICAS=$(echo $DEPLOYMENT_DETAILS | jq .spec.replicas)

# Retrieving the labels
LABELS=$(echo $DEPLOYMENT_DETAILS | jq .spec.selector.matchLabels)
LABEL=$(echo $LABELS | jq -r 'to_entries|map("\(.key)=\(.value|tostring)")|.[0]')

# Scaling down the replicas
echo "Scaling down the replicas to 0"
kubectl scale --replicas=0 deploy/$DEPLOYMENT -n $NAMESPACE

while true; do

    PODS_COUNT=$(kubectl get po -l $LABEL -n $NAMESPACE -o json | jq '.items | length')

    if [ $PODS_COUNT == 0 ]; then
        break
    else
        printf "."
        sleep 5
    fi

done

# Scaling up the replicas
echo ""
echo "Scaling up replicas to $CURRENT_REPLICAS"
kubectl scale --replicas=$CURRENT_REPLICAS deploy/$DEPLOYMENT -n $NAMESPACE

while true; do

    INDEX=0
    RUNNING_COUNT=0
    PODS=$(kubectl get po -l $LABEL -n $NAMESPACE -o json | jq .items)

    while [ $INDEX -lt $CURRENT_REPLICAS ]; do
        PHASE=$(echo $PODS | jq -r --arg index $INDEX '.[$index | tonumber].status.phase')

        if [ $PHASE == "Running" ]; then
            RUNNING_COUNT=$((RUNNING_COUNT + 1))
        fi

        INDEX=$((INDEX + 1))
    done

    if [ $RUNNING_COUNT == $CURRENT_REPLICAS ]; then
        break
    else
        printf "."
        sleep 5
    fi

done

# Logging script execution end
echo ""
echo "-------------------------"

Refer to source code here.

Make kubectl-restart-pod.sh file executable by using the following command:

chmod +x kubectl-restart-pod.sh

Move kubectl-restart-pod.sh file to /usr/local/bin directory by using following command:

mv kubectl-restart-pod.sh /usr/local/bin/kubectl-restart-pod

Demo

Install jq on the workstation machine, where you can access the Kubernetes cluster. Visit here for steps to install jq.
List all the available plugins by using the following command:

kubectl plugin list

kubectl-restart-pod plugin should list in the output.

Create namespace demo by using the following command:

kubectl create ns demo

Deploy nginx application on Kubernetes cluster by using the following command:

kubectl create deploy nginx --image=nginx:latest -n demo

Check the status of nginx Pod by using the following command:

kubectl get po -n demo

nginx Pod should be in the Running state.

Restart the nginx Pod by using the following command:

kubectl restart pod nginx -n demo

Notes

As a prerequisite, you should have kubectl CLI installed on your workstation machine, where you can access the Kubernetes cluster. Visit here for steps to install kubectl CLI.
Name of the plugin standalone executable file should start with kubectl- for example kubectl-restart-pod.sh
You cannot override the existing kubectl command using plugins for example you cannot create a plugin kubectl-delete-pod. If you create such plugin then it will be ignored when you run kubectl delete pod command.

Show Your Support

Buy me a coffee If you like the content and find it useful.
Report an issue here If you find a bug or want to improve the content.

Demystify Pointers in Go

Sagar Jadhav — Wed, 21 Apr 2021 05:46:04 +0000

Introduction
Pass By Value
Pointer in Action
Pointer Receiver

Introduction

Pointers is Go is one of the most complex concepts especially for beginners. In this blog, I have explained the Pointers in a very simple format through visualization and point-by-point explanation. Please read the full blog for complete understanding. To start with let me give you the definition of Pointers:
Pointer stores the memory address of the variable instead of the value of a variable.

This makes it different from other types of variables.

Pass By Value

Let me explain to you the concept of Pass By Value before going deep in understanding Pointers. If you understand this then It will help you in understanding the code with extensive use of Pointers. In Pass By Value the value of a variable is copied into the calling method argument instead of the reference or memory address of the variable. Just remember this simple formula:
Go always follows Pass By Value and not Pass By Reference

Let's see How Pass By Value works in Go.

Variable x of type string is defined and the value "Sagar" is assigned to it.
Method addSurname() is called with x, Here the value of x that is "Sagar" is copied to variable y
String "Jadhav" is appended to the value of y and the result is assigned back to y.

So updating the value of y doesn't update the value of x as both are different variables but storing the same value.

Pointer in Action

In the above example How to change the value of x by updating the value of y? Here Pointers come into the action. Yes, It is possible to update the value of one variable through other variables with the help of Pointers. Let me explain you through the below example:

Variable x of type string is defined and the value "Sagar" is assigned to it.
Variable y of type string pointer is defined and the address of x is assigned to it.
Method addSurname() is called with y, Here the value of y that is the address of x is copied to variable z.
String "Jadhav" is appended to the value at address stored in z and the result "Sagar Jadhav" is assigned back to the variable at the address stored in z. Sounds complicated, Map this point with the above picture for better understanding.

Pointer Receiver

The use of Pointer with Structs is very common, Hence understanding this concept is a must. Let's get deep-dive through the below example:

Variable emp of type employee struct is defined and the property Name is initialized with value "Sagar".
Method Receiver addTitle() is called with string "Mr.", Here the string "Mr." is copied to variable t.
Value of Name property is appended to Value of t and the result "Mr. Sagar" is assigned back to the Name property. But here the Name property of emp is not updated because addTitle() is a method receiver so when it is called, Value of emp variable is copied to another variable e. So any update e will not affect emp.
Pointer receiver addSurname() is called with string "Jadhav", Here the string "Jadhav" is copied to variable s.
Value of s is appended to the value of Name property and the result "Sagar Jadhav" assigned back to the Name property. Here emp variable is updated because variable e is a pointer to emp so any changes in e will also affect emp.

Checkout here for more details.

How to effectively Tag a Cloud Resource?

Sagar Jadhav — Tue, 26 Jan 2021 13:28:22 +0000

Introduction
Types of Tagging
- I. Automated Tagging
- II. Manual Tagging
Tagging Best Practices
Why Tag a Cloud Resource?
Demo
- Add timestamp tag to EC2 instance through Terraform
- Add env tag to EC2 instance through AWS Console
Glossary
- Cloud Resource
- Provision

Introduction

Labeling a Cloud Resource in key:value format is known as Tagging. Labels should contain meaningful information. For e.g. To mark the EC2 instance as a production environment you can tag it with the label env:prod.

Types of Tagging

I. Automated Tagging

Automated Tagging is a method of adding machine-generated Tag to Cloud Resource at the time of provisioning. You can use Automated Tagging in case of provisioning a Cloud Resource through an automation tool like Terraform.

Examples:

user:sagar: A user who provisioned the Cloud Resource.
timestamp:06/01/22 04:11:05: Time of provisioning.
id:12456: Unique identifier of the Cloud Resource.
group:finance: A group that owns the Cloud Resource.

II. Manual Tagging

Manual Tagging is a method of adding Tag manually to Cloud Resource at the time of provisioning. You can use Manual Tagging in case of provisioning a Cloud Resource through UI.

Examples:

purpose:poc: The purpose behind provisioning a Cloud Resource.
env:prod: Name of the environment where the Cloud Resource is provisioned.
cleanup:yes: Delete a Cloud Resource after certain days.

Tagging Best Practices

Use a small case.
Don't use any special character especially @.
Use underscore _ instead of space.

Why Tag a Cloud Resource?

To group Cloud Resources. For e.g. If an application has multiple Cloud Resources then you can tag them with the label app:myapp.
To delete Cloud Resources after certain days. For e.g. You can implement a policy that Cloud Resources will be automatically deleted after 7 days If they are tagged with a cleanup:yes label.
For audit purposes. For e.g. You can generate a User per Cloud Resource report i.e How many Cloud Resources are owned by a particular User? By looking at the owner:sagar Tag.

Demo

Let us understand Automated & Manual Tagging through the following examples:

Add `timestamp` tag to EC2 instance through Terraform

In this example, you will learn How to add the timestamp tag to the EC2 instance through Terraform at the time of provisioning. Check out documentation to configure AWS connection before proceeding with the below steps.

I. Create a file called main.tf and add the below content to it

data "aws_ami" "ubuntu" {
  most_recent = true

  filter {
    name   = "name"
    values = ["ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-*"]
  }

  filter {
    name   = "virtualization-type"
    values = ["hvm"]
  }

  owners = ["099720109477"] # Canonical
}

resource "aws_instance" "web" {
  ami           = data.aws_ami.ubuntu.id
  instance_type = "m1.small"

  tags = {
    Name = "automatedtaggedvm"
    timestamp = "${timestamp()}"
  }
}

II. Run terraform init command

III. Run terraform plan command

IV. Run terraform apply command

V. Verify EC2 instance provisioned with timestamp Tag

Add `env` tag to EC2 instance through AWS Console

In this example, you will learn How to add the env tag to the EC2 instance through AWS Console at the time of provisioning.

I. Login to AWS Console

II. Launch EC2 instance and add env Tag as follows:

III. Verify EC2 instance provisioned with env Tag

Glossary

Cloud Resource

A resource deployed in Cloud. For e.g. EC2 instance, SNS service, Managed Kubernetes Service, etc.

Provision

A process of deploying or creating Cloud Resources in Cloud. For e.g. Launching EC2 instance in AWS.

12 Useful OpenShift Commands You Should Know

Sagar Jadhav — Sat, 09 Jan 2021 06:48:03 +0000

Introduction

Redhat OpenShift is a Container Management and a Hybrid Cloud Platform. It gives you the ability to develop and run containerized applications along with OOTB integration with existing DevOps tools. Checkout OpenShift documentation for more details.

OC CLI is used to perform various operations on OpenShift. It is similar to kubectl CLI and offers all the operations that you can perform with kubectl CLI plus additional support for native OpenShift features. Checkout OC CLI documentation for more details.

12 Useful OpenShift Commands

I. Create Service Account testsa

oc create sa testsa

II. Add anyuid SCC to Service Account testsa

oc adm policy add-scc-to-user anyuid -z testa

III. Deploy nginx application using nginx Docker Image from Docker Hub with label app=test

oc new-app --docker-image nginx --name nginx -l app=test

IV. Scale up nginx application to 5 replicas

oc scale --replicas=5 dc nginx

V. Delete nginx application using label app=test

oc delete all -l app=test

VI. Export nginx application definition to nginx.yaml

oc new-app --docker-image nginx --name nginx -l app=test -o yaml > nginx.yaml

VII. Deploy nginx application using nginx.yaml

oc apply -f nginx.yaml

VIII. Deploy Node.js Hello World application using GitHub URL with label app=test and name helloworld

oc new-app https://github.com/sagar-jadhav/node-hello --name helloworld -l app=test

IX. Export nginx application to nginx-template template

oc export dc nginx --as-template=nginx-template

X. Set requests & limits of nginx application

oc set resources dc nginx --requests=cpu=250m --limits=cpu=250m

XI. Create Edge Terminated Route nginx-route for nginx service using nginx.key & nginx.crt files

oc create route edge nginx-route --service=nginx --key=nginx.key --cert=nginx.crt

XII. Create secret user-creds with values user=admin and password=admin

oc create secret generic user-creds --from-literal='user'='admin' --from-literal='password'='admin'

A quick introduction to Velero

Sagar Jadhav — Mon, 21 Dec 2020 10:00:27 +0000

Introduction

Formerly known as "Heptio Ark"
It provides tools to Backup and Restore K8s cluster
It consists of the following components:
- Server: Runs on K8s cluster
- CLI: Runs locally
Current release: v1.5.x
GitHub stars: 4.6K+

Checkout here for more details

Architecture

Source: https://velero.io/docs/v1.5/img/backup-process.png

Velero supports the following operations:

On-demand backup
Scheduled backup
Restore

Each operation is a custom resource defined with the custom resource definition and stored in etcd. Velero has controllers that act on these resources.

On-demand backup

Creates a copy of k8s objects in the form of tarball and uploads that tarball to cloud object storage

Note: Backup operation is not atomic.

Scheduled backup

As the name suggests you can schedule the backup at a particular time. You can also schedule recurrent backups. Provide Cron expression to specify a schedule. For e.g. Use the 0 0 * * * Cron expression to take backup once a day.

Restore

Creates k8s objects from the definition stored in cloud object storage.

Note: As a good practice always set the mode of backup storage location to Read-Only during restore to avoid update or deletion of backup.

Velero uses cloud object storage as a source of truth. It synchronizes data between cloud object storage and the K8s cluster.

Features

Filtering k8s objects based on type, namespace & label during backup and restore
TTL (Time to Live) for backups. Backup resources will be deleted after TTL is reached
Different lifecycle hooks for both backup and restore operations
Supports namespace remapping i.e. K8s object from namespace A can be restored to namespace B

Executing Shell Script in Terraform via Null Resource

Sagar Jadhav — Mon, 07 Dec 2020 12:45:52 +0000

Null Resource in Terraform implements all the lifecycle methods as compare to other resources but it doesn't take any action. It is very useful for many use cases but in this blog I will cover How I can use Null Resource to execute the shell script by using local exec provisioner during provision.

Use Case

Let say I am deploying some resources on private cloud (x-cloud) through terraform but provision should only start when x-cloud is up & running. x-cloud exposed a REST API for health check, Hence as part of provisioning I should first check whether x-cloud is up & running, If it is running then continue with the provisioning otherwise stop the provisioning.

Step 1: Shell script to perform health check

healthcheck.sh

#!/bin/sh

result=$(curl -X GET --header "Accept: */*" "https://jsonplaceholder.typicode.com/todos/1" | jq -r '.id')

if [ $result -eq 1 ]
then
   exit 0
else
   exit 1
fi

Step 2: Terraform file for provision

main.tf

terraform {
  required_version = "> 0.8.0"
}

resource "null_resource" "health_check" {

 provisioner "local-exec" {

    command = "/bin/bash healthcheck.sh"
  }
}

Step 3: Initializing Terraform

terraform init

Output:

Initializing provider plugins...

The following providers do not have any version constraints in configuration,
so the latest version was installed.

To prevent automatic upgrades to new major versions that may contain breaking
changes, it is recommended to add version = "..." constraints to the
corresponding provider blocks in configuration, with the constraint strings
suggested below.

* provider.null: version = "~> 2.1"

Terraform has been successfully initialized!

You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure. All Terraform commands
should now work.

If you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working directory. If you forget, other
commands will detect it and remind you to do so if necessary.

Step 4: Provisioning resources

terraform apply

Output:

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # null_resource.health_check will be created
  + resource "null_resource" "health_check" {
      + id = (known after apply)
    }

Plan: 1 to add, 0 to change, 0 to destroy.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

null_resource.health_check: Creating...
null_resource.health_check: Provisioning with 'local-exec'...
null_resource.health_check (local-exec): Executing: ["/bin/sh" "-c" "/bin/bash healthcheck.sh"]
null_resource.health_check (local-exec):   % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
null_resource.health_check (local-exec):                                  Dload  Upload   Total   Spent    Left  Speed
null_resource.health_check (local-exec):   0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
null_resource.health_check (local-exec):   0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
null_resource.health_check (local-exec): 100    83  100    83    0     0    154      0 --:--:-- --:--:-- --:--:--   154
null_resource.health_check: Creation complete after 0s [id=9103842202970100490]

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

References:

How to deploy applications using Helm in Kubernetes?

Sagar Jadhav — Sun, 28 Jun 2020 05:15:59 +0000

Let's learn How to deploy PHPMyAdmin application using helm chart? Learn more about helm here.

Prerequisites:

Create NFS share

Reference:

Install Helm

Refer installation guide here

Clone github repository

git clone https://github.com/sagar-jadhav/kubernetes-essentials.git

Go to `session_5` directory

cd ./kubernetes-essentials/session_5/

Enable Nginx ingress controller

minikube addons enable ingress

kubectl get pods --watch -n kube-system

Exit once controller pod goes into running state

Step 1: Create PHPMyAdmin helm chart

helm create phpmyadmin

Step 2: Add all application YAML files to templates directory

Remove unwanted files from template directory

rm -rf ./phpmyadmin/templates/*

Copy YAML files

cp configmap.yaml db-deployment.yaml db-pv.yaml db-pvc.yaml db-service.yaml secret.yaml phpmyadmin-deployment.yaml phpmyadmin-ingress.yaml phpmyadmin-service.yaml ./phpmyadmin/templates/

Step 3: Package helm chart

helm package phpmyadmin

Step 4: Deploy PHPMyAdmin application

helm install phpmyadmin ./phpmyadmin-0.1.0.tgz

Step 5: List helm release

helm ls

Step 6: List pods

kubectl get pods

Demo

What is Readiness & Liveness Probes in Kubernetes?

Sagar Jadhav — Sun, 21 Jun 2020 04:34:45 +0000

Kubernetes uses Readiness & Liveness probes to manage pod lifecycle. Readiness probe is used to determine whether pod is ready to accept the traffic or not and liveness probe is used to determine whether pod is functioning properly or not. Read more about them here. In this blog I am adding readiness & liveness probe to PHPMyAdmin application.

Architecture

Prerequisites:

Deploy PHPMyAdmin Application

Follow Deploy phpMyAdmin application on kubernetes blog

Go to session_4 directory

cd ../session_4/

Step 1: Delete PHPMyAdmin deployment

kubectl delete deployment phpmyadmin

Step 2: Deploy PHPMyAdmin deployment with Readiness & Liveness probes

kubectl create -f phpmyadmin-deployment.yaml

kubectl get pods --watch

Exit once pod goes into running state

Step 9: Browse phpmyadmin application

Go to browser and browse http://IP_ADDRESS:30030. Login with root user & test password

here IP_ADDRESS is the ip address of virtual machine where kubernetes is running.

Demo

What is Ingress Controller in Kubernetes?

Sagar Jadhav — Sat, 13 Jun 2020 04:31:03 +0000

In Deploy phpMyAdmin application on kubernetes blog I used NodePort service type to expose application to external world but disadvantage with that approach is port needs to be exposed on each node and there is a dependency on external load balancer for load balancing requests, custom hostname and SSL/TLS encryption support etc. With the help of Ingress controllers I can eliminate dependency on external load balancer. In this blog I am using Nginx Ingress controller to expose PHPMyAdmin application to external world. Learn more about ingress controller here

Architecture

Prerequisites:

Deploy PHPMyAdmin Application

Follow Deploy phpMyAdmin application on kubernetes blog

Go to session_2 directory

cd ../session_3/

Step 1: Enable Nginx ingress controller

minikube addons enable ingress

kubectl get pods --watch -n kube-system

Exit once controller pod goes into running state

This step is valid only for Minikube. Check steps to enable Nginx Ingress controller on Kubernetes here

Step 2: Delete PHPMyAdmin NodePort service

kubectl delete svc phpmyadmin

Step 3: Deploy PHPMyAdmin ClusterIP service

kubectl create -f phpmyadmin-service.yaml

Step 4: Deploy PHPMyAdmin Ingress rule

kubectl create -f phpmyadmin-ingress.yaml

kubectl get ingress --watch

Exit once address gets populated

Step 5: Update hosts file custome hostname

Add below entry in /etc/hosts

<INGRESS_ADDRESS> myapp.xyz

Get INGRESS_ADDRESS from kubectl get ingress

Demo

What is Persistent Volume (PV) & Persistent Volume Claim (PVC) in Kubernetes?

Sagar Jadhav — Sat, 06 Jun 2020 04:38:13 +0000

Here, I am covering concepts of persistent volume (PV) & persistent volume claim (PVC). In the previous blog I have covered how to deploy PHPMyAdmin application in kubernetes. PHPMyAdmin application does not have a persistent storage. Hence If MySQL pod die due to some unexpected error for e.g. resource crunch then data stored in database will also get deleted as data by default stored in pod. Pods by default are stateless in nature. Hence to persist MySQL data PV & PVC is required.

Persistent Volume (PV)

Storage provisioned by administrator. Learn more here

Persistent Volume Clain (PVC)

Request for a storage by user. Learn more here

Architecture

Prerequisites:

Deploy PHPMyAdmin Application

Follow Deploy phpMyAdmin application on kubernetes blog

Go to session_2 directory

cd ../session_2/

Step 1: Create NFS share

Reference:

I have created NFS mount at /mnt/share location on VM with IP 192.168.1.6

Step 2: Create Persistent Volume (PV)

kubectl create -f db-pv.yaml

Step 3: Create Persistent Volume Claim (PVC)

kubectl create -f db-pvc.yaml

Step 4: List PV & PVC

kubectl get pvc

kubectl get pv

Step 5: Redeploy MySQL deployment

kubectl delete deployment db

kubectl create -f db-deployment.yaml

Here db-deployment.yaml is updated YAML with volume & volume mounts. Next watch pods.

kubectl get pods -n watch

Exit once db pod goes into running state.

Step 6: Go to mount directory and list files

cd /mnt/share

ls -ltr

Forem: Sagar Jadhav

Deploy a Microservice in Kubernetes with zero lines of code

Let me show you How?

Before you start deploying, finish the below prerequisites:

Gear up yourself to deploy a Microservice in Kubernetes

Introduction to Docker Compose

A quick guide on How to extend kubectl with plugins?

kubectl

What is a plugin?

Why write a plugin?

Restart a Pod

How to write a plugin?

Demo

Notes

Show Your Support

Demystify Pointers in Go

Introduction

Pass By Value

Pointer in Action

Pointer Receiver

How to effectively Tag a Cloud Resource?

Introduction

Types of Tagging

I. Automated Tagging

II. Manual Tagging

Tagging Best Practices

Why Tag a Cloud Resource?

Demo

Add timestamp tag to EC2 instance through Terraform

Add env tag to EC2 instance through AWS Console

Glossary

Cloud Resource

Provision

12 Useful OpenShift Commands You Should Know

Introduction

12 Useful OpenShift Commands

A quick introduction to Velero

Introduction

Architecture

On-demand backup

Scheduled backup

Restore

Features

Executing Shell Script in Terraform via Null Resource

Use Case

Step 1: Shell script to perform health check

Step 2: Terraform file for provision

Step 3: Initializing Terraform

Step 4: Provisioning resources

References:

How to deploy applications using Helm in Kubernetes?

Prerequisites:

Create NFS share

Install Helm

Clone github repository

Go to session_5 directory

Enable Nginx ingress controller

Step 1: Create PHPMyAdmin helm chart

Step 2: Add all application YAML files to templates directory

Step 3: Package helm chart

Step 4: Deploy PHPMyAdmin application

Step 5: List helm release

Step 6: List pods

Demo

What is Readiness & Liveness Probes in Kubernetes?

Architecture

Prerequisites:

Deploy PHPMyAdmin Application

Go to session_4 directory

Step 1: Delete PHPMyAdmin deployment

Step 2: Deploy PHPMyAdmin deployment with Readiness & Liveness probes

Step 9: Browse phpmyadmin application

Demo

What is Ingress Controller in Kubernetes?

Architecture

Prerequisites:

Deploy PHPMyAdmin Application

Go to session_2 directory

Step 1: Enable Nginx ingress controller

Step 2: Delete PHPMyAdmin NodePort service

Add `timestamp` tag to EC2 instance through Terraform

Add `env` tag to EC2 instance through AWS Console

Go to `session_5` directory