Foundations for DevOps

Concept Detailed Explanation with Example Top 3 Tools/Strategies
Containerization Containerization is like packaging an application into a self-contained unit, a container. It allows the application to run consistently across different environments. Example: Packaging a Python web app and its dependencies in a Docker container.
Docker Docker is an open-source platform for containerization. It simplifies the process of creating, deploying, and running applications in containers. Tools: Docker, containerd, CRI-O.
Container Image A container image is a lightweight, standalone, and executable package that includes everything needed to run an application, such as code, libraries, and dependencies. Example: Creating an image for a Node.js application with its runtime dependencies.
Container Registry A container registry is a centralized repository for storing and distributing container images. It provides a convenient way to share and manage container images. Tools: Docker Hub, Google Container Registry, AWS ECR.
Container Orchestration Container orchestration involves managing the deployment, scaling, and operation of containerized applications in a distributed system. Tools: Kubernetes, Docker Swarm, Amazon ECS.
Kubernetes Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. Tools: Kubernetes, kops, Minikube.
Pod A pod is the basic unit of deployment in Kubernetes, representing one or more containers that are deployed together on the same host. Example: Deploying a pod with a frontend and backend container in Kubernetes.
Service A service in Kubernetes is a logical set of pods and a policy by which to access them, often using a load balancer. It enables stable network access to the pods. Tools: Kubernetes Services, Docker Compose, OpenShift Services.
Deployment Deployment in Kubernetes specifies how a container or set of containers should be deployed and updated in the cluster. It defines the desired state of the application. Example: Configuring a rolling update deployment in Kubernetes.
Scaling Scaling involves adjusting the number of replicas of a container or set of containers based on demand. It ensures that the application can handle varying workloads. Tools: Kubernetes Horizontal Pod Autoscaler, Docker Swarm Scaling.
Health Check A health check is a mechanism for testing the health of a container or set of containers. It helps determine whether a container should be restarted or removed from service. Tools: Kubernetes Liveness Probe, Docker Health Check.
Volumes Volumes provide a persistent storage mechanism for containers. They allow data to be shared between containers and preserved across container restarts. Tools: Kubernetes Volumes, Docker Volumes, OpenShift Persistent Storage.
Namespaces Namespaces in Kubernetes are a mechanism for dividing cluster resources among multiple users or projects, providing isolation. Example: Using namespaces to separate development and production environments.
Secrets Secrets in Kubernetes provide a secure way to store sensitive data, such as passwords or TLS certificates, within the cluster. Example: Storing a database password as a Kubernetes Secret.
ConfigMaps ConfigMaps in Kubernetes store configuration data for use by containers. They allow decoupling configuration from the container images. Example: Managing application configuration using ConfigMaps.
Resource Limits Resource limits in Kubernetes specify the maximum amount of compute resources, such as CPU and memory, that a container is allowed to use. Example: Setting resource limits for a Java application in Kubernetes.
Rollout Rollout is the process of deploying new code or configuration changes to a container or set of containers. It ensures a controlled and managed update. Example: Rolling out a new version of a web application in production.
Canary Deployment Canary deployment is a strategy where a small number of containers running the new code or configuration are gradually increased, allowing for testing before a full rollout. Tools: Kubernetes Canary Deployments, Istio Traffic Management.
A/B Testing A/B testing is a deployment strategy where two or more versions of an application are deployed and tested concurrently, with traffic being routed to different versions. Example: Testing two variations of a website to determine user preferences.
Blue-Green Deployment Blue-Green deployment is a strategy in which two identical copies of an application are run concurrently, with traffic being routed to one while the other is updated. Example: Switching traffic from the Blue to the Green environment after an update.
Container Runtime Container runtime is the software responsible for executing containers on a host. It interprets container images and manages their execution. Tools: Docker, containerd, CRI-O.
Container Networking Container networking is the process of connecting containers to each other and to the external network. Various drivers enable communication between containers. Tools: Default Bridge Driver, Kubernetes Networking, Calico.
Multi-Tenancy Multi-tenancy allows running multiple isolated workloads on a shared cluster, using mechanisms like namespaces to prevent interference between workloads. Tools: Kubernetes Namespaces, OpenShift Multi-Tenancy.
Sidecar Pattern The sidecar pattern involves adding an auxiliary container (sidecar) to a pod to perform specific tasks, such as logging or monitoring. Example: Adding a sidecar container for log processing in a pod.
Istio Istio is an open-source service mesh platform that provides advanced networking and security features for containerized applications. Tools: Istio, Linkerd, Consul.
Cloud Native Cloud-native refers to applications and infrastructure designed to be deployed in a cloud environment, leveraging containers and modern technologies. Example: Developing and deploying microservices in a cloud environment.
Microservices Microservices is an architectural style where a single application is decomposed into smaller, independent services that can be developed, deployed, and scaled independently. Tools: Kubernetes, Docker, Istio.
Serverless Computing Serverless computing is a model where the cloud provider dynamically allocates resources to run code in response to incoming requests, without managing servers. Tools: AWS Lambda, Azure Functions, Google Cloud Functions.
Container Security Container security involves securing the host system, container images, and runtime environment to protect against threats and vulnerabilities. Tools: Clair, Aqua Security, Twistlock.
Image Signing Image signing is a security mechanism for verifying the authenticity and integrity of container images, using digital signatures and trusted image repositories. Example: Signing Docker images using Docker Content Trust.
Vulnerability Scanning Vulnerability scanning is the process of identifying and mitigating vulnerabilities in container images and runtime environments. Tools: Clair, Aqua Security, Twistlock.
AppArmor AppArmor is a Linux kernel security module that allows administrators to specify fine-grained access controls for programs running in containers. Example: Applying AppArmor profiles in Kubernetes.
SELinux SELinux is a Linux security module providing mandatory access control (MAC) to prevent unauthorized access to resources within a container. Example: Setting SELinux labels for Docker containers.
Container Isolation Container isolation is the process of separating resources and processes of one container from another, ensuring security and preventing interference. Tools: Kubernetes PodSecurityPolicy, Docker Security Mode.
Container Placement Container placement involves deciding on which host or hosts to run a container or set of containers, based on factors like resource availability and network latency. Strategy: Kubernetes Scheduler, Docker Swarm Scheduler.
Batch Processing Batch processing is the process of running a large number of jobs, often using containers to parallelize work and improve resource utilization. Example: Using Apache Flink for distributed batch processing.
CI/CD CI/CD (Continuous Integration and Continuous Delivery) automates building, testing, and deploying code changes to ensure a consistent and reliable development pipeline. Tools: Jenkins, GitLab CI, CircleCI.
Rolling Updates Rolling updates involve updating containers gradually over time, allowing for a more gradual transition and the ability to roll back if necessary. Strategy: Kubernetes Rolling Updates, Docker Swarm Rolling Updates.
Persistent Storage Persistent storage ensures data is retained across container restarts and host failures. It is crucial for applications that require durable data storage. Tools: Kubernetes Persistent Volumes, Docker Volumes, NAS.
Stateful Applications Stateful applications maintain a persistent state, such as databases. They require persistent storage for data consistency across container restarts. Example: Running a stateful MySQL database in Kubernetes.
Stateless Applications Stateless applications do not maintain persistent state and can be easily scaled horizontally by adding more instances. They are often simpler to containerize. Example: Stateless microservices in a cloud-native architecture.
Container-Native Virtualization Container-native virtualization allows containers to run directly on a host’s kernel without a traditional hypervisor, enhancing performance and resource utilization. Tools: Kata Containers, gVisor, runC.
Immutable Infrastructure Immutable infrastructure involves treating infrastructure components, like servers or containers, as disposable and replacing them rather than modifying in place. Tools: Docker, Kubernetes, Terraform.
12-Factor App The 12-factor app is a set of best practices for building cloud-native applications, emphasizing factors like codebase, dependencies, and config. Example: Adhering to the 12-factor app principles in a microservices architecture.
Cloud-Agnostic Cloud-agnostic refers to the ability to run containerized applications on any cloud platform, avoiding vendor lock-in. Portable container orchestration tools, like Kubernetes, support this. Tools: Kubernetes, Docker, OpenShift.
Service Mesh A service mesh is a layer of infrastructure providing advanced networking and security features, such as load balancing and service discovery, for containerized applications. Tools: Istio, Linkerd, Consul.
Sidecar Proxy A sidecar proxy is a container running alongside a primary container, intercepting network traffic and providing features like service discovery and load balancing. Tools: Envoy, Linkerd, NGINX.
Ingress Controller An ingress controller sits in front of services and routes incoming traffic based on rules defined in a Kubernetes Ingress resource. It manages external access to services. Tools: Nginx Ingress, Traefik, HAProxy.
Ingress Resource An Ingress resource in Kubernetes defines rules for routing incoming traffic to services within a cluster. It acts as a configuration for external access. Example: Defining rules for routing HTTP traffic to different services.
Virtual Kubelet Virtual Kubelet acts as a bridge between a Kubernetes cluster and other infrastructure, allowing non-Kubernetes workloads to be treated as first-class citizens. Tools: Virtual Kubelet, AKS Virtual Nodes, KubeVirt.
Container-Based Infrastructure Container-based infrastructure uses containers as the primary packaging and deployment mechanism for applications, providing improved resource utilization and portability. Tools: Docker, Kubernetes, OpenShift.
Container Platform A container platform is a suite of tools and services for building, deploying, and managing containerized applications. Examples include Docker Enterprise and Red Hat OpenShift. Tools: Docker Enterprise, Red Hat OpenShift, Kubernetes.
Container Security Scanning Container security scanning involves analyzing container images for vulnerabilities and security issues before deployment. Tools: Clair, Aqua Security, Twistlock.
Container Networking Model Container networking model defines how containers communicate with each other and the external network. It involves various drivers and protocols for networking. Tools: Default Bridge Driver, Kubernetes Networking, Calico.
Service Discovery Service discovery is the process of locating and connecting to other services in a distributed system. It often uses a registry or directory service for discovery. Tools: Consul, etcd, Kubernetes Service Discovery.
Load Balancing Load balancing distributes incoming requests across multiple instances of a service to improve resource utilization and availability. Tools: HAProxy, NGINX, Kubernetes Load Balancer.
Request Routing Request routing is the process of directing incoming requests to the appropriate service based on rules, such as the path or hostname of the request. Tools: NGINX, Traefik, Istio Traffic Management.
Service Registry A service registry is a directory of available services and their locations, used by clients to discover and connect to services in a distributed system. Tools: Consul, etcd, ZooKeeper.
Container Networking Overlay A container networking overlay spans multiple hosts, allowing containers on different hosts to communicate as if they were on the same network. Tools: Docker Overlay Network, Kubernetes Network Policies, Calico.
Container Networking Bridge A container networking bridge is a virtual network interface connecting a container to the host network, enabling communication with the outside world. Tools: Docker Bridge Network, Kubernetes Networking, Weave.
Container Networking Port Mapping Port mapping is the process of mapping a port on the host network to a port on a container, allowing incoming traffic to be forwarded to the container. Tools: Docker Port Mapping, Kubernetes Service NodePort, Traefik.
Container Networking DNS Container networking DNS resolves hostnames to IP addresses within a containerized environment, allowing communication using domain names instead of IP addresses. Tools: CoreDNS, kube-dns, Docker DNS.
Container Networking Service Discovery Service discovery in container networking involves locating and connecting to other services, often using a registry or directory service for efficient discovery. Tools: Consul, etcd, Kubernetes Service Discovery.
Container Networking Load Balancing Load balancing in container networking distributes incoming requests across multiple instances of a service to enhance resource utilization and availability. Tools: HAProxy, NGINX, Kubernetes Load Balancer.
Container Networking Request Routing Request routing in container networking directs incoming requests to the appropriate service based on rules like path or hostname of the request. Tools: NGINX, Traefik, Istio Traffic Management.
Container Networking Service Registry A service registry in container networking is a directory of available services and their locations, facilitating client discovery and connection to services. Tools: Consul, etcd, ZooKeeper.
Container Networking Service Mesh A service mesh in container networking is a layer of infrastructure providing advanced features like load balancing, service discovery, and secure communication. Tools: Istio, Linkerd, Consul.
Container Networking IPC Inter-Process Communication (IPC) in container networking is the way processes communicate within a system, utilizing mechanisms like pipes, sockets, or message queues. Tools: Docker IPC, Kubernetes IPC, Container Orchestrator IPC.
Container Scaling Container scaling is the process of adjusting the number of replicas of a container or set of containers based on demand, ensuring optimal resource usage. Tools: Kubernetes Horizontal Pod Autoscaler, Docker Swarm Scaling.
Autoscaling Autoscaling automatically adjusts the number of replicas of a container or set of containers based on predefined policies or metrics like CPU utilization or request volume. Tools: Kubernetes Autoscaler, AWS Auto Scaling, Azure Autoscale.
Horizontal Scaling Horizontal scaling involves scaling a service by adding more replicas, distributing the workload, and improving performance without increasing individual instance resources. Tools: Kubernetes Horizontal Pod Autoscaler, Docker Swarm Scaling.
Vertical Scaling Vertical scaling involves increasing the resources of individual instances, such as CPU or memory, to handle increased workload demands for a specific container. Tools: Kubernetes Vertical Pod Autoscaler, Docker Resource Scaling.
Deployment Strategies Deployment strategies are methods for deploying and updating containerized applications, including rolling updates, blue-green deployments, and canary deployments. Strategies: Kubernetes Rolling Updates, Blue-Green Deployments, Canary Deployments.
Deployment Automation Deployment automation uses tools and processes to automate the deployment and management of containerized applications, ensuring consistency and efficiency. Tools: Jenkins, GitLab CI/CD, Kubernetes Deployments.
Continuous Integration (CI) Continuous Integration (CI) merges code changes frequently and automatically builds and tests the codebase to maintain a consistent and deployable state. Tools: Jenkins, GitLab CI, CircleCI.
Continuous Delivery (CD) Continuous Delivery (CD) automates the process of delivering code changes to production, ensuring that the code is always in a deployable state. Tools: Jenkins, GitLab CI/CD, ArgoCD.
Continuous Deployment Continuous Deployment (CD) automatically deploys code changes to production without human intervention, ensuring rapid and consistent delivery. Tools: Jenkins, GitLab CI/CD, ArgoCD.
Cloud-Native Design Principles Cloud-native design principles guide the development of applications for the cloud, emphasizing factors like being loosely coupled, horizontally scalable, and resilient. Principles: Twelve-Factor App, Microservices, Stateless Design.
Container Clustering Container clustering groups multiple containers to form a logical unit, enabling them to be managed and scaled as a single entity for efficient resource utilization. Tools: Kubernetes, Docker Swarm, OpenShift.
Container Scheduling Container scheduling involves deciding on which host to run a container, considering factors like resource availability, affinity rules, and taints and tolerations. Strategy: Kubernetes Scheduler, Docker Swarm Scheduler.
Resource Constraints Resource constraints set limits on the amount of resources, such as CPU or memory, that a container is allowed to use, preventing resource exhaustion. Tools: Kubernetes ResourceQuotas, Docker Resource Constraints.
Affinity Rules Affinity rules specify which containers should be co-located on the same host or which hosts a container should be excluded from based on certain criteria. Tools: Kubernetes Affinity, Docker Compose Placement.
Taints and Tolerations Taints and tolerations mark a node as unsuitable for certain pods, allowing specific pods to be scheduled onto tainted nodes based on defined tolerations. Tools: Kubernetes Taints, Docker Swarm Constraints.
Pod Disruption Budget A pod disruption budget specifies the minimum number of pod replicas that must be available at all times and controls the rate of pod terminations during events. Tools: Kubernetes PodDisruptionBudget, OpenShift Disruption Controllers.
Container Security Context Container security context involves applying security-related settings to a container, such as privilege levels, AppArmor profiles, and SELinux labels. Tools: Kubernetes SecurityContext, Docker Security Options.
Container Networking Policies Container networking policies are rules that specify which containers are allowed to communicate with each other and define how they are allowed to communicate. Tools: Kubernetes NetworkPolicies, Calico, Cilium.
Kubernetes Operators Kubernetes Operators are a method of packaging, deploying, and managing applications as code using custom resources, extending Kubernetes functionality. Tools: Operator SDK, Helm, Ansible.
Infrastructure as Code (IaC) Infrastructure as Code (IaC) represents the practice of managing and provisioning infrastructure using machine-readable script files, improving consistency. Tools: Terraform, Ansible, CloudFormation.
Cloud-Native Storage Cloud-native storage solutions are designed for containerized environments, providing scalable and dynamic storage that can be easily integrated with orchestration tools. Tools: Rook, OpenEBS, Portworx.
StatefulSet StatefulSet in Kubernetes is a workload API object used for managing stateful applications, providing guarantees about the ordering and uniqueness of pods. Tools: Kubernetes StatefulSet, Helm, OpenShift StatefulSet.
Helm Helm is a package manager for Kubernetes that simplifies deploying and managing applications using charts, which are packages of pre-configured Kubernetes resources. Tools: Helm, Helmfile, Kustomize.
GitOps GitOps is a set of practices for managing infrastructure and application configurations using version-controlled Git repositories, ensuring declarative state. Tools: ArgoCD, Flux, Jenkins X.
Event-Driven Architecture Event-Driven Architecture (EDA) is an architectural style where services communicate and react to events, enabling decoupled and scalable systems. Example: Building a system using Apache Kafka for event streaming.
Domain-Driven Design (DDD) Domain-Driven Design (DDD) is a methodology for developing software systems based on understanding and modeling the business domain, fostering collaboration. Tools: None specific, but DDD principles can be applied in software design.
Pipeline A CI/CD pipeline automates the steps from code integration to deployment, ensuring code is tested and delivered consistently and quickly. Tools: Jenkins, GitLab CI/CD, CircleCI.
Canary Release Canary release is a deployment strategy where a small subset of users receives the new version first, allowing testing before a full rollout. Strategies: Kubernetes Canary Deployments, Istio Traffic Shifting, Spinnaker.
Dark Launch Dark launch is a technique where new features are deployed but kept hidden from users, allowing testing and gradual exposure based on performance. Strategies: Feature toggles, LaunchDarkly, Unleash.
Feature Toggle Feature toggle is a technique where a feature is selectively enabled or disabled at runtime, providing control over the release of new functionalities. Tools: LaunchDarkly, Unleash, ConfigCat.
Infrastructure as Code (IaC) IaC involves managing infrastructure using code, enabling version control, repeatability, and automation of infrastructure provisioning. Tools: Terraform, Ansible, AWS CloudFormation.
ChatOps ChatOps integrates chat platforms into the development process, allowing teams to collaborate, automate tasks, and receive notifications within chat tools. Tools: Slack, Microsoft Teams, Hubot.
GitOps GitOps is an approach where Git repositories serve as a source of truth for declarative infrastructure and application configurations. Tools: ArgoCD, Flux, Jenkins X.
Chaos Engineering Chaos engineering involves intentionally introducing failures into a system to identify weaknesses and improve overall resilience. Tools: Chaos Monkey, Gremlin, Chaos Toolkit.
Log Aggregation Log aggregation centralizes and collects logs from various services and applications, making it easier to analyze and troubleshoot issues. Tools: ELK Stack (Elasticsearch, Logstash, Kibana), Splunk, Fluentd.
Monitoring and Alerting Monitoring tracks system health, while alerting provides notifications for abnormal conditions, helping teams respond to issues promptly. Tools: Prometheus, Grafana, Nagios.
Incident Response Plan An incident response plan outlines steps and procedures for handling and mitigating incidents, ensuring a structured and coordinated response. Strategies: Runbooks, Incident Command System (ICS), PagerDuty.
Microservices Architecture Microservices architecture decomposes a monolithic application into smaller, independent services, allowing development, deployment, and scaling of individual components. Tools: Kubernetes, Docker, Istio.
Observability Observability involves understanding and measuring the internal state of a system using metrics, logs, and traces to facilitate effective troubleshooting. Tools: Prometheus, Grafana, Jaeger.
Security as Code Security as code integrates security practices into the development process, applying security measures through code and automation. Tools: Checkmarx, SonarQube, Snyk.
Compliance as Code Compliance as code ensures that infrastructure and applications adhere to regulatory requirements by codifying compliance rules and checks. Tools: InSpec, Chef Compliance, OpenSCAP.
Configuration Management Configuration management automates the setup and maintenance of system configurations, ensuring consistency across environments. Tools: Ansible, Puppet, Chef.
Disaster Recovery Planning Disaster recovery planning involves creating strategies and procedures for recovering systems and data in case of unexpected failures or disasters. Strategies: Backup and Restore, Multi-region Deployments, Cloud Endure.
Secret Management Secret management securely stores and manages sensitive information such as passwords and API keys, preventing exposure and unauthorized access. Tools: HashiCorp Vault, AWS Secrets Manager, Azure Key Vault.
Git Workflow A Git workflow defines how code changes are managed, reviewed, and integrated into a codebase, ensuring a structured and collaborative development process. Workflows: Gitflow, GitHub Flow, GitLab Flow.
Change Management Change management controls and manages changes to the IT environment, ensuring that modifications are planned, approved, and communicated effectively. Strategies: ITIL Change Management, Version Control Systems.
Test Automation Test automation involves automating the execution of tests to ensure code quality and catch defects early in the development process. Tools: Selenium, JUnit, TestNG.
Continuous Testing Continuous testing integrates testing practices throughout the CI/CD pipeline, ensuring that each code change undergoes automated tests before deployment. Tools: Jenkins, GitLab CI/CD, Travis CI.
Shift-Left Testing Shift-left testing involves moving testing activities earlier in the development process, identifying and fixing issues during the initial stages of development. Tools: SonarQube, Snyk, Checkmarx.
Code Review Code review is a collaborative process where developers assess each other’s code changes, ensuring code quality, best practices, and knowledge sharing. Tools: GitHub, GitLab, Bitbucket.
Infrastructure Monitoring Infrastructure monitoring focuses on tracking and analyzing the performance and health of servers, networks, and other infrastructure components. Tools: Nagios, Prometheus, Datadog.
Git Hooks Git hooks are scripts triggered by Git events, allowing custom actions to be performed at different stages of the version control workflow. Tools: Git, Husky, Overcommit.
Server Configuration Management Server configuration management automates the provisioning and maintenance of server configurations, ensuring consistency and reducing manual effort. Tools: Ansible, Puppet, Chef.
Dependency Management Dependency management tracks and controls external libraries and components used in a project, ensuring consistent and secure dependencies. Tools: Maven, Gradle, npm.
Technical Debt Technical debt represents the cost of delaying necessary work, often resulting from shortcuts or compromises made during the development process. Strategies: Refactoring, Regular Code Reviews, SonarQube.
Release Management Release management oversees the planning, scheduling, and coordination of software releases, ensuring a smooth and controlled deployment process. Tools: Spinnaker, AWS CodePipeline, Octopus Deploy.
Observability Tools Observability tools help monitor and gain insights into system performance, including metrics, logs, and traces, for effective troubleshooting. Tools: Prometheus, Grafana, ELK Stack.
Policy as Code Policy as code translates compliance and security policies into code, automating checks and ensuring adherence to organizational standards. Tools: Open Policy Agent (OPA), Conftest, Kyverno.
Rolling Updates Rolling updates gradually replace instances of an application with new ones, ensuring continuous availability and allowing easy rollback if issues arise. Strategies: Kubernetes Rolling Updates, AWS Elastic Beanstalk, Spinnaker.
Multicloud Strategy A multicloud strategy involves using services from multiple cloud providers, reducing dependency on a single provider and enhancing flexibility. Strategies: Kubernetes Multi-Cluster Management, Terraform, Anthos.
API Gateway An API gateway manages and secures API traffic, handling tasks such as authentication, authorization, and rate limiting for microservices. Tools: Kong, Apigee, AWS API Gateway.
Infrastructure Resilience Infrastructure resilience ensures that systems can withstand and recover from failures, incorporating redundancy and failover mechanisms. Strategies: Load Balancing, High Availability Architectures, Chaos Engineering.
Build Automation Build automation automates the process of compiling source code into executable artifacts, ensuring consistency and efficiency in the build process. Tools: Jenkins, Maven, Gradle.
ITIL (Information Technology Infrastructure Library) ITIL is a set of practices for IT service management, providing guidance on aligning IT services with business needs. Strategies: ITIL Framework, ServiceNow, Jira Service Management.
Risk Management Risk management involves identifying, assessing, and mitigating potential risks that may impact the success of a project or the stability of a system. Strategies: Risk Assessment Matrix, Risk Register, Monte Carlo Simulation.
User Acceptance Testing (UAT) UAT is a testing phase where end-users evaluate the software to ensure it meets their requirements and is ready for production deployment. Strategies: Manual Testing, Automated Testing, TestRail.
Test-Driven Development (TDD) TDD involves writing tests before implementing the corresponding code, ensuring that code meets the specified requirements and reducing defects. Strategies: JUnit, NUnit, Pytest.