DevOps Engineering Training

RexGalaxy Academy's DevOps Engineering Training is a practical, project-based program designed for learners who want to build modern software delivery, automation, cloud deployment and infrastructure management skills. The course follows the broad structure of traditional DevOps training while making it suitable for trending technology learners who want hands-on exposure to CI/CD, containers, cloud, monitoring and automation workflows.

This course helps students understand how development and operations teams work together to release software faster, safer and more reliably. Learners practice Linux commands, Git and GitHub workflows, scripting basics, build automation, Jenkins pipelines, Docker containers, Kubernetes orchestration, AWS deployment basics, infrastructure as code, monitoring, logging and end-to-end project delivery.

The training is focused on real tools and job-ready workflows. Students learn how code moves from developer machines to repositories, build servers, test stages, containers, cloud servers and production-like environments. Along with tools, learners also develop DevOps thinking: automation first, repeatable deployment, version control, collaboration, observability, security awareness and continuous improvement.

Students should be able to:

• Understand DevOps culture, CI/CD workflow, automation practices and software delivery lifecycle.

• Work with Linux, Git, GitHub, shell commands and basic scripting for DevOps tasks.

• Build CI/CD pipelines using Jenkins and connect them with repositories, build steps and deployment actions.

• Containerize applications using Docker and manage container images, volumes, networks and registries.

• Understand Kubernetes basics including pods, deployments, services, scaling and configuration.

• Deploy cloud-ready projects with AWS basics, infrastructure planning, monitoring, logging and documentation.

• Build portfolio-ready DevOps projects with pipeline screenshots, architecture diagrams and interview-ready explanations.

Start with DevOps fundamentals and understand how modern teams deliver software faster and more reliably.

• Understand what DevOps means and how it connects development, testing, operations, security and business delivery.

• Learn the difference between traditional release models and modern continuous delivery workflows.

• Understand the software development lifecycle, release lifecycle, deployment stages and production support awareness.

• Learn DevOps culture concepts such as collaboration, automation, feedback, shared responsibility and continuous improvement.

• Understand CI, CD, continuous testing, continuous monitoring and continuous deployment at a practical level.

• Explore common DevOps tools such as Linux, Git, GitHub, Jenkins, Docker, Kubernetes, AWS, Terraform and monitoring platforms.

• Understand the role of a DevOps engineer, cloud engineer, release engineer and site reliability engineer at a beginner level.

• Learn why automation, repeatability, version control and observability are important for real-world software delivery.

• Study basic architecture flow from code commit to build, test, containerization, deployment and monitoring.

• Outcome: build a strong DevOps mindset before learning individual tools and pipelines.

Develop Linux command-line confidence because most DevOps environments run on Linux servers.

• Understand Linux operating system basics, distributions, terminal usage and server access concepts.

• Learn file and directory commands such as pwd, ls, cd, mkdir, cp, mv, rm, cat, less, head, tail and find.

• Work with file permissions, ownership, chmod, chown and permission troubleshooting.

• Learn user management basics, groups, sudo access and secure administrative practices.

• Understand process management using ps, top, kill, systemctl and service status checks.

• Learn networking commands such as ping, curl, wget, netstat or ss, ip, hostname and port testing.

• Practice log reading using tail, grep, journalctl awareness and application log troubleshooting.

• Understand package management, software installation, updates and repository awareness.

• Practice server preparation tasks for application deployment and DevOps tooling installation.

• Outcome: confidently use Linux servers for deployment, troubleshooting and automation work.

Learn Git and GitHub workflows used by development and DevOps teams for source code management.

• Understand version control, repositories, commits, branches, merges and collaboration workflows.

• Install and configure Git with username, email, authentication awareness and local repository setup.

• Practice Git commands such as init, clone, status, add, commit, log, diff, branch, checkout, merge and pull.

• Understand remote repositories, origin, push, pull, fetch and tracking branches.

• Learn GitHub workflow including repository creation, README files, issues, pull requests and code review awareness.

• Understand branching strategies such as feature branches, main branch, release branch and hotfix awareness.

• Practice resolving common Git problems such as merge conflicts, wrong branch work and uncommitted changes.

