i27 Academy

DevOps Mastery: Real-time Project-Based Learning with Job Ready Program

Learn Devops with Real time project implementation and get through Top product based companies.

DevOps Mastery: Real-time Project-Based Learning with Job Ready Program

  • Welcome to DevOps Job-Ready Program, where we don’t just learn DevOps tools; we prepare yourself for the real world.
  • In this program, you won’t just learn theory; you’ll dive into practical, hands-on projects that mirror the challenges you’ll face in a real DevOps job.
  • My focus is on building your skills and experience, so you can confidently navigate the complex landscapes of DevOps.
  • By working on actual projects, you’ll gain a deep understanding of how DevOps tools are used in the industry and develop the problem-solving abilities that will set you apart in interviews.
  • Join us on this journey as we bridge the gap between knowledge and application, making you not just DevOps proficient, but job-ready!
  • We shall start from the basics and go to an advanced level to a position where we will be confidently clearing any technical interview along with project implementation as well.

More Details About Projects:

  • We shall work on real time microservices based projects and try to replicate the same environment which we use in the real world.
  • After you implement these End to End projects, you will be able to get good implementation knowledge once you move to a new job role or trying to switch your career

Introducing: Job Oriented Program

IntroductionTo Devops













prometheus & grafana

Roles & Responibilities

Interview Preperation

Resume Preperation


DevOps Mastery: Real-time Project-Based Learning

By the end of this course, you will have developed a strong foundation in DevOps principles and gained hands-on experience by working on real-time projects.

This will be completely Project based learning. By the projects we are implementing, we will be having an experience of (3-4 years to claim minimum ). You will be confident enough to apply the skills learned and clear any DevOps Interview and sustain as a Devops Engineer.
The Main Aim of the Course is to have a real time experience while learning each tool and integrating with various Devops Tools with CICD implementation.

Devops Overview

LESSON 1: What is Devops ?

LESSON 2: How do we start our project and what teams are involved?

LESSON 3: What problems do Devops Solve?

Cloud Foundation

LESSON 1: What is Cloud, Cloud computing

LESSON 2: Various Clouds

LESSON 3: What is Infrastructure?

LESSON 4: Account Setup in AWS and GCP


LESSON 1: Overview of UNIX/Linux Operating

LESSON 2: Linux File System

LESSON 3: ls,date and cal commands

LESSON 4: Working with Directories

LESSON 5: Working with Files

LESSON 6: Comparing Files

LESSON 7: Creation of Link Files

LESSON 8: Word count command (wc command)

LESSON 9: Sorting content of the file

LESSON 10: Find unique content in the file by using uniq command

LESSON 11: Input and Output of Commands and Redirection

LESSON 12: Piping

LESSON 13: How to use multiple commands in a single line

LESSON 14: Regular Expressions and Wildcard Characters

LESSON 15: Command Aliasing

LESSON 16: Locate and Find Commands

LESSON 17: Compression and Uncompression of files(tar,gzip,gunzip,bzip2,bunzip2)

LESSON 18: grep command

LESSON 19: Cut, Paste and tr Commands

LESSON 20: File Permissions

LESSON 21: SSH keys configuration

LESSON 22: Working with editors

Interview Questions Discussion

Version Control with Git

LESSON 1: What is Version Control ?

LESSON 2: What is Git and GitHub

LESSON 3: Basic concepts of Git

LESSON 4: Setup Git repository Remote and Local

LESSON 5: Initialising a Git Project locally and connecting 

LESSON 6: Git commands handson

LESSON 7: Working with branches and merge branches

LESSON 8: Rebase

LESSON 9: Undoing commits

LESSON 10: What are merge conflicts and how to resolve merge conflicts in real time

LESSON 11: Going back in history

LESSON 12: What are tags , how and where we use in real world

LESSON 13: Git Reset

LESSON 14: Git Merge

LESSON 15: Git Rebase

LESSON 16: Git checkouts

LESSON 17: Git Administration tasks

Interview Questions Discussion


LESSON 1: What is a Build tool ?

LESSON 2: Various Build tools ?

LESSON 3: What is MAVEN ?

LESSON 4: Why do Devops engineers need to use Maven

LESSON 5: Installing maven  and configuring Java on Linux machine

LESSON 6: Maven Repository.

LESSON 7: Project Structure of Maven

LESSON 8: Creating a sample project from scratch using Maven.

LESSON 9: Maven Lifecycles and Goals

LESSON 10: Maven Dependency Management

LESSON 11: Configuring how to use private/company dependencies.

LESSON 12: Integration with Jenkins

