Skip to content

Core Concepts

Keptn integrates seamlessly with cloud-native deployment tools such as ArgoCD, Flux, and Gitlab to bring application awareness to your Kubernetes cluster. Keptn supplements the standard deployment tools with features to help you ensure that your deployments are in a healthy state.

For information about the history of the Keptn project, see the Keptn Lifecycle Toolkit is now Keptn! blog.

Keptn includes multiple features that can be implemented independently or together. It targets three main use cases: Metrics, Observability, and Release lifecycle management.


The Keptn metrics feature extends the functionality of Kubernetes metrics:

  • Allows you to define metrics from multiple data sources in your Kubernetes cluster.

  • Supports deployment tools like Argo, Flux, KEDA, HPA, or Keptn for automated decision-making based on observability data.

  • Handles observability data from multiple instances of multiple observability solutions – Prometheus, Thanos, Cortex, Dynatrace, Datadog and others – as well as data that comes directly from your cloud provider such as AWS, Google, or Azure.

  • Enhances the Kubernetes Horizontal Pod Autoscaling facility.

The Keptn metrics server unifies and standardizes access to data from various sources, simplifying configuration and integration into a single set of metrics.

To learn more, see:


Keptn ensures observability for Kubernetes deployments by creating a comprehensive trace of all Kubernetes activities within a deployment. Keptn observability makes it easy to understand deployment durations and failures across multiple deployment strategies.

  • Provides observability data for standard Kubernetes workload resources as well as KeptnApp resources (which connect logically related workloads) using different deployment strategies.

  • Captures DORA metrics and exposes them as OpenTelemetry metrics out of the box.

  • Uses OpenTelemetry to report traces and custom Keptn metrics from all data providers that are configured in your cluster.

  • Enables monitoring of new logs from log monitoring solutions.

  • Information can be displayed on standard dashboard tools like Grafana.

Keptn is tool- and vendor neutral and does not depend on particular tooling. Keptn emits signals at every stage (Kubernetes events, CloudEvents, and OpenTelemetry metrics and traces) to ensure that your deployments are observable.

To learn more, see:

Release lifecycle management

The Release lifecycle management tools run in conjunction with the standard Kubernetes deployment tools to make deployments more robust. Keptn "wraps" a standard Kubernetes deployment with the capability to automatically handle issues before and after the actual deployment.

These tools run checks and tasks before or after deployment initiation.

  • Pre-deployment tasks such as checking for dependent services, image scanning, and setting the cluster to be ready for the deployment.

  • Pre-deployment evaluations such as checking whether the cluster has enough resources for the deployment.

  • Post-deployment tasks such as triggering tests, triggering a deployment to another cluster, or sending notifications that the deployment succeeded or failed.

  • Post-deployment evaluations to evaluate the deployment, evaluate test results, or confirm software health against SLOs like performance and user experience.

  • Promotion tasks such as promoting the application to another stage.

All KeptnTask resources that are defined by KeptnTaskDefinition resources at the same level (pre-deployment, post-deployment, or promotion) run in parallel. Task sequences that are not part of the lifecycle workflow should be handled by the pipeline engine tools rather than Keptn. A KeptnTask resource can be defined to run multiple executables (functions, programs, and scripts) that are part of the lifecycle workflow. The executables within a KeptnTask resource run in sequential order.

Keptn tasks and evaluations can be run for either a Kubernetes workload (single service) resource or a KeptnApp resource, which is a single, cohesive unit that groups multiple workloads. For more information, see: