Commit Graph
96 Commits
Author SHA1 Message Date
Myasnikov Daniil b83cc087cc docs: move the repo-only guides onto the website
Seven guides in docs/ were written next to the code and left in the
source tree, where no operator looks. The website carries them now, so
a second copy here only lets the two drift again: the Backup Classes
page had already fallen behind its original.

docs/release.md, docs/deprecating-applications.md and the two SeaweedFS
runbooks in docs/operations stay. A migration, a bats suite, a workflow
or AGENTS.md reads each of them by path, which is the test for keeping
a document in this repository.

Assisted-by: LLM
Signed-off-by: Myasnikov Daniil <myasnikovdaniil2001@gmail.com>
2026-10-21 17:50:46 +05:00
Mattia Eleuteri bb3ddee233 fix(rabbitmq): bound the topology operator Secret cache
messaging-topology-operator 1.14.2 caches every Secret in the cluster: its
ClusterRole grants secrets list/watch cluster-wide with no namespace or label
restriction, so the controller-runtime cache holds the whole set. Against the
vendored 500Mi limit this OOMKills on any cluster that has grown enough
Secrets, and it never recovers, because the initial LIST alone no longer fits.
While it is down no topology CR reconciles, for any tenant.

Observed on a cluster with 8211 Secrets across 291 namespaces (293 MB, 87% of
it Helm release history): a flat 333Mi working set for days, then the ceiling,
then a permanent crashloop. The operator was caching 8211 Secrets to read 2.

Upstream fixed this by gating the Secret informer on a label, released in
v1.20.0, and by bypassing the cache for Service reads, released in v1.20.1.
Refresh the vendored manifest to v1.20.2, the current patch release carrying
both, through the package's existing make update pipeline.

The bump alone would break every install: the app chart's credentials Secret is
referenced by User.spec.importCredentialsSecret, and from 1.20 the admission
webhook rejects a user-provided Secret that does not carry
rabbitmq.com/topology-operator=true. Label it in the same change, pin the
label in the chart's unit tests, and give the e2e RabbitMQ a user so the
webhook and the User reconcile are exercised against the real operator.

The RabbitmqCluster default-user Secret needs no label, it is read uncached via
apiReader, and the Status.Binding contract is unchanged since 1.14.2, so the
vendored cluster-operator 2.9.0 stays compatible and does not move here.

Refs #4128

Signed-off-by: Mattia Eleuteri <mattia@hidora.io>
Assisted-by: LLM
2026-09-29 17:08:17 +02:00
Yan Bondarenko cdcb2710cd docs(apps): correct the shared resources and preset paragraphs
Two sentences of the boilerplate shared by the app READMEs were wrong.
"When left empty, the preset is applied" described an all-or-nothing
rule, but cozy-lib.resources.defaultingSanitize merges per key: every
resource that resources leaves unset comes from the preset. And the
legacy flat names were called aliases of their "1:1 instance-type
equivalents", which reads as the c1 series; nano through small match t1,
and medium matches c1.small rather than c1.medium, the trap
docs/operations/resource-presets.md already warns about.

Signed-off-by: Yan Bondarenko <202671653+yankawai@users.noreply.github.com>
2026-09-23 01:20:50 +03:00
Yan Bondarenko 78f01d5542 docs(rabbitmq): point the preset section at the shared size matrix
The preset table in this README listed the seven legacy aliases only, and
its CPU column disagreed with cozy-lib on every row, so a reader looking up
what the new s1.nano default buys them found neither the name nor a correct
number. Nine app READMEs already replaced that table with the two paragraphs
that describe the <series>.<size> convention and link the full matrix in
docs/operations/resource-presets.md; this README now carries the same text.

Assisted-by: LLM
Signed-off-by: Yan Bondarenko <202671653+yankawai@users.noreply.github.com>
2026-09-22 17:47:55 +04:00
Yan Bondarenko 6d5666f7e6 fix(rabbitmq): describe the preset as filling what resources leaves unset
cozy-lib merges the preset under resources key by key, so a partially set
resources map still takes the preset for everything it omits: with
resources.cpu=700m alone the broker renders 700m of CPU against the
preset's 512Mi of memory, and this upgrade moves that broker from 128Mi to
512Mi as well. The description said the preset applies when resources is
omitted, and cozyvalues-gen copies it verbatim into values.schema.json, the
README parameter table and the cozyrd openAPISchema the dashboard renders,
so one sentence made the claim on three surfaces.

The suite covered a fully omitted resources map and one that sets both cpu
and memory, which is the one shape that does not exercise the merge. The
new case pins it: reverting defaultingSanitize to replace the preset
instead of merging over it turns that case red and leaves the other three
green.

Assisted-by: LLM
Signed-off-by: Yan Bondarenko <202671653+yankawai@users.noreply.github.com>
2026-09-22 17:47:55 +04:00
Yan Bondarenko 03394bd5fe chore(rabbitmq): drop the test target the rebase duplicated
main already carries a test target at the bottom of the Makefile; the rebase
kept the earlier copy at the top and GNU make warns about the override. The
Makefile matches main again.

