KCL

https://www.kcl-lang.io/docs/user_docs/guides/
Admin
KCL is a cloud-native programmable language for configuration management, validation, and...
Tokens:58,610
Snippets:722
Trust Score:7.4
Update:2 months ago
Show doc for...
Tokens:
Raw
### Clone Example Repository

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/helmfile-kcl-plugin

Clone the example repository to get started with the Helmfile KCL plugin.

```bash
git clone https://github.com/kcl-lang/helmfile-kcl.git  
cd ./helmfile-kcl/examples/hello-world/  
```

--------------------------------

### Clone Example Repository

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/helm-kcl-plugin

Clone the Helm KCL plugin example repository to get started.

```bash
git clone https://github.com/kcl-lang/helm-kcl.git/  
cd ./helm-kcl/examples/workload-charts-with-kcl  
```

--------------------------------

### Clone GitOps Example Repository

Source: https://www.kcl-lang.io/docs/user_docs/guides/gitops/gitops-quick-start

Clone the example repository to get started with GitOps configurations.

```bash
git clone https://github.com/kcl-lang/kcl-lang.io.git/  
cd ./kcl-lang.io/examples/gitops  
```

--------------------------------

### Clone KPT KCL SDK Example

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/kpt-kcl-sdk

Clone the example repository to get started with the KPT KCL SDK. This sets up the necessary files for the annotation example.

```bash
git clone https://github.com/kcl-lang/kpt-kcl-sdk.git/  
cd ./kpt-kcl-sdk/get-started/set-annotation  
```

--------------------------------

### Clone Kustomize KCL Example

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/kustomize-kcl-plugin

Clone the example repository to get started with Kustomize KCL functions.

```bash
git clone https://github.com/kcl-lang/kustomize-kcl.git  
cd ./kustomize-kcl/examples/set-annotation/  
```

--------------------------------

### Clone KCL Abstraction Example

Source: https://www.kcl-lang.io/docs/user_docs/guides/abstraction

Clone the KCL abstraction example repository to get started. This sets up the necessary files for demonstrating abstraction.

```bash
git clone https://github.com/kcl-lang/kcl-lang.io.git/  
cd ./kcl-lang.io/examples/abstraction  
```

--------------------------------

### Clone and Navigate to KCL Examples

Source: https://www.kcl-lang.io/docs/user_docs/guides/schema-definition

Commands to retrieve the KCL example repository and enter the definition directory.

```bash
git clone https://github.com/kcl-lang/kcl-lang.io.git/  
cd ./kcl-lang.io/examples/definition  
```

--------------------------------

### Clone KCL Examples Repository

Source: https://www.kcl-lang.io/docs/user_docs/guides/automation

Get the example code for automation by cloning the KCL language repository.

```bash
git clone https://github.com/kcl-lang/kcl-lang.io.git/  
cd ./kcl-lang.io/examples/automation  
```

--------------------------------

### Clone Example Repository

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/kubectl-kcl-plugin

Clone the kubectl-kcl repository to access example configurations.

```bash
git clone https://github.com/kcl-lang/kubectl-kcl.git/  
cd ./kubectl-kcl/examples/  
```

--------------------------------

### Clone KCL Examples Repository

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/adapt-from-kubernetes

Clone the KCL language examples repository to access Kubernetes-related examples.

```bash
git clone https://github.com/kcl-lang/kcl-lang.io.git/  
cd ./kcl-lang.io/examples/kubernetes/from-kubernetes  
```

--------------------------------

### Clone KCL Examples Repository

Source: https://www.kcl-lang.io/docs/user_docs/guides/data-integration

Clone the KCL language examples repository to access data integration examples.

```bash
git clone https://github.com/kcl-lang/kcl-lang.io.git/  
cd ./kcl-lang.io/examples/data-integration  
```

--------------------------------

### Clone KCL Examples Repository

Source: https://www.kcl-lang.io/docs/user_docs/guides/configuration

Clone the KCL language examples repository to access configuration-related files.

```bash
git clone https://github.com/kcl-lang/kcl-lang.io.git/  
cd ./kcl-lang.io/examples/configuration  
```

--------------------------------

### Display Example Configuration

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/kubectl-kcl-plugin

View the content of the kcl-run-oci.yaml file, which includes Kubernetes resources and a KCLRun configuration.

```bash
cat ./kcl-run-oci.yaml  
```

--------------------------------

### Display KCL Configuration

Source: https://www.kcl-lang.io/docs/user_docs/guides/gitops/gitops-quick-start

View the KCL configuration file for the example application.

```bash
cat config/main.k  
```

--------------------------------

### Clone Example Repository

Source: https://www.kcl-lang.io/docs/user_docs/guides/secret-management/vault

Clone the KCL examples repository to access the Vault integration code.

```bash
git clone https://github.com/kcl-lang/kcl-lang.io.git/  
cd ./kcl-lang.io/examples/secret-management/vault  
```

--------------------------------

### Start KCL Server

Source: https://www.kcl-lang.io/docs/user_docs/guides/automation

Initiate the KCL language server to enable API interactions.

```bash
kcl server  
```

--------------------------------

### Clone Example Repository

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-terraform/validation

Clone the KCL language IO repository to access the Terraform validation examples.

```bash
git clone https://github.com/kcl-lang/kcl-lang.io.git/  
cd ./kcl-lang.io/examples/terraform/validation  

```

--------------------------------

### Install ArgoCD

Source: https://www.kcl-lang.io/docs/user_docs/guides/gitops/gitops-quick-start

Install ArgoCD controllers into the Kubernetes cluster using kubectl.

```bash
kubectl create namespace argocd  
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml  
```

--------------------------------

### Start Vault Server and Set Environment Variables

Source: https://www.kcl-lang.io/docs/user_docs/guides/secret-management/vault

