The DevOps Dictionary: Defining Our Weird And Wonderful Terms

DevOps is commonly defined as:

• A combination of technical practices and tools, and
• A distinctive collaborative culture that fosters teamwork between software development and IT teams.

However, if you’re new to the game, you might find yourself drowning in a sea of jargon and acronyms.

Here’s a roadmap:

A – C

A/Bn testing: A type of A/B testing where you deploy a new feature or update to a subset of users. [The “n” denotes that more than two features could be tested.]

Access Control: A security measure that allows you to restrict access to certain areas of your application to certain users.

Agile: Fluid software development, adapting to change like a pro.

Agile Development: Agile development is a software development methodology that emphasizes iterative development, team collaboration, and customer feedback.

AIOps: The use of artificial intelligence and machine learning algorithms to enhance and automate IT operations, including monitoring, incident management, and capacity planning.

ALB (Application Load Balancing): An AWS service used for splitting the incoming traffic between multiple application instances across multiple Availability Zones to ensure your app runs smoothly.

Amazon Aurora: An AWS service, providing a cloud-based relational database, which became the most rapidly growing service in AWS history.

Ansible: An automation engine for various IT tasks, like cloud infrastructure provisioning and configuration.

Apache: A cross-platform tool for launching websites and applications.

API (Application Programming Interface): APIs allow different systems to communicate and exchange data seamlessly.

Artifacts: The outputs of your development process, like compiled code or packaged applications, ready for deployment.

Attribute: A unique or standardized variable used to target users.

Automation:  Making repetitive tasks like deployments, testing, and infrastructure management run automatically.

AWS (Amazon Web Services): The most popular cloud service provider (CSP) according to the aforementioned State of DevOps report of 2017, offering a wide variety of cloud computing services for businesses of all sizes.

Backup: A process of copying the important data to provide the reserve copy and enable restoration on demand, as well as the result of the backup process, an archive with files.

Bare-metal: The case when the software is installed on the physical devices (hard disks), omitting the virtualization layer.

‍Beta Tester: A user who tests software before it is released to the general public.

Blue-Green Deployment: Like having two identical rooms, you switch traffic from one (blue) to the other (green) during deployment, minimizing downtime.

Branch: A temporary copy of your code, where you can experiment without affecting the main project.

Build: The process of transforming code into a usable product, like compiling, packaging, and testing.

Burn Rate: The speed at which you’re spending resources.

Canary Deployment/Launch: Deploy a small portion of your update to a limited group (the canary) to test before rolling it out to everyone.

Chaos Engineering: A practice of intentionally introducing failures and disruptions into a system to test its resiliency and identify potential weaknesses.

Cloud: A flexible, on-demand computing platform, like renting a server instead of buying one.

Cloud computing: A dominating IT paradigm of accessing over the Internet the networks of virtual servers for collecting, processing and storing data, running apps and managing other resources. An opposite of using dedicated servers or personal computers for that purpose.

Cluster: A set of interconnected instances (bare-metal servers, virtual machines, Kubernetes pods, etc.) that are treated as a single entity to enable load balancing, auto-scaling, and high availability.

Commit: The process of pushing the code to the Git repository and the resulting piece of code pushed.

Configuration Management (CM): Ensures consistency and repeatability by managing server configurations through code.

Container: A software envelope separating the app and all resources required to run it from the infrastructure it runs on.

Continuous Delivery (CD): Frequent, automated delivery of changes to production, minimizing risk and speeding up innovation.

Continuous Integration (CI): Merging code changes regularly and automating tests to catch issues early.

D – J

Datadog: An efficient cloud monitoring service, allowing to analyze the processes within any infrastructure, database or app at any scale, using a SaaS-based platform.

Dark Launching: Testing a new feature or application in a live environment without exposing it to end-users.

Declarative Infrastructure: Describing what your infrastructure should look like, and letting tools like Terraform figure out how to achieve it.

Deployment: Release your software to the world, like sending a rocket packed with new features soaring into the digital sky.

DevSecOps: A practice that integrates security into the DevOps lifecycle.

Disaster Recovery (DR): Having a plan and tools to recover quickly from system outages or disasters.

Django framework: A high-level Python framework oriented at clean design, rapid development and high performance of the apps.

Docker: A containerization technology that packages your application and its dependencies, making it portable and reliable.

Edge Computing: A distributed computing model where data processing and storage are performed closer to the edge of the network, reducing latency and improving real-time performance for IoT and other applications.