• Learn .gitignore usage, repository hygiene and keeping secrets out of source code.

• Connect GitHub repositories with CI/CD tools like Jenkins for automated build triggers.

• Outcome: manage code professionally and prepare repositories for pipeline automation.

Use shell scripting to automate repetitive DevOps tasks and improve operational productivity.

• Understand shell scripting purpose, script files, shebang, execution permissions and running scripts safely.

• Learn variables, input, output, command substitution, conditions, loops and basic functions in shell scripts.

• Practice scripting for file management, backups, log checks, service checks and deployment preparation.

• Use grep, awk, sed awareness and text processing concepts for log and configuration handling.

• Learn exit codes, error handling, command chaining and basic debugging techniques.

• Create scripts for checking disk usage, server health, package installation and application status.

• Understand cron job basics for scheduled automation tasks.

• Learn safe scripting habits including validation, comments, readable naming and avoiding destructive commands.

• Use scripts inside Jenkins or deployment workflows for repeatable automation.

• Outcome: write simple automation scripts that support DevOps pipelines and server operations.

Understand application build, packaging and deployment basics before creating full CI/CD pipelines.

• Learn how applications are built, packaged, tested and deployed in real software projects.

• Understand build tools and dependency management awareness for Java, Node.js, Python or similar stacks.

• Learn artifact concepts including build files, packages, binaries, Docker images and release versions.

• Understand environment configuration, environment variables, ports, secrets awareness and deployment folders.

• Practice manual application deployment steps on Linux servers before automating them.

• Learn service management, restart strategies, log checks and health verification after deployment.

• Understand build failures, dependency errors, version mismatch and environment-specific problems.

• Learn basic testing stages such as unit test awareness, smoke test awareness and deployment validation.

• Prepare applications for pipeline automation by documenting commands and required dependencies.

• Outcome: understand what CI/CD tools automate and why deployment steps must be repeatable.

Build CI/CD pipeline fundamentals using Jenkins, one of the most widely used DevOps automation tools.

• Understand Jenkins purpose, controller-agent concept, jobs, plugins, workspaces and build history.

• Install and configure Jenkins basics with secure access, plugin setup and initial administration awareness.

• Create freestyle jobs connected to GitHub repositories for automated build execution.

• Configure source code management, build triggers, build steps and post-build actions.

• Understand polling, webhooks awareness and how code changes can trigger pipeline execution.

• Run basic commands from Jenkins to build, test or deploy sample applications.

• Learn how Jenkins stores logs, build status, artifacts and job configuration.

• Troubleshoot common Jenkins problems such as plugin issues, permission errors, wrong commands and missing tools.

• Practice a simple pipeline from GitHub code checkout to build and deployment command execution.

• Outcome: create basic Jenkins jobs and understand CI/CD automation flow.

Move deeper into Jenkins pipelines and learn practical automation patterns for real projects.

• Understand declarative pipeline syntax, Jenkinsfile usage and pipeline-as-code benefits.

• Learn pipeline stages such as checkout, build, test, package, docker build, deploy and post actions.

• Use environment variables, credentials awareness and parameterized builds in Jenkins pipelines.

• Understand agents, workspace cleanup, artifact archiving and pipeline logs.

• Practice creating Jenkinsfiles stored inside GitHub repositories for version-controlled pipelines.

• Learn basic pipeline failure handling, notifications awareness and retry or post-build strategies.

• Connect Jenkins with Docker commands for image build and container deployment workflows.

• Understand approval stages, deployment gates and separating development, staging and production environments.

• Build a multi-stage CI/CD pipeline for a sample application with clear documentation.

• Outcome: automate real software delivery workflows using Jenkins pipeline-as-code.

Learn Docker to containerize applications and create consistent deployment environments.

• Understand containers, images, Docker Engine, Docker Hub, registries and container lifecycle.

• Learn why containers solve environment mismatch problems between development, testing and production.

• Write Dockerfiles with base images, working directory, copy commands, dependency installation and startup command.

• Build Docker images, run containers, inspect logs, stop containers and remove unused resources.

