Skip to main content

7 posts tagged with "Release Blog"

View All Tags

· 16 min read

Introduction

The KCL team is pleased to announce that KCL v0.6.0 is now available! This release has brought three key updates to everyone: Language, Tools, and Integrations.

  • Use KCL language, tools and IDE extensions with more complete features and fewer errors to improve code writing experience and efficiency.
  • Use KPM, OCI Registry and other tools to directly use and share your cloud native domain models, reducing learning and hands-on costs.
  • Use cloud-native integration extensions such as Helmfile KCL plugin and KCL Operator to simultaneously support in-place mutation and validation of Kubernetes resources on both the client and runtime, avoiding hardcoded configurations.

You can visit the KCL release page or the KCL website to get KCL binary download link and more detailed release information.

KCL is an open-source, constraint-based record and functional language. KCL improves the writing of numerous complex configurations, such as cloud-native scenarios, through its mature programming language technology and practice. It is dedicated to building better modularity, scalability, and stability around configurations, simpler logic writing, faster automation, and great built-in or API-driven integrations.

This blog will introduce the content of KCL v0.6.0 and recent developments in the KCL community to readers.

Language

🔧 Type system enhancement

Support automatic type inference for KCL configuration block attributes. Prior to version 0.6.0 of KCL, the key1 and key2 attributes in the code snippet below would be inferred as type str | int. With the updated version, we have further improved the precision of type inference for configuration attributes, so key1 and key2 will have more specific and precise corresponding types.

config = {
key1 = "value1"
key2 = 2
}
key1 = config.key1 # The type of key1 is str
key2 = config.key2 # The type of key2 is int

In addition, we have optimized error messages for schema semantic checking, union type checking, and type checking errors in system library functions.

For more information, please refer to here

🏄 API Update

KCL Schema model parsing: The GetSchemaType API is used to retrieve KCL package-related information and default values for schema attributes.

🐞 Bug Fixes

Fix schema required/optional attribute check in KCL

In previous versions of KCL, the required/optional attribute check for KCL would miss nested schema attribute checks. In version KCL v0.6.0, we have fixed such similar issues.

schema S:
a: int
b: str
schema L:
# In previous versions, the required attribute check for attributes 'a' and 'b' of S in [S] and {str:S} would be missed.
# This issue has been fixed in KCL v0.6.0 and later versions.
ss?: [S]
sss?: {str:S}
l = L {
ss = [S {b = "b"}]
}

For more information, please see here

IDE & Toolchain Updates

IDE Updates

Features

  • Performance improvement for all IDE features
  • Support variable and schema attribute completion for KCL packages
  • Support KCL schema attribute document attribute hover
  • Support for quick fix of useless import statements

ide-quick-fix

  • Support right-click formatting of files and code fragments in VS Code.

ide-format

  • Support hover for built-in functions and function information in system libraries

ide-func-hover

IDE Extension Updates

We have integrated the KCL language server LSP into NeoVim and Idea, enabling the completion, navigation, and hover features supported by VS Code IDE in NeoVim and IntelliJ IDEA.

  • NeoVim KCL Extension

kcl.nvim

  • IntelliJ Extension

intellij

For more information on downloading, installation, and features of the IDE plugins, please refer to:

KCL Formatting Tool Updates

Support formatting of configuration blocks with incorrect indentation

  • Before formatting
config = {
a ={
x = 1
y =2
}
b = {
x = 1
y = 2
}
}
  • After formatting
config = {
a = {
x = 1
y = 2
}
b = {
x = 1
y = 2
}
}

KCL Documentation Tool Updates

  • Support for exporting Markdown documents
  • Support for exporting document index pages
  • Support for exporting documents with custom style templates
  • Support for HTML escaping in exported documents
  • Enhanced document generation to parse and render example code snippets in document comments
  • By tracking model updates in Github workflow and regenerating the documentation, automatic synchronization of the documentation can be achieved. Please refer to here for more details.

