Contents

1. Introduction to DevOps....................................................................................................2

2. Git.................................................................................................................................. 15

3. Jenkins........................................................................................................................... 29

4. Docker........................................................................................................................... 29

5. Kubernetes.................................................................................................................... 30

6. Ansible........................................................................................................................... 30

7. Chef............................................................................................................................... 31

8. Puppet........................................................................................................................... 31

9. Nagios............................................................................................................................ 32

10. Splunk........................................................................................................................ 32

11. Azure.......................................................................................................................... 33

12. AWS (Amazon Web Service)......................................................................................33

13. OpenStack..................................................................................................................34

14. Selenium.................................................................................................................... 35
 1. Introduction to DevOps1
1.1. What is DevOps (Beginner’s Guide)

1.1.1. What is DevOps?

Image 1. DevOps

Term DevOps is a combination of two words, Development and Operations and it is a

practice that allows a single team to manage the entire application development life cycle,
that is, development, testing, deployment and monitoring.

The ultimate goal of DevOps is to decrease the duration of system development life cycle
while delivering features, fixes and updates frequently in close synchronization with business
objectives.

It consists of various stages such as continuous development, continuous integration,

continuous testing, continuous deployment and continuous monitoring.

1.1.2. DevOps History

Before DevOps there were two approaches for software development named Waterfall and
Agile.

Agile methodology is widely used with DevOps and it is a iterative software development
approach where the software is broken down into various iterations or sprints. Each sprint
1
A Beginner's Guide to Understand DevOps And Its Evolution - Edureka.co
has phases such as Requirements Gathering, Design, Development, Testing and
Maintenance. Duration of each sprint is generally 2-8 weeks.

Image 2. Agile Methodology

1.1.3. DevOps Tools and Stages

Above we mentioned five stages of DevOps. Let’s break them one by one and look at the
tools used.

 Stage 1 - Continuous Development (Git, SVN, Mercurial, CVS)

In this phase software is planned and coded. You decide project vision during planning
phase and developers begin developing code for the application. There are no DevOps tools
required for the planning phase, but lot of those for maintaining the code.

Code can be in any language and you maintain it using Version Control tools. This process is
also known as the Source Code Management. After the code is developed it moves to the
Continuous Integration phase.

 Stage 2 - Continuous Integration (Jenkins, TeamCity, Travis)

This stage is the main core of the entire DevOps life cycle. It is a practice that require
developers to commit changes to the source code more frequently which can be either on a
daily or weekly basis.

Every commit has itsy build that allows early detection of problems if they are present.
Building that code involves not only compilation but also code review, unit testing, integration
testing and packaging.
 Image 3. CI Flow

Code supporting new functionality is continuously integrated with the existing code. Since
there is a continuous development of the software you need to integrate the code
continuously as well as smoothly with the systems to reflect changes to end-users.

In CI stage you use tools for building or packaging the code into an executable file so that
you can forward it to the next phases.

 Stage 3 - Continuous Testing (Jenkins, Selenium TestNG, JUnit)

In this stage you test the developed software continuously for bugs using automation testing
tools. These tools allow QA’s to test multiple code-bases thoroughly in parallel to ensure that
there are no flaws in the functionality. In this phase you can use Docker Containers to
simulate test environment.

Image 4. CT
One of the widely used tools for automation testing is Selenium, and its reports are
generated by TestNG. You can automate this entire testing phase with the help of a CI tool
called Jenkins.

Let’s say you have written selenium code in Java to test your application. Now you can build
this code using maven or ant. Once code is built you can test it for UAT (User Acceptance
Testing). This entire process can be automated using Jenkins.

 Stage 4 - Continuous Deployment (Docker and Vagrant <-> Chef Puppet

Ansible)

This is the stage where you deploy the code on production servers. It is also important to
ensure that you correctly deploy the code on all the servers. Let’s understand few things
about Configuration Management and Containerization tools. Those are tools that help in
achieving CD.

Image 5. CD

Configuration Management is act of establishing and maintaining consistency in an

application’s functional requirements and performance. In easier words, it is the act of
releasing deployments to servers, scheduling updates on all servers and most importantly,
keeping the configurations consistent across all servers.

