Forem: rohitreddyk33

Everything a DevOps Engineer must know about kubernetes.

rohitreddyk33 — Mon, 13 Feb 2023 05:13:45 +0000

*KUBERNETES *

Kubernetes is an open-source container orchestration tool which helps in deployment of applications.
Kubernetes helps in scaling the applications among the users. It is a CD tool that helps in deployments
It helps manage containerized applications in different deployment environments
There are two types of services in Kubernetes. Deployment and Stateful services
Stateful services: It is a Kubernetes controller that manages multiple pods that have unique identities and are not interchangeable. In a stateful set each pod has a persistent, unique ID.
Deployment set: the Deployment Controller changes the actual state to the desired state at a controlled rate. We can define Deployments to create new Replica Sets, or to remove existing Deployments and adopt all their resources with new Deployments.
Stateful sets are generally used for databases and stateful applications because databases are generally hosted outside the Kubernetes cluster as a database can’t be replicated.
Kubernetes consists of the following components- pods, replica sets, services etc.
Pods and replica sets are used to scale the application. It creates multiple instances of applications.
It load balances using load balancer and sends requests from users to the pods according to the load on different pods. Hence adjusts the traffic preventing the server or application from crashing
We have to create ‘yaml’ files to define the type of deployments, pods and replica sets
We have a create pods in template section to define the blue print of pods
Minikube is a tool which lets us run Kubernetes locally. It runs on the node-kubernetes cluster

Kubectl- It is a command line tool for k8s cluster.

Whenever the pods gets destroyed, deployment will restore the pods with a different IP address
Generally, pods contain containers where the application is resided in the form of an image inside the container
A pod can have one or more containers running inside it. Each container will be having different port numbers. Based on that the requests will be sent to respective containers from the service
We can define the number of instances of pods to be created in the section ‘replica sets’
Deployments are also used to roll back to previous versions of our applications.

*KUBERNETES SERVICES
*
There are 4 types of services in Kubernetes

Headless services
Node port
Load balancer
Cluster IP

*Need for services: *

When a pod dies, a new IP address is created for the pod. It becomes difficult to access the IP address for newly created pods.
For each pod we set a service, service has a stable IP address pointing to the pod.
Svc receives requests and forwards it to one of the pod
CLUSTER IP: It is a default type of service. When we create a svc without specifying the type it automatically takes cluster IP
When a svc is created end points are created. K8s will use the endpoints to keep track which pods are members of svc.
Selector in svc and label in pod should be same so that svc points to the pod.
Target port should be mentioned in svc. Target port and container port should be same.

*HEADLESS: *

If client wants to communicate with 1 specific pod directly, headless svc is used
Pods are not randomly selected by the svc
Stateful apps like SQL, databases use headless services
If client wants to communicate with a selected pod then the IP address of the pod should be known
To achieve it, DNS lookup is used where it returns svc IP address to get pod IP address. If we set cluster IP address to none, pod IP address is returned.
Cluster IP: only accessible with in the cluster
Node port: External traffic has access to fixed port on each worker node. The range of the port is 30000-32767
Load Balancer: becomes accessible externally through cloud provider.

*KUBECTL COMMANDS *

Kubectl appy -f <.yamlFile>: To create the resource from the file.
Kubectl create -f --edit -o json: edit the data in the file then creates the resource using the edited data.
Kubectl create deployment --image=: creates a deployment with the specified image name.
Kubectl create deployment --image=--replicas=3: creates a deployment with the specified image name and 3 replicas.
Kubectl create deployment --image= --port: : creates a deployment that runs on an image on the specified port number.
Kubectl delete deployment : to delete a deployment
Kubectl get deployments: displays list of created deployments .
Kubectl get svc: displays list of created services .
Kubectl get pods: displays list of pods .
Kubectl describe deployment : describes about the deployment in detail .
Kubectl describe svc : describes about the svc in detail .
Kubectl describe pod : describes about the pod in detail .
Kubectl get pod -o wide: describes the pod with cluster IP address .
Kubectl rollout status deployment : gives the status of deployment .
Kubectl rollout history deployment : gives the revisions of deployments .
Kubectl rollout undo deployment --to-revison=: goes back to the revised deployment.

Every Git command a DevOps Engineer must know(Basic, Advanced)

rohitreddyk33 — Mon, 13 Feb 2023 05:08:07 +0000