Generate model document from kpm package

  1. Create a kpm package and add documentation comments (using docstring) to the Service model. The documentation can include explanations, example code, and usage instructions to help other developers quickly get started and use it correctly.

➜ kpm init demo

➜ cat > demo/server.k << EOF
schema Service:
"""
Service is a kind of workload profile that describes how to run your application code. This
is typically used for long-running web applications that should "never" go down, and handle
short-lived latency-sensitive web requests, or events.

Attributes
----------
workloadType : str = "Deployment" | "StatefulSet", default is Deployment, required.
workloadType represents the type of workload used by this Service. Currently, it supports several
types, including Deployment and StatefulSet.
image : str, default is Undefined, required.
Image refers to the Docker image name to run for this container.
More info: https://kubernetes.io/docs/concepts/containers/images
replicas : int, default is 2, required.
Number of container replicas based on this configuration that should be ran.

Examples
--------
# Instantiate a long-running service and its image is "nginx:v1"

svc = Service {
workloadType: "Deployment"
image: "nginx:v1"
replica: 2
}
"""
workloadType: "Deployment" | "StatefulSet"
image: str
replica: int
EOF

  1. Generate the package documentation in Markdown format

The following command will output the demo package documentation to the doc/ directory in the current working directory:

kcl-go doc generate --file-path demo

docgen

For more usage details, please use kcl-go doc generate -h to refer to the help information.

Automatic synchronization of documents through CI pipelines

Implement automatic documentation synchronization through a pipeline By tracking model updates in a Github workflow and regenerating the documentation, automatic synchronization of the documentation can be achieved. You can refer to the approach in the Kusionstack/catalog repo to generate the documentation and automatically submit change PRs to the documentation repository.

By tracking model updates in Github workflow and regenerating documents, automatic document synchronization can be achieved. Can refer to the approach in the Kusionstack/catalog repo is to generate documents and automatically submit change PRs to the document repository.

KCL Import Tool Updates