Containerization tools also play an equally crucial role in the deployment stage. These tools
help produce consistency across Development, Test, Staging as well as Production
environments. They also help in swiftly scaling instances up and down.

 Stage 5 - Continuous Monitoring (Splunk, ELK Stack, Nagios, New Relic)

This is a very critical stage of DevOps life cycle where you continuously monitor performance
of your application. Here you record vital information about the use of this software. You then
process this information to check the proper functionality of the application. You resolve
system errors such as low memory, server not reachable and similar.
 Image 6. CM

This practice involves the participation of the Operations team who will monitor user activity
for bugs or any improper behavior of the system. CM tools help you monitor the application’s
performance and the servers closely and also enable you to check the health of the system
proactively.

1.1.4. Who is DevOps Engineer?

DevOps Engineer is somebody who understands the SDL (Software Development Lifecycle)
and has the outright understanding of various automation tools for developing digital
pipelines (CI/CD pipelines).

DevOps Engineer works with developers and the IT staff to oversee the code releases. They
are either developers who get interested in deployment and network operations or sysadmins
who have a passion for scripting and coding and move into the development side where they
can improve the planning of test and deployment.

Image 7. DevOps Engineers

So, key responsibilities of DevOps Engineer include:

  Administration of IT infrastructure
 Choosing the right deployment models
 Conducting the testing protocol and critical monitoring.

1.2. Pre-Requisites for DevOps Professionals2

As a DevOps Engineer one has a very pivotal role to play in any organization, it is mandatory
for one to be perfect in various technical and personal skills such as Coding, re-engineering
of processes and collaboration. Some of the prerequisites of a DevOps Engineer are listed
below.

 Containers

Containers are one of the most required assets of a DevOps Engineer to have on his or her
resume. Containers enable developers to generate applications and install them to servers
from a laptop. This tool has changed the whole scenario of apps’ creation, operation and
shipment. It has become one of the most in practice advances in DevOps technology due to
the ability to impart an accurate and directed environment to build within.

Image 8. Containerization Tools - Docker and Kubernetes

 Grasp of Programming Languages

It is mandatory for the DevOps Engineer to have a basic knowledge of certain basic
programming languages such as Java, Perl and Pythion as it ensures the DevOps Engineer
to handle the development team well so as to enable trouble-free flow of application
installation, configuration and validation. One should also be a scripting guru as he must be
capable of writing a code to automate repeatable processes.

2
Pre-Requisites For DevOps Professionals - Edureka.co
 Comprehending Tools and Technologies

Operations like development, testing, integration and observation depend on DevOps tools.
DevOps Engineer should have a thorough knowledge of popular tools such as Ansible, Chef,
Docker, ELK Stack, GIT, Jenkins, Puppet, Selenium, Splunk and similar.

 Knowledge of Automation Tools

Must have comprehensive knowledge of Jenkins or similar tools like Bamboo, Hudson
Though Works and other.

 Testing

DevOps Engineer is responsible for the proper administration of testing procedures at all
levels.

 Excellent Collaboration

 Grasp of Networking

 Logical Attitude

 Passion

1.3. DevOps Solving Problems

https://www.edureka.co/blog/devops-in-various-domains/

1.4. DevOps Real-Time Exam Scenarios

https://www.edureka.co/blog/devops-real-time-scenarios/

1.5. DevOps vs Agile

https://www.edureka.co/blog/devops-vs-agile-everything-you-need-to-know/

1.6. Infrastructure as Code (IaC)

1.6.1. What is IaC

Infrastructure as Code (IaC) is the process of managing computer data centers through
machine-readable definition files, rather than physical HW configuration or interactive
configuration tools. IT infrastructure managed by IaC is compromised of both physical
servers as well as virtual machines and their resource allocations.

1.6.2. How it Works

There are two main approaches of how IaC works:

 Imperative approach
Imperative approach gives order which means it defines a sequence of commands or
instructions so the infrastructure can reach desired result.

 Declarative approach

This approach declares the desired outcome. It does not outline sequence of steps that
infrastructure needs to reach desired result, it only shows what the final result looks like.

Image 9. Imperative vs Declarative

1.6.3. IaC Benefits

Some of the main benefits of IaC are:

 Speed
 Consistency
 Accountability
 Increased Efficiency
 Lower Cost

https://www.edureka.co/blog/infrastructure-as-code/#benefits

