semver VS helmfile

It seems to me that a lot of people are forgetting that when updating to next major version of a package, breaking changes are expected - that's the whole point of major version number in SemVer [1]. What they actually want is seamless updates (or never changing APIs, but that not possible in most situations, and also not what you want as a package developer - you want to be able to correct your API design mistakes). That requires a lot of work from the package developers.

Look for example how people at Remix do it: breaking changes are hidden behind future flags [2], so you a user can turn them on one by one and adapt their code on gradually without surprises. Another solution is creating codemods for upgrades. But how many open-source package developers are willing do to this extra work?

Same story with peer dependencies - they're completely fine, if package developers know how to use them.

As always, don't be mad at React, don't curse Npm, it's not their fault. There is no great package without great effort.

[1] https://semver.org/

You can always check the official Semantic Versioning Specification.

Using Semantic Versioning for version control.

Suppose our pre-pre-production environment is named STAGING, and our pre-production environment is named UAT. STAGING corresponds to the latest commit in the main branch - that's the 'bleeding edge'. UAT corresponds to the latest release candidate tag on the main branch. In semantic versioning, this would be achieved by adding the suffix -rc.N to the name of the release it's targeting. For example, if our goal is to create production release v12.0.0, our UAT environment commits would be tagged v12.0.0-rc.1, then v12.0.0-rc.2, and so on. Suppose on v12.0.0-rc.5 we finally feel confident enough to push to production. We would then add the tag v12.0.0 to the same commit, which would constitute a full release and then be automatically deployed to production.

SemVer.org

If you don't know what semantic versioning is, I suggest you read up on it. In a nutshell, it is a standard/guideline for defining version numbers and how to increase them:

We know that our packages need to have a version. This version follows a format called semantic versioning. This is where the job called generate-version comes in. The output of this job is a version number that will be used when we publish our package in the package-and-publish-lib job.

I frequently need to set a semantic versioning version number when building ASP.NET Core API projects, then read or report this at runtime.

You can install Helmfile by following the instructions on the Helmfile GitHub repository.

Helmfile is a tool that simplifies the management of Helm charts across multiple clusters or environments. It’s ideal for teams that need to maintain tight control over their deployments, allowing them to specify the exact configurations for each cluster in a centralized, declarative way.

Having prepared the charts, we can install them. A common way to install Helm charts into clusters is helm install or helm upgrade --install. But this time, let’s try a more declarative way to do the same thing using helmfile.

What we’re going to install into the newly created AKS cluster is located in the helm directory. The descriptive Helmfile approach enables us to define applications and their settings in the helmfile.yaml file.

Is there any alternative to https://github.com/roboll/helmfile you are currently using in your company.

Interesting, I have approached this problem using Helmfile (https://github.com/roboll/helmfile) to define a “platform release package.”

To make managing the Helm deployments a little easier I used helmfile (https://github.com/roboll/helmfile).

But in general it's always easier to keep things quite separated. Meaning in separate helm releases. If you want to be able to manage things "together" at will, then you can use helmfile ( https://github.com/roboll/helmfile )

I agree; helm is too declarative.

Whenever I can, I use helmfile[0] for storing variables for helm since it does add a declarative layer on top of helm.

0 - https://github.com/roboll/helmfile

I went through the Helmfile repo Readme to figure out the difference between helmfile sync and helmfile apply. It seems like unlike the apply command, the sync command doesn't do a diff and helm upgrades the hell out of all releases 😃. But from the word sync, you'd expect the command to apply those releases that have been changed. There is also mention of the potential application of helmfile apply to periodically syncing of releases. Why not use helmfile sync for this purpose? Overall, the difference didn't become crystal clear, and I though there could probably be more to it. So, I'm asking.