The KCL Import Tool now adds support for converting Terraform Provider Schema to KCL Schema based on Protobuf, JsonSchema OpenAPI models, and Go Structures, such as the following Terraform Provider Json (obtained through the command terraform providers schema -json > provider.json , For more details, please refer to https://developer.hashicorp.com/terraform/cli/commands/providers/schema)

{
"format_version": "0.2",
"provider_schemas": {
"registry.terraform.io/aliyun/alicloud": {
"provider": {
"version": 0,
"block": {
"attributes": {},
"block_types": {},
"description_kind": "plain"
}
},
"resource_schemas": {
"alicloud_db_instance": {
"version": 0,
"block": {
"attributes": {
"db_instance_type": {
"type": "string",
"description_kind": "plain",
"computed": true
},
"engine": {
"type": "string",
"description_kind": "plain",
"required": true
},
"security_group_ids": {
"type": [
"set",
"string"
],
"description_kind": "plain",
"optional": true,
"computed": true
},
"security_ips": {
"type": [
"set",
"string"
],
"description_kind": "plain",
"optional": true,
"computed": true
},
"tags": {
"type": [
"map",
"string"
],
"description_kind": "plain",
"optional": true
}
},
"block_types": {},
"description_kind": "plain"
}
},
"alicloud_config_rule": {
"version": 0,
"block": {
"attributes": {
"compliance": {
"type": [
"list",
[
"object",
{
"compliance_type": "string",
"count": "number"
}
]
],
"description_kind": "plain",
"computed": true
},
"resource_types_scope": {
"type": [
"list",
"string"
],
"description_kind": "plain",
"optional": true,
"computed": true
}
}
}
}
},
"data_source_schemas": {}
}
}
}

Then the tool can output the following KCL code

"""
This file was generated by the KCL auto-gen tool. DO NOT EDIT.
Editing this file might prove futile when you re-run the KCL auto-gen generate command.
"""

schema AlicloudConfigRule:
"""
AlicloudConfigRule

Attributes
----------
compliance: [ComplianceObject], optional
resource_types_scope: [str], optional
"""

compliance?: [ComplianceObject]
resource_types_scope?: [str]

schema ComplianceObject:
"""
ComplianceObject

Attributes
----------
compliance_type: str, optional
count: int, optional
"""

compliance_type?: str
count?: int

schema AlicloudDbInstance:
"""
AlicloudDbInstance

Attributes
----------
db_instance_type: str, optional
engine: str, required
security_group_ids: [str], optional
security_ips: [str], optional
tags: {str:str}, optional
"""

db_instance_type?: str
engine: str
security_group_ids?: [str]
security_ips?: [str]
tags?: {str:str}

check:
isunique(security_group_ids)
isunique(security_ips)

Package Manage Tool Updates

kpm pull supports pulling packages by package name

kpm supports pulling the corresponding package by using the kpm pull <package_name>:<package_version> command.

Taking the k8s package as an example, you can directly download the package to your local machine using the following commands:

kpm pull k8s

or

kpm pull k8s:1.27

The package downloaded with kpm pull will be saved in the directory <execution_directory>/<oci_registry>/<package_name>. For example, if you use the default kpm registry and run the kpm pull k8s command, you can find the downloaded content in the directory <execution_directory>/ghcr.io/kcl-lang/k8s.

$ tree ghcr.io/kcl-lang/k8s -L 1

ghcr.io/kcl-lang/k8s
├── api
├── apiextensions_apiserver
├── apimachinery
├── kcl.mod
├── kcl.mod.lock
├── kube_aggregator
└── vendor

6 directories, 2 files

kpm supports adding local paths as dependencies

"Different projects have different KCL packages, and there are dependencies between them. However, they are stored in different directories. I hope that these packages stored in different directories can be managed together, rather than having to put them together for them to compile." If you also have this need, you can try this feature. The kpm add command currently supports adding local paths as dependencies to a KCL package. You just need to run the command kpm add <local_package_path>, and your local package will be added as a third-party library dependency to the current package.

kpm pull k8s

After completion, you can find the downloaded k8s package in the directory "the_directory_where_you_executed_the_command/ghcr.io/kcl-lang/k8s". Create a new KCL package using the kpm init mynginx command.

kpm init mynginx

Then, navigate into this package.

cd mynginx

Inside this package, you can use the kpm add command to add the k8s package you downloaded locally as a third-party library dependency to mynginx.

kpm add ../ghcr.io/kcl-lang/k8s/

Next, add the following content to main.k.

import k8s.api.core.v1 as k8core

k8core.Pod {
metadata.name = "web-app"
spec.containers = [{
name = "main-container"
image = "nginx"
ports = [{containerPort: 80}]
}]
}

Normal compilation can be performed through the kpm run command.

kpm run

kpm adds checking for existing package tags

We have added a check for duplicate tags in the kpm push command. In order to avoid situations where packages with the same tag have different content, we have added restrictions on the push function in the kpm. If the version of the kcl package you push already exists, you will not be able to push the current kcl package. You will receive the following information:

kpm: package 'my_package' will be pushed.
kpm: package version '0.1.0' already exists

Modifying the content of a package that has already been pushed to the registry without changing the tag carries a high risk, as the package may already be in use by others. Therefore, if you need to push your package, we recommend:

  • Change your tag and follow semantic versioning conventions.
  • If you must modify the content of a package without changing the tag, you will need to delete the existing tag from the registry.

Integrations

Helmfile KCL Plugin

Helmfile is a declarative specification and tool for deploying Helm Charts. With the Helmfile KCL plugin, you can:

  • Edit or verify Helm Chart through non-invasive hook methods, separating the data and logic parts of Kubernetes configuration management
    • Modify resource labels/annotations, inject sidecar container configuration
    • Use KCL schema to validate resources
    • Define your own abstract application models
  • Maintain multiple environment and tenant configurations elegantly, rather than simply copying and pasting.

Here is a detailed explanation using a simple example. With the Helmfile KCL plugin, you do not need to install any components related to KCL. You only need the latest version of the Helmfile tool on your local device.

We can write a helmfile.yaml file as follows:

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]