1.6.4. IaC Tools

Some of the main IaC tools used are:

 AWS CloudFormation
 Azure Resource Manager
 Google Cloud Deployment Manager
 Terraform
 Chef
 Ansible
 Puppet
1.7. Must-Know Linux Commands

https://www.edureka.co/blog/linux-commands-in-devops/#shell

1.8. Better Understanding of DevOps Tools

As mentioned before, phases in DevOps are:

a) Continuous Development
b) Continuous Testing
c) Continuous Integration
d) Continuous Deployment
e) Continuous Monitoring

Image 10. DevOps Phases

1.8.1. Continuous Development

Some of the tools used in this Phase 1 are:

 Git

Git plays a crucial role when it comes to managing the code that the collaborators contribute
to the shared repository. This code is then pulled for performing continuous integration to
create a build and test it on the test server and eventually deploy it on the production.
 Image 11. GIT Workflow

Git enables communication between the development and the operations team. When you
are working on a large project with a huge number of collaborators, it becomes very critical to
have communication between the collaborators while making changes in the project.

Commit messages in Git play a vital role in communicating among the team.

To check more look Chapter 2 GIT.

 SVN
 CVS
 Mercurial

1.8.2. Continuous Integration

Some of the tools used in this Phase 2 are:

 Jenkins

Jenkins is open-source automation tool that is written in Java with plugins built for CI
purposes. Jenkins builds and tests your software continuously which makes integration of
changes and obtaining fresh build much easier. Jenkins also allows continuous delivery of
your software by integrating large number of testing and deployment technologies.
 Image 12. Jenkins Workflow

Jenkins integrates development life-cycle processes such as build, document, test, package,
stage, deploy, analyze and much more. All that is achieved with plugins. Plugins allow
integration of different DevOps stages. Widely used plugins are tools like Git, Maven 2
Project, Amazon EC2, HTML Publisher.

To check more look Chapter 3 Jenkins.

 TeamCity
 Travis

1.8.3. Continuous Testing

Some of the tools used in this Phase 3 are:

 Selenium

Selenium is an open-source tool used for automation of tests carried out on web browsers.
Some of the features are:

o Test scripts can be written in different programming languages such as Java,

Python, C#, PHP, Ruby, Perl or .Net.
o Tests can be carried in either Windows, Mac or Linux
o Any browser can be used
o It can be easily integrated with tools such as TestNG or JUnit for managing
test cases and generating reports
o It can be integrated with Maven, Jenkins or Docker for Continuous Testing

To check more look Chapter 9 Selenium.

 JUnit
 Jenkins
 1.8.4. Continuous Deployments.

In this phase there are two tool types used:

 Management Tools - Chef, Puppet, Ansible

Ansible is a tool designed with the perspective of automation from the start. Ansible focuses
on providing “simple” configuration language as well as being able to manage cloud
instances immediately with no modifications. Rather than managing systems as individual
unites, you just describe how components and the system in general interact with each other
and Ansible will handle the rest.

To check more look Chapter 6 Ansible.

Puppet is using Ruby-based DSL as the primary language for defining the desired end state
of the infrastructure. After you define it will figure out best way to achieve that desired end
state for you. It also monitors whole infrastructure for any changes that deviate away from
the defined end state and corrects them. Puppet is a tool developed specifically for system
administrators.

 Containerization - Docker, Vagrant

Docker is a platform that packages an application and all its dependencies together in the
form of containers. This containerization aspect of Docker assures you that the application
can work in any environment.

Image 13. Docker Workflow

As seen in the image above, developer can build a container that can have different
applications installed on it and give that to QA or another team. QA team needs to run only
container to get exact replica of developer’s environment.

To check more look Chapter 4 Docker.

Once you deploy the application it is important to monitor its performance.

1.8.5. Continuous Monitoring

Some of the tools used in Phase 5 are:

 Nagios

Nagios is a tool used for monitoring of systems, applications, services, processes and
similar. In case of a failure Nagios can alert the technical staff of the problem. That allows
them to begin remediation processes before outages affect business processes, end-users
or customer.

Image 14. Nagios Workflow

To check more look at Chapter 12 Nagios.

 Splunk
 ELK Stack
 New Relic
 2. Git
2.1. What is Git?

2.1.1. Why Git?

