Now that you are in the DevOps

family

What
is
Devops ?
 DEFINITION

DevOps is the combination of two main words

DEFINITION
DEFINITION
 DEFINITION

Let us talk about

 DEFINITION

What is DEV ?
 DEFINITION

Now that you know DEV is

application development what
is application?

Is a program, or set of programs, that allows end-users to perform

particular functions.
 DEFINITION

Big grammar aside

Are just tools we use daily to easy our life and solve issues, for
example we use facebook, twitter, whatsapp to communicate
or banking applications to monitor our bank accounts, or
doordash to order food when we are hungry, or gmail,
yahoo,msn, aol, outlook to check and monitor our email.
 DEFINITION

Now that you know what is

application and DEV

Has
NOTHING
to do with
DEFINITION

dev
elop
 DEFINITION

In other words

Write application
 DEFINITION

In other words

DO
 DEFINITION

If Devops does not develop

applications who does ?
DEFINITION

Developers world
 DEFINITION

Any question about

 DEFINITION

Let us talk about

 DEFINITION

What is OPS
 DEFINITION

What are Operations

 DEFINITION

What is Operation

In simple words operation in this context stand for transforming a code coming from
developers into a working application
 DEFINITION

DevOps engineer operation tools

DevOps engineer operation
process
Any question about
DevOps engineer operation
process
In other words

pl i c a t i on
e ap
Writ
c od e mor
e
A r e
he
on t

of
Side
t he
 to
i rt h
G iv e b
Now that you have an idea
of what is
Tired of the big grammar ?
In simple worlds DevOps is a tradition or culture that help break the gap between
Development and operations teams to improve and better control the software

development life cycle (SDLC)

 software development life cycle
DevOps engineers are in middle of all
(SDLC) teams and provide tools for those teams as well
 Quality
assurance
Team (QA)
Devops Security and
Operations team
Provide tools for (DevSecOps)

Pro
vid
e to
Pr ol s
ov for
Development
ide
oot

team (DEV)
ls
f or

r
ls fo
v i de too
Provide tools for Pro
Security and
Infosec
team
Network
Team (IT)
 Quality
Engineers
Database
Administrators

CyberSecurity
Developers Engineers

IT Helpdesk

Network
Engineers
DEVOPS ENGINEERS COLLEAGUES Security
Engineers
 Quality
Developers Engineers

DEVOPS ENGINEERS
Devops process
 Devops process

Continue Continuous
Continue Continuous
Planning Integration
Development code
(CI) Inspection

Continuous
Testing
Continuous Continuous
Security Continuous
Deployment
Delivery (CD)

Continue
Monitoring and
Continuous Continuous Logging
Feedback Improvement
 Devops process

Continue
Planning
The process of continuously defining goals, tasks, and
requirements for the project, involving regular
discussions to ensure everyone is aligned.

The team meets to discuss adding a discount feature to

an e-commerce site. They outline what it should look like,
how it should work, and which developers will handle
each part.
 Devops process

Continue
Development
The practice of constantly writing, testing, and building
code in small increments, so features are developed
quickly and efficiently.

Developers start working on different parts of the

discount feature, like coding the input field and
calculating the discount amount. Each part is tested
individually to catch errors early.
 Devops process

Continuous
Integration
(CI)
Frequently merging all code changes into a shared
repository, followed by automated testing to ensure new
code works well with existing code.

After finishing a part of the discount feature, a developer

integrates it into the main codebase. Automated tests
check to ensure that the feature doesn’t interfere with the
checkout process.
 Devops process

Continuous
code
Inspection
Reviewing code regularly, either manually or through
automated tools, to identify issues like bugs, security
vulnerabilities, and code quality concerns.

A team member reviews the discount code logic and

spots a potential security issue, like improperly validating
discount codes. They fix it before it goes live.
 Devops process

Continuous
Security

Running automated tests on integrated code to verify it

works as expected in different scenarios.

Automated tests simulate different user inputs for the

discount code feature to ensure valid codes apply
discounts and invalid ones don’t, catching any errors
early.
 Devops process

Continuous
Deployment
Automatically deploying code to the live production
environment after all tests pass, making the latest
updates instantly available to users.

After passing all tests, the discount feature is

automatically deployed to the live website, enabling
users to apply discount codes at checkout without any
downtime.
 Devops process

Continuous
Delivery (CD)
Automatically deploying code to the live production
environment after all tests pass, making the latest
updates instantly available to users.

After passing all tests, the discount feature is

automatically deployed to the live website, enabling
users to apply discount codes at checkout without any
downtime.
 Devops process

Continuous
Feedback

Regularly collecting feedback from users and monitoring

tools to understand how the application performs and
where improvements are needed.

The team monitors user feedback on the discount

feature. If users report confusion, the team makes a note
to improve the user interface.
 Devops process

Continuous
Improvement

Using feedback to make enhancements and

optimizations to improve the software over time.

Based on feedback, the team makes changes to the

discount code field, adding clearer instructions to
improve usability.
 Devops process

Continuous
Monitoring and
Logging

Tracking the application’s performance and recording

events to detect issues and understand user interactions.

Monitoring tools keep track of how often discount codes

are used and log any errors. If multiple users experience
a problem, the team is alerted to investigate
 Devops Tooling

Continuous
Version Integration and Configuration
Control Continuous Management Containerization
Systems and Orchestration
Deployment
(CI/CD)

Artifact Collaboration
Infrastructure Monitoring and
Repository Communication
as Code (IaC) and Logging Management

Source Code Security and Backup and

Analysis (Static Vulnerability Testing Disaster
Code Analysis) Scanning Recovery
 Devops Tooling

Version
Control
Systems
 Devops Tooling

Continuous
Integration and
Continuous
Deployment
(CI/CD)
 Devops Tooling

Configuration
Management
 Devops Tooling

Containerization
and Orchestration
 Devops Tooling

Infrastructure
as Code (IaC)
 Devops Tooling

Monitoring
and Logging
 Devops Tooling

Artifact
Repository
Management
 Devops Tooling

Collaboration
and
Communication
 Devops Tooling

Source Code
Analysis (Static
Code Analysis)
 Devops Tooling

Security and
Vulnerability
Scanning
 Devops Tooling

Testing
 Devops Tooling

Backup and
Disaster
Recovery
 Metric for Devops
Success

Deployment
Frequency How often deployments
happen.

Lead Time for

Changes Time from code commit to
production.

Mean Time to
Recovery
(MTTR) Average time to recover from
failures.

Change Failure
Rate Percentage of changes
causing failures.
 Important DevOps
Concepts
 Important DevOps
Concepts
 Important DevOps
Concepts
 Important DevOps
Concepts
 Important DevOps
Concepts
 Important DevOps
Concepts
 Important DevOps
Concepts
 Important DevOps
Concepts
 Important DevOps
Concepts
 Important DevOps
Concepts
 Important DevOps
Concepts
 Important DevOps
Concepts
 What to know from
day 1 at work as new
DevOps Engineer

Version Control
(e.g., Git)

Why: Almost every DevOps pipeline

relies on version control to track code
changes. Understanding Git is
essential.

Key Skills:
Commit, push,
pull, merge,
branching.
 What to know from
day 1 at work as new
DevOps Engineer

Continuous Integration
and Continuous
Deployment (CI/CD)

Why: CI/CD automates code

integration and deployment, speeding
up development and reducing human
error.

Key Tools: Jenkins,

GitHub Actions, GitLab
CI, Bitbucket Pipelines.
 What to know from
day 1 at work as new
DevOps Engineer

Infrastructure as Code
(IaC)

Why: IaC allows you to manage and

provision infrastructure through code,
which improves consistency and
enables automation.

Key Tools: Terraform,

CloudFormation,
Ansible.
 What to know from
day 1 at work as new
DevOps Engineer

Containers and
Containerization

Why: Containers, like Docker, package

applications and their dependencies,
making them portable and consistent
across environments.

Key Tools: Docker,

Docker Compose.
 What to know from
day 1 at work as new
DevOps Engineer

Orchestration

Why: Orchestration tools help manage

and automate the deployment, scaling,
and management of containerized
applications.

Key Tools: Kubernetes,

Helm.
 What to know from
day 1 at work as new
DevOps Engineer

Monitoring and Logging

Why: Monitoring allows you to track

system health and performance, while
logging is essential for debugging and
auditing.

Key Tools: Prometheus

(monitoring), Grafana
(visualization), ELK Stack
(Elasticsearch, Logstash,
Kibana for logging).
 What to know from
day 1 at work as new
DevOps Engineer

Automation

Why: Automating repetitive tasks frees

up time for strategic work and reduces
errors.

Key Tools: Ansible

(configuration
management), Jenkins (for
CI/CD automation).
 What to know from
day 1 at work as new
DevOps Engineer

Networking Basics

Why: Understanding networking

fundamentals is critical for
troubleshooting connectivity, load
balancing, and security.

Key Concepts: IP
addresses, DNS,
HTTP/HTTPS, firewalls,
VPN.
 What to know from
day 1 at work as new
DevOps Engineer

Cloud Platforms

Why: Most DevOps work today is

cloud-based. Understanding cloud
fundamentals is crucial.

Key Platforms: AWS,

Azure, Google Cloud
Platform (GCP).
 What to know from
day 1 at work as new
DevOps Engineer

Linux and Shell

Scripting

Why: Linux is the dominant OS for

servers, and shell scripting is a
powerful tool for automation.

Key Skills: Basic Linux

commands, writing and
debugging shell scripts,
managing files and
processes.
 What to know from
day 1 at work as new
DevOps Engineer

Security Fundamentals

Why: DevOps engineers must secure

