Merge branch 'main' of github.com:sizzldev/ctrlplane into browswer-en…

…v-fix

apps/docs/pages/deployments.mdx

@@ -2,85 +2,65 @@ import { Callout } from "nextra/components";
 
 # Deployments
 
-Deployments are the heart of Ctrlplane. They represent the process of delivering
-your software or application to various environments and targets.
-Deployments encapsulate the configuration, workflows, and triggers necessary to
-automate and manage the entire release process.
+Deployments are the core component of Ctrlplane, orchestrating the delivery of
+your applications across various environments and targets. They encapsulate the
+configuration, workflows, and triggers required to automate and manage the
+entire release lifecycle.
 
 ## Key Components
 
-A deployment in Ctrlplane typically consists of the following elements:
-
-- **System:** The high-level category or grouping to which the deployment
-  belongs (e.g., "E-commerce," "Backend Services").
-- **Release:** The specific version or build of your software to be deployed.
-- **Environments:** The different stages or phases of the deployment pipeline
-  (e.g., "QA," "Staging," "Production").
-- **Targets:** The specific destinations where your software will be
-  deployed (e.g., Kubernetes clusters, server groups, cloud functions).
-- **Workflows:** The automated tasks and actions performed during the deployment
-  process (e.g., running tests, deploying code, sending notifications).
-- **Job Agents:** The integrations responsible for triggering your existing
-  pipelines in external systems (e.g., GitHub Actions, GitLab CI/CD, Jenkins).
-- **Policies (Optional):** Rules and constraints that govern the deployment
-  process, such as requiring approvals or enforcing automated checks.
+A Ctrlplane deployment consists of:
+
+- **System:** High-level categorization (e.g., "Microservices," "Data Pipeline")
+- **Release:** Specific version or build to be deployed
+- **Environments:** Deployment stages (e.g., "Dev," "Staging," "Prod")
+- **Targets:** Deployment destinations (e.g., K8s clusters, VM groups, FaaS)
+- **Workflows:** Automated tasks executed during deployment
+- **Job Agents:** Integrations triggering external CI/CD pipelines
+- **Policies (Optional):** Rules governing the deployment process
 
 ## Deployment Process
 
-The typical deployment process in Ctrlplane involves the following steps:
-
-- **Create a New Release:** You create a new release of your software,
-  specifying the version or build number.
-- **Trigger Workflows:** Ctrlplane automatically triggers the workflows
-  associated with the relevant environments for that release.
-- **Job Agent Activation:** The configured job agents for each deployment are
-  activated, sending triggers to your external pipelines.
-- **Pipeline Execution:** Your existing pipelines in GitHub, GitLab, Jenkins, or
-  other systems execute the necessary steps to deploy your software to the
-  targeted environments and targets.
-- **Deployment Status Tracking:** Ctrlplane tracks the status of each
-  deployment, providing you with visibility into the progress and success of
-  your releases.
+1. **Release Creation:** Initiate a new release with version/build number
+2. **Workflow Triggering:** Automatic activation of environment-specific workflows
+3. **Job Agent Activation:** Triggers sent to external CI/CD systems
+4. **Pipeline Execution:** External systems deploy to specified targets
+5. **Status Tracking:** Real-time monitoring of deployment progress
 
 <Callout type="info">
-  Its common to have multiple targets a single application may deploy too. It is
-  best practice to have a single deployment with a pipeline that supports
-  deploying to these different systems.
+  Best practice: Use a single deployment with a pipeline supporting multiple
+  targets, rather than separate deployments for each target.
 </Callout>
 
