Merge pull request #66 from appscode-cloud/lic

Modify/rephrase license docs

Author: ArnobKumarSaha

src/en/guides/license-management/contract.md

@@ -18,12 +18,7 @@ section_menu: guides
 
 ## Contract
 
-Contracts are the foundational element of the AppsCode licensing system. They encapsulate the agreement between AppsCode and the customer regarding the use of AppsCode products.
-
-A contract in the AppsCode Billing Console is a digital record, generally established and maintained by AppsCode administrators, that specifies the licensing 
-terms for one or more AppsCode products. It dictates which products can be used, for how long, by whom (typically an organization or user), and under what conditions.
-
-It basically forms a digital agreement of the licensing relationship between AppsCode and its customers. Each contract represents a formal agreement for the use of 
+A contract is basically a digital agreement of the licensing relationship between AppsCode and its customers. Each contract represents a formal agreement for the use of 
 specific AppsCode products, such as KubeDB or platform-enterprise, with defined validity periods and feature sets.
 
 The contract management system within the Billing Console provides comprehensive tools for creating, modifying, and monitoring contracts. Administrators can specify 
@@ -95,7 +90,7 @@ The operational mode of a contract (`online` or `offline`) is a critical setting
 - Designed for environments without `internet access` (air-gapped) or with highly restricted outbound connectivity.
 - When a contract is configured as `offline` by AppsCode's administrators, the `license-proxyserver` installer generated by the customer will include licenses covering the contract's entire duration.
 - These licenses do not require periodic online `validation` or `rotation`.
-- This mode offers operational autonomy for `disconnected environments`. However, any changes to the contract term or licensed products necessitate an admin updating the contract, followed by the customer generating and deploying a new offline License Proxy Server installer. **Change this line**
+- Any changes to the contract term requires the customer to generate & deploy a new offline License Proxy Server installer.
 - In offline contract you can download the license file from the contract details page. ![Download Offline License](./images/download-offline-license.png)
 
 > The Billing Console enables customers to generate the appropriate License Proxy Server installer based on the mode of their contract.

src/en/guides/license-management/license-proxyserver.md

@@ -17,8 +17,7 @@ section_menu: guides
 
 ## The License Proxy Server
 
-The `license-proxyserver` is a critical component of the AppsCode License Management System, deployed within customer Kubernetes clusters to validate and apply licenses to AppsCode products. This component acts as the local authority for AppsCode product's licensing and as an intermediary between the licensed products and the AppsCode's Central Billing Console, ensuring that all deployed AppsCode applications operate with valid licenses as per the terms defined in their associated contracts.
-
+The `license-proxyserver` is a critical component of the AppsCode License Management System, deployed within customer Kubernetes clusters to validate and apply licenses to AppsCode products. 
 ### 1. Purpose and Architecture
 
 The primary purpose of the `license-proxyserver` is to:
@@ -34,9 +33,9 @@ The primary purpose of the `license-proxyserver` is to:
 1. **AppsCode Product Request:** When an AppsCode product (e.g., KubeDB operator) starts or performs a licensed operation, it requests a license from the License Proxy Server running in its cluster.
 2. **License Proxy Server Response:**
     - **Online Mode:** If the `license-proxyserver` has a valid, cached license, it provides it immediately. If the license is nearing its expiration, has already expired, or is otherwise invalid, the `license-proxyserver` attempts to contact AppsCode `Billing Backend` to fetch a new license. This new license is based on the active contracts associated with that specific cluster.
-    - **Offline Mode:** The `license-proxyserver` primarily uses the pre-generated licenses embedded in its installer. It operates without connecting to the Billing Console for routine validation. However, if all embedded licenses are found to be expired or have been revoked, the `license-proxyserver` will, as a fallback, attempt to fetch new licenses from the AppsCode billing backend. This means that even in air-gapped environments, a temporary or controlled outbound connection might be necessary for license renewal or recovery if the embedded licenses become invalid over time. Each mode offers distinct advantages and is suitable for different operational contexts.
+    - **Offline Mode:** The `license-proxyserver` primarily uses the pre-generated licenses embedded in its installer. It operates without connecting to the Billing Console for routine validation. However, if all embedded licenses are found to be expired or have been revoked, the `license-proxyserver` will, as a fallback, attempt to fetch new licenses from the AppsCode billing backend. This means that even in air-gapped environments, a temporary or controlled outbound connection might be necessary for license renewal or recovery if the embedded licenses become invalid over time. 
    > Each mode offers distinct advantages and is suitable for different operational contexts.