Start a development Vault server and configure the necessary environment variables for Vault address and token.

```bash
vault server -dev  
export VAULT_ADDR='http://127.0.0.1:8200'  
# Note: Replace with your token  
export VAULT_TOKEN=yourtoken  
```

--------------------------------

### Clone KCL Validation Example

Source: https://www.kcl-lang.io/docs/user_docs/guides/validation

Clone the KCL language repository to access validation examples. Navigate to the validation directory within the examples.

```bash
git clone https://github.com/kcl-lang/kcl-lang.io.git/  
cd ./kcl-lang.io/examples/validation  
```

--------------------------------

### Example Deployment Result

Source: https://www.kcl-lang.io/docs/user_docs/guides/gitops/gitops-with-fluxcd

Shows a successful deployment result indicating that the flask-demo application is running.

```text
NAME         READY   UP-TO-DATE   AVAILABLE   AGE  
flask-demo   1/1     1            1           17d  

```

--------------------------------

### Initialize Helmfile

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/helmfile-kcl-plugin

Initialize the helmfile tool before applying configurations. This may prompt for plugin installation.

```bash
helmfile init  
```

--------------------------------

### Clone Flask Demo Application

Source: https://www.kcl-lang.io/docs/user_docs/guides/ci-integration/github-actions

Clone the example Flask application repository to get the source code.

```bash
git clone https://github.com/kcl-lang/flask-demo.git/ 
cd flask-demo  

```

--------------------------------

### Display Validation Example Configuration

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/kubectl-kcl-plugin

Show the configuration for the kcl-vet-oci-err.yaml file, which includes a KCLRun for validation and an Ingress resource.

```bash
cat ./kcl-vet-oci-err.yaml  
```

--------------------------------

### KCL Configuration Instance

Source: https://www.kcl-lang.io/docs/user_docs/guides/schema-definition

An example of a KCL configuration file importing a module and defining an app instance.

```kcl
import .app_module  # A relative path import  
  
app: app_module.App {  
    domainType = "Standard"  
    containerPort = 80  
    volumes = [  
        {  
            mountPath = "/tmp"  
        }  
    ]  
    services = [  
        {  
            clusterIP = "None"  
            $type = "ClusterIP"  
        }  
    ]  
}  
```

--------------------------------

### Clone Flask Demo Application

Source: https://www.kcl-lang.io/docs/user_docs/guides/ci-integration/gitlab-ci

Clone the example Flask application repository to begin.

```bash
git clone https://gitlab.com/kcl-lang/flask-demo.git/ 
cd flask-demo  

```

--------------------------------

### KCL File Structure

Source: https://www.kcl-lang.io/docs/user_docs/guides/schema-definition

The directory layout for the modular KCL example.

```text
.  
├── app_module.k  
└── main.k  
```

--------------------------------

### Install KCL CLI

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-kubevela

Installs the KCL (Kubernetes Configuration Language) command-line interface. KCL is used for writing and managing configurations.

```bash
curl -fsSL https://kcl-lang.io/script/install-cli.sh | /bin/bash  

```

--------------------------------

### Execute KCL and Get Configuration

Source: https://www.kcl-lang.io/docs/user_docs/guides/automation

Run KCL on the main configuration file to see the resolved output.

```bash
kcl main.k  
```

--------------------------------

### Install KubeVela CLI

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-kubevela

Installs the KubeVela command-line interface using a script. This tool is used to manage KubeVela applications.

```bash
curl -fsSl https://kubevela.net/script/install.sh | bash  

```

--------------------------------

### Install KubeVela Core

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-kubevela

Installs the core components of KubeVela into the Kubernetes cluster. This command enables KubeVela's application delivery capabilities.

```bash
vela install  

```

--------------------------------

### Service Manifest Example

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/helm-kcl-plugin

An example Kubernetes Service manifest generated by the Helm KCL Plugin.

```yaml
apiVersion: v1
kind: Service
metadata:
  labels:
    app.kubernetes.io/instance: workload
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: workload
    app.kubernetes.io/version: 0.1.0
    helm.sh/chart: workload-0.1.0
  name: workload
spec:
  ports:
    - name: www
      port: 80
      protocol: TCP
      targetPort: 80
  selector:
    app.kubernetes.io/instance: workload
    app.kubernetes.io/name: workload
  type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app.kubernetes.io/instance: workload
    app.kubernetes.io/managed-by: Helm
    app.kubernetes.io/name: workload
    app.kubernetes.io/version: 0.1.0
    helm.sh/chart: workload-0.1.0
  name: workload
  annotations:
    managed-by: helm-kcl-plugin
spec:
  selector:
    matchLabels:
      app.kubernetes.io/instance: workload
      app.kubernetes.io/name: workload
  template:
    metadata:
      labels:
        app.kubernetes.io/instance: workload
        app.kubernetes.io/name: workload
    spec:
      containers:
        - image: nginx:alpine
          name: frontend  
```

--------------------------------

### KCL Code Example: Returning KRM List

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/kubectl-kcl-plugin

Demonstrates returning a KRM list for output resources in KCL.

```kcl
# Return a KRM list for output resources.
```

--------------------------------

### Irrelevant Order Calculation Example

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Demonstrates how KCL calculates values based on dependencies, similar to a topological sort, making declaration order irrelevant. No setup is required.

```kcl
schema Fib:
    n1: int = n - 1  # Refers to the attribute `n` declared after `n1`
    n2: int = n1 - 1
    n: int
    value: int = 1 if n <= 2 else Fib {n = n1}.value + Fib {n = n2}.value

fib8 = Fib {n = 8}.value

```

```kcl
fib8: 21

```

--------------------------------

### KCL Package and Module Import Example

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-konfig/practice

Shows how to define functions in a KCL package (`utils.k`) and import them into another file (`main.k`) for use.

