Helm Chart Multiple Deployments

Published
Length
3 min read

Luis Felipe Dias

All posts

You can set up a helm chart multiple deployments layout using one parent chart. You can also place several workload files inside a single templates folder. Platform teams often group web servers, background workers, and schedulers into one release. This pattern keeps related apps together during upgrades and rollbacks. Still, teams often share one broad service account across all these workloads. When every pod uses the same cluster role, a single flaw exposes everything. How a helm chart mult

Your coding agents run with your access.

Claude Code reaches prod with a developer's credentials, and approval prompts get clicked through. hoop.dev checks every query, masks sensitive data, and holds risky changes for a human.

You can set up a helm chart multiple deployments layout using one parent chart. You can also place several workload files inside a single templates folder. Platform teams often group web servers, background workers, and schedulers into one release. This pattern keeps related apps together during upgrades and rollbacks. Still, teams often share one broad service account across all these workloads. When every pod uses the same cluster role, a single flaw exposes everything.

How a helm chart multiple deployments layout works

Helm packages Kubernetes manifests into a single release unit. You have two main patterns when your app needs more than one deployment. The first pattern puts separate manifest files inside one templates directory. Each file defines its own pod spec, replica count, and container image. You can also use a loop in one template to build several workloads. The loop reads a list of services from your values file. This works well when your microservices share the same structure.

The second pattern uses an umbrella chart with subcharts. Each subchart holds one workload and its own default values. The parent chart ties them together and overrides values for each stage. Both patterns send one combined manifest list to the Kubernetes API. The cluster then creates the pods, services, and roles at the same time. To keep this safe, each workload needs its own service account. You should bind each account to a small role with tight permissions.

What native chart permissions solve and what they miss

Kubernetes role bindings decide which user or pod can talk to the API. They let you limit who can install or upgrade a release. You can let developers read pod logs in a test namespace. You can also block them from changing production secrets or deleting workloads. Separate service accounts stop a worker pod from reading web server secrets. These native rules handle cluster entry and resource creation well.

Still, native chart roles only check permissions when a session starts. Once an engineer opens a shell into a pod, role checks stop. Kubernetes does not inspect the commands that run inside that active shell. If a pod connects to a database, cluster roles cannot check the queries. A user with exec rights can run destructive scripts or read sensitive tables. Unmasked query results can expose emails, phone numbers, card numbers, or national IDs. Native roles also do not log the exact statements a user runs.

Helm Chart Security: architecture patterns and best practices

Continue reading? Get the full guide.

Free. No spam. Unsubscribe anytime.

Why shared values files create secret sprawl

Multi-deployment charts often pull database keys from one shared values file. Teams pass these keys into every pod as environment variables. Any person who can inspect a pod can read those plain keys. If three workloads share one database user, audit logs lose track of identity. You cannot tell which app or engineer ran a bad write query. Splitting charts helps, but static keys in cluster secrets still leave gaps. Teams need a way to check every command and query in flight.

Check Kubernetes API requests and responses on the wire

Kubernetes RBAC decides who may call the API server. RBAC does not check response payloads or split listing Secret names from reading Secret values when a role grants get access. With hoop.dev, you run an open-source HTTP proxy, a sidecar for your Kubernetes API. The kubectl client changes only the server address it talks to while RBAC stays in place.

On each call, hoop.dev guardrails read the method, normalized path, and headers to refuse bad deletes or full Secret reads with a 403 error. On the way back, hoop.dev data masking walks JSON responses by key and masks matched values in Secrets, ConfigMaps, and pod logs. Every request and verdict is logged without storing bearer tokens. View the project on GitHub.

Frequently asked questions

Should I use one chart or subcharts for multiple workloads?

Use one chart with multiple template files when workloads share the same lifecycle. Use subcharts when independent teams own the services and release on different schedules.

How do I stop workloads in one chart from sharing permissions?

Create a dedicated service account and role binding for each deployment template. Never mount the default namespace service account across all pods in your release.

Can Helm restrict what commands engineers run inside deployed pods?

No, Helm only templates and sends manifests to the Kubernetes API. It cannot inspect interactive shell commands, database queries, or live pod sessions after deployment.

The query runs. The emails stay hidden.