Interview Questions Discussion


LESSON 1: What is an artifactory ? 

    • What is Nexus?
    • Installing nexus on a Linux VM
    • Nexus Overview 
    • Nexus Installation and Configuration
    • Repository creation.
    • Snapshot management
    • Release management
    • Nexus repository configuration
    • Artifacts Management.
    • Uploading the artifacts to Nexus
    • Downloading the artifacts in the CD process
    • Nexus repo management
    • Managing of Versions
    • Integration with Jenkins
    • Interview Questions Discussion

LESSON 2: Project

LESSON 3: Implementing Nexus integration with jenkins freestyle for artifact uploads .


LESSON 1: What is Tomcat ?

LESSON 2: Installing Tomcat on linux machines .

LESSON 3: Setting up tomcat as a service in linux

LESSON 4: Deploying web application war file in tomcat

LESSON 5: Creating and managing roles available in Tomcat

LESSON 6: Integration with Jenkins

Interview Questions Discussion


LESSON 1: What is an Sonarqube ? 

    • Use case of Sonarqube
    • What is Sonarqube ??
    • Understanding the Sonarqube Architecture
    • Installing sonarqube on linux machine
    • Configuring projects to run on Sonarqube
    • Creating QualityProfiles, quality gates for the applications
    • Performing scans based on the code quality 
    • Admin activities.
    • Users Creation in sonar
    • Scanning a microservice with Maven build tool.
    • Scanning a microservice with Gradle build tool
    • Integrating SonarQUbe with Jenkins
    • Integration with Jenkins

Interview Questions Discussion


Implementing Sonar scans for Java based applications using Jenkins FreeStyle job .


LESSON 1: Jfrog Artifactory OVerview .

LESSON 2: Installing Jfrog Artifactory in Linux.

LESSON 3: Integrating the Jfrog in Maven.

LESSON 4: Managing/Creating of Users and groups in Jfrog Artifactory

LESSON 5: Integrating Jfrog with Jenkins


LESSON 1:  Introduction: 

    • What is Continuous Integration
    • What is Continuous Delivery
    • What is Continuous Deployment ?

LESSON 2:  What is Jenkins ?

LESSON 3: Installation: 

    • Installing in Redhat/Centos
    • Installing in ubuntu 
    • Jenkins Directory Structure
    • Jenkins Graphical User Interface
      • Exploring the GUI
      • System Configuration
      • Job Configuration
    • Create a CICD for JAVA App using Maven 
    • Jenkins Plugins:
      • Managing Plugins
      • Updating Plugins
      • Adding Plugins
    • Freestyle Jobs:
      • Various Job Structures
      • Parameters
      • Notifications
    • Agent and Distributed Builds:
      • Why do we need Agents ?
      • Setting up a Build Agent . 
      • Distributing a build on various agents 
      • Healthcheck of Build Agents.
    • UpStream, Downstream and Triggers
      • What are Upstream and Downstream jobs, and how to trigger
      • Artefacts and fingerprints
    • Security:
      • Understanding on Authentication and Authorization part .
      • OVerview of Jenkins Security
      • Matrix Based Security
      • Managing Folders 
      • Creating Users, Roles and Groups. 
      • Deep dive into Credentials
    • Update and Maintenance:
      • Various ways to upgrade jenkins
      • Backing up Jenkins 
    • Notifications and Alerts:
      • How to Setup Email Notifications. 
      • Various Notifications Plugins
    • What is a Pipeline : 
      • Various Pipeline Jobs 
      • The Blue Ocean Editor
    • Scripted vs Declarative Pipeline
      • Creating Scripted Pipelines
      • Creating Declarative Pipelines
      • Understanding Groovy and DSL

LESSON 4: Deep diving Jenkins Declarative Pipeline

LESSON 5: Implementing Production Grade Pipelines used in Large Product based Companies

LESSON 6: JenkinsShared Libraries

LESSON 7: Exploring options under Mange Jenkins

LESSON 8: Pipeline Triggers

LESSON 9: Multi Branch Pipelines Implementation.

LESSON 10: Implementing Master Slave architecture.

LESSON 11: Shared Libraries vs Global Libraries

Interview Questions Discussion


LESSON 1: Introduction to Docker:

    • Monolithic Application Overview
    • Microservices Application Overview.
    • Introduction to Containers
    • Understanding Docker Architecture , Docker Engine
    • Various types of installations available for Docker.

LESSON 2: Docker Containers:

    • Learning Docker Basic Commands:
    • Container LifeCycle. 
    • Docker Port Binding.
    • Docker commands
    • VM vs Container

