# k8t
*Pronounced katie [ˈkeɪti]*
[](https://circleci.com/gh/ClarkSource/k8t/tree/master)
[](https://pypi.org/project/k8t/)
[](https://pypi.org/project/k8t/)
[](https://www.clark.de/de/jobs)
Simple cluster and environment specific aware templating for kubernetes manifests.
<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)*
- [Installation](#installation)
- [Docker](#docker)
- [Completion](#completion)
- [Concepts](#concepts)
- [*Clusters* and *Environments*](#clusters-and-environments)
- [Templating](#templating)
- [Template helper functions](#template-helper-functions)
- [Configuration inheritance](#configuration-inheritance)
- [Usage](#usage)
- [Scaffolding](#scaffolding)
- [Config management](#config-management)
- [Validate templates](#validate-templates)
- [Shortcomings](#shortcomings)
- [is defined](#is-defined)
- [Generate manifests](#generate-manifests)
- [Overriding templates](#overriding-templates)
- [Managing secrets](#managing-secrets)
- [Providers](#providers)
- [SSM](#ssm)
- [role assumption](#role-assumption)
- [Random](#random)
- [Hash](#hash)
- [Using as a pre-commit hook](#using-as-a-pre-commit-hook)
- [TODO](#todo)
<!-- END doctoc generated TOC please keep comment here to allow auto update -->
## Installation
run this
```bash
$ pip install --user --upgrade k8t
```
run the following to install [ujson](https://pypi.org/project/ujson/) as a dependency
```bash
$ pip install --user --upgrade k8t[ujson]
```
**note**: k8t is not Python 2 compatible
### Docker
You can also run k8t via docker
```bash
$ docker run clarksource/k8t:latest
```
**hint**: the docker image comes with [aws-cli](https://aws.amazon.com/cli/), and [kubectl](https://github.com/kubernetes/kubectl).
### Completion
Run the following and store the file in your distribution/OS specific spot
bash:
```bash
$ _K8T_COMPLETE=source k8t > k8t-completion.sh
```
zsh:
```zsh
$ _K8T_COMPLETE=source_zsh k8t > k8t-completion.sh
```
## Concepts
By combining those concepts you can quickly add completely new environments to your deployment pipeline just by
modifying specializing values and sharing the rest.
Check out our examples [here](examples/).
### *Clusters* and *Environments*
k8t comes with a builtin framework for *clusters* and *environments* (e.g. production, staging). This came from the need to be able to deploy
the same application over multiple clusters and in different environments with completely different setups and values.
This idea is helped by the fact that k8t deep-merges values and configs, allowing easy variation through different
stages of your application deployment.
Both *clusters* and *environments* are intentionally working the same way and can be used to add another degree of freedom when
combined. *Environments* however are also available globally, meaning clusters can share environment specific
configuration while specifying differences in those environments.
### Templating
Templating is supported via [Jinja](https://jinja.palletsprojects.com). k8t also comes with some additional
[helper functions](#template-helper-functions) and a [validation function](#validate-templates) with verbose output to
quickly verify the written templates.
#### Template helper functions
* `random_password(N: int)` - generate a random string of length N
* `envvar(key: str, [default])` - get a value from any environment variable with optional default
* `b64encode(value: str)` - encodes a value in base64 (usually required for secrets)
* `b64decode(value: str)` - decodes a value from base64
* `hash(value: str, [method: str])` - hashes a given value (default using `sha256`)
* `get_secret(key: str)` - provides a secret value from a given provider (see [here](#managing-secrets))
* `bool(value: Any)` - casts value to boolean ("true", "on", "yes", "1", 1 are considered as `True`)
* `sanitize_label(value: str)` - sanitizes label values according to kubernetes spec
* `sanitize_cpu(value: str | int)` - sanitize cpu value to millicores
* `sanitize_memory(value: str | int)` - sanitize memory value to megabyte (note: values in scientific notation need to be converted to strings)
* `standardize_cpu(value: str | int)` - standardize cpu value to millicores (as int)
* `standardize_memory(value: str | int)` - standardize memory value to megabyte (as int; note: values in scientific notation need to be converted to strings)
## Configuration inheritance
Configuration, values and templates are used according to the scope they are in. The following snippet shows an example project with low scores (1) and high scores (4) for evaluation order.
So variables and templates will be overridden from `project` -> `environments` -> `clusters` -> `cluster-environments` resulting in more specific configuration overriding lower values.
```bash
. (1) # k8t new project .
├── clusters
│ ├── foo (3) # k8t new cluster foo
│ │ ├── config.yaml
│ │ ├── values.yaml
│ │ ├── environments
│ │ │ ├── production (4) # k8t new environment production -c foo
│ │ │ │ ├── config.yaml
│ │ │ │ └── values.yaml
│ │ │ └── staging (4) # k8t new environment staging -c foo
│ │ │ ├── config.yaml
│ │ │ ├── values.yaml
│ │ │ └── templates
│ │ │ └── deployment.yaml.j2 (4) # k8t new template deployment -c foo -e staging
│ │ └── templates
│ │ └── deployment.yaml.j2 (3) # k8t new template deployment -c foo
│ └── bar (3) # k8t new cluster bar
│ ├── config.yaml
│ └── values.yaml
├── environments
│ ├── production (2) # k8t new environment production
│ │ ├── config.yaml
│ │ └── values.yaml
│ └── staging (2) # k8t new environment staging
│ ├── config.yaml
│ └── values.yaml
├── config.yaml (1)
└── values.yaml (1)
```
## Usage
### Scaffolding
Create a new project folder with a cluster directory and an empty defaults file
```bash
$ k8t new project .
```
Create a new cluster
```bash
$ k8t new cluster MyCluster
```
Create a new global environment
```bash
$ k8t new environment staging
```
And a new cluster environment
```bash
k8t new environment staging -c MyCluster
```
Generate a new deployment template for cluster MyCluster (for a list of available templates see the `k8t new template --help`)
```bash
$ k8t new template deployment -c MyCluster -e staging
```
### Config management
To ease file access a little bit k8t can open config and value files in your `$EDITOR` or fallback to a sensible
default.
```bash
$ k8t edit values --environment staging
```
```bash
$ k8t edit config --cluster MyCluster
```
### Validate templates
While validation is done before generating, templates can be validated for environment files easily.
```bash
$ k8t validate
```
To validate for clusters/environments the usual options can be used
```bash
$ k8t validate -c MyCluster -e production
```
#### Shortcomings
The validation is currently not a 100% correct and can miss certain edge cases. If you notice any other issues please let us know.
##### is defined
The following will result in a false negative for `foobar` being defined
```
{{ foobar }}
{% if foobar is defined %}
{{ foobar }}
{% endif %}
```
To avoid this make sure that the `is defined` test is applied to all instances of the variable.
The following may result in a false positive for `bar` being undefined
```
{% if foobar is defined %}
{{ bar }}
{% endif %}
```
### Generate manifests
The **--cluster** flag will load variables from a directory. By default the file **default.yaml** in that directory will be
loaded, however an environment can be specified with **--environment**.
```bash
$ k8t gen -c MyCluster -e staging
```
Additionally k8t will attempt to load a file **defaults.yaml** in the root directory. This way a set of default
variables can be specified and selectively overriden via cluster and environment.
Additional values can be given via flag **--value-file** in the form of a file or **--value KEY VALUE**, both can be
supplied multiple times.
Variables will be merged via deep merging. Default merge strategy is left-to-right.
### Overriding templates
Templates can be overriden on a cluster/environment level.
If a file `application.yaml` exists in the root templates folder, simply add a file with the same name to the
cluster/environment template folder.
### Managing secrets
Secrets can be interpolated with the helper function `get_secret`. It requires a key as first argument and providers
are configurable by environment/cluster.
```yaml
foobar: "{{ get_secret('/my-key') }}"
```
#### Providers
##### SSM
Setup secrets on SSM
```yaml
secrets:
provider: ssm
region: "eu-central-1"
prefix: "/foobar"
```
> Keep in mind that SSM parameter names can be formed as a path and they can only consist of sub-paths divided by slash symbol; each sub-path can be formed as a mix of letters, numbers and the following 3 symbols: `.-_`
>
> Be careful to follow this format when setting up the provider `prefix` and `get_secret(key)`.
Global secrets config can be overridden in `get_secret` helper function call by specifying `config_override` argument.
```yaml
foobar: "{{ get_secret('/my-key', config_override={'prefix': '/dev'}) }}"
```
###### role assumption
You can optionally assume an IAM role to retrieve secrets by specyfing `role_arn` in the config:
```
secrets:
provider: ssm
region: "eu-central-1"
role_arn: "arn:aws:iam::account:role/role-name-with-path"
```
##### Random
Random secrets can be generated easily by using the random provider. This provider uses a global dictionary to store
results for the time of the run in python so keys should always produce the same result.
```yaml
secrets:
provider: random
```
##### Hash
In case consistent (fake) secrets are needed, the `hash` provider can be used that hashes the secret key for the value.
```yaml
secrets:
provider: hash
```
### Using as a pre-commit hook
You can also use this repo as a https://github.com/pre-commit/pre-commit hook
Add this to your `.pre-commit-config.yaml`:
```yaml
- repo: https://github.com/ClarkSource/k8t
rev: '' # Use the sha / tag you want to point at
hooks:
- id: k8t-validate
# args: [ -e dev -c us-west-2 ]
- id: k8t-generate
name: k8t(dev)
args: [ -o dev.yaml -e dev ]
```
## TODO
* testing needs to be expanded
* the ability to add additional template directories via the CLI
* validation functions for template values (e.g. memory/cpu values)
Raw data
{
"_id": null,
"home_page": "https://github.com/ClarkSource/k8t",
"name": "k8t",
"maintainer": "",
"docs_url": null,
"requires_python": "",
"maintainer_email": "",
"keywords": "kubernetes,jinja,multi-cluster,templating",
"author": "Aljosha Friemann",
"author_email": "aljosha.friemann@clark.de",
"download_url": "https://files.pythonhosted.org/packages/51/8e/bbd04b0143045a2d9e33826498727fc8a673c8faa62590adcae0507f1984/k8t-0.8.3.tar.gz",
"platform": "linux",
"description": "# k8t\n\n*Pronounced katie [\u02c8ke\u026ati]*\n\n[](https://circleci.com/gh/ClarkSource/k8t/tree/master)\n[](https://pypi.org/project/k8t/)\n[](https://pypi.org/project/k8t/)\n[](https://www.clark.de/de/jobs)\n\nSimple cluster and environment specific aware templating for kubernetes manifests.\n\n<!-- START doctoc generated TOC please keep comment here to allow auto update -->\n<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->\n**Table of Contents** *generated with [DocToc](https://github.com/thlorenz/doctoc)*\n\n- [Installation](#installation)\n - [Docker](#docker)\n - [Completion](#completion)\n- [Concepts](#concepts)\n - [*Clusters* and *Environments*](#clusters-and-environments)\n - [Templating](#templating)\n - [Template helper functions](#template-helper-functions)\n- [Configuration inheritance](#configuration-inheritance)\n- [Usage](#usage)\n - [Scaffolding](#scaffolding)\n - [Config management](#config-management)\n - [Validate templates](#validate-templates)\n - [Shortcomings](#shortcomings)\n - [is defined](#is-defined)\n - [Generate manifests](#generate-manifests)\n - [Overriding templates](#overriding-templates)\n - [Managing secrets](#managing-secrets)\n - [Providers](#providers)\n - [SSM](#ssm)\n - [role assumption](#role-assumption)\n - [Random](#random)\n - [Hash](#hash)\n - [Using as a pre-commit hook](#using-as-a-pre-commit-hook)\n- [TODO](#todo)\n\n<!-- END doctoc generated TOC please keep comment here to allow auto update -->\n\n## Installation\n\nrun this\n\n```bash\n$ pip install --user --upgrade k8t\n```\n\nrun the following to install [ujson](https://pypi.org/project/ujson/) as a dependency\n\n```bash\n$ pip install --user --upgrade k8t[ujson]\n```\n\n**note**: k8t is not Python 2 compatible\n\n### Docker\n\nYou can also run k8t via docker\n\n```bash\n$ docker run clarksource/k8t:latest\n```\n\n**hint**: the docker image comes with [aws-cli](https://aws.amazon.com/cli/), and [kubectl](https://github.com/kubernetes/kubectl).\n\n### Completion\n\nRun the following and store the file in your distribution/OS specific spot\n\nbash:\n\n```bash\n$ _K8T_COMPLETE=source k8t > k8t-completion.sh\n```\n\nzsh:\n\n```zsh\n$ _K8T_COMPLETE=source_zsh k8t > k8t-completion.sh\n```\n\n## Concepts\n\nBy combining those concepts you can quickly add completely new environments to your deployment pipeline just by\nmodifying specializing values and sharing the rest.\n\nCheck out our examples [here](examples/).\n\n### *Clusters* and *Environments*\n\nk8t comes with a builtin framework for *clusters* and *environments* (e.g. production, staging). This came from the need to be able to deploy\nthe same application over multiple clusters and in different environments with completely different setups and values.\nThis idea is helped by the fact that k8t deep-merges values and configs, allowing easy variation through different\nstages of your application deployment.\n\nBoth *clusters* and *environments* are intentionally working the same way and can be used to add another degree of freedom when\ncombined. *Environments* however are also available globally, meaning clusters can share environment specific\nconfiguration while specifying differences in those environments.\n\n### Templating\n\nTemplating is supported via [Jinja](https://jinja.palletsprojects.com). k8t also comes with some additional\n[helper functions](#template-helper-functions) and a [validation function](#validate-templates) with verbose output to\nquickly verify the written templates.\n\n#### Template helper functions\n\n* `random_password(N: int)` - generate a random string of length N\n* `envvar(key: str, [default])` - get a value from any environment variable with optional default\n* `b64encode(value: str)` - encodes a value in base64 (usually required for secrets)\n* `b64decode(value: str)` - decodes a value from base64\n* `hash(value: str, [method: str])` - hashes a given value (default using `sha256`)\n* `get_secret(key: str)` - provides a secret value from a given provider (see [here](#managing-secrets))\n* `bool(value: Any)` - casts value to boolean (\"true\", \"on\", \"yes\", \"1\", 1 are considered as `True`)\n* `sanitize_label(value: str)` - sanitizes label values according to kubernetes spec\n* `sanitize_cpu(value: str | int)` - sanitize cpu value to millicores\n* `sanitize_memory(value: str | int)` - sanitize memory value to megabyte (note: values in scientific notation need to be converted to strings)\n* `standardize_cpu(value: str | int)` - standardize cpu value to millicores (as int)\n* `standardize_memory(value: str | int)` - standardize memory value to megabyte (as int; note: values in scientific notation need to be converted to strings)\n\n## Configuration inheritance\n\nConfiguration, values and templates are used according to the scope they are in. The following snippet shows an example project with low scores (1) and high scores (4) for evaluation order.\n\nSo variables and templates will be overridden from `project` -> `environments` -> `clusters` -> `cluster-environments` resulting in more specific configuration overriding lower values.\n\n```bash\n. (1) # k8t new project .\n\u251c\u2500\u2500 clusters\n\u2502 \u251c\u2500\u2500 foo (3) # k8t new cluster foo\n\u2502 \u2502 \u251c\u2500\u2500 config.yaml\n\u2502 \u2502 \u251c\u2500\u2500 values.yaml\n\u2502 \u2502 \u251c\u2500\u2500 environments\n\u2502 \u2502 \u2502 \u251c\u2500\u2500 production (4) # k8t new environment production -c foo\n\u2502 \u2502 \u2502 \u2502 \u251c\u2500\u2500 config.yaml\n\u2502 \u2502 \u2502 \u2502 \u2514\u2500\u2500 values.yaml\n\u2502 \u2502 \u2502 \u2514\u2500\u2500 staging (4) # k8t new environment staging -c foo\n\u2502 \u2502 \u2502 \u251c\u2500\u2500 config.yaml\n\u2502 \u2502 \u2502 \u251c\u2500\u2500 values.yaml\n\u2502 \u2502 \u2502 \u2514\u2500\u2500 templates\n\u2502 \u2502 \u2502 \u2514\u2500\u2500 deployment.yaml.j2 (4) # k8t new template deployment -c foo -e staging\n\u2502 \u2502 \u2514\u2500\u2500 templates\n\u2502 \u2502 \u2514\u2500\u2500 deployment.yaml.j2 (3) # k8t new template deployment -c foo\n\u2502 \u2514\u2500\u2500 bar (3) # k8t new cluster bar\n\u2502 \u251c\u2500\u2500 config.yaml\n\u2502 \u2514\u2500\u2500 values.yaml\n\u251c\u2500\u2500 environments\n\u2502 \u251c\u2500\u2500 production (2) # k8t new environment production\n\u2502 \u2502 \u251c\u2500\u2500 config.yaml\n\u2502 \u2502 \u2514\u2500\u2500 values.yaml\n\u2502 \u2514\u2500\u2500 staging (2) # k8t new environment staging\n\u2502 \u251c\u2500\u2500 config.yaml\n\u2502 \u2514\u2500\u2500 values.yaml\n\u251c\u2500\u2500 config.yaml (1)\n\u2514\u2500\u2500 values.yaml (1)\n\n```\n\n## Usage\n\n### Scaffolding\n\nCreate a new project folder with a cluster directory and an empty defaults file\n\n```bash\n$ k8t new project .\n```\n\nCreate a new cluster\n\n```bash\n$ k8t new cluster MyCluster\n```\n\nCreate a new global environment\n\n```bash\n$ k8t new environment staging\n```\n\nAnd a new cluster environment\n\n```bash\nk8t new environment staging -c MyCluster\n```\n\nGenerate a new deployment template for cluster MyCluster (for a list of available templates see the `k8t new template --help`)\n\n```bash\n$ k8t new template deployment -c MyCluster -e staging\n```\n\n### Config management\n\nTo ease file access a little bit k8t can open config and value files in your `$EDITOR` or fallback to a sensible\ndefault.\n\n```bash\n$ k8t edit values --environment staging\n```\n\n```bash\n$ k8t edit config --cluster MyCluster\n```\n\n### Validate templates\n\nWhile validation is done before generating, templates can be validated for environment files easily.\n\n```bash\n$ k8t validate\n```\n\nTo validate for clusters/environments the usual options can be used\n\n```bash\n$ k8t validate -c MyCluster -e production\n```\n\n#### Shortcomings\n\nThe validation is currently not a 100% correct and can miss certain edge cases. If you notice any other issues please let us know.\n\n##### is defined\n\nThe following will result in a false negative for `foobar` being defined\n\n```\n{{ foobar }}\n\n{% if foobar is defined %}\n{{ foobar }}\n{% endif %}\n```\n\nTo avoid this make sure that the `is defined` test is applied to all instances of the variable.\n\nThe following may result in a false positive for `bar` being undefined\n\n```\n{% if foobar is defined %}\n{{ bar }}\n{% endif %}\n```\n\n### Generate manifests\n\nThe **--cluster** flag will load variables from a directory. By default the file **default.yaml** in that directory will be\nloaded, however an environment can be specified with **--environment**.\n\n```bash\n$ k8t gen -c MyCluster -e staging\n```\n\nAdditionally k8t will attempt to load a file **defaults.yaml** in the root directory. This way a set of default\nvariables can be specified and selectively overriden via cluster and environment.\n\nAdditional values can be given via flag **--value-file** in the form of a file or **--value KEY VALUE**, both can be\nsupplied multiple times.\n\nVariables will be merged via deep merging. Default merge strategy is left-to-right.\n\n### Overriding templates\n\nTemplates can be overriden on a cluster/environment level.\n\nIf a file `application.yaml` exists in the root templates folder, simply add a file with the same name to the\ncluster/environment template folder.\n\n### Managing secrets\n\nSecrets can be interpolated with the helper function `get_secret`. It requires a key as first argument and providers\nare configurable by environment/cluster.\n\n```yaml\nfoobar: \"{{ get_secret('/my-key') }}\"\n```\n\n#### Providers\n\n##### SSM\n\nSetup secrets on SSM\n\n```yaml\nsecrets:\n provider: ssm\n region: \"eu-central-1\"\n prefix: \"/foobar\"\n```\n\n> Keep in mind that SSM parameter names can be formed as a path and they can only consist of sub-paths divided by slash symbol; each sub-path can be formed as a mix of letters, numbers and the following 3 symbols: `.-_`\n>\n> Be careful to follow this format when setting up the provider `prefix` and `get_secret(key)`.\n\nGlobal secrets config can be overridden in `get_secret` helper function call by specifying `config_override` argument.\n\n```yaml\nfoobar: \"{{ get_secret('/my-key', config_override={'prefix': '/dev'}) }}\"\n```\n\n###### role assumption\n\nYou can optionally assume an IAM role to retrieve secrets by specyfing `role_arn` in the config:\n\n```\nsecrets:\n provider: ssm\n region: \"eu-central-1\"\n role_arn: \"arn:aws:iam::account:role/role-name-with-path\"\n```\n\n##### Random\n\nRandom secrets can be generated easily by using the random provider. This provider uses a global dictionary to store\nresults for the time of the run in python so keys should always produce the same result.\n\n```yaml\nsecrets:\n provider: random\n```\n\n##### Hash\n\nIn case consistent (fake) secrets are needed, the `hash` provider can be used that hashes the secret key for the value.\n\n```yaml\nsecrets:\n provider: hash\n```\n### Using as a pre-commit hook\n\nYou can also use this repo as a https://github.com/pre-commit/pre-commit hook\n\nAdd this to your `.pre-commit-config.yaml`:\n\n```yaml\n- repo: https://github.com/ClarkSource/k8t\n rev: '' # Use the sha / tag you want to point at\n hooks:\n - id: k8t-validate\n # args: [ -e dev -c us-west-2 ]\n - id: k8t-generate\n name: k8t(dev)\n args: [ -o dev.yaml -e dev ]\n```\n\n## TODO\n\n* testing needs to be expanded\n* the ability to add additional template directories via the CLI\n* validation functions for template values (e.g. memory/cpu values)\n",
"bugtrack_url": null,
"license": "",
"summary": "Kubernetes templating engine based on Jinja2",
"version": "0.8.3",
"split_keywords": [
"kubernetes",
"jinja",
"multi-cluster",
"templating"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "d5a3183da5d9fc573ac2b9e0560a7d4064b9cd717da595324377ed26b3f44815",
"md5": "0ff78a2e2af6b7576fccd08f7c0d8e62",
"sha256": "c98c1e57141db41f5a81b173786eaf68300c0a80eaed582caa3ebb61b7cf84f8"
},
"downloads": -1,
"filename": "k8t-0.8.3-py3-none-any.whl",
"has_sig": false,
"md5_digest": "0ff78a2e2af6b7576fccd08f7c0d8e62",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": null,
"size": 29800,
"upload_time": "2023-02-09T15:42:37",
"upload_time_iso_8601": "2023-02-09T15:42:37.392389Z",
"url": "https://files.pythonhosted.org/packages/d5/a3/183da5d9fc573ac2b9e0560a7d4064b9cd717da595324377ed26b3f44815/k8t-0.8.3-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "518ebbd04b0143045a2d9e33826498727fc8a673c8faa62590adcae0507f1984",
"md5": "f6632c94db13ab00509bcd71f83e5be2",
"sha256": "22af098f246d0100c94de5d57b9d6f05600b8a7a6bfdf75371089ed6d5cb3623"
},
"downloads": -1,
"filename": "k8t-0.8.3.tar.gz",
"has_sig": false,
"md5_digest": "f6632c94db13ab00509bcd71f83e5be2",
"packagetype": "sdist",
"python_version": "source",
"requires_python": null,
"size": 42513,
"upload_time": "2023-02-09T15:42:38",
"upload_time_iso_8601": "2023-02-09T15:42:38.983369Z",
"url": "https://files.pythonhosted.org/packages/51/8e/bbd04b0143045a2d9e33826498727fc8a673c8faa62590adcae0507f1984/k8t-0.8.3.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2023-02-09 15:42:38",
"github": true,
"gitlab": false,
"bitbucket": false,
"github_user": "ClarkSource",
"github_project": "k8t",
"travis_ci": false,
"coveralls": false,
"github_actions": true,
"circle": true,
"tox": true,
"lcname": "k8t"
}
JSON