-3. **Product Operation:** Based on whether a valid license is received from the `license-proxyserver`, the AppsCode product will enable or disable its functionalities accordingly. A valid license allows the product to operate with its full feature set, while an invalid or absent license may lead to reduced functionality or prevent the product from operating.
+3. **Product Operation:** A valid license allows the product to operate with its full feature set, while an invalid or absent license may lead to reduced functionality or prevent the product from operating.
 
 > This architecture ensures that licensing checks are performed locally within the cluster, minimizing latency and dependency on external services for routine operations, especially after initial license acquisition.
 
@@ -54,14 +53,12 @@ Online mode is suitable for clusters with reliable internet connectivity, allowi
 When the `Online` option is selected for installer generation in the Billing Console, the system prepares a standard `license-proxyserver` installer. ![Online Installer](./images/online-installer.png) 
 This installer is typically provided as a `Helm` commands or `YAML files`, as seen in the `Scripts` pop-up. ![Online Installer Scripts](./images/online-installer-scripts.png)
 
-The generated installer configures the license-proxyserver to communicate with the AppsCode licensing backend. Key configurations embedded in the installer include:
+The generated installer configures the license-proxyserver to communicate with the AppsCode licensing backend. The cluster where this `license-proxyserver` is installed must be `associated with one or more online contracts` in the Billing Console for successful license acquisition.
+Key configurations embedded in the installer include:
 
 - The base URL for the AppsCode licensing backend, explicitly set (e.g., `-set platform.baseURL=https://AppsCode.com`). This ensures the `license-proxyserver` knows where to connect for license validation and updates.
 - A platform token (e.g., `-set platform.token=dc823391fc8d6d9ca10f47a1ed07************`). This token is used by the `license-proxyserver` to authenticate itself with the AppsCode backend and identify which licenses it is eligible for.
 
-The Helm command provided (e.g., `helm upgrade --install license-proxyserver oci://ghcr.io/AppsCode-charts/license-proxyserver --version v2025.4.30`) specifies the Helm chart repository and a particular version, 
-along with flags for namespace creation (`--namespace kubeops --create-namespace`) and deployment behavior (`--wait --debug --burst-limit=1000`). 
-The cluster where this `license-proxyserver` is installed must be `associated with one or more online contracts` in the Billing Console for successful license acquisition.
 
 #### License Acquisition and Rotation
 