Git is a Version Control System (VCS). VCS is the management of changes to documents,
computer programs, large websites and other collection of information. There are two VCS
types:

 Centralized VCS

CVCS uses a central server to store all files and enables team collaboration. It works on a
single repository to which users can directly access a central server.

Image 15. CVCS Diagram

Every programmer can extract or update their workstations with the data present in the
repository or can make changes to the data or commit in the repository.

Every operation is performed directly on the repository. With all that being said, some of the
major drawbacks or CVCS are pretty obvious. CVCS is not locally available so you always
need to be connected to a network to perform any action. Another thing is, since everything
is centralized in case of the central server getting crashed or corrupted it can result in losing
the entire data of the project, or at lest part to the last backup.

 Distributed VCS

In DCVS every contributor has a local copy or “clone” of the main repository. So, everyone
maintains a local repository of their own which contains all the files and metadata present in
main repository.
 Image 16. DVCS Diagram

As seen above, every programmer maintains a local repository on its own, which is just a
clone of central repository on their hard drive. They can commit and update their local
repository without any interference.

They can update their local repositories with new data from the central server by an
operation called pull and affect changes to the main repository by an operation called push
from their local repo.

The whole art of cloning an entire repository into your local workstation to get local repo
gives many advantages such as:

 All operations (except for pull & push) are fast because the tool only needs to access
hard drive, not a remote server.
 Committing new change-sets can be done locally without manipulating the data on
main repository. Once you have a group of change-sets ready, you can push them all
at once.
 Since every contributor has a full copy of the project repository, they can share
changes with one another if they want to get some feedback before affecting changes
in the main repository.
 If the central server gets crashed at any point of time, the lost data can be easily
recovered from any of the contributor’s local repo.
 2.1.2. What is Git?

Git is a DVC Tool that supports distributed workflows by providing data assurance for
developing quality software.

Git provides with all the DVCS facilities to the users. Git repositories are very easy to find
and access. Some of the main features of Git are:

 Free and Open-Source - Git is released under GPL’s (General Public License) open
source license. You don’t need to purchase Git and you can modify the source code
per your requirement.
 Speed - Since you do not have to connect to any network for performing all
operations, it completes all the tasks very fast.
 Scalable - Git is very scalable so if the number of collaborators increases Git can
easily handle it.
 Reliable - since every contributor has its own local repo, on the even of a system
crash the lost data can be recovered from any of the local repos. You will always
have a backup of all your files.
 Secure - Git uses SHA1 (Secure Hash Function) to name and identify objects within
its repo. Every file and commit are check-summed and retrieved by its checksum at
the time of checkout. Git history is stored in such way that the ID of a particular
version (commit) depends upon the complete development history leading up to that
commit. Once it is published, it is not possible to change the old versions without it
being noticed.
 Economical - in case of CVCS, central server needs to be powerful enough to server
requests of the entire team. In large companies that can be an issue. In case of
DVCS, developers don’t interact with the server unless they need to push or pull
changes. All the heavy lifting happens on client side, so the server hardware can be
very simple.
 Supports non-linear development - Git supports rapid branching and merging and
includes specific tools for visualizing and navigating a non-linear development history.
A core assumption in Git is that a change will be merged more often that it is written,
as it is passed around various reviewers. Branches in Git are very lightweight. A
branch in Git is only a reference to a single commit. With its parental commits, the full
branch structure can be constructed.
 Easy branching - branches provide an isolated environment for every change to your
codebase. When a developer wants to start working on something, no matter how big
 or small, they create a new branch. This ensures that the master branch always
contains quality code.
 Distributed development - gives each developer a local copy of the entire
development history and changes are copied from one such repo to another. These
changes are imported as additional development branches and can be merged in the
same way as a locally developed branch.
 Compatibility with existing systems or protocols - Repos can be published via
http, ftp or a Git protocol run over either a plain socket, or ssh. Git also has a
Concurrent Version Systems (CVS) server emulation, which enables the use of
existing CVS clients and IDE plugins to access Git repos. Apache SubVersion (SVN)
and SVK repos can be used directly with Git-SVN.

2.1.3. How Git fits in DevOps

As you know already, DevOps is a practice of bringing agility to the process of development
and operations.

Image 17. DevOps Diagram with GIT in focus

