DevOps Content

--------------------------------------------------------------------------------------------------------------------------
                                                            DevOps Content
-----------------------------------------------------------------------------------------------------------

1. What’s Agile?

1. Agile methodologies and Scrum
2. Scrum Basics
3. User Stories
4. Estimating User Stories

2. DevOps Fundamentals

1. Recall Waterfall and Agile concepts
2. Differences within Dev and Ops Teams
3. DevOps and Agile – complementary concepts
4. DevOps Definition and need
5. DevOps history
6. Shift left approach to Ops
7. DevOps Principles
8. Benefits achieved using DevOps, trends towards faster delivery
9. DevOps Life Cycle and need for tools

3. Software Version Control

1. What is Version Control
2. Types of Version Control System
3. Introduction to SVN
4. Introduction to Git
5. Git Lifecycle
6. Common Git Commands
7. Working with Branches in Git
8. Merging Branches
9. Resolving Merge Conflicts
10. Git Workflow
11. Hands-on Exercise – 
Git Life cycle Commands
Pushing Code to Github
Stashing Code in git
Creating, Deleting Git Branches
Reverting a Push to GitHub
Merging branches using git merge
Merging branches using git rebase
Resolving merge conflicts using the git merge tool

4. Maven – as a Build tool

  1. Maven Objectives and usage
2. Maven Build Life Cycle and Goals
3. Maven build file POM.xml and its configuration elements with an example
4. Basic Maven commands – practical using CP-DOF case study

5. Containerization using Docker - Part I

1. Introduction to Docker
2. Understanding Docker Lifecycle
3. Components of Docker Ecosystem
4. Common Docker Operations
5. Creating a DockerHub Account
6. Committing changes in a Container
7. Pushing a Container Image to DockerHub
8. Creating Custom Docker Images using Dockerfile
9. Hands-on Exercise – 
Common Docker Operations
Creating a DockerHub Account
Committing Changes to a Container
Pushing container to DockerHub
Creating Local Image Repository
Building an Image using Dockerfile

6. Containerization using Docker - Part II

1. What are Docker Volumes
2. Deploying a Multi-Tier Application using Docker Network
3. Using Docker Compose to deploy containers
4. What is Container Orchestration
5. Container Orchestration Tools
6. Introduction to Docker Swarm
7. Deploying a 2-Node Cluster using Docker Swarm
8. Hands-on Exercise – 
Creating Docker Volumes
Using Docker Compose to deploy multiple containers
Deploying a Multi-Node Cluster using Docker Swarm
Deploying a multi-service app on Docker Swarm

7. Configuration Management using Puppet

1. Need of Configuration Management
2. Configuration Management Tools
3. What is Puppet
4. Puppet Architecture
5. Setting up Master Slave using Puppet
6. Puppet Manifests
7. Puppet Modules
8. Applying configuration using Puppet
9. Puppet File Server
10. Hands-on Exercise – 
Setting up Master-Slave on AWS
Testing Connection of nodes with Puppet
Creating a Manifest
Deploying Manifest on Node
Creating a Module
Deploying sample software on nodes using Puppet Modules and Manifests
Implementing a File Server Module on Puppet

8. Configuration Management using Ansible

1. What is Ansible?
2. Ansible vs Puppet
3. Ansible Architecture
4. Setting up Master-Slave using Ansible
5. Ansible Playbook
6. Ansible Roles
7. Applying configuration using Ansible
8. Hands-on Exercise – 
Installing Ansible on AWS
Creating a Playbook using YAML
Creating an Ansible Role
Using Roles in Playbook

9. Continuous Testing using Selenium

1. What is Continuous Testing?
2. Introduction to Selenium
3. What is Maven?
4. Using Maven with Selenium
5. Creating Test Cases with Selenium
6. Running Test Cases on Chromium Web Driver
7. What is Headless Mode?
8. Hands-on Exercise – 
Using Maven to import dependencies in Eclipse
Create a Sample Test Case for a website using Selenium
Implementing a headless test in selenium using Chrome WebDriver

10. Continuous Integration using Jenkins

1. Introduction to Continuous Integration
2. Jenkins Master-Slave Architecture
3. Understanding CI/CD Pipelines
4. Creating an end to end automated CI/CD Pipeline
 5. Creating Users + Manage + Assign
 6. Jenkins Catlight Notifications
 7. Jenkins Email Notifications 
 8. Jenkins Automated Deployment
 9. Jenkins Delivery Pipeline
 10. Jenkins Build Pipeline
 11. Jenkins Blue Ocean Window
 12. Jenkins Build Monitor View
13. Hands-on Exercise –
Creating a Jenkins Master Slave on AWS
Installing Plug-ins in Jenkins
Creating Jenkins Builds
Creating Scheduled Builds
Triggering Jobs using Git WebHooks
Using the Pipeline Plugin In Jenkins

11. Continuous Orchestration using Kubernetes
1. Introduction to Kubernetes
2. Docker Swarm vs Kubernetes
3. Kubernetes Architecture
4. Deploying Kubernetes using Kubeadms
5. Alternate ways of deploying Kubernetes
6. YAML Files
7. Creating a Deployment in Kubernetes using YAML
8. Services in Kubernetes
9. Ingress in Kubernetes
10. Case Study – Kubernetes Architecture
11. Hands-on Exercise – 
Setting up Kubernetes using kubeadm
Installing Kubernetes using kops and GCK
Creating a Deployment
Creating Services
Creating an Ingress
Demonstrating the use of Ingress, services, and deployments together

12. Continuous Monitoring using Nagios

1. What is Continuous Monitoring
2. Introduction to Nagios
3. Nagios Architecture
4. Monitoring Services in Nagios
5. What are NRPE Plugins
6. Monitoring System Info using NRPE plugins
7. Hands-on Exercise – 
Installing Nagios
Monitoring of different servers using Nagios


------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------