In this course you will learn how to apply DevOps. Why DevOps? It is one of the most sought after skills in the IT industry.

The course is aimed at software engineers and system administrators that want to deliver better software. Other IT professionals can also take this course, but might have to do some extra research to understand some of the concepts.

You will learn how to improve the Software Development Lifecycle by applying techniques to improve software delivery. We will explain how to improve delivery using automation, configuration management,provisioning and deployment tools. We also cover newer tools like Docker and Kubernetes.

The course is very practical. There is about 20 hours of Live instructor led online training.The sessions are completely interactive.


Course Curriculum –

Course Introduction

  1. How the course is structured and what the learning objectives are.
  2. We will try to understand the concepts of DevOps and why it is introduced in IT.
  3. We will understand the impact of it in the industry as a whole and how it affects typical job roles.
  4. Focus will be on identifying the gaps between current understanding and devops vision.
  5. There are several terms in devops such as infrastructure as a code, continuous integration, continuous delivery, continuous testing etc. Understanding them in concept is important.
  6. At this part we will try to understand theoretical and philosophical approaches of devops.

Lab Setup

  1. Next we will implement all the necessary tools on the lab systems to be able to have a common setup on which we will bring up our systems.
  2. We will implement tools that make your windows system behave like linux including even a package management system like yum on your windows system.
  3. We will replace your notepad, we will learn to build our laptop as a developer workstation.
  4. Systems would be tested at this stage for fitment of doing the lab. In case due to technical limitations, systems are found not to be capable, alternative arrangements can be made (conditions apply).

Section A – Infrastructure Automation

Virtualization Automation with Vagrant

  1. First thing that we are going to learn is about automating and abstracting virtualization complexities
  2. Understanding various approaches used in automating virtualization
  3. Learning virtualization automation with Vagrant
  4. Vagrant’s use case as Workstation Standardization
  5. Vagrant as Infrastructure as Code
  6. Vagrant as Desired State Configuration Management
  7. Vagrant providers
  8. Vagrant Commands
  9. Vagrantfile
  10. Using Vagrant to launch multiple systems at once
  11. Familiarity with Vagrant Boxes
  12. Exporting and Importing Vagrant Boxes
  13. Using Vagrant to bootstrap a system with shell scripts
  14. Impact of Vagrant in DevOps timeline optimization
  15. Understanding vendor behind Vagrant
  16. Where to position Vagrant and where not to

Docker – Enabling Immutable Infrastructure

  1. Introduction to Containerization
  2. Understanding Linux Containers
  3. Using LXC
  4. Understanding benefits of docker over LXC
  5. Understanding Docker Architecture
  6. Implementing Docker
  7. Docker commands to start, manage and stop containers
  8. Running docker containers in interactive mode
  9. Understanding ephemeral behavior of docker
  10. Data persistence in docker
  11. Network Stack of docker
  12. Understanding Docker repositories
  13. Using docker hub
  14. Creating own docker images and submitting to Hub
  15. Creating docker image from docker file
  16. Managing docker at scale
  17. Understanding docker’s use case as deployment tool
  18. Understanding concept of Immutable Infrastructure

Kubernetes – Orchestrating Dockers

  1. What is orchestration
  2. Why Kubernetes is required
  3. Understanding of Swarm vs Kubernetes vs Mesos
  4. Understanding Kubernetes Architecture
  5. Implementing Kubernetes cluster on 4 Servers
  6. Managing docker lifecycle using Kubernetes
  7. Creating a deployment in Kubernetes
  8. Managing deployment
  9. Deleting Deployment
  10. Scaling of containers on Kubernetes
  11. Exploring container logs in kubernetes
  12. Understanding Kubernetes Docker Placements
  13. Implementing and Using GUI for Kubernetes
  14. Introduction to Microservices and relevance of Kubernetes in context
  15. Introduction to PaaS and relevance of Kubernetes in context

Section B – Release Automation

Source Code Management with Git

  1. Understanding of Source Code Repository as the point of handover from Developer team to Operations team
  2. Understanding Wall of Confusion
  3. Understanding Code Conflicts
  4. Understanding Merge Hell
  5. Understanding Possible Merger Issue Resolution approaches
  6. Understanding use case for git and brief history of Linus Torvalds’s contribution
  7. Using git in command line to clone an internet repository
  8. Using local git command line environment setup
  9. Using git to do commit code locally
  10. Integrating local git with remote git server
  11. Using by creating user account and projects
  12. Using UI to perform typical source code management tasks
  13. Understanding extra features of GitHub UI over basic git command line
  14. Concepts of bug tracking and collaborative documentation
  15. git clone of github repository
  16. distributed use of git
  17. Creating own github clone
  18. Github enterprise alternatives
  19. Implementing lightweight alternative that looks and feels similar to
  20. Implementing enterprise grade open source github clone system called GitLab through Infrastructure as Code
  21. Understanding features of GitLab
  22. Understanding unique proposition of GitLab
  23. Retracing typical actions on GitLab
  24. Importing Sample J2EE source code in local git server

Jenkins – Continuous Integration de facto Industry Standard

  1. Introduction to Continuous Integration
  2. Understanding Jenkins and Hudson relation
  3. Implementing Jenkins through Infrastructure as Code
  4. Understanding concept of Job based automation
  5. Creating first job in Jenkins
  6. Enabling Git in Jenkins
  7. Integrating Git Server with Jenkins for periodic polling of source code changes
  8. Import sample java j2ee application on git server
  9. Trigger Jenkins job from Git
  10. Understanding Software Builds
  11. Using Maven as a Build Tool
  12. Configure Maven to work with Nexus Repository and Sonarqube Code Quality Analysis
  13. Implement Nexus Repository through Infrastructure as Code
  14. Configure Nexus repository for integration with Maven
  15. Implement Sonarqube Code Quality Analysis
  16. Integrate Sonarqube to be called by maven in a jenkins job for code quality testing
  17. Integrate Nexus to store builds and artifacts
  18. Understanding Deployment Automation
  19. Implementing Deployment Automation
  20. Understanding testing stages and purposes
  21. Implementing various test stages and creating pipeline
  22. End to End Pipeline automation for continuous deployment
  23. Understanding Testing Automation
  24. Implementing Web Testing Automation in Jenkins by integrating Selenium through Python wrapper
  25. Deployment Automation through API calls
  26. Understanding Jenkins Deployment Architecture for better performance

Nagios -Industry Standard for Monitoring

  1. What is Continuous Monitoring
  2. Need for Monitoring
  3. What is Nagios
  4. What can Nagios Monitor
  5. How does Nagios compare with Competition
  6. Installing Nagios
  7. Configuring Nagios for monitoring local system
  8. Understanding File structures in Nagios
  9. Understanding inter file relationships and dependencies in Nagios Configuration
  10. Configuring NRPE on Linux server
  11. Using NRPE to monitor Linux systems through Nagios
  12. Configuring NSClient++ on Windows
  13. Using check_nt to monitor Windows systems
  14. Understanding Nagios Ecosystem of Agent Alternatives
  15. Understanding Nagios Ecosystem of GUI Alternatives
  16. Understanding options for web based GUI management of Nagios Configurations
  17. Understanding Nagios Core engine alternatives

Section C – DevOps Coding Languages

Puppet  – The ‘Easiest’ Programming Language

  1. Introduction to Automation and Configuration Management with Puppet
  2. Introduction to concepts of resources and providers
  3. Desired State Configuration Management
  4. Managing Puppet Infrastructure as a Code
  5. Puppet Code Lifecycle
  6. Understanding architecture components
  7. Installing puppetmaster and puppet agent
  8. Implementing Puppet Enterprise GUI
  9. Writing Manifests
  10. Running Manifests locally
  11. Running Manifests on Server
  12. Using common resources – file, service, package
  13. Automate anything by executing commands through puppet
  14. Understanding non sequential coding style
  15. Implementing ordering in puppet
  16. Dissecting a puppet code run
  17. Understanding how to write platform independent code in puppet
  18. Using variables
  19. Using facter variables
  20. Puppet conditionals
  21. Use of embedded ruby templates in puppet
  22. Implementing modularity in puppet
  23. Using third party modules
  24. Creating own modules
  25. Applying automation modules on agents
  26. Automating web services with Puppet