```kcl
# utils.k

# Define a function that adds two numbers and returns the result。
add = lambda x, y {
    x + y
}

# Define a function that subs two numbers and returns the result。
sub = lambda x, y {
    x - y
}

```

```kcl
# main.k
import .utils

# Call the function, pass in arguments, and obtain the return value. 
result = utils.sub(utils.add(2, 3), 2)  # The result is 3.

```

--------------------------------

### KCL Code Example: Reading Environment Variables

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/kubectl-kcl-plugin

Demonstrates how to read general environment variables within KCL code.

```kcl
option("env")
```

--------------------------------

### Example Kubernetes Deployment YAML

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/generate-k8s-manifests

A sample Kubernetes Deployment manifest illustrating common fields and potential pitfalls like incorrect types or missing fields.

```yaml
apiVersion: apps/v1
kind: Deployment
metadata: ... # Omit
spec:
  selector:
    matchlabels:
      cell: RZ00A
  replicas: 2
  template:
    metadata: ... # Omit
    spec:
      tolerations:
      - effect: NoSchedules
        key: is-over-quota
        operator: Equal
        value: 'true'
      containers:
      - name: test-app
          image: images.example/app:v1 # Wrong ident
        resources:
          limits:
            cpu: 2 # Wrong type. The type of cpu should be str
            memory: 4Gi
            # Field missing: ephemeral-storage
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: is-over-quota
                operator: In
                values:
                - 'true'

```

--------------------------------

### KCL Code Example: Reading PATH Variables

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/kubectl-kcl-plugin

Shows how to read PATH environment variables within KCL code.

```kcl
option("PATH")
```

--------------------------------

### Create Kubernetes Cluster with K3d

Source: https://www.kcl-lang.io/docs/user_docs/guides/gitops/gitops-with-fluxcd

Installs K3d to create a default Kubernetes cluster for testing GitOps configurations.

```bash
k3d cluster create mycluster  

```

--------------------------------

### KCL CLI Path Selector Example

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Demonstrates selecting values from a KCL model using the `-S` parameter. The model is defined in `pkg/model.k` and `main.k`.

```kcl
.  
├── kcl.mod  
└── main.k  
    └── pkg  
        └── model.k  

```

```kcl
schema Person:
    name: str
    age: int

var = Person {
    name = "Alice"
    age = 18
}

```

```kcl
import pkg

var = pkg.Person {
    name = "Bob"
    age = 10
}

```

```bash
kcl main.k -S var

```

```text
name: Alice
age: 18

```

--------------------------------

### Schema Inheritance Example

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Demonstrates basic schema inheritance where a derived schema reuses attributes from a base schema.

```kcl
# A person has a first name, a last name and an age.
schema Person:
    firstName: str
    lastName: str
    # The default value of age is 0
    age: int = 0

```

--------------------------------

### Create Kubernetes Cluster

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-kubevela

Creates a Kubernetes cluster using k3d. This is a prerequisite for installing KubeVela.

```bash
k3d cluster create  

```

--------------------------------

### Get Schema Instances

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Illustrates using the built-in `instances()` member method of a schema to retrieve a list of all existing instances of that schema within the main package. The `full_pkg` argument can be used to retrieve all instances across the entire program.

```KCL
schema Person:
    name: str
    age: int

alice = Person {
    name = "Alice"
    age = 18
}

bob = Person {
    name = "Bob"
    age = 10
}

aliceAndBob = Person.instances()  # Person is a schema type, instances() is its member method

```

--------------------------------

### Integer Literals

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Examples of defining integer literals in various bases (decimal, hexadecimal, octal, binary) and using the int constructor.

```kcl
a = 1  
b = -1  
c = 0x10 # hexadecimal literal  
d = 0o10 # octal literal  
e = 010  # octal literal  
f = 0b10 # binary literal  
g = int("10") # int constructor  
```

--------------------------------

### String Built-in Functions and Members

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Provides examples of common string operations like length, case conversion, searching, splitting, and joining.

```kcl
x = "length"
assert len(x) == 6 # True
assert x.capitalize() == "Length"
assert x.count("gt") == 1
assert x.endswith("th") == True
assert x.find("gth") == 3
assert "{} {}".format("hello", "world") == 'hello world'
assert x.index("gth") == 3
assert x.isalnum() == True
assert x.isalpha() == True
assert "123456".isdigit() == True
assert x.islower() == True
assert "       ".isspace() == True
assert "This Is Title Example".istitle() == True
assert x.isupper() == False
assert "|".join(["a", "b", "c"]) == "a|b|c"
assert "LENGTH".lower() == "length"
assert '   spacious   '.lstrip() == 'spacious   '
assert x.replace("th", "ht") == "lenght"
assert "lengthlength".rfind("le") == 6
assert "lengthlength".rindex("le") == 6
assert "length length".rsplit() == ["length", "length"]
assert "length   ".rstrip() == "length"
assert "length length".split() == ["length", "length"]
assert 'ab c\n\nde fg\rkl\r\n'.splitlines() == ['ab c', '', 'de fg', 'kl']
assert "length".startswith('len') == True
assert "***length***".strip('*') == "length"
assert "length length".title() == "Length Length"
assert x.upper() == "LENGTH"
```

--------------------------------

### Get External Data with 'option' Function (Simple)

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Illustrates fetching external data using the 'option' function to define a schema and filter data based on provided inputs. Useful for dynamic configuration.

```kcl
schema Day:
    day: str
    homework: str

days: [Day] = option("days")

rule Main:
    filter d in days {
        d.day not in ["saturday", "sunday"] and d.homework
    }

Main()

```

--------------------------------

### KCL Bitwise and Shift Operators

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Provides examples of bitwise AND (&), AND NOT (& ~), OR (|), XOR (^), left shift (<<), and right shift (>>) operators in KCL.