Diagram above shows the entire DevOps circle starting from planning the project to its
development and monitoring. Git plays a vital role when it comes to managing the code that
developers contribute to the shared repos. This code is then extracted for performing CI to
crate a build and test it on the test server and eventually deploy it on the production.

Tools like Git enable communication between the development and the operations team.
Commit messages in Git play a very important role in communicating among the team. To
succeed in DevOps, you need to have all of the communication in Version Control. Hence,
Git plays a vital role in DevOps success.
Git has earned way more popularity compared to other version control tools available on the
market.

Image 18. Version Control Tools Popularity

2.2. GitHub

2.2.1. Introduction

2.2.2. Creating Repository

2.2.3. Creating Branches and performing Operations

2.2.4. Cloning and Forking GitHub Repo

2.3. Git Installation

2.3.1. Git Installation on Windows

Installation of Git on Windows consists of few steps:

a) Download and run .exe file.

b) Follow the installer and choose Default options or per your will.
c) Launch Git Bash

Image 19. Git Bash

After opening Git Bash type following commands into the terminal to set your username and
email.

git config - - global user.name "<your name>"

git config - - global user.email "<your email>"

You can view configuration details use command below.

git config - - list

2.3.2. Git Installation on Linux

Steps to install Git on Linux are following:

A) Download software that Git depends on. Use command

sudo yum groupinstall "Development Tools"

Development tools is a yum group, a predefined bundle of software that can be installed at
once.

B) Now install tools needed for Git

sudo yum install gettext-devel openssl-devel perl-CPAN perl-devel

zlib-devel

Tools used are:

 gettext-devel
 openssl-devel
 perl-CPAN
 perl-devel
 zlib-devel
C) Download, Install & Configuration Git

For installations on CentOS, RHEL, Oracle Linux and similar you need to download tarball
and build from source. You can download newest git file from here - Git SCM. (Download
.tar.gz. file). Use wget command for that.

After that you can use „tar -zxf“.

Enter the extracted directory and follow process.

Begin source build process:

make configure

Start configuration script to prepare for software building. It makes sure all of the
dependencies for the rest of the build and install process are available. Once it has done its
job you can invoke make to build the software.
make configure

Check Git version and use same commands as for Windows installation to setup your mail
and username. Confirm your configuration after that.

git --version

git config - - global user.name "<your name>"

git config - - global user.email "<your email>"

git config --list

D) Generate SSH key & Add it to GitHub account

Now you need to generate SSH key. SSH is a secure protocol used as the primary means of
connecting to Linux servers remotely. Generate SSH key with command:

ssh-keygen -t rsa -b 4096 -C [email protected]

Just press Enter. Now verify that your ssh-agent is active and add SSH key to the SSH
agent. Also, check that your public key we will use is generated.

eval "$(ssh-agent -s)"

ssh-add ~/.ssh/id_rsa

cat ~/.ssh/id_rsa.pub

In order to add SSH key to your GitHub account go to your profile Settings, click on New
SSH key and add its title to the first box, and copy your SSH key to second box. Click on
Add SSH Key. After that test your SSH Key.

ssh -T [email protected]

If you don’t have GitHub repository read the chapter before on how to create one.

2.4. Operations & Commands

Some of the basic operations in Git are:

 Initialize
  Add
 Commit
 Pull Push

Some of the advanced operations in Git are:

 Branching
 Merging
 Rebasing

Before we dive into those, let’s check out a simple Git architecture.

Image 20. Git Diagram

2.4.1. Initialize & Status

In order to initialize Git repo, we use “git init” command. That one creates and empty Git
repository or re-initializes an existing one.
“git status” gives exactly what is says, current status in the repo. It shows all the modified
files which are ready to be added to local repository.

Image 21. Git Status

2.4.2. Add

This command updates the index using current content found in the working tree and
prepares that content in the staging area for the next commit.

So, before you make changes to the working tree and before you commit them, you must
use add command to add new or modified files to the index.

Image 22. Git Add

2.4.3. Commit

Once files are added to the index, you can commit them. Commit refers to recording
snapshots of the repo at a given time. Committed snapshots will never change unless done
explicitly.
 Image 23. Git Commit Diagram

In the diagram above we can see that C1 is the initial commit or the snapshot of the first
change from which another snapshot is created with changes named C2. Master points to
the latest commit.

