DOCSEARCHbyAlgolia
Submit Docs

Plural Documentation

website·Indexed 35 days ago

https://docs.plural.sh

Documentation for Plural, featuring a REST API for managing continuous delivery (CD) clusters, pipelines, global services, and git repositories, as well as AI agent sessions, runtimes, and SCM catalog and pull request automation.

Tokens
58.6K
Snippets
250
Records
421
Agent score
62%

What's inside Plural

  1. Overview of Flow Preview Environments

    Preview environments in Plural create a near-clone of a development environment using the code from a feature branch for the duration of a pull request. This pattern provides three primary benefits:

    1. Stability: Reduces churn in the main development environment.
    2. Isolation: Allows testing of code changes in isolation from other in-flight changes.
    3. Data Integrity: Reduces development data corruption, especially when combined with database forking for testing schema migrations.

    Plural implements this natively via GitOps patterns, a built-in webhook/event system for tracking PR updates, and secure SCM credential management for GitHub/GitLab feedback.

  2. Overview of SCM Webhooks and PR Linking in Plural

    Plural uses SCM (Source Control Management) webhooks to monitor pull request events. When a pull request is linked to a Plural Flow, Plural automatically creates vector embeddings of the code changes. These embeddings enable semantic search and AI-assisted analysis to identify potential root causes when alerts fire. Access to the vector index is governed by Flow permissions to maintain security boundaries.

  3. Overview of Plural Cloud managed hosting

    Plural Cloud is a hybrid deployment model where Plural manages the control plane (including database and high availability), while the user registers their own Kubernetes clusters in their cloud for remote operation.

    Key architectural features include:

    • Security: Plural manages infrastructure in the user's cloud without storing cloud keys on Plural servers, utilizing agents in management or leaf clusters and cloud IAM solutions like EKS IRSA or GKE Workload Identity.
    • Tenancy Modes:
      • Shared: Hosted on shared k8s clusters and postgres servers for lower cost.
      • Dedicated: Dedicated k8s cluster and database for maximum scalability and full data isolation.
    • Built-in Integrations: Includes preconfigured log aggregation (Elasticsearch/Logstash), scale-out Prometheus (vmetrics agent), a working AI endpoint, and a GitHub App integration for PR generation and SCM tasks.

  4. Overview of Flow MCP Server integration

    Plural Flows integrate with the Model Context Protocol (MCP), allowing Flow chats to call MCP servers via tool-calling to automate operational tasks. This enables developers to implement ops tasks (e.g., managing payment plans), explore databases (e.g., via Postgres MCP), query external data (e.g., JIRA/ServiceNow), or create a secure developer admin panel. Plural enhances the base MCP protocol with audit logging, confirmation workflows for tool-calls, JWT-based authentication, and granular access permissions.

  5. Overview of Plural Custom Stacks

    Custom stacks allow developers to define proprietary command workflows instead of using standard patterns (like Terraform or Ansible). This is useful for implementing GitOps workflows for CLI-based Kubernetes provisioners (e.g., k3s, gkectl), scaling in-house provisioner scripts via the Plural Console UI, or automating bulk scripting based on declarative configurations.

  6. Overview of Automating Workbench Follow-up

    Follow-up automation allows a workbench associated with a pull request to verify changes after they have been merged, built, and deployed. This enables the workbench to inspect the live system and infrastructure state to report or fix issues that only become visible post-deployment.

  7. Overview of Kubernetes Upgrade Insights

    Upgrade Insights allows Plural to integrate with cloud provider Kubernetes upgrade intelligence and add-on ecosystems (specifically EKS). The Plural operator scrapes these endpoints to provide a unified dashboard for upgrade-relevant information, aggregating provider-specific data with Plural's own intelligence to identify latent risks for future upgrades without needing to switch between cloud accounts or regions.

  8. Overview of Plural Kubernetes Fleet Management

    Plural is a unified cloud orchestrator designed for managing Kubernetes at scale. It addresses fleet management through four primary functional areas:

    1. Kubernetes Continuous Deployment: A GitOps-based mechanism with drift detection to sync manifests (Helm, Kustomize, raw YAML) into clusters, orchestrable via API.
    2. Kubernetes Dashboarding: A secure, SSO-integrated read-path for ad-hoc troubleshooting.
    3. Infrastructure-As-Code (IaC) Management: Managed via 'Stacks', providing a Kubernetes-native, API-driven way to handle Terraform complexity.
    4. Self-Service Code Generation: A PR Automation API and UI wizard that allows users to generate manifests for the above workflows (similar to Backstage for Kubernetes).

  9. Overview of workbench job automation mechanisms

    Plural workbenches support three primary ways to automate job execution:

    • Cron schedules: Run a specific prompt on a recurring time-based schedule.
    • Webhook triggers: Execute a job when an observability alert or issue tracker event matches a pattern (e.g., triggering when a user writes Plural fix this on a ticket or PR).
    • Post-merge follow-ups: Trigger a workbench associated with a merged pull request to verify the reconciled system state.

    Cron schedules and webhook triggers are managed via the overflow menu (•••) on the workbench, while follow-up prompts are configured within source control or CI automation.

  10. Overview of the Plural embedded Kubernetes dashboard

    Plural provides an embedded Kubernetes dashboard within the console that simplifies cluster management by removing the need for manual kubeconfig management or VPNs. It leverages OIDC for authentication and uses the same unidirectional egress networking as Plural agents, allowing visibility into private and on-prem clusters.

  11. Overview of Plural AI infrastructure automation

    Plural AI is an AI engine designed to reduce manual infrastructure management tasks. It provides a set of capabilities to automate troubleshooting and coding tasks within enterprise environments. Key differentiators include:

    • Bring-Your-Own-LLM: Integration with enterprise-approved LLMs to avoid man-in-the-middle concerns.
    • Self-Hostability: Support for self-hosting to maintain data sovereignty and ensure data is not used for model training.
    • Always-on Troubleshooting Engine: Automatically monitors signals from failed Kubernetes services and Terraform runs to perform investigative processes and summarize results.
    • Remote Coding Agents on K8s: Ability to run parallelizable coding agents via API on existing Kubernetes infrastructure, with Plural managing scheduling and developer experience.

  12. Overview of Plural Policy Enforcement

    Plural allows platform and security teams to encode enterprise guardrails using Rego (Open Policy Agent). Policies are evaluated alongside built-in RBAC and approval controls to add organization-specific authorization.

    Key capabilities include:

    • Allowing or denying workbench tool calls based on actor, tool, and arguments.
    • Automatically approving known-safe workbench operations.
    • Approving or rejecting stack runs based on infrastructure plan contents.
    • Applying policies consistently across matching workbenches or stacks.
    • Testing policy changes against live evaluation inputs.

    Important Constraint: Policies only add constraints or automate existing approval steps; they cannot grant access that an actor or workbench does not already possess via Plural RBAC and tool permissions.