DOCSEARCHbyAlgolia
Submit Docs

PipeCD Documentation

repository·master·Indexed 23 days ago

https://github.com/pipe-cd/pipecd

A GitOps-style continuous delivery platform providing a unified, multi-cloud deployment experience for various application types without requiring changes to application manifests. The documentation covers the Control Plane, the Piped agent, local development prerequisites (Go, NodeJS, Docker, kind, helm), and OIDC authentication setup using Keycloak.

Tokens
435.9K
Snippets
851
Records
2K
Agent score
74%

What's inside PipeCD

  1. Overview of the Kubernetes Multicluster Plugin

    master

    The Kubernetes Multicluster plugin allows you to deploy applications across multiple Kubernetes clusters using a single pipeline definition. It manages sync state, traffic routing, and rollbacks across all target clusters simultaneously.

    Note: This plugin is currently in alpha status.

    It supports two primary sync modes:

    1. Quick sync: Applies manifests to all target clusters immediately. This occurs if no pipeline is specified in the application configuration or if the sync is triggered manually with the quick sync option.
    2. Pipeline sync: Enables progressive deployment across clusters using stages like canary rollouts, traffic routing, and baseline comparisons.

  2. Overview of the Docsy theme for Hugo

    master

    Docsy is a theme for the Hugo static site generator designed specifically for technical documentation sets. It provides built-in best practices for managing large documentation projects, including support for tutorials, reference documentation, blog posts, and community pages.

    Key Characteristics:

    • Built on Hugo: Docsy does not generate HTML files itself; it provides the theme files that Hugo uses to transform Markdown or HTML source files into a static site.
    • Target Audience: It is best suited for medium to large documentation sets (typically 20+ pages) with complex navigation needs.
    • Not a Hosting Service: Docsy does not provide source hosting or site deployment. You must manage your source files (e.g., on GitHub, GitLab) and deploy the resulting static site to a provider like Netlify.
    • Customization: Users can customize site layouts, blocks, and templates to suit their specific documentation needs.

  3. Overview of PipeCD

    master

    PipeCD is a GitOps-style continuous delivery platform designed for multi-cloud environments. It provides a unified solution for deploying various application types (e.g., Kubernetes, Terraform, GCP Cloud Run, AWS Lambda, AWS ECS) using a consistent deployment and operations experience.

    Key features include:

    • GitOps Workflow: Enables deployment operations via pull requests on Git.
    • Unified Interface: Use the same deployment interface across different platforms.
    • No Manifest Changes: Does not require changes to Custom Resource Definitions (CRDs) or application manifests; only a pipeline definition is needed.
    • Secure: Deployment credentials are not exposed outside the application cluster.
    • Built-in Analysis: Includes deployment analysis to measure impact using metrics, logs, and emitted requests.
    • CI Integration: Works alongside any CI tool; CI handles builds and tests, while PipeCD manages the deployment lifecycle.
    • Delivery Insights: Provides metrics such as lead time, deployment frequency, MTTR (Mean Time To Recovery), and change failure rate.

  4. Overview of the Kubernetes plugin

    master

    The Kubernetes plugin enables PipeCD to manage deployments to Kubernetes clusters. It supports both 'Quick sync' (direct application of manifests) and 'Pipeline sync' (progressive deployment strategies like canary or blue-green).

    Deployment Modes:

    • Quick sync: Triggered if no pipeline is specified in the application configuration, or if a PR only changes non-workload/non-config resources (e.g., scaling replicas). It applies all defined manifests directly.
    • Pipeline sync: Enables progressive deployment by managing three variants of an application:
      • primary: The current stable version.
      • baseline: A fresh instance of the current stable version (used to isolate metrics from long-running process effects).
      • canary: The proposed new version of code or configuration.
    CAUTION

    This plugin is currently in alpha status.

  5. What is PipeCD?

    master

    PipeCD is a GitOps-style continuous delivery solution designed for multi-cloud environments. It provides a unified interface to deploy various application kinds (such as Kubernetes, Terraform, GCP Cloud Run, AWS Lambda, and AWS ECS) by using pull requests on Git to trigger deployment operations.

    Key architectural benefits include:

    • Decoupled CI/CD: CI tools handle testing and artifact building, while PipeCD manages the deployment lifecycle.
    • No Manifest Changes: Deployment logic is defined in a separate pipeline definition, meaning application manifests and CRDs do not need to be modified to support PipeCD.
    • Security: Credentials are not stored in the Control Plane and are not exposed outside the application cluster. The Piped component makes only outbound requests, allowing it to run in restricted networks.

  6. Overview of Docsy Hugo Theme

    master

    Docsy is a pre-configured Hugo theme designed specifically for creating technical documentation sites. It provides the structural and UI components necessary for documentation, such as optimized page layouts, autogenerated navigation, and language switchers, allowing authors to focus on Markdown or HTML content.

    Key features include:

    • Optimized Layouts: Specialized designs for navigation, page menus, headers, landing pages, and blog snippets.
    • Autogenerated Navigation: Menus are automatically updated based on your folder structure.
    • Multi-language Support: Leverages Hugo's built-in capabilities for internationalization.
    • Custom Shortcodes: Reusable HTML snippets for alerts, image boxes, and landing page blocks.
    • Built-in Integrations: Support for GitHub (for feedback/PR links), Google Analytics, Google Custom Search, Algolia DocSearch, and Lunr (local search).

  7. PipeCD web directory structure

    master

    The web repository follows this organizational structure:

    • src/__fixtures__: Dummy models for testing/mocking.
    • src/api: API clients.
    • src/components: Shared UI components. Each component typically has its own sub-directory containing its sub-components, index.tsx, tests, and stories.
    • src/constants: Shared constants.
    • src/hooks: Shared React hooks.
    • src/mocks: API mock files (used with msw).
    • src/queries: React Query modules, organized by module name, containing query-hook.ts and mutation-hook.ts.
    • src/styles: Shared styles.
    • src/types: Application TypeScript definitions.
    • src/utils: Utility functions.
    src