applications, infrastructure, and
pipelines.

Key Concepts: SSH,

secrets management, IAM
(Identity and Access
Management), least
privilege.
 What to know from
day 1 at work as new
DevOps Engineer

Configuration
Management

Why: Configuration management tools

ensure systems are configured
consistently across multiple
environments.

Key Tools: Ansible, Puppet,

Chef.
 What to know from
day 1 at work as new
DevOps Engineer

CI/CD Pipeline
Components

Why: A DevOps engineer needs to

understand the stages in a CI/CD
pipeline, from build to deployment.

Key Concepts: Build, test,

release, deployment,
rollback.
 What to know from
day 1 at work as new
DevOps Engineer

Fundamentals of Load
Balancing and Scaling

Why: Ensuring applications can handle

varying levels of traffic is a key
responsibility.

Key Concepts: Load

balancing, horizontal
scaling, vertical scaling,
auto-scaling.
 What to know from
day 1 at work as new
DevOps Engineer

Basic Networking and

HTTP/HTTPS Protocols

Why: Almost every application interacts

with the internet or a network, making
network basics crucial.

Key Concepts: IP
addresses, DNS, ports,
HTTP methods, load
balancers.
 What to know from
day 1 at work as new
DevOps Engineer

Backup and Recovery

Why: Understanding backup strategies

and recovery procedures is critical for
data protection and disaster recovery.

Key Concepts: RPO

(Recovery Point Objective),
RTO (Recovery Time
Objective).
 What to know from
day 1 at work as new
DevOps Engineer

Observability

Why: Observability (logging,

monitoring, tracing) is key for
troubleshooting and understanding
system health.

Key Tools: Prometheus

(metrics), Grafana
(dashboards), ELK Stack
(logging).
 What to know from
day 1 at work as new
DevOps Engineer

Basic SQL and

Databases

Why: Knowledge of databases is

essential, as most applications rely on
them.

Key Concepts: SQL

basics, database backups,
performance tuning.
 What to know from
day 1 at work as new
DevOps Engineer

Collaboration and
Communication

Why: DevOps is about bridging the gap

between development and operations,
so communication skills are essential.

Key Tools: Slack, JIRA,

Confluence.
 What to know from
day 1 at work as new
DevOps Engineer

Blameless
Postmortems and
Incident Management

Why: When incidents happen,

understanding the root cause and
learning from mistakes is key to
continuous improvement.

Key Concepts: Blameless

culture, RCA (Root Cause
Analysis), incident
response.
Here are the key environments that typically require DevOps
practices to ensure smooth operations, consistency, and efficiency
throughout the software development lifecycle

Testing/QA
Environment

Development
Staging
Environment
DevOps Environment

Production
Environment
Here are the key environments that typically require DevOps
practices to ensure smooth operations, consistency, and efficiency
throughout the software development lifecycle

1. Development Environment

● Purpose: Where developers write, test, and debug

code. It’s often highly flexible to allow rapid changes.
● DevOps Focus: Automate setup, provide quick
feedback with CI, and enforce version control to
manage changes.
Here are the key environments that typically require DevOps practices
to ensure smooth operations, consistency, and efficiency throughout
the software development lifecycle

2. Testing/QA Environment

● Purpose: Where code is tested to ensure quality and

functionality before moving to staging or production. It
might involve multiple types of testing (unit, integration,
functional).
● DevOps Focus: Set up CI/CD pipelines for automated
testing, use infrastructure as code (IaC) to recreate
environments, and maintain configuration consistency.
Here are the key environments that typically require DevOps practices
to ensure smooth operations, consistency, and efficiency throughout
the software development lifecycle

3. Staging Environment

● Purpose: A close replica of the production environment

where final testing occurs. It serves as the last line of
testing to detect any issues before deploying to
production.
● DevOps Focus: Ensure staging mirrors production as
closely as possible, including data and configurations,
and provide controlled deployment practices like blue-
green or canary deployments.
Here are the key environments that typically require DevOps practices
to ensure smooth operations, consistency, and efficiency throughout
the software development lifecycle

4. Production Environment

● Purpose: The live environment where users access the

application. Stability, performance, and security are
paramount here.
● DevOps Focus: Monitor health and performance,
ensure robust logging, enforce security policies,
automate scaling, and establish disaster recovery plans.
 Environment flow

Production
Environment
Development
Environment

Testing/QA
Environment Staging
Environment
 What does DevOps
Engineer Deploy ?

Infrastructure

Application

As a DevOps Engineer we Deploy,

secure, and manage
 Applications tools

Version Control -
Code Repositories - Database Applications -
GitHub, GitLab, Bitbucket
Artifactory, Nexus MySQL, PostgreSQL,
MongoDB

CI/CD Tools - Jenkins,

GitHub Actions, GitLab Monitoring Applications Logging and Observability -
CI/CD - Grafana, Prometheus, ELK Stack (Elasticsearch,
Datadog Logstash, Kibana), Splunk

Automation Tools -
Ansible Tower, Rundeck
 Infrastructure tools

Infrastructure as Code (IaC)

Containerization and
Orchestration
● Terraform
● AWS CloudFormation ● Docker
● Azure Resource Manager (ARM) ● Kubernetes
● Google Cloud Deployment ● OpenShift
Manager ● Docker Swarm

Cloud Providers Continuous Integration/Continuous

Configuration Management
Deployment (CI/CD)
● Amazon Web Services (AWS)
● Ansible ● Microsoft Azure ● Jenkins
● Chef ● Google Cloud Platform (GCP) ● GitLab CI/CD
● Puppet ● IBM Cloud ● CircleCI
● SaltStack ● Oracle Cloud ● Travis CI
● Bamboo
 Infrastructure tools

Monitoring and Logging Security and Compliance

● Prometheus ● HashiCorp Vault (secrets management)

● Grafana ● AWS IAM (Identity and Access Management)
● Datadog ● Okta (Identity Management)
● New Relic ● Open Policy Agent (OPA)
● Cloud Security Posture Management (CSPM)
● Nagios
tools like Prisma Cloud and Dome9
● ELK Stack (Elasticsearch, Logstash,
Kibana)
● Splunk

Backup and Disaster Database Management

Recovery
● Amazon RDS (Relational Database
Service)
● AWS Backup ● MySQL, PostgreSQL, MongoDB
(managed in cloud or on-premises)
● Redis, Cassandra, DynamoDB for
NoSQL databases
 Application birth

Code
Devops
Get the code from DEV
team
Docker Devops take the docker
image and turn it into an
application

image
Devops use automation
tools to transform DEV
code into a docker
image
Application
 Application birth

Code
Devops
Get the code from DEV
team

An application can be written in a single language or

multiple languages
 Application birth

Code
Devops
Get the code from DEV
team

Depending on the application at hand a specific language

or language will be selected.
 Application birth

Code
Devops
Get the code from DEV
team

No matter the language or languages selected by the

developers they will end up producing a code
 Application birth

Code
Devops
Get the code from DEV
team

DevOps only expect CODE from the Dev team

 Application birth

Code
Devops
Get the code from DEV
team

DevOps DON’T care about the language or languages use

by the Dev team
 Application birth

Code
Devops
Get the code from DEV
team

DevOps MUST always know on which language or

languages the application has been written
 Application birth

Docker
image
Devops
Get the code from DEV
team

Devops use automation

tools to transform DEV
code into a docker An image packages the
image application code,
dependencies, libraries, and
environment configurations
An image is just a seal box that contains all the code required to run an
application, ensuring
written by developer
consistency across different
environments (e.g.,
development, testing, and
production).
 Application birth

Docker
image
Devops
Get the code from DEV
team

Devops use automation

tools to transform DEV
code into a docker Each layer in an image
image represents a change or
addition to the image, such
as installing dependencies,
adding configuration files, or
copying application code.
These layers are cached,
An image is made of multiple layer allowing for faster builds by
reusing unchanged layers.
 Application birth

Docker
image
Devops
Get the code from DEV
team

Devops use automation

tools to transform DEV
code into a docker Once created, an image is
image immutable. When an image
is used to create a container,
a writable layer is added on
top, but the underlying image
layers remain unchanged,
ensuring that the application
An image is read only runs consistently every time.
 Application birth

Docker
image
Devops
Get the code from DEV
team

Devops use automation

tools to transform DEV
code into a docker Complex applications often
image use multiple images for
different services, such as
separate images for the front
end, back end, and
database, each with its own
dependencies and
An application can have multiple images configuration.
 Application birth

Docker
image
Devops
Get the code from DEV
team

Devops use automation

tools to transform DEV
code into a docker Images are designed to be
image small and self-contained,
making them portable across
different systems. This
portability is one of the key
advantages, allowing
applications to run
Images are Lightweight and Portable consistently on any platform
that supports
containerization.
 Application birth

Docker
image
Devops
Get the code from DEV
team

Devops use automation

tools to transform DEV
code into a docker Images are typically stored in
image container registries (e.g.,
Docker Hub, AWS ECR,
Google Container Registry),
making it easy to share and
pull images as needed for
deployment.
Images Can be Stored and Shared in Repositories
 Application birth

Docker
image
Devops
Get the code from DEV
team

Devops use automation

tools to transform DEV
code into a docker Each image can have
image multiple versions, tagged to
indicate different releases or
configurations. This
versioning allows teams to
roll back to previous versions
if needed and provides clear
Images are Versioned tracking for updates.
 Application birth

Docker
image
Devops
Get the code from DEV
team

Devops use automation

tools to transform DEV
code into a docker An image encapsulates all
image required libraries and
dependencies, avoiding
conflicts with the host system’s
environment and other
applications. This isolation
ensures that applications
Images Enable Isolation of Dependencies behave as expected regardless
of the underlying infrastructure.
 Application birth