In the above file, we referenced the Prometheus Helm Chart and injected the managed-by="helmfile-kcl" label into all deployment resources of Prometheus with just one line of KCL code. The following command can be used to deploy the above configuration to the Kubernetes cluster:

helmfile apply

For more use cases, please refer to https://github.com/kcl-lang/krm-kcl

KCL Operator

KCL Operator provides cluster integration, allowing you to use Access Webhook to generate, mutate, or validate resources based on KCL configuration when apply resources to the cluster. Webhook will capture creation, application, and editing operations, and execute KCLRun on the configuration associated with each operation, and the KCL programming language can be used to

  • Add labels or annotations based on a condition.
  • Inject a sidecar container in all KRM resources that contain a PodTemplate.
  • Validating all KRM resources using KCL Schema, such as constraints on starting containers only in a root mode.
  • Generating KRM resources using an abstract model or combining and using different KRM APIs.

Here is a simple resource annotation mutation example to introduce the usage of the KCL operator.

0. Prerequisites

Prepare a Kubernetes cluster like k3d the kubectl tool.

1. Install KCL Operator

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

Use the following command to observe and wait for the pod status to be Running.

kubectl get po

2. Deploy KCL Annotation Setting Model

kubectl apply -f- << EOF
apiVersion: krm.kcl.dev/v1alpha1
kind: KCLRun
metadata:
name: set-annotation
spec:
# Set dynamic parameters required for the annotation modification model, here we can add the labels we want to modify/add
params:
annotations:
managed-by: kcl-operator
# Reference the annotation modification model on OCI
source: oci://ghcr.io/kcl-lang/set-annotation
EOF

3. Deploy a Pod to Verify the Model Result

Execute the following command to deploy a Pod resource:

kubectl apply -f- << EOF
apiVersion: v1
kind: Pod
metadata:
name: nginx
annotations:
app: nginx
spec:
containers:
- name: nginx
image: nginx:1.14.2
ports:
- containerPort: 80
EOF
kubectl get po nginx -o yaml | grep kcl-operator

We can see the following output:

    managed-by: kcl-operator

We can see that the Nginx Pod automatically added the annotation managed-by=kcl-operator.

In addition, besides referencing an existing model for the source field of the KCLRun resource, we can directly set KCL code for the source field to achieve the same effect. For example:

apiVersion: krm.kcl.dev/v1alpha1
kind: KCLRun
metadata:
name: set-annotation
spec:
params:
annotations:
managed-by: kcl-operator
# Resource modification can be achieved with just one line of KCL code
source: |
items = [item | {metadata.annotations: option("params").annotations} for item in option("items")]

registry

We have provided more than 30 built-in models, and you can find more code examples in the following link: https://github.com/kcl-lang/krm-kcl/tree/main/examples

For example

  • Use the web-service model to directly instantiate the Kubernetes resources required for a web application
  • Add annotations to existing k8s resources using the set-annotation model
  • Use the https-only model to verify that your Ingress configuration can only be set to https, otherwise an error will be reported.

Vault Integration

In just three steps, we can use Vault to store and manage sensitive information and use it in KCL.

Firstly, we install and use Vault to store foo and bar information.

vault kv put secret/foo foo=foo
vault kv put secret/bar bar=bar

Then write the following KCL code (main.k)

apiVersion = "apps/v1"
kind = "Deployment"
metadata = {
name = "nginx"
labels.app = "nginx"
annotations: {
"secret-store": "vault"
# Valid format:
# "ref+vault://PATH/TO/KV_BACKEND#/KEY"
"foo": "ref+vault://secret/foo#/foo"
"bar": "ref+vault://secret/bar#/bar"
}
}
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 }]
}
]
}

Finally, the decrypted configuration can be obtained through the vals command-line tool

kcl main.k | vals eval -f -

For more details and use cases, please refer to here

GitLab CI Integration

Using KCL, we can not only use Github Action as CI for application publishing through GitOps, but also provide GitLab CI integration in this version. Please refer to: https://kcl-lang.io/docs/user_docs/guides/ci-integration/gitlab-ci