• Understand port mapping, environment variables, container names and restart behavior.

• Work with Docker volumes for persistent data and Docker networks for container communication.

• Push and pull images from container registries with version tags and naming discipline.

• Learn Docker Compose awareness for multi-container application setups.

• Practice containerizing a sample web application and running it locally or on a cloud server.

• Outcome: package applications into Docker images and run them in repeatable container environments.

Understand Kubernetes basics for managing containers at scale in production-like environments.

• Learn why Kubernetes is used for orchestration, scaling, self-healing and container management.

• Understand cluster concepts including nodes, control plane awareness, pods, deployments and services.

• Learn YAML manifest basics and how Kubernetes resources are defined declaratively.

• Create pods and deployments, expose applications using services and understand service types.

• Practice scaling replicas, rolling updates, rollback awareness and deployment status checks.

• Understand ConfigMaps, Secrets awareness, namespaces and resource organization basics.

• Learn container image pull flow and how Kubernetes runs application containers.

• Troubleshoot common Kubernetes issues such as image pull errors, crash loops, wrong ports and service exposure problems.

• Understand how Kubernetes connects with CI/CD pipelines and cloud deployment workflows.

• Outcome: understand Kubernetes fundamentals and deploy simple containerized applications.

Connect DevOps skills with AWS cloud services for practical deployment and infrastructure hosting.

• Understand how AWS supports DevOps with compute, storage, networking, identity, monitoring and deployment services.

• Review AWS fundamentals including regions, availability zones, IAM, EC2, S3, VPC and security groups.

• Deploy applications on EC2 servers and connect them with Git, Jenkins or Docker workflows.

• Store build artifacts, backups or static files using S3 with security awareness.

• Understand VPC basics, public subnets, ports, SSH access and server security configuration.

• Learn Elastic Load Balancer and Auto Scaling awareness for scalable deployments.

• Understand CloudWatch basics for monitoring server metrics, logs and alarms.

• Practice deploying a sample application to AWS using manual and pipeline-supported steps.

• Discuss cloud cost awareness, cleanup habits and budget safety for students.

• Outcome: use AWS basics as a practical platform for DevOps project deployment.

Learn infrastructure automation, monitoring and logging concepts used in production DevOps environments.

• Understand infrastructure as code and why teams define infrastructure in reusable configuration files.

• Learn Terraform or CloudFormation awareness including providers, resources, variables, plan and apply concepts.

• Understand configuration management awareness and how tools help maintain server consistency.

• Learn monitoring concepts including metrics, logs, dashboards, alerts and incident response basics.

• Use CloudWatch, Prometheus/Grafana awareness or similar tools to understand observability workflows.

• Understand logging practices, centralized logs, error tracking and troubleshooting from application logs.

• Learn backup, recovery, uptime, health checks and basic reliability planning.

• Understand security awareness in DevOps including secrets management, IAM permissions and dependency risks.

• Practice documenting infrastructure diagrams, monitoring checks and alert conditions for projects.

• Outcome: understand how automation and observability improve reliability and production readiness.

Complete portfolio-ready DevOps projects and prepare for interviews, resumes and real-world work.

• Build an end-to-end DevOps project from GitHub code repository to Jenkins pipeline, Docker image and cloud deployment.

• Create a CI/CD pipeline with stages for checkout, build, test awareness, Docker build, image push and deployment.

• Deploy a containerized application on AWS EC2 or a Kubernetes-based environment with proper documentation.

• Add monitoring and log review steps to show operational readiness after deployment.

• Prepare architecture diagrams showing developer, GitHub, Jenkins, Docker, registry, cloud server and users.

• Document every project with problem statement, tools used, setup steps, screenshots, pipeline output and troubleshooting notes.

• Practice interview questions on Linux, Git, Jenkins, Docker, Kubernetes, AWS, CI/CD and automation.

• Prepare resume bullet points that highlight practical pipelines, deployments, cloud and container skills.

• Review common mistakes such as weak Linux basics, copied pipelines, missing documentation and unclear project explanation.

• Outcome: build confidence to present DevOps skills for internships, jobs, freelance projects and technical interviews.