Docker
image
Devops
Get the code from DEV
team

Devops use automation

tools to transform DEV
code into a docker Images can be based on other
image images, building additional
functionality on top of a base
image. For instance, an
application image might extend
a base OS image by adding
specific dependencies and
Images Can be Layered and Extended configurations.
 Application birth

Docker
image
Devops
Get the code from DEV
team

Devops use automation

tools to transform DEV
code into a docker By reducing unnecessary files,
image combining commands, and
reusing common base images,
developers can create
optimized images that are
faster to build, transfer, and
deploy, reducing overhead in
Images Can be Optimized for Performance and Size production environments.
 Application birth

Docker
image
Devops
Get the code from DEV
team

Devops use automation

tools to transform DEV
code into a docker Since images are standardized
image and immutable, they allow
containers to be spun up or
down quickly, enabling rapid
scaling in response to demand
without the need for lengthy
setup processes.
Images Allow for Rapid Scaling
 Application birth

Docker
image
Devops
Get the code from DEV
team

Devops use automation

tools to transform DEV
code into a docker An image serves as the
image blueprint for creating
containers. Each time a
container is created, it
instantiates from the image,
inheriting its configurations and
dependencies, and is run in an
Images are the Blueprint for Containers isolated environment.
 Application birth

Application

Devops take the docker

image and turn it into an
application

An application is essentially a
program or set of programs
designed to perform specific
tasks, delivering particular
functionality to end users or
other systems.
An Application is a Set of Code and Configurations to
Achieve Specific Functionalities
 Application birth

Application

Devops take the docker

image and turn it into an
application

Complex applications are

typically made up of multiple,
interdependent components or
services. For example, a web
application might include a
user interface, backend API,
database, and caching layer,
An Application is Composed of Multiple Components each with distinct roles.
 Application birth

Application

Devops take the docker

image and turn it into an
application

Applications are often divided

into tiers, such as the front-end
(user interface), business logic
(backend services), and data
storage (database). With
microservices architecture,
applications are broken into
An Application Can Be Multi-Tiered or Microservices-Based loosely coupled services, each
handling specific
functionalities.
 Application birth

Application

Devops take the docker

image and turn it into an
application

Applications often have

multiple versions, including
development, staging, and
production versions, as well as
updates over time. Versioning
allows for easy tracking of
changes, bug fixes, and
An Application Can Have Multiple Versions feature enhancements.
 Application birth

Application

Devops take the docker

image and turn it into an
application

Applications rely on various

libraries, frameworks, and
external services (e.g.,
databases, authentication
services) that provide essential
functionalities without needing
An Application Has Dependencies on Libraries and External to build everything from
scratch.
Services
 Application birth

Application

Devops take the docker

image and turn it into an
application

Applications rely on various

libraries, frameworks, and
external services (e.g.,
databases, authentication
services) that provide essential
functionalities without needing
An Application Has Dependencies on Libraries and External to build everything from
scratch.
Services
 Application birth

Application

Devops take the docker

image and turn it into an
application

For containerized deployments,

an application can be built from
multiple images, each
corresponding to different
components. For instance, a
database, backend, and
frontend may each have a
An Application May Use Multiple Images dedicated image, allowing
them to be deployed
independently.
 Application birth

Application

Devops take the docker

image and turn it into an
application

Some applications are

stateless, meaning each
request is independent, while
others are stateful, requiring
persistent data storage (e.g., a
shopping cart application that
needs to remember user
An Application is Stateless or Stateful selections).
 Application birth

Application

Devops take the docker

image and turn it into an
application

Applications are designed with

configurable settings (e.g.,
environment variables,
configuration files) to adapt to
different environments or
requirements. This
configurability makes it easy to
An Application is Configurable deploy the application in
various scenarios without
modifying the code.
 Application birth

Application

Devops take the docker

image and turn it into an
application

Once deployed, an
application’s health and
performance need to be
continuously monitored to
ensure reliability, track usage
metrics, detect anomalies, and
An Application Needs to be Monitored and Managed in troubleshoot issues in real
time.
Production
 Application birth

Application

Devops take the docker

image and turn it into an
application

Modern applications are

designed to scale up or down
based on demand, typically by
creating more instances or
containers, enabling reliable
performance under variable
load conditions.
An Application Can Be Scalable
 Application birth

Application

Devops take the docker

image and turn it into an
application

Applications often contain

sensitive data or processes, so
they must be secured against
unauthorized access, data
leaks, and other vulnerabilities.
This includes implementing
access controls, encryption,
An Application Requires Security Controls and regular security audits.
 Application birth

Application

Devops take the docker

image and turn it into an
application

Applications may require

persistent data storage (e.g.,
databases, file storage) to save
data even when instances are
restarted or scaled down,
ensuring data consistency and
availability.
An Application Can Use Persistent Storage
 Application birth

Application

Devops take the docker

image and turn it into an
application

Applications undergo testing at

various stages (e.g., unit tests,
integration tests, end-to-end
tests) to verify functionality,
compatibility, performance, and
security before being deployed
to production.
An Application is Tested Across Multiple Stages
 Application birth

Application

Devops take the docker

image and turn it into an
application

Applications go through a
lifecycle, starting from
development, moving through
testing and staging, and finally
being deployed to production.
This lifecycle may repeat for
An Application Has a Lifecycle from Development to every new version or update.
Deployment
 Application birth

Application

Devops take the docker

image and turn it into an
application

Applications can be user-facing

(e.g., mobile or web apps) that
interact with users directly or
backend systems that support
other applications, processing
data or handling business logic
behind the scenes.
An Application is a User-Facing or Backend System
 Application birth

Application

Devops take the docker

image and turn it into an
application

Proper documentation of an
application’s functionality, setup
instructions, API references,
and troubleshooting guides is
crucial to support developers,
operators, and end-users,
especially for complex
An Application Requires Documentation applications.
 Application birth

Application

Devops take the docker

image and turn it into an
application

Applications can be packaged

in containers for lightweight
and consistent deployment or
virtualized if they require a full
operating system.
Containerized applications are
preferred for microservices and
An Application Can Be Containerized or Virtualized cloud-native applications.
 Application birth

Application

Devops take the docker

image and turn it into an
application

Applications are typically

deployed in multiple
environments (development,
testing, staging, production) to
ensure quality and stability
before going live, with each
environment configured to
An Application is Deployed in Various Environments mirror production as closely as
possible.
 Application birth

Code
Devops
Get the code from DEV
team
Docker Devops take the docker
image and turn it into an
application

image
Devops use automation
tools to transform DEV
code to a docker image
Application
 Application birth

Docke
Code rfile
Dock
er
image

Doc
Application ker
con DockerHub
tain
er
 Application birth

Devops write Dockerfile to encapsulate the

Dev code

Docke
Devops get code from dev team

Code rfile Devops guse Dockerfile to build a docker

image

Dock
er
image
The docker container use the application
code to create the application Devops use docker image to create a docker
container

Doc Devops store the docker image into docker

Application ker hub

con DockerHub
tain
er
 Application birth

Code: The development team writes the application code, which is

then handed over to the DevOps team.
Code
 Application birth

Docke
Dockerfile: The DevOps team creates a Dockerfile, which contains
instructions on how to package the code and dependencies into a
rfile Docker image. The Dockerfile encapsulates all necessary steps to
build the environment.
 Application birth

Dock
er Docker Image: Using the Dockerfile, a Docker image is built. This
image is a snapshot of the application environment, containing all
image the code, libraries, and dependencies required to run the
application.
 Application birth

Do DockerHub: The created Docker image is then stored in

ck DockerHub (or another container registry). This makes the image

e rH
accessible for future use and deployment on different
environments.

u b
 Application birth

Doc Docker Container: The Docker image is used to create a Docker

ker
container, which is a runnable instance of the image. The container
runs the application by isolating it in a consistent environment.
con
tain
er
 Application birth

Application: The container executes the application, providing a

Ap

stable and isolated runtime that ensures consistent performance

p

across different systems.

l ic
at
io
n
 Application birth

Dockerfile

Dockerfile: The DevOps team creates a

Dockerfile, which contains instructions on
how to package the code and dependencies
into a Docker image. The Dockerfile
encapsulates all necessary steps to build the The Dockerfile is a script
environment. containing a set of instructions
on how to assemble an image.
It defines every step needed to
create a self-contained
environment for an application,
ensuring consistency across all
A Dockerfile is a Blueprint for Building Docker Images stages.
 Application birth

Dockerfile

Dockerfile: The DevOps team creates a

Dockerfile, which contains instructions on
how to package the code and dependencies
into a Docker image. The Dockerfile
encapsulates all necessary steps to build the The first line in most
environment. Dockerfiles is the FROM
instruction, which defines the
base image. This is the
foundational layer for the
image, providing a starting
environment (e.g., FROM
A Dockerfile Specifies the Base Image python:3.9 or FROM
ubuntu:latest) and often
including essential libraries or
dependencies.
 Application birth

Dockerfile

Dockerfile: The DevOps team creates a

Dockerfile, which contains instructions on
how to package the code and dependencies
into a Docker image. The Dockerfile
encapsulates all necessary steps to build the The Dockerfile can include
environment. instructions to install additional
packages, libraries, or
dependencies needed for the
application, typically using
commands like RUN apt-get
install or RUN npm install.
A Dockerfile Can Install Dependencies This ensures all dependencies
are included within the image.
 Application birth

Dockerfile

Dockerfile: The DevOps team creates a

