Ex 2:

---------
vim pod-definition2.yml

---
apiVersion: v1
kind: Pod
metadata:
name: postgres-pod
labels:
author: sunil
type: database
spec:
containers:
- name: mypostgres
image: postgres
env:
- name: POSTGRES_PASSWORD
value: durgasoft
- name: POSTGRES_USER
value: myuser
- name: POSTGRES_DB
value: mydb

:wq

Command to run the definition file

------------------------------------------
kubectl create -f pod-definition2.yml

To get the list of pods

---------------------------
kubectl get pods

To get the list of pods along with IP address and which node the pod is running
---------------------------
kubectl get pods -o wide

TO get more details about the pod

-----------------------------------------
kubectl describe pods postgres-pod

or

kubectl describe pods postgres-pod | less

Ex3:

vim pod-definition3.yml

---
apiVersion: v1
kind: Pod
metadata:
name: jenkins-pod
labels:
author: sunil
ci: cd
spec:
containers:
- name: myjenkins
image: jenkins/jenkins
ports:
- containerPort: 8080
hostPort: 8080

:wq

How to open the port?

-----------------------------
gcloud compute firewall-rules create rule35 --allow tcp:8080

gcloud compute firewall-rules create rule2 --allow tcp:9090

kubectl create -f pod-definition3.yml

kubectl get pods -o wide

Take a note on the node in which the pod is running.

gke-cluster-1-default-pool-9fb99245-q1nm

TO get the list of nodes

-----------------------
kubectl get nodes -o wide

Take the external IP of the node

35.223.183.189:8080
34.68.242.87:8080

Open browser ( chrome)

35.223.183.189:8080 ( we should get the jenkins page )

++++++++++++++++++++++++
Deployment Object
-------------------------
This is also an high level object which can be used for scalling, load balancing
and perform rolling updates.

Create a deployment file to run nginx 1.7.9 with 3 replicas.

Later perform a rolling update to nginx 1.9.1

vim deployment.yml
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: nginx-deployment
labels:
author: sunil
type: proxyserver
spec:
replicas: 3
selector:
matchLabels:
type: proxyserver
template:
metadata:
name: nginx-pod
labels:
type: proxyserver
spec:
containers:
- name: nginx
image: nginx:1.7.9
ports:
- containerPort: 80
hostPort: 8888

:wq

kubectl get all ( we have one default service running )

kubectl create -f deployment.yml

TO check, if the deployment is created or not

--------------------------------------------
kubectl get deployment ( we can see 1 deployment object )

kubectl get pods ( we should get 3 pods )

We can anyways perform scaling, apart from that we can perform rolling updates.

kubectl get all ( we get all the objects )

Take a note of the full name of the deployment object
deployment.apps/nginx-deployment

To perform rolling update

-----------------------------

kubectl --record deployment.apps/nginx-deployment set image

deployment.v1.apps/nginx-deployment nginx=nginx:1.9.1

We get a message ( image updated )

kubectl get pods

To know more about pod
------------------------
kubectl describe pods podname

nginx-deployment-6fdc797dc6-qrlqb

kubectl describe pods nginx-deployment-6fdc797dc6-qrlqb | less

we can see as Image: nginx:1.9.1

:q
( It will take some time )

kubectl get pods

++++++++++++++++++++++++++++++++++++++++++++

++++++++++++++++++++++++++++++++++++

Service Object
-----------------------
This is used for network load balancing and port mapping.
Service Object uses 3 ports
1. Target port - Its is pod or container port
2. port - Refers to service port.
3. hostPort - Refers to host machine port to make it accessable from external
network.

Service Objects are classified into 3 types

1. clusterIP: This is default type of service object used in kubermetes and it is

used when we want the pods in the cluster to communicate with each other and not
with external network.

2. nodePort: This is used, if we want to access the pods from an external network
and it also performs network load balancing. ie Even if a pod is running on a
specific slave, we can access it from other slave in the cluster.
3. LoadBalancer: This is similar to nodePort. It is used for external
connectivity of a pod and also network load balancing and it also assigns a public
ip for all the nodes combined together.

+++++++++++++++++++++++

vim pod-definition1.yml

We will be creating a service object for the labels used in pod-definition1.yml

kubectl create -f pod-definition1.yml

As we know by pod will be created using the above command.

We want to create service object for the above pod

Ex: Create a service definition file for port mapping on nginx pod

vim pod-definition1.yml

---
apiVersion: v1
kind: Pod
metadata:
name: nginx-pod
labels:
author: sunil
type: reverse-proxy
spec:
containers:
- name: appserver
image: nginx

:wq

kubectl create -f pod-definition1.yml

Observation: Along with the pod, service object gets created.

This service object is type clusterIP. Hence cannot be accessed from external
network.

gcloud compute firewall-rules create rule3 --allow tcp:30008

vim service1.yml

---
apiVersion: v1
kind: Service
metadata:
name: nginx-service
labels:
author: sunil
spec:
type: NodePort
ports:
- targetPort: 80
 port: 80
nodePort: 30008
selector:
author: sunil
type: reverse-proxy
...

:wq

