DevOps Training in Hyderabad
with Practical Training

• • Week-1

    • Introduction to Linux OS
    • Linux file system hierarchy
    • Basic commands: ls, cd, pwd, mkdir, rm, cp, mv, touch
    • File permissions and ownership: chmod, chown, chgrp
    • Text editors: nano, vim, vi
    • Creating and managing users: useradd, usermod, userdel
    • Creating and managing groups: groupadd, groupmod, groupdel
    • Switching users: su, sudo
    • Viewing processes: ps, top, htop
    • Killing processes: kill, pkill, killall
    • Managing services: systemctl, service
    • Installing and removing packages: apt, yum, dnf, rpm, dpkg
    • Updating and upgrading packages
    • Managing repositories
    • Disk partitioning: fdisk, parted
    • Mounting and unmounting file systems: mount, umount
    • Checking disk usage: df, du
    • Managing swap space
    • Network configuration: ifconfig, ip, nmcli
    • Remote access: ssh, scp, rsync
    • Monitoring system performance: top, htop, vmstat, iostat
    • File permissions and ACLs
    • Cron jobs: crontab
    • Environment variables: export, env
    • Shell configuration files: .bashrc, .bash_profile, /etc/profile

  • Shell Scripting

    • Writing and executing scripts: #!/bin/bash
    • Variables and data types
    • Command substitution: $(…), backticks
    • Reading input: read
    • Printing output: echo, printf
    • Redirection: >, >>, <, |
    • if, else, elif
    • Comparison operators: -eq, -ne, -lt, -gt, -le, -ge
    • File and string tests: -f, -d, -z, -n
    • for loops, while loops, until loops
    • Loop control: break, continue
    • Functions

Week-2

• • • What is version control?
    • Centralized vs Distributed version control systems
    • Introduction to Git and GitHub
    • Installing Git and setting up GitHub account
    • Initializing a Git repository: git init
    • Checking the status of a repository: git status
    • Staging changes: git add
    • Committing changes: git commit
    • Viewing commit history: git log
    • Ignoring files: .gitignore
    • Cloning a repository: git clone
    • Adding a remote repository: git remote add
    • Pushing changes to GitHub: git push
    • Pulling changes from GitHub: git pull
    • Forking a repository on GitHub
    • Creating pull requests (PRs)
    • Stashing changes: git stash
    • Rebasing: git rebase
    • Cherry-picking commits: git cherry-pick
    • Tagging releases: git tag
    • Reverting changes: git revert, git reset
    • GitHub Issues: Creating, assigning, and closing issues
    • GitHub Projects: Managing tasks and workflows
    • GitHub Wiki: Creating documentation for repositories
    • GitHub Discussions: Starting and participating in discussions
    • GitHub Actions, Codespaces, organizations, projects, pages, webhooks

  • Projects

    • Project-1: Build and Deploy a Personal Portfolio Website
      • Hosted on GitHub Pages
      • Automated build and deployment with GitHub Actions
      • Development with GitHub Codespaces
    • Project-2: Generate source code for a Java-based Netflix clone project with Github Co-Pilot

• Week-3

  • Maven
    • Introduction to Maven
    • Structure of maven POM.xml file
    • Maven Repositories
    • Build Lifecycle: Maven’s lifecycle phases (validate, compile, test, package, verify, install, deploy)
    • Plugins and Goals
  • Trivy
    • Introduction to Trivy
    • Installing Trivy
    • Scanning filesystems with Trivy
    • Scanning configuration files, git repos, for vulnerabilities
  • Sonarqube and SonarCloud
    • Introduction to Sonarqube and SonarCloud
    • Sonarqube architecture
    • Installing and configuring Sonarqube, Sonar-Scanner
    • Creating Sonarway profiles and quality gates
    • Report generation
    • Identifying and fixing issues
  • Nexus
    • Introduction to Sonatype Nexus
    • Installing Nexus, exploring the dashboard
    • Understanding and managing different types of repositories
    • Exploring advanced Nexus capabilities
    • Deploying artifacts into Nexus snapshots/releases repositories
  • Apache Tomcat
    • Introduction to Tomcat
    • Installing Tomcat on Windows and Linux Machines
    • Understanding the directory structure of Tomcat
    • Configuring Tomcat and exploring files server.xml, tomcat-users.xml
    • Deploying applications to Tomcat webapps directory
    • Exploring the logs and monitoring logs for debugging and troubleshooting