Other Updates and Bug Fixes

See here for more updates and bug fixes.

Documents

The versioning semantic option is added to the KCL website. Currently, v0.4.x, v0.5.x and v0.6.0 versions are supported.

Community

  • Thank @jakezhu9 for his contribution to converting KCL Import tools, including Terraform Provider Schema, JsonSchema, JSON, YAML, and other configuration formats/data to KCL schema/configurations 🙌
  • Thank @xxmao123 for her contribution to connecting KCL LSP language server to the Idea IDE extension 🙌
  • Thank @starkers for his contribution to the KCL NeoVim extension 🙌
  • Thank @starkers for adding KCL installation support to mason.nvim registry 🙌
  • Thank @Ekko for his contribution to the integration of KCL cloud native tools and KCL Operator 🙌
  • Thank @prahalaramji for the upgrade, update, and contribution to the KCL Homebrew installation script 🙌
  • Thank @yyxhero for providing assistance and support in the Helmfile KCL plugin support 🙌
  • Thank @nkabir, @mihaigalos, @prahalaramji, @yamin-oanda, @dhhopen, @magick93, @MirKml, @kolloch, @steeling, and others for their valuable feedback and discussion during the past two months of using KCL. 🙌

Additional Resources

For more information, see KCL FAQ.

Resources

Thank all KCL users for their valuable feedback and suggestions during this version release. For more resources, please refer to:

See the community for ways to join us. 👏👏👏

· 13 min read

Introduction

The KCL team is pleased to announce that KCL v0.5.0 is now available! This release has brought three key updates to everyone: Language, Tools, and Integrations.

  • Use KCL language and IDE with more complete features and fewer errors to improve code writing experience and efficiency.
  • Use KPM, KCL OpenAPI, OCI Registry and other tools to directly use and share your cloud native domain models, reducing learning and hands-on costs.
  • Using community tools such as Github Action, ArgoCD, and Kubectl KCL plugins to integrate and extend support to improve automation efficiency.

You can visit the KCL release page or the KCL website to get KCL binary download link and more detailed release information.

KCL is an open-source, constraint-based record and functional language. KCL improves the writing of numerous complex configurations, such as cloud-native scenarios, through its mature programming language technology and practice. It is dedicated to building better modularity, scalability, and stability around configurations, simpler logic writing, faster automation, and great built-in or API-driven integrations.

This blog will introduce the content of KCL v0.5.0 and recent developments in the KCL community to readers.

Language

Top-level Variable Output

In previous versions of KCL, running the following KCL code will not output YAML. In KCL v0.5.0, we improved this and supported exporting top-level variables to YAML configuration to reduce additional KCL code and command-line parameters, such as for the following KCL code (main.k)

schema Nginx:
http: Http

schema Http:
server: Server

schema Server:
listen: int | str
location?: Location

schema Location:
root: str
index: str

Nginx { # Nginx will be output
http.server = {
listen = 80
location = {
root = "/var/www/html"
index = "index.html"
}
}
}

In the new version, running KCL code can directly obtain the following output

$ kcl main.k
http:
server:
listen: 80
location:
root: /var/www/html
index: index.html

See here for more.

Index Signature

In previous versions of KCL, running the KCL command-line tool once only displayed one error message and warning. In KCL v0.5.0, it supported the ability to display multiple errors and warnings in one compilation and improved error information to improve the efficiency of KCL code error troubleshooting, such as for the following KCL code (main.k).

schema TeamSpec:
fullName: str
name = id
shortName: str = name

schema TeamMap:
[n: str]: TeamSpec = TeamSpec {
name = n # n is the schema index signature key alias, we can use it directly
}

teamMap = TeamMap {
a.fullName = "alpha"
b.fullName = "bravo"
}

In the new version, running KCL code can directly obtain the following output.

$ kcl main.k
teamMap:
b:
fullName: bravo
name: b
shortName: b
a:
fullName: alpha
name: a
shortName: a