```kcl
value = 0x22
bitmask = 0x0f

assert (value & bitmask) == 0x02
assert (value & ~bitmask) == 0x20
assert (value | bitmask) == 0x2f
assert (value ^ bitmask) == 0x2d
assert (value << 4) == 0x220
assert (value >> 4) == 0x02
```

--------------------------------

### KCL Application Configuration Example

Source: https://www.kcl-lang.io/docs/user_docs/guides/gitops/gitops-quick-start

This KCL code defines an application configuration, specifying container image, ports, and service details.

```kcl
import .app  
  
config = app.App {  
    name = "kcl-guestbook-ui"  
    containers.guestbook = {  
        image = "gcr.io/heptio-images/ks-guestbook-demo:0.2"  
        ports = [{containerPort = 80}]  
    }  
    service.ports = [{ port = 80 }]  
    service.type = "LoadBalancer"  
}  


```

--------------------------------

### Convert CRD YAML to KCL Schema and Project Setup

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/adapt-from-kubernetes

Convert a CRD YAML to KCL Schema and initialize a KCL project, adding the CRD models as a dependency.

```bash
# Convert the CRD YAML to KCL Schema  
kcl import -m crd -s -f crd.yaml  
# Init a new KCL project.  
rm -rf kcl.mod && kcl mod init  
# Add the crd models dependency  
kcl mod add ./models --rename crd  
```

--------------------------------

### KCL Package Repository Structure

Source: https://www.kcl-lang.io/docs/user_docs/guides/package-management/how-to/push_github_action

Example file structure for a KCL package repository, including the GitHub Actions workflow file.

```yaml
├── .github  
│   └── workflows  
│       └── push.yaml # github action workflow  
├── LICENSE  
├── README.md  
├── kcl.mod # kcl.mod to define your kcl package  
├── kcl.mod.lock # kcl.mod.lock generated by the kcl package management tool  
└── main.k # Your KCL program  

```

--------------------------------

### Install KCL Operator

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/kcl-operator

Apply the KCL Operator configuration to your Kubernetes cluster. Use `kubectl get po` to watch and wait for the pods to be in a Running state.

```bash
kubectl apply -f https://raw.githubusercontent.com/kcl-lang/kcl-operator/main/config/all.yaml  

```

```bash
kubectl get po  

```

--------------------------------

### Passing Dynamic Parameters via YAML Configuration

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/generate-k8s-manifests

Define dynamic parameters in a kcl.yaml file for simplified input. This example sets the 'env' parameter to 'prod' using a YAML configuration.

```yaml
kcl_options:  
  - key: env  
    value: prod  


```

--------------------------------

### Schema Inheritance Example

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Demonstrates how a schema can inherit from a base schema, adding or modifying properties. Optional attributes in the base schema can be optional or required in the sub-schema, while required attributes in the base schema must remain required.

```KCL
schema Person:
    bankCard?: int
    nationality: str

schema Employee(Person):
    bankCard: int  # Valid, both `bankCard: int` and `bankCard?: int` are allowed
    nationality?: str  # Error, only `nationality: str` is allowed

```

--------------------------------

### Using Imported Kubernetes Modules

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/generate-k8s-manifests

Write KCL code to define a Kubernetes Deployment by importing and utilizing the 'k8s' module. This example creates an Nginx deployment.

```kcl
# Import and use the contents of the external dependency 'k8s'.  
import k8s.api.apps.v1 as apps  
  
apps.Deployment {  
    metadata.name = "nginx-deployment"  
    metadata.labels.app = "nginx"  
    spec: {  
        replicas = 3  
        selector.matchLabels = metadata.labels  
        template: {  
            metadata.labels = metadata.labels  
            spec.containers = [{  
                name = metadata.labels.app  
                image = "nginx:1.14.2"  
                ports: [{  
                    containerPort = 80  
                }]  
            }]  
        }  
    }  
}  


```

--------------------------------

### Sidecar Configuration Example

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-konfig/practice

Illustrates the separation of user-facing configuration and downstream processing logic for a sidecar service. The user defines 'user_sidecar_feature_gates', which is then used in the 'sidecars' list to configure individual sidecar instances.

```kcl
# Config user interface.  
user_sidecar_feature_gates: str  

# Downstream config of processing.  
sidecars = [  
    {  
        name = "sidecar_name"  # Additional template for sidecars parameters, users do not need to configure them.  
        feature_gates = user_sidecar_feature_gates  
    }  
]  

```

--------------------------------

### Schema Instantiation without Parameters

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Demonstrates three ways to instantiate a schema when no configuration parameters are provided.

```kcl
schema Data:
    id: int = 1

data1 = Data {}
data2 = Data() {}
data3 = Data()

```

--------------------------------

### Schema Inheriting from Protocol (Error Example)

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Demonstrates an error case where a schema attempts to inherit from a protocol directly, which is not allowed. Protocols are intended for mixin definitions.

```kcl
protocol DataProtocol:
    data: str

schema Data for DataProtocol:  # Error: only schema mixin can inherit from protocol
    x: str = data

```

--------------------------------

### GitHub Actions Workflow for KCL Package Push

Source: https://www.kcl-lang.io/docs/user_docs/guides/package-management/how-to/push_github_action

A GitHub Actions workflow that checks out code, installs KCL CLI, logs into an OCI registry, and pushes the KCL package.