Elasticity: The ability of a system to dynamically adapt to changing workloads by adding or removing resources automatically.

Environment: The specific settings where your application runs.

Feature Toggle/Flags: Like switches, they enable or disable features in production without redeploying the entire application.

Feature Management: A process that ensures that new features are deployed and released to users in a strategic and controlled manner.

Git: The version control system that tracks changes in your codebase and keeps your code organized.

GitHub: The most popular web-based hosting for code, running all Git features and adding its own functionality.

GitLab: An open source web-based Git portal tuned for DevOps performance, due to the built-in support of CI/CD tools like Gitlab CI.

Gitlab CI: A CI/CD runner for Gitlab, which allows the developers to build their code automatically after each commit.

GitOps: Managing infrastructure and applications using Git, keeping them in sync with your code repository.

GitOps Operator: A Kubernetes operator that automates and manages the deployment of applications and infrastructure based on Git repository changes, implementing the GitOps methodology.

Golden Path: The ideal workflow for deploying your application.

High Availability (HA): Ensuring that your system or application is always operational, minimizing downtime and ensuring users can access services consistently.

Hypervisor: A software or hardware platform that creates and runs virtual machines.

Incident Management: Identifying, responding to, and resolving incidents that disrupt the normal operation of your system.

Infrastructure: Tthe whole complex of hardware, software, and processes required to run apps, as well as to collect, manage and store data.

Infrastructure as Code (IaC): Treat your infrastructure like code, making it versionable and flexible.

Infrastructure as Code (IaC) Framework: A framework that provides guidelines and best practices for writing infrastructure code.

Instance: A virtual machine you run your app on.

Integration Testing: Making sure different parts of your application work together seamlessly.

Iteration: A short cycle of development, testing, and feedback, allowing for quick course correction.

Jenkins: An open source Java server enabling software delivery automation out-of-the-box.

Jenkins Job: A process in Jenkins, needed to build code, run unit tests, generate code quality metrics, deploy the new app versions to production, etc.

Jira: A popular project management tool for tracking tasks and issues, like a digital whiteboard for your team.

K – P

Kanban Board: A visual workflow management system, like using sticky notes on a whiteboard to track tasks and progress.

Kill Switch: A software development technique that allows developers instantly disable code that isn’t performing as expected.

Kubernetes: A container orchestration platform that automates the deployment, scaling, and management of containerized applications.

Load Balancer: Distributes incoming network traffic across multiple servers to ensure no single server is overwhelmed.

Log: A record of events and activities.

Logstash: A part of the Elastic stack responsible for server-side data collection, processing and transfer to the storage.

Microservices: Break down large applications into smaller, independent units.

Mean Time to Resolution (MTTR): The average time it takes to fix an issue.

Metrics: Measurable data points that tell you how your system is perform.

Monitoring: Keep an eye on your system’s health.

Multi-Cloud Strategy: The use of multiple cloud service providers to reduce vendor lock-in, increase redundancy, and improve disaster recovery capabilities.

Nagios: An open-source monitoring tool used for tracking the status of hosts, services, and network devices in real-time.

Network: A web of that connect your computers, servers, and devices, allowing them to communicate and share information.

Notification: An alert that something needs attention.

Observability: The ability to gain insights into the performance and behavior of complex distributed systems. It includes monitoring, logging, and tracing to understand how applications and infrastructure are performing.

Open Source: Software with publicly available code that anyone can contribute to.

Ops (Operations): The team that keeps your infrastructure running smoothly.

Ops flag: Used when releasing features with unknown performance implications to ensure the safety of your systems during the deployment of the feature.

Opsgenie: A platform for incident alerting and management, notifying the right people and helping them collaborate to resolve issues.

OpenShift: Enterprise-grade container management platform for Kubernetes running on on-prem cloud infrastructures, developed by Red Hat.

OpenStack: An open source platform for building on-prem cloud infrastructures.

Orchestration: A practice of automating the IT tasks (container management and infrastructure configuration in particular) in the context of SOA, virtualization, environment provisioning.

Pair Programming: Two developers working together on the same code, promoting knowledge sharing and code quality.

Patch: A small fix for a specific issue.

Performance Optimization: Squeezing every ounce of speed out of your system.

Permission Flags: A type of feature flag that allows developers to control which users have access to specific features.

Personally Identifiable Information (PII): Any information that could be used to identify an individual or user.

Pipeline: A set of automated processes that facilitate the continuous delivery of software