See here for more.

Runtime Backtrace Output

In previous versions of KCL, when writing the following KCL code, the two schema configurations with the same name were merged and output. In KCL v0.5.0, it was required to explicitly use the attribute merge operator instead of the attribute overlay operator.

schema Fib:
n1 = n - 1
n2 = n1 - 1
n: int
value: int

if n <= 1:
value = [][n] # There is a index overflow runtime error.
elif n == 2:
value = 1
else:
value = Fib {n = n1}.value + Fib {n = n2}.value

fib8 = Fib {n = 4}.value

After execution, we will receive the following error message

$ kcl main.k -d
error[E3M38]: EvaluationError
EvaluationError
--> main.k:8
|
8 | value = [][n] # There is a index overflow runtime error.
| list index out of range: 1
|
note: backtrace:
1: __main__.Fib
at main.k:8
2: __main__.Fib
at main.k:12
3: __main__.Fib
at main.k:12
4: main
at main.k:14

See here for more.

Bugfix

Type Error in Filter Expressions

Before KCL v0.5.0, filter expressions returned incorrect types (should return the type of the iterator instead of the type of the iterated object). In KCL v0.5.0, we fixed similar issues.

schema Student:
name: str
grade: int

students: [Student] = [
{name = "Alice", grade = 85}
{name = "Bob", grade = 70}
]

studentsGrade70: [Student] = filter s in students {
s.grade == 70
} # Previously, we received a type mismatch error here. In KCL v0.5.0, we fixed similar issues.

See here for more.

Lambda Closure Error

In previous versions of KCL, for the following KCL code, there was an error where the versions attribute was not assigned as expected. In KCL v0.5.0, we fixed similar issues.

z = 1
add = lambda x { lambda y { x + y + z} } # `x` is the closure of the inner lambda.
res = add(1)(1) # 3

See here for more.

String Literal Union Type Error Containing UTF-8 Characters

In previous versions of KCL, using string literal union type that contains UTF-8 characters resulted in an unexpected type error. In KCL v0.5.0 version, we fixed similar issues like this.

msg: "无需容灾" | "标准型" | "流水型" = "流水型"

See here for more.

Tools & IDE

KCL OpenAPI Tool

The kcl-openapi command-line tool supports conversion from OpenAPI Spec to KCL code. Installation can be obtained through go install or curl:

# go install
go install kcl-lang.io/kcl-openapi@latest

# curl install (MacOS & Linux)
curl -fsSL https://kcl-lang.io/script/install-kcl-openapi.sh | /bin/bash

Kubernetes KCL Package Conversion Optimization

The v0.5.0 version optimizes the experience of using Kubernetes KCL packages:

  • Built-in Kubernetes package: KCL provides out of the box KCL packages for Kubernetes 1.14-1.27 versions, which can be obtained through the package management tool kpm pull k8s:<version>.
  • If you need to convert other Kubernetes versions of the KCL model on your own, you can use the following preprocessing script to convert the swagger.json file downloaded from the Kubernetes repository into the KCL package. Change 1.27 of the following command to the desired Kubernetes version.
version=1.27
spec_path=swagger.json
script_path=main.py
wget https://raw.githubusercontent.com/kubernetes/kubernetes/release-${version}/api/openapi-spec/swagger.json -O swagger.json
wget https://raw.githubusercontent.com/kcl-lang/kcl-openapi/main/scripts/preprocess/main.py -O main.py
python3 ${script_path} ${spec_path} --omit-status --rename=io.k8s=k8s
kcl-openapi generate model -f processed-${spec_path}

The expected execution output of the script is the corresponding version of the KCL Kubernetes model, and the generated path is <workspace path>/models/k8s.

$ tree models/k8s
models/k8s
├── api
│ ├── admissionregistration
│ │ ├── v1
│ │ │ ├── match_condition.k
│ │ │ ├── mutating_webhook.k
│ │ │ ├── mutating_webhook_configuration.k
│ │ │ ├── mutating_webhook_configuration_list.k
│ │ │ ├── rule_with_operations.k
│ │ │ ├── service_reference.k
│ │ │ ├── validating_webhook.k
...