```yaml
name: KPM Push Workflow  
  
on:  
  push:  
    branches:  
      - main  
  
jobs:  
  build:  
    runs-on: ubuntu-latest  
    steps:  
      - name: Checkout  
        uses: actions/checkout@v2  
  
      - name: Set up Go 1.21  
        uses: actions/setup-go@v2  
        with:  
          go-version: 1.21  
  
      - name: Install KCL CLI  
        run: go install kcl-lang.io/cli/cmd/kcl@latest  
  
      - name: Login and Push  
        env:  
          KPM_REG: ${{ secrets.REG }}  
          KPM_REPO: ${{ secrets.REG_ACCOUNT }}  
        run: kcl registry login -u ${{ secrets.REG_ACCOUNT }} -p ${{ secrets.REG_TOKEN }} ${{ secrets.REG }} && kcl mod push  
  
      - name: Run kcl project from oci registry  
        run: kcl run oci://${{ secrets.REG }}/${{ secrets.REG_ACCOUNT }}/catalog --tag 0.0.1  

```

--------------------------------

### Defining a Schema with Optional Attributes

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Demonstrates how to define a schema 'Employee' with a required 'bankCard' attribute and an optional 'nationality' attribute. Shows an example of creating an instance and the validation rules for required and optional attributes.

```kcl
schema Employee:
    bankCard: int  # bankCard is a required attribute, and it can NOT be None or Undefined
    nationality?: str  # nationality is an optional attribute, and it can be None or Undefined

employee = Employee {
    bankCard = None  # Error, attribute 'bankCard' of Employee is required and can't be None or Undefined
    nationality = None  # Ok
}
```

--------------------------------

### KCL Code Example: Reading Items

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/kubectl-kcl-plugin

Example of how to read resources from `option("items")` within KCL code, which conforms to the KRM Functions Specification.

```kcl
option("items")
```

--------------------------------

### Install Crossplane KCL Function

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/crossplane-kcl-function

Installs the KCL Function using a Crossplane Function object. This creates a function pod that Crossplane will use to process requests for resource creation.

```yaml
apiVersion: pkg.crossplane.io/v1beta1
kind: Function
metadata:
  name: kcl-function
spec:
  package: xpkg.upbound.io/crossplane-contrib/function-kcl:latest

```

--------------------------------

### KCL Vet Error Message Example

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-terraform/validation

This is an example of the error message output by `kcl vet` when a policy check fails. It indicates the specific line in the policy file and the reason for the failure.

```text
Error: EvaluationError
  --> main.policy.failure.k:13:1
   |
13 |         } if type == "aws_autoscaling_group", "Disable AWS autoscaling group resource create action for the resource ${type} ${name}"
   |  Check failed on the condition: Disable AWS autoscaling group resource create action for the resource aws_autoscaling_group my_asg
   |

```

--------------------------------

### KCL CLI Variable Override - Update Example

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Shows how to update existing variables in a KCL model using the `-O` parameter. The example modifies the `name` and `age` attributes of the `person` schema.

```kcl
schema Person:
    name: str
    age: int

person = Person {
    name = "Alice"
    age = 18
}

```

```bash
kcl main.k -O :person.name="Bob" -O :person.age=10

```

```text
person:
  name: Bob
  age: 10

```

--------------------------------

### Clone Repository and Run KCL

Source: https://www.kcl-lang.io/docs/user_docs/guides/ci-integration/github-actions

Clone the KCL manifest repository, navigate into it, pull the latest changes, and run the KCL command to generate deployment manifests.

```bash
git clone https://github.com/kcl-lang/flask-demo-kcl-manifests.git/  
cd flask-demo-kcl-manifests  
git checkout main && git pull && kcl  

```

--------------------------------

### Define and Call Rules Using Inheritance

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Shows how to define rules and then use inheritance to combine them into a main rule. This is effective for building complex rules from simpler, reusable components.

```kcl
weather = "sunny"
day = "wednesday"

rule IsSunny:
    weather == "sunny"

rule IsWednesday:
    day == "wednesday"

rule Main(IsSunny, IsWednesday):
    id == 1

Main()

```

--------------------------------

### Initialize a New KCL Package

Source: https://www.kcl-lang.io/docs/user_docs/guides/package-management/quick-start

Use `kcl mod init` to create a new KCL package and `cd` into its directory. This command sets up the basic configuration files for your project.

```bash
kcl mod init my_package && cd my_package  
```

--------------------------------

### Initialize and Push KCL Package to Default OCI Registry

Source: https://www.kcl-lang.io/docs/user_docs/guides/package-management/how-to/kpm_oci

Create a new KCL package, navigate into its directory, and then push it to the default OCI registry. This involves initializing the package and then performing the push operation.

```bash
# Create a new kcl package.  
kcl mod init <package_name>  
# Enter the root directory of the kcl package  
cd <package_name>  
# Upload the kcl package to an oci registry  
kcl mod push  
```

```bash
kcl mod init MyPkg
cd MyPkg
kcl mod push
```

--------------------------------

### Clone Konfig Repository

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-konfig/guide

Clone the Konfig repository to your local machine to access example configurations and tools.

```bash
git clone https://github.com/kcl-lang/konfig.git && cd konfig
```

--------------------------------

### Initialize KCL Package in Existing Directory

Source: https://www.kcl-lang.io/docs/user_docs/guides/package-management/how-to/share_your_pkg_docker

Converts an existing directory containing KCL files into a KCL package by creating kcl.mod and kcl.mod.lock files.

```bash
kcl mod init  

```

--------------------------------

### Float Literals

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Examples of defining float literals, including scientific notation and using the float constructor.

```kcl
a = 1.10  
b = 1.0  
c = -35.59  
d = 32.3e+18  
f = -90.  
h = 70.2E-12  
i = float("112") # float constructor  
```

--------------------------------

### Valid KCL Identifiers

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Examples of valid identifiers in KCL, including letters, numbers, underscores, and the '$' prefix.

```kcl
x  
a  
b1  
b_2  
_c  
$if  
```

--------------------------------

### Adding Kubernetes Modules from Registry

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/generate-k8s-manifests

Initialize a KCL module and add Kubernetes API definitions from the registry. This command fetches modules for all supported Kubernetes versions.