Now when you make another commit, C3 is created and now master points to C3.

Image 24. Git Commit

2.4.4. Push & Pull

Git pull command fetches changes from a remote repository to a local repository. Before you
can pull changes, you need to add your central repository as origin.

After that you can pull changes from the branch of your choice.

Image 25, Git Pull

Git push command transfers commits from your local repo to remote repo. It is the opposite
of pull operation. Pulling imports, while pushing exports.

Image 26. Git Push

Files are now added to the central repository.

2.4.5. Branching

Branches in Git are nothing but pointers to a specific commit. Git generally prefers to keep its
branches lightweight as possible. There are two types of branches, local branches are path
of your working tree while remote tracking branches have some special purposes with some
of the being:

 They link work from the local repository to the work on a central repository.
 They automatically detect which remote branches to get changes from when you use
pull.

With Git branch command you can check what is your current branch or create a new
branch.

Image 27. New Branch Diagram

In the diagram above we can see that when you create new branch it originates from the
master branch itself. In order to commit to a specific branch you have to do a checkout
command and then commit changes.

Image 28. Committing on New Branch

2.4.6. Merging

Merging is a way to combine the work of different branches together. That allows you to
branch off, develop something new, and then combine it back in.

Image 29. Git Merge Diagram

In the diagram above we have two different branches. When we merge work from
newBranch into master it creates a new commit which contains all the work of master and
newBranch.

2.4.7. Rebasing

Rebasing is a way of combining the work between different branches. Rebasing takes a set
of commits, copies them and stores them outside your repository.

Rebasing is used because it can make linear sequence of commits. The commit log or
history of repo stays clean if rebasing is done.

Image 30. Git Rebase Diagram

In the diagram above, after rebase command is invoked, work on newBranch is placed right
after master and we have a nice linear sequence of commits.

2.4.8. More Operations

Some of the other useful operations and commands you may use in Git are:

 git archive <branch> - stores all files and data in a zip file. This creates only a single
snapshot omitting version control completely. Useful if you want to send files to a
client review without them having Git installed on computer.
 git bundle create - pushes master branch to a remote branch, only contained in a file
instead of a repo.
  Stash uncommitting changes - when you want to undo adding a feature or any kind of
data temporarily, you can stash them with stash command. When you want to re-
apply changes, you stashed use stash apply.

2.5. Common Git Mistakes

https://www.edureka.co/blog/common-git-mistakes/

2.6. Git Reflog - Recover Deleted Branch

https://www.edureka.co/blog/git-reflog/

2.7. Git Bisect - Identifying Code Bugs

https://www.edureka.co/blog/git-bisect/

2.8. Git vs GitHub

https://www.edureka.co/blog/git-vs-github/
 3. Jenkins
3.1. What is Jenkins

https://www.edureka.co/blog/what-is-jenkins/

3.2. Jenkins Installation

https://www.edureka.co/blog/install-jenkins/

3.3. Jenkins CI

https://www.edureka.co/blog/jenkins-tutorial/

3.4. What is Jenkins X?

https://www.edureka.co/blog/jenkins-x/

3.5. Jenkins Pipeline Tutorial

https://www.edureka.co/blog/jenkins-pipeline-tutorial-continuous-delivery
 4. Docker
4.1. Docker Explained - Introductory Guide

4.1.1. History Before Containerization

4.1.2. Reasons to use Containers

4.1.3. What is Docker?

4.1.4. Dockerfile, Images & Containers

4.1.5. Docker Compose & Docker Swarm

4.1.6. Hands-On

https://www.edureka.co/blog/docker-explained/

4.2. Docker Installation

4.2.1. Docker on Ubuntu

4.2.2. Docker on CentOS

https://www.edureka.co/blog/install-docker/

4.3. What is Docker & Docker Container?

4.3.1. Docker & Docker Container

4.3.2. VM vs Docker Container Comparison

4.3.3. Integration

4.3.4. Docker Engine

4.3.5. Docker Image, Registry & Architecture

https://www.edureka.co/blog/what-is-docker-container

https://www.edureka.co/blog/docker-container/

https://www.edureka.co/blog/docker-tutorial

4.4. Docker Architecture

4.4.1. Docker Workflow

