DevOps
DevOps is a set of practices that combines software development (Dev) and IT operations (Ops). It aims to shorten the systems development life cycle and provide continuous delivery with high software quality.
1. The Core Philosophy
DevOps is not just about tools; it is a cultural shift. It breaks down the "silos" between development and operations teams.
- Traditional: Developers write code and "throw it over the wall" to Operations to deploy and manage. If it breaks, it's Ops' problem.
- DevOps: "You build it, you run it." The team that writes the code is responsible for its deployment and maintenance in production.
2. The CAMS Model
A common acronym to describe the pillars of DevOps:
- Culture: Collaboration, communication, and shared responsibility.
- Automation: Automating repetitive tasks (testing, deployment, infrastructure provisioning) to reduce human error and increase speed.
- Measurement: Using data (metrics, logs) to make decisions and improve performance.
- Sharing: Sharing knowledge, tools, and success/failure stories across the organization.
3. The DevOps Lifecycle
The lifecycle is often visualized as an infinite loop:
- Plan: Define requirements and tasks.
- Code: Write software.
- Build: Compile and package the software.
- Test: Automated testing (Unit, Integration, etc.).
- Release: Prepare artifacts for deployment.
- Deploy: Push to production environments.
- Operate: Manage and maintain the running system.
- Monitor: Track performance and user feedback (Observability).
4. Key Practices
- Continuous Integration / Continuous Deployment (CI/CD): Automating the path from code commit to production.
- Infrastructure as Code (IaC): Managing infrastructure (servers, networks) using code and version control (e.g., Terraform, Ansible).
- Microservices: Building applications as a collection of small, independent services.
- Monitoring & Logging: Real-time visibility into system health.
5. Benefits
- Speed: Faster time to market.
- Reliability: Automated testing and smaller changes reduce failure rates.
- Scale: Managing complex infrastructure at scale becomes easier with automation.
- Security: Integrating security early in the lifecycle (DevSecOps).
6. DevSecOps
DevSecOps stands for Development, Security, and Operations. It integrates security practices into the DevOps process.
- Shift Left Security: Instead of checking for security vulnerabilities at the very end (just before release), security checks are automated and run early in the pipeline (during coding and building).
- Automated Security Testing:
- SAST (Static Application Security Testing): Scanning source code for vulnerabilities.
- DAST (Dynamic Application Security Testing): Scanning running applications for vulnerabilities.
- Dependency Scanning: Checking for known vulnerabilities in third-party libraries.
7. Site Reliability Engineering (SRE)
SRE is a discipline that incorporates aspects of software engineering and applies them to infrastructure and operations problems.
- DevOps vs. SRE: DevOps is the philosophy ("Break down silos"), while SRE is a prescriptive way of achieving that philosophy ("Here is how we measure reliability").
- Error Budgets: The concept that 100% reliability is not the goal. If your SLO is 99.9%, you have an "error budget" of 0.1%. As long as you are within budget, you can ship features fast. If you exhaust it, you freeze releases and fix stability.
- Toil Reduction: SREs aim to automate manual, repetitive, tactical work (toil) so they can focus on engineering long-term solutions.
programming/ci-cd-pipelines programming/docker-and-containers programming/microservices-architecture programming/observability-vs-monitoring programming/software-development-life-cycle