DevOps is the modern approach in
Agile to solve the problem of the communication between the
developer, and the
operations team. In the software development cycle, the developer is the person that is meant to develop features in code, the tester is meant to make sure all the tests are satisfied and nothing breaks in the development environment. The
operations has to take care of pushing those new changes into the production environment and to make sure it does not break anything else. This whole cycle mainly comprises of the following main points,
- Designing (the infrastructure and networking)
- Observability (implementing Logging, Metrics and Tracing)
- Automation (CI/CD pipelines, deployments, auto-scaling )
The idea is that developer wants to make changes and push those to the production as soon as possible, also called
early to market, but doing this in the past has resulted in the Ops person receiving calls at 2 AM in the morning about something critical breaking - no one likes that. The
Ops person on the other hand wants to strive to maintain as much stability as possible, and always pushing new changes ( increasing the velocity ) leads to breaks - which is undesired.
So the idea has been mainly on focusing on automation in order to make changes as quickly as possible, and finding the way to maintan good velocity as well as stability.
Table Of Contents
- Table Of Contents
- Please Read First
- An Introduction
- Getting Started
- People To Follow
- Learning Materials
Please Read First
The modern DevOps consists of automated sets of tests that keep checking if the new changes break anything, it has an automated sense of commands that take in some configuration files, make sense of the changes, and apply those settings to a containzired environment. Usually, you’ll find the changes being
containers that have the complete environment setup for the customer.
So what is the remaining work? It’s to configure
.yaml / .yml files that take in
manifestations of the
images that you want to push to production and making sure and note of what changes happen when and what breaks and what’s get fixed, most likely through a versioning tool such as
git. Companies also prefer to use
bitbucket for extra features.
Want to see a repo with all these concepts and questions? Check out Tikam02/DevOps-Guide!
For being a DevOps practitioner, you should be familiar with these ideas:
- Version Control and Source Code Management (SCM)
- Git / GitHub / GitLab / BitBucket
- Docker / Virtual Machines (VM)
- Configuration Management
- Ansible / Chef / Puppet
- Automation (CI/CD) Server
- Jenkins / TeamCity / Circle CI / BuildKite / Azure DevOps / BitBucket Pipelines / GitLab / GitHub Actions / etc.
- Bash / Python / Perl / etc.
- Orchestrator Engine
- Kubernetes / Docker Swarm / Docker Compose / AWS ECS
- Automated Testing
- Test Driven Development (TDD), BDD, etc.
- Code Quality
- Delivery Reports
- DORA Metrics
- Cloud Computing
- Amazon Web Services (AWS), Google Cloud Platform (GCP), Microsoft Azure
- Infrastructure as Code (IaC)
- Terraform / AWS CloudFormation / Plumi
- Scrum / Kanban / Lean
- Working With CLI
- Zsh / Fish / Bash / AWS CLI
- Continuous Integration
- Continuous Delivery
- Docker Hub / GitHub / JFrog / etc.
- Continuous Deployment
- Ansible / CodeDeploy / etc.
It is hard to justify what is DevOps or how to implement it in a proper way. You can read about it in FAQs. To become an engineer with firm DevOps concepts you have to be a Developer or Operations person at first. Then you pivot into being a DevOps Engineer or Systems Engineer as it is formally called. An extension to DevOps is Site Reliability Engineering (SRE). A complete DevOps person would know one of the technology from each segment mentioned in Technologies.
People To Follow
Is DevOps a title (designation or role), a team, a practice or something else?
DevOps is the set of practices and mindset for modern software delivery. It provides highlevel guidelines on automation, continuous improvements, and increasing the end to end value in software development lifecycle.
What is SRE (Site Reliability Engineering)? How is it different from DevOps?
SRE is a term coined by Google. SRE is one of the way to implement DevOps and can be understood as a concrete set of practices based on abstraction defined by DevOps. SRE has terms like Toil, SLIs, SLOs, SLAs, etc which all serve a purpose to improve overall system value.
Books To Look Into
For Testing Software
- Sample Application On JSFiddle
- Creating & Managing Users with Google Firebase + Domain Validator. This is the sample application whose code appears in the test examples below.
- Unit Test Example on JS Fiddle: Unit Testing Domain Validator (with Jasmine). Taking look at a Unit Test.
- Unit Test Practice Problem on JS Fiddle: Jasmine Test Hello World, Running oaccess n jsFiddle. This is the simple ‘Hello World’ example you can play with if you’re interested.
- Integration Test Example on JS Fiddle: Integration Testing Domain Validator (with Jasmine).
- Testing In General
- Tutorial from ThoughtWorks on Test Suite Composition: The Practical Test Pyramid. Note: A look into the testing pyramid.
- Post from Simon Stewart at Google on Test Type Definitions: Test Sizes. This is the source of the test sizes (small (aka unit), medium (aka integration), large (aka system)) kind of referenced in the previous link
- Post from Alan Page of Angry Weasel on Integrated/Test-First vs. Silo’ed/Test-Last Schools: Two new…schools?.
- Parable from Alberto Savoia on Test Coverage: What is a reasonable code coverage % for unit tests (and why)?
- Wikipedia Page on Technical Debt: Technical Debt
- Test-Driven Development
- Post by David Heinemeier Hansson on what he calls ‘test-first fundamentalism’: TDD is dead. Long live testing. While many developers benefit from test-driven development (TDD) and advocate its practice, this is perspective you might find interesting, particularly regarding things your team may be grappling with as they consider and refine their practice of TDD.
- Discussions between Kent Beck, David Heinemeier Hansson, and Martin Fowler on TDD: Is TDD Dead?.
Doing the Jobs of Ops
- Interview with Ben Treynor, VP of Engineering at Google on the SRE Concept: What is ‘Site Reliability Engineering’?
- Short Form Piece on Infrastructure as Code by Martin Fowler: InfrastructureAsCode
- Krishelle Hardson-Hurley on Pivoting to an SRE Role: So you want to be an SRE?
- Asaf Yigal on SRE vs. DevOps: SRE vs. DevOps — a False Distinction?
- Aymen El Amri on DevOps-Related Foundation Skills: The Must Know Checklist For DevOps & Site Reliability Engineers. I’m not sure every ops-employed person would 100% agree with this list. As the author says, ‘This list is opinionated.’. However, I think at a minimum it’s a good starter list to get a sense of what types of skills individuals in these roles tend to need.
- Video Overview of Continuous Integration from a Developer Perspective (Mattias Petter Johansson ): Continuous Integration - What’s the point? - Continuous Integration P1 && Getting started with CircleCI - Continuous Integration P2 && Running CircleCI on Pull Request - Continuous Integration P3
- Continuous Delivery Book by Jez Humble: Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation
Agile in General
- Online Specialization on Coursera: Agile Development
- Tutorial on about agile on Alex’s Site: Agile - Just the Basics. This page covers…the basics. It’s a good place to start if you want to understand the general nature of a topic and how it relates to the practice of agile.
- Tutorial on about Using User Stories on Alex’s Site: Your Best Agile User Story. This page covers the user story- how to prepare to write them, how to use them, and how to link them to implementation and testing.
- Bringing Design to Agile
- Tutorial on Alex’s Site: Venture Design. This page provides a comprehensive set of resources. What I would do for a general overview is just read the intro to each of the areas (Personas, Problem Scenarios, etc.).
- Tutorial on Alex’s Site: Venture Design Sprints. This page provides an overview of design sprints and four different focal types for those sprints: Problems, Motivation, Usability, and Architecture.
- Bringing Lean Startup to Agile
- Tutorial on Alex’s Site: Your Lean Startup. This tutorial will allow you to review the fundamentals and a few case studies. It also links to the applicable Venture Design templates.
- Playlist in Google Cloud Platform youtube channel class SRE implements DevOps