Pod: basic Kubernetes structure unit, a group of Docker containers deployed to a single host.

Production: The environment where your application is used by real users.

Prometheus: An open source cloud monitoring solution with a powerful query language, time series database, dimensional data model and smart alerting capabilities.

Provisioning: Setting up and configuring infrastructure resources, like creating a new server.

Pull Requests: A code review process where developers propose changes and others can provide feedback before merging them into the main codebase.

Puppet: A popular tool for configuration management and automation.

Python: An interpreted high-level programming language. Due to its efficiency and speed, Python is now widely adopted for tasks from website development to Big Data analytics.

Q – Z

QA (Quality Assurance): The process of ensuring the quality and functionality of your application.

Refactoring: Improving the structure and maintainability of your code without changing its functionality.

Remediation: Automatically taking corrective actions to fix issues based on monitoring data, like restarting a crashed service.

Repository: A central location where you store your code and other project files, like a digital library.

Rollback: Quickly reverting to a previous version of your application if a deployment goes wrong, minimizing downtime and impact.

Rolling forward: The process of taking a new change and applying it to an existing system.

Rolling update: A process of smooth updates for an app without any downtime, performed instance by instance.

Scalability: The ability of your system to handle increasing or decreasing workloads efficiently, ensuring smooth performance under pressure.

Scrum: An agile project management framework that focuses on short sprints and continuous improvement.

Security: Protecting your systems and data from unauthorized access.

Serverless Computing: A type of service that provides access to computing resources on demand, without requiring users to configure or manage an entire server environment.

Serverless Framework: An open-source framework that simplifies the deployment and management of serverless applications.

Serverless Monitoring: The process of monitoring serverless functions and their performance in real-time, including response times, error rates, and resource usage.

Shift Left: Moving security and reliability testing earlier in the development lifecycle, catching issues sooner and preventing them from reaching production.

Staging Environment: A replica of your production environment for testing deployments and changes before they go live.

Stand-up Meetings: Short daily meetings for teams to communicate progress and roadblocks.

Targeting Rule: A statement that defines which users should be included in a particular group.

Telemetry: Collecting data about your system’s behavior to gain insights and improve performance.

Terraform: An open-source infrastructure as code tool used for building, changing, and versioning infrastructure efficiently.

Test-Driven Development (TDD): Writing tests first to guide and ensure the implementation of functionality.

Testing: Evaluating your application to ensure it meets requirements and behaves as expected.

Time Bomb: A piece of code that is designed to cause problems at a specific time.

Trunk Based Development: A software development strategy where engineers merge smaller changes into the main codebase.

Unit Testing: The practice of testing the app code in small chunks against the automated test codebase before building the app, to minimize the time needed to discover and fix the bugs, reducing the time to market for a product as a result.

User Acceptance Testing (UAT): A phase in software development where the end-users evaluate and validate the application to ensure it meets their requirements

User Segmentation: The process of dividing users into groups based on certain criteria.

Vagrant: A tool for creating and managing virtual machines, like having a portable, pre-configured server environment in your pocket.

Version Control: Tracking changes to your code over time, allowing collaboration and easy rollbacks.

Virtual Machine: A basic unit of the cloud computing systems, an emulation of a physical server running under a supervisor.

Waterfall Development/Model: A traditional development methodology where each phase of the project is completed before moving on to the next phase.

Workflow: The series of steps that tasks progress through in your development process.

Zero Downtime Deployments: Updating your application without any interruption to service.

METHODS

DevOps includes several techniques that are independent of each other:

• Agile Software Development
• Continuous Integration (also: CI or Continuous Integration) and Continuous Delivery (also: CD).
• Continuous Service Monitoring
• Microservices
• Automated software testing
• Software Configuration Management, version management and “Infrastructure as Code”.
• Cross-domain Key Performance Indicators (KPIs)

TOOLS

The above methods are enabled or supported by the following DevOps tools, for example:

• GitHub and GitLab (for Continuous Integration and Continuous Delivery, automated software testing and version management).
• Jenkins (Continuous Integration)
• Puppet (for Infrastructure as Code)
• Ansible (for configuration management)
• Vagrant (as a virtualization platform)
• Azure DevOps (e.g. for Continuous Integration, Testing, Release Management and Systems Management)
• Microsoft Azure (for monitoring and hosting)
• Team Foundation Server
• Docker (for container virtualization)
• Kubernetes (container orchestration)

This is the most detailed DevOps glossary you’ll find on the net yet.

You’re welcome!