LESSON3: Docker Networking:

    • Overview of Docker Networking.
    • Bridge networking 
    • Implementing user-defined bridge networking.
    • Host networking.
    • Networking Commands and implementing with containers.

LESSON 4: Docker Storage:

    • What is Persistency ? how to achieve it in containers ??
    • Overview of Storage Drivers.
    • Understanding Bind Mount and TMPFS Mount.
    • Overview of Docker Volumes.
    • Using Volumes for Persistent Storage. 

LESSON 5: Docker Image Management and Registry:

    • What is an Image ?
    • Inspecting and Docker image 
    • How to Create and Pull/Push an Image. 
    • What are Image tags ? How do we implement it in the real world?
    • Image Layering.
    • Committing Changes.
    • Deploying and Configuring Private Registry.
    • Using Multi Stage Builds.

LESSON 6: Building Image with Dockerfile

    • Dockerfile Introduction
    • Working with dockerfile instructions. 

LESSON 7: Integration with Jenkins

Interview Questions Discussion


LESSON 1: Introduction to Infrastructure as a Code/Terraform

      • Challenges with traditional IT Infrastructure
      • Types of IAC
      • Why and what is terraform

LESSON 2: Getting Started with terraform:

      • Installing terraform on Windows and Linux
      • HCL Basics

LESSON 3: Providers

LESSON 4: Terraform Basics:

      • Understanding Terraform Workflow
      • Terraform core commands
      • Terraform Configuration syntax
      • Understand various blocks in terraform 

LESSON 5: Terraform Fundamental Blocks:

      • Terraform Settings Block
      • Terraform Provider Block
      • Implement Terraform Multi provider 
      • Dependency Lock file
      • Terraform Resource Block
      • Terraform Data Block

LESSON 6: Terraform Resources:

      • What are Terraform Resources
      • Creating Resources in AWS and GCP cloud. 
      • Understanding terraform resource behaviour while updating the infra
      • Understanding terraform resource behaviour while deleting the infra
      • What are Meta Arguments, and creating resources with the help

LESSON 7: Terraform Data Sources.

LESSON 8: Input Variables

LESSON 9: Output Variables

LESSON 10: Resource Attributes

LESSON 11: Resource Dependencies

LESSON 12: Terraform State:

      • Remote state
      • State locking
      • Remote backend with S3
      • State commands

LESSON 13: Terraform Workspaces

LESSON 14: Terraform Provisioners

LESSON 15: Null Resources

LESSON 16: Terraform Modules

LESSON 17: Integration with Jenkins

Interview Questions Discussion


  • Creating 3 tier architecture with all above concepts
  • Creating infra with Docker installation and containers with Jenkins Pipeline and terraform Integration


LESSON 1: What is Configuration Management?

LESSON 2: What is Ansible , how does it works ?

LESSON 3: Installing Ansible and Configuring it.

LESSON 4: Push vs Pull architecture

LESSON 5: Adding nodes to the controller after configuration .

LESSON 6: Creating Playbooks.

LESSON 7: Working with Ansible Components

LESSON 8: Inventory

LESSON 9: Managing host key checking and ssh keys

LESSON 10: Ansible Modules

LESSON 11: Ansible Collections

LESSON 12: Ansible Variables

Interview Questions Discussion

LESSON 13: Project: Deploying a NodeJS application

LESSON 14: Project: Deploying Nexus/sonarqube

LESSON 15: Project: Deploying Docker through ansible

LESSON 16: Integrating Ansible with Jenkins Pipeline

Devops Engineer Roles and Responsibilities

Day to Day Activities of a Devops Engineer

Devops Engineer Resume building

Tips to Crack Devops Interview

Docker and Kubernetes Deep Dive

Introduction to Docker:

LESSON 1: Monolithic Application Overview

LESSON 2:Microservices Application Overview.

LESSON 3: Introduction to Containers

LESSON 4: Understanding Docker Architecture , Docker Engine

LESSON 5: Various types of installations available for Docker.

Docker Containers:

LESSON 1: Learning Docker Basic Commands

LESSON 2: Container LifeCycle.

LESSON 3: Docker Port Binding.

LESSON 4: Docker commands

LESSON 5: VM vs Container

Docker Networking:

LESSON 1: Overview of Docker Networking.

LESSON 2: Bridge networking

LESSON 3: Implementing user-defined bridge networking.

LESSON 4: Host networking.

Networking Commands and implementing with containers.

Docker Storage:

LESSON 1: What is Persistency ? how to achieve it in containers ??