• Project-3: End-to-End DevOps Workflow with Maven, Trivy, SonarQube, Nexus, and Tomcat

  • Compile the Code: Use Maven to compile the project
  • Run Unit Tests: Execute unit tests using Maven
  • Scan for Vulnerabilities: Use Trivy to scan the project directory for vulnerabilities
  • Analyze Code Quality: Use SonarQube to analyze the code quality
  • Package the Artifact: Package the application into a WAR file using Maven
  • Upload Artifact to Nexus: Upload the WAR file to a Nexus repository
  • Deploy to Tomcat: Download the WAR file from Nexus and deploy it to Apache Tomcat

• Weeks-4,5

  • Introduction to Jenkins
    • What is Jenkins?
    • Role of Jenkins in CI/CD pipelines
    • Jenkins architecture: Master, agents, and plugins
  • Installing and configuring Jenkins
    • Installing Jenkins on Linux, Windows, and Docker
    • Initial setup: Unlocking Jenkins, installing plugins, and configuring global settings
    • Upgrading Jenkins
  • Jenkins UI Overview
    • Navigating the Jenkins dashboard
    • Understanding jobs, builds, and logs
    • Managing plugins and configurations
  • Configuring email notifications
    • Creating and managing jobs
  • Types of jobs: Freestyle, Pipeline, and Multi-branch Pipeline
    • Configuring job parameters, triggers, and build steps
    • Scheduling jobs using cron syntax
  • Pipeline as Code
    • Introduction to Jenkinsfile
    • Declarative Pipeline vs Scripted Pipeline
    • Writing basic pipelines: Stages, steps, and post-actions
    • Parameterized Builds
    • Advanced pipeline features: Parallel stages, error handling, and retries
  • Integrations
    • Integrating Jenkins with version control systems (Git, GitHub, GitLab)
    • Integrating Jenkins with build tools (Maven, Gradle, npm)
    • Integrating Jenkins with Docker and Kubernetes
    • Integrating Jenkins with artifact repositories (Nexus, Artifactory)
  • Artifact Management
    • Publishing and archiving build artifacts
    • Using fingerprinting to track artifacts
    • Deploying artifacts to staging/production environments
  • Best Practices
    • Writing reusable and maintainable pipelines
    • Optimizing Jenkins performance
    • Managing Jenkins configurations as code
    • Automations with Github Webhooks, communications, and collaborations
    • Implementing backup and recovery strategies

• Projects

  • Project-4: End-to-End CI/CD Pipeline with Git, Jenkins, Maven, Nexus, Tomcat, and SonarQube (Java-based project)
    • Project Description
      • Create a CI/CD pipeline for a Java web application using the following tools:
        1. Git/GitHub: For version control
        2. Jenkins: For automating the pipeline
        3. Maven: For building and testing the application
        4. Nexus: For storing the build artifact (WAR file)
        5. Tomcat: For deploying the application
        6. SonarQube: For code quality analysis
      • Additional requirements:
        • If the pipeline fails, Jenkins should send email notifications and Slack notifications
        • The pipeline should automatically trigger when code is pushed to GitHub
  • Project-5: End-to-End CI/CD Pipeline for a Node.js Application
    • Project Description
      • Create a CI/CD pipeline for a Node.js application using the following tools:
        1. Git/GitHub: For version control
        2. Jenkins: For automating the pipeline
        3. npm: For building and testing the application
        4. Nexus: For storing the build artifact (Docker image or tarball)
        5. SonarQube: For code quality analysis
      • Additional requirements:
        • If the pipeline fails, Jenkins should send email notifications and Slack notifications
        • The pipeline should automatically trigger when code is pushed to GitHub
        • Use Jenkins master-slave architecture for this project

• Additional Learning Activities

  • 2 days of break
  • Time given to practice all the concepts learned till this module and complete all the assignments
  • Interview questions
  • Live assessment
  • Review Sessions

Week-6

• Introduction to Docker
  • What is Docker and why is it used?
  • Docker architecture: Docker Engine, Images, Containers, and Registries
  • Difference between Docker and virtual machines