-## Benefits of Deployments in Ctrlplane
-
-- **Automation:** Automates the entire deployment process, reducing manual
-  effort and potential for errors.
-- **Flexibility:** Supports various deployment strategies, from simple linear
-  pipelines to complex multi-stage workflows.
-- **Integration:** Seamlessly integrates with your existing CI/CD tools and
-  processes.
-- **Visibility:** Provides real-time visibility into the status and progress of
-  your deployments.
-- **Control:** Allows you to enforce policies and approvals to ensure compliance
-  and mitigate risks.
-
-## Example
-
-### Deploying a Web Application
-
-You have a web application with three environments (Dev, Staging, Production)
-and multiple targets (Kubernetes clusters in different regions). You
-create a deployment in Ctrlplane for this application, associating it with the
-correct system, environments, and targets. You also configure job agents to
-trigger your GitHub Actions workflows for each environment. When you create a
-new release, Ctrlplane automatically triggers the deployment process, deploying
-your application to the Dev environment first, then to Staging after approval,
-and finally to Production.
-
-## Key Points
-
-- Deployments are the core building block for automating your release process in
-  Ctrlplane.
-- Deployments encompass releases, environments, targets, workflows,
-  and job agents.
-- Ctrlplane complements your existing CI/CD tools, providing a centralized
-  platform for managing deployments across different systems and environments.
-- By leveraging deployments in Ctrlplane, you can achieve a streamlined,
-  efficient, and reliable deployment process.
+## Key Benefits
+
+- **Automation:** Minimizes manual intervention and error potential
+- **Flexibility:** Supports various deployment strategies and complexities
+- **Integration:** Seamless connection with existing CI/CD toolchains
+- **Visibility:** Real-time deployment status and progress tracking
+- **Control:** Policy enforcement and approval workflows
+
+## Example: Microservices Deployment
+
+Consider a microservices architecture with environments (Dev, Staging, Prod) and
+multiple regional Kubernetes clusters. Configure a Ctrlplane deployment with:
+
+1. System: "Microservices Platform"
+2. Environments: Dev, Staging, Prod
+3. Targets: Regional K8s clusters
+4. Job Agents: Configured for GitLab CI/CD
+5. Policies: Require approvals for Staging and Prod
+
+When creating a release, Ctrlplane orchestrates:
+
+1. Dev deployment via GitLab CI/CD
+2. Staging deployment after approval
+3. Production rollout across regions
+
+## Key Takeaways
+
+- Deployments centralize release management across diverse environments and
+  systems
+- Ctrlplane complements existing CI/CD tools, providing higher-level
+  orchestration
+- Achieve streamlined, efficient, and reliable deployment processes at scale

apps/docs/pages/environments.mdx

@@ -1,56 +1,40 @@
 # Environments
 
-In Ctrlplane, an environment serves as a logical grouping of targets.
-Think of environments as distinct stages or phases within your software release
-process. Common examples include:
-
-- **QA (Quality Assurance):** An environment dedicated to thorough testing and
-  validation before broader deployment.
-- **Staging:** A pre-production environment that closely mirrors your live
-  system for final checks and performance tuning.
-- **Production:** Your live environment where the application is accessible to
-  end users.
-
-By organizing your targets into environments, you gain several
-benefits:
-
-- **Clear Separation:** You can clearly delineate which targets
-  belong to which stage of your pipeline.
-- **Version Control:** You can easily manage different versions of your software
-  in different environments, allowing for gradual rollouts and controlled
-  validation.
-- **Policy Enforcement:** You can apply specific policies and approvals to
-  transitions between environments, ensuring compliance and minimizing risk.
+In Ctrlplane, environments are logical groupings of targets, essential for
+structuring your CI/CD pipeline. Common examples:
+
+- **QA**: For thorough testing and validation
+- **Staging**: Pre-production environment mirroring production
+- **Production**: Live environment for end-users
+
+Benefits:
+
+- Clear separation of deployment stages
+- Efficient version management across environments
+- Granular policy enforcement for environment transitions
 
 ## Environment Policies
 
-Environments in Ctrlplane support Environment Policies. These policies provide
-configurable settings to govern how deployments move from one environment to the
-next. Environment Policies help you:
-
-- **Enforce Approvals:** Require manual approval before promoting a deployment
-  to a higher environment (e.g., from Staging to Production).
-- **Define Time Windows:** Restrict deployments to specific time periods (e.g.,
-  only during off-peak hours).
-- **Set Deployment Limits:** Cap the number of concurrent deployments or the
-  total number of deployments within a given timeframe.
-- **Semver/Regex Validation:** Validate the version of the software being
-  deployed against a regular expression or semantic versioning (Semver) pattern.
-
-## Assigning Targets to Environments
-
-Targets are added to environments using labels. You define labels on
-your targets, and your environment configuration includes filters
-that match those labels. When a new target is registered, Ctrlplane
-automatically checks if its labels match any environment filters. If so, the
-target is automatically added to the corresponding environment, and
-any associated workflows are triggered.
-
-## Key Points
-
-- Environments provide logical structure and control over your deployment
-  pipeline.
-- Environment Policies enhance governance and security by defining rules for
-  transitions.
-- Labels offer a flexible way to dynamically associate targets with
-  environments.
+Configurable settings to control inter-environment deployments:
+
+- **Approval Workflows**: Implement manual gates (e.g., Staging to Production)
+- **Deployment Windows**: Schedule deployments for specific timeframes
+- **Rate Limiting**: Set concurrent deployment limits or caps within time
+  periods
+- **Version Validation**: Use regex or Semver patterns to validate deployment
+  versions
+
+## Target-Environment Association
+
+Targets are dynamically assigned to environments using a label-based system:
+
+1. Define labels on targets
+2. Set up environment filters to match these labels
+3. Upon registration, targets are automatically added to matching environments
+4. Associated workflows trigger automatically
+
+## Key Takeaways
+
+- Environments provide structured control over the deployment pipeline
+- Policies enhance governance and security for environment transitions
+- Label-based system allows flexible, dynamic target-environment associations