Dockerfile, which contains instructions on
how to package the code and dependencies
into a Docker image. The Dockerfile
encapsulates all necessary steps to build the The COPY or ADD instruction
environment. in a Dockerfile copies the
application’s code and
resources from the host
machine into the image. This
brings the application files into
the isolated environment where
A Dockerfile Copies Application Code the image will be run.
 Application birth

Dockerfile

Dockerfile: The DevOps team creates a

Dockerfile, which contains instructions on
how to package the code and dependencies
into a Docker image. The Dockerfile
encapsulates all necessary steps to build the Using the ENV instruction, a
environment. Dockerfile can define
environment variables that the
application will use. This allows
configuration details to be set
at build time, keeping sensitive
information out of the code and
A Dockerfile Can Set Environment Variables enabling different
configurations for various
environments.
 Application birth

Dockerfile

Dockerfile: The DevOps team creates a

Dockerfile, which contains instructions on
how to package the code and dependencies
into a Docker image. The Dockerfile
encapsulates all necessary steps to build the The CMD or ENTRYPOINT
environment. instruction defines the default
command to execute when a
container starts from the
image. For example, it could
specify CMD ["python",
"[Link]"] to run a Python
A Dockerfile Specifies Commands to Run the Application application or start a web
server.
 Application birth

Dockerfile

Dockerfile: The DevOps team creates a

Dockerfile, which contains instructions on
how to package the code and dependencies
into a Docker image. The Dockerfile
encapsulates all necessary steps to build the Each instruction in the
environment. Dockerfile creates a new layer
in the final image. Docker
caches these layers, allowing
for faster rebuilds by reusing
unchanged layers. This layered
approach makes Docker
A Dockerfile Contains Multiple Layers images efficient and enables
incremental updates.
 Application birth

Dockerfile

Dockerfile: The DevOps team creates a

Dockerfile, which contains instructions on
how to package the code and dependencies
into a Docker image. The Dockerfile
encapsulates all necessary steps to build the Multi-stage builds allow
environment. complex applications to be built
in one stage (e.g., compiling or
bundling code) and packaged
in a minimal image in the final
stage. This reduces the image
size by including only essential
A Dockerfile Supports Multi-Stage Builds files and dependencies in the
final image.
 Application birth

Dockerfile

Dockerfile: The DevOps team creates a

Dockerfile, which contains instructions on
how to package the code and dependencies
into a Docker image. The Dockerfile
encapsulates all necessary steps to build the The WORKDIR instruction sets
environment. the default directory where
commands will be executed
within the image. This is helpful
for organizing code and setting
the context for the application.

A Dockerfile Can Set the Working Directory

 Application birth

Dockerfile

Dockerfile: The DevOps team creates a

Dockerfile, which contains instructions on
how to package the code and dependencies
into a Docker image. The Dockerfile
encapsulates all necessary steps to build the The EXPOSE instruction in a
environment. Dockerfile indicates which
network ports the container will
listen on at runtime. Although
this doesn’t publish the port to
the host automatically, it serves
as documentation and
A Dockerfile Allows for Port Exposure prepares the container for port
binding.
 Application birth

Dockerfile

Dockerfile: The DevOps team creates a

Dockerfile, which contains instructions on
how to package the code and dependencies
into a Docker image. The Dockerfile
encapsulates all necessary steps to build the Build arguments (ARG) allow
environment. dynamic values to be passed
into the Dockerfile at build time.
These values can help
customize the image based on
different needs without
hardcoding values directly into
A Dockerfile Includes Build Arguments the Dockerfile.
 Application birth

Dockerfile

Dockerfile: The DevOps team creates a

Dockerfile, which contains instructions on
how to package the code and dependencies
into a Docker image. The Dockerfile
encapsulates all necessary steps to build the By defining all setup steps in a
environment. Dockerfile, DevOps teams can
ensure that the application will
run consistently regardless of
the underlying host
environment, as the entire
environment is encapsulated in
A Dockerfile Ensures Consistency Across Environments the image.
 Application birth

Dockerfile

Dockerfile: The DevOps team creates a

Dockerfile, which contains instructions on
how to package the code and dependencies
into a Docker image. The Dockerfile
encapsulates all necessary steps to build the Like other code files,
environment. Dockerfiles are version-
controlled, allowing teams to
track changes, roll back to
previous versions, and
document modifications for
future reference.
A Dockerfile is Version-Controlled
 Application birth

Dockerfile

Dockerfile: The DevOps team creates a

Dockerfile, which contains instructions on
how to package the code and dependencies
into a Docker image. The Dockerfile
encapsulates all necessary steps to build the The Dockerfile enables teams
environment. to build the same Docker
image on any system with
Docker installed, making the
process of setting up an
application highly portable and
repeatable across different
A Dockerfile is Portable Across Systems machines or cloud
environments.
 Application birth

DockerHub

DockerHub: The created Docker image is

then stored in DockerHub (or another
container registry). This makes the image
accessible for future use and deployment on
different environments. DockerHub is a cloud-based
registry where Docker images
can be stored, managed, and
shared. It serves as a central
hub for accessing pre-built
images and sharing custom
images within teams or with the
DockerHub is a Repository for Docker Images public.
 Application birth

DockerHub

DockerHub: The created Docker image is

then stored in DockerHub (or another
container registry). This makes the image
accessible for future use and deployment on
different environments. DockerHub allows users to
create public repositories that
anyone can access and
download, as well as private
repositories that restrict access
to specific users or teams. This
flexibility allows for both open-
DockerHub Provides Public and Private Repositories source collaboration and
secure image storage.
 Application birth

DockerHub

DockerHub: The created Docker image is

then stored in DockerHub (or another
container registry). This makes the image
accessible for future use and deployment on
different environments. DockerHub includes a
collection of verified "official
images," such as nginx,
mysql, python, etc.,
maintained by Docker and
trusted providers. These
images are reliable, widely
DockerHub Hosts Official Images used, and regularly updated,
providing a solid foundation for
many applications.
 Application birth

DockerHub

DockerHub: The created Docker image is

then stored in DockerHub (or another
container registry). This makes the image
accessible for future use and deployment on
different environments. Images in DockerHub can have
multiple versions, managed
through tags (e.g.,
nginx:1.19, python:3.8).
Tags allow users to specify
exact versions, ensuring
consistency when pulling
DockerHub Supports Versioning with Image Tags images.
 Application birth

DockerHub

DockerHub: The created Docker image is

then stored in DockerHub (or another
container registry). This makes the image
accessible for future use and deployment on
different environments. DockerHub enables users to
"push" images (upload) from
their local Docker environment
to the registry, as well as "pull"
images (download) for local
use. This enables efficient
sharing and reuse of images
DockerHub Allows Image Pulling and Pushing across different environments
and systems.
 Application birth

DockerHub

DockerHub: The created Docker image is

then stored in DockerHub (or another
container registry). This makes the image
accessible for future use and deployment on
different environments. DockerHub can be integrated
into CI/CD pipelines, allowing
automated pushing of new
images to DockerHub after
successful builds. This ensures
the latest images are always
available in the registry for
DockerHub Integrates with CI/CD Pipelines deployment.
 Application birth

DockerHub

DockerHub: The created Docker image is

then stored in DockerHub (or another
container registry). This makes the image
accessible for future use and deployment on
different environments. DockerHub includes a security
scanning feature that analyzes
images for known
vulnerabilities. This helps
ensure that images stored in
DockerHub are secure and that
users are aware of potential
DockerHub Has Built-in Image Scanning for Vulnerabilities security issues.
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. A container encapsulates an
application and all of its
dependencies, running in
isolation from other processes
on the host system. This
isolation ensures that each
container behaves consistently
A Container is an Isolated Runtime Environment regardless of where it’s
deployed.
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Containers are created from
images, which act as templates
defining what’s inside the
container (e.g., code, libraries,
and system tools). Once an
image is instantiated, it
becomes a container that can
A Container is Based on an Image be executed.
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Containers share the host
operating system kernel and
require fewer resources than
traditional virtual machines
(VMs). This allows for higher
density and more efficient
resource utilization on the
A Container is Lightweight and Efficient same infrastructure.
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. While the underlying image is
read-only, a writable layer is
added to the container when
it’s created. This layer allows
the application to make
changes while running, such as
writing logs or temporary data,
A Container Has a Writable Layer without modifying the original
image.
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Containers can run on any
system that supports the
container runtime (e.g.,
Docker, Kubernetes), making
them highly portable across
different environments, from
local development to cloud-
A Container is Portable based production.
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Containers are lightweight and
require minimal setup, allowing
them to start and stop almost
instantly. This makes them
ideal for dynamic scaling, rapid
deployment, and ephemeral
workloads.
A Container Starts and Stops Quickly
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Containers are designed to be
temporary. When a container is
stopped or deleted, any data in
the writable layer is lost unless
explicitly saved in external
storage. This stateless nature
encourages best practices for
A Container is Ephemeral by Nature storing persistent data outside
of containers.
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Containers can expose
network ports, allowing
external systems or other
containers to communicate
with them. Port mapping allows
for controlled access to the
containerized application.
A Container Can Expose Specific Ports
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Each container has its own
isolated filesystem, network,
and process space, which
helps avoid conflicts between
applications. This controlled
environment allows containers
to run consistently across
A Container Runs in a Controlled Environment development, testing, and
production.
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Containers are often managed
by container orchestration tools
like Kubernetes, which handle
tasks such as scaling, load
balancing, and health checks,
ensuring that containers run
reliably and can scale as
A Container Can Be Managed by Orchestration Tools needed.
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Containers are typically
stateless, where they don’t
maintain data after shutdown.
However, stateful containers
can be achieved by attaching
persistent storage, allowing
them to retain data across
A Container Can Be Stateless or Stateful restarts.
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Containers follow runtime
specifications like the Open
Container Initiative (OCI),
ensuring that containers
behave predictably and can be
run across compatible
container runtimes (e.g.,
A Container is Defined by a Runtime Specification Docker, Podman).
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Containers use Linux
namespaces to isolate
processes, networking, and
filesystem, and cgroups
(control groups) to control
resource allocation (CPU,
memory, disk I/O). This
A Container Uses Namespaces and Cgroups for Isolation ensures that containers don’t
interfere with each other or the
host system.
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Containers can communicate
with each other and external
systems through networks.
Docker and Kubernetes allow
users to define networks,
enabling containers to join
networks and use DNS for
A Container Can Be Connected to a Network inter-container communication.
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Containers go through a
lifecycle: they are created,
started, stopped, and removed.
Orchestration tools manage
the lifecycle of containers,
handling restarts, health
checks, scaling, and load
A Container Has Lifecycle Management distribution.
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Containers make it easier to
adopt microservices, where
applications are broken down
into smaller, independently
deployable services. Each
service can be packaged in its
own container, allowing
A Container Promotes a Microservices Architecture independent scaling and
updating.
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Once a container is running, it
typically doesn’t change. Any
updates or changes to the
application require building a
new image and creating a new
container. This immutability
makes containers reliable and
A Container is Often Immutable predictable.
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Containers allow developers to
run applications in the same
environment across
development, testing, and
production, reducing "it works
on my machine" issues and
A Container is Suitable for Dev, Test, and Prod improving consistency.
Environments
 Application birth

