Introduction

What is Tensegrity?

Tensegrity is Kubernetes controller and set of CRDs that allows to create Kubernetes native workloads such as Deployments, StatefulSets and DaemonSets with dependencies between them by defining produced and consumed configuration keys and values. Tensegrity watches for those key and value changes, and reconciles workloads if necessary to apply the new configuration.

In addition, Tensegrity allows to specify delegates to consume keys and values from other Namespaces to build more complex development and deployment scenarios.

Features

• Automated Resource Synchronization - Tensegrity ensures that changes to ConfigMaps or Secrets are automatically propagated across all relevant Kubernetes clusters, preventing inconsistencies and reducing the risk of configuration drift.
• Declarative Configuration Management - By using a declarative approach, Tensegrity allows you to define your desired resource states, ensuring that Kubernetes environments continuously match the intended configuration without manual intervention.
• Version Tracking and Rollbacks - It can keep track of different versions of your ConfigMaps and Secrets, making it easier to roll back to a known-good state if a new configuration introduces issues.
• Security and Compliance Integration - With centralized management of Secrets, Tensegrity enhances security controls. It can help ensure that sensitive data is properly encrypted, rotated, and tracked, aligning with compliance standards.
• Multi-Cluster Consistency - Whether you run a single Kubernetes cluster or multiple clusters across various environments, Tensegrity provides a unified way to enforce and maintain consistent configurations at scale.
• Reduced Operational Overhead - By eliminating the need for manual updates, Tensegrity streamlines workflows, saving valuable engineering time and reducing the likelihood of human error in complex deployments.
• Scalability and Resilience - As environments grow, Tensegrity’s architecture supports scaling without sacrificing performance or reliability, ensuring that even large and dynamic deployments remain stable and manageable.

Target Audience and Use Cases

Tensegrity is ideal for:

• Developers: Streamlining configuration management in Kubernetes.
• DevOps Teams: Managing secure and scalable deployments.
• Enterprises: Handling multi-cluster environments with high compliance requirements.

Concepts and Architecture

Producers and Consumers Model

Tensegrity introduces the Producers and Consumers model to manage dependencies:

• Producers: Generate configurations or secrets (e.g., microservices, operators, databases).
• Consumers: Utilize these configurations or secrets (e.g., clusters, namespaces, services).

Core Components

• Controller: Monitors changes and reconciles dependent resources.
• CRDs: Define custom resources to manage dependencies declaratively.
• Webhooks: Validate resource configurations and maintain system integrity.

Real-Time Reconciliation Process

Tensegrity continuously monitors Kubernetes resources for changes. When a change is detected, it triggers an automated reconciliation process to update dependent resources and maintain consistency across the dependency tree.

Sneak peak

apiVersion: k8s.tensegrity.fastforge.io/v1alpha1
kind: Deployment
metadata:
  name: api
spec:
  # native K8s Deployment spec here in addition to...
  delegates:
    # resolves in order production > staging > user-alice
    - kind: Namespace
      name: production
    - kind: Namespace
      name: staging
    - kind: Namespace
      name: user-alice
  consumes:
    # the Deployment consumes keys/values from postgres StatefulSet and maps them to env variables
    - apiVersion: k8s.tensegrity.fastforge.io/v1alpha1
      kind: deployment
      name: postgres
      maps:
        DATABASE_HOST: host
        DATABASE_PORT: port
    # the Deployment consumes keys/values from redis Deployment and maps them to env variables
    - apiVersion: k8s.tensegrity.fastforge.io/v1alpha1
      kind: Deployment
      name: redis
      maps:
        REDIS_HOST: host
        REDIS_PORT: port
  produces:
    # the Deployment produces its own host and port keys from related Ingress and Service
    - key: host
      apiVersion: networking.k8s.io/v1
      kind: Ingress
      fieldPath: '{ .spec.rules[0].host }.{ .metadata.namespace }'
    - key: port
      apiVersion: v1
      kind: Service
      fieldPath: '{ .spec.ports[?(@.name=="http")].port }'

Get the code

You can get started with running Tensegrity as your Kubernetes configmap/secrets manager simply deploying it with the following documentation:

Or contact us for a Demo.