Chef  – The Challenger and Developer’s Choice

  1. Introduction to Automation and Configuration Management with Chef
  2. Introduction to concepts of resources and providers in Chef
  3. Desired State Configuration Management push/pull mechanisms in chef
  4. Managing Chef Infrastructure as a Code n Git SCM
  5. Understanding architecture components
  6. Chef component integration flow
  7. Installing chef workstation, chef server, chef node
  8. Implementing enterprise chef with GUI
  9. Writing recipes
  10. Running recipes locally
  11. Running recipes on Server
  12. Using common resources – file, service, package
  13. Automate anything by executing commands through chef
  14. Implementing modularity in chef through cookbooks
  15. Using third party cookbooks
  16. Creating own cookbooks
  17. Uploading cookbooks
  18. Mapping cookbooks
  19. Applying cookbooks on agents
  20. Understanding concept of runlist
  21. Using file shipment within cookbooks
  22. Understanding benefits of sequential coding style
  23. Understanding the scalability of chef
  24. Dissecting a chef code run
  25. Understanding how to write platform independent code in chef
  26. Using variables
  27. Using ohai variables
  28. Chef conditionals & loops
  29. Use of embedded ruby templates in Chef
  30. Automating databases with Chef
  31. Automating web services with Chef
  32. Understand how chef knife can interact with cloud solutions like ec2
  33. Understand the ways to use chef on AWS cloud
  34. AWS Opsworks and how it works
  35. Difference between Opsworks and CloudFormation
  36. Chef’s cloud first approach

Ansible – The Redhat Dark Horse – Easiest to implement

  1. Introduction to Automation and Configuration Management with Chef
  2. Introduction to concepts of modules and providers in Chef
  3. Desired State Configuration Management through Push
  4. Understanding Ansible requirements
  5. Understanding enterprise implementation architectures
  6. Ansible code run workflow
  7. Installing Ansible Tower
  8. Installing Ansible Opensource
  9. Understanding concept of inventory
  10. Managing datacenter structures with inventory
  11. Writing playbooks
  12. Running playbooks
  13. Using common modules – file, service, apt, yum
  14. Automate anything by executing commands through Ansible
  15. Understanding benefits of yaml coding
  16. Common automation with Ansible
  17. Platform dependencies in Ansible code
  18. Using variables
  19. Ansible vault variables
  20. Using Ansible vault for storing passwords
  21. Automating databases with Ansible
  22. Automating web services with Ansible

Application Designs that Suit these DevOps Tools

  1. Gartner Bi-Modal IT Concept
  2. Understanding Cloud Ready Application Architecture
  3. Understanding New Age DevOps and Use case of Legacy Software
  4. Legacy Software Architecture Modernizations
  5. Introduction to the Twelve Factor app
  6. The Twelve Factors

Live Projects –

10 projects are covered as part of this course

  • Project 1: Implementing private Git server behind corporate firewall.
  • Project 2: Sample Java J2EE application’s end to end continuous delivery and deployment automation with integrated and automated testing in a delivery pipeline
  • Project 3: Implementing 3 tier enterprise chef architecture and using it to create an end to end automation of leading web application framework automation involving application configuration, database configuration, platform configuration and vm configuration
  • Project 4: Managing Webservers and Websites using Puppet
  • Project 5: Managing Cloud Infrastructure as a Code
  • Project 6: Performing secure user management across multiple servers using ansible.
  • Project 7: Creating your own docker image that you can contribute back to open source community
  • Project 8: Managing dockers at scale by using kubernetes in a 4 server cluster
  • Project 9: Monitoring Windows and Linux platforms and tools using Nagios monitoring system
  • Project 10: Bringing up a pre-baked multi server virtual machine blueprint by using vagrant