Docker
container

Docker Container: The Docker image is

used to create a Docker container, which is a
runnable instance of the image. The
container runs the application by isolating it in
a consistent environment. Containers can be monitored
for metrics like CPU, memory
usage, and health status.
Monitoring tools like
Prometheus and Grafana
provide visibility into container
performance, helping with
A Container Can be Monitored performance optimization and
troubleshooting.
 Questions

Where does developers store code ?

 Questions: Where does developers store code ?

Imagine you’re writing a book, but you’re not working on it alone. You
have a team of writers, editors, and designers all making changes to
the manuscript. Now, imagine the chaos if everyone just edited a single
copy of the book on their own computer without any way to track
changes, work on separate sections, or see what others were doing.

In software development, writing code is a lot like writing that book. Developers
(the writers) need a system to store and manage all the code they’re writing so
they can collaborate, make changes safely, and keep track of the history of
every change. T
 Questions: Where does developers store code ?

1. Where Code is Stored – Think of a Central Library

In the example of the book, imagine you have a central library where
all versions of the manuscript are stored. This library allows writers to
check out a copy, make changes, and check it back in.

In coding, this central library is a Version Control System (VCS) like GitHub, GitLab, or Bitbucket.
It’s an online place where all the code (the manuscript) is stored and where developers can safely
collaborate and track changes.
 Questions: Where does developers store code ?

2. How Changes are Managed – Keeping Track of Edits

In the book example, every time a writer checks out a copy, makes
edits, and returns it, the library keeps a record of who made which
changes. This way, if any mistakes are made, you can go back to an
earlier version.

Similarly, in a VCS, every change to the code is recorded as a “commit” (like a saved snapshot). This
means you can look back through the history of changes, see who made what change, and even
revert to an earlier version if something goes wrong.
 Questions: Where does developers store code ?

3. Working on Different Parts – Using Branches

Let’s say you have different writers working on different chapters of the
book at the same time. Instead of editing the main manuscript directly,
they work on their own copies of their specific chapters and merge
them into the main book when they’re done.

In coding, developers use branches to work on different parts of the code independently. They can
try out new features or make changes without affecting the main version. When they’re done and
everything looks good, they can “merge” their branch back into the main code.
 Questions: Where does developers store code ?

4. Reviewing and Approving Changes – Like Editors Reviewing Manuscript

Edits

Before any major edits are added to the final manuscript, an editor
reviews them to make sure they fit with the overall story. Similarly,
before code is added to the main version, other developers review it to
check for errors or improvements.

In VCS systems like GitHub, developers create something called a pull request to ask for their
changes to be reviewed. Once the changes are approved, they’re added to the main code.
 Questions: Where does developers store code ?

5. Accessing the Code Anywhere – Cloud Libraries

In our book example, the central library could be online, so any writer
can access the manuscript from anywhere in the world.

In coding, VCS platforms like GitHub are online, so developers can access the code from anywhere.
They “clone” (make a copy of) the code to work on their own computer, then “push” their changes
back to the online repository when they’re done.
 Example: Building a Simple To-Do List App Together

Imagine you and a friend are building a to-do list app together. You both want to be able to
add, delete, and organize tasks, and each of you will work on different parts of the app.
Here’s how you’d use a Version Control System like GitHub:

Store the Main Code in GitHub:

● You set up a GitHub repository (like an online folder) for your app. This is where the
main version of the code lives.

Work on Different Features:

● You create a branch to work on the feature for adding tasks.

● Your friend creates another branch to work on the feature for deleting tasks.

Commit Your Changes:

● Every time you make progress on your feature, you commit (save) your changes with a
message describing what you did, like “Added feature to add tasks to the to-do list.”
 Example: Building a Simple To-Do List App Together

Imagine you and a friend are building a to-do list app together. You both want to be able to
add, delete, and organize tasks, and each of you will work on different parts of the app.
Here’s how you’d use a Version Control System like GitHub:

Review and Merge:

● When you’re both done with your features, you each create a pull request on
GitHub. This allows you to review each other’s work, make sure everything works
correctly, and then merge the changes into the main code.

Pull the Latest Version:

● Now, the main code on GitHub has the features for both adding and deleting tasks. You both
“pull” (download) this latest version to your computers, and now you each have the updated
app.

Why This Matters

Using a Version Control System like GitHub makes it easy to collaborate, keep track of changes, and
build your app without accidentally overwriting each other’s work. If something goes wrong, you can
always go back to an earlier version of the code and fix it.
 Questions

What is structure of an application ?

 Question: What is structure of an application ?

Think of an application like a house. To make it work, you need

different parts with specific functions, all connected and interacting
with each other.
 Question: What is structure of an application ?

Frontend (User Simple application

Interface)

APIs (Application
Programming
Interfaces)

Database
 Question: What is structure of an application ?

Frontend (User APIs (Application

Interface) Backend (Server) Database Programming
Interfaces)

Complex application
Middleware
Services
Authentication and Cache
Authorization
 Question: What is structure of an application ?

Frontend (User The “Visible” Part of the Application

Interface)

Frontend (User Interface): The

visible part that users interact
Imagine the frontend as the walls, windows, doors, and with, like buttons and text fields.
decor of the house. It’s the part that people interact with
directly.

In an application, the frontend includes everything the user

sees and clicks on: buttons, forms, text, images, and
layouts.

Technologies like HTML, CSS, and JavaScript are commonly used to

create the frontend, which can be viewed in a web browser or an app
interface.
 Question: What is structure of an application ?

The “Behind-the-Scenes” Part of the

Backend (Server) Application

Backend (Server): The

behind-the-scenes logic that
processes and handles data
Think of the backend as the rooms and storage areas that requests.
you don’t see right away but are essential for making the
house functional.

The backend handles the logic, processes, and

calculations that power the app. It receives data from the
frontend, processes it, and stores it where needed.

Common backend technologies include [Link], Python, Java, and PHP.

The backend can also use APIs (Application Programming Interfaces) to
communicate with the frontend.
 Question: What is structure of an application ?

The “Storage Room” of the Application

Database

Database: The storage room

where all data is kept, ready to be
The database is like a storage room or filing cabinet where accessed and updated.
all important information is kept, ready to be accessed
when needed.

It stores data in an organized way, making it easy to retrieve

or update. Databases are crucial for storing user information,
content, and other essential data.

Popular databases include MySQL, PostgreSQL, MongoDB, and SQLite.

 Question: What is structure of an application ?

APIs (Application
Programming The “Messenger”
Interfaces)

APIs: The messenger that connects

different parts, letting the frontend and
backend communicate.
APIs are like a phone line connecting different rooms in
the house, allowing them to communicate with each other.

In an application, APIs let the frontend talk to the backend

and retrieve or send data. APIs can also connect your app to
external services, like a weather app that shows data from a
weather provider.

APIs ensure that data flows smoothly and securely between parts of the
application.
 Question: What is structure of an application ?

Authentication and The “Security System”

Authorization

● This is like the locks on your doors or a security system Authentication and Authorization: The
in the house, controlling who can enter and what they security system, controlling who can access
and modify data.
can access.

Authentication verifies the identity of users (e.g., login with

username and password), while authorization determines
what each user can do (e.g., edit tasks only if they’re the
owner).

This is often managed by backend code and frameworks that control

access to different parts of the application.
 Question: What is structure of an application ?

The “Shortcut Storage”

Cache

Cache: The shortcut storage for

frequently accessed data to make the app
The cache is like a small storage room near the front of the faster.
house, keeping frequently used items for easy access.

Caching stores data temporarily to make loading faster, like

frequently accessed pages or user data, so the app doesn’t
need to pull from the main database every time.

Common caching solutions include Redis and Memcached.

 Question: What is structure of an application ?

Services Specialized Workers in the Application

Services: Specialized helpers that handle

Services are like specialized workers or appliances in your specific tasks, such as sending emails or
house, handling specific tasks, such as sending notifications, processing payments.
processing payments, or managing files.

Some services are external, like Google Maps for location or