```bash
kcl mod init my-module && cd my-module  
kcl mod add k8s  

```

--------------------------------

### Initialize a New KCL Package

Source: https://www.kcl-lang.io/docs/user_docs/guides/package-management/how-to/share_your_pkg_docker

Creates a new KCL package named 'my_package', including the necessary kcl.mod and kcl.mod.lock files.

```bash
kcl mod init my_package  

```

--------------------------------

### Quantifier Expressions: All and Any

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Shows how to use 'all' and 'any' quantifier expressions to check conditions across collection elements.

```kcl
schema Config:
    volumes: [{str:}]
    services: [{str:}]

    check:
        all service in services {
            service.clusterIP == "NONE" if service.type == "ClusterIP"
        }, "invalid cluster ip"

        any volume in volumes {
            volume.mountPath in ["/home/admin", "/home/myapp"]
        }

```

--------------------------------

### Generate Terraform Plan JSON

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-terraform/validation

Initialize Terraform, create a plan file, and show the plan in JSON format.

```bash
terraform init  
terraform plan --out tfplan.binary  
terraform show -json tfplan.binary > tfplan.json  

```

--------------------------------

### KCL Logic Simplification with Configuration Map

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-konfig/practice

Demonstrates simplifying conditional logic in KCL by using a configuration map to determine a value based on a key, with a default fallback.

```kcl
# Complex Logic, `_cpu` is a non-exported and mutable attribute.  
_cpu = 256  
_priority = "1"  

if _priority == "1":  
    _cpu = 256  
elif _priority == "2":  
    _cpu = 512  
elif _priority == "3":  
    _cpu = 1024  
else:  
    _cpu = 2048  

# Simplify Logic Expression using Config  
cpuMap = {  
    "1" = 256  
    "2" = 512  
    "3" = 1024  
}
# Get cpu from the cpuMap, when not found, use the default value 2048.  
cpu = cpuMap[_priority] or 2048  

```

--------------------------------

### Log in to Docker.io

Source: https://www.kcl-lang.io/docs/user_docs/guides/package-management/how-to/share_your_pkg_docker

Logs into your Docker.io registry using your username and an access token. Replace <USERNAME> and <TOKEN> with your actual credentials.

```bash
kcl registry login -u <USERNAME> -p <TOKEN> docker.io  

```

--------------------------------

### Initialize KCL package in an existing directory

Source: https://www.kcl-lang.io/docs/user_docs/guides/package-management/how-to/share_your_pkg

Converts an existing directory containing KCL files into a KCL package by creating kcl.mod and kcl.mod.lock files.

```bash
# In the exist_kcl_package directory  
pwd  
/home/user/exist_kcl_package  
  
# Run the `kcl mod init` command to create the `kcl.mod` and `kcl.mod.lock` files  
kcl mod init  
```

--------------------------------

### Retrieve ArgoCD Initial Admin Password

Source: https://www.kcl-lang.io/docs/user_docs/guides/gitops/gitops-quick-start

Get the initial admin password for the ArgoCD web UI from the Kubernetes secret.

```bash
kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d  
```

--------------------------------

### Schema Definition with Docstring

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Define a schema with a detailed docstring explaining its attributes and providing examples. Use triple-quoted strings for documentation.

```kcl
schema Server:  
    """Server is the common user interface for long-running  
    services adopting the best practice of Kubernetes.  
  
    Attributes  
    ----------  
    workloadType : str, default is Deployment  
        Use this attribute to specify which kind of long-running service you want.  
        Valid values: Deployment, CafeDeployment.  
        See also: k8s/core/v1/workload_metadata.k.  
    name : str, default is None  
        A Server-level attribute.  
        The name of the long-running service.  
        See also: k8s/core/v1/metadata.k.  
    labels : {str:str}, optional, default is None  
        A Server-level attribute.  
        The labels of the long-running service.  
        See also: k8s/core/v1/metadata.k.  
  
    Examples  
    ----------------------  
    myCustomApp = AppConfiguration {  
        name = "componentName"  
    }  
    """  
    workloadType: str = "Deployment"  
    name: str  
    labels?: {str:str}  

```

--------------------------------

### KCL Code Example: Asserting Errors

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/kubectl-kcl-plugin

Illustrates how to return an error using the `assert` statement with a condition and error message in KCL.

```kcl
assert {condition}, {error_message}
```

--------------------------------

### Run Kustomize KCL Plugin

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/kustomize-kcl-plugin

Execute the Kustomize KCL plugin locally using the 'kustomize fn run' command with the --dry-run flag.

```bash
kustomize fn run ./local-resource/ --dry-run  
```

--------------------------------

### Create Kubernetes Cluster with K3d

Source: https://www.kcl-lang.io/docs/user_docs/guides/gitops/gitops-quick-start

Create a Kubernetes cluster using k3d for local development and testing.

```bash
k3d cluster create mycluster  
```

--------------------------------

### KCL CLI Variable Override - Delete Example

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Demonstrates deleting a variable attribute from a KCL model using the `-O` parameter with a hyphen.

```kcl
schema Config:
    x?: int = 1
    y?: str = "s"

config = Config {
    x = 2
}

```

```bash
kcl main.k -O config.x-

```

```text
config:
  y: s

```

--------------------------------

### Initialize a new KCL package

Source: https://www.kcl-lang.io/docs/user_docs/guides/package-management/how-to/share_your_pkg

Creates a new KCL package named 'my_package' and generates the necessary kcl.mod and kcl.mod.lock files.

```bash
# Create a new kcl package named my_package  
kcl mod init my_package  
```

--------------------------------

### Elif Statement Example

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Shows a practical use case for multiple elif conditions to assign a value based on different string inputs.

```kcl
_result = 0
if condition == "one":
    _result = 1
elif condition == "two":
    _result = 2
elif condition == "three":
    _result = 3
else:
    _result = 4

```

