ytt
cue
ytt | cue | |
---|---|---|
14 | 109 | |
1,591 | 4,779 | |
1.3% | 1.7% | |
7.0 | 9.8 | |
26 days ago | about 24 hours ago | |
Go | Go | |
Apache License 2.0 | Apache License 2.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
ytt
-
10 Ways for Kubernetes Declarative Configuration Management
YTT - YTT is a templating tool that understands YAML structure. It helps you easily configure complex software via reusable templates and user provided values using the Starlark language.
-
Alternatives to Helm/Kustomize for complex Kubernetes Deployments
Adding https://carvel.dev/ytt/ to the list. I was happy using this tool as IMO it mixes good things from Helm and Kustomize, however the syntax is ugly and repelling my colleagues to have a closer look.
-
The YAML Document from Hell
> Templating yaml is a terrible, terrible idea
I've had a good time using ytt: https://carvel.dev/ytt/. It implements language-aware templating, which is IMO the only reasonable way to do it.
-
Creating Kubernetes Templates
`ytt` is part of the Carvel toolchain. https://carvel.dev/ytt/
-
Dealing with YAML overload
I agree with you on `you will want to see just plain texts instead of a bunch of templating token with hidden logic.` Which is why I think https://carvel.dev/ytt/ would be great. We could generate these templates in pipelines, or we could just make it easier to maintain what we have.
-
How to handle the lifecycle of multiple COTS
For more advanced configuration management you might be interested in ytt ( https://carvel.dev/ytt/ ) which is a "yaml-aware" templating tool. it lets you do "patches" via an overlay mechanism to add or remove specific yaml blocks, and it also lets you use a simplified python dialect for more complicated logic. With ytt you would put your DNS IP into a "data values" file and then run ytt to render it into the configs before handing them off to the deployment tool. e.g. `ytt -f | kubectl apply`
-
The Dhall Configuration Language
I said this above as well: ytt (https://carvel.dev/ytt/) lets you embed starlark into valid yaml, among other cute tricks for managing biz-logic in configs.
-
ArgoCD Instance per kubernetes cluster? (staging and prod)
Manifests are generated with ytt (https://carvel.dev/ytt/).
- Dynamically creating yaml manifests?
-
YAML and Configuration Files
This is why you should consider https://carvel.dev/ytt/
cue
-
TypeSpec: A New Language for API-Centric Development
If you are in a situation where you have a backend and you want to expose an API and then you would eventually want a client, you would need format specs as the starting point where server and clients are generated from that one source.
At the moment, OpenAPI with YAML is the only way to go but you can't easily split the spec into separate files as you would do any program with packages, modules and what not.
There are third party tools[0] which are archived and the libraries they depend upon are up for adoption.
In that space, either you can use something like cue language 1] or something like TypeSpec which is purpose built for this so yet, this seems like a great tool although I have not tried it yet myself.
[0]. https://github.com/APIDevTools/swagger-cli
[1]. https://cuelang.org/
EDIT: formating
-
Show HN: Workout Tracker – self-hosted, single binary web application
Where `kube.cue` sets reasonable defaults (e.g. image is /). The "cluster" runs on a mini PC in my basement, and I have a small Digital Ocean VM with a static IP acting as an ingress (networking via Tailscale). Backups to cloud storage with restic, alerting/monitoring with Prometheus/Grafana, Caddy/Tailscale for local ingress.
[1] https://www.talos.dev/
[2] https://cuelang.org/
-
Apple releases Pkl – onfiguration as code language
I've been somewhat surprised that CUE bills itself as "tooling friendly" and doesn't yet have a language server- the number one bit of tooling most devs use for a particular language.
I'm assuming it's becaus CUE is still unstable?
Anyway, if others are interested in CUE's LSP work, I think https://github.com/cue-lang/cue/issues/142 is the issue to subscribe to
-
Why the fuck are we templating YAML? (2019)
This is where I usually pitch in with "Have your heard of CUELang, our lord and savior?": https://cuelang.org/
- Not turing complete
-
10 Ways for Kubernetes Declarative Configuration Management
CUE: The core problem CUE solves is "type checking", which is mainly used in configuration constraint verification scenarios and simple cloud native configuration scenarios.
-
Lua is a viable alternative for JSON
If you really want executable configurations please consider a newer language like https://dascript.org or https://cuelang.org which provide better type safety.
1- https://news.ycombinator.com/item?id=38030778
-
Writerside – a new technical writing environment from JetBrains
Markdown and XML are nice, but what about more advanced documentation formats like OpenAPI? For one recent project, I set up automatic generation of the OpenAPI docs from (much more compact and flexible) CUE definitions (https://cuelang.org/) - which has the bonus of also being able to test the API against the definitions. JetBrains has a CUE plugin, but it's really barebones (doesn't even support jumping from the usage of a schema to its definition). Of course the possibilities when generating docs are endless (just think of the various syntaxes for doc comments, embedding examples/tests in source code etc.)...
-
Show HN: Config-file-validator – CLI tool to validate all your config files
It doesn't include validators for TOML and INI, but if you're doing JSON and YAML, I would take a look at using or building upon CUE (https://cuelang.org/). It is a different take on schema definition (plus more), and is surprising terse and powerful model.
- That's a Lot of YAML
- An INI Critique of TOML
What are some alternatives?
kustomize - Customization of kubernetes YAML configurations
dhall-lang - Maintainable configuration files
cue - CUE has moved to https://github.com/cue-lang/cue
jsonnet - Jsonnet - The data templating language
tanka - Flexible, reusable and concise configuration for Kubernetes
terraform - Terraform enables you to safely and predictably create, change, and improve infrastructure. It is a source-available tool that codifies APIs into declarative configuration files that can be shared amongst team members, treated as code, edited, reviewed, and versioned.
strictyaml - Type-safe YAML parser and validator.
starlark-rust - A Rust implementation of the Starlark language
hull - The incredible HULL - Helm Uniform Layer Library - is a Helm library chart to improve Helm chart based workflows
Protobuf - Protocol Buffers - Google's data interchange format
yaml-rust - A pure rust YAML implementation.
jsonnet-libs - Grafana Labs' Jsonnet libraries