Effortlessly deploy complex infrastructure across any cloud provider using simple YAML manifests and powerful automation.

TL;DR

ProjectPlanton is an open-source framework that simplifies the deployment of multi-cloud environments with Kubernetes-like declarative configuration. It enables you to:

• Define Configuration: Create Kubernetes-like manifests based on ProjectPlanton APIs, using simple, consistent APIs written in protobuf and published on the Buf Schema Registry to manage resources across various cloud providers. Essentially, Kubernetes manifests for multi-cloud deployments.

• Deploy Infrastructure: Utilize pre-written Pulumi modules that take your YAML configuration manifests as input and handle the complex infrastructure provisioning. Avoid the complexity of learning intricate deployments with the project-planton CLI. The CLI reads your manifest and determines the appropriate Pulumi module for deployment.

3 Steps to Get Started

brew install project-planton/tap/project-planton

apiVersion: kubernetes.project.planton/v1
kind: RedisKubernetes
metadata:
  name: payments
  id: payments-namespace
spec:
  container:
    replicas: 1
    resources:
      limits:
        cpu: 50m
        memory: 2Gi
      requests:
        cpu: 50m
        memory: 100Mi
    isPersistenceEnabled: true
    diskSize: 1Gi

project-planton pulumi up --manifest redis.yaml

How It Works

ProjectPlanton bridges the gap between Kubernetes’ declarative resource model and multi-cloud deployments by leveraging Pulumi modules and a simple CLI tool. Here’s an overview of how the system operates:

1. Declarative Manifests: Users define their desired infrastructure or application configurations in YAML manifests, following the familiar structure of Kubernetes resources with apiVersion, kind, metadata, spec, and status.

2. Protocol Buffers Definitions: These manifests correspond to API resources defined in Protocol Buffers (protobuf). The APIs are published to the Buf Schema Registry (BSR), providing accessible documentation and on-demand SDK generation in multiple languages.

3. Field Validation: Validations are embedded within the protobuf definitions using Protovalidate and Common Expression Language (CEL). This ensures that the configurations adhere to the expected formats and constraints before deployment.

4. CLI Execution: When the user runs the project-planton CLI command, the tool performs the following actions:

   • Module Retrieval: It identifies the appropriate Pulumi module repository for the specified deployment component (e.g., a Kubernetes cluster, database service, etc.).
   • Pulumi Module Execution: It clones the Pulumi module and passes the manifest and any additional configuration to it.
   • State Management: Users manage the Pulumi state backend, ensuring that state is preserved across deployments.
   • Provisioning: The Pulumi module uses the provided configurations to interact with the target cloud providers’ APIs, provisioning the resources as declared.

5. Desired State Realization: Pulumi modules act similarly to Kubernetes controllers but are triggered manually by the user. They reconcile the declared state in the manifests with the actual state in the cloud environment, ensuring that the infrastructure matches the desired specifications.

6. Status Reporting: After deployment, the status field in the manifest can be updated to reflect the current state of the resources, providing feedback to the user.

Advantages

• Consistency Across Clouds: By abstracting cloud-specific details, developers can deploy resources to any supported cloud provider using the same declarative approach.
• Modularity and Reusability: Pulumi modules are versioned and maintained in separate repositories, promoting reuse and ease of updates.
• Transparency and Control: Unlike automated controllers, users have explicit control over when deployments occur, allowing for better planning and coordination.

Compare

FAQ