DEVOPS ASSIGNMENT

1.Agile Development Model

1. Agile methodologies emphasize face-to-face communication as the
most effective form of conveying information, encouraging team
members to collaborate in person or through video calls.

2. Agile promotes the idea of sustainable development, meaning the

team should be able to maintain a constant pace indefinitely, avoiding
burnout from excessive workloads.

3. In Agile, technical excellence and good design are seen as crucial to

enhancing agility, as they enable faster development and easier
adaptation to changes.

4. Agile's focus on frequent deliveries provides continuous validation

of the product, reducing the risk of building features that don’t meet
the customer's needs.

5. Agile encourages cross-functional team empowerment, where team

members have the autonomy to make decisions about how to best
accomplish their tasks, fostering innovation and accountability.

2.DevOps Architecture

architecture of DevOps
1. DevOps pipelines typically include stages like build, test, release,
deploy, and monitor, ensuring an automated flow from development to
production, reducing manual interventions.

2. Configuration management tools, such as Ansible and Puppet, are

integral in ensuring consistency and stability in infrastructure and
environment setups across development, testing, and production.

3. DevOps encourages containerization using tools like Docker,

enabling applications to run consistently across different environments
by packaging them with all dependencies.

4. Orchestration platforms like Kubernetes are often used in DevOps

architecture to manage, scale, and automate the deployment of
containerized applications across clusters.

5. Continuous security testing is integrated into the DevOps pipeline to

ensure that vulnerabilities are detected and mitigated during the
development process, leading to more secure applications.

3.Version Control Systems of SCM

1. GitHub, GitLab, and Bitbucket are popular platforms that provide
hosting for Git repositories, offering additional features like pull
requests, issue tracking, and continuous integration.

2. Forking is a feature of distributed version control systems like Git,

allowing developers to create their own copy of a repository, work on
it independently, and submit changes through pull requests.

3. Cherry-picking is a feature in Git that allows developers to pick

specific commits from one branch and apply them to another, making
it useful for hotfixes or selective updates.
4. Conflict resolution is a critical aspect of version control systems,
enabling teams to resolve code conflicts that arise when multiple
developers work on the same file simultaneously.

5. Hooks in Git are custom scripts that can be triggered by Git events
(e.g., before or after a commit), allowing for automation tasks such as
linting, testing, or formatting code before committing changes.

4.Architecture Rules of Thumb

1. Avoid tight coupling: Ensure that components have low
interdependencies, making it easier to change or replace one
component without affecting others.

2. Favor asynchronous communication between services to improve

system resilience and allow components to operate independently,
reducing wait times and bottlenecks.

3. Document architectural decisions and rationale so that future teams

understand the context of why certain design choices were made.

4. Design for deployment flexibility, ensuring that components can be

deployed independently or as part of a larger system, allowing for
continuous deployment.

5. Adopt a layered architecture that separates concerns, such as the

presentation layer, business logic layer, and data access layer,
improving maintainability and scalability.

5.Scrum
Scrum is a lightweight, iterative framework for managing complex
work, particularly in software development. It encourages
collaboration, flexibility, and continuous improvement, and it aligns
with Agile principles. The main elements of Scrum are:

1. Roles:
Product Owner: Represents stakeholders and is responsible for
maximizing the value of the product. They manage the product
backlog, prioritize tasks, and ensure the development team is
working on the most valuable features.
Scrum Master: Acts as a facilitator and coach for the Scrum
team. The Scrum Master ensures that Scrum practices are
followed, removes impediments, and helps the team improve
productivity.
Development Team: A cross-functional group responsible for
delivering product increments. This team is self-organizing,
meaning they decide how to accomplish tasks and organize their
work.
2. Artifacts:
Product Backlog: A prioritized list of all desired work on the
project. It is dynamic and evolves over time as new requirements
emerge.
Sprint Backlog: A subset of the product backlog that the team
commits to completing during a sprint. It consists of selected
user stories and tasks to be done in a sprint.
Increment: The sum of all completed product backlog items
during a sprint. It must meet the Definition of Done and be in a
usable state.
3. Ceremonies:
Sprint Planning: A meeting at the start of the sprint where the
team selects items from the product backlog and commits to
completing them during the sprint. The team discusses how to
break down tasks and estimates the effort required.
 Daily Stand-up (Daily Scrum): A brief, time-boxed meeting
(usually 15 minutes) where team members share updates on what
they accomplished the previous day, what they plan to do today,
and if there are any blockers.
Sprint Review: Held at the end of the sprint to review the work
done. The team demonstrates the increment to stakeholders,
gathers feedback, and discusses potential changes to the backlog.
Sprint Retrospective: A reflection meeting where the team
discusses what went well, what didn’t, and how they can improve
in the next sprint. This fosters continuous improvement.
4. Sprints: Sprints are time-boxed to 2-4 weeks. The goal of each
sprint is to deliver a "potentially shippable product increment" that
adds value to the overall project. Sprints ensure regular feedback
and adaptability to changing requirements.
5. Scrum Benefits:
Transparency: All stakeholders are aware of the progress and
current work.
Flexibility: Scrum embraces change and allows teams to adapt
quickly to new requirements.
Customer Focus: Regular feedback from stakeholders helps
ensure that the product meets customer needs.
Accountability: Each team member is responsible for their work
and progress, which encourages ownership and commitment.
Continuous Improvement: Through retrospectives, the team
continually seeks ways to improve processes and productivity.