Basic Git:

git init: Initializes an empty git repository
git add : Adds the files into staging area
git commit : Selects the changes which are staged for the next commit.
git commit -a -m ""- commits the changes without the file being undergoing the staging area
git remote add origin - adds the pathway from our local git to the remote repo.
git remote set-url origin-To change the remote repo to another remote.
git remote -v- Displays the pathway of remote repo which the user has set.
git config --global user.name "" - configures the username
git config --global user.passsword "" - configures the password
git config --global --edit - To edit the configured details
git status - Shows the status of the files and displays whether the respective files are already staged,committed or yet to stage, commit
git log- displays the log of the previous commits
git log --oneline - displays the previous commits in one line with the starting 8 hashcode characters
git diff - shows the modifications and updations in the file between the commits
git stash - stores our commit in a hidden place and we can make changes to the file prior that commit
git stash pop <{head-path}> - returns the previously stashed commit
git log --merge- returns the list of commits which are causing merge conflicts
git log --after:returns the commits done after the mentioned date
git log --before:returns the commits done before the mentioned date
git branch : Creates a new branch with the specified branch name
git checkout : navigates and makes the head pointer points towards the specific branch
git checkout -b : creates and navigates to the created branch
git merge : Merges one branch with another branch
fork: creates a copy of an existing repo in the user's remote repo
git clone creates a copy of files of existing repo in the local repo of the user
git push origin: lets you move local branch into the remote repository
git pull origin: lets you move your remote branch into the local repo
git fetch: downloads the copy of a branch from another repo but doesn't integrate it with your local repo
ls : gives the list of files in the current working branch

Advanced Git:

git reset : undo's the changes made in the commit and puts it into staging area
git reset --soft: undo's the changes made in the commit and puts them in non committed area
git reset --hard:undo's the changes made in the respective commit and deletes the changes. Once used they are deleted permanantly.
git reset --mixed: It works the same as 'git reset'
git merge --abort : aborts the merging process
git merge --reset: undo's the merging process and puts back the commits in the state as they were before merging process
git rebase -i HEAD~: deletes a specifc commit
git rebase --abort: aborts the deletion of a branch
Git rebase : acts same as git merge but moves the commits of entire feature branch on top of the master branch
Git rebase –i HEAD~ : interactive rebase helps in manipulating the commits. Ex: squash is used to combine two commits, reword is used to edit the commit message.
Git revert: undo commits in a branch and creates a new commit
Find .git/objects -type f : displays the staged files present in git in the form of objects
Git cat-file –t : displays the type of object
Git cat-file –p : displays the content present in the object
Git gc –aggressive : performs compression on stored git objects freeing up disk space. It identifies a group of similar objects and compress them into a ‘pack’.
Git verify-pack –v .git/objects/pack/pack: displays the contents of a pack
Git reflog : gives the history of everything done in local repo
Git reflog expire –-expire=now –-expire-unreachable=now –all: expire all entries to the reflog that are older than now
Git show : inspects a commit

Deploying a MERN application over Kubernetes

rohitreddyk33 — Mon, 30 Jan 2023 09:52:31 +0000

Deploying a MERN(mongo-db, express, react-js, node-js) application using kubernetes.
This is a simple authentication application where the users can Register and Login. The login details of the users are stored in mongo-db database.
We are using React-js for the front end.

https://github.com/rohitreddyk33/dock

Registration page using React-js. The requests are made through API calls.



import {React,useState} from 'react'

function Register() {
  const[name,setName]=useState('')
  const[email,setEmail]=useState('')
  const[password,setPassword]=useState('')



  async function registerUser(event){
    event.preventDefault()
  const response=await fetch('http://<your service name after creating a service yaml file>.default.svc.cluster.local:7070/api/register',{
      method:'POST',
      headers:{
        'Content-Type':'application/json',
      },
      body:JSON.stringify({
        name,email,password
      }),
    })
    const data=await response.json()
    console.log(data)


  }
  return (
   <div>
    <h1>register</h1>
    <form onSubmit={registerUser}>
      <input type ="text" value={name} onChange={(e)=>setName(e.target.value)} placeholder="name"/>
      <input type ="email" value={email} onChange={(e)=>setEmail(e.target.value)} placeholder="email"/>
      <input type ="password" value={password} onChange={(e)=>setPassword(e.target.value)} placeholder="password"/>
      <input type="submit" value="register"/>
    </form>
   </div>

  )
  }

