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

Devops
Culture

Git

linux

Maven

Nexus

Sonarqube

Jfrog

Jenkins

Ansible

Terraform

Docker

Kubernetes

prometheus & grafana

Roles & Responibilities

Interview Preperation

Resume Preperation

NAVIGATING THE DEVOPS MASTERY JOURNEY.

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

Linux

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

Maven

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

Nexus

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 .

Tomcat

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

Sonarqube

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


Project


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

Jfrog

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

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

Docker

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

Terraform

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


Project: 

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

Ansible

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.

Observability:

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.

Helm:

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


Prerequisite:

    • 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