6.Kanban
Kanban is a visual framework used to manage workflow and improve
efficiency by visualizing work, balancing demands with available
capacity, and identifying bottlenecks. It was originally developed by
Toyota for manufacturing but is widely used in software development
and other fields.

1. Principles of Kanban:
Start with what you do now: Kanban doesn't require any changes
to the current process to get started.
Respect existing roles: There’s no need to redefine team roles
immediately.
Encourage incremental change: The focus is on making gradual,
continuous improvements to processes.
2. Kanban Board Elements: The Kanban board is a central feature of
the framework, designed to visualize the flow of work. Common
components of a Kanban board include:
Columns: These represent different stages in the workflow (e.g.,
To Do, In Progress, Done). The stages can be customized based
on the team’s workflow.
Cards: Each card represents a task or work item. Cards typically
contain information like task description, assignee, due date, and
other relevant details.
Work in Progress (WIP) Limits: To avoid overloading the team,
WIP limits cap the number of tasks that can be in progress at any
given stage. This helps to identify bottlenecks and ensures a
smooth flow of tasks through the system.
Swimlanes: These are horizontal rows on the Kanban board that
categorize tasks. For example, a team may have separate
swimlanes for different types of work (e.g., urgent tasks vs.
routine tasks).
Cumulative Flow Diagram (CFD): This visualizes the progress of
tasks over time. It helps teams understand where bottlenecks are
occurring and if work is flowing smoothly.
3. Kanban Workflow: The primary goal of Kanban is to optimize the
flow of tasks through the system. It aims to balance demand with
available capacity, ensuring that teams are neither overwhelmed nor
underutilized. Work is "pulled" by the team members as they have
the capacity, rather than being "pushed" by management or
external sources.
4. Key Metrics in Kanban:
Cycle Time: The time it takes for a task to move from the start of
the process to completion.
Lead Time: The time between when a request is made and when
it’s completed.
Throughput: The number of tasks completed over a specific
period.
5. Kanban Practices:
Visualize work: Use the board to make the work visible to all
team members and stakeholders.
Limit WIP: Focus on controlling how much work is in progress
to prevent bottlenecks.
Manage flow: Constantly review and adjust processes to improve
the flow of work.
Make process policies explicit: Define rules for how work moves
through the system.
Implement feedback loops: Regularly review progress, identify
challenges, and adjust processes accordingly.
Improve collaboratively: Use feedback and team input to
continuously improve processes.

7.DevOps Life Cycle in Business Agility

1. DevOps reduces time to recovery by automating rollbacks and
implementing monitoring tools that allow for rapid identification and
remediation of production issues.

2. Infrastructure as Code (IaC) in the DevOps lifecycle ensures that

environments are consistent, easily replicable, and scalable, reducing
the complexity of manual infrastructure management.

3. Continuous delivery focuses on ensuring that code changes are

automatically tested and validated for release, allowing teams to deploy
new features or fixes at any time.

4. The DevOps lifecycle supports cross-team collaboration, ensuring

that business, development, and operations teams work together to
achieve shared goals and deliver better products.

5. DevOps encourages the automation of compliance checks, ensuring

that security, performance, and legal requirements are continuously
met throughout the development process.

8.Git Commands for User Configuration

1. `git config --global alias.st status`:

Sets a shortcut for the `git status` command, allowing the user to type
`git st` instead.

2. `git config --global user.signingkey <key>`: Sets a GPG key to sign

commits and tags, adding an extra layer of security by verifying the
author’s identity.

3. `git config --global core.autocrlf true`:

Configures Git to automatically convert line endings, useful when

working on projects across different operating systems.
4. `git config --global push.default current`:

Configures Git to only push the current branch by default, preventing

unintentional pushes to other branches.

5. `git config --global credential.helper cache`:

Caches Git credentials for a specified period, avoiding the need to

repeatedly enter credentials for multiple pushes.

9.Git Commands for Pushing Files to Repository

1. `git stash`: Temporarily saves uncommitted changes in a "stash"
without committing them, allowing you to pull or switch branches
without losing your work.

2. `git stash pop`: Restores the stashed changes after pulling updates
from the remote repository, useful for applying changes back after
resolving conflicts.

3. `git reset --soft HEAD~1`: Moves the last commit back to the
staging area, allowing changes to be amended or added before pushing
again.

4. `git push --force`: Forces the push to overwrite changes in the remote
repository, typically used to overwrite changes when a rebase or
commit amendment has been made.

5. `git fetch`: Retrieves the latest changes from the remote repository
without merging them, allowing you to review the changes before
deciding to integrate them.

10.Microservices
1. Microservices can be organized using domain-driven design (DDD)
principles, which structure services around business domains,
improving alignment with organizational goals.

2. Event-driven architectures are often used in microservices to

decouple services, where services communicate asynchronously
through event streams like Kafka, reducing dependencies.

3. API gateways act as an entry point for external clients, routing

requests to the appropriate microservice and handling concerns like
authentication, load balancing, and logging.

4. Service mesh technologies, such as Istio, provide a dedicated

infrastructure layer for managing microservice communication, adding
observability, security, and traffic management features.

5. Microservices introduce data management complexities, often

requiring strategies like eventual consistency, distributed transactions,
or the Saga pattern to ensure data integrity across services.