DevOps Training Online

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

Programming with Ruby and Python

1. We will try to build a developer in everyone by learning the basics of coding
2. Ruby is a heavily used language in DevOps. Both Puppet and Chef are based on Ruby. We will learn fundamental programming concepts in Ruby
3. Python is a language for cloud computing automation. Various tools and most notably Openstack cloud is built on Python. The Ansible coding is also based on Python. We will learn fundamental programming concepts of Python
4. Multiple coding examples will be performed along with

Cloud Computing and Linux Shell

1. Cloud Computing is a related concept to DevOps and we will learn what is called cloud computing and what are the various types of cloud computing
2. In context of DevOps, we will understand how does DevOps and Cloud solutions work together
3. To understand cloud computing in depth, we will do practical operations on AWS Cloud(Amazon Web Services – Architecture-EC2,S3, Load Balancing, RDS etc.)
4. To complete our understanding we will look at all services such as IaaS, PaaS and SaaS through hands on experience
5. Basics of Linux administration ,Command-Line Editing ,Multiple Commands ,Working with files and users ,Working with Shell , Writing your own shell scripts

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 Github.com by creating user account and projects
12. Using Github.com 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 github.com
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 github.com 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

• 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