Why learn DevOps?

DevOps originally started off as a means of enhancing collaboration between people involved in the software lifecycle management to speed up the delivery of features to production. It tries to eliminate the wall of confusion between developers and operations team by enabling teams with focused people practices, processes and tools. However, since launch of devops philosophy, the market has gradually moved towards devops as extreme automation of the release management process. People are trying to automate everything between developers finishing the code and the production environment. Now there are tools in the market which some leading companies have successfully implemented and partially achieved this vision. Entire industry is thus following suit as in the competitive market dominated by SMAC, no one wants to be left behind. That has in turn created a tremendous demand for skilled devops people in the market and companies are ready to pay any amount for well skilled devops job seekers. And in many companies, existing employees are being asked to skill up on the devops.

Is there any pre-requisite?

This course is a 360 degree devops course that prepares people to take on the job interviews in devops job market and showcase some live experience of working on real systems where devops is implemented. The course enables one with the ammunition required to crack interviews and do well in any devops role work.

The course starts from the basics. In a DevOps course, the main prerequisite is understanding of basic commands in Linux. For those who do not understand Linux commands, a special session is given to give them Just Enough Knowledge on Linux.

Do I need to know Programming?

Some people think that for learning DevOps, you may need to know programming in prior. Its a myth without substance. DevOps philosophy on the contrary suggests that people should not do programming but rather should write configuration files for tools that know how to do programming. For example, Ansible is based on Python. When it executes a task it actually runs a python code. However, what Ansible asks of you is to write a simple yaml configuration file where you describe in simplest of terms what you want to achieve through ansible – such as saying I want to install a software and start its service. Offcourse there might be syntaxes for you to remember – but that is far from writing a real programming language code. Instead its like writing parameter values for some configurations. Once Ansible receives those parameters of configuration and instructions in simpler english, the tool itself figures out the part of “how to achieve this” and accordingly writes down the appropriate python code. So who is writing the code? it is the tool; not you. So knowing python is not a pre-requisite for learning Ansible. Rather Ansible demands you to not to write the code and rather leave it to the tool. So lets be clear, coding experience is not needed for learning DevOps.

What programming languages are covered in this course?

However, there is no harm in knowing some coding. Considering, at many places, you may need to use native shell scripting and for some advanced automations of ansible, you may need to know how python works; in the course we have also added three more Just Enough Knowledge sections – Shell Scripting, Python and Ruby (as puppet and chef are based on Ruby).

Will Cloud Computing be covered in this course?

Not only that considering the close relationship between DevOps and Cloud Computing there is a dedicated Just Enough Knowledge section on AWS Cloud Concepts.

How much time will it take?

The course is of around 30 hours of duration. Out of which approximately 25 hours are completely hands on training on the tools and implementations of devops. We do not waste time in PPTs and theory sessions. In a professional job world, real experience matters. Our entire course is hands on and hence time taken to complete the course is almost equal to time taken for implementation of these automations and writing up of those codes. For around 10 odd tools, 30 hours is more than adequate (in case you are wondering why unlike others we are not giving 50/60 or 100 hours of training – simply because neither we like to waste time nor we believe you would like to waste time as well).

  • Regular classes – 4 weeks
  • Weekend Classes – 6 weeks
  • Customized Fast Track option is available as well. Call +91-8030474000 now to customize according to your requirement

Training Provider


Phone: +918884830222/ For USA: +1 408 556-9065

Skype: Call / Chat


Our Kolkata Center Address: 8th Floor, RDB Boulevard, Plot K-1, Sector V, Block EP & GP, Salt Lake City, Kolkata, West Bengal 700091

Schedule: Weekdays (1 hr /day), Weekends (2.5 hrs /day)  and Fast Track options available

Self Paced Training (SPT) with Videos and Documents – INR 5000

Online Instructor Led Live Classroom Training – INR 15000

Leave a Reply