Stripe for payments, which the application accesses via APIs.
 Question: What is structure of an application ?

Middleware The “Connector” Between Parts

Middleware: The connector that processes

Middleware acts like a hallway connecting rooms, allowing data or checks permissions as it moves
them to pass information back and forth. between parts.

It sits between the frontend, backend, and database,

handling specific tasks such as logging activity, checking
permissions, or processing data.

Middleware makes sure data is processed or filtered correctly before it

moves on to its destination.
 Questions

How many type of application exist ?

 Questions

How many type of application exist ?

In software development, applications can be structured in two main ways: Monolithic

and Microservices.

Monolithic Application Microservices

Application
 Questions

How many type of application exist ?

A monolithic application is built as one large, unified piece. All the components (like the
user interface, backend, database, and business logic) are tightly connected and
operate as a single unit.

Monolithic Application
 Questions

How many type of application exist ?

A microservices application is made up of many small, independent services. Each

service is responsible for one specific function of the application, and these services
communicate with each other over a network.

Microservices
Application
 Microservice

Think of a microservice like a team of specialists in a pizza restaurant. Instead of

having one person do everything (take orders, make pizza, deliver it), each person has
a specific job:
Microservices
Application ● Order Taker: Handles orders from customers.
● Pizza Chef: Makes the pizzas.
● Delivery Driver: Delivers the pizzas.
● Cashier: Manages payments.

Each person focuses on their own job and works independently, but they work together
to make the restaurant run smoothly. If the cashier has a problem, the chef can still
keep making pizzas, and the delivery driver can still deliver orders.
 Microservice

What is a Microservice?
Microservices
Application A microservice is like one of these specialists. Instead of building an app where one
big system does everything, we split the app into smaller pieces, and each piece (or
"microservice") has a specific job.

Example: Online Shopping App

Imagine an online shopping app. Using microservices, the app would be split into smaller
pieces, each with one job:

1. Product Service: Shows the items for sale.

2. Cart Service: Keeps track of what’s in your cart.
3. Order Service: Handles orders when you check out.
4. Payment Service: Processes payments.
5. Notification Service: Sends emails or texts about your order.
 Microservice

Each of these parts is a microservice.

Microservices How They Work Together

Application
When you order something:

● The Cart Service sends your cart info to the Order Service.
● The Order Service checks with the Payment Service to process payment.
● The Notification Service sends you a confirmation email.

Each microservice does just one job, and if one has an issue, it doesn’t stop the others from
working.

Why Microservices are Useful

1. Independent Updates: You can change or update one microservice without affecting the
others.
2. Scalability: If the Cart Service gets busy, you can add more resources to it without
changing the rest of the app.
3. Reliability: If one microservice goes down (like Notifications), the rest of the app still works.
Now that you know a bit about DevOps and Application
etc ..
Let me take you to the next step
 Questions

Understanding Stateful vs. Stateless Architectures

 Questions

Stateless Stateful

Understanding Stateful vs. Stateless Architectures

 Questions

Stateless

A stateless application is a software application that does not retain any

data or session information about user interactions.

Don't store user session data on the server, so each request is treated
independently. Stateless applications are good for dynamic workloads and
changing business requirements. They can easily scale horizontally and are
simpler to develop and maintain. However, they often require frequent database
queries, which can create performance bottlenecks.
 Questions

Stateful

Stateful applications are web applications that store data related to user
sessions on the server side

Save client session data on the server, allowing for faster processing and
improved performance. Stateful applications are good for predictable
workloads and consistent user experiences. However, they can be more
difficult to scale than stateless applications.
 Questions

Stateless Stateful

stateful applications save information about previous

sessions, while stateless applications do not
 Questions

Stateless Stateful

stateful applications save information about previous

sessions, while stateless applications do not
Client-side vs Server-side
 Client-side vs Server-side

Client Side Server Side

This is the behind-the-scenes part of

This is the part of a computer system
a computer system. The server
that the user interacts with directly. It processes requests, handles data,
includes everything you see and use on and sends the right information back
your screen, like clicking buttons, typing to the client. Think of it as the
in forms, or watching videos. The client powerful, hidden part that makes
side is all about showing information to things work but isn’t directly visible to
you and letting you interact with it. the user.
 Client-side vs Server-side

Imagine you’re using a computer or a phone to play a game online or browse a website. The
client side and the server side work together like a team to make everything happen.
 Client-side vs Server-side

The client side is everything you see and do on your device. It’s what makes the game or website
Client Side look nice and lets you interact with it.

When you open a game or website, all the colors, images, text, and buttons you see are part of the
client side.

If you click a button, type in a text box, or swipe your screen, the client side handles that. It’s like the
“face” of the program that talks to you.

Think of it like the outside of a vending machine: you press buttons, choose snacks, and see the
display. The client side is all about what you can see, touch, and use.
 Client-side vs Server-side

The server side is like the engine inside the vending machine that you don’t see. It’s hidden but
does all the important work behind the scenes
Server Side

When you press a button to choose a snack, the server side processes that choice, checks if the snack
is in stock, and then sends it down to you.

On a website, when you log in, the server side checks if your password is correct. Or if you search for
something, it finds the results for you.

So, the server side is the “brain” of the operation. It stores all the information, runs calculations, and
makes sure everything works the way it should. You don’t see it, but it’s working hard every time you
interact with the client side.
 Client-side vs Server-side

Client Side Server Side

Whenever you do something on the client side, like press a button, the server side respond. The
client and server talk to each other to make sure everything works smoothly. The client asks for
what you need, and the server figures it out and sends it back.
 Networking

As a DevOps Engineer do I need to know a networking ?

 Networking

As a DevOps Engineer do I need to know a networking ?

Yes, as a DevOps Engineer, having an understanding of

networking is essential.

Here’s why networking knowledge is critical in DevOps

 Networking

DevOps often involves setting up, managing, and troubleshooting

infrastructure, much of which relies on network configuration.

Infrastructure Management

Understanding network protocols, IP addressing, subnets,

and DNS helps ensure efficient communication between
servers, services, and users.
 Networking

Knowing networking basics is essential when setting up environments, load

balancers, virtual networks, and firewalls

Deployment and Automation

Many cloud platforms require familiarity with network

configurations for secure and scalable deployments.
 Networking

Security is paramount, and networking is a core part of securing

applications.

Security

Configuring network security groups, VPNs, firewalls, and

secure connections can prevent unauthorized access and
protect sensitive data.
 Networking

During deployment, applications often need to interact with other services

over the network.

CI/CD Pipelines

Knowing how to configure network policies and

troubleshoot connectivity issues is valuable in maintaining
smooth deployment processes.
 Networking

When issues arise, such as latency or downtime, understanding networking

can help pinpoint and resolve them.

Monitoring and
Troubleshooting

Tools like Wireshark, netstat, and traceroute are used to

monitor and debug network performance.
 Networking

In a microservices environment, services communicate over networks.

Microservices and
Containerization

Tools like Wireshark, netstat, and traceroute are used to

monitor and debug network performance.
 Networking

Key networking concepts to be familiar

with include
OSI model

IP
TCP subnet

CIDR Firewalls
DNS Load
balancing

reverse
proxies VPN
TLS SSH
 Networking

Key networking concepts to be familiar

with include
UDP
HTTP

TCP
HTTPS

DHCP Certificate

MX
record
SOA A record
SSL CNAME

CA

NS Network
NAT Ports
Layers
 Networking

The OSI (Open Systems Interconnection) model is a conceptual

framework that standardizes the functions of a telecommunication
or computing system into seven layers: Physical, Data Link,
OS Model Network, Transport, Session, Presentation, and Application. Each
layer is responsible for specific functions, making it easier to
troubleshoot and understand networking processes.

When you access a website, the OSI model explains how each layer
interacts. For instance, the Application layer is your web browser, the
Transport layer (using TCP) breaks data into packets, and the Network
layer routes those packets to the correct IP address.
 Networking

OS Model
 Networking

TCP is a core protocol of the internet protocol suite that ensures

TCP (Transmission reliable, ordered, and error-checked data delivery between
Control Protocol) applications on different devices in a network.

When you download a file, TCP guarantees that every packet of data
arrives and is reassembled in the correct order. If a packet is lost, TCP
resends it, ensuring your file downloads correctly without missing data.
 Networking

IP is a protocol that assigns unique addresses (IP addresses) to

IP (Internet devices in a network and is responsible for routing data from source
Protocol) to destination.

Typing [Link] in a browser often takes you to your home router’s settings page. This
IP address uniquely identifies your router on your local network, allowing communication with
connected devices.
 Networking

A subnet, short for subnetwork, is a segmented piece of a larger

network. It helps organize networks, improve performance, and
Subnet enhance security by isolating sections of the network.

In an office, the IT department might be assigned to a subnet like [Link]/24, while

HR uses [Link]/24. Subnets help keep departments' data separate, improving
management and security.
 Networking

CIDR is a way to allocate IP addresses more efficiently by using

CIDR (Classless flexible subnet masks, which define IP address ranges. CIDR
Inter-Domain notation (e.g., [Link]/24) specifies the range of IP
Routing) addresses within a network.

[Link]/24 represents IP addresses from [Link] to [Link]. CIDR

helps networks save IPs by only allocating what’s necessary, rather than following fixed
classes (A, B, C).
 Networking

DNS translates human-readable domain names (like

DNS (Domain Name [Link]) into IP addresses that computers use to
System) identify each other on the network.

When you type "[Link]" in a browser, DNS translates it to Google’s IP address

(e.g., [Link]). Without DNS, we’d need to remember numerical IP addresses
instead of website names.
 Networking

