# External Secrets Operator: One Secrets Workflow Across Clouds

URL: https://www.devopsness.com/blog/external-secrets-operator-across-clouds
Author: Kiril Urbonas
Published: 2026-07-07
Updated: 2026-10-31
Categories: Cloud
Tags: Secrets, Kubernetes, Security, Vault, Cloud

Summary: 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.

---
# External Secrets Operator: One Secrets Workflow Across Clouds

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]
> 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:

```yaml
# 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:

```yaml
# 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:

```
# 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](/blog/vault-as-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](/blog/vault-vs-secrets-manager-vs-doppler) 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

- [External Secrets Operator: ExternalSecret API, refreshInterval and refreshPolicy](https://external-secrets.io/latest/api/externalsecret/)
- [External Secrets Operator: AWS authentication with IRSA and serviceAccountRef](https://external-secrets.io/latest/provider/aws-access/)
- [External Secrets Operator: metrics reference](https://external-secrets.io/latest/api/metrics/)
- [External Secrets Operator releases on GitHub](https://github.com/external-secrets/external-secrets/releases/tag/helm-chart-2.14.0)