• Installing Docker on Linux and Windows
  • Docker Images
    • Understanding Docker images and layers
    • Pulling images from Docker Hub: docker pull
    • Listing images: docker images
  • Docker Containers
    • Running containers: docker run
    • Listing running containers: docker ps
    • Stopping and removing containers: docker stop, docker rm
  • Dockerfile
    • Writing a Dockerfile: FROM, RUN, COPY, CMD, ENTRYPOINT
    • Building Docker images: docker build
    • Best practices for writing Dockerfiles
  • Docker Volumes
    • Understanding Docker volumes
    • Creating and managing volumes: docker volume create
    • Mounting volumes in containers
  • Docker Networking
    • Docker network types: Bridge, Host, None
    • Creating custom networks: docker network create
    • Connecting containers to networks
  • Docker Compose – Multi Container Architecture
    • Introduction to Docker Compose
    • Writing docker-compose.yml files
    • Starting and stopping multi-container applications
  • Docker Registries
  • Docker Security
  • Docker Swarm
    • What is Docker Swarm and why use it?
    • Docker Swarm architecture: Managers and Workers
    • Setting up Docker Swarm
    • Docker Services
    • Docker Stack
    • Docker Swarm Networking
    • Docker Swarm Security

• Week-7

  • Introduction to Kubernetes
    • What is Kubernetes and why use it?
    • Kubernetes architecture: Master, Nodes, Pods, and Clusters
  • Installing Kubernetes
    • Setting up a Kubernetes cluster using Minikube or kubeadm
    • Installing kubectl: The Kubernetes CLI
  • Kubernetes Objects
    • Understanding Pods, Deployments, Services, and ConfigMaps
    • Creating and managing objects using YAML files
  • Deploying applications
    • Deploying applications using kubectl apply
    • Rolling updates and rollbacks: kubectl rollout
  • Kubernetes Networking
    • ClusterIP, NodePort, and LoadBalancer services
    • Ingress controllers for external access
  • Kubernetes Storage
    • Persistent Volumes (PVs) and Persistent Volume Claims (PVCs)
    • Dynamic provisioning of storage
  • Kubernetes Security
    • Role-Based Access Control (RBAC)
    • Managing secrets: kubectl create secret
  • Kubernetes Monitoring and Logging
    • Using kubectl logs for container logs
    • Monitoring with Prometheus and Grafana
  • Helm Charts
  • Kubernetes Operators
  • Kubernetes Best Practices
    • Resource limits and requests
    • Liveness and readiness probes
    • Horizontal Pod Autoscaling (HPA)
  • Kubernetes Production Level
    • Setting up KOPS
    • Backup and disaster recovery strategies

• Project-6

  • Deploy a multi-container application using Docker Compose
  • Set up a Docker Swarm cluster and deploy a service
  • Deploy a microservices application on Kubernetes
  • Implement CI/CD pipelines for Kubernetes using Jenkins or GitLab CI

Week-8

• Introduction: Understand what Ansible is and its role in DevOps
  • Install Ansible on Linux
  • Learn static and dynamic inventory management
  • Execute quick tasks using ad-hoc commands
  • Create YAML-based playbooks for automation
  • Use common modules like yum, apt, copy, and template
  • Use variables in playbooks and inventory files
  • Use ansible_facts for dynamic configurations
  • Apply when for conditional task execution
  • Use with_items or loop for repetitive tasks
  • Trigger tasks with notify for idempotent changes
  • Structure playbooks using roles for reusability
  • Generate dynamic files with Jinja2 templates
  • Encrypt sensitive data using Ansible Vault
  • Use ignore_errors and blocks for error handling
  • Tag Tasks: Use tags for selective task execution
  • Automate Config Management: Manage server configurations with playbooks
  • Automate application deployment workflows
  • Use Ansible for AWS, Azure, or GCP automation
  • Automate Docker container management with Ansible
  • Deploy and manage Kubernetes clusters
  • Write reusable, maintainable, and version-controlled playbooks
  • Automate server setup, app deployment, and cloud provisioning

