Skip to main content
External Secrets Operator: One Secrets Workflow Across Clouds

External Secrets Operator: One Secrets Workflow Across Clouds

KU
· Founder & Chief Editor
• 7 min read•Updated •51 views

We ran secrets three different ways across AWS, GCP, and Vault. External Secrets Operator gave us one Kubernetes-native workflow. Here's the setup and the gotchas.

Key takeaways

  • External Secrets Operator syncs secrets from AWS Secrets Manager, GCP Secret Manager, Vault and other backends into native Kubernetes Secrets using two CRDs.
  • The platform team owns the SecretStore and its credentials; app teams write only ExternalSecret manifests.
  • Use it for stored secrets, and keep a Vault Agent sidecar for short-lived dynamic credentials.

External Secrets Operator (ESO) gives every cluster one secrets workflow: a controller syncs values from AWS Secrets Manager, GCP Secret Manager or Vault into native Kubernetes Secrets, driven by the same two CRDs everywhere. The platform team owns the SecretStore, app teams write ExternalSecret, and nobody hand-copies a password into a ConfigMap again.

Verified against

External Secrets Operator Helm chart 2.14.0 (external-secrets.io/v1 API), against the external-secrets.io ExternalSecret, AWS authentication and metrics docs. Checked October 2026.

We got here the hard way. We ran three clusters across two clouds plus on-prem, and each had its own secrets story. AWS workloads pulled from Secrets Manager with an init container. GCP used a sidecar hitting Secret Manager. The on-prem cluster read from HashiCorp Vault with yet another tool. Onboarding an engineer meant teaching three workflows, and every audit turned up a secret that had been copy-pasted into a plain ConfigMap because someone didn't want to learn the fourth way to do it. ESO collapsed all of that into one Kubernetes-native pattern.

The two objects you actually work with

ESO gives you a SecretStore (where secrets come from and how to auth) and an ExternalSecret (which secrets to pull and what to name them). The developer only ever writes ExternalSecret. The platform team owns SecretStore. That split is the reason it scales: app teams never touch credentials for the backend.

Here's an AWS store using IRSA so there are no static keys anywhere:

k8s/payments/secretstore.yaml
apiVersion: external-secrets.io/v1
kind: SecretStore
metadata:
  name: aws-secrets
  namespace: payments
spec:
  provider:
    aws:
      service: SecretsManager
      region: eu-west-1
      auth:
        jwt:
          serviceAccountRef:
            name: payments-eso   # bound to an IAM role via IRSA

The GCP store and the Vault store are structurally identical, just a different provider block. That sameness is the whole value. An app team's ExternalSecret looks the same no matter which cloud the cluster runs in:

k8s/payments/externalsecret.yaml
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: db-credentials
  namespace: payments
spec:
  refreshInterval: 1h
  secretStoreRef:
    name: aws-secrets
    kind: SecretStore
  target:
    name: db-credentials      # the k8s Secret ESO creates
  data:
    - secretKey: password
      remoteRef:
        key: prod/payments/db
        property: password

That remoteRef.key is the path in the backend; on GCP it'd be a resource name, in Vault a mount path. Same CRD, backend-specific reference. Developers learn one manifest shape. Older manifests and blog posts still say external-secrets.io/v1beta1; the current docs use v1, so check which versions your installed CRDs serve (kubectl get crd externalsecrets.external-secrets.io -o jsonpath='{.spec.versions[*].name}') before copying anything.

Rotation without redeploys

The feature that sold the security team: refreshInterval. ESO re-reads the backend on that cadence and updates the Kubernetes Secret in place. Leave refreshPolicy unset (it defaults to Periodic) for anything that rotates; CreatedOnce and OnChange stop the scheduled re-reads. Pair it with a reloader so pods pick up the change without a manual rollout.

YAML
# k8s/payments/deployment.yaml (excerpt)
metadata:
  annotations:
    reloader.stakater.com/auto: "true"

When we rotate the database password in Secrets Manager, ESO syncs it within the hour and the reloader restarts the affected deployments. What used to be a coordinated change across three clusters is now a single write to the backend. We rotate the payments DB credential every 30 days now, which we simply never did before because the manual dance was too painful.