LESSON 2: Overview of Storage Drivers.

LESSON 3: Understanding Bind Mount and TMPFS Mount.

LESSON 4: Overview of Docker Volumes.

Using Volumes for Persistent Storage.

Docker Image Management & Registry:

LESSON 1: What is an Image ?

LESSON 2: Inspecting and Docker image

LESSON 3: How to Create and Pull/Push an Image.

LESSON 4: What are Image tags ? How do we implement it in the real world?

LESSON 5: Image Layering.

LESSON 6: Committing Changes.

LESSON 7: Deploying and Configuring Private Registry.

LESSON 8: Using Multi Stage Builds.

Building Docker Image:

LESSON 1: Dockerfile Introduction.

LESSON 2: Working with Instructions.

Introduction to Kubernetes:

LESSON 1: History of Kubernetes.

LESSON 2: Need for Orchestration and Management tool

LESSON 3: Introduction to Kubernetes.

Kubernetes Architecture:

LESSON 1: Kubernetes Components

LESSON 2: Kubernetes Master and Worker Node Architecture.

LESSON 3: Working with Kubernetes:

    • Kube API Server
    • ETCD
    • Kube Controller Manager
    • Kube Scheduler
    • Kubelet
    • Kube Proxy

BootStrap a Kubernetes Cluster on Cloud:

LESSON 1: Creating Infra ready on the cloud.

LESSON 2: Bootstrapping Master and Worker nodes using KUBEADM

LESSON 3: Other various ways to create a cluster.

Working with Kubernetes POD’s and Deployments :

LESSON 1: Overview on Pod , Container Vs Pod ???

LESSON 2: What are Namespaces, and how would they be in real time projects ?

LESSON 3: Understanding YAML.

LESSON 4: Creation of Pod’s through Imperative and Declarative.

LESSON 5: What are Labels, Selectors , Annotations and their use in K8S.

LESSON 6: Disadvantage of Pods and introduction to Deployments.

LESSON 7: Difference between ReplicaSets and Replication Controllers.

LESSON 8: Deep Dive into Deployments.

LESSON 9: Scaling Application with RC, RS , and Deployments.

LESSON 10: Deployment Strategies in Kubernetes, which are used in Production Deployments.

LESSON 11:Deploying with Blue/Green and Canary strategies

LESSON 12:Rolling updates and Rollbacks

Working with Services :

LESSON 1: What are Services in Kubernetes, and what’s the importance of using it ???

LESSON 2: Deepdive into K8S Services.

LESSON 3: Creating ClusterIP, NodePort, LoadBalancer and Headless Service.

LESSON 4: What’s an Ingress Controller and how to create them.


LESSON 1: Understanding Liveness and Readiness Probes.

LESSON 2: Installing Metrics Server in Kubernetes.

LESSON 3: Horizontal Pod Autoscaler.

LESSON 4: Automated Scaling of Application with HPA and Metric Server.

LESSON 5: Logging, Monitoring Applications and debugging.

Advanced Kubernetes Scheduling:

LESSON 1: How scheduling works in Kubernetes

LESSON 2: Manually scheduling pods on different nodes.

LESSON 3: Advanced Pod Scheduling with Node Affinity and Anti Affinity

LESSON 4:Understanding Node Taints and Pod Tolerations.

LESSON 5: Understanding INIT-Containers.

LESSON 6:Understanding DaemonSets.

LESSON 7: Static Pods

LESSON 8: Working with Resource Limits in Kubernetes.

Storage In Kubernetes:

LESSON 1: Understanding and Creating Persistent Volumes.

LESSON 2: Access modes for Volumes

LESSON 3: Understanding Persistent Volume Claims

LESSON 4: Mounting Persistent Volume in Pods

LESSON 5: What are Storage classes and Dynamic Volume Provisioning?

Kubernetes Security:

LESSON 1: How to Configure Authentication and Authorization.

LESSON 2: Configuring User Access to the cluster and Namespace

LESSON 3: How to Configure Network Policies.

LESSON 4: Working with kubeconfig and kube contexts.

LESSON 5: Understanding Various TLS certificates for Cluster Components.

LESSON 6:Working with RBAC in Kubernetes.

LESSON 7: Creating Role and Role Binding .

LESSON 8:Creating ClusterRoles and ClusterRole Bindings.

Cluster Management:

LESSON 1: Introduction to High Availability in Kubernetes.

LESSON 2: Working with OS upgrades.

LESSON 3: Draining a node safely during maintenance.

LESSON 4: Upgrading Kubernetes Cluster.