• Week-9

  • Introduction to Terraform
    • Install Terraform on Linux and Windows
    • Master HCL Syntax
    • Write Terraform Configs: Create .tf files to define infrastructure
    • Use Providers: Configure providers (e.g., AWS, Azure, GCP) for cloud resources
    • Manage State: Understand Terraform state files and their importance
    • Use Variables: Define and use variables for dynamic configurations
    • Use Outputs: Extract and display resource attributes using outputs
    • Use Modules: Organize and reuse code with Terraform modules
    • Explore Public Modules: Use modules from the Terraform Registry
    • Manage Dependencies: Use depends_on for explicit resource dependencies
    • Use Data Sources: Fetch external data (e.g., AMI IDs) using data sources
    • Handle Provisioners: Use local-exec and remote-exec for post-creation tasks
    • Use Workspaces: Manage multiple environments
    • Backend Configuration: Store state files remotely using backends
    • Automate with CI/CD: Integrate Terraform with Jenkins, GitLab CI, or GitHub Actions
    • Use Terraform CLI: Master commands like init, plan, apply, and destroy
    • Validate Configs: Use terraform validate to check syntax
    • Format Code: Use terraform fmt for consistent formatting
    • Secure Secrets: Use tools like HashiCorp Vault for managing secrets
    • Intro to OpenTofu

• Project-7: Realtime End-to-End CI/CD Pipeline

  • The goal is to build a CI/CD pipeline for the OpenTelemetry application, incorporating code management, build automation, security scanning, artifact storage, deployment, observability, and infrastructure as code
    • Git: Version control for the OpenTelemetry repository
    • Jenkins: CI/CD automation for building, testing, and deploying the application
    • Maven: Build tool for Java-based microservices in the project
    • Trivy: Vulnerability scanning for Docker images and dependencies
    • Nexus: Artifact repository for storing build artifacts (e.g., WAR files, Docker images)
    • Tomcat: Application server for deploying Java-based services
    • SonarQube: Code quality and security analysis
    • Docker: Containerization of microservices
    • Kubernetes: Orchestration of containerized microservices
    • Ansible: Configuration management for infrastructure and deployment
    • Terraform: Infrastructure as Code (IaC) for provisioning cloud resources
    • Prometheus: Monitoring and alerting for the application and infrastructure
    • Grafana: Visualization of metrics and logs collected by Prometheus

Week-10

• Implementing DevOps activities with AWS cloud services
  • IAM: For secure access management
  • S3: For storing build artifacts and logs
  • AWS CodePipeline: For orchestrating the CI/CD pipeline
  • AWS CodeBuild: For building and testing the application
  • AWS CodeDeploy: For deploying the application
  • AWS CloudFormation: For Infrastructure as Code (IaC)
  • Amazon SNS, SQS, and SES: For notifications and event-driven workflows
  • Amazon EKS: For container orchestration
  • Amazon ECR: For storing Docker images
  • Cloud workshop session
    • Introduction to the Cloud Computing
    • Cloud Computing Advantages, Disadvantages
    • Cloud computing Deployment Models
    • Cloud computing service Models
    • Cloud Shared Responsibility Model
    • DevOps on Various Cloud providers (AWS, Azure, and GCP)

Week-11

• Intro to Azure DevOps portal
  • Explore and understand Azure boards, repos, pipeline, artifacts, AKS, etc.
• Project Overview
  • The goal is to build a CI/CD pipeline for a sample application (e.g., a web app or microservice) using Azure DevOps portal
    • Version Control: Using Azure Repos
    • CI/CD: Using Azure Pipelines
    • Artifact Management: Using Azure Artifacts
    • Infrastructure as Code (IaC): Using Azure Resource Manager (ARM) templates
    • Deployment: To Azure App Service or Azure Kubernetes Service (AKS)
    • Monitoring: Using Azure Monitor and Application Insights

Week-12

• Implementing DevOps activities with Google Cloud
  • Project Overview
    • The goal is to build a CI/CD pipeline for a sample application (e.g., a web app or microservice) using the following Google Cloud services:
      • Version Control: Using Cloud Source Repositories
      • CI/CD: Using Cloud Build
      • Artifact Management: Using Artifact Registry
      • Infrastructure as Code (IaC): Using Deployment Manager or Terraform with GCP
      • Deployment: To Google Kubernetes Engine (GKE) or Cloud Run
      • Monitoring: Using Cloud Monitoring and Cloud Logging

• Week-13

  • Digital Ocean Cloud – students implement a project on this cloud
  • Resume Preparation
  • Interview Questions and Answers discussion
  • Mock Interview
  • Next Steps

• Bonus Courses:

  • Python for DevOps Course
  • ArgoCD GitOps course
  • Access to workshops and Seminars