--------------------------------

### KCL Assignment Operators

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Lists the tokens used as assignment operators and provides an example of using compound assignment operators like `*=`, `+=`.

```kcl
_a = 2
_a *= 3
_a += 1
assert _a == 7
```

--------------------------------

### Create ArgoCD Application with KCL

Source: https://www.kcl-lang.io/docs/user_docs/guides/gitops/gitops-quick-start

Creates a new ArgoCD application named 'guestbook'. This snippet specifies the Git repository, path to configuration files, destination namespace and server, and utilizes a KCL configuration management plugin.

```bash
argocd app create guestbook \
--repo https://github.com/kcl-lang/kcl-lang.io \
--path examples/gitops/config \
--dest-namespace default \
--dest-server https://kubernetes.default.svc \
--config-management-plugin kcl-v1.0  

```

--------------------------------

### Checkout and Pull Repository, Navigate to Deploy Directory

Source: https://www.kcl-lang.io/docs/user_docs/guides/ci-integration/gitlab-ci

This command is used to update the local repository to the main branch, pull the latest changes, and navigate to the deploy directory to prepare for KCL compilation.

```bash
git checkout main && git pull && cd deploy && kcl  

```

--------------------------------

### Display KCL Configuration

Source: https://www.kcl-lang.io/docs/user_docs/guides/automation

View the content of the main KCL configuration file.

```bash
cat main.k  
```

--------------------------------

### Apply Helmfile Configuration

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/helmfile-kcl-plugin

Apply the configurations defined in helmfile.yaml, including those processed by the KCL plugin.

```bash
helmfile apply  
```

--------------------------------

### KCL Numerical Unit Type Example

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-konfig/practice

Demonstrates the use of `units.NumberMultiplier` for numerical units in KCL and shows that arithmetic operations are not allowed directly on these types.

```kcl
import units

type NumberMultiplier = units.NumberMultiplier

x0: NumberMultiplier = 1M  # Ok
x1: NumberMultiplier = x0  # Ok
x2 = x0 + x1  # Error: unsupported operand type(s) for +: 'number_multiplier(1M)' and 'number_multiplier(1M)'

```

--------------------------------

### Backend YAML Output for Boolean Attribute

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-konfig/practice

Example of how a simple boolean attribute like 'overQuota: True' is translated into a detailed backend YAML configuration.

```YAML
spec:  
spec:  
  template:  
    spec:  
      affinity:  
        nodeAffinity:  
          requiredDuringSchedulingIgnoredDuringExecution:  
            nodeSelectorTerms:  
              - matchExpressions:  
                  - key: k8s/is-over-quota  
                    operator: In  
                    values:  
                      - "true"  
```

--------------------------------

### Display helmfile.yaml Configuration

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/helmfile-kcl-plugin

View the helmfile.yaml configuration, which includes the KCLRun plugin for manifest mutation.

```bash
cat helmfile.yaml  
```

--------------------------------

### Example JSON Data for Validation

Source: https://www.kcl-lang.io/docs/user_docs/guides/validation

This JSON object represents the data to be validated against the KCL schema. It includes various data types and nested structures.

```json
{
  "name": "Alice",
  "age": 18,
  "message": "This is Alice",
  "data": {
    "id": 1,
    "value": "value1"
  },
  "labels": {
    "key": "value"
  },
  "hc": [1, 2, 3]
}

```

--------------------------------

### Push KCL Package to Docker.io

Source: https://www.kcl-lang.io/docs/user_docs/guides/package-management/how-to/share_your_pkg_docker

Pushes the KCL package from the current directory to your Docker.io registry. Ensure you replace <USERNAME> with your Docker.io username.

```bash
kcl mod push oci://docker.io/<USERNAME>/exist_kcl_package  

```

--------------------------------

### Helmfile Configuration with KCLRun Plugin

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/mutate-manifests/helmfile-kcl-plugin

This configuration demonstrates using the KCLRun plugin within helmfile.yaml to add annotations to Deployment resources.

```yaml
repositories:  
  - name: prometheus-community  
    url: https://prometheus-community.github.io/helm-charts  
  
releases:  
  - name: prom-norbac-ubuntu  
    namespace: prometheus  
    chart: prometheus-community/prometheus  
    set:  
      - name: rbac.create  
        value: false  
    transformers:  
      # Use KCL Plugin to mutate or validate Kubernetes manifests.  
      - apiVersion: krm.kcl.dev/v1alpha1  
        kind: KCLRun  
        metadata:  
          name: "set-annotation"  
          annotations:  
            config.kubernetes.io/function: |
              container:  
                image: docker.io/kcllang/kustomize-kcl:v0.2.0  
spec:  
          source: |  
            [resource | {if resource.kind == "Deployment": metadata.annotations: {"managed-by" = "helmfile-kcl"}} for resource in option("resource_list").items]  
```

--------------------------------

### Add Git Repository Dependency with Branch

Source: https://www.kcl-lang.io/docs/user_docs/guides/package-management/how-to/kpm_git

Add a Git repository as a dependency using a specific branch. Ensure Git is installed and accessible in your PATH.

```bash
kcl mod add git://github.com/kcl-lang/konfig --branch main
```

--------------------------------

### Add Git Repository Dependency with Tag

Source: https://www.kcl-lang.io/docs/user_docs/guides/package-management/how-to/kpm_git

Add a Git repository as a dependency using a specific tag. Ensure Git is installed and accessible in your PATH.

```bash
kcl mod add git://github.com/kcl-lang/konfig --tag v0.4.0
```

--------------------------------

### Display KCL Help Information

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Display help information for KCL command-line parameters.

```bash
kcl --help  
```

--------------------------------

### KCL CLI Variable Override - Add List Example

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Illustrates overriding a variable to add a list of integers to a schema attribute using the `-O` parameter.