The gotchas that cost us time

A synced Kubernetes Secret is still a base64 Secret sitting in etcd. ESO moves secrets around; it does not make them encrypted at rest by itself. You still need etcd encryption enabled and RBAC locked down. We caught a namespace where any pod could read the Secret because a broad Role had crept in. ESO is not a substitute for least privilege.

Second, refresh interval versus API cost. We set refreshInterval: 1m on a chatty cluster and got a bill surprise, plus AWS throttling, because ESO was calling the Secrets Manager API constantly across hundreds of ExternalSecrets. One minute times hundreds of secrets is a lot of GetSecretValue calls. We moved to 1h for stable secrets and reserved short intervals for the handful that actually rotate fast. Right-size per secret. On AWS, dataFrom with a path prefix also lets ESO use the batched BatchGetSecretValue call instead of listing and fetching secrets one by one.

Third, a failed sync is quiet unless you watch for it. If the backend is unreachable, ESO keeps serving the last-good Secret, which is good for uptime and bad because you won't notice the sync broke. ESO exports externalsecret_sync_calls_error and externalsecret_status_condition; alert on the error counter:

code
# prometheus/rules/eso.yaml (expr)
increase(externalsecret_sync_calls_error[15m]) > 0

We wire that into Prometheus so a store losing auth pages us before the stale secret expires. A quick manual check is kubectl get externalsecret -A, which shows each object's READY and STATUS columns.

Where it didn't fit

We tried ESO for dynamic database credentials from Vault, the kind that are minted per-session and expire in 15 minutes. That's a poor fit; ESO's sync model wants relatively stable secrets, and 15-minute leases meant constant churn and race conditions on pod start. For that one case we kept the Vault Agent sidecar, the pattern we cover in Vault as a secrets backend for Kubernetes. Use the right tool: ESO is for syncing stored secrets, not for short-lived dynamic ones.

Questions people ask

What is the difference between SecretStore and ClusterSecretStore?

A SecretStore is namespaced: only ExternalSecret objects in the same namespace can reference it, which keeps one team's backend credentials away from another's. A ClusterSecretStore is cluster-wide and any namespace can use it. We default to namespaced stores and reserve the cluster-wide kind for shared, low-risk values. With IRSA on a ClusterSecretStore, the serviceAccountRef must also name the namespace the service account lives in.

Does External Secrets Operator encrypt secrets?

No. ESO reads from the backend and writes an ordinary Kubernetes Secret, which is base64-encoded in etcd. Encryption at rest is a cluster setting (an EncryptionConfiguration or your managed provider's KMS integration), and access is a matter of RBAC. ESO reduces how many places a secret is copied by hand; it does not change how Kubernetes stores the result.

How often should refreshInterval be?

Match it to how often the value really changes. We use 1h for stable credentials and shorter intervals only for the few secrets that rotate quickly, because every refresh is a backend API call multiplied by the number of ExternalSecret objects. Setting it to 0 creates the Secret once and never updates it, which suits values that never rotate.

The call we'd make

If you have more than one secrets backend, or more than one cluster, adopt ESO. The single-workflow payoff is worth it just for onboarding and audits, and rotation stops being a project. If you're still choosing the backend itself, our Vault vs Secrets Manager vs Doppler comparison covers that decision. Keep the platform team owning SecretStore and let app teams own ExternalSecret. And keep a sidecar around for genuinely dynamic, short-lived credentials; that's the one case ESO shouldn't own.

Sources

React
Share this post
Cite this article
Plain text

Kiril Urbonas (2026). External Secrets Operator: One Secrets Workflow Across Clouds. DevOpsNess. Updated 2026-10-31. https://www.devopsness.com/blog/external-secrets-operator-across-clouds

Markdown

[External Secrets Operator: One Secrets Workflow Across Clouds](https://www.devopsness.com/blog/external-secrets-operator-across-clouds) (Kiril Urbonas, DevOpsNess, updated 2026-10-31)

KU

Kiril Urbonas

Founder & Chief Editor

605 articles
View all articles by Kiril Urbonas

You might have missed

Evergreen posts worth revisiting.