A firewall is a security device or software that monitors and controls

network traffic, blocking unauthorized access while allowing
Firewalls permitted traffic.

A company firewall may block access to certain websites, like social media, to enhance
productivity. It may also allow only specific applications, like email, to prevent malware from
entering the network.
 Networking

Load balancing distributes network traffic across multiple servers to

ensure no single server is overwhelmed. It improves service
Load Balancing availability and scalability.

High-traffic websites like Amazon use load balancers to distribute incoming requests across
multiple servers, ensuring that no server gets overloaded and users experience fast
response times.
 Networking

A reverse proxy is a server that sits between users and web

servers, forwarding client requests to the appropriate server. It’s
Reverse Proxies commonly used for load balancing, caching, and securing
applications.

A reverse proxy like Nginx receives requests for [Link], checks which backend
server is available, and forwards the request to that server. The client only interacts with the
reverse proxy, not the actual backend servers.
 Networking

A VPN extends a private network across a public network, enabling

secure and encrypted connections. It allows users to send and
VPN (Virtual Private receive data securely as if their devices were directly connected to
Network) the private network.

When working remotely, employees use a VPN to securely access the company's internal
network. This allows them to work as if they’re in the office while keeping data secure over
the public internet.
 Networking

TLS is a cryptographic protocol that provides secure communication

over a network. It’s commonly used for HTTPS to encrypt data
TLS (Transport between a browser and a web server, ensuring privacy and data
Layer Security) integrity.

