SCD CHAPTER 9

DevOps Practices

Definition: DevOps (Development and Operations) is a set of practices aimed at improving

collaboration between software development and IT operations teams to deliver software faster
and more reliably. It emphasizes automation, continuous feedback, and iterative improvement to
streamline the software delivery process.

●​ Key Practices in DevOps:

o​ Continuous Integration (CI):
▪​ Definition: CI is a DevOps practice where developers frequently merge
code changes into a central repository. Automated builds and tests are then
run to detect any issues early.
▪​ Example: A team uses GitHub Actions or Jenkins to automatically run
unit tests whenever code is pushed to the main branch.
▪​ Benefits: Reduces integration issues, detects bugs early, and maintains a
clean codebase.
o​ Continuous Deployment (CD):
▪​ Definition: CD automates the deployment of changes to production after
they pass testing, enabling faster release cycles.
▪​ Example: Using CircleCI or GitLab CI/CD, a team can automatically
deploy updates to production when all tests pass, eliminating manual
deployment steps.
▪​ Benefits: Accelerates delivery, reduces manual errors, and ensures users
get the latest updates promptly.
o​ Continuous Delivery:
▪​ Definition: Continuous Delivery is similar to Continuous Deployment but
requires final manual approval before deployment to production. This adds
an extra layer of control.
▪​ Example: A company sets up its pipeline to prepare code for release but
includes a manual approval step before deploying it live.
▪​ Benefits: Increases control and allows rapid but cautious deployment.
o​ Monitoring and Logging:
▪​ Definition: Monitoring and logging involve continuously tracking
application performance and collecting logs to identify, analyze, and
resolve issues.
▪​ Example: Using tools like Prometheus for monitoring metrics and ELK
Stack (Elasticsearch, Logstash, Kibana) for logs to gain insights into
application health and performance.
▪​ Benefits: Enables proactive maintenance, faster issue resolution, and
performance optimization.
o​ Collaboration and Automation:
▪​ Definition: DevOps encourages close collaboration between development,
operations, and other teams, with automation as a key enabler to reduce
repetitive tasks.
 ▪​ Example: Automating configuration, testing, and deployment tasks with
tools like Ansible or Terraform.
▪​ Benefits: Increases efficiency, reduces human error, and frees teams to
focus on higher-value work.

2. Infrastructure as Code (IaC)

Definition: IaC is the practice of managing and provisioning computing infrastructure through
machine-readable configuration files rather than through physical hardware configuration or
interactive configuration tools. It treats infrastructure as code, enabling consistent, repeatable
deployments.

●​ Advantages of IaC:
o​ Consistency: By defining infrastructure as code, every deployment is consistent
with minimal risk of configuration drift (differences in environment settings).
o​ Reproducibility: IaC scripts can reproduce environments across development,
testing, and production.
o​ Scalability: IaC allows infrastructure to dynamically scale based on demand.
o​ Version Control: Changes to infrastructure can be versioned, enabling rollback if
needed.
●​ Types of IaC:
o​ Declarative (What): Describes the desired end-state, letting the tool decide the
best way to reach it. Example: Terraform.
o​ Imperative (How): Specifies the exact steps to configure the infrastructure.
Example: Ansible.

3. IaC Tools

●​ Terraform:
o​ Definition: An open-source IaC tool by HashiCorp that allows users to define and
provision data center infrastructure using a declarative language (HCL -
HashiCorp Configuration Language).
o​ Example: Provisioning infrastructure across AWS, Google Cloud, and Azure with
a single script.
o​ Core Concepts:
▪​ Providers: Plugins for managing resources from different platforms (e.g.,
AWS, GCP).
▪​ Modules: Collections of resources that can be reused.
▪​ State: Terraform stores the state of managed infrastructure in a file,
allowing it to track changes and apply incremental updates.
o​ Benefits: Multi-cloud support, modular configuration, and easy rollbacks.
●​ Ansible:
 o​ Definition: An open-source automation tool that provides configuration
management, application deployment, and task automation.
o​ Example: Using Ansible Playbooks to configure web servers, set up databases,
and deploy applications.
o​ Core Concepts:
▪​ Playbooks: YAML files that define a series of tasks to execute on remote
hosts.
▪​ Roles: Reusable, modular units of code that contain related playbooks and
tasks.
▪​ Inventory: A list of hosts Ansible manages, organized by groups.
o​ Benefits: Agentless, easy to set up, suitable for configuration management and
application deployment.

4. Containerization and Orchestration

●​ Containerization:
o​ Definition: A lightweight form of virtualization that packages applications and
their dependencies into isolated containers.
o​ Example: A development team uses Docker to containerize an application,
allowing it to run consistently across development, testing, and production
environments.
o​ Benefits: Eliminates "it works on my machine" issues, enhances portability, and
optimizes resource usage.
●​ Orchestration:
o​ Definition: Orchestration is managing, coordinating, and scaling multiple
containers to ensure applications run smoothly across different environments.
o​ Example: Using Kubernetes to automatically scale and load balance a web
service across several containers.
o​ Benefits: Provides high availability, optimizes resource usage, and simplifies
complex deployments.

5. Docker and Kubernetes

●​ Docker:
o​ Definition: Docker is an open-source platform that allows developers to automate
the deployment of applications inside lightweight, portable containers.
o​ Core Concepts:
▪​ Docker Images: Immutable templates with application code and
dependencies.
▪​ Docker Containers: Run instances of Docker images, isolated from the
host system.
 ▪​Dockerfile: A script defining how to build an image (e.g., instructions to
install software).
▪​ Docker Compose: A tool to define and manage multi-container Docker
applications.
o​ Example: Dockerizing a Python web app and deploying it with a Dockerfile and
Docker Compose for a consistent environment setup.
o​ Benefits: Increases consistency across environments, simplifies dependency
management, and enhances portability.
●​ Kubernetes (K8s):
o​ Definition: Kubernetes is an open-source orchestration platform designed to
automate the deployment, scaling, and management of containerized applications.
o​ Core Concepts:
▪​ Pods: The smallest unit in Kubernetes, typically containing one or more
containers.
▪​ Services: Defines a policy to access pods, providing load balancing and
discovery.
▪​ ReplicaSets: Ensures a specified number of pod replicas are running.
▪​ Deployments: Defines the desired state for applications and manages
updates.
▪​ Namespaces: Logical clusters within a physical cluster, providing
resource isolation.
o​ Example: A company deploys a microservices architecture on Kubernetes, where
each microservice runs in its own pod, allowing independent scaling.
o​ Benefits: Provides scalability, high availability, and fault tolerance.

6. Managing Containers and Microservices with Kubernetes

●​ Definition: Kubernetes is particularly suited for microservices, as it enables independent

deployment, scaling, and maintenance of each microservice within an application.
●​ Key Kubernetes Features for Microservices:
o​ Scaling and Load Balancing: Automatically adjusts the number of replicas of
each service based on demand.
o​ Service Discovery and Load Balancing: Each service is exposed through a
stable IP or DNS name, with built-in load balancing.
o​ Storage Orchestration: Automatically mounts and manages storage, allowing
applications to maintain persistent data.
o​ Self-Healing: Continuously monitors the health of pods and replaces any that fail.
●​ Example: Deploying an e-commerce platform on Kubernetes with separate
microservices for user management, inventory, payments, etc., each running in isolated
pods. Kubernetes handles scaling, networking, and failover for each service, ensuring
high availability.