hull VS helm

If you are just starting out and decide to go with writing your own Helm Charts I'd like to suggest our HULL Helm Library Chart for that purpose.

With HULL we have proposed an alternative yet Helm based solution a year ago which that tries to do it upside down by first giving you a documented Kubernetes API style full access to each objects configuration. Only on top of that it provides you further advanced options to (re)introduce abstraction into the mix - only if you need them and they actually improve your configuration. Everything takes place in the values.yaml so there is no digging around in the templates folder and everything is in view.

The HULL library Helm chart provides a single common interface to specifying Kubernetes objects within Helm Charts. The interface itself is based on the Kubernetes API schema itself which is integrated as a JSON schema in the HULL chart. Since all objects are defined directly in the values.yaml under the hull key there is no need to create and maintain custom template files when creating objects with HULL, everything happens in the values.yaml.

Good, now proceed by creating a new empty HULL based Helm chart. The steps are documented here but you will create it from scratch here to understand what is needed.

As a reminder, the goal of this tutorial series is to demonstrate how to build Helm charts based on the HULL library chart by recreating the functionality of the original kubernetes-dashboard Helm chart with a HULL based chart from scratch. When you have followed the previous part of this tutorial on setting up a HULL base chart you have created a for now unconfigured Helm chart named kubernetes-dashboard-hull in the 02_setup subfolder of your working directory (we assume that's ~/kubernetes-dashboard-hull here). You can alternatively download the current chart state here and continue from there. Also you should have checked out and extracted the kubernetes-dashboard Helm chart to kubernetes-dashboard in your working directory because examining it will be frequently required.

the ability to specify any CustomResource as a customresource object instance. For CustomResources you additionally need to specify the kind and apiVersion besides the free form spec of your object.

We have built a Helm Library chart named HULL, it provides amongst other features full access to all defined objects and their properties at creation and deployment time. Think of it as an API to specify Kubernetes objects directly in a Helm charts values.yaml. If there is some functionality you want to add or use in a particular scenario you can just configure it and the Kubernetes objects are as you actually want them to be - every aspect can always be tuned at deploy time if needed without you having to get back to the chart creator via PRs, hack the chart or similar methods. All doable with Helm and the HULL library chart, no other tooling required!

We actually proposed an alternative way to solve the problem if you are Helm with our Helm library chart HULL.

It may be worthwhile to look at the recently added examles, these are more advanced chart values.yamls from products we are deploying this way. You can see it can be pretty concise to define your applications structure with HULL in comparison.

Downsides to this is that you would have to write out the full content of your config in the values.yaml and cannot use the templating capabilities any further. Within the values.yaml no templating is allowed (unless you base your chart on this library chart we have created ;) which may be a more advanced topic if you just got started)

Applying Kubernetes manifests individually is problematic because files can get overlooked. Packaging your applications as Helm charts lets you version your manifests and easily repeat deployments into different environments. Helm tracks the state of each deployment as a "release" in your cluster.

helm

Explanation here: https://github.com/helm/helm/issues/12681#issuecomment-19593...

Looks like it's a bug in Helm, but actually isn't Helm's fault, the issue was introduced by Fedora Linux.

Helm (Get from here https://helm.sh/)

It’s also well understood that having a k8s cluster is not enough to make developers able to host their services - you need a devops team to work with them, using tools like delivery pipelines, Helm, kustomize, infra as code, service mesh, ingress, secrets management, key management - the list goes on! Developer Portals like Backstage, Port and Cortex have started to emerge to help manage some of this complexity.

Kubernetes orchestrates deployments and manages resources through yaml configuration files. While Kubernetes supports a wide array of resources and configurations, our aim in this tutorial is to maintain simplicity. For the sake of clarity and ease of understanding, we will use yaml configurations with hardcoded values. This method simplifies the learning process but isn’t ideal for production environments due to the need for manual updates with each new deployment. Although there are methods to streamline and automate this process, such as using Helm charts or bash scripts, we’ll not delve into those techniques to keep the tutorial manageable and avoid fatigue — you might be quite tired by that point!

Helm is a package manager that automates Kubernetes applications' creation, packaging, configuration, and deployment by combining your configuration files into a single reusable package. This eliminates the requirement to create the mentioned Kubernetes resources by ourselves since they have been implemented within the Helm chart. All we need to do is configure it as needed to match our requirements. From the public Helm chart repository, we can get the charts for common software packages like Consul, Jenkins SonarQube, etc. We can also create our own Helm charts for our custom applications so that we don’t need to repeat ourselves and simplify deployments.

We can search for charts https://helm.sh/ . Charts can be pulled(downloaded) and optionally unpacked(untar).

Generally I felt as if I was diving in the deepest of waters without the correct equipement and that was horrifying. Unfortunately to me, I had to dive even deeper before getting equiped with tools like ArgoCD, and k8slens. I had to start working with... HELM.

Within the architecture of Cyclops, a central component is the Helm engine. Helm is very popular within the Kubernetes community; chances are you have already run into it. The popularity of Helm plays to Cyclops's strength because of its straightforward integration.