When you visit a bank’s website (indicated by "[Link] TLS encrypts your data, such as
login credentials, to prevent eavesdropping by malicious parties. Sites without TLS are
labeled "[Link] and are less secure.
 Networking

SSH is a network protocol that provides secure remote login and

other secure network services over an unsecured network. It uses
SSH (Secure Shell) encryption to protect data sent between a client and a server.

To manage a remote server, a DevOps engineer might use ssh user@[Link]. This
allows them to securely execute commands on the server as if they were physically present,
with data encrypted during the session.
 Networking

HTTP is the protocol used for transferring data on the web. It

HTTP (Hypertext defines how messages are formatted and transmitted, and how web
Transfer Protocol) servers and browsers should respond to various commands.

When you visit a website like [Link] your browser uses HTTP to
communicate with the web server and request the webpage.
 Networking

HTTPS (Hypertext HTTPS is the secure version of HTTP, using encryption (TLS/SSL)
Transfer Protocol to protect the data exchanged between the client and server.
Secure)

Banking websites use HTTPS (e.g., [Link] to ensure that sensitive information,
like your password, is encrypted and secure from eavesdropping.
 Networking

TCP is a connection-oriented protocol that ensures reliable data

TCP (Transmission transmission by establishing a connection before data transfer,
Control Protocol) resending lost packets, and ensuring data integrity.

TCP is used when downloading a file from the internet. If any packet is lost during transfer,
TCP ensures it is resent, so the file downloads correctly.
 Networking

UDP is a connectionless protocol that prioritizes speed over

UDP (User reliability, meaning it doesn’t guarantee the delivery or order of
Datagram Protocol) packets.

Online gaming and video streaming often use UDP because a few lost packets (causing a
minor glitch) are preferable to the delay caused by resending packets.
 Networking

DHCP (Dynamic DHCP automatically assigns IP addresses to devices on a network,

Host Configuration allowing them to communicate without manual configuration.
Protocol):

When you connect to Wi-Fi at a coffee shop, the router assigns your device an IP address
using DHCP, so you can access the internet.
 Networking

MX records are DNS records that specify the mail servers

MX Record (Mail responsible for receiving email for a domain.
Exchange Record)

The MX record for [Link] might direct emails to [Link], allowing the
domain to receive emails.
 Networking

An A (Address) record is a DNS record that maps a domain name to

an IP address, allowing users to access the site with a human-
A Record readable address.

The A record for [Link] might map to [Link], so when you type
[Link], you’re directed to that IP address.
 Networking

SSL is an encryption protocol used to secure data sent between a

SSL (Secure client and a server. SSL has mostly been replaced by TLS but is still
Sockets Layer) commonly referenced.

When you see a padlock icon in the browser address bar (usually for HTTPS sites), SSL or
TLS is securing the data between your browser and the website.
 Networking

The SOA record is a DNS record that provides essential information

about a domain, including the primary name server, the email of the
SOA (Start of domain administrator, and domain serial numbers for DNS
Authority) synchronization.

When a DNS server checks the SOA record for [Link], it learns which server is
authoritative for the domain and can contact the administrator if needed.
 Networking

NS records in DNS specify which servers are authoritative for a

domain, meaning they contain the actual DNS records for that
NS (Name Server) domain.

If [Link] is an NS record for [Link], it indicates that

[Link] holds the DNS records for [Link].
 Networking

NAT is a method that allows multiple devices on a local network to

NAT (Network share a single public IP address, making it possible for them to
Address connect to the internet.
Translation)

In a home network, your router uses NAT to let multiple devices (laptops, phones) share one
public IP address while assigning each device a unique local IP address.
 Networking

Ports are logical endpoints in a network connection, used by

protocols to specify different types of traffic and applications (e.g.,
Ports web traffic, email).

Port 80 is commonly used for HTTP traffic, and port 443 is used for HTTPS. When you visit
a website, your browser connects to the server’s IP on port 80 or 443.
 Networking

A digital certificate is an electronic document used to prove the

ownership of a public key. Certificates are used to establish secure
connections on the internet (typically for HTTPS). The certificate
Certificate binds a public key with an entity’s identity, ensuring that the data
sent between the user and server is secure.

When you visit a secure website ([Link] your browser checks the site’s
digital certificate to verify it’s legitimate. If the certificate is valid and trusted, it establishes a
secure (TLS/SSL) connection. The certificate shows the site’s authenticity and that data
exchange will be encrypted.
 Networking

A Certificate Authority (CA) is a trusted organization responsible for

issuing digital certificates. The CA verifies the identity of the
CA (Certificate certificate requester (e.g., a website or organization) before issuing
Authority) the certificate. This trust is fundamental to the security of HTTPS
and other encrypted communications.

Let’s say [Link] wants to secure its website with HTTPS. It requests a certificate
from a CA, like Let’s Encrypt or DigiCert. The CA verifies the identity of [Link] and
issues a certificate. Now, when users visit [Link], their browsers trust that the
certificate is legitimate because it’s signed by a trusted CA.
 Networking

As a DevOps Engineer do I need to know a networking ?

Yes, as a DevOps Engineer, having an understanding of

networking is essential.

Here’s why networking knowledge is critical in DevOps

 Security

As a DevOps Engineer do I need to know a Security ?

 Security

As a DevOps Engineer do I need to know a Security ?

Yes, as a DevOps Engineer, having a strong understanding of security is

essential. Security is a crucial part of the DevOps lifecycle, often referred to
as DevSecOps when security practices are integrated into DevOps
workflows.

Here are several key reasons why security knowledge is

vital in a DevOps role
 Security

The CI/CD pipeline automates the process of building, testing, and

deploying code. Since it handles sensitive information (like API keys,
secrets, and credentials) and deploys code to production, it’s a prime target
for attackers.

Securing the CI/CD

Pipeline

Ensuring that credentials are stored securely, using tools like

HashiCorp Vault or AWS Secrets Manager, and implementing
proper access controls are essential to prevent unauthorized
access.
 Security

DevOps engineers often manage infrastructure with IaC tools like Terraform,
Ansible, or CloudFormation. Misconfigurations in IaC can lead to security
vulnerabilities.

Infrastructure as Code
(IaC) Security

If a security group in AWS is accidentally set to allow open access (e.g., [Link]/0
on SSH), it can expose your infrastructure to attacks. Knowing how to set secure
defaults and review IaC for security issues is critical.
 Security

DevOps engineers work with network configurations, including firewalls,

VPNs, and load balancers. Understanding network security concepts like IP
whitelisting, NAT, and port management is necessary to prevent
unauthorized access and secure data transmission.

Network Security

Setting up secure VPCs, subnets, and using security groups and firewalls to
control traffic can help protect sensitive data and systems.
 Security

Many DevOps pipelines include stages for scanning code and applications
for vulnerabilities. Knowing how to configure and interpret security tools (like
SonarQube, OWASP Dependency-Check, or Snyk) is valuable.

Application Security

Automating static application security testing (SAST) and dynamic application

security testing (DAST) in the CI/CD pipeline helps detect vulnerabilities early in
the development cycle.
 Security

Containers, like those managed by Docker and Kubernetes, have unique

security concerns. DevOps engineers should know how to secure container
images, set resource limits, and manage Kubernetes security
configurations.

Container Security

Using tools like Aqua Security or Twistlock to scan Docker images for
vulnerabilities, managing permissions within Kubernetes, and avoiding running
containers as the root user are all essential container security practices.
 Security

Containers, like those managed by Docker and Kubernetes, have unique

security concerns. DevOps engineers should know how to secure container
images, set resource limits, and manage Kubernetes security
configurations.

Identity and Access

Management (IAM)

Proper IAM ensures that only authorized users and services have access to
resources. Managing permissions correctly and following the principle of least
privilege are crucial.
 Security

Proper IAM ensures that only authorized users and services have access to
resources. Managing permissions correctly and following the principle of
least privilege are crucial.

Identity and Access

Management (IAM)

Configuring IAM roles and policies in AWS or other cloud platforms to limit access
based on roles (e.g., giving production access only to certain team members)
helps reduce the risk of unauthorized access.
 Security

Security monitoring is vital for detecting suspicious activity, and knowing

how to respond to incidents helps mitigate damage. DevOps engineers
should understand logging, monitoring, and alerting tools and processes.

Monitoring and Incident

Response

Setting up monitoring with tools like Prometheus, Grafana, and ELK stack
(Elasticsearch, Logstash, Kibana) helps detect anomalies. Having incident
response protocols in place helps respond quickly to security incidents.
 Security

Many industries have regulatory requirements like GDPR, HIPAA, and SOC
2. Knowing these requirements helps ensure that DevOps practices meet
security standards and legal obligations.

Compliance and
Regulatory
Requirements

Implementing data encryption, secure storage for sensitive information, and

access audits can help meet compliance requirements.
 Security

Many industries have regulatory requirements like GDPR, HIPAA, and SOC
2. Knowing these requirements helps ensure that DevOps practices meet
security standards and legal obligations.

Compliance and
Regulatory
Requirements

Implementing data encryption, secure storage for sensitive information, and

access audits can help meet compliance requirements.
Important Security
Concepts
 Important Security
Concepts

Users, processes, and systems should only have the minimum access
necessary to perform their functions.

Principle of
Least
Privilege
(PoLP)

Reduces the attack surface by limiting access to only what’s necessary, preventing
unauthorized access to sensitive resources.
 Important Security
Concepts

Encryption is the process of encoding data to prevent unauthorized access.

Data at rest refers to data stored on a disk, while data in transit refers to
data being transferred over a network.

Encryption (Data
at Rest and Data
in Transit)

Encrypting data ensures that even if it’s intercepted or accessed by unauthorized

users, it remains unreadable without the decryption key.
 Important Security
Concepts

IAM is a framework of policies and technologies that ensure the right

individuals and systems have the right access to technology resources.

Identity and
Access
Management
(IAM)

Helps manage permissions, ensuring that only authenticated and authorized

entities can access certain resources.
 Important Security
Concepts

The process of identifying, classifying, remediating, and mitigating

vulnerabilities.

Vulnerability
Management

Continuous vulnerability assessment allows organizations to identify and fix

security flaws before they are exploited by attackers.
 Important Security
Concepts

Storing and managing sensitive information (such as API keys, passwords,

and credentials) securely to prevent unauthorized access.

Secrets
Management

Protects sensitive data from exposure, especially in CI/CD pipelines where secrets
are frequently used.
 Important Security
Concepts

Compliance with industry standards (e.g., GDPR, HIPAA, SOC 2) involves

following legal guidelines for handling data.

Compliance and
Regulatory
Standards

Non-compliance can lead to legal consequences, so it’s essential to know relevant

standards for handling data in a secure and compliant manner.
 Important Security
Concepts

Practices that help prevent security vulnerabilities in code, like input

validation, error handling, and avoiding hard-coded secrets.

Secure Coding
Practices

Prevents common vulnerabilities (like SQL injection and cross-site scripting) and
ensures code is secure by design.
 Important Security
Concepts

Firewalls control incoming and outgoing network traffic, and network

segmentation divides networks into smaller parts.

Firewall Rules and

Network
Segmentation

Limits the spread of attacks within a network and restricts access to sensitive
areas, providing layered security.
 Important Security
Concepts

Continuously tracking, recording, and analyzing system events and

behaviors to detect and respond to security incidents.

Monitoring and
Logging

Monitoring enables early detection of suspicious activity, while logging provides an

audit trail to investigate incidents.
 Important Security
Concepts

A structured approach to managing and addressing security incidents to

limit damage and reduce recovery time.

Incident
Response and
Recovery

Being prepared with an incident response plan helps organizations respond swiftly
and minimize the impact of security breaches.
 Important Security
Concepts

Regularly applying updates and patches to software to fix known

vulnerabilities.

Patching and
Update
Management

Helps prevent attackers from exploiting known vulnerabilities and ensures that
systems are up-to-date and secure.
 Important Security
Concepts

The process of identifying and evaluating potential threats and

vulnerabilities in a system.

Threat Modeling

Helps proactively identify and mitigate risks, making security a built-in aspect of the
system’s design.
 Important Security
Concepts

A security model where trust is never assumed; instead, verification is

required at every stage for every user and device attempting access.

Zero Trust
Architecture

Reduces the risk of unauthorized access by continuously verifying trustworthiness

within a system.
 Important Security
Concepts

The practice of maintaining secure and consistent settings across all

infrastructure components and software.

Configuration
Management and
Secure Defaults

Ensures all systems start with secure configurations, reducing vulnerabilities from
default or misconfigured settings.
 Important Security
Concepts

Integrating security practices into CI/CD pipelines to automatically detect

vulnerabilities and enforce security standards.

Security in CI/CD
(DevSecOps)

Shifts security left, allowing issues to be identified and addressed early in the
development cycle, reducing overall risk.
 Important Security
Concepts

Protecting APIs from vulnerabilities like unauthorized access, injection

attacks, and data breaches.

API Security

APIs are widely used to integrate services and access data, so securing them is
crucial to protect both backend services and sensitive information.
 Important Security
Concepts

Securing containers and the containerized environment, including image

scanning, runtime protection, and secure configurations.

Container
Security

Containers are widely used in DevOps, and they introduce unique security
challenges that require special handling.
 Important Security
Concepts

NAT translates private IP addresses to a public IP address, hiding the

internal network from external users.

NAT (Network
Address
Translation) and
IP Masking

Helps prevent direct access to internal network devices, reducing the risk of
external attacks.
 Important Security
Concepts

TLS/SSL certificates encrypt data in transit between a client and server.

Certificate management involves handling these certificates securely.

TLS/SSL
Certificates and
Certificate
Management

Certificates ensure data confidentiality and integrity during transmission and help
users verify the authenticity of a website or server.
 Important Security
Concepts

Access control defines who can access resources, and MFA adds an extra
layer of security by requiring multiple forms of verification.

Access Control
and Multi-Factor
Authentication
(MFA)

Access control and MFA help prevent unauthorized access, even if passwords are
compromised.
 DATABASE

As a DevOps Engineer do I need to know a DATABASE ?

 DATABASE

As a DevOps Engineer do I need to know a DATABASE ?

Yes, as a DevOps Engineer, it’s important to have a solid understanding of

databases. While you might not need to be a full-fledged database
administrator (DBA), knowing the basics of databases, as well as certain
advanced concepts, is essential

Here are several key reasons why Database knowledge is

vital in a DevOps role
 DATABASE

DevOps engineers often need to integrate database changes into the CI/CD
pipeline to ensure that schema migrations and updates are deployed
seamlessly alongside application code.

CI/CD Pipelines for

Database Changes

A DevOps pipeline might include a step for running database

migrations using tools like Liquibase or Flyway. This ensures that
any schema changes (e.g., adding a new table or column) are
applied to the database in a controlled way during deployment.
 DATABASE

Database servers and configurations are part of the infrastructure. As a

DevOps engineer, you’ll often provision, configure, and manage databases
using IaC tools like Terraform or Ansible.

Infrastructure as
Code (IaC)

You might use Terraform to create an Amazon RDS instance in

AWS or a MySQL database in Azure, specifying configurations
like instance size, storage, and security settings.
 DATABASE

Database performance has a direct impact on application performance, so

it’s important to know how to monitor and troubleshoot databases. DevOps
engineers often set up monitoring tools to track database metrics like query
performance, CPU usage, and disk space.

Database Monitoring
and Performance
Tuning

Tools like Prometheus, Grafana, or DataDog can be configured

to monitor database health. If query latency spikes, you may
need to investigate the root cause, which could involve checking
slow-running queries or identifying high CPU usage.
 DATABASE

Ensuring data safety is critical. DevOps engineers often handle automated

backups, as well as restoration and disaster recovery processes, to ensure
data is protected and can be restored in case of an incident.

Database Backup and

Recovery

Setting up automated daily backups for a PostgreSQL database

on AWS RDS and testing the restoration process periodically to
confirm that backups work as expected.
 DATABASE

Databases often contain sensitive information, making them a high-value

target for attackers. Understanding database security fundamentals (like
access control, encryption, and network restrictions) is crucial for protecting
data.

Database Security

Configuring database access using roles and permissions,

encrypting data at rest and in transit, and restricting network
access to trusted IP addresses.
 DATABASE

Applications may use SQL or NoSQL databases depending on the data

structure and performance requirements. DevOps engineers should
understand the differences and use cases for each type to support
applications effectively.

Understanding SQL
and NoSQL
Databases

A DevOps engineer might support a relational database like

MySQL for an application that needs strong data consistency,
while another application might use MongoDB, a NoSQL
database, for flexible, unstructured data storage
 DATABASE

Data migrations (moving data from one database to another or from one
version of a database to another) are common in DevOps workflows,
especially when upgrading applications or changing environments. Knowing
how to plan and execute migrations is essential to avoid data loss and
ensure data integrity.

Data Migrations

● Migrating data from an on-premises MySQL database to an AWS RDS

instance or using tools like pg_dump and pg_restore to migrate a
PostgreSQL database.
 DATABASE

As applications grow, databases may need to scale to handle increased load.

Understanding scaling options (e.g., sharding, read replicas) and replication
is important for high availability and performance.

Database Scaling and

Replication

Setting up read replicas in MySQL to offload read requests from the primary
database, which improves performance for read-heavy applications.
 DATABASE

Proper configuration and optimization can drastically improve database

performance. Knowing how to adjust database settings and optimize queries
can prevent performance bottlenecks.

Database
Configuration and
Optimization

Adjusting PostgreSQL configurations like max_connections, shared_buffers,

and work_mem to better utilize server resources based on the application
workload.
 DEVOPS MOST
USED DATABASE