export default Register;

Login page : If the users are already registered then they'll be able to view a page after logging in. Duplicate E-mails can't be used.

import { React, useState } from 'react'
import { useNavigate } from 'react-router-dom'

function Login() {
  const [email, setEmail] = useState('')
  const [password, setPassword] = useState('')

  const navigate=useNavigate()
  function loginUser(event) {
    event.preventDefault()
    fetch('http://<your service name after creating a service yaml file>.default.svc.cluster.local:7070/api/login', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        email, password
      }),
    }).then(res =>{
      return res.json();
    }).then(res =>{
      if(res.status==='ok'){
        localStorage.setItem('user',JSON.stringify(res))
      }

      navigate('/home')
    }) 
  }
  return (
    <div>
      <h1>Login</h1>
      <form onSubmit={loginUser}>
        <input type="email" value={email} onChange={(e) => setEmail(e.target.value)} placeholder="email" />
        <input type="password" value={password} onChange={(e) => setPassword(e.target.value)} placeholder="password" />
        <input type="submit" value="login" />
      </form>
    </div>

  )
}

export default Login;

A basic home page after logging in:

import React from 'react'

function Home() {
  return (
    <div>Welcome User</div>
  )
}

export default Home

Creating a schema and collection in the mongo-db database with the help of express


const mongoose=require('mongoose')
const User=new mongoose.Schema(
    {
    name:{type:String,required:true},
    email:{type:String,required:true,unique:true},
    password:{type:String,required:true},
    quote:{type:String},

},
{collection:'userdata'}
)
const model=mongoose.model('userdata',User)
module.exports=model

We are using Node-js for backend. It receives the requests from users and performs functions accordingly. It also authenticates users through jwt authentication where it generates Tokens for the users.

const express = require('express')
const app = express()
const cors = require('cors')
const User = require('./models/model')
const jwt = require('jsonwebtoken');
app.use(express.json())
app.use(cors())
const mongoose = require('mongoose')
mongoose.connect("<your connection string which can be found in mongodb atlas after creating a cluster>")
 mongoose.connection.on('error', err => {
     console.log(err);
  });


app.post('/api/register', async (req, res) => {
    console.log(req.body)
    try {
        await User.create({
            name: req.body.name,
            email: req.body.email,
            password: req.body.password
        })
        res.json({ status: 'ok' })

    } catch (err) {
        res.json({ status: 'error', error: 'duplicate email' })
    }

}
)

app.post('/api/login', async (req, res) => {
    const user = await User.findOne({
        email: req.body.email,
        password: req.body.password
    })
    console.log(user)
    if (user) {
        const token = jwt.sign({
            name: user.name,
            email: user.email

        },
            <Your secret key for tokenization>
        )
        console.log(token);
        const userToken={name:user.name,email:user.email,token}
        return res.json({"status":"ok",'user':userToken})
    }
    else {
        return res.json({ 'status': 'error', user: false })
    }
})


app.listen(7070, () => {
    console.log("port 7070")
})

Creating deployment yaml files for back-end.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mern-node  
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mern-node
  template:
    metadata:
      labels:
        app: mern-node
    spec:
      containers:
      - name: mern-node
        image:(your repository in docker hub where you built and uploaded the Image of the back-end code)
        ports:
        - containerPort: 7070

Creating deployment yaml files for front-end.

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: mern-react
  name: mern-react
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mern-react
  template:
    metadata:
      labels:
        app: mern-react
    spec:
      containers:
      - image: (your repository in docker hub where you built and uploaded the Image of the front-end code)
        name: mern-react
        ports:
        - containerPort: 3000

creating a service file for back-end deployment

apiVersion: v1
kind: Service
metadata:
  name: node-service
spec:
  selector:
    app: mern-node
  type: ClusterIP
  ports:
  - port: 7070
    targetPort: 7070

creating a service file for front-end deployment

apiVersion: v1
kind: Service
metadata:
  name: node-service
spec:
  selector:
    app: mern-node
  type: ClusterIP
  ports:
  - port: 7070
    targetPort: 7070

Access your application through the service port of the node-port
Steps:

kubectl describe service mern-service
Get the port number for the node-port
localhost: "node-port port number"