kubectl create -f service1.yml

Now, the nginx pod is accessable externally

kubectl get nodes -o wide

As we have created nodePort, we should able to access from any node.

Take external_IP from anynode

34.66.234.81:30008 ( We should be able to access nginx )

34.123.230.145:30008

If service object is not created, we used to identify in which node the pod is
running, take that node IP, from that node IP, we used to access that application.

( Note: We need to open 30008 port in cluster )

++++++++++++++++++++++

Kubernetes Project
---------------
This is a python based application which is used for accepting a vote ( voting
app ).
This application accepts the vote and passes it to temporary db created using
redis. From redis, the data is passed to worker application created using dotnet.
Dotnet based application analyses the data and stores it in permanant database
created using postgres.
From postgres database, results can be seen on an application created using node
JS.

Have a look at the project Architecture.

Redis and postgres pod needs to assigned as cluster IP.

As cluster Ip is used for internal communication.

Voting App and Result App needs to be assigned as loadbalance type.

We need to create 5 definition files.

These 5 images related to this project is available in hub.docker.com

Using those images, we will create pods.
We need to create 5 pod definition files
We need to create 4 service files
We will be creating these definition files using pycharm.

vim voting-app-pod.yml

---
apiVersion: v1
kind: Pod
metadata:
name: voting-app-pod
labels:
name: voting-app-pod
app: demo-voting-app
spec:
containers:
- name: voting-app
image: dockersamples/examplevotingapp_vote
ports:
- containerPort: 80
...

:wq

vim result-app-pod.yml

apiVersion: v1
kind: Pod
metadata:
name: result-app-pod
labels:
name: result-app-pod
app: demo-voting-app
spec:
containers:
- name: result-app
image: dockersamples/examplevotingapp_result
ports:
- containerPort: 80
...

:wq

vim worker-app-pod.yml

---
apiVersion: v1
kind: Pod
metadata:
name: worker-app-pod
labels:
 name: worker-app-pod
app: demo-voting-app
spec:
containers:
- name: worker-app
image: dockersamples/examplevotingapp_worker
...

:wq

vim redis-pod.yml

---
apiVersion: v1
kind: Pod
metadata:
name: redis-pod
labels:
name: redis-pod
app: demo-voting-app
spec:
containers:
- name: redis
image: redis
ports:
- containerPort: 6379
...

:wq

vim postgres-pod.yml

---
apiVersion: v1
kind: Pod
metadata:
name: postgres-pod
labels:
name: postgres-pod
app: demo-voting-app
spec:
containers:
- name: postgres
image: postgres:9.4
ports:
- containerPort: 5432
...

We are done with 5 pod definiton files.

We need to create 4 service definiton files.

vim redis-service.yml
---
apiVersion: v1
kind: Service
metadata:
name: redis-service
labels:
name: redis-service
app: demo-voting-app
spec:
ports:
- port: 6379
targetPort: 6379
selector:
name: redis-pod
app: demo-voting-app

:wq

Note: As we have not specified the type of service object, by default it creates
service object to type Cluster_IP

vim result-app-service.yml

apiVersion: v1
kind: Service
metadata:
name: result-service
labels:
name: result-service
app: demo-voting-app
spec:
type: LoadBalancer
ports:
- port: 80
targetPort: 80
selector:
name: result-app-pod
app: demo-voting-app

:wq

The above two service objects are of type load balancer. we can access it from the
external network.

Open gitbash from the location where all the definition files are saved.

$ git init
$ git add .
$ git commit -m "a"

Open github ---> create new repository

Repository name - kuber_project

upload the files from local repository to remote repository using the two commands

$ git remote add XXXXX

$ git push XXXX

We should able to see the definition files in github repository ( Total 9 files )

We need to download the 9 files into kubernetes cluster.

Login to GCP console

Create kubernetes cluster
Connect to the cluster

Get the repository URL in github.

$ git clone rep_url

$ git clone https://github.com/sunildevops77/kube_project_durga.git

( Observation all the definition files will be downloaded )

$ cd kuber_project
$ ls ( we get the files )

$ kubectl create -f voting-app-pod.yml

$ kubectl get pods ( we should get one pod )

$ kubectl create -f redis-pod.yml

$ kubectl create -f worker-app-pod.yml

$ kubectl create -f postgres-pod.yml

$ kubectl create -f result-app-pod.yml

Now, we need to run service definition files

$ kubectl create -f voting-app-service.yml

$ kubectl create -f redis-service.yml

$ kubectl create -f postgres-service.yml

$ kubectl create -f result-app-service.yml

To get all the information

$ kubectl get all

We can see 5 pods and 4 services created.

Observation: worker pod also failed.

++++++++++++++++++++++++++++

These images are coming from community called dockersamples

Connection between workerpod and postgresPod is creating issues.

Go to service&ingress option in the kuberneted dashboard

We can see the four services, which are created.

Click on endpoint ( IP ) of voting Application

Click in URL, we get Voting App ( CATS / DOGS ) -- This is python based App.

Click on endpoint ( IP ) of result Application

Click in URL, we get Result App

++++++++++++++++++++++++++++++++++++++