Bugfix

  • Escape attribute names with the - character as _ to comply with KCL v0.5.0 syntax, see details
  • Automatically recognize and set import as reference aliases to avoid reference conflicts, see details
  • Fix the issue of attribute description indentation in docstring, and automatically indent the internal line breaks of attribute descriptions. See details
  • Fix the generated reference path to be the full reference path based on the root directory of the package, see details

Package Management Tool

In the new version of KCL v0.5.0, we have provided a new KCL package management tool, which allows users to access the KCL modules in the community with a few commands.

Managing KCL Programs through the kpm Tool

Before using kpm, it is necessary to ensure that you are currently working in a KCL package. You can use the command kpm init to create a standard KCL package.

kpm init kubernetes_demo && cd kubernetes_demo && kpm add k8s

Write a KCL code to import the Kubernetes models (main.k).

import k8s.api.apps.v1 as apps

apps.Deployment {
metadata.name = "nginx-deployment"
spec = {
replicas = 3
selector.matchLabels.app = "nginx"
template.metadata.labels = selector.matchLabels
template.spec.containers = [
{
name = selector.matchLabels.app
image = "nginx:1.14.2"
ports = [
{containerPort = 80}
]
}
]
}
}

By combining the kpm run and kubectl command lines, we can directly distribute resource configurations to the cluster.

$ kpm run | kubectl apply -f -

deployment.apps/nginx-deployment configured

OCI Registry

The kpm tool supports pushing KCL packages through OCI Registry. The default OCI Registry currently provided by kpm is https://github.com/orgs/kcl-lang/packages.

You can browse the KCL package you need here. We currently provide the KCL package for k8s, which supports all versions of k8s from 1.14 to 1.27. Welcome to open Issues to co build KCL models.

See here for more information about the kpm tool.

Integrations

CI Integrations

In the new version of KCL, we have provided an example scheme of Github Actions as the CI integration. We hope to implement the end-to-end application development process by using containers, Continuous Integration (CI) for configuration generation, and GitOps for Continuous Deployment (CD). The overall workflow is as follows:

  • Develop application code and submit it to the GitHub repository to trigger CI (using Python Flask web application as an example).

app

  • GitHub Actions generate container images from application code and push them to the docker.io container registry.

app-ci

  • GitHub Actions automatically synchronizes and updates the KCL manifest deployment file based on the version of the container image in the docker.io container registry.

auto-update

We can obtain the deployment manifest source code for compilation and verification, and the following YAML output will be obtained

apiVersion: apps/v1
kind: Deployment
metadata:
name: flask_demo
labels:
app: flask_demo
spec:
replicas: 1
selector:
matchLabels:
app: flask_demo
template:
metadata:
labels:
app: flask_demo
spec:
containers:
- name: flask_demo
image: "kcllang/flask_demo:6428cff4309afc8c1c40ad180bb9cfd82546be3e"
ports:
- protocol: TCP
containerPort: 5000
---
apiVersion: v1
kind: Service
metadata:
name: flask_demo
labels:
app: flask_demo
spec:
type: NodePort
selector:
app: flask_demo
ports:
- port: 5000
protocol: TCP
targetPort: 5000

From the above configuration, it can be seen that the image of the resource is indeed automatically updated to the newly constructed image content. In addition, we can also use the Argo CD KCL plugin to automatically synchronize data from the Git repository and deploy the application to the Kubernetes cluster.

For more details, please refer to here

CD Integrations

In addition, we also provide ArgoCD as an example solution for CD integration. Through Github Action CI integration and ArgoCD KCL plugin, we can complete end-to-end GitOps workflow, improve application configuration automatic change and deployment efficiency. The following is an overview and synchronization of Kubernetes configuration using ArgoCD application. By using ArgoCD's ability, when application code changes, it is automatically updated and deployed synchronously.

  • Application Overview