```kcl
schema Person:
    name: str
    age: int
    ids?: [int]

person = Person {
    name = "Alice"
    age = 10
}

```

```bash
kcl main.k -O :person.ids=[1,2]

```

```text
person:
  name: Alice
  age: 10
  ids:
    - 1
    - 2

```

--------------------------------

### Defensive Type Conversion with 'as' and Type Guards

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Demonstrates using the 'as' keyword with type guards for safe type conversion. Handles cases where the type might not match, preventing runtime errors by assigning None.

```kcl
schema Data1:
    id?: int

schema Data2:
    name?: str

data: Data1 | Data2 = Data1 {}

if typeof(data) == "Data1":
    data1 = data as Data1  # The type of `data` is `Data1`
elif typeof(data) == "Data2":
    data2 = data as Data2  # The type of `data` is `Data2`
```

```kcl
a: any = "s"
b: int = a as int  # Error: The `str` type cannot be converted to the `int` type
```

```kcl
a: any = "s"
b = a as int if typeof(a) == "int" else None  # The type of b is `int`
```

--------------------------------

### KCL Arithmetic Operators

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Provides examples of common arithmetic operations supported in KCL, including addition, subtraction, multiplication, division, floor division, and modulo.

```kcl
assert 2 + 3 == 5
assert 2 - 3 == -1
assert 2 * 3 == 6
assert 5 / 2 == 2.5
assert 5 // 2 == 2
assert 5 % 2 == 1
```

--------------------------------

### String Formatting and Interpolation

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Demonstrates string formatting using `.format()` and string interpolation with `${variable}` syntax, including serialization to JSON and YAML.

```kcl
world = "world"
a = "hello {}".format(world)        # "hello world"
b = "hello ${world}"                # "hello world"
c1 = "$hello ${world}$"             # "$hello world$"
c2 = "$" + "hello ${world}" + "$"   # "$hello world$"
c3 = "$" + "hello \${world}" + "$"  # "$hello ${world}$"
```

```kcl
myDict = {
    "key1" = "value1"
    "key2" = "value2"
}
myList = [1, 2, 3]

d = "here is myDict in json: ${myDict: #json}"
# d: 'here is myDict in json: {"key1": "value1", "key2": "value2"}'

e = "here is myDict in yaml:\n${myDict: #yaml}"
# e: |
#  here is myDict in yaml:
#  key1: value1
#  key2: value2

f = "here is myList in json: ${myList: #json}"
# f: 'here is myList in json: [1, 2, 3]'
g = "here is myList in yaml: ${myList: #yaml}"
# g: |
#  here is myList in yaml: - 1
#  - 2
```

--------------------------------

### Deploy Configuration using KCL, Vals, and Kubectl

Source: https://www.kcl-lang.io/docs/user_docs/guides/secret-management/vault

Apply the KCL configuration to Kubernetes after processing it with Vals to resolve secret references.

```bash
kcl main.k | vals eval -f - | kubectl apply -f -  
```

--------------------------------

### KCL Code for Kubernetes Deployment

Source: https://www.kcl-lang.io/docs/user_docs/guides/working-with-k8s/generate-k8s-manifests

Define a Kubernetes Deployment resource using KCL syntax. This example showcases variable definition and reuse for metadata labels.

```kcl
apiVersion = "apps/v1"  
kind = "Deployment"  
metadata = {  
    name = "nginx"  
    labels.app = "nginx"  
}
spec = {  
    replicas = 3  
    selector.matchLabels = metadata.labels  
    template.metadata.labels = metadata.labels  
    template.spec.containers = [  
        {  
            name = metadata.name  
            image = "${metadata.name}:1.14.2"  
            ports = [{ containerPort = 80 }]  
        }  
    ]  
}  

```

--------------------------------

### Safe Navigation for Optional Attributes and Keys

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Illustrates safe navigation using '?.' to access dictionary keys or schema attributes that might be null or non-existent.

```kcl
# Example of dict:  
data = {key = "value"}
a = data?.key     # "value"
b = data?.name    # Undefined

# example of schema instance:
schema Company:
    name: str
    address: str

schema Person:
    name: str
    job?: Company

alice = Person {
    name = "alice"
}

if alice?.job?.name == "Group":
    print("work in Group")

```

--------------------------------

### Add Git Repository Dependency with Commit

Source: https://www.kcl-lang.io/docs/user_docs/guides/package-management/how-to/kpm_git

Add a Git repository as a dependency using a specific commit hash. Ensure Git is installed and accessible in your PATH.

```bash
kcl mod add git://github.com/kcl-lang/konfig --commit 78ba6e9
```

--------------------------------

### Add Dependency from OCI Registry

Source: https://www.kcl-lang.io/docs/user_docs/guides/package-management/quick-start

Use `kcl mod add` to include external packages from an OCI registry. This example adds the 'k8s' package with version '1.28.1'.

```bash
kcl mod add k8s:1.28.1  
```

--------------------------------

### Compile with YAML Setting File for Options

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Compile KCL code using a YAML file that specifies top-level options.

```bash
kcl -Y setting.yaml employee.k  
```

--------------------------------

### Instantiating Schema with Mixin

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Create an instance of a schema that uses a mixin, providing values for its defined attributes.

```kcl
person = Person {
    firstName = "John"
    lastName = "Doe"
}

```

--------------------------------

### Schema Attribute Immutability Example

Source: https://www.kcl-lang.io/docs/reference/lang/tour

Shows the immutability rules for schema attributes. Immutable attributes (like 'age') cannot be modified after initialization, while mutable attributes (like '_name') can be changed.

```kcl
schema Person:
    age: int = 1  # Immutable attribute
    _name: str = "Alice"  # Mutable attribute

    age = 10  # Error
    _name = "Bob"  # Ok
```
Tokens:
Raw