4.4.2. Docker Architecture

4.4.3. Docker Objects

https://www.edureka.co/blog/docker-architecture/
4.5. Docker Commands

https://www.edureka.co/blog/docker-commands/

4.6. Setting Up Docker on Windows

https://www.edureka.co/blog/docker-for-windows/

4.7. Docker Compose

4.7.1. Introduction

4.7.2. Dockerfile

4.7.3. Creating Docker Containers

4.7.4. Docker Compose File

https://www.edureka.co/blog/docker-compose-containerizing-mean-stack-application/

4.8. Docker Swarm

4.8.1. What is Docker Swarm?

4.8.2. Getting Started With Swarm Mode

https://www.edureka.co/blog/docker-swarm-cluster-of-docker-engines-for-high-availability

4.9. Docker Networking

4.9.1. Goals of Docker Networking

4.9.2. Container Network Model (CNM)

4.9.3. Hands-On

https://www.edureka.co/blog/docker-networking/

5. Kubernetes
5.1. What is Kubernetes?

https://www.edureka.co/blog/what-is-kubernetes-container-orchestration

https://www.edureka.co/blog/kubernetes-tutorial/

5.2. Kubernetes Installation

https://www.edureka.co/blog/install-kubernetes-on-ubuntu

5.3. Kubernetes Architecture

https://www.edureka.co/blog/kubernetes-architecture/
5.4. Kubernetes Dashboard Installation & Views

https://www.edureka.co/blog/kubernetes-dashboard/

5.5. Visualize Kubernetes Cluster Events

https://www.edureka.co/blog/logging-monitoring-elasticsearch-fluentd-kibana/

5.6. Kubernetes Networking

https://www.edureka.co/blog/kubernetes-networking/

5.7. Kubernetes Ingress Controller on AWS

https://www.edureka.co/blog/kubernetes-ingress-controller-nginx

6. Ansible
6.1. What is Ansible?

https://www.edureka.co/blog/what-is-ansible/

https://www.edureka.co/blog/ansible-tutorial/

6.2. Ansible Installation

https://www.edureka.co/blog/install-ansible/

6.3. Ansible Provisioning

https://www.edureka.co/blog/ansible-provisioning-setting-up-lamp-stack

6.4. Ansible Roles

https://www.edureka.co/blog/ansible-roles-setup-mean-stack

7. Chef
7.1. What is Chef?

https://www.edureka.co/blog/what-is-chef/

https://www.edureka.co/blog/chef-tutorial/

7.2. Chef Installation

https://www.edureka.co/blog/install-chef/
 8. Puppet
8.1. What is Puppet - Configuration Management

https://www.edureka.co/blog/what-is-puppet/

https://www.edureka.co/blog/puppet-tutorial/

8.2. Puppet Installation

https://www.edureka.co/blog/install-puppet/

8.3. Puppet Modules

https://www.edureka.co/blog/puppet-modules-automation/

8.4. Ansible Roles

https://www.edureka.co/blog/ansible-roles-setup-mean-stack

8.5. Ansible Vault

https://www.edureka.co/blog/ansible-vault-secure-secrets

8.6. Ansible Tower

https://www.edureka.co/blog/ansible-tower/

8.7. Ansible for AWS

https://www.edureka.co/blog/ansible-for-aws-provision-ec2-instance

9. Nagios
https://www.edureka.co/blog/nagios-tutorial/

9.1. What is Nagios?

9.2. Nagios Installation

9.3. Add a Remote Server Using NRPE (Nagios Remote Plugin Executor)

10. Splunk
10.1. What is Splunk?

https://www.edureka.co/blog/what-is-splunk/

10.2. Splunk vs ELK vs Sumo Logic

https://www.edureka.co/blog/splunk-vs-elk-vs-sumologic
10.3. Machine Data with Splunk

https://www.edureka.co/blog/splunk-tutorial

10.4. Splunk Use Case

https://www.edureka.co/blog/splunk-use-case

10.5. Splunk Architecture

https://www.edureka.co/blog/splunk-architecture/

10.6. Splunk Knowledge Objects

https://www.edureka.co/blog/splunk-events-event-types-and-tags/

10.7. Splunk Lookup and Fields

https://www.edureka.co/blog/splunk-lookup-and-fields/

10.8. Splunk Interview Questions