@@ -78,12 +75,7 @@ The cluster where this `license-proxyserver` is installed must be `associated wi
 
 #### Offline Mode Deployment
 
-Offline mode caters to environments that are air-gapped or have stringent restrictions on external network communications.
-
-#### Rationale for Offline Mode
-Many organizations, particularly in sectors like finance, government, or critical infrastructure, operate Kubernetes clusters in environments completely 
-disconnected from the internet for security reasons. Offline licensing ensures that AppsCode products can still be fully utilized in such scenarios without 
-compromising security policies. It provides operational autonomy once the `license-proxyserver` is deployed.
+Offline mode caters to environments that are air-gapped or have stringent restrictions on external network communications. It is ideal for sectors like finance, government, or critical infrastructure, where Kubernetes cluster environments are completely offline.
 
 #### Enabling Offline Contracts
 The prerequisite for generating an offline `license-proxyserver` installer is that the relevant contract(s) in the AppsCode Billing Console must be explicitly 
@@ -99,11 +91,11 @@ Generating an installer for offline mode is a multi-step process, designed to em
 
 #### License Characteristics in Offline Mode
 
-- **Full Duration Licenses:** The licenses embedded in the offline installer are valid for the entire duration of the selected offline contract(s). <br>For example, if an offline contract runs from `not_before: June 1, 2025`, to `not_after: May 31, 2026`, the embedded license will be valid for this `full one-year` period.
-- **No Periodic Online Rotation (Initially):** Unlike online mode, these licenses do not require periodic contact with AppsCode servers for renewal or rotation as long as they are valid. They are self-contained and remain active until the contract's specified end date.
-- **Fallback to Online Mode:** A critical aspect of `Offline Mode` is its fallback mechanism. If all embedded licenses within the `license-proxyserver` are found to be `expired`, the `license-proxyserver` will, as a fallback, attempt to fetch new licenses from the AppsCode billing backend. In this scenario, it will try to periodically fetch licenses for shorter periods, similar to how online mode operates.
-- **Self-Contained Deployment:** All necessary licensing information is deployed directly into the cluster as part of the `license-proxyserver's` configuration. The cluster can operate in a fully disconnected state post-installation, provided the embedded licenses are valid.
-- **Updates Require New Installer:** When an offline contract is extended by [AppsCode administrators](https://AppsCode.com/contact) and the customer wishes to update the embedded license to reflect this extended duration, a new offline `license-proxyserver` installer bundle must be generated from the Billing Console. This new bundle then needs to be `upgraded` or `re-installed` on the cluster by the customer. Similarly, if the embedded licenses expire and the `license-proxyserver` switches to online mode, the customer should generate a fresh offline installer and upgrade the existing `Helm release` to `re-embed` the `long-lived` licenses, thereby restoring full offline functionality.
+- **Full Duration Licenses:** Offline licenses are valid for the entire contract term, e.g., June 1, 2025, to May 31, 2026.
+- **No Periodic Online Rotation (Initially):** Self-contained licenses don’t need AppsCode server contact until expiration.
+- **Fallback to Online Mode:** Expired offline licenses trigger the license-proxyserver to fetch new licenses online, mimicking online mode.
+- **Self-Contained Deployment:** Licensing data is embedded in the license-proxyserver, allowing disconnected operation while licenses are valid.
+- **Updates Require New Installer:** Contract extensions or expired licenses require a new installer from the Billing Console, which must be upgraded or reinstalled to maintain or restore offline functionality.
 
 
 ### 3. Verifying Product License Status

src/en/guides/license-management/overview.md

@@ -23,11 +23,9 @@ section_menu: guides
 
 ## Overview <br>
 
-The AppsCode License Management System provides a comprehensive solution for managing AppsCode's product licenses across customer Kubernetes deployments. This system enables efficient license administration through a centralized billing console while ensuring secure license validation within customer environments. Supporting both `online` and `offline` licensing modes, the system accommodates various operational requirements and network constraints.
+The AppsCode License Management System simplifies managing product licenses for Kubernetes deployments. It offers a centralized billing console for efficient license administration and secure validation, supporting both online and offline modes to suit various needs.
 
-This documentation offers a detailed guide to the AppsCode License Management System, covering its architecture, operational workflows, and best practices for license administration.
-
-In this detailed guide, we'll explore the Billing Console's functionality in depth. We'll start with an overview of its `key components`, then dive into `contract management`, explain the `license-proxyserver` deployment process, and conclude with `troubleshooting tips` for common issues. By the end, you'll have a clear, actionable understanding of how to leverage this tool to manage licenses effectively.
+This guide explores the Billing Console, covering its key components, contract management, license-proxyserver deployment, and troubleshooting tips for common issues. By the end, you’ll know how to effectively manage licenses with this tool.
 
 **Target Audience:** This guide is intended for `administrators` and `personnel` responsible for managing AppsCode's product licenses.
 
@@ -41,13 +39,10 @@ While AppsCode administrators are responsible for the core lifecycle of contract
 
 ### Key Components
 
-The Billing Console serves as the central center for AppsCode's license management ecosystem. It's a web-based platform that integrates various components to provide a seamless experience. Let's break down its key elements:
-
 - **Contracts:** Digital agreements, typically established by [AppsCode administrators](https://AppsCode.com/contact/) within the Billing Console, that define the terms of AppsCode's product (e.g., ACE, KubeDB, KubeStash, KubeVault etc.) usage. This includes the specific AppsCode products which can be licensed, the duration of the contract, applicable features, and the clusters authorized to use these licenses. Contracts ensure that usage aligns with legal and financial terms, providing a foundation for all subsequent actions in the console. Contracts can be configured for either online or offline license validation.
 <br> <br>
 - **Licensed cluster:** The `Licensed Cluster` section within the AppsCode Billing Console offers a comprehensive overview and detailed management capabilities for Kubernetes clusters that have been issued AppsCode product licenses. This component is pivotal for administrators to monitor the cluster(s) `licences` and `events` of licensed products across their infrastructure.
 <br> <br>
-- **License Proxy Server:** A lightweight component deployed within the customer's Kubernetes cluster(s). It functions as an on-premise license manager, acting as a bridge between AppsCode products running in the cluster and the central AppsCode Billing Console. Its primary function is to ensure that AppsCode products are properly licensed and remain compliant with the terms defined in the customer's contracts. It also handles license `validation` and `retrieval`, acting as a `gatekeeper` to ensure compliance. This localized validation mechanism enhances security and performance by keeping sensitive license checks within the customer's environment. 
-  <br>The AppsCode Billing Console generates installers for the `license-proxyserver`, customized based on the contract's mode (`online` or `offline`). Depending on the contract type (`online` or `offline`), it either periodically refreshes and validates licenses with AppsCode's central licensing servers or uses static preloaded licenses embedded during deployment for the full contract duration.
+- **License Proxy Server:** A lightweight in-cluster component that validates licenses, either by connecting to AppsCode servers (online) or using preloaded licenses (offline). The console generates customized installers for deployment. Depending on the contract type (`online` or `offline`), it either periodically refreshes and validates licenses with AppsCode's central licensing servers or uses static preloaded licenses embedded during deployment for the full contract duration.
 
 These components work together to provide a seamless experience for license administrators, allowing them to efficiently manage the entire licensing `lifecycle` from a single interface. For instance, AppsCode's administrator creates a contract for KubeDB, and associates the contract to the target customer. Then from the customer panel, the customer can add a cluster to it, generates a customized installer for the `license-proxyserver`, deploys it to the cluster, and then monitors usage—all within the Billing Console. This integrated workflow eliminates the need for disparate tools or manual processes, saving time and reducing errors.

src/en/guides/license-management/troubleshoots.md

@@ -16,8 +16,7 @@ section_menu: guides
 ---
 
 ## Troubleshooting License Proxy Server Issues
-When encountering issues with AppsCode product licensing, troubleshooting the license-proxyserver is a crucial first step. Since the license-proxyserver functions as an extended API server within the Kubernetes cluster, 
-the troubleshooting process involves verifying its API registration, service health, and connectivity to the AppsCode backend.
+The troubleshooting process involves verifying its API registration, service health, connectivity to the AppsCode backend etc.
 
 #### 1. Verify `APIService` Configuration
 First, confirm that the APIService for the license-proxyserver is correctly registered and available within the Kubernetes API aggregation layer.
@@ -155,8 +154,6 @@ If the `in-cluster` components of the `license-proxyserver` appear healthy, and
 
 #### 5. Conclusion
 The AppsCode License Management System delivers a `lightweight`, `in-cluster` authority for fast, reliable license validation in Kubernetes. Its `online` and `offline` modes accommodate both 
-always-connected and isolated environments. <br>
-Meanwhile, The AppsCode Billing Console serves as the centralized administrative hub, empowering customers with `self-service` capabilities for cluster association, 
-installer generation, and comprehensive monitoring of licensed clusters and their associated licenses.
+always-connected and isolated environments. It empowers customers with `self-service` capabilities for cluster association.
 
 For unresolved issues, email [support@appscode.com](mailto:support@appscode.com) or [platform-support@appscode.com](mailto:support@appscode.com), or file a ticket at [AppsCode Contact](https://appscode.com/contact).