Understanding the basics of DevOps
4 min read
What is DevOps?
According to Wikipedia
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. DevOps is complementary with Agile software development; several DevOps aspects came from the Agile way of working.
If you found the above definition complex don't worry this blog would help you understand the fundamentals of DevOps
DevOps is a cultural practice by the development team and operation team to use each other tools, to smooth out the software delivery.
Need for the DevOps
Running code in the local system is not the same as running the code in the production environment especially when multiple people are working on the same codebase.
A general flow of execution is to code your software then test it and if it passes then deploy it to the server. Once deployed you need to operate it as well.
While the above flow seems to deliver the software but has its own challenges that can hamper developer productivity and operational downtimes.
DevOps in an Organization
The organization that wants to implement DevOps practices should be clear with its Core Values, Core Ideas, and Methods.
Should have well-defined Practices and implement Tools
The goal of the organization to implement DevOps should be to Deploy faster, have Less failure, and have Better recovery time. The team should think of it as a complete process
- Talk to each other and understand how things work altogether
- People over process over tools. Always optimize for people
- Tools does not just mean chef or puppet explore different tools
- Understand how many servers you need
- Know how much can you automate and should you automate?
- Measure to improve and optimize
- It should not just be about infra but also include business measures, client activity, and other points
- Recovery time and cycle time are important to monitor and incentivize it
- Clearly share goals and responsibility
- Provide ownership and no scapegoat
- Having a feedback loop is important
It's a practice of not passing a known defect to downstream work centers, never allowing local optimization to create global degradation, always seeking to increase flow, and always seeking to achieve a profound understanding of the system
It's a practice of understanding and responding to all customers, internal and external, shortening and amplifying all feedback loops, and embedding knowledge where we need it.
Experiment and learn
It's a practice of allocating time for the improvement of daily work, creating rituals that reward the team for taking risks, and introducing faults into the system to increase resilience.
- While investigating the failure the focus should be on learning why and how did the failure occur to improve it, instead of blaming the system or people.
- The information regarding the system failure should not be isolated to a few people but should be shared with everyone concerned
Integrate team - Dev, and Ops
- Having isolated teams creates an invisible wall that can act as a barrier and may impact the performance of the teams
Extension of agile
- Have some sort of Agile management integrated into DevOps practices
- Embrace Infrastructure as Code and Version control to have a track of changes
- Provisioning: server is ready with os, software, and networking
- Deployment: adding or upgrading software on the server
- Orchestration: coordinated operations on multiple systems
- Configuration management: managing server configuration via files such as ram, space, dependency software, etc
- Imperative (procedural): commands to produce desirable state
- Declarative (procedural): the desired state is defined and tools will achieve it
- Idempotent: repeat execution and the same result
- Blue-green deployment: Identical deployment, used as a switch
- Continuous integration: build and test at every check-in
- Continuous delivery: deploy on production live environment at every check
- Continuous deployment: after unit testing, deploy changes to production in small batches