LESSON 5: Backing Up and Restoring ETCD.

Managed Kubernetes Service:

LESSON 1: Creating a High available cluster in GKE

LESSON 2: Creating various types of clusters based on requirement.

LESSON 3: Dynamic volume allocation using SC

LESSON 4: Zero downtime upgrades of cluster

LESSON 5: Private container registry(GCR)

LESSON 6: Private kubernetes cluster

LESSON 7: Binary authorization with secure webhooks


Troubleshooting in Kubernetes:

LESSON 1: Checking Cluster and Node logs

LESSON 2: Troubleshooting a broken cluster.

LESSON 3: Troubleshooting broken applications.


LESSON 1: Introduction:
  • Helm Introduction
  • Helm installation.
  • Introduction to Repository
  • Helm Component Installation.
  • How to install charts
  • Creating a New Helm Chart

LESSON 2: Chart Template:
  • Charts Templates
  • Built in Objects
  • Template functions
  • Control flow if else

LESSON 3: Introduction:
  • Helm Introduction
  • Helm installation.
  • Introduction to Repository
  • Helm Component Installation.
  • How to install charts
  • Creating a New Helm Chart

LESSON 4 :Chart Template:
  • Charts Templates
  • Built in Objects
  • Template functions
  • Control flow if else

Repository Management

Chart Management

Learn and Implement Real time projects, Get ready!!!!! 🔥

Real Time Devops Projects with Microservices Architecture.

Super Excited!!!!!!!!!!!!!!!!!

This will be one of its kind implementation, where we will be working on Projects from the Scratch

By Implementing this Complete Project, one can confidently clear any Interview and work in any company too, as we are implementing in a Production grade with Best Practices.

This will be End to End Workflow , where we will be creating a company Scenario.

Right from Gathering the requirements of the business.

Creating infrastructure for the projects we deploy.

Implement a CICD pipeline with all the tools we have learned.

Deploying the application to the production environment.

Creating jenkins pipelines from scratch.

This project consists of a complete CICD which we generally do with production grade applications.

Here are the Modules/Project we will be Implementing


    • Understanding the Company Scenario
    • Getting Familiar with Product Architecture.
    • Microservices Functional architecture along with Infrastructure Architecture.
    • Jenkins Pipeline Architecture
    • Deploying Planning for our Product in a Production Grade Setup

Module 1:

  • Implementing the Complete Infrastructure Using Terraform for creation of all tech stack we use in our project, we shall use best practices too for this creation.

Module 2:

  • Once Infra is ready we will be deploying all our configurations using Ansible, on the above Created Servers , we shall be writing many playbooks for this implementation with best practises.

Module 3:

Implementing Jenkins Master and Jenkins Slave setup for our CICD Implementations.

We shall be using both Static and Dynamic as well for these implementations to achieve advanced scenarios


Module 4:

All hands on deck !!!!!!!!

Creating a Jenkins Pipelines for all our Microservices

This will be a Complete Production Grade Pipeline with many reusable methods written in Groovy

Module 4a:

    • Github Organisation Setup 
    • Implementing Multi Branch Pipelines
    • Jenkins with Build Integration , and creating methods
    • Jenkins with Sonar Integration with Quality gates implementation
    • Jenkins with Nexus integration for all artifacts 
    • Jenkins with Docker Integration for all our Microservices image creations using Dockerfile
    • Jenkins with Docker Deployments on different environments with prod approval steps and production grade deployment pipeline

Module 6:

Create Dockerfiles and Jenkins Pipelines for our frontend based application.

Modifying the Source code and deploying the application in different environments

Create a web server with reverse proxy configurations to access our application


Module 7:

Implementing Kubernetes in our Pipeline.

Creating Terraform manifest files and creating Kubernetes Clusters.

Configuring kubernetes prerequisite on the Jenkins Slave using Ansible

Creating Manifest files for all our Microservices and Frontend applications to deploy in Kubernetes

Modifying the existing pipelines to add the Kubernetes Deployment stage 

Module 8:

Creating Shared Libraries in jenkins for all our applications.

This will be helping us to reuse the same methods and pipelines across the Organization (Super Cool and advanced!!!!!)

Module 9:

Implementing Helm Charts in our Pipeline

Creating Charts with environment based values and integrating with Shared Libraries for Our Deployment

Module 10:

Advanced Kubernetes Admin operations with Jenkins pipelines

We will Create multiple jobs to make sure we are giving developers an easy deployment for all their activities without us being involved in all stages.


What is Devops ? Understand from a Real World Scenario