argocd-app

  • Configuration Synchronization

argocd-sync

For more details, please refer to here

Kubernetes Configuration Management Tool Plugin

In KCL v0.5.0, we provide KCL plugin support for configuration management tools such as Kubectl, Helm, Kustomize, and KPT in the Kubernetes community through a unified programming interface. By writing a few lines of configuration code, we can non-invasive edit and validate existing Kustomize YAML and Helm Charts, such as modifying resource labels/annotations, injecting sidecar containers, and validate resources using KCL schema, defining your own abstract models and share them, etc.

Below is a detailed explanation of the integration of Kubectl tool with KCL as an example. You can click here to obtain the installation of Kubectl KCL plugin.

First, execute the following command to obtain a configuration example

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

Then execute the following command to show the configuration

$ cat krm-kcl-abstration.yaml
apiVersion: krm.kcl.dev/v1alpha1
kind: KCLRun
metadata:
name: web-service-abtraction
spec:
params:
name: app
containers:
ngnix:
image: ngnix
ports:
- containerPort: 80
service:
ports:
- port: 80
labels:
name: app
source: oci://ghcr.io/kcl-lang/web-service

In the above configuration, we used a Kubernetes web service application abstract model that has been predetermined on OCI oci://ghcr.io/kcl-lang/web-service and configured the required configuration fields for the model through the params field. The original Kubernetes YAML output can be obtained and applied by executing the following command:

$ kubectl kcl apply -f krm-kcl-abstration.yaml

deployment.apps/app created
service/app created

More detailed introductions and use cases of Kubernetes configuration management tools can be found here

At present, the integration of Kubernetes configuration management tools supported by KCL is still in its early stages. If you have more ideas and requirements, welcome to open issues to discuss.

Other Updates and Bug Fixes

See here for more updates and bug fixes.

Documents

The versioning semantic option is added to the KCL website. Currently, v0.4.3, v0.4.4, v0.4.5, v0.4.6 and v0.5.0 versions are supported.

Community

  • Thank @harri2012 for his first contribution to the KCL IDE plugin 🙌
  • Thank @niconical for his contribution to the KCL command line basic code and CI/CD scripts 🙌
  • Thank @Ekko for his contribution to the integration of KCL cloud native tools 🙌
  • Congratulations to Junxing Zhu his successful selection into the GitLink Programming Summer Camp (GLCC) "Terraform/JsonSchema to KCL Schema" project 🎉
  • Congratulations to Yiming Ren on her successful selection of the topic "IDE plug-in enhancement and language server integration" in the summer of open source 🎉
  • We have relocated KCL 30+ repos as a whole to the new Github kcl-lang organization, keeping the project address in mind https://github.com/kcl-lang ❤️
  • KCL's joining CNCF Landscape is a small encouragement and recognition from the cloud native community. The next step is to strive to join CNCF Sandbox and make more contributions to the cloud native community 💪

Next

It is expected that in September 2023, we will release KCL v0.6.0. The expected key evolution includes:

  • KCL language is further improved for convenience, the user interface is continuously optimized and experience is improved, user support and pain points are solved.
  • More IDE extensions, package management tools, Kubernetes scenario integration, feature support, and user experience improvement.
  • Provide more out-of-box KCL model support for cloud-native scenarios, mainly including containers, services, computing, storage, and networks.
  • More CI/CD integrations such as Jenkins, Gitlab CI, FluxCD, etc.
  • Support helmfile KCL plugins, directly generating, mutating, and validating Kubernetes resources through the KCL code.
  • Support for mutating and validating YAML by running KCL code through the admission controller at the Kubernetes runtime.

For more details, please refer to KCL 2023 Roadmap and KCL v0.6.0 Milestone.

If you have more ideas and needs, welcome to open Issues and join our community for communication as well 🙌 🙌 🙌

FAQ

For more information, see KCL FAQ.

Additional Resources

Thank all KCL users for their valuable feedback and suggestions during this version release. For more resources, please refer to:

See the community for ways to join us. 👏👏👏