https://www.edureka.co/blog/interview-questions/top-splunk-interview-questions-and-
answers/

https://www.edureka.co/blog/splunk-careers-big-data-jobs/

11. Azure
11.1. What is Azure?

https://www.edureka.co/blog/what-is-azure/

11.2. Microsoft Azure Tutorial

https://www.edureka.co/blog/microsoft-azure-tutorial

11.3. Azure Portal

https://www.edureka.co/blog/azure-portal/

11.4. Azure Storage Tutorial

https://www.edureka.co/blog/azure-storage-tutorial/

11.5. Azure Virtual Network for Beginners

https://www.edureka.co/blog/azure-virtual-network-tutorial/

11.6. Azure Machine Learning Service

https://www.edureka.co/blog/azure-machine-learning
11.7. Azure Interview Questions

https://www.edureka.co/blog/interview-questions/azure-interview-questions/

11.8. Azure DevOps

https://www.edureka.co/blog/introducing-azure-devops

12. AWS (Amazon Web Service)

12.1. What is AWS?

https://www.guru99.com/what-is-aws.html

12.2. How to Create EC2 Instance in AWS?

https://www.guru99.com/creating-amazon-ec2-instance.html

12.3. Modify Instances

https://www.guru99.com/modifying-amazon-ec2-instance-parameters.html

12.4. What is AWS Lambda?

https://www.guru99.com/aws-lambda-function.html

12.5. Azure vs AWS

https://www.guru99.com/azure-vs-aws.html

12.6. Google Cloud vs AWS

https://www.guru99.com/google-cloud-vs-aws.html

12.7. Azure DevOps

https://www.edureka.co/blog/aws-devops-a-new-approach-to-software-deployment/

12.8. AWS CodeCommit

https://www.edureka.co/blog/aws-codecommit/

12.9. AWS CodeDeploy

https://www.edureka.co/blog/aws-codedeploy/

12.10. AWS CodeStar

https://www.edureka.co/blog/aws-codestar/

12.11. AWS OpsWorks

https://www.edureka.co/blog/introduction-to-aws-opswork/
12.12. Running Docker Using Amazon ECS

https://www.edureka.co/blog/docker-container-in-production-amazon-ecs/

13. OpenStack
13.1. What is OpenStack?

https://www.tecmint.com/openstack-installation-guide-rhel-centos/

13.2. OpenStack Installation

https://www.tecmint.com/openstack-installation-guide-rhel-centos/

13.3. Configure OpenStack Network

https://www.tecmint.com/openstack-networking-guide/

13.4. OpenStack Configuration Options

https://platform9.com/wp-content/uploads/2018/08/openstack-installation-a-practitioner-s-
guide.pdf

13.5. Create, Deploy and Launch VMs in OpenStack

https://www.tecmint.com/create-deploy-and-launch-virtual-machines-in-openstack/

13.6. OpenStack Ansible

https://platform9.com/wp-content/uploads/2018/08/openstack-installation-a-practitioner-s-
guide.pdf

14. Selenium
14.1. What is Selenium?

https://www.edureka.co/blog/what-is-selenium/

14.2. Selenium Installation

https://www.edureka.co/blog/selenium-installation/

14.3. Java for Selenium

https://www.edureka.co/blog/java-for-selenium/

14.4. Python for Selenium

https://www.edureka.co/blog/selenium-using-python/
14.5. Components of Selenium Suite

https://www.edureka.co/blog/components-of-selenium

14.6. What is setProperty?

https://www.edureka.co/blog/what-is-setproperty-in-selenium/

14.7. Run Selenium in Chrome Browser

https://www.edureka.co/blog/how-to-run-selenium-in-chrome/

14.8. Selenium WebDriver

https://www.edureka.co/blog/selenium-tutorial

14.9. WebDriver Architecture

https://www.edureka.co/blog/selenium-webdriver-architecture/

14.10. Selenium Listeners

https://www.edureka.co/blog/listeners-in-selenium/

14.11. User’s Perspective on Selenium IDE

https://www.edureka.co/blog/selenium-ide

14.12. QTP vs Selenium

https://www.edureka.co/blog/qtp-vs-selenium/

14.13. Selenium vs RPA

https://www.edureka.co/blog/selenium-vs-rpa/