Assisted-by: LLM
Signed-off-by: Yan Bondarenko <202671653+yankawai@users.noreply.github.com>
2026-09-22 17:47:55 +04:00
Yan Bondarenko cf749988a4 fix(rabbitmq): right-size the default resources preset to s1.nano
Signed-off-by: Yan Bondarenko <202671653+yankawai@users.noreply.github.com>
Assisted-by: LLM
2026-09-22 17:47:55 +04:00
Aleksei Sviridkin e104c39f55 docs(rabbitmq): say that deleting the application leaves the TLS Secrets behind
The README covered only the disable path. Deleting the application hits
the same cert-manager behaviour: the chart renders Certificate and Issuer
objects and never the Secrets, and cert-manager does not own what it
issued, so the CA and server private keys stay in the tenant namespace
with nothing referencing them. Name the two Secrets and the cleanup.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-07 21:59:35 +03:00
Aleksei Sviridkin d000d02b99 feat(rabbitmq): add TLS support for AMQPS and management HTTPS (#2683)
## What this PR does

Adds TLS for AMQP and the management API, and hands the tenant a
key-free trust anchor instead of a private key.

- A chart-authored cert-manager chain issues the broker certificate. The
chart names its CA Secret in a `TenantProjection` sentinel; the
CA-extraction controller reads `ca.crt` from that Secret and writes a
key-free projection, stamping `internal.cozystack.io/tenant-ca` on the
projection it owns. That label is what the ResourceDefinition selects.
Nothing labels the CA Secret itself, which holds the CA private key and
is excluded by name.
- The leaf `<release>-tls` carries the broker's private key and reaches
no tenant. Neither the dashboard Role nor the ResourceDefinition grants
it, and the ResourceDefinition excludes it by name as well, so a label
mis-stamped onto it later still does not get through.
- SAN coverage now lists every resolvable form explicitly, including the
bare `*.<release>-nodes` wildcard that the operator uses for
`RABBITMQ_NODENAME`.

## TLS is opt-in here, unlike the sibling charts

`tls.enabled` defaults to `false` and is not inferred from `external`.
That diverges from nats, qdrant and kafka, which infer it, and the
divergence is deliberate for a reason specific to this operator.

Setting `spec.tls.secretName` makes the cluster operator rewrite the
`port` key in the `<release>-default-user` Secret from 5672 to 5671, on
the mere fact of TLS and regardless of whether the plaintext listener is
still open. That Secret is the Service Binding the chart hands the
tenant. A client with a hardcoded `:5672` keeps working. A client that
reads the endpoint from the binding, which is the documented way, gets
moved to the TLS port and must then speak TLS and be given a CA to
verify against, neither of which it was configured for. Inferring TLS
from `external` would fire all of that on an ordinary upgrade, with no
configuration change, against exactly the clients that followed the
documentation.

Whether the other engines should follow is an epic-level question rather
than this PR's to answer; for nats it is raised in #3348.

## The plaintext ports are still published, and this PR says so

There is no operator-supported way to publish the TLS ports alone.
`spec.override.service.spec.ports` is a strategic merge keyed on `port`
against defaults the operator rebuilds every reconcile, so it adds and
mutates entries but never subtracts one, and a TLS-only port list there
would read as a guarantee while changing nothing. The chart renders no
service override at all and says why at the callsite.

`tls.disableNonTLSListeners` is offered as an explicit opt-in, and it
refuses to render rather than failing silently in three situations.

- Together with `users` or `vhosts`. The flag forces
messaging-topology-operator onto TLS regardless of its own
configuration, after which it verifies the broker against the system
certificate pool, where a per-release CA cannot be. Every topology
object bound to the release would stop reconciling, silently:
already-created users keep working while password rotation and new users
simply never apply. There is no working route left for it, so the chart
refuses instead. Managing those objects as hand-written CRs is not a way
out, because the operator takes TLS from the `RabbitmqCluster` and not
from whoever created the CR, so manual objects break identically and
without the render-time refusal. `rabbitmqctl` or a definitions import
are.
- While topology objects are still live in the namespace. See the next
section.
- With TLS off, where no listener of either kind would remain.

Erlang distribution (25672) and epmd (4369) stay plaintext under every
setting; the flag does not touch them, so `disableNonTLSListeners: true`
is not "TLS everywhere".

A third route, closing AMQP at the broker through
`spec.rabbitmq.additionalConfig` while leaving the operator on plaintext
management, has been suggested and is plausible, but the operator's
sources are not vendored here and it was not verified. It is recorded as
an open question rather than promised.

## Closing the listeners takes two upgrades, and the chart enforces it

Clearing `users` and `vhosts` and setting `tls.disableNonTLSListeners:
true` in one edit is the natural thing to try, and it wedges the objects
being removed. The values-level refusal cannot catch it, because by then
both maps are empty. Helm applies every object in the target release
before pruning the ones the release dropped, so the broker closes
plaintext and loses the `rabbitmq.com/operator-connection-uri`
annotation while the topology objects still hold
`deletion.finalizers.<plural>.rabbitmq.com`. Their operator then has to
reach a management API it can only get to over a certificate it verifies
against the system trust pool. The delete never completes, and the
upgrade reports success over objects left in `Terminating`, with the
users still live in the broker and `kubectl delete namespace` on that
tenant hanging.

The chart now reads the namespace rather than the values. When the flag
is being introduced and any topology object is still there, the render
refuses and names them, gives the two-upgrade order and the `kubectl
get` that confirms nothing bound to this release is left, and says how
to unwedge a release that is already stuck. The check keys on the live
`RabbitmqCluster` as well, so it applies only to the transition: once
the listeners are closed, an object a tenant creates afterwards is
theirs to clean up rather than something that stops the release
rendering. Eleven unit cases cover the firing and the silent paths.

The set is wider than the three kinds this chart creates. All twelve
kinds `messaging-topology-operator` drives through its shared
`TopologyReconciler` carry that finalizer and share one deletion path,
so a `Queue` or a `Shovel` written by hand against the release wedges
exactly the same way, and a runbook step that checks only users, vhosts
and permissions says the namespace is clear when it is not. The list is
derived in one place and read from both the lookup and the `kubectl get`
the refusal prints, and a unit test holds it against the operator's own
CRDs so a bump cannot introduce a kind the guard has never heard of.
`SuperStream` is the one CRD left out: it runs on its own reconciler
with no finalizer, and the objects it owns are already on the list. An
object that binds through `connectionSecret` instead of naming the
cluster stays outside the guard, which the comment says.

## Breaking for metrics scrapers

Enabling TLS moves the metrics endpoint from 15692 to 15691. A
ServiceMonitor selecting the port by the name `prometheus` silently
stops matching and the instance's metrics disappear with no error
anywhere. Nothing in this repository scrapes RabbitMQ, so only
user-defined monitoring is affected, silently, which is why it is stated
here.

## Known limitations

1. Turning TLS back off leaves the raw CA material behind. The anchor
itself is collected: the projection carries an owner reference to the
`TenantProjection` sentinel, and Helm deletes the sentinel along with
the rest of the chain. What survives is `<release>-ca` and
`<release>-tls`, because cert-manager runs with
`enableCertificateOwnerRef: false` and does not delete the Secrets it
issued, so the README says to remove them by hand. #3349 asks the same
question of the label-driven leg of the contract, which this chart does
not use.
2. No e2e coverage for the TLS path. The one-upgrade wedge above is the
case that most deserves it: install with TLS and users, upgrade to no
users plus the flag, and assert the `User` is actually gone rather than
merely marked for deletion. A template test cannot reach that.

On certificate renewal, the leaf carries `duration: 8760h` and
`renewBefore: 720h`, so cert-manager rewrites the Secret around day 335.
The cluster operator mounts it as a projected volume with no `subPath`,
so the kubelet refreshes the files in place, and the operator does not
watch a user-supplied TLS Secret, so nothing rolls the pods. The last
hop, the broker picking the new file up, rests on Erlang's
`ssl_pem_cache` re-reading by mtime and has only been read from sources
rather than exercised against a live broker. The merged qdrant chart
ships the same duration and `rotationPolicy`, so this is a platform-wide
property rather than something this PR introduces.

### Downstream repositories

`packages/apps/rabbitmq/values.schema.json` gains the `tls` object, so
`cozystack/terraform-provider-cozystack` needs the field modelled for
`cozystack_rabbitmq`; tracked in
cozystack/terraform-provider-cozystack#42.

### Release note

```release-note
feat(rabbitmq): opt-in TLS for AMQP and the management API, with the CA published to tenants as a key-free trust anchor. Enabling TLS moves the metrics port from 15692 to 15691 (ServiceMonitors selecting the port named `prometheus` must be updated) and moves the `port` value in the `<release>-default-user` binding Secret from 5672 to 5671. Plaintext AMQP and management ports remain published; `tls.disableNonTLSListeners` closes them but also drops in-cluster plaintext clients, and must be enabled in a separate upgrade after the topology objects are gone.
```
2026-09-07 18:51:34 +04:00
Aleksei Sviridkin 3c5d9f49e5 docs(rabbitmq): scope the runbook check and close the narrower-variant question
The confirmation step told the operator to wait for an empty namespace,
while the guard it confirms deliberately ignores objects naming another
release. A tenant running two brokers in one namespace would wait for
something that never happens. Say the check is release-scoped, in the
README and in the refusal.

Closing AMQP through additionalConfig while keeping the operator on
plaintext management was recorded as an open question. It is answerable:
cluster-operator pins the readiness probe to the amqp port unless
disableNonTLSListeners is set, so that configuration leaves every pod
failing readiness. Stated instead of left open.

Also repoint one template reference at the heading that exists, and name
the runbook test after what it compares.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-07 03:13:15 +03:00
Aleksei Sviridkin 2f6c1554ed docs(rabbitmq): correct two TLS mechanisms the prose states wrongly
The helper comment says a HelmRelease override carrying `tls: null`
reaches the chart unpruned and is accepted by values.schema.json.
Helm's coalescing drops the key instead, so the schema never sees a
null and `.Values.tls` is nil rather than an empty dict. The `dig` on
a defaulted dict is still what stops the panic; only the account of
how the value arrives was wrong.

The README says the flag forces the topology operator onto TLS
regardless of how it is configured. The connection-uri annotation
short-circuits that calculation before it is reached, so the reason
the flag wins is that the port the annotation names is the port the
flag closes, which is why the chart withdraws it.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-07 02:54:55 +03:00
Aleksei Sviridkin 69155919b4 fix(rabbitmq): refuse on every topology kind that wedges
The refusal that stops tls.disableNonTLSListeners from closing the
plaintext listeners under live topology objects iterated User, Vhost
and Permission, the three kinds the chart itself creates. All twelve
kinds messaging-topology-operator drives through TopologyReconciler
carry the same deletion.finalizers.<plural>.rabbitmq.com finalizer and
share one deletion path, so a Queue or a Shovel bound to the release
wedges identically while the render passes and the runbook step
reports the namespace clear.

Derive the list once in a template helper, read it from both the
lookup loop and the confirmation command the refusal prints, and widen
the README runbook to the same set. SuperStream stays out: its own
reconciler sets no finalizer, and the Queue, Exchange and Binding
objects it owns are already on the list.

An object that binds through connectionSecret rather than by cluster
name is still outside the guard, which the comment now says.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-07 02:27:41 +03:00
Aleksei Sviridkin 2d6a18888d docs(rabbitmq): name caSecretName for what the operator does with it
The README and the TLS suite called spec.tls.caSecretName the inter-node
mTLS knob and said the chart leaves it unwired. The field has nothing to
do with Erlang distribution: under it the operator writes
ssl_options.cacertfile, ssl_options.verify = verify_peer, and a cacertfile
for the management and metrics listeners, every one of them client-facing.
The cluster-operator this platform ships carries no distribution TLS under
any field, so there was no inter-node path to leave unwired either.

Say what the field does at each place it is named, and give the
client-verification section the operator field it was missing, along with
the reason verify_peer on its own does not make a client certificate
mandatory.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 12:14:48 +03:00
Aleksei Sviridkin a1f512664a fix(rabbitmq): shorten the refusals that land in a release condition
Both messages ran 700-800 characters. They surface in a HelmRelease
condition read through kubectl describe, which truncates, so the part an
operator needs was the part most likely to be cut. Keep the objects that
block, the two-upgrade order, the command that confirms the namespace is
clear and a pointer to the README section; the mechanism is already there
in full.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:48:24 +03:00
Aleksei Sviridkin 2d2f2d1ecb docs(rabbitmq): argue the opt-in default from timing, not availability
The paragraph closed by saying TLS moves clients before there is a
key-free way to hand them the CA. This chart ships that way, and the
section two headings down documents it. The reason the default holds is
that the move lands the instant the flag is set, before any client has
had a chance to pick the trust anchor up.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:48:16 +03:00
Aleksei Sviridkin 824fbefeef docs(rabbitmq): drop the Role header the rule below already carries
The file header and the block at the secrets rule both said no TLS Secret
is granted in either TLS state. The one at the rule is where a reader
editing the grant will be looking.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:48:15 +03:00
Aleksei Sviridkin 9e6465d093 fix(rabbitmq): scope the topology-object refusal to this release
A tenant namespace holds every RabbitMQ application the tenant runs, and
the listing enumerated all of them. A second instance with users kept the
first from ever closing its listeners, and the refusal named the other
application's objects and told the operator to delete them. The mechanism
behind the refusal does not reach that far either: a sibling's topology
objects are reconciled through their own broker, whose listeners this flag
leaves alone.

Read spec.rabbitmqClusterReference.name and keep only the objects that
name this release. The hand-written fixture gained the reference it was
missing, which is what hid the gap, and a sibling release now has a case
of its own.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:45:04 +03:00
Aleksei Sviridkin e521c3b8c7 test(rabbitmq): isolate the external gate on the platform-host SAN
Every existing case with external: false also left _namespace.host unset,
so the platform host stayed out of the SAN list because no host was
supplied, not because the gate held. Replacing the gate with a constant
left the suite green. Supply a host with external: false so the gate is
the only thing deciding.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:28:37 +03:00
Aleksei Sviridkin fcab5dbb07 docs(rabbitmq): carry the TLS consequences to where the toggle is rendered
cozyvalues-gen propagates the @field line and nothing under it, so the
description reaching values.schema.json, the README table and the
dashboard form said only that TLS turns on, while the continuation lines
holding the breaking part of the change stayed in values.yaml. Fold the
listener, binding-port and metrics-port moves into the @field line, and
leave the continuation with the part that is genuinely about the struct.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:28:04 +03:00
Aleksei Sviridkin 0d8a5c7941 docs(rabbitmq): keep the Certificate rationale out of the applied object
Two comment blocks in certmanager.yaml used `#`, which the renderer does
not strip, so fourteen lines of prose about the sentinel wiring and the CA
rotation policy were copied verbatim into every Certificate the chart
applies. The rest of the file already explains itself with Go-template
comments; use those here too, and cut the parts the README carries.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:26:32 +03:00
Aleksei Sviridkin fd9b96b2c5 fix(rabbitmq): refuse to close the plaintext listeners in one upgrade
Clearing users and vhosts and setting tls.disableNonTLSListeners in the
same edit rendered cleanly, because the existing refusal reads values and
both were already empty by then. Helm applies every object in the target
release before pruning the ones the release dropped, so the broker closed
plaintext and lost the operator-connection-uri annotation while the User,
Vhost and Permission objects still held their deletion finalizers.
messaging-topology-operator then had to reach the management API over a
certificate it verifies against the system trust pool, which cannot hold
a per-release CA, so the delete never completed and the upgrade reported
success over objects left in Terminating.

Read the topology objects actually present in the namespace instead, and
only while the flag is being introduced, so a release that already closed
its listeners keeps rendering and an object created afterwards does not
block it. Both refusals and the README now carry the two-upgrade order,
the command that confirms the namespace is clear, and the way back out.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:24:51 +03:00
Aleksei Sviridkin e04c5c62a3 fix(rabbitmq): create the tenant-ca projection the Role relies on
The dashboard Role already refuses to grant the key-bearing TLS
Secrets, but nothing in the chart told the CA-extraction controller
to publish the key-free trust anchor those Secrets feed: no
TenantProjection sentinel referenced the CA Certificate's Secret as
a source. Without that sentinel the controller has nothing to act
on, so rabbitmq-<name>.tenant-ca is never created and a tenant has
no path to the CA at all, contrary to what the README and the Role's
own comments describe.

Add templates/tenant-projection.yaml, gated on the same TLS
condition as the certificate chain and mirroring the nats and qdrant
charts: it names the CA Certificate's Secret as the projection
source. Drop the internal.cozystack.io/publish-ca-cert labels from
certmanager.yaml, since the controller resolves its source by name
through the sentinel rather than by a label on the Secret, and
correct the comments and README passage that described that label as
the actual publication mechanism.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:48 +03:00
Aleksei Sviridkin ff56ebae72 docs(rabbitmq): cut the values.yaml TLS prose to the callsite facts
The annotation block restated the README's TLS section nearly verbatim.
Only the @param and @field lines reach the generated schema and README
table; the rest was a second copy that would drift against the first.

Keeps the three facts that change what a caller sets — neither field is
inferred from external, enabling TLS moves the binding port, and
disableNonTLSListeners is not external-only — and points at the README.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:48 +03:00
Aleksei Sviridkin 411a3d6c02 docs(rabbitmq): cut template comments duplicating the README
The TLS comments had grown to narrate rejected alternatives and operator
internals at length, roughly matching the volume of configuration they
annotate. The README already carries every long-form explanation, so the
duplicates are prose that will drift out of sync with it.

Each block keeps the mechanism a next editor needs to avoid breaking
something and points at the README section holding the rest.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:47 +03:00
Aleksei Sviridkin a0efa75dd2 fix(rabbitmq): add the missing bare pod-wildcard SAN
The certificate covered the client and headless Services in all four
resolvable forms but gave the pod wildcard only three: bare
*.<release>-nodes was absent. A client in the broker's own namespace
dialling <pod>.<release>-nodes resolves through the DNS search path,
connects, and fails only at hostname verification — which reads as a
certificate bug rather than a missing name, the exact failure the
four-form rule exists to prevent.

The suite asserted the headless forms with contains, so it stayed
green for the form nobody listed; it now pins the whole list.

Also drops key encipherment from the leaf usages: it authorises RSA
key transport and the key is ECDSA, so it requested a capability the
key type cannot supply.

Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:47 +03:00
Aleksei Sviridkin 52e60935e9 docs(rabbitmq): correct the disableNonTLSListeners escape hatch
The refusal message and the README told the reader to manage users and
vhosts outside the chart. That reads as an instruction to move them
into hand-written User/Vhost/Permission objects, which fails the same
way: the topology operator derives its connection from the
RabbitmqCluster, not from who created the CR, so those objects break
identically and without the chart's refusal to warn anyone.

Say what the flag actually costs — the cluster leaves that operator's
reach entirely — and point at rabbitmqctl or a definitions import.

Also narrows the claim that no option closes plaintext: a variant
through spec.rabbitmq.additionalConfig looks reachable but is not
wired or validated here, so it is named as an open question rather
than left implicitly denied.

Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:47 +03:00
Aleksei Sviridkin 636228f706 test(rabbitmq): pin the operator connection URI to the cluster domain
Every existing assertion on rabbitmq.com/operator-connection-uri ran on
the default domain, so a hardcoded cozy.local would have satisfied all
of them. On a cluster with its own cluster-domain that URI does not
resolve and messaging-topology-operator loses the broker outright, so
the case that distinguishes the two is worth having.

Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:46 +03:00
Aleksei Sviridkin 4e3d9cd784 docs(rabbitmq): drop the TLS claims that only held under inheritance
The TLS scope section described an upgrade that turns TLS on by itself
and told the reader to set tls.enabled: false to avoid it. Neither is
true now that the field defaults to false: the rolled pods, the
cert-manager dependency, the metrics port swap and the rewritten
binding port are all consequences of an explicit edit, so they are
described that way.

Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:46 +03:00
Aleksei Sviridkin 36ee8a2608 feat(rabbitmq): make TLS opt-in instead of following external
tls.enabled inherited the value of external when unset, so enabling
external access also enabled TLS. That is not free on an existing
instance: setting spec.tls.secretName makes the operator rewrite the
port key of the <release>-default-user Secret from 5672 to 5671, and
that Secret is the Service Binding handed to the tenant. Every client
resolving its endpoint from the binding — the documented way — would
move onto TLS on upgrade and have to verify a per-release CA it has no
key-free way to obtain.

Resolve unset, null and false to false instead, so TLS is only ever on
because someone asked for it. enabled becomes a plain bool now that
there is no third state to express.

Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:45 +03:00
Aleksei Sviridkin dd04377e71 docs(rabbitmq): trim template comments to what the callsite needs
The template had grown to roughly 60% comment prose, most of it restating the
README verbatim — the strategic-merge-patch reasoning, the topology-operator TLS
derivation and the disableNonTLSListeners scope each existed in two places that
can drift apart, and the README is the copy users read. Several also carried
review-thread voice ("both directions are deliberate", "refuse the contradiction
rather than drop it") rather than describing the artifact.

Keep at each callsite only the facts an editor needs before touching that line —
why the override exists in neither direction, why the connection URI is pinned to
plaintext, what the flag does not cover — and let the README own the rest.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:45 +03:00
Aleksei Sviridkin 8e48cfc8fd fix(rabbitmq): refuse contradictory TLS settings and correct the upgrade note
Two things this change got wrong about its own behaviour.

tls.disableNonTLSListeners was silently discarded whenever TLS resolved to off,
because the value was folded into the TLS condition before anything read it.
Asking to close the plaintext listeners with TLS off leaves nothing listening,
and the operator rejects the combination itself, returning "TLS must be enabled
if disableNonTLSListeners is set to true" and setting ReconcileSuccess=False.
Swallowing it in the chart was worse than what the operator does: the operator
at least records a TLSError event, while a dropped flag rendered a
healthy-looking cluster with every plaintext listener open and no trace of the
request. The likeliest way in is an operator hardening an internal broker who
sets only the flag, since tls.enabled follows external and so resolves to false
there. Fail with a message naming tls.enabled instead.

The README also claimed messaging clients are unaffected by enabling TLS. That
holds only for a client with a hardcoded port. <release>-default-user is the
Service Binding object the chart grants to the tenant, and the operator rewrites
its port key from 5672 to 5671 as soon as spec.tls.secretName is set — gated on
TLS alone, not on whether the plaintext listener stayed open — along with the
per-plugin port keys. A binding-driven client, which is the documented way to
consume it, follows that change and must speak TLS from then on, without being
able to verify the certificate until the trust anchor is obtainable. Say so.

Also record that the connection-uri annotation fans out: the operator's
annotation filter strips only kubernetes.io and k8s.io keys, so it lands on every
child object including the Secret the tenant reads.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:45 +03:00
Aleksei Sviridkin d668dfbd6a feat(rabbitmq): add opt-in switch to close the plaintext listeners
TLS so far only added encrypted endpoints; nothing closed the unencrypted ones,
and the chart had no way to express the intent. tls.disableNonTLSListeners gives
the operator that switch, defaulting to false so an upgrade never closes a
listener a client is already using — the choice to break plaintext has to be
made deliberately.

Its reach is worth stating plainly, because the natural reading is wrong in both
directions. It writes `listeners.tcp = none` into rabbitmq.conf, which is broker
level: the socket is not opened on any interface, so in-cluster clients lose
plaintext at the same instant external ones do, and there is no configuration
that closes it outside while keeping it inside. In the other direction it is not
"TLS everywhere" either — Erlang distribution on 25672 and epmd on 4369 ride the
headless Service, which the flag never touches, so inter-node traffic stays in
the clear regardless.

The flag also cannot coexist with chart-managed users. messaging-topology-operator
derives its connection as TLSEnabled() && (!connectUsingHTTP ||
DisableNonTLSListeners()), so the flag forces TLS on that side whatever the
operator's own configuration says, and it verifies the broker against
x509.SystemCertPool(), which cannot hold a per-release CA. The connection-uri
annotation is no escape, since it would point at the port the flag just closed —
so that annotation is now omitted when the flag is set, rather than advertising a
closed port. Every User, Vhost and Permission would silently stop reconciling.
Rendering fails instead, naming the conflict, and the flag stays usable for an
instance whose users and vhosts are managed outside the chart.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:44 +03:00
Aleksei Sviridkin 6f1ada4159 fix(rabbitmq): add the two-segment wildcard SAN for pod addresses
The SAN list covered every Service name in all resolvable forms but applied the
rule only to the non-wildcard entries, leaving the per-pod wildcard with .svc and
.svc.<domain> and no two-segment form. That is the form the operator itself uses:
RABBITMQ_NODENAME is rabbit@$(MY_POD_NAME).$(K8S_SERVICE_NAME).$(MY_POD_NAMESPACE)
and K8S_HOSTNAME_SUFFIX matches, so <pod>.<name>-nodes.<namespace> is the
canonical pod address rather than an incidental alias, and it is the form the
upstream API documentation shows to users.

A client dialling a pod by that name resolves it through the DNS search path,
connects, and fails only at hostname verification — which presents as a
certificate bug rather than a missing name. It would also break outright the
moment inter-node mTLS is wired through caSecretName.

Move the clusterDomain helper above the tri-state doc block while here, so each
comment sits next to the definition it describes.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:44 +03:00
Aleksei Sviridkin 2f42cd6baf fix(rabbitmq): keep the topology operator on the plaintext management port
Setting spec.tls.secretName makes RabbitmqCluster.TLSEnabled() true, and
messaging-topology-operator derives its own connection from that:

    useTLSForConnection = TLSEnabled() && (!connectUsingHTTP || DisableNonTLSListeners())

connectUsingHTTP comes from CONNECT_USING_PLAIN_HTTP, which the shipped
Deployment does not set, so the expression collapses to TLSEnabled(). The
operator would dial https://<release>:15671 and verify it against
x509.SystemCertPool() — a process-wide pool that cannot contain a per-release
self-signed CA. Every User, Vhost and Permission this chart renders from users
and vhosts would fail with "certificate signed by unknown authority".

The failure is quiet, which is what makes it worth guarding: users already
applied to the broker keep working, so nothing looks wrong, while password
rotation, new users, new vhosts and permission changes all stop taking effect.

Annotate the cluster with rabbitmq.com/operator-connection-uri on the plaintext
management port when TLS is on. extractURIandScheme reports tlsEnabled=false for
an http:// scheme, so the operator keeps using the listener the chart
deliberately leaves open — that listener is load-bearing, not merely tolerated,
and the README now says so. Only the operator's management connection is
affected; broker traffic is untouched.

Also add the two-segment <name>.<namespace> SANs for both the client and headless
Services. That form resolves through the DNS search path, so a client connecting
to amqps://<name>.<namespace>:5671 reached the broker and failed only at hostname
verification — which presents as a certificate bug rather than a missing name.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:44 +03:00
Aleksei Sviridkin b4c66f2b55 docs(rabbitmq): record the metrics port change when TLS is enabled
Enabling TLS swaps the published metrics port: the operator exposes either
prometheus:15692 or prometheus-tls:15691 and never both, deliberately, so a
scrape config selecting every port does not count each node twice. That choice
keys off TLS alone rather than off disableNonTLSListeners, so a ServiceMonitor
selecting the port by the name prometheus stops matching once TLS is on, even
though the broker keeps listening on 15692. Since tls.enabled inherits external,
this reaches existing instances on upgrade with no user action.

Re-adding 15692 through spec.override.service looks like the fix and is not.
updatePorts keeps only port NAMES the operator owns and carries their NodePort
across, so every reconcile drops the re-added entry; the override then reinstates
it with nodePort unset, which the apiserver reads as "allocate" on a
LoadBalancer. The resulting write retriggers the operator's own Service watch and
the NodePort is reallocated each round. ClusterIP escapes it only because Update
zeroes every NodePort there, leaving the patched spec equal to the live one — and
external:true, the configuration that turns TLS on by default, is precisely the
one that would loop. Trading a renamed metrics port for continuous LoadBalancer
and kube-proxy reprogramming is not a trade worth making.

So the chart renders no service override at all. The README says what changed and
how to retarget a scrape config, including that 15691 is HTTPS under the release
CA and so needs the trust anchor to verify, and the template comment records why
neither direction of override is used.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:43 +03:00
Aleksei Sviridkin a021bfa324 docs(rabbitmq): correct TLS comments that outran the code
Several comments described a shape the chart does not render. A test comment
claimed the chart carries a management cacertfile while the assertion directly
below it pins that no additionalConfig exists at all; the suite title and two
section headers advertised a management HTTPS block that is never rendered; and
a scope note named interNodeTLS, which is not a field on RabbitmqCluster — the
CRD exposes exactly secretName, caSecretName and disableNonTLSListeners.

Two tests were named for something they did not assert. The inter-node scope
test checked disableNonTLSListeners, which by this chart's own reasoning has no
bearing on port 25672; it now checks caSecretName, which is the field that would
actually configure inter-node mTLS.

State the ResourceDefinition backstop's real standing. The exclude list is
defence in depth, not the first line: promotion runs on the tenantresource label
that the lineage webhook stamps only when it resolves an ancestor, and a
cert-manager Secret has no ownerReference or Helm metadata, so it fails closed
before include or exclude is consulted. The list covers the case where that
stops holding.

Pin the dashboard Role's complete grant rather than only the absence of
known-bad names — every existing assertion there was a notContains, so a Role
that gained an unrelated Secret satisfied all of them.

Record what upgrading an existing external instance does: tls.enabled inherits
external, so the broker pods roll once when the operator mounts the new Secret,
and the instance gains a cert-manager dependency. No client breaks, but a
stateful broker restarting is not something to discover from a diff.

Drop four tests that duplicated earlier ones verbatim.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:43 +03:00
Aleksei Sviridkin 7406303701 fix(rabbitmq): skip the external certificate SAN instead of failing without a host
Requiring _namespace.host under external:true turned a working configuration
into a render error. The value derives from _cluster.root-host, which the
platform treats as optional — the ingress hostname policy skips rendering when
it is unset and the platform chart passes it through default so it can be empty
— and an external RabbitMQ is a bare LoadBalancer Service with no Ingress and no
hostname involvement. Releases in that state predate the tls field, so they
carry no tls.enabled: false to fall back on and would have failed on upgrade
with no way out. Append the SAN when a host is supplied and skip it otherwise.

Say plainly what the external SAN is worth: the chart creates no DNS record for
that name, so verifying by hostname means pointing it at the LoadBalancer
address yourself, and a client dialling the IP fails hostname verification.
Guarding the render was protecting a guarantee the chart does not deliver.

Document the one manual step when disabling TLS, which until now existed only in
a template comment nobody performing the downgrade would read: cert-manager
keeps the Secrets after Helm removes the Certificates, so the CA keeps its
publication label and a stale anchor keeps being projected until it is deleted.

Correct the tri-state helper's own comment while here. It claimed to guard a
class of input it does not need to: values.schema.json types tls as an object,
so non-map scalars are rejected by Helm before any template renders. Null is the
only shape that reaches the template, and that is what the dig form covers.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:42 +03:00
Aleksei Sviridkin d8a711bd29 refactor(rabbitmq): resolve the TLS tri-state in one place
The tri-state resolution was copy-pasted into three templates. It had already
drifted: the copy in the dashboard Role outlived the grant it used to gate and
was removed with nothing to catch that the remaining two could diverge in the
same way. Extract rabbitmq.tls.enabled and have both callers use it.

Reading .Values.tls.enabled directly also panicked with "nil pointer evaluating
interface {}.enabled" under `tls: null`. The app CR cannot produce that shape,
since structural-schema pruning replaces null with the {} default, but a
HelmRelease values override reaches the chart without pruning. Resolve through
dig on a defaulted dict so the value falls back to external instead.

Cover both with a suite that renders the cluster and the certificate chain
together across every external x tls.enabled combination and asserts they agree,
so a future divergence fails a test rather than issuing certificates nobody uses.

Drop the management ssl cacertfile line while here. It was set on the management
listener but not on AMQPS, and on neither does a CA alone verify client
certificates without verify_peer and fail_if_no_peer_cert. It bought nothing and
left the two listeners inconsistent; the operator supplies everything else once
spec.tls.secretName is set, so no additionalConfig remains.

Pin the ResourceDefinition invariants that decide whether a private key can
reach a tenant. The chart's helm-unittest suite cannot see that file, so the
label-based include, the non-empty selector and the exclude backstop are
asserted in hack/check-rabbitmq-rd-secrets.bats instead.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:42 +03:00
Aleksei Sviridkin 31101eeeaf fix(rabbitmq): drop schema guard that the aggregated API strips
values.schema.json carried additionalProperties:false on the tls object,
post-processed onto a generated file by a jq patch plus a drift guard, and a
test asserted that an unknown tls key is rejected. It is not rejected on the
path tenants use: the aggregated apiserver removes every boolean-form
additionalProperties before publishing, and its own comment states the schema
is consumed for documentation and type-checking rather than enforcement. The
constraint therefore held only for a direct helm install, while the test
documented it as a general guarantee. rabbitmq was also the only chart in the
catalog carrying it. Remove the patch, the guard and the test rather than keep
a check that does not check on the path that matters.

Also in the same area, three fixes for things that claimed more than they did:

The management ssl port, certfile and keyfile lines in additionalConfig
duplicated the operator's defaultTLSConf verbatim, which it writes as soon as
spec.tls.secretName is set. Only cacertfile adds anything outside mutual TLS.
Keep that one and record what it does not do — supplying a CA does not enable
client-certificate verification without verify_peer and fail_if_no_peer_cert,
so clients still authenticate by password inside the TLS session.

The dashboard Role computed the tri-state TLS flag and never read it, left over
from removing the Secret grant it used to gate.

A missing _namespace.host under external:true rendered as `nil pointer
evaluating interface {}.host`. Fail closed with a message naming the key: the
external DNS name is a certificate SAN, so omitting it silently produces a
certificate that fails verification at connect time instead of at render time.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:41 +03:00
Aleksei Sviridkin 56043f962b fix(rabbitmq): drop the service port override that could not remove a port
The override listed only the TLS ports, which reads as "plaintext is not
published on the LoadBalancer". It never did that. The operator rebuilds its
default port set from generateServicePortsMap() on every reconcile and only
then applies spec.override.service as a strategic merge patch keyed on `port`
(corev1.ServiceSpec tags Ports with patchMergeKey:"port"), so a partial list
can add or mutate entries but never remove them. With TLS on, the two ports it
listed are byte-identical to what the operator already generates, making the
whole block a no-op that credited itself with a guarantee it did not provide.

Remove it and say plainly what holds: amqp:5672 and management:15672 stay
published, on the LoadBalancer too when external is true. Closing them requires
spec.tls.disableNonTLSListeners, which writes `listeners.tcp = none` into
rabbitmq.conf — a broker-level switch that closes the socket on every interface
at once and drops in-cluster plaintext clients along with external ones. It
stays unset, so enabling TLS adds encrypted endpoints without breaking a
working connection; treat an external RabbitMQ as plaintext-reachable and
restrict it at the network layer if that is not acceptable.

Erlang distribution on 25672 is unaffected either way: the operator never
applies the flag to the headless Service that carries it.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:41 +03:00
Aleksei Sviridkin d6c1539545 fix(rabbitmq): stop granting key-bearing TLS Secrets to tenants
Both objects holding ca.crt also hold a private key: the leaf <release>-tls
carries the server key and the CA <release>-ca carries the CA key. RBAC has no
key-level filter, so granting either one to deliver a trust anchor delivers a
key with it — read access to the CA key is enough to issue a certificate for
anything and MITM the endpoint undetected.

Publish the CA instead: label the isCA Certificate so the CA-extraction
controller projects ca.crt alone into the key-free <release>.tenant-ca, which
tenants read through core.cozystack.io/tenantsecrets. The labels go on the CA
Certificate rather than the leaf, since projecting from the leaf would read a
Secret whose tls.key is the server key. The release label is required because
cert-manager issues the Secret, leaving no OwnerReference or Helm metadata to
attribute it by.

Back the label-only include with a name-based exclude covering the cert-manager
chain and the operator's erlang-cookie, so a mis-stamp of the trust-anchor label
cannot promote a private key. The erlang cookie is worth the entry on its own:
it grants peer-node code execution over port 25672, which disableNonTLSListeners
does not close.

Document the retrieval path and state the limits it comes with — the projection
depends on a controller that ships separately, and the CA rotates, so a bundle
copied once eventually stops verifying.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:41 +03:00
Arsolitt c3333c359d refactor(rabbitmq): switch CA and leaf private keys to ECDSA P-256
Replace implicit RSA key generation with explicit ECDSA P-256 for both the
CA and leaf Certificates. ECDSA P-256 provides equivalent security with
smaller keys and faster TLS handshakes.

CA privateKey: algorithm ECDSA, size 256, rotationPolicy Never (unchanged).
Leaf privateKey: algorithm ECDSA, size 256, rotationPolicy Always.

Also migrate tri-state detection in certmanager.yaml from
hasKey+ne nil to the canonical kindIs "invalid" pattern.

Assisted-by: LLM
Signed-off-by: Arsolitt <arsolitt@gmail.com>
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:40 +03:00
Arsolitt 6ac3b31a1a refactor(rabbitmq): drop null from tls.enabled schema, use kindIs invalid pattern
cozyvalues-gen v1.5.0 with {*bool} annotation emits "type": "boolean" (not
["boolean", "null"]), making the manual jq patch unnecessary. Remove the
nullable patch and its precondition check from the Makefile.

Update tri-state detection in certmanager.yaml and rabbitmq.yaml to use the
canonical kindIs "invalid" pattern, which correctly handles both the
missing-key and explicit-null cases without hasKey+ne nil.

Assisted-by: LLM
Signed-off-by: Arsolitt <arsolitt@gmail.com>
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:40 +03:00
Arsolitt d1e0d7ca24 fix(rabbitmq): drop plaintext ports from LoadBalancer override when TLS on
When both external and TLS are active, the public LoadBalancer was exposing
plaintext amqp (5672) and management (15672) alongside the TLS equivalents.
Restrict the LB override to amqps (5671) and management-tls (15671) only.

In-cluster ClusterIP plain listeners are intentionally left open to support
client migration without disruption. spec.tls.disableNonTLSListeners is not
set to avoid closing plain ports at the broker level.

Assisted-by: LLM
Signed-off-by: Arsolitt <arsolitt@gmail.com>
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:40 +03:00
Arsolitt 3d55017037 feat(rabbitmq): grant tenant read access to TLS Secret for ca.crt retrieval
Add the <release>-tls Secret to the dashboard Role resourceNames when TLS
is active, allowing tenants to retrieve the CA certificate via kubectl.
The tri-state logic in dashboard-resourcemap.yaml mirrors the same pattern
used in certmanager.yaml and rabbitmq.yaml.

Also include rabbitmq-{{ .name }}-tls in cozyrds secrets.include so the
dashboard surfaces the TLS Secret alongside the default-user credential.

Assisted-by: LLM
Signed-off-by: Arsolitt <arsolitt@gmail.com>
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:39 +03:00
Arsolitt 867cdf2c7b fix(rabbitmq): add inter-node service SANs to TLS cert
Adds wildcard and base SANs for the <release>-nodes headless service
required by RabbitMQ Cluster Operator for inter-node TLS handshake
(Erlang distribution between pods). Without these entries, hostname
verification fails during cluster formation.

Also quotes all dnsNames entries to handle the wildcard (*) prefix,
which is otherwise rejected as an invalid YAML anchor character.

Signed-off-by: Arsolitt <arsolitt@gmail.com>
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:39 +03:00
Arsolitt 1d1778d769 test(rabbitmq): update cert SANs to cozy.local, add custom-domain and LB port tri-state coverage
Update certmanager_test.yaml SAN assertions to match the new default
cluster domain (cozy.local) and add a test that verifies a custom
_cluster.cluster-domain propagates into the FQDN SAN.

Add a tri-state LoadBalancer port override test (tls.enabled unset +
external=true) to cover the case that was untested in the existing matrix.

Replace documentIndex: 0 in the baseline RabbitmqCluster test with
a documentSelector so the test is stable regardless of render order.

Assisted-by: LLM
Signed-off-by: Arsolitt <arsolitt@gmail.com>
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:38 +03:00
Arsolitt 42decd708e fix(rabbitmq): treat null tls.enabled as inherit-from-external and use cluster domain for cert SANs
The previous hasKey-only check treated an explicit null tls.enabled as a
real value (false), skipping the external fallback. Add a nil guard so
null is handled the same as absent — TLS inherits from .Values.external.

Replace the hardcoded cluster.local suffix in cert SANs with the
platform-injected _cluster.cluster-domain value (defaulting to cozy.local),
consistent with how clickhouse, foundationdb, mongodb, and opensearch resolve
the cluster DNS domain.

Assisted-by: LLM
Signed-off-by: Arsolitt <arsolitt@gmail.com>
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:38 +03:00
Arsolitt f08db57bb2 test(rabbitmq): add TLS test coverage
Add Helm unittest cases for cert-manager resource generation and RabbitMQ TLS configuration, with a fixture file for default TLS values.

Signed-off-by: Arsolitt <arsolitt@gmail.com>
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:37 +03:00
Arsolitt c6cb09e73d feat(rabbitmq): implement TLS in Helm templates
Add cert-manager Certificate and Issuer resources for RabbitMQ TLS, and wire TLS secret references into the RabbitMQ cluster manifest.

Signed-off-by: Arsolitt <arsolitt@gmail.com>
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-09-04 11:18:37 +03:00