myceliam
Every Kubernetes workload gets real, federated cloud identity the moment it's labeled — not a static key sitting in a Secret.
A Kubernetes-native operator that reconciles namespaces and ServiceAccounts into IdP realms/clients and cloud IAM trust — continuously, declaratively, with no long-lived credential ever minted.
Non-human identity is already out of control
Machine identities now outnumber human ones many times over, and the industry's own data shows most of them are unmanaged: sitting idle, over-permissioned, or authenticated with a long-lived secret nobody is rotating.
Humans mostly log in federated. Workloads mostly still carry a static key.
CNAPPs and non-human-identity platforms are good at the what — which ServiceAccounts, roles, and clients exist, and what they can reach. The why they got that way is only ever pieced together after the fact, from tags, naming conventions, and activity logs — and that's exactly where context gets lost: roles with no clear owner, federated trusts nobody remembers creating, clients whose workload was deleted months ago. The knowledge that would answer "why does this exist" is scattered across Terraform modules, cloud-specific annotations, CI pipelines, and old tickets — and none of it stays current as the workload changes or disappears.
Two ways to give a workload cloud access
Cloud providers like AWS and GCP have had a federate-instead-of-mint answer to static keys for years. The reason static keys still win by default isn't that federation is worse — it's that wiring it up by hand, per workload, per cloud, is real toil. myceliam's answer is Kubernetes-native: namespaces and ServiceAccounts declare identity intent directly, as the source of truth, and the operator reconciles that intent into IdP resources and cloud federation — continuously, not just at apply-time. Every resource it creates carries that provenance back out, as a label a CNAPP can already read, with no custom integration required. SPIFFE/SPIRE still issues the workload's own identity and Terraform still describes the surrounding infrastructure — myceliam is the reconciliation layer that keeps cloud trust in sync with whichever of those is the source of truth for a given workload, continuously, instead of once at apply-time.
Without myceliam
Developer creates a Kubernetes ServiceAccount. developer
Engineer updates Terraform or cloud configuration. engineer
Engineer creates or updates an IdP realm/client. engineer
Engineer configures AWS or GCP federation. engineer
Engineer writes trust conditions and claim mappings. engineer
Engineer applies changes and verifies connectivity. engineer
On teardown, engineer has to remember to clean up every external resource. engineer
With myceliam
Developer creates a namespace and ServiceAccount. developer
Labels declare the identity intent. developer
myceliam reconciles the corresponding IdP resources. automatic
It establishes cloud federation and trust relationships. automatic
Workload identity becomes available. automatic
Any change to labels or ServiceAccounts triggers reconciliation and cleanup — on every reconcile, forever. automatic
Why is it called MycelIAM?
Kubernetes trusts its own ServiceAccount tokens. IDPs (Identiy providers) Keycloak, Auth0, and SPIRE each issue JWTs they're willing to vouch for. Public clouds like AWS and GCP will happily accept a federated token — from an identity provider they've already been told to trust. Each of those three systems already knows how to trust something. None of them know about each other by default. Myceliam is named after mycelium, the hidden underground fungal network that connects separate organisms and lets them trade nutrients. In the same way, Myceliam is a Kubernetes operator that weaves identity threads between clusters, identity providers and clouds. It watches namespace and ServiceAccount events and creates the matching resources in IdPs and cloud IAM on demand, so workloads can exchange short-lived credentials to access cloud resources.
Watch the intro
How it works
Label a ServiceAccount with myceliam.io/autoidp=true plus a
myceliam.io/client-type, and the operator provisions its identity.
Add myceliam.io/aws-access-profile / myceliam.io/gcp-access-profile,
and it federates that identity into the AWS roles or GCP service accounts an
AwsAccessProfile/GcpAccessProfile CRD lists. Remove a label,
delete the ServiceAccount, and myceliam tears the trust back down — nothing lingers.
Client secret auth. Written straight to a Secret — no manual IdP console work.
private_key_jwt auth from a cert in a paired Secret — bring your own (cert-manager) or let the operator generate one.
No client at all — identity comes straight from SPIRE. myceliam only registers the cloud-side trust.
No static cloud credentials: AWS/GCP tokens are fetched by the workload itself at request time, never stored or proxied by the operator. Registration, not authorization: myceliam earns the trust; your cloud's own IAM policies still decide what that identity can do once it crosses. Isolation by design: every namespace gets its own realm (or SPIFFE ID hierarchy) and per-namespace, per-cloud audiences, so one namespace's token can never satisfy another's trust condition.
Known limitations
- Registration and trust only — myceliam never attaches the permissions policy. In AWS it will create a referenced IAM role if missing (trust policy only); on GCP the target service account will be created if it does not already exist.
- AWS trust-policy documents cap at 2048 characters; a role shared by many namespaces over a long time can eventually hit that ceiling.
- Must run as a single replica — no leader election. Shipped manifests set
strategy: Recreateso a rolling deploy never runs two operators at once.