├── __fixtures__ # dummy models
├── api # API clients
├── components # shared components
│  └── comp-name
│     ├── comp-name # component's components
│     ├── index.tsx
│     ├── index.test.ts
│     └── index.stories.ts
├── constants # shared constants
├── hooks # shared hooks
├── mocks # API mock files
│  └── services
├── queries # react query modules
│  └── module-name
│     ├── query-hook.ts # use query hook
│     └── mutation-hook.ts # use mutation hook
├── styles # shared styles
├── types # application types
└── utils # utils files

  8. Locate PipeCD documentation files

    master

    PipeCD documentation is stored within the /docs folder of the repository. Content files are written in Markdown and are located in /docs/content/en/.

    There are two primary directory structures for documentation:

    • /docs-dev/: Contains documentation for unreleased or in-development features.
    • /docs-v0.x.x/ (or /docs-v1.0.x/): Contains documentation for specific released versions of PipeCD.

    Note: When fixing issues in current documentation, you should typically update files in both the /docs-dev/ and the latest /docs-vx.y.z/ folders to ensure both upcoming and current versions are accurate.

  9. Monitor delivery performance with PipeCD Insights

    master

    PipeCD provides an Insights page that visualizes delivery performance metrics based on executed deployment data. These metrics help you understand the performance of a single application or an entire project.

    Available metrics include:

    • Lead Time for Changes: The duration from code commit to code successfully running in production.
    • Deployment Frequency: How often code is deployed to production for an application or project.
    • Mean Time To Restore: The average time taken to restore service when a service incident occurs.
    • Change Failure Rate: The frequency of deployment failures in production that require immediate remedy (such as a fix or rollback).

  10. Supported platforms and templating methods

    master

    PipeCD supports a variety of platforms and Kubernetes templating methods:

    Supported Platforms

    • Kubernetes
    • ECS (AWS)
    • Terraform
    • CloudRun (GCP)
    • Lambda (AWS)
    • Future support planned for Crossplane

    Kubernetes Templating Methods

    • Helm
    • Kustomize

    Service Mesh Support

    • Supports both mesh applications (e.g., Istio, SMI) and non-mesh applications.

  11. Develop piped plugins using the Go SDK

    master

    The piped-plugin-sdk-go repository provides the SDK required to develop plugins for PipeCD using the Go programming language.

    Important Note on Contributions: This repository is a mirror and is automatically synced from the pkg/plugin/sdk directory in the main pipe-cd/pipecd repository. To contribute code, submit pull requests to pipe-cd/pipecd rather than this repository. For issues, feature requests, or questions, use the issue tracker at pipe-cd/pipecd/issues.

  12. Supported platforms and templating methods in PipeCD

    master

    PipeCD supports a variety of platform providers and Kubernetes templating methods:

    Supported Platforms/Providers:

    • Kubernetes
    • ECS (AWS)
    • Terraform
    • CloudRun (GCP)
    • Lambda (AWS)
    • Future support planned for Crossplane

    Kubernetes Templating Methods:

    • Helm
    • Kustomize

    Service Mesh Support:

    • Supports both mesh applications (e.g., Istio, SMI) and non-mesh applications.