apps/docs/pages/index.mdx

@@ -12,36 +12,39 @@ import {
   TbVariable,
 } from "react-icons/tb";
 
-# Introduction
-
-The Ultimate Continuous Deployment Solution.
-
-## What is Ctrl Plane?
-
-Ctrlplane is a flexible and powerful deployment orchestration platform designed
-to streamline and automate your software release process. It complements your
-existing CI/CD tools by providing centralized management, automated triggers,
-and seamless integrations.
-
-## Why Ctrlplane?
-
-Modern software development often involves complex, multi-stage deployment
-pipelines that span across diverse environments and platforms. Managing these
-pipelines manually can quickly become overwhelming, leading to errors,
-inconsistencies, and delays. Ctrlplane addresses these challenges by providing
-a centralized platform to orchestrate, automate, and streamline your entire
-deployment process.
-
-- **Multiple Environments:** If your application needs to be deployed across
-  development, testing, staging, and production environments, Ctrlplane
-  simplifies the management of these environments and the transitions between
-  them.
-- **Diverse Targets:** Whether you're deploying to Kubernetes
-  clusters, cloud functions, virtual machines, or custom infrastructure,
-  Ctrlplane allows you to manage all your targets from a single platform.
-- **Sophisticated Workflows:** If your deployment process involves multiple
-  steps like testing, code analysis, security scanning, and approvals, Ctrlplane
-  helps you orchestrate these workflows with ease.
-- **Integration with CI/CD Tools:** Ctrlplane integrates seamlessly with popular
-  CI/CD tools like Jenkins, GitLab CI, and GitHub Actions, allowing you to
-  trigger deployments automatically based on your existing pipelines.
+# Ctrlplane: Advanced Deployment Orchestration
+
+Empowering DevOps with Seamless Continuous Deployment
+
+## Overview
+
+Ctrlplane is a robust deployment orchestration platform engineered to enhance
+your existing CI/CD pipeline. It provides centralized management, automated
+triggers, and deep integrations to streamline complex release processes.
+
+## Key Features for DevOps
+
+- **Unified Control:** Centralize management of multi-stage deployment pipelines
+  across diverse environments.
+- **Flexible Target Support:** Deploy to Kubernetes, cloud functions, VMs, or
+  custom infrastructure from a single platform.
+- **Advanced Workflow Orchestration:** Automate sophisticated deployment
+  processes including testing, code analysis, security scans, and approval
+  gates.
+- **CI/CD Integration:** Seamlessly connects with Jenkins, GitLab CI, GitHub
+  Actions, and other popular CI tools to trigger deployments.
+- **Environment Management:** Efficiently handle transitions between dev, test,
+  staging, and production environments.
+
+## Benefits for DevOps Teams
+
+- **Reduced Complexity:** Simplify management of intricate, multi-environment
+  deployment pipelines.
+- **Increased Reliability:** Minimize manual errors and inconsistencies through
+  automation.
+- **Enhanced Visibility:** Gain a comprehensive view of your entire deployment
+  landscape.
+- **Faster Time-to-Market:** Accelerate release cycles with streamlined
+  processes and automated workflows.
+- **Scalability:** Easily adapt to growing infrastructure and evolving
+  deployment needs.

apps/docs/pages/requirements.mdx

@@ -35,5 +35,5 @@ data.
 <Callout type="warning">
   Do not make direct changes to the database, schemas, users, or other
   properties except when following procedures in the Ctrlplane documentation or
-  following the directions of Ctrlplane Support or other GitLab engineers.
+  following the directions of Ctrlplane Support or other Ctrlplane engineers.
 </Callout>