• 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.

• 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

• IP Addressing & Subnetting
• Understand IPv4 addresses, CIDR notation (192.168.1.0/24), public vs. private IPs
• Basic subnetting for network segmentation
• DNS (Domain Name System)
• How DNS resolution works (A, CNAME records)
• Critical for service discovery (myservice.internal) and external access
• TCP/UDP & Ports
• Key difference: TCP (reliable, connection-oriented) vs UDP (fast, connectionless)
• Common ports: 22 (SSH), 80/443 (HTTP/HTTPS), 8080 (apps), 53 (DNS)
• Know how to check/listen on ports (netstat, ss)
• Load Balancing
• Distribute traffic across multiple servers (Layer 4 TCP vs Layer 7 HTTP)
• Key for high availability (AWS ALB/NLB, NGINX, HAProxy)
• Firewalls & Security Groups
• How traffic filtering works (inbound/outbound rules)
• Cloud Security Groups (AWS, Azure) and iptables basics
• VPN & VPC (Cloud Networking)
• Virtual Private Cloud: Isolated cloud networks with subnets, route tables
• VPNs for secure site-to-site or remote access
• Network Troubleshooting Tools
• ping: Basic connectivity test
• traceroute / mtr: Path analysis
• nslookup / dig: DNS troubleshooting
• curl: HTTP/API testing
• netcat (nc): Raw TCP/UDP connections

• 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
• GitHub Codespaces, organizations, projects, pages, webhooks

• 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

• Introduction to Trivy 
• Installing Trivy 
• Scanning filesystems with trivy 
• Scanning configuration files, git repos, for vulnerabilities

• sonarqube and sonarcloud introduction.
• Sonarqube architecture
• Installing and configuring sonarqube, sonar-scanner
• Creating sonarway profiles and quality gates
• Report generation
• Identifying and fixing issues

• 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 globalsettings.
• 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.

• 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

• 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

• 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.

• 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

• Understand what Prometheus is and its role in monitoring.
• Install Prometheus: Set up Prometheus on Linux
• Understand Metrics
• Configure Prometheus: Write prometheus.yml for scraping targets.
• Set Up Targets: Add endpoints for Prometheus to scrape metrics.
• Use Exporters
• Learn Grafana Basics
• Install Grafana: Set up Grafana on Linux
• Connect Data Sources: Add Prometheus data source to grafana
• Create Dashboards
• Add panels (e.g., graphs, tables, gauges) to dashboards.
• Write Queries: Use PromQL or other query languages to fetch data.
• Set Up Alerts: Configure Grafana alerts for critical metrics.

• 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
• AWS VPC: Isolated virtual network for AWS resources with complete control
• AWS RDS: Managed relational database service for multiple engines
• Additional AWS Solutions Architect Associate concepts

Your task is to perform the following steps manually for a Java web application: 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

Your task is to 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.
• If the pipeline fails, Jenkins should send email notifications and Slack notifications.
• The pipeline should automatically trigger when code is pushed to GitHub.

• Your task is to 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.
• Additionally:
• 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

• 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.

The goal is to build a CI/CD pipeline for the real time 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.

• 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)

• 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
• AI courses on Youtube

X-Ops is an umbrella term for the proliferation of "___Ops" methodologies that extend DevOps principles into specific domains. It represents the specialization and expansion of the collaborative, automated, and continuous delivery mindset beyond just Development and Operations.

Think of it as: DevOps philosophy applied to specialized areas. You are given introductions to all the X-Ops concepts. 

• DevOps (Development + Operations)
• DevSecOps (Development + Security + Operations)
• GitOps (Git + Operations)
• AIOps (Artificial Intelligence + Operations)
• DataOps (Data + Operations)
• MLOps / ModelOps (Machine Learning + Operations)
• Platform Engineering

Cloud & Infrastructure Focused

• CloudOps (Cloud + Operations)
• FinOps (Finance + Operations)
• NetOps (Network + Operations)
• SecOps (Security + Operations)
• ChatOps (Chat + Operations)
• NoOps (No Operations)

Business & Domain Focused

• BizOps (Business + Operations)
• MarketingOps (Marketing + Operations)
• SalesOps (Sales + Operations)
• HR/Ops (Human Resources + Operations)
• LegalOps (Legal + Operations)
• ProductOps (Product + Operations)
• DesignOps (Design + Operations)
• Process & Methodology
• AgileOps (Agile + Operations)
• SRE (Site Reliability Engineering)
• ITOps (IT Operations)
• OpsDev (Operations-led Development)

Industry Specific

• GovOps (Government + Operations)
• EduOps (Education + Operations)
• HealthOps / MedOps (Healthcare + Operations)
• RetailOps (Retail + Operations)

Specialized Technical

• TestOps (Testing + Operations)
• DocOps (Documentation + Operations)
• OpsOps (Meta-operations)
• ObservabilityOps (Observability + Operations)
• ComplianceOps (Compliance + Operations)