content large_stringlengths 3 20.5k | url large_stringlengths 54 193 | branch large_stringclasses 4
values | source large_stringclasses 42
values | embeddings listlengths 384 384 | score float64 -0.21 0.65 |
|---|---|---|---|---|---|
# Rewriting Keys in DataFrom When calling out an ExternalSecret with `dataFrom.extract` or `dataFrom.find`, it is possible that you end up with a kubernetes secret that has conflicts in the key names, or that you simply want to remove a common path from the secret keys. In order to do so, it is possible to define a set of rewrite operations using `dataFrom.rewrite`. These operations can be stacked, hence allowing complex manipulations of the secret keys. Rewrite operations are all applied before `ConversionStrategy` is applied. ## Methods ### Regexp This method implements rewriting through the use of regular expressions. It needs a `source` and a `target` field. The source field is where the definition of the matching regular expression goes, where the `target` field is where the replacing expression goes. ### Transform This method uses Go templating to rewrite the keys of each secret. The `template` field is used to specify the template. You can reference the key of each secret by the `.value` string. You can also use [helper functions](templating.md#helper-functions) in the template. ### Merge This method implements rewriting keys by merging operation and solving key collisions. It supports two merging strategies: `Extract` and `JSON`. The `Extract` strategy interprets all secret values in the secret map as JSON and merges all contained key/value pairs hoisting them to the top level, substituting the original secret map. The `JSON` strategy interprets all secret values in the secret map as JSON and merges all contained key/value pairs in the key specified by the \_required\_ parameter `into`. If the key specified by `into` already exists in the original secrets map it will be overwritten. Key collisions can be ignored or cause an error according to `conflictPolicy` which can be either `Ignore` or `Error`. To guarantee deterministic results of the merge operation, secret keys are processed in alphabetical order. Key priority can also be made explicit by providing a list of secret keys in the `priority` parameter. These keys will be processed last in the order they appear while all other keys will still be processed in alphabetical order. Specifying a key in the `priority` list which is not found in the source secret will cause an error. You can override this behavior setting `priorityPolicy` to `IgnoreNotFound` instead of the default `Strict`. ## Considerations about Rewrite implementation 1. The input of a subsequent rewrite operation are the outputs of the previous rewrite. 2. If a given set of keys do not match any Rewrite operation, there will be no error. Rather, the original keys will be used. 3. In Regexp operations, if a `source` is not a compilable `regexp` expression, an error will be produced and the external secret will go into a error state. 4. In Merge operations, if secrets are not valid JSON, an error will be produced and the external secret will go into an error state. ## Examples ### Removing a common path from find operations The following ExternalSecret: ```yaml {% include 'datafrom-rewrite-remove-path.yaml' %} ``` Will get all the secrets matching `path/to/my/secrets/\*` and then rewrite them by removing the common path away. In this example, if we had the following secrets available in the provider: ``` path/to/my/secrets/username path/to/my/secrets/password ``` the output kubernetes secret would be: ```yaml apiVersion: v1 kind: Secret type: Opaque data: username: ... password: ... ``` ### Avoiding key collisions The following ExternalSecret: ```yaml {% include 'datafrom-rewrite-conflict.yaml' %} ``` Will allow two secrets with the same JSON keys to be imported into a Kubernetes Secret without any conflict. In this example, if we had the following secrets available in the provider: ```json { "my-secrets-dev": { "password": "bar", }, | https://github.com/external-secrets/external-secrets/blob/main//docs/guides/datafrom-rewrite.md | main | external-secrets | [
-0.05582069978117943,
0.06751065701246262,
0.06354149430990219,
-0.004706914070993662,
-0.02888891100883484,
-0.0021781031973659992,
-0.0064198230393230915,
-0.013299594633281231,
0.09988755732774734,
0.04777894169092178,
-0.02368718944489956,
-0.0601404570043087,
0.0013494588201865554,
-0... | 0.055691 |
key collisions The following ExternalSecret: ```yaml {% include 'datafrom-rewrite-conflict.yaml' %} ``` Will allow two secrets with the same JSON keys to be imported into a Kubernetes Secret without any conflict. In this example, if we had the following secrets available in the provider: ```json { "my-secrets-dev": { "password": "bar", }, "my-secrets-prod": { "password": "safebar", } } ``` the output kubernetes secret would be: ```yaml apiVersion: v1 kind: Secret type: Opaque data: dev\_password: YmFy #bar prod\_password: c2FmZWJhcg== #safebar ``` ### Remove invalid characters The following ExternalSecret: ```yaml {% include 'datafrom-rewrite-invalid-characters.yaml' %} ``` Will remove invalid characters from the secret key. In this example, if we had the following secrets available in the provider: ```json { "development": { "foo/bar": "1111", "foo$baz": "2222" } } ``` the output kubernetes secret would be: ```yaml apiVersion: v1 kind: Secret type: Opaque data: foo\_bar: MTExMQ== #1111 foo\_baz: MjIyMg== #2222 ``` ### Merging all secrets The following ExternalSecret: ```yaml {% include 'datafrom-rewrite-merge-empty.yaml' %} ``` Will merge all keys found in all secrets at top level. In this example, if we had the following secrets available in the provider: ```json { "path/to/secrets/object-storage-credentials": { "ACCESS\_KEY": "XXXX", "SECRET\_KEY": "YYYY" }, "path/to/secrets/mongo-credentials": { "USERNAME": "XXXX", "PASSWORD": "YYYY" } } ``` the output kubernetes secret would be: ```yaml apiVersion: v1 kind: Secret type: Opaque data: ACCESS\_KEY: WFhYWA== #XXXX SECRET\_KEY: WVlZWQ== #YYYY USERNAME: WFhYWA== #XXXX PASSWORD: WVlZWQ== #YYYY ``` ### Transform secret keys The following ExternalSecret: ```yaml {% include 'datafrom-rewrite-transform.yaml' %} ``` Uses a template to transform all secret keys into an "environment variable" format by capitalizing, replacing `-` with `\_` and prefixing them with `ENV\_`. In this example, if we had the following secrets available in the provider: ```json { "foo-nut-bar": "HELLO1" "foo-naz-bar": "HELLO2" "foo-bar-baz": '{"john": "doe"}' } ``` the output kubernetes secret would be: ```yaml apiVersion: v1 kind: Secret type: Opaque data: ENV\_FOO\_BAR\_BAZ: eyJqb2huIjogImRvZSJ9 ENV\_FOO\_NAZ\_BAR: SEVMTE8y ENV\_FOO\_NUT\_BAR: SEVMTE8x ``` ## Limitations Regexp Rewrite is based on golang `regexp`, which in turns implements `RE2` regexp language. There a a series of known limitations to this implementation, such as: \* Lack of ability to do lookaheads or lookbehinds; \* Lack of negation expressions; \* Lack of support for conditional branches; \* Lack of support for possessive repetitions. A list of compatibility and known limitations considering other commonly used regexp frameworks (such as PCRE and PERL) are listed [here](https://github.com/google/re2/wiki/Syntax). | https://github.com/external-secrets/external-secrets/blob/main//docs/guides/datafrom-rewrite.md | main | external-secrets | [
-0.0759800523519516,
0.008679581806063652,
0.07164355367422104,
-0.03402112424373627,
0.0038227990735322237,
-0.0356874018907547,
-0.008656799793243408,
-0.01718919165432453,
0.1065601333975792,
-0.011030670255422592,
0.07238984107971191,
0.0002076178352581337,
0.06641492247581482,
-0.0322... | -0.002929 |
# Deploying without ClusterSecretStore and ClusterExternalSecret and ClusterPushSecret When deploying External Secrets Operator via Helm chart, the default configuration will install `ClusterSecretStore` and `ClusterExternalSecret` and other CRDs and these objects will be processed by the operator. In order to disable both or one of these features, it is necessary to configure the `crds.\*` Helm value, as well as the `process\*` Helm value, as these 2 values are connected. If you would like to install the operator without `ClusterSecretStore` and `ClusterExternalSecret` and `ClusterPushSecret` management, you will have to : \* set `crds.createClusterExternalSecret` to false \* set `crds.createClusterSecretStore` to false \* set `crds.createClusterPushSecret` to false \* set `processClusterExternalSecret` to false \* set `processClusterStore` to false \* set `processClusterPushSecret` to false Example: ```bash helm install external-secrets external-secrets/external-secrets --set crds.createClusterExternalSecret=false \ --set crds.createClusterSecretStore=false \ --set crds.createClusterPushSecret=false \ --set processClusterExternalSecret=false \ --set processClusterStore=false \ --set processClusterPushSecret=false ``` | https://github.com/external-secrets/external-secrets/blob/main//docs/guides/disable-cluster-features.md | main | external-secrets | [
0.019442280754446983,
0.032564856112003326,
-0.016533100977540016,
-0.011170887388288975,
-0.0043472908437252045,
0.007092128042131662,
-0.052902646362781525,
-0.0029823249205946922,
0.009599518030881882,
0.04392059147357941,
0.04228374734520912,
-0.08573656529188156,
0.034748125821352005,
... | 0.028596 |
# Lifecycle The External Secrets Operator manages the lifecycle of secrets in Kubernetes. With `refreshPolicy`, `creationPolicy` and `deletionPolicy` you get fine-grained control of its lifecycle. !!! note "Creation/Deletion Policy Combinations" Some combinations of creationPolicy/deletionPolicy are not allowed as they would delete existing secrets: - `deletionPolicy=Delete` & `creationPolicy=Merge` - `deletionPolicy=Delete` & `creationPolicy=None` - `deletionPolicy=Merge` & `creationPolicy=None` ## Refresh Policy The field `spec.refreshPolicy` defines how the operator refreshes the a secret. ### Periodic (default) Refreshes the secret at a fixed interval via `spec.refreshInterval`. Due to backwards compatibility, setting a refresh interval of 0 will result in the same behavior as `CreatedOnce`. ### OnChange Refreshes the secret only when the ExternalSecret is updated. ### CreatedOnce Refreshes the secret only once, when the ExternalSecret is created. ## Creation Policy The field `spec.target.creationPolicy` defines how the operator creates the a secret. ### Owner (default) The External Secret Operator creates secret and sets the `ownerReference` field on the Secret. This secret is subject to [garbage collection](https://kubernetes.io/docs/concepts/architecture/garbage-collection/) if the initial `ExternalSecret` is absent. If a secret with the same name already exists that is not owned by the controller it will result in a conflict. The operator will just error out, not claiming the ownership. !!! note "Secrets with `ownerReference` field not found" If the secret exists and the ownerReference field is not found, the controller treats this secret as orphaned. It will take ownership of this secret by adding an `ownerReference` field and updating it. ### Orphan Whenever triggered via `RefreshPolicy` conditions, the operator creates/updates the target Secret according to the provider available information. However, the operator will not watch on Secret Changes (delete/updates), nor trigger [garbage collection](https://kubernetes.io/docs/concepts/architecture/garbage-collection/) when the `ExternalSecret` object is deleted. !!! warning "Unwanted reverts of manual changes" If you set `spec.refreshPolicy` to `Periodic` or `OnChange` and `spec.target.creationPolicy` to `Orphan`, any changes manually done to the Secret will eventually be replaced on the next sync interval or on the next update to `ExternalSecret` object. That manual change is then lost forever. Use `creationPolicy=Orphan` with caution. ### Merge The operator does not create a secret. Instead, it expects the secret to already exist. Values from the secret provider will be merged into the existing secret. Note: the controller takes ownership of a field even if it is owned by a different entity. Multiple ExternalSecrets can use `creationPolicy=Merge` with a single secret as long as the fields don't collide - otherwise you end up in an oscillating state. ### None The operator does not create or update the secret, this is basically a no-op. ## Deletion Policy DeletionPolicy defines what should happen if a given secret gets deleted \*\*from the provider\*\*. DeletionPolicy is only supported on the specific providers, please refer to our [stability/support table](../introduction/stability-support.md). ### Retain (default) Retain will retain the secret if all provider secrets have been deleted. If a provider secret does not exist the ExternalSecret gets into the SecretSyncedError status. ### Delete Delete deletes the secret if all provider secrets are deleted. If a secret gets deleted on the provider side and is not accessible anymore this is not considered an error and the ExternalSecret does not go into SecretSyncedError status. This is also true for new ExternalSecrets mapping to non-existing secrets in the provider. ### Merge Merge removes keys in the secret, but not the secret itself. If a secret gets deleted on the provider side and is not accessible anymore this is not considered an error and the ExternalSecret does not go into SecretSyncedError status. | https://github.com/external-secrets/external-secrets/blob/main//docs/guides/ownership-deletion-policy.md | main | external-secrets | [
-0.10323890298604965,
-0.038789935410022736,
0.007998289540410042,
0.034368306398391724,
-0.02309594675898552,
-0.008767814375460148,
0.013595635071396828,
-0.05874668061733246,
0.1575581580400467,
0.05457814037799835,
0.03962429240345955,
-0.018775928765535355,
-0.012220178730785847,
-0.0... | 0.108919 |
gets deleted on the provider side and is not accessible anymore this is not considered an error and the ExternalSecret does not go into SecretSyncedError status. | https://github.com/external-secrets/external-secrets/blob/main//docs/guides/ownership-deletion-policy.md | main | external-secrets | [
-0.10841391235589981,
-0.03966769948601723,
-0.009345016442239285,
0.034779373556375504,
0.03590823709964752,
-0.019081033766269684,
-0.006020188797265291,
-0.0010104426182806492,
0.0759778693318367,
-0.01628516986966133,
0.0596928708255291,
0.02247176133096218,
0.016338838264346123,
0.028... | -0.001968 |
# Controller Classes > NOTE: this feature is experimental and not highly tested Controller classes are a property set during the deployment that allows multiple controllers to work in a group of workload. It works by separating which secretStores are going to be attributed to which controller. For the behavior of a single controller, no extra configuration is needed. ## Setting up Controller Class In order to deploy the controller with a specific class, install the helm charts specifying the controller class, and create a `SecretStore` with the appropriate `spec.controller` values: ``` helm install custom-external-secrets external-secrets/external-secrets --set controllerClass=custom ``` ``` yaml {% include 'controller-class-store.yaml' %} ``` Now, any `ExternalSecret` bound to this secret store will be evaluated by the operator with the controllerClass custom. > Note: Any SecretStore without `spec.controller` set will be considered as valid by any operator, regardless of their respective controllerClasses. | https://github.com/external-secrets/external-secrets/blob/main//docs/guides/controller-class.md | main | external-secrets | [
-0.06891808658838272,
-0.00835566595196724,
-0.07319000363349915,
0.008814138360321522,
-0.004199496004730463,
0.010613062418997288,
-0.019337086006999016,
0.03158828616142273,
0.018945515155792236,
0.035804059356451035,
0.1039736345410347,
0.005192471668124199,
0.02719465270638466,
-0.033... | -0.049336 |
# GitOps using FluxCD (v2) FluxCD is a GitOps operator for Kubernetes. It synchronizes the status of the cluster from manifests allocated in different repositories (Git or Helm). This approach fits perfectly with External Secrets on clusters which are dynamically created, to get credentials with no manual intervention from the beginning. ## Advantages This approach has several advantages as follows: \* \*\*Homogenize environments\*\* allowing developers to use the same toolset in Kind in the same way they do in the cloud provider distributions such as EKS or GKE. This accelerates the development \* \*\*Reduce security risks\*\*, because credentials can be easily obtained, so temptation to store them locally is reduced. \* \*\*Application compatibility increase\*\*: Applications are deployed in different ways, and sometimes they need to share credentials. This can be done using External Secrets as a wire for them at real time. \* \*\*Automation by default\*\* oh, come on! ## The approach FluxCD is composed by several controllers dedicated to manage different custom resources. The most important ones are \*\*Kustomization\*\* (to clarify, Flux one, not Kubernetes' one) and \*\*HelmRelease\*\* to deploy using the approaches of the same names. External Secrets can be deployed using Helm [as explained here](../introduction/getting-started.md). The deployment includes the CRDs if enabled on the `values.yaml`, but after this, you need to deploy some `SecretStore` to start getting credentials from your secrets manager with External Secrets. > The idea of this guide is to deploy the whole stack, using flux, needed by developers not to worry about the credentials, > but only about the application and its code. ## The problem This can sound easy, but External Secrets is deployed using Helm, which is managed by the HelmController, and your custom resources, for example a `ClusterSecretStore` and the related `Secret`, are often deployed using a `kustomization.yaml`, which is deployed by the KustomizeController. Both controllers manage the resources independently, at different moments, with no possibility to wait each other. This means that we have a wonderful race condition where sometimes the CRs (`SecretStore`,`ClusterSecretStore`...) tries to be deployed before than the CRDs needed to recognize them. ## The solution Let's see the conditions to start working on a solution: \* The External Secrets operator is deployed with Helm, and admits disabling the CRDs deployment \* The race condition only affects the deployment of `CustomResourceDefinition` and the CRs needed later \* CRDs can be deployed directly from the Git repository of the project using a Flux `Kustomization` \* Required CRs can be deployed using a Flux `Kustomization` too, allowing dependency between CRDs and CRs \* All previous manifests can be applied with a Kubernetes `kustomization` ## Create the main kustomization To have a better view of things needed later, the first manifest to be created is the `kustomization.yaml` ```yaml {% include 'gitops/kustomization.yaml' %} ``` ## Create the secret To access your secret manager, External Secrets needs some credentials. They are stored inside a Secret, which is intended to be deployed by automation as a good practise. This time, a placeholder called `secret-token.yaml` is show as an example: ```yaml # The namespace.yaml first {% include 'gitops/namespace.yaml' %} ``` ```yaml {% include 'gitops/secret-token.yaml' %} ``` ## Creating the references to repositories Create a manifest called `repositories.yaml` to store the references to external repositories for Flux ```yaml {% include 'gitops/repositories.yaml' %} ``` ## Deploy the CRDs As mentioned, CRDs can be deployed using the official Helm package, but to solve the race condition, they will be deployed from our git repository using a Kustomization manifest called `deployment-crds.yaml` as follows: ```yaml {% include 'gitops/deployment-crds.yaml' %} ``` ## Deploy the operator The operator is deployed using | https://github.com/external-secrets/external-secrets/blob/main//docs/examples/gitops-using-fluxcd.md | main | external-secrets | [
-0.10338130593299866,
-0.0016231279587373137,
0.015734359622001648,
-0.012828071601688862,
-0.01887749508023262,
-0.016463421285152435,
0.03313407674431801,
0.03823968395590782,
0.09692852199077606,
0.07324283570051193,
-0.03332572430372238,
-0.07186610996723175,
0.07930687069892883,
-0.03... | 0.246485 |
the CRDs As mentioned, CRDs can be deployed using the official Helm package, but to solve the race condition, they will be deployed from our git repository using a Kustomization manifest called `deployment-crds.yaml` as follows: ```yaml {% include 'gitops/deployment-crds.yaml' %} ``` ## Deploy the operator The operator is deployed using a HelmRelease manifest to deploy the Helm package, but due to the special race condition, the deployment must be disabled in the `values` of the manifest called `deployment.yaml`, as follows: ```yaml {% include 'gitops/deployment.yaml' %} ``` ## Deploy the CRs Now, be ready for the arcane magic. Create a Kustomization manifest called `deployment-crs.yaml` with the following content: ```yaml {% include 'gitops/deployment-crs.yaml' %} ``` There are several interesting details to see here, that finally solves the race condition: 1. First one is the field `dependsOn`, which points to a previous Kustomization called `external-secrets-crds`. This dependency forces this deployment to wait for the other to be ready, before start being deployed. 2. The reference to the place where to find the CRs ```yaml path: ./infrastructure/external-secrets/crs sourceRef: kind: GitRepository name: flux-system ``` Custom Resources will be searched in the relative path `./infrastructure/external-secrets/crs` of the GitRepository called `flux-system`, which is a reference to the same repository that FluxCD watches to synchronize the cluster. With fewer words, a reference to itself, but going to another directory called `crs` Of course, allocate inside the mentioned path `./infrastructure/external-secrets/crs`, all the desired CRs to be deployed, for example, a manifest `clusterSecretStore.yaml` to reach your Hashicorp Vault as follows: ```yaml {% include 'gitops/crs/clusterSecretStore.yaml' %} ``` ## Results At the end, the required files tree is shown in the following picture:  | https://github.com/external-secrets/external-secrets/blob/main//docs/examples/gitops-using-fluxcd.md | main | external-secrets | [
-0.01650422066450119,
0.003662011818960309,
0.015796344727277756,
-0.10072272270917892,
-0.003900666953995824,
-0.015397122129797935,
-0.02658027596771717,
0.004133619833737612,
-0.00879777129739523,
0.025509459897875786,
0.03940870985388756,
-0.05780963972210884,
0.026063309982419014,
-0.... | 0.042931 |
# Bitwarden support using webhook provider Bitwarden is an integrated open source password management solution for individuals, teams, and business organizations. !!! note This documentation is for Bitwarden \*\*Password Manager\*\*. It is different from [Bitwarden Secrets Manager](https://bitwarden.com/products/secrets-manager/), which enables developers, DevOps, and cybersecurity teams to centrally store, manage, and deploy secrets at scale. To integrate with Bitwarden \*\*Secrets Manager\*\*, reference the [provider documentation](../provider/bitwarden-secrets-manager.md). ## How does it work? To make external-secrets compatible with Bitwarden, we need: \* External Secrets Operator >= 0.8.0 \* Multiple (Cluster)SecretStores using the webhook provider \* Bitwarden CLI image running `bw serve` When you create a new external-secret object, the External Secrets webhook provider will query the Bitwarden CLI pod that is synced with the Bitwarden server. ## Requirements \* Bitwarden account (it also works with Vaultwarden!) \* A Kubernetes secret which contains your Bitwarden credentials \* A Docker image running the Bitwarden CLI. You could use `ghcr.io/charlesthomas/bitwarden-cli:2023.12.1` or build your own. Here is an example of a Dockerfile used to build the image: ```dockerfile FROM debian:sid ENV BW\_CLI\_VERSION=2023.12.1 RUN apt update && \ apt install -y wget unzip && \ wget https://github.com/bitwarden/clients/releases/download/cli-v${BW\_CLI\_VERSION}/bw-linux-${BW\_CLI\_VERSION}.zip && \ unzip bw-linux-${BW\_CLI\_VERSION}.zip && \ chmod +x bw && \ mv bw /usr/local/bin/bw && \ rm -rfv \*.zip COPY entrypoint.sh / CMD ["/entrypoint.sh"] ``` And the content of `entrypoint.sh`: ```bash #!/usr/bin/env bash set -e bw config server ${BW\_HOST} if [ -n "$BW\_CLIENTID" ] && [ -n "$BW\_CLIENTSECRET" ]; then echo "Using apikey to log in" bw login --apikey --raw export BW\_SESSION=$(bw unlock --passwordenv BW\_PASSWORD --raw) else echo "Using username and password to log in" export BW\_SESSION=$(bw login ${BW\_USER} --passwordenv BW\_PASSWORD --raw) fi bw unlock --check echo 'Running `bw server` on port 8087' bw serve --hostname 0.0.0.0 #--disable-origin-protection ``` ## Deploy Bitwarden credentials ```yaml {% include 'bitwarden-cli-secrets.yaml' %} ``` ## Deploy Bitwarden CLI container ```yaml {% include 'bitwarden-cli-deployment.yaml' %} ``` > NOTE: Deploying a network policy is recommended since there is no authentication to query the Bitwarden CLI, which means that your secrets are exposed. > NOTE: In this example the Liveness probe is querying /sync to ensure that the Bitwarden CLI is able to connect to the server and is also synchronised. (The secret sync is only every 2 minutes in this example) ## Deploy (Cluster)SecretStores There are five possible (Cluster)SecretStores to deploy, each can access different types of fields from an item in the Bitwarden vault. It is not required to deploy them all. ```yaml {% include 'bitwarden-secret-store.yaml' %} ``` ## Usage (Cluster)SecretStores: \* `bitwarden-login`: Use to get the `username` or `password` fields \* `bitwarden-fields`: Use to get custom fields \* `bitwarden-notes`: Use to get notes \* `bitwarden-attachments`: Use to get attachments \* `bitwarden-ssh`: Use to get ssh key stored in `privateKey` (other possible fields are `publicKey` and `keyFingerprint`) remoteRef: \* `key`: ID of a secret, which can be found in the URL `itemId` parameter: `https://myvault.com/#/vault?type=login&itemId=........-....-....-....-............`s \* `property`: Name of the field to access \* `username` for the username of a secret (`bitwarden-login` SecretStore) \* `password` for the password of a secret (`bitwarden-login` SecretStore) \* `name\_of\_the\_custom\_field` for any custom field (`bitwarden-fields` SecretStore) \* `id\_or\_name\_of\_the\_attachment` for any attachment (`bitwarden-attachment`, SecretStore) \* `name\_of\_the\_ssh\_field` for any ssh field (`bitwarden-ssh` SecretStore) possible fields are `publicKey`, `privateKey` and `keyFingerprint` ```yaml {% include 'bitwarden-secret.yaml' %} ``` | https://github.com/external-secrets/external-secrets/blob/main//docs/examples/bitwarden.md | main | external-secrets | [
-0.11878269910812378,
-0.021242793649435043,
-0.08167585730552673,
-0.004855410195887089,
-0.02029346115887165,
-0.04624081403017044,
-0.012000108137726784,
-0.022515572607517242,
-0.01292773149907589,
-0.004443629179149866,
0.02198396436870098,
-0.03786301240324974,
0.0793280154466629,
-0... | 0.098724 |
# Getting started Jenkins is one of the most popular automation servers for continuous integration, automation, scheduling jobs and for generic pipelining. It has an extensive set of plugins that extend or provide additional functionality including the [kubernetes credentials plugin](https://github.com/jenkinsci/kubernetes-credentials-provider-plugin). This plugin takes kubernetes secrets and creates Jenkins credentials from them removing the need for manual entry of secrets, local storage and manual secret rotation. ## Examples The Jenkins credentials plugin uses labels and annotations on a kubernetes secret to create a Jenkins credential. The different types of Jenkins credentials that can be created are SecretText, privateSSHKey, UsernamePassword. ### SecretText Here are some examples of SecretText with the Hashicorp Vault and AWS External Secrets providers: #### Hashicorp Vault ``` yaml {% include 'vault-jenkins-credential-sonarqube-api-token-external-secret.yaml' %} ``` #### AWS Secrets Manager ``` yaml {% include 'aws-jenkins-credential-sonarqube-api-token-external-secret.yaml' %} ``` ### UsernamePassword Here are some examples of UsernamePassword credentials with the Hashicorp Vault and AWS External Secrets providers: #### Hashicorp Vault ``` yaml {% include 'vault-jenkins-credential-harbor-chart-robot-external-secret.yaml' %} ``` #### AWS Secrets Manager ``` yaml {% include 'aws-jenkins-credentials-harbor-chart-robot-external-secret.yaml' %} ``` ### basicSSHUserPrivateKey Here are some examples of basicSSHUserPrivateKey credentials with the Hashicorp Vault and AWS External Secrets providers: #### Hashicorp Vault ``` yaml {% include 'vault-jenkins-credential-github-ssh-access-external-secret.yaml' %} ``` #### AWS Secrets Manager ``` yaml {% include 'aws-jenkins-credential-github-ssh-external-secret.yaml' %} ``` | https://github.com/external-secrets/external-secrets/blob/main//docs/examples/jenkins-kubernetes-credentials.md | main | external-secrets | [
-0.09600162506103516,
0.0088399238884449,
-0.03862336277961731,
0.00283878855407238,
-0.061161063611507416,
-0.010111343115568161,
-0.01859411969780922,
0.006311197765171528,
0.08240161091089249,
0.012483594007790089,
-0.050676602870225906,
-0.040607478469610214,
0.04445735365152359,
-0.00... | 0.176633 |
# Getting started \*\*Anchore Engine\*\* is an open-source platform that provides centralized inspection, analysis, and certification of container images. When integrated with Kubernetes, it adds powerful features—such as preventing unscanned images from being deployed into your clusters. ## Installation with Helm There are several parts of the installation that require credentials these being: - `ANCHORE\_ADMIN\_USERNAME` - `ANCHORE\_ADMIN\_PASSWORD` - `ANCHORE\_DB\_PASSWORD` - `db-url` - `db-user` - `postgres-password` You can use an \*\*ExternalSecret\*\* to automatically fetch these credentials from your preferred backend provider. The following examples demonstrate how to configure it with \*\*HashiCorp Vault\*\* and \*\*AWS Secrets Manager\*\*. #### Hashicorp Vault ``` yaml {% include 'vault-anchore-engine-access-credentials-external-secret.yaml' %} ``` #### AWS Secrets Manager ``` yaml {% include 'aws-anchore-engine-access-credentials-external-secret.yaml' %} ``` | https://github.com/external-secrets/external-secrets/blob/main//docs/examples/anchore-engine-credentials.md | main | external-secrets | [
0.013270695693790913,
0.024704722687602043,
-0.026935985311865807,
-0.00665806932374835,
0.02026652917265892,
-0.020822737365961075,
0.0067910607904195786,
-0.005450442899018526,
0.07631642371416092,
0.033382244408130646,
-0.022134961560368538,
-0.06583283841609955,
0.07414171099662781,
-0... | 0.02651 |
 The `PushSecret` is namespaced and it describes what data should be pushed to the secret provider. \* tells the operator what secrets should be pushed by using `spec.selector`. \* you can specify what secret keys should be pushed by using `spec.data`. \* you can also template the resulting property values using [templating](#templating). ## Example Below is an example of the `PushSecret` in use. ``` yaml {% include 'full-pushsecret.yaml' %} ``` The result of the created Secret object will look like: ```yaml # The destination secret that will be templated and pushed by PushSecret. apiVersion: v1 kind: Secret metadata: name: destination-secret stringData: best-pokemon-dst: "PIKACHU is the really best!" ``` ## Template When the controller reconciles the `PushSecret` it will use the `spec.template` as a blueprint to construct a new property. You can use golang templates to define the blueprint and use template functions to transform the defined properties. You can also pull in `ConfigMaps` that contain golang-template data using `templateFrom`. See [advanced templating](../guides/templating.md) for details. | https://github.com/external-secrets/external-secrets/blob/main//docs/api/pushsecret.md | main | external-secrets | [
-0.05456775799393654,
0.019606439396739006,
-0.0019772136583924294,
0.03914736583828926,
0.0001737513521220535,
0.011826165951788425,
0.016943365335464478,
0.08740609139204025,
-0.005072600208222866,
-0.01426331140100956,
0.06883794069290161,
-0.045001499354839325,
0.0005346522084437311,
0... | 0.049565 |
 The `ClusterExternalSecret` is a cluster scoped resource that can be used to manage `ExternalSecret` resources in specific namespaces. With `namespaceSelectors` you can select namespaces in which the ExternalSecret should be created. If there is a conflict with an existing resource the controller will error out. ## Example Below is an example of the `ClusterExternalSecret` in use. ```yaml {% include 'full-cluster-external-secret.yaml' %} ``` ## Synchronizing corresponding ExternalSecrets Regular refreshes can be controlled using the `refreshPolicy` and `refreshInterval` fields. Adhoc synchronizations can be triggered by setting, updating or deleting the annotation `external-secrets.io/force-sync` on the ClusterExternalSecret: ``` kubectl annotate ces my-ces external-secrets.io/force-sync=$(date +%s) --overwrite ``` Changes to this annotation will be synchronized to all ExternalSecrets owned by the ClusterExternalSecret. ## Deprecations ### namespaceSelector The field `namespaceSelector` has been deprecated in favor of `namespaceSelectors` and will be removed in a future version. | https://github.com/external-secrets/external-secrets/blob/main//docs/api/clusterexternalsecret.md | main | external-secrets | [
-0.060257963836193085,
-0.10453102737665176,
-0.004809287376701832,
0.05980167165398598,
0.05393882468342781,
-0.022558441385626793,
-0.020388852804899216,
-0.030972614884376526,
0.08266060054302216,
-0.013055666349828243,
0.07025023549795151,
-0.08104371279478073,
0.035733576864004135,
-0... | 0.153992 |
The `ExternalSecret` describes what data should be fetched, how the data should be transformed and saved as a `Kind=Secret`: \* tells the operator what secrets should be synced by using `spec.data` to explicitly sync individual keys or use `spec.dataFrom` to get \*\*all values\*\* from the external API. \* you can specify how the secret should look like by specifying a `spec.target.template` ## Template When the controller reconciles the `ExternalSecret` it will use the `spec.template` as a blueprint to construct a new `Kind=Secret`. You can use golang templates to define the blueprint and use template functions to transform secret values. You can also pull in `ConfigMaps` that contain golang-template data using `templateFrom`. See [advanced templating](../guides/templating.md) for details. ## Update behavior with 3 different refresh policies You can control how and when the `ExternalSecret` is refreshed by setting the `spec.refreshPolicy` field. If not specified, the default behavior is `Periodic`. ### CreatedOnce With `refreshPolicy: CreatedOnce`, the controller will: - Create the `Kind=Secret` only if it does not exist yet - Never update the `Kind=Secret` afterwards if the source data changes - Update/ Recreate the `Kind=Secret` if it gets changed/Deleted - Useful for immutable credentials or when you want to manage updates manually Example: ```yaml apiVersion: external-secrets.io/v1 kind: ExternalSecret metadata: name: example spec: refreshPolicy: CreatedOnce # other fields... ``` ### Periodic With `refreshPolicy: Periodic` (the default behavior), the controller will: - Create the `Kind=Secret` if it doesn't exist - Update the `Kind=Secret` regularly based on the `spec.refreshInterval` duration - When `spec.refreshInterval` is set to zero, it will only create the secret once and not update it afterward - When `spec.refreshInterval` is set to a value greater than zero, the controller will update the `Kind=Secret` at the specified interval or when the `ExternalSecret` specification changes Example: ```yaml apiVersion: external-secrets.io/v1 kind: ExternalSecret metadata: name: example spec: refreshPolicy: Periodic refreshInterval: 1h0m0s # Update every hour # other fields... ``` ### OnChange With `refreshPolicy: OnChange`, the controller will: - Create the `Kind=Secret` if it doesn't exist - Update the `Kind=Secret` only when the `ExternalSecret`'s metadata or specification changes - This policy is independent of the `refreshInterval` value - Useful when you want to manually control when the secret is updated, by modifying the `ExternalSecret` resource Example: ```yaml apiVersion: external-secrets.io/v1 kind: ExternalSecret metadata: name: example spec: refreshPolicy: OnChange # other fields... ``` ## Manual Refresh If supported by the configured `refreshPolicy`, you can manually trigger a refresh of the `Kind=Secret` by updating the annotations of the `ExternalSecret`: ``` kubectl annotate es my-es force-sync=$(date +%s) --overwrite ``` ## Features Individual features are described in the [Guides section](../guides/introduction.md): \* [Find many secrets / Extract from structured data](../guides/getallsecrets.md) \* [Templating](../guides/templating.md) \* [Using Generators](../guides/generator.md) \* [Secret Ownership and Deletion](../guides/ownership-deletion-policy.md) \* [Key Rewriting](../guides/datafrom-rewrite.md) \* [Decoding Strategy](../guides/decoding-strategy.md) ## Example Take a look at an annotated example to understand the design behind the `ExternalSecret`. ``` yaml {% include 'full-external-secret.yaml' %} ``` | https://github.com/external-secrets/external-secrets/blob/main//docs/api/externalsecret.md | main | external-secrets | [
-0.1007113829255104,
0.02780723199248314,
-0.06186514347791672,
0.03801574558019638,
-0.007913971319794655,
0.003589602652937174,
0.026868578046560287,
0.0851307064294815,
-0.0217849500477314,
-0.029173927381634712,
0.05990337207913399,
-0.060562875121831894,
0.0005295035080052912,
0.01257... | 0.070791 |
The `ClusterPushSecret` is a cluster scoped resource that can be used to manage `PushSecret` resources in specific namespaces. With `namespaceSelectors` you can select namespaces in which the PushSecret should be created. If there is a conflict with an existing resource the controller will error out. ## Example Below is an example of the `ClusterPushSecret` in use. ```yaml {% include 'full-cluster-push-secret.yaml' %} ``` The result of the created Secret object will look like: ```yaml # The destination secret that will be templated and pushed by ClusterPushSecret. apiVersion: v1 kind: Secret metadata: name: destination-secret stringData: best-pokemon-dst: "PIKACHU is the really best!" ``` | https://github.com/external-secrets/external-secrets/blob/main//docs/api/clusterpushsecret.md | main | external-secrets | [
-0.06612295657396317,
-0.09286241233348846,
-0.04707647114992142,
0.05850396305322647,
0.01667727343738079,
0.02888067252933979,
-0.02833518385887146,
-0.00040663083200342953,
0.014007319696247578,
0.015851985663175583,
0.07699023932218552,
-0.09817799925804138,
0.034671202301979065,
0.004... | 0.090568 |
# Components ## Overview External Secrets comes with three components: `Core Controller`, `Webhook` and `Cert Controller`. This is due to the need to implement conversion webhooks in order to convert custom resources between api versions and to provide a ValidatingWebhook for the `ExternalSecret` and `SecretStore` resources. These features are optional but highly recommended. You can disable them with helm chart values `certController.create=false`, `webhook.create=false` and `crds.conversion.enabled=false`.  ### TLS Bootstrap Cert-controller is responsible for (1) generating TLS credentials which will be used by the webhook component and (2) injecting the certificate as `caBundle` into `Kind=CustomResourceDefinition` for conversion webhooks and `Kind=ValidatingWebhookConfiguration` for validating admission webhook. The TLS credentials are stored in a `Kind=Secret` which is consumed by the webhook. {: style="width:70%;"} | https://github.com/external-secrets/external-secrets/blob/main//docs/api/components.md | main | external-secrets | [
-0.11011573672294617,
0.08337543159723282,
-0.06075255945324898,
0.008451523259282112,
0.05834077671170235,
-0.025007149204611778,
-0.03658874332904816,
0.04934968799352646,
0.083292156457901,
-0.029574479907751083,
0.062261030077934265,
-0.07456963509321213,
0.09185701608657837,
0.0021636... | -0.001052 |
# Controller Options The external-secrets binary includes three components: `core controller`, `certcontroller` and `webhook`. ## Core Controller Flags The core controller is invoked without a subcommand and can be configured with the following flags: | Name | Type | Default | Description | |-----------------------------------------------|----------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `--client-burst` | int | 100 | Maximum Burst allowed to be passed to rest.Client | | `--client-qps` | float32 | 50 | QPS configuration to be passed to rest.Client | | `--concurrent` | int | 1 | The number of concurrent reconciles. | | `--controller-class` | string | default | The controller is instantiated with a specific controller name and filters ES based on this property | | `--enable-cluster-external-secret-reconciler` | boolean | true | Enables the cluster external secret reconciler. | | `--enable-cluster-store-reconciler` | boolean | true | Enables the cluster store reconciler. | `--enable-secret-store-reconciler` | boolean | true | Enables the secret store reconciler | | `--enable-push-secret-reconciler` | boolean | true | Enables the push secret reconciler. | | `--enable-cluster-push-secret-reconciler` | boolean | true | Enables the cluster push secret reconciler. | | `--enable-secrets-caching` | boolean | false | Enable secrets caching for ALL secrets in the cluster (WARNING: can increase memory usage). | | `--enable-configmaps-caching` | boolean | false | Enable configmaps caching for ALL configmaps in the cluster (WARNING: can increase memory usage). | | `--enable-managed-secrets-caching` | boolean | true | Enable secrets caching for secrets managed by an ExternalSecret. | | `--enable-flood-gate` | boolean | true | Enable flood gate. External secret will be reconciled only if the ClusterStore or Store have an healthy or unknown state. | | `--enable-extended-metric-labels` | boolean | true | Enable recommended kubernetes annotations as labels in metrics. | | `--enable-leader-election` | boolean | false | Enable leader election for controller manager. Enabling this will ensure there is only one active controller manager. | | `--experimental-enable-aws-session-cache` | boolean | false | DEPRECATED: this flag is no longer used and will be removed since aws sdk v2 has its own session cache. | | `--help` | | | help for external-secrets | | `--loglevel` | string | info | loglevel to use, one of: debug, info, warn, error, dpanic, panic, fatal | | `--zap-time-encoding` | string | epoch | time encoding to use, one of: epoch, millis, nano, iso8601, rfc3339, rfc3339nano | | `--live-addr` | string | :8082 | The address the live endpoint binds to | | `--metrics-addr` | string | :8080 | The address the metric endpoint binds to. | | `--namespace` | string | - | watch external secrets scoped in the provided namespace only. ClusterSecretStore can be used but only work if it doesn't reference resources from other namespaces | | `--store-requeue-interval` | duration | 5m0s | Default Time duration between reconciling (Cluster)SecretStores | | `--enable-http2` | boolean | false | If set, HTTP/2 will be enabled for the metrics server | ## Cert Controller Flags | Name | Type | Default | Descripton | |----------------------------|----------|--------------------------|-----------------------------------------------------------------------------------------------------------------------| | `--crd-requeue-interval` | duration | 5m0s | Time duration between reconciling CRDs for new certs | | `--enable-leader-election` | boolean | false | Enable leader election for controller manager. Enabling this will ensure there is only one active controller manager. | | `--healthz-addr` | string | :8081 | The address the health endpoint binds to. | | `--help` | | | help for certcontroller | | `--loglevel` | string | info | loglevel to use, one of: debug, info, warn, error, dpanic, panic, fatal | | `--zap-time-encoding` | string | epoch | time encoding to use, one of: epoch, millis, nano, iso8601, rfc3339, rfc3339nano | | `--metrics-addr` | https://github.com/external-secrets/external-secrets/blob/main//docs/api/controller-options.md | main | external-secrets | [
-0.07232919335365295,
-0.011883536353707314,
-0.13840189576148987,
-0.00752749340608716,
0.021179962903261185,
-0.03592437133193016,
-0.03788599744439125,
0.037977464497089386,
0.0308176688849926,
0.015317199751734734,
0.060944005846977234,
-0.09437654167413712,
-0.00821455754339695,
-0.06... | 0.046796 |
`--help` | | | help for certcontroller | | `--loglevel` | string | info | loglevel to use, one of: debug, info, warn, error, dpanic, panic, fatal | | `--zap-time-encoding` | string | epoch | time encoding to use, one of: epoch, millis, nano, iso8601, rfc3339, rfc3339nano | | `--metrics-addr` | string | :8080 | The address the metric endpoint binds to. | | `--secret-name` | string | external-secrets-webhook | Secret to store certs for webhook | | `--secret-namespace` | string | default | namespace of the secret to store certs | | `--service-name` | string | external-secrets-webhook | Webhook service name | | `--service-namespace` | string | default | Webhook service namespace | | `--enable-http2` | boolean | false | If set, HTTP/2 will be enabled for the metrics server | ## Webhook Flags | Name | Type | Default | Description | |------------------------|----------|---------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `--cert-dir` | string | /tmp/k8s-webhook-server/serving-certs | path to check for certs | | `--check-interval` | duration | 5m0s | certificate check interval | | `--dns-name` | string | localhost | DNS name to validate certificates with | | `--healthz-addr` | string | :8081 | The address the health endpoint binds to. | | `--help` | | | help for webhook | | `--loglevel` | string | info | loglevel to use, one of: debug, info, warn, error, dpanic, panic, fatal | | `--zap-time-encoding` | string | epoch | time encoding to use, one of: epoch, millis, nano, iso8601, rfc3339, rfc3339nano | | `--lookahead-interval` | duration | 2160h0m0s (90d) | certificate check interval | | `--metrics-addr` | string | :8080 | The address the metric endpoint binds to. | | `--port` | number | 10250 | Port number that the webhook server will serve. | | `--tls-ciphers` | string | | comma separated list of tls ciphers allowed. This does not apply to TLS 1.3 as the ciphers are selected automatically. The order of this list does not give preference to the ciphers, the ordering is done automatically. Full lists of available ciphers can be found at https://pkg.go.dev/crypto/tls#pkg-constants. E.g. 'TLS\_ECDHE\_ECDSA\_WITH\_CHACHA20\_POLY1305\_SHA256,TLS\_ECDHE\_RSA\_WITH\_CHACHA20\_POLY1305\_SHA256' | | `--tls-min-version` | string | 1.2 | minimum version of TLS supported. | | `--enable-http2` | boolean | false | If set, HTTP/2 will be enabled for the metrics and webhook servers | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/controller-options.md | main | external-secrets | [
-0.059017445892095566,
-0.0071967169642448425,
-0.1279495358467102,
-0.03168480470776558,
-0.030619848519563675,
-0.0060133119113743305,
0.004395004827529192,
0.03169571980834007,
0.008027427829802036,
-0.0018660200294107199,
0.06116867437958717,
-0.137618750333786,
0.04071459919214249,
0.... | 0.097219 |
# ExternalSecret Selectable Fields As of Kubernetes 1.30, External Secrets Operator supports selectable fields for querying ExternalSecret resources based on spec field values. This feature enables efficient server-side filtering of ExternalSecret resources. ## Overview Selectable fields allow you to use `kubectl` field selectors and Kubernetes API field selectors to filter ExternalSecret resources based on specific spec field values rather than just metadata fields like `metadata.name` and `metadata.namespace`. ## Supported Selectable Fields The following spec fields are available for field selectors in ExternalSecret resources: - `spec.secretStoreRef.name` - Name of the SecretStore or ClusterSecretStore - `spec.secretStoreRef.kind` - Type of store (SecretStore or ClusterSecretStore) - `spec.target.name` - Name of the target Kubernetes Secret - `spec.refreshInterval` - Refresh interval for the external secret ## Usage Examples ### Using kubectl with field selectors Query all ExternalSecrets that use a specific SecretStore: ```bash kubectl get externalsecrets --field-selector spec.secretStoreRef.name=my-vault-store ``` Find all ExternalSecrets that use ClusterSecretStores: ```bash kubectl get externalsecrets --field-selector spec.secretStoreRef.kind=ClusterSecretStore ``` Find ExternalSecrets with a specific refresh interval: ```bash kubectl get externalsecrets --field-selector spec.refreshInterval=15m ``` Find ExternalSecrets that create a specific target secret: ```bash kubectl get externalsecrets --field-selector spec.target.name=database-credentials ``` You can also combine multiple field selectors: ```bash kubectl get externalsecrets --field-selector spec.secretStoreRef.kind=SecretStore,spec.refreshInterval=1h ``` ### Using the Kubernetes API When using the Kubernetes client libraries, you can use field selectors programmatically: ```go import ( metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "sigs.k8s.io/controller-runtime/pkg/client" ) // List ExternalSecrets using a specific SecretStore fieldSelector := fields.OneTermEqualSelector("spec.secretStoreRef.name", "my-vault-store") listOptions := &client.ListOptions{ FieldSelector: fieldSelector, } var externalSecrets esv1.ExternalSecretList err := kubeClient.List(ctx, &externalSecrets, listOptions) ``` ### Advanced Filtering You can combine field selectors with label selectors for more complex queries: ```bash # Find ExternalSecrets with specific store AND specific label kubectl get externalsecrets \ --field-selector spec.secretStoreRef.kind=ClusterSecretStore \ --selector environment=production ``` | https://github.com/external-secrets/external-secrets/blob/main//docs/api/selectable-fields.md | main | external-secrets | [
-0.0049658529460430145,
0.015564064495265484,
-0.013898734003305435,
0.026052948087453842,
0.06652479618787766,
-0.0255307424813509,
0.06304943561553955,
-0.0004877523169852793,
0.1125289797782898,
-0.0007480316562578082,
-0.02417207509279251,
-0.10118796676397324,
-0.022912828251719475,
-... | 0.127179 |
 The `SecretStore` is namespaced and specifies how to access the external API. The SecretStore maps to exactly one instance of an external API. By design, SecretStores are bound to a namespace and can not reference resources across namespaces. If you want to design cross-namespace SecretStores you must use [ClusterSecretStores](./clustersecretstore.md) which do not have this limitation. Different Store Providers have different stability levels, maintenance status, and support. To check the full list, please see [Stability Support](../introduction/stability-support.md). !!! note "Unmaintained Stores generate events" Admission webhooks and controllers will emit warning events for providers without a explicit maintainer. To disable controller warning events, you can add `external-secrets.io/ignore-maintenance-checks: "true"` annotation to the SecretStore. Admission webhook warning cannot be disabled. ## Example For a full list of supported fields see [spec](./spec.md) or dig into our [guides](../guides/introduction.md). ``` yaml {% include 'full-secret-store.yaml' %} ``` | https://github.com/external-secrets/external-secrets/blob/main//docs/api/secretstore.md | main | external-secrets | [
-0.08747157454490662,
-0.022486012428998947,
-0.0866730585694313,
0.041129108518362045,
0.018987711519002914,
-0.01986038126051426,
-0.052558016031980515,
0.004452737048268318,
-0.005166463553905487,
-0.0036339955404400826,
0.06321598589420319,
-0.017155427485704422,
0.03378059342503548,
-... | 0.09282 |
# Metrics The External Secrets Operator exposes its Prometheus metrics in the `/metrics` path. To enable it, set the `serviceMonitor.enabled` Helm flag to `true`. If you are using a different monitoring tool that also needs a `/metrics` endpoint, you can set the `metrics.service.enabled` Helm flag to `true`. In addition you can also set `webhook.metrics.service.enabled` and `certController.metrics.service.enabled` to scrape the other components. The Operator has [the controller-runtime metrics inherited from kubebuilder](https://book.kubebuilder.io/reference/metrics-reference.html) plus some custom metrics with a resource name prefix, such as `externalsecret\_`. ## Cluster External Secret Metrics | Name | Type | Description | |--------------------------------------------|-------|------------------------------------------------------------| | `clusterexternalsecret\_status\_condition` | Gauge | The status condition of a specific Cluster External Secret | | `clusterexternalsecret\_reconcile\_duration` | Gauge | The duration time to reconcile the Cluster External Secret | ## External Secret Metrics | Name | Type | Description | |------------------------------------------------|-----------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `externalsecret\_provider\_api\_calls\_count` | Counter | Number of API calls made to an upstream secret provider API. The metric provides a `provider`, `call` and `status` labels. | | `externalsecret\_sync\_calls\_total` | Counter | Total number of the External Secret sync calls | | `externalsecret\_sync\_calls\_error` | Counter | Total number of the External Secret sync errors | | `externalsecret\_status\_condition` | Gauge | The status condition of a specific External Secret | | `externalsecret\_reconcile\_duration` | Gauge | The duration time to reconcile the External Secret | ## Push Secret Metrics | Name | Type | Description | |-----------------------------------------|-------|---------------------------------------------------------| | `pushsecret\_status\_condition` | Gauge | The status condition of a specific Push Secret | | `pushsecret\_reconcile\_duration` | Gauge | The duration time to reconcile the Push Secret | ## Cluster Secret Store Metrics | Name | Type | Description | |-----------------------------------------|-------|---------------------------------------------------------| | `clustersecretstore\_status\_condition` | Gauge | The status condition of a specific Cluster Secret Store | | `clustersecretstore\_reconcile\_duration` | Gauge | The duration time to reconcile the Cluster Secret Store | # Secret Store Metrics | Name | Type | Description | |----------------------------------|-------|-------------------------------------------------| | `secretstore\_status\_condition` | Gauge | The status condition of a specific Secret Store | | `secretstore\_reconcile\_duration` | Gauge | The duration time to reconcile the Secret Store | ## Controller Runtime Metrics See [the kubebuilder documentation](https://book.kubebuilder.io/reference/metrics-reference.html) on the default exported metrics by controller-runtime. ## Dashboard We provide a [Grafana Dashboard](https://raw.githubusercontent.com/external-secrets/external-secrets/main/docs/snippets/dashboard.json) that gives you an overview of External Secrets Operator:   ## Service Level Indicators and Alerts We find the following Service Level Indicators (SLIs) useful when operating ESO. They should give you a good starting point and hints to develop your own Service Level Objectives (SLOs). #### Webhook HTTP Status Codes The webhook HTTP status code indicates that a HTTP Request was answered successfully or not. If the Webhook pod is not able to serve the requests properly then that failure may cascade down to the controller or any other user of `kube-apiserver`. SLI Example: request error percentage. ``` sum(increase(controller\_runtime\_webhook\_requests\_total{service=~"external-secrets.\*",code="500"}[1m])) / sum(increase(controller\_runtime\_webhook\_requests\_total{service=~"external-secrets.\*"}[1m])) ``` #### Webhook HTTP Request Latency If the webhook server is not able to respond in time then that may cause a timeout at the client. This failure may cascade down to the controller or any other user of `kube-apiserver`. SLI Example: p99 across all webhook requests. ``` histogram\_quantile(0.99, sum(rate(controller\_runtime\_webhook\_latency\_seconds\_bucket{service=~"external-secrets.\*"}[5m])) by (le) ) ``` #### Controller Workqueue Depth If the workqueue depth is > 0 for a longer period of time then this is an indicator for the controller not being able to reconcile resources in time. I.e. delivery of secret updates is delayed. Note: when a controller is restarted, then `queue length = total number of resources`. Make sure to measure the time it takes for the controller to fully reconcile all secrets after a restart. In large clusters this | https://github.com/external-secrets/external-secrets/blob/main//docs/api/metrics.md | main | external-secrets | [
-0.058781858533620834,
-0.04011043906211853,
-0.06854193657636642,
0.02679385617375374,
-0.02716592699289322,
-0.04134722426533699,
-0.028793243691325188,
0.008815429173409939,
0.09267137199640274,
-0.017063409090042114,
0.005176906008273363,
-0.1516999751329422,
0.0059278616681694984,
-0.... | 0.099008 |
able to reconcile resources in time. I.e. delivery of secret updates is delayed. Note: when a controller is restarted, then `queue length = total number of resources`. Make sure to measure the time it takes for the controller to fully reconcile all secrets after a restart. In large clusters this may take a while, make sure to define an acceptable timeframe to fully reconcile all resources. ``` sum( workqueue\_depth{service=~"external-secrets.\*"} ) by (name) ``` #### Controller Reconcile Latency The controller should be able to reconcile resources within a reasonable timeframe. When latency is high secret delivery may impacted. SLI Example: p99 across all controllers. ``` histogram\_quantile(0.99, sum(rate(controller\_runtime\_reconcile\_time\_seconds\_bucket{service=~"external-secrets.\*"}[5m])) by (le) ) ``` #### Controller Reconcile Error The controller should be able to reconcile resources without errors. When errors occur secret delivery may be impacted which could cascade down to the secret consuming applications. ``` sum(increase( controller\_runtime\_reconcile\_total{service=~"external-secrets.\*",controller=~"$controller",result="error"}[1m]) ) by (result) ``` | https://github.com/external-secrets/external-secrets/blob/main//docs/api/metrics.md | main | external-secrets | [
-0.09909410774707794,
-0.05130169913172722,
-0.04190696030855179,
0.0717601552605629,
0.04029322788119316,
-0.08515562117099762,
0.0017939828103408217,
-0.04123544692993164,
0.06617481261491776,
0.010242006741464138,
0.04533195495605469,
0.04424954205751419,
-0.012506349943578243,
-0.03600... | 0.055542 |
Packages: * [external-secrets.io/v1](#external-secrets.io%2fv1) * [external-secrets.io/v1alpha1](#external-secrets.io%2fv1alpha1) * [external-secrets.io/v1beta1](#external-secrets.io%2fv1beta1) * [generators.external-secrets.io/v1alpha1](#generators.external-secrets.io%2fv1alpha1) ## external-secrets.io/v1 Package v1 contains resources for external-secrets Resource Types: ### AWSAuth (*Appears on:* [AWSProvider](#external-secrets.io/v1.AWSProvider)) AWSAuth tells the controller how to do authentication with aws. Only one of secretRef or jwt can be specified. if none is specified the controller will load credentials using the aws sdk defaults. | Field | Description | | --- | --- | | `secretRef` *[AWSAuthSecretRef](#external-secrets.io/v1.AWSAuthSecretRef)* | *(Optional)* | | `jwt` *[AWSJWTAuth](#external-secrets.io/v1.AWSJWTAuth)* | *(Optional)* | ### AWSAuthSecretRef (*Appears on:* [AWSAuth](#external-secrets.io/v1.AWSAuth)) AWSAuthSecretRef holds secret references for AWS credentials both AccessKeyID and SecretAccessKey must be defined in order to properly authenticate. | Field | Description | | --- | --- | | `accessKeyIDSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The AccessKeyID is used for authentication | | `secretAccessKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The SecretAccessKey is used for authentication | | `sessionTokenSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The SessionToken used for authentication This must be defined if AccessKeyID and SecretAccessKey are temporary credentials see: <https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html> | ### AWSJWTAuth (*Appears on:* [AWSAuth](#external-secrets.io/v1.AWSAuth)) AWSJWTAuth stores reference to Authenticate against AWS using service account tokens. | Field | Description | | --- | --- | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | | ### AWSProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) AWSProvider configures a store to sync secrets with AWS. | Field | Description | | --- | --- | | `service` *[AWSServiceType](#external-secrets.io/v1.AWSServiceType)* | Service defines which service should be used to fetch the secrets | | `auth` *[AWSAuth](#external-secrets.io/v1.AWSAuth)* | *(Optional)* Auth defines the information necessary to authenticate against AWS if not set aws sdk will infer credentials from your environment see: <https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#specifying-credentials> | | `role` *string* | *(Optional)* Role is a Role ARN which the provider will assume | | `region` *string* | AWS Region to be used for the provider | | `additionalRoles` *[]string* | *(Optional)* AdditionalRoles is a chained list of Role ARNs which the provider will sequentially assume before assuming the Role | | `externalID` *string* | AWS External ID set on assumed IAM roles | | `sessionTags` *[[]\*github.com/external-secrets/external-secrets/apis/externalsecrets/v1.Tag](#external-secrets.io/v1.*github.com/external-secrets/external-secrets/apis/externalsecrets/v1.Tag)* | *(Optional)* AWS STS assume role session tags | | `secretsManager` *[SecretsManager](#external-secrets.io/v1.SecretsManager)* | *(Optional)* SecretsManager defines how the provider behaves when interacting with AWS SecretsManager | | `transitiveTagKeys` *[]string* | *(Optional)* AWS STS assume role transitive session tags. Required when multiple rules are used with the provider | | `prefix` *string* | *(Optional)* Prefix adds a prefix to all retrieved values. | ### AWSServiceType (`string` alias) (*Appears on:* [AWSProvider](#external-secrets.io/v1.AWSProvider)) AWSServiceType is a enum that defines the service/API that is used to fetch the secrets. | Value | Description | | --- | --- | | "ParameterStore" | AWSServiceParameterStore is the AWS SystemsManager ParameterStore service. see: <https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html> | | "SecretsManager" | AWSServiceSecretsManager is the AWS SecretsManager service. see: <https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html> | ### AkeylessAuth (*Appears on:* [AkeylessProvider](#external-secrets.io/v1.AkeylessProvider)) AkeylessAuth configures how the operator authenticates with Akeyless. | Field | Description | | --- | --- | | `secretRef` *[AkeylessAuthSecretRef](#external-secrets.io/v1.AkeylessAuthSecretRef)* | *(Optional)* Reference to a Secret that contains the details to authenticate with Akeyless. | | `kubernetesAuth` *[AkeylessKubernetesAuth](#external-secrets.io/v1.AkeylessKubernetesAuth)* | *(Optional)* Kubernetes authenticates with Akeyless by passing the ServiceAccount token stored in the named Secret resource. | ### AkeylessAuthSecretRef (*Appears on:* [AkeylessAuth](#external-secrets.io/v1.AkeylessAuth)) AkeylessAuthSecretRef references a Secret that contains the details to authenticate with Akeyless. AKEYLESS\_ACCESS\_TYPE\_PARAM: AZURE\_OBJ\_ID OR GCP\_AUDIENCE OR ACCESS\_KEY OR KUB\_CONFIG\_NAME. | Field | Description | | --- | --- | | `accessID` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The SecretAccessID is used for authentication | | `accessType` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `accessTypeParam` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### AkeylessKubernetesAuth (*Appears on:* [AkeylessAuth](#external-secrets.io/v1.AkeylessAuth)) AkeylessKubernetesAuth configures Kubernetes authentication with Akeyless. It authenticates with Kubernetes ServiceAccount token stored. | Field | Description | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.1619214117527008,
-0.003402082249522209,
-0.0736924335360527,
-0.006336917635053396,
0.08001778274774551,
-0.003788510337471962,
0.010568471625447273,
0.025654355064034462,
0.06676347553730011,
0.008093073032796383,
-0.002922129351645708,
-0.06810076534748077,
0.026802506297826767,
-0.0... | 0.080926 |
| `accessID` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The SecretAccessID is used for authentication | | `accessType` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `accessTypeParam` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### AkeylessKubernetesAuth (*Appears on:* [AkeylessAuth](#external-secrets.io/v1.AkeylessAuth)) AkeylessKubernetesAuth configures Kubernetes authentication with Akeyless. It authenticates with Kubernetes ServiceAccount token stored. | Field | Description | | --- | --- | | `accessID` *string* | the Akeyless Kubernetes auth-method access-id | | `k8sConfName` *string* | Kubernetes-auth configuration name in Akeyless-Gateway | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* Optional service account field containing the name of a kubernetes ServiceAccount. If the service account is specified, the service account secret token JWT will be used for authenticating with Akeyless. If the service account selector is not supplied, the secretRef will be used instead. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* Optional secret field containing a Kubernetes ServiceAccount JWT used for authenticating with Akeyless. If a name is specified without a key, `token` is the default. If one is not specified, the one bound to the controller will be used. | ### AkeylessProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) AkeylessProvider Configures an store to sync secrets using Akeyless KV. | Field | Description | | --- | --- | | `akeylessGWApiURL` *string* | Akeyless GW API Url from which the secrets to be fetched from. | | `authSecretRef` *[AkeylessAuth](#external-secrets.io/v1.AkeylessAuth)* | Auth configures how the operator authenticates with Akeyless. | | `caBundle` *[]byte* | *(Optional)* PEM/base64 encoded CA bundle used to validate Akeyless Gateway certificate. Only used if the AkeylessGWApiURL URL is using HTTPS protocol. If not set the system root certificates are used to validate the TLS connection. | | `caProvider` *[CAProvider](#external-secrets.io/v1.CAProvider)* | *(Optional)* The provider for the CA bundle to use to validate Akeyless Gateway certificate. | ### AlibabaAuth (*Appears on:* [AlibabaProvider](#external-secrets.io/v1.AlibabaProvider)) AlibabaAuth contains a secretRef for credentials. | Field | Description | | --- | --- | | `secretRef` *[AlibabaAuthSecretRef](#external-secrets.io/v1.AlibabaAuthSecretRef)* | *(Optional)* | | `rrsa` *[AlibabaRRSAAuth](#external-secrets.io/v1.AlibabaRRSAAuth)* | *(Optional)* | ### AlibabaAuthSecretRef (*Appears on:* [AlibabaAuth](#external-secrets.io/v1.AlibabaAuth)) AlibabaAuthSecretRef holds secret references for Alibaba credentials. | Field | Description | | --- | --- | | `accessKeyIDSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The AccessKeyID is used for authentication | | `accessKeySecretSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The AccessKeySecret is used for authentication | ### AlibabaProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) AlibabaProvider configures a store to sync secrets using the Alibaba Secret Manager provider. | Field | Description | | --- | --- | | `auth` *[AlibabaAuth](#external-secrets.io/v1.AlibabaAuth)* | | | `regionID` *string* | Alibaba Region to be used for the provider | ### AlibabaRRSAAuth (*Appears on:* [AlibabaAuth](#external-secrets.io/v1.AlibabaAuth)) AlibabaRRSAAuth authenticates against Alibaba using RRSA. | Field | Description | | --- | --- | | `oidcProviderArn` *string* | | | `oidcTokenFilePath` *string* | | | `roleArn` *string* | | | `sessionName` *string* | | ### AuthorizationProtocol (*Appears on:* [WebhookProvider](#external-secrets.io/v1.WebhookProvider)) AuthorizationProtocol contains the protocol-specific configuration | Field | Description | | --- | --- | | `ntlm` *[NTLMProtocol](#external-secrets.io/v1.NTLMProtocol)* | *(Optional)* NTLMProtocol configures the store to use NTLM for auth | ### AwsAuthCredentials (*Appears on:* [InfisicalAuth](#external-secrets.io/v1.InfisicalAuth)) AwsAuthCredentials represents the credentials for AWS authentication. | Field | Description | | --- | --- | | `identityId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### AwsCredentialsConfig (*Appears on:* [GCPWorkloadIdentityFederation](#external-secrets.io/v1.GCPWorkloadIdentityFederation)) AwsCredentialsConfig holds the region and the Secret reference which contains the AWS credentials. | Field | Description | | --- | --- | | `region` *string* | region is for configuring the AWS region to be used. | | `awsCredentialsSecretRef` *[SecretReference](#external-secrets.io/v1.SecretReference)* | awsCredentialsSecretRef is the reference to the secret which holds the AWS credentials. Secret should be created with below names for keys - aws\_access\_key\_id: Access Key ID, which is the unique identifier for the | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.08954057842493057,
0.04864443838596344,
-0.07131615281105042,
0.025473108515143394,
0.010896893218159676,
0.01647925190627575,
0.044367771595716476,
-0.014439304359257221,
0.039652567356824875,
-0.021042734384536743,
0.05223468691110611,
0.00815493892878294,
-0.017778247594833374,
0.007... | 0.07414 |
*string* | region is for configuring the AWS region to be used. | | `awsCredentialsSecretRef` *[SecretReference](#external-secrets.io/v1.SecretReference)* | awsCredentialsSecretRef is the reference to the secret which holds the AWS credentials. Secret should be created with below names for keys - aws\_access\_key\_id: Access Key ID, which is the unique identifier for the AWS account or the IAM user. - aws\_secret\_access\_key: Secret Access Key, which is used to authenticate requests made to AWS services. - aws\_session\_token: Session Token, is the short-lived token to authenticate requests made to AWS services. | ### AzureAuthCredentials (*Appears on:* [InfisicalAuth](#external-secrets.io/v1.InfisicalAuth)) AzureAuthCredentials represents the credentials for Azure authentication. | Field | Description | | --- | --- | | `identityId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `resource` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* | ### AzureAuthType (`string` alias) (*Appears on:* [AzureKVProvider](#external-secrets.io/v1.AzureKVProvider)) AzureAuthType describes how to authenticate to the Azure Keyvault Only one of the following auth types may be specified. If none of the following auth type is specified, the default one is ServicePrincipal. | Value | Description | | --- | --- | | "ManagedIdentity" | AzureManagedIdentity uses Managed Identity to authenticate. Used with aad-pod-identity installed in the cluster. | | "ServicePrincipal" | AzureServicePrincipal uses service principal to authenticate, which needs a tenantId, a clientId and a clientSecret. | | "WorkloadIdentity" | AzureWorkloadIdentity uses Workload Identity service accounts to authenticate. | ### AzureCustomCloudConfig (*Appears on:* [AzureKVProvider](#external-secrets.io/v1.AzureKVProvider)) AzureCustomCloudConfig specifies custom cloud configuration for private Azure environments IMPORTANT: Custom cloud configuration is ONLY supported when UseAzureSDK is true. The legacy go-autorest SDK does not support custom cloud endpoints. | Field | Description | | --- | --- | | `activeDirectoryEndpoint` *string* | ActiveDirectoryEndpoint is the AAD endpoint for authentication Required when using custom cloud configuration | | `keyVaultEndpoint` *string* | *(Optional)* KeyVaultEndpoint is the Key Vault service endpoint | | `keyVaultDNSSuffix` *string* | *(Optional)* KeyVaultDNSSuffix is the DNS suffix for Key Vault URLs | | `resourceManagerEndpoint` *string* | *(Optional)* ResourceManagerEndpoint is the Azure Resource Manager endpoint | ### AzureEnvironmentType (`string` alias) (*Appears on:* [AzureKVProvider](#external-secrets.io/v1.AzureKVProvider), [ACRAccessTokenSpec](#generators.external-secrets.io/v1alpha1.ACRAccessTokenSpec)) AzureEnvironmentType specifies the Azure cloud environment endpoints to use for connecting and authenticating with Azure. By default, it points to the public cloud AAD endpoint. The following endpoints are available, also see here: <https://github.com/Azure/go-autorest/blob/main/autorest/azure/environments.go#L152> PublicCloud, USGovernmentCloud, ChinaCloud, GermanCloud, AzureStackCloud | Value | Description | | --- | --- | | "AzureStackCloud" | | | "ChinaCloud" | | | "GermanCloud" | | | "PublicCloud" | | | "USGovernmentCloud" | | ### AzureKVAuth (*Appears on:* [AzureKVProvider](#external-secrets.io/v1.AzureKVProvider)) AzureKVAuth is the configuration used to authenticate with Azure. | Field | Description | | --- | --- | | `clientId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The Azure clientId of the service principle or managed identity used for authentication. | | `tenantId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The Azure tenantId of the managed identity used for authentication. | | `clientSecret` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The Azure ClientSecret of the service principle used for authentication. | | `clientCertificate` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The Azure ClientCertificate of the service principle used for authentication. | ### AzureKVProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) AzureKVProvider configures a store to sync secrets using Azure KV. | Field | Description | | --- | --- | | `authType` *[AzureAuthType](#external-secrets.io/v1.AzureAuthType)* | *(Optional)* Auth type defines how to authenticate to the keyvault service. Valid values are: - “ServicePrincipal” (default): Using a service principal (tenantId, clientId, clientSecret) - “ManagedIdentity”: Using Managed Identity assigned to the pod (see aad-pod-identity) | | `vaultUrl` *string* | Vault Url from which the secrets to be fetched from. | | `tenantId` *string* | *(Optional)* TenantID configures the Azure Tenant to send requests to. Required for ServicePrincipal auth | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.05259763449430466,
0.07302773743867874,
-0.06447169929742813,
0.007000852841883898,
0.018349602818489075,
0.010479831136763096,
0.10208448767662048,
-0.010963743552565575,
0.08735117316246033,
0.102470263838768,
-0.017109913751482964,
-0.06683750450611115,
0.09399046003818512,
-0.026839... | 0.098579 |
service principal (tenantId, clientId, clientSecret) - “ManagedIdentity”: Using Managed Identity assigned to the pod (see aad-pod-identity) | | `vaultUrl` *string* | Vault Url from which the secrets to be fetched from. | | `tenantId` *string* | *(Optional)* TenantID configures the Azure Tenant to send requests to. Required for ServicePrincipal auth type. Optional for WorkloadIdentity. | | `environmentType` *[AzureEnvironmentType](#external-secrets.io/v1.AzureEnvironmentType)* | EnvironmentType specifies the Azure cloud environment endpoints to use for connecting and authenticating with Azure. By default it points to the public cloud AAD endpoint. The following endpoints are available, also see here: <https://github.com/Azure/go-autorest/blob/main/autorest/azure/environments.go#L152> PublicCloud, USGovernmentCloud, ChinaCloud, GermanCloud, AzureStackCloud Use AzureStackCloud when you need to configure custom Azure Stack Hub or Azure Stack Edge endpoints. | | `authSecretRef` *[AzureKVAuth](#external-secrets.io/v1.AzureKVAuth)* | *(Optional)* Auth configures how the operator authenticates with Azure. Required for ServicePrincipal auth type. Optional for WorkloadIdentity. | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* ServiceAccountRef specified the service account that should be used when authenticating with WorkloadIdentity. | | `identityId` *string* | *(Optional)* If multiple Managed Identity is assigned to the pod, you can select the one to be used | | `useAzureSDK` *bool* | *(Optional)* UseAzureSDK enables the use of the new Azure SDK for Go (azcore-based) instead of the legacy go-autorest SDK. This is experimental and may have behavioral differences. Defaults to false (legacy SDK). | | `customCloudConfig` *[AzureCustomCloudConfig](#external-secrets.io/v1.AzureCustomCloudConfig)* | *(Optional)* CustomCloudConfig defines custom Azure endpoints for non-standard clouds. Required when EnvironmentType is AzureStackCloud. Optional for other environment types - useful for Azure China when using Workload Identity with AKS, where the OIDC issuer (login.partner.microsoftonline.cn) differs from the standard China Cloud endpoint (login.chinacloudapi.cn). IMPORTANT: This feature REQUIRES UseAzureSDK to be set to true. Custom cloud configuration is not supported with the legacy go-autorest SDK. | ### BarbicanAuth (*Appears on:* [BarbicanProvider](#external-secrets.io/v1.BarbicanProvider)) BarbicanAuth contains the authentication information for Barbican. | Field | Description | | --- | --- | | `username` *[BarbicanProviderUsernameRef](#external-secrets.io/v1.BarbicanProviderUsernameRef)* | | | `password` *[BarbicanProviderPasswordRef](#external-secrets.io/v1.BarbicanProviderPasswordRef)* | | ### BarbicanProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) BarbicanProvider setup a store to sync secrets with barbican. | Field | Description | | --- | --- | | `authURL` *string* | | | `tenantName` *string* | | | `domainName` *string* | | | `region` *string* | | | `auth` *[BarbicanAuth](#external-secrets.io/v1.BarbicanAuth)* | | ### BarbicanProviderPasswordRef (*Appears on:* [BarbicanAuth](#external-secrets.io/v1.BarbicanAuth)) BarbicanProviderPasswordRef defines a reference to a secret containing password for the Barbican provider. | Field | Description | | --- | --- | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### BarbicanProviderUsernameRef (*Appears on:* [BarbicanAuth](#external-secrets.io/v1.BarbicanAuth)) BarbicanProviderUsernameRef defines a reference to a secret containing username for the Barbican provider. | Field | Description | | --- | --- | | `value` *string* | | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### BeyondTrustProviderSecretRef (*Appears on:* [BeyondtrustAuth](#external-secrets.io/v1.BeyondtrustAuth)) BeyondTrustProviderSecretRef references a value that can be specified directly or via a secret for a BeyondTrustProvider. | Field | Description | | --- | --- | | `value` *string* | *(Optional)* Value can be specified directly to set a value without using a secret. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef references a key in a secret that will be used as value. | ### BeyondtrustAuth (*Appears on:* [BeyondtrustProvider](#external-secrets.io/v1.BeyondtrustProvider)) BeyondtrustAuth provides different ways to authenticate to a BeyondtrustProvider server. | Field | Description | | --- | --- | | `apiKey` *[BeyondTrustProviderSecretRef](#external-secrets.io/v1.BeyondTrustProviderSecretRef)* | APIKey If not provided then ClientID/ClientSecret become required. | | `clientId` *[BeyondTrustProviderSecretRef](#external-secrets.io/v1.BeyondTrustProviderSecretRef)* | ClientID is the API OAuth Client ID. | | `clientSecret` *[BeyondTrustProviderSecretRef](#external-secrets.io/v1.BeyondTrustProviderSecretRef)* | ClientSecret is the API OAuth Client Secret. | | `certificate` *[BeyondTrustProviderSecretRef](#external-secrets.io/v1.BeyondTrustProviderSecretRef)* | Certificate (cert.pem) for use when authenticating with an OAuth client Id using a Client Certificate. | | `certificateKey` *[BeyondTrustProviderSecretRef](#external-secrets.io/v1.BeyondTrustProviderSecretRef)* | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.00048222840996459126,
0.0072554899379611015,
-0.05135764554142952,
0.004387585446238518,
-0.0536661371588707,
0.016982318833470345,
0.02999584935605526,
-0.064602330327034,
0.10852177441120148,
0.08058125525712967,
0.03136332705616951,
-0.027806749567389488,
0.01782863214612007,
0.05779... | 0.054694 |
required. | | `clientId` *[BeyondTrustProviderSecretRef](#external-secrets.io/v1.BeyondTrustProviderSecretRef)* | ClientID is the API OAuth Client ID. | | `clientSecret` *[BeyondTrustProviderSecretRef](#external-secrets.io/v1.BeyondTrustProviderSecretRef)* | ClientSecret is the API OAuth Client Secret. | | `certificate` *[BeyondTrustProviderSecretRef](#external-secrets.io/v1.BeyondTrustProviderSecretRef)* | Certificate (cert.pem) for use when authenticating with an OAuth client Id using a Client Certificate. | | `certificateKey` *[BeyondTrustProviderSecretRef](#external-secrets.io/v1.BeyondTrustProviderSecretRef)* | Certificate private key (key.pem). For use when authenticating with an OAuth client Id | ### BeyondtrustProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) BeyondtrustProvider provides access to a BeyondTrust secrets provider. | Field | Description | | --- | --- | | `auth` *[BeyondtrustAuth](#external-secrets.io/v1.BeyondtrustAuth)* | Auth configures how the operator authenticates with Beyondtrust. | | `server` *[BeyondtrustServer](#external-secrets.io/v1.BeyondtrustServer)* | Auth configures how API server works. | ### BeyondtrustServer (*Appears on:* [BeyondtrustProvider](#external-secrets.io/v1.BeyondtrustProvider)) BeyondtrustServer configures a store to sync secrets using BeyondTrust Password Safe. | Field | Description | | --- | --- | | `apiUrl` *string* | | | `apiVersion` *string* | | | `retrievalType` *string* | The secret retrieval type. SECRET = Secrets Safe (credential, text, file). MANAGED\_ACCOUNT = Password Safe account associated with a system. | | `separator` *string* | A character that separates the folder names. | | `decrypt` *bool* | *(Optional)* When true, the response includes the decrypted password. When false, the password field is omitted. This option only applies to the SECRET retrieval type. Default: true. | | `verifyCA` *bool* | | | `clientTimeOutSeconds` *int* | Timeout specifies a time limit for requests made by this Client. The timeout includes connection time, any redirects, and reading the response body. Defaults to 45 seconds. | ### BitwardenSecretsManagerAuth (*Appears on:* [BitwardenSecretsManagerProvider](#external-secrets.io/v1.BitwardenSecretsManagerProvider)) BitwardenSecretsManagerAuth contains the ref to the secret that contains the machine account token. | Field | Description | | --- | --- | | `secretRef` *[BitwardenSecretsManagerSecretRef](#external-secrets.io/v1.BitwardenSecretsManagerSecretRef)* | | ### BitwardenSecretsManagerProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) BitwardenSecretsManagerProvider configures a store to sync secrets with a Bitwarden Secrets Manager instance. | Field | Description | | --- | --- | | `apiURL` *string* | | | `identityURL` *string* | | | `bitwardenServerSDKURL` *string* | | | `caBundle` *string* | *(Optional)* Base64 encoded certificate for the bitwarden server sdk. The sdk MUST run with HTTPS to make sure no MITM attack can be performed. | | `caProvider` *[CAProvider](#external-secrets.io/v1.CAProvider)* | *(Optional)* see: <https://external-secrets.io/latest/spec/#external-secrets.io/v1alpha1.CAProvider> | | `organizationID` *string* | OrganizationID determines which organization this secret store manages. | | `projectID` *string* | ProjectID determines which project this secret store manages. | | `auth` *[BitwardenSecretsManagerAuth](#external-secrets.io/v1.BitwardenSecretsManagerAuth)* | Auth configures how secret-manager authenticates with a bitwarden machine account instance. Make sure that the token being used has permissions on the given secret. | ### BitwardenSecretsManagerSecretRef (*Appears on:* [BitwardenSecretsManagerAuth](#external-secrets.io/v1.BitwardenSecretsManagerAuth)) BitwardenSecretsManagerSecretRef contains the credential ref to the bitwarden instance. | Field | Description | | --- | --- | | `credentials` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | AccessToken used for the bitwarden instance. | ### ByID (*Appears on:* [FetchingPolicy](#external-secrets.io/v1.FetchingPolicy)) ByID configures the provider to interpret the `data.secretKey.remoteRef.key` field in ExternalSecret as secret ID. ### ByName (*Appears on:* [FetchingPolicy](#external-secrets.io/v1.FetchingPolicy)) ByName configures the provider to interpret the `data.secretKey.remoteRef.key` field in ExternalSecret as secret name. | Field | Description | | --- | --- | | `folderID` *string* | The folder to fetch secrets from | ### CAProvider (*Appears on:* [AkeylessProvider](#external-secrets.io/v1.AkeylessProvider), [BitwardenSecretsManagerProvider](#external-secrets.io/v1.BitwardenSecretsManagerProvider), [ConjurProvider](#external-secrets.io/v1.ConjurProvider), [GitlabProvider](#external-secrets.io/v1.GitlabProvider), [InfisicalProvider](#external-secrets.io/v1.InfisicalProvider), [KubernetesServer](#external-secrets.io/v1.KubernetesServer), [SecretServerProvider](#external-secrets.io/v1.SecretServerProvider), [VaultProvider](#external-secrets.io/v1.VaultProvider)) CAProvider provides a custom certificate authority for accessing the provider’s store. The CAProvider points to a Secret or ConfigMap resource that contains a PEM-encoded certificate. | Field | Description | | --- | --- | | `type` *[CAProviderType](#external-secrets.io/v1.CAProviderType)* | The type of provider to use such as “Secret”, or “ConfigMap”. | | `name` *string* | The name of the object located at the provider type. | | `key` *string* | The | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.12087608128786087,
0.07726150006055832,
-0.0396122932434082,
0.007027327083051205,
0.10322992503643036,
-0.044017452746629715,
0.027498463168740273,
0.045750513672828674,
0.04452233016490936,
-0.09430131316184998,
0.043649669736623764,
-0.042035408318042755,
0.10609064996242523,
0.01977... | -0.010439 |
contains a PEM-encoded certificate. | Field | Description | | --- | --- | | `type` *[CAProviderType](#external-secrets.io/v1.CAProviderType)* | The type of provider to use such as “Secret”, or “ConfigMap”. | | `name` *string* | The name of the object located at the provider type. | | `key` *string* | The key where the CA certificate can be found in the Secret or ConfigMap. | | `namespace` *string* | *(Optional)* The namespace the Provider type is in. Can only be defined when used in a ClusterSecretStore. | ### CAProviderType (`string` alias) (*Appears on:* [CAProvider](#external-secrets.io/v1.CAProvider)) CAProviderType defines the type of provider for certificate authority. | Value | Description | | --- | --- | | "ConfigMap" | CAProviderTypeConfigMap indicates that the CA certificate is stored in a ConfigMap resource. | | "Secret" | CAProviderTypeSecret indicates that the CA certificate is stored in a Secret resource. | ### CSMAuth (*Appears on:* [CloudruSMProvider](#external-secrets.io/v1.CloudruSMProvider)) CSMAuth contains a secretRef for credentials. | Field | Description | | --- | --- | | `secretRef` *[CSMAuthSecretRef](#external-secrets.io/v1.CSMAuthSecretRef)* | *(Optional)* | ### CSMAuthSecretRef (*Appears on:* [CSMAuth](#external-secrets.io/v1.CSMAuth)) CSMAuthSecretRef holds secret references for Cloud.ru credentials. | Field | Description | | --- | --- | | `accessKeyIDSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The AccessKeyID is used for authentication | | `accessKeySecretSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The AccessKeySecret is used for authentication | ### CacheConfig (*Appears on:* [OnePasswordSDKProvider](#external-secrets.io/v1.OnePasswordSDKProvider)) CacheConfig configures client-side caching for read operations. | Field | Description | | --- | --- | | `ttl` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | *(Optional)* TTL is the time-to-live for cached secrets. Format: duration string (e.g., “5m”, “1h”, “30s”) | | `maxSize` *int* | *(Optional)* MaxSize is the maximum number of secrets to cache. When the cache is full, least-recently-used entries are evicted. | ### CertAuth (*Appears on:* [KubernetesAuth](#external-secrets.io/v1.KubernetesAuth)) CertAuth defines certificate-based authentication configuration for Kubernetes. | Field | Description | | --- | --- | | `clientCert` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `clientKey` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### ChefAuth (*Appears on:* [ChefProvider](#external-secrets.io/v1.ChefProvider)) ChefAuth contains a secretRef for credentials. | Field | Description | | --- | --- | | `secretRef` *[ChefAuthSecretRef](#external-secrets.io/v1.ChefAuthSecretRef)* | | ### ChefAuthSecretRef (*Appears on:* [ChefAuth](#external-secrets.io/v1.ChefAuth)) ChefAuthSecretRef holds secret references for chef server login credentials. | Field | Description | | --- | --- | | `privateKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | SecretKey is the Signing Key in PEM format, used for authentication. | ### ChefProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) ChefProvider configures a store to sync secrets using basic chef server connection credentials. | Field | Description | | --- | --- | | `auth` *[ChefAuth](#external-secrets.io/v1.ChefAuth)* | Auth defines the information necessary to authenticate against chef Server | | `username` *string* | UserName should be the user ID on the chef server | | `serverUrl` *string* | ServerURL is the chef server URL used to connect to. If using orgs you should include your org in the url and terminate the url with a “/” | ### CloudruSMProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) CloudruSMProvider configures a store to sync secrets using the Cloud.ru Secret Manager provider. | Field | Description | | --- | --- | | `auth` *[CSMAuth](#external-secrets.io/v1.CSMAuth)* | | | `projectID` *string* | ProjectID is the project, which the secrets are stored in. | ### ClusterExternalSecret ClusterExternalSecret is the Schema for the clusterexternalsecrets API. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[ClusterExternalSecretSpec](#external-secrets.io/v1.ClusterExternalSecretSpec)* | | `externalSecretSpec` *[ExternalSecretSpec](#external-secrets.io/v1.ExternalSecretSpec)* | The spec for the ExternalSecrets to be created | | --- | --- | | `externalSecretName` *string* | *(Optional)* The name of the external | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.03590930998325348,
0.013856316916644573,
-0.028632286936044693,
0.046349674463272095,
0.044450946152210236,
-0.03097333014011383,
0.07626230269670486,
0.03673243150115013,
0.038443394005298615,
-0.02629930153489113,
0.04815826565027237,
-0.13315807282924652,
0.11162674427032471,
-0.0088... | 0.088469 |
`metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[ClusterExternalSecretSpec](#external-secrets.io/v1.ClusterExternalSecretSpec)* | | `externalSecretSpec` *[ExternalSecretSpec](#external-secrets.io/v1.ExternalSecretSpec)* | The spec for the ExternalSecrets to be created | | --- | --- | | `externalSecretName` *string* | *(Optional)* The name of the external secrets to be created. Defaults to the name of the ClusterExternalSecret | | `externalSecretMetadata` *[ExternalSecretMetadata](#external-secrets.io/v1.ExternalSecretMetadata)* | *(Optional)* The metadata of the external secrets to be created | | `namespaceSelector` *[Kubernetes meta/v1.LabelSelector](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#labelselector-v1-meta)* | *(Optional)* The labels to select by to find the Namespaces to create the ExternalSecrets in. Deprecated: Use NamespaceSelectors instead. | | `namespaceSelectors` *[[]\*k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#*k8s.io/apimachinery/pkg/apis/meta/v1.labelselector--)* | *(Optional)* A list of labels to select by to find the Namespaces to create the ExternalSecrets in. The selectors are ORed. | | `namespaces` *[]string* | *(Optional)* Choose namespaces by name. This field is ORed with anything that NamespaceSelectors ends up choosing. Deprecated: Use NamespaceSelectors instead. | | `refreshTime` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | The time in which the controller should reconcile its objects and recheck namespaces for labels. | | | `status` *[ClusterExternalSecretStatus](#external-secrets.io/v1.ClusterExternalSecretStatus)* | | ### ClusterExternalSecretConditionType (`string` alias) (*Appears on:* [ClusterExternalSecretStatusCondition](#external-secrets.io/v1.ClusterExternalSecretStatusCondition)) ClusterExternalSecretConditionType defines a value type for ClusterExternalSecret conditions. | Value | Description | | --- | --- | | "Ready" | ClusterExternalSecretReady is a ClusterExternalSecretConditionType set when the ClusterExternalSecret is ready. | ### ClusterExternalSecretNamespaceFailure (*Appears on:* [ClusterExternalSecretStatus](#external-secrets.io/v1.ClusterExternalSecretStatus)) ClusterExternalSecretNamespaceFailure represents a failed namespace deployment and it’s reason. | Field | Description | | --- | --- | | `namespace` *string* | Namespace is the namespace that failed when trying to apply an ExternalSecret | | `reason` *string* | *(Optional)* Reason is why the ExternalSecret failed to apply to the namespace | ### ClusterExternalSecretSpec (*Appears on:* [ClusterExternalSecret](#external-secrets.io/v1.ClusterExternalSecret)) ClusterExternalSecretSpec defines the desired state of ClusterExternalSecret. | Field | Description | | --- | --- | | `externalSecretSpec` *[ExternalSecretSpec](#external-secrets.io/v1.ExternalSecretSpec)* | The spec for the ExternalSecrets to be created | | `externalSecretName` *string* | *(Optional)* The name of the external secrets to be created. Defaults to the name of the ClusterExternalSecret | | `externalSecretMetadata` *[ExternalSecretMetadata](#external-secrets.io/v1.ExternalSecretMetadata)* | *(Optional)* The metadata of the external secrets to be created | | `namespaceSelector` *[Kubernetes meta/v1.LabelSelector](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#labelselector-v1-meta)* | *(Optional)* The labels to select by to find the Namespaces to create the ExternalSecrets in. Deprecated: Use NamespaceSelectors instead. | | `namespaceSelectors` *[[]\*k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#*k8s.io/apimachinery/pkg/apis/meta/v1.labelselector--)* | *(Optional)* A list of labels to select by to find the Namespaces to create the ExternalSecrets in. The selectors are ORed. | | `namespaces` *[]string* | *(Optional)* Choose namespaces by name. This field is ORed with anything that NamespaceSelectors ends up choosing. Deprecated: Use NamespaceSelectors instead. | | `refreshTime` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | The time in which the controller should reconcile its objects and recheck namespaces for labels. | ### ClusterExternalSecretStatus (*Appears on:* [ClusterExternalSecret](#external-secrets.io/v1.ClusterExternalSecret)) ClusterExternalSecretStatus defines the observed state of ClusterExternalSecret. | Field | Description | | --- | --- | | `externalSecretName` *string* | ExternalSecretName is the name of the ExternalSecrets created by the ClusterExternalSecret | | `failedNamespaces` *[[]ClusterExternalSecretNamespaceFailure](#external-secrets.io/v1.ClusterExternalSecretNamespaceFailure)* | *(Optional)* Failed namespaces are the namespaces that failed to apply an ExternalSecret | | `provisionedNamespaces` *[]string* | *(Optional)* ProvisionedNamespaces are the namespaces where the ClusterExternalSecret has secrets | | `conditions` *[[]ClusterExternalSecretStatusCondition](#external-secrets.io/v1.ClusterExternalSecretStatusCondition)* | *(Optional)* | ### ClusterExternalSecretStatusCondition (*Appears on:* [ClusterExternalSecretStatus](#external-secrets.io/v1.ClusterExternalSecretStatus)) ClusterExternalSecretStatusCondition defines the observed state of a ClusterExternalSecret resource. | Field | Description | | --- | --- | | `type` *[ClusterExternalSecretConditionType](#external-secrets.io/v1.ClusterExternalSecretConditionType)* | | | `status` *[Kubernetes core/v1.ConditionStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#conditionstatus-v1-core)* | | | `message` *string* | *(Optional)* | ### ClusterSecretStore ClusterSecretStore represents a secure external location for storing secrets, which can be referenced as part of `storeRef` fields. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.038103628903627396,
-0.030854349955916405,
-0.03372679650783539,
0.012348423711955547,
0.01641882210969925,
-0.0004846010124310851,
0.011815523728728294,
0.04175858199596405,
0.08530370146036148,
0.04267673194408417,
0.0064116124995052814,
-0.12599234282970428,
-0.005738083738833666,
-0... | 0.165901 |
| | `status` *[Kubernetes core/v1.ConditionStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#conditionstatus-v1-core)* | | | `message` *string* | *(Optional)* | ### ClusterSecretStore ClusterSecretStore represents a secure external location for storing secrets, which can be referenced as part of `storeRef` fields. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[SecretStoreSpec](#external-secrets.io/v1.SecretStoreSpec)* | | `controller` *string* | *(Optional)* Used to select the correct ESO controller (think: ingress.ingressClassName) The ESO controller is instantiated with a specific controller name and filters ES based on this property | | --- | --- | | `provider` *[SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)* | Used to configure the provider. Only one provider may be set | | `retrySettings` *[SecretStoreRetrySettings](#external-secrets.io/v1.SecretStoreRetrySettings)* | *(Optional)* Used to configure HTTP retries on failures. | | `refreshInterval` *int* | *(Optional)* Used to configure store refresh interval in seconds. Empty or 0 will default to the controller config. | | `conditions` *[[]ClusterSecretStoreCondition](#external-secrets.io/v1.ClusterSecretStoreCondition)* | *(Optional)* Used to constrain a ClusterSecretStore to specific namespaces. Relevant only to ClusterSecretStore. | | | `status` *[SecretStoreStatus](#external-secrets.io/v1.SecretStoreStatus)* | | ### ClusterSecretStoreCondition (*Appears on:* [SecretStoreSpec](#external-secrets.io/v1.SecretStoreSpec)) ClusterSecretStoreCondition describes a condition by which to choose namespaces to process ExternalSecrets in for a ClusterSecretStore instance. | Field | Description | | --- | --- | | `namespaceSelector` *[Kubernetes meta/v1.LabelSelector](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#labelselector-v1-meta)* | *(Optional)* Choose namespace using a labelSelector | | `namespaces` *[]string* | *(Optional)* Choose namespaces by name | | `namespaceRegexes` *[]string* | *(Optional)* Choose namespaces by using regex matching | ### ConfigMapReference (*Appears on:* [GCPWorkloadIdentityFederation](#external-secrets.io/v1.GCPWorkloadIdentityFederation)) ConfigMapReference holds the details of a configmap. | Field | Description | | --- | --- | | `name` *string* | name of the configmap. | | `namespace` *string* | namespace in which the configmap exists. If empty, configmap will looked up in local namespace. | | `key` *string* | key name holding the external account credential config. | ### ConjurAPIKey (*Appears on:* [ConjurAuth](#external-secrets.io/v1.ConjurAuth)) ConjurAPIKey contains references to a Secret resource that holds the Conjur username and API key. | Field | Description | | --- | --- | | `account` *string* | Account is the Conjur organization account name. | | `userRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | A reference to a specific ‘key’ containing the Conjur username within a Secret resource. In some instances, `key` is a required field. | | `apiKeyRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | A reference to a specific ‘key’ containing the Conjur API key within a Secret resource. In some instances, `key` is a required field. | ### ConjurAuth (*Appears on:* [ConjurProvider](#external-secrets.io/v1.ConjurProvider)) ConjurAuth is the way to provide authentication credentials to the ConjurProvider. | Field | Description | | --- | --- | | `apikey` *[ConjurAPIKey](#external-secrets.io/v1.ConjurAPIKey)* | *(Optional)* Authenticates with Conjur using an API key. | | `jwt` *[ConjurJWT](#external-secrets.io/v1.ConjurJWT)* | *(Optional)* Jwt enables JWT authentication using Kubernetes service account tokens. | ### ConjurJWT (*Appears on:* [ConjurAuth](#external-secrets.io/v1.ConjurAuth)) ConjurJWT defines the JWT authentication configuration for Conjur provider. | Field | Description | | --- | --- | | `account` *string* | Account is the Conjur organization account name. | | `serviceID` *string* | The conjur authn jwt webservice id | | `hostId` *string* | *(Optional)* Optional HostID for JWT authentication. This may be used depending on how the Conjur JWT authenticator policy is configured. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* Optional SecretRef that refers to a key in a Secret resource containing JWT token to authenticate with Conjur using the JWT authentication method. | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* Optional ServiceAccountRef specifies the Kubernetes service account for which to request a token for with the `TokenRequest` API. | ### ConjurProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) ConjurProvider provides | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.010876642540097237,
0.03429099917411804,
-0.07759604603052139,
0.042468782514333725,
0.016738945618271828,
0.03302573040127754,
-0.0067464387975633144,
0.011267311871051788,
0.07106801867485046,
0.07384193688631058,
0.023658540099859238,
-0.09679335355758667,
0.02032807096838951,
-0.039... | 0.182392 |
in a Secret resource containing JWT token to authenticate with Conjur using the JWT authentication method. | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* Optional ServiceAccountRef specifies the Kubernetes service account for which to request a token for with the `TokenRequest` API. | ### ConjurProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) ConjurProvider provides access to a Conjur provider. | Field | Description | | --- | --- | | `url` *string* | URL is the endpoint of the Conjur instance. | | `caBundle` *string* | *(Optional)* CABundle is a PEM encoded CA bundle that will be used to validate the Conjur server certificate. | | `caProvider` *[CAProvider](#external-secrets.io/v1.CAProvider)* | *(Optional)* Used to provide custom certificate authority (CA) certificates for a secret store. The CAProvider points to a Secret or ConfigMap resource that contains a PEM-encoded certificate. | | `auth` *[ConjurAuth](#external-secrets.io/v1.ConjurAuth)* | Defines authentication settings for connecting to Conjur. | ### DVLSAuth (*Appears on:* [DVLSProvider](#external-secrets.io/v1.DVLSProvider)) DVLSAuth defines the authentication method for the DVLS provider. | Field | Description | | --- | --- | | `secretRef` *[DVLSAuthSecretRef](#external-secrets.io/v1.DVLSAuthSecretRef)* | SecretRef contains the Application ID and Application Secret for authentication. | ### DVLSAuthSecretRef (*Appears on:* [DVLSAuth](#external-secrets.io/v1.DVLSAuth)) DVLSAuthSecretRef defines the secret references for DVLS authentication credentials. | Field | Description | | --- | --- | | `appId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | AppID is the reference to the secret containing the Application ID. | | `appSecret` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | AppSecret is the reference to the secret containing the Application Secret. | ### DVLSProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) DVLSProvider configures a store to sync secrets using Devolutions Server. | Field | Description | | --- | --- | | `serverUrl` *string* | ServerURL is the DVLS instance URL (e.g., <https://dvls.example.com>). | | `insecure` *bool* | *(Optional)* Insecure allows connecting to DVLS over plain HTTP. This is NOT RECOMMENDED for production use. Set to true only if you understand the security implications. | | `auth` *[DVLSAuth](#external-secrets.io/v1.DVLSAuth)* | Auth defines the authentication method to use. | ### DelineaProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) DelineaProvider provides access to Delinea secrets vault Server. See: <https://github.com/DelineaXPM/dsv-sdk-go/blob/main/vault/vault.go>. | Field | Description | | --- | --- | | `clientId` *[DelineaProviderSecretRef](#external-secrets.io/v1.DelineaProviderSecretRef)* | ClientID is the non-secret part of the credential. | | `clientSecret` *[DelineaProviderSecretRef](#external-secrets.io/v1.DelineaProviderSecretRef)* | ClientSecret is the secret part of the credential. | | `tenant` *string* | Tenant is the chosen hostname / site name. | | `urlTemplate` *string* | *(Optional)* URLTemplate If unset, defaults to “https://%s.secretsvaultcloud.%s/v1/%s%s”. | | `tld` *string* | *(Optional)* TLD is based on the server location that was chosen during provisioning. If unset, defaults to “com”. | ### DelineaProviderSecretRef (*Appears on:* [DelineaProvider](#external-secrets.io/v1.DelineaProvider)) DelineaProviderSecretRef is a secret reference containing either a direct value or a reference to a secret key. | Field | Description | | --- | --- | | `value` *string* | *(Optional)* Value can be specified directly to set a value without using a secret. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef references a key in a secret that will be used as value. | ### Device42Auth (*Appears on:* [Device42Provider](#external-secrets.io/v1.Device42Provider)) Device42Auth defines the authentication method for the Device42 provider. | Field | Description | | --- | --- | | `secretRef` *[Device42SecretRef](#external-secrets.io/v1.Device42SecretRef)* | | ### Device42Provider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) Device42Provider configures a store to sync secrets with a Device42 instance. | Field | Description | | --- | --- | | `host` *string* | URL configures the Device42 instance URL. | | `auth` *[Device42Auth](#external-secrets.io/v1.Device42Auth)* | Auth configures how secret-manager authenticates with a Device42 instance. | ### Device42SecretRef (*Appears on:* [Device42Auth](#external-secrets.io/v1.Device42Auth)) Device42SecretRef contains the secret reference for accessing the Device42 instance. | Field | Description | | --- | --- | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.11138158291578293,
0.030644025653600693,
0.051361460238695145,
-0.05395825207233429,
-0.05911249294877052,
-0.02857128530740738,
0.0543639175593853,
0.020948775112628937,
0.12211734801530838,
-0.009412456303834915,
-0.0006203243974596262,
-0.047049883753061295,
0.041790712624788284,
-0.... | 0.117873 |
| | `host` *string* | URL configures the Device42 instance URL. | | `auth` *[Device42Auth](#external-secrets.io/v1.Device42Auth)* | Auth configures how secret-manager authenticates with a Device42 instance. | ### Device42SecretRef (*Appears on:* [Device42Auth](#external-secrets.io/v1.Device42Auth)) Device42SecretRef contains the secret reference for accessing the Device42 instance. | Field | Description | | --- | --- | | `credentials` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* Username / Password is used for authentication. | ### DopplerAuth (*Appears on:* [DopplerProvider](#external-secrets.io/v1.DopplerProvider)) DopplerAuth configures authentication with the Doppler API. Exactly one of secretRef or oidcConfig must be specified. | Field | Description | | --- | --- | | `secretRef` *[DopplerAuthSecretRef](#external-secrets.io/v1.DopplerAuthSecretRef)* | *(Optional)* SecretRef authenticates using a Doppler service token stored in a Kubernetes Secret. | | `oidcConfig` *[DopplerOIDCAuth](#external-secrets.io/v1.DopplerOIDCAuth)* | *(Optional)* OIDCConfig authenticates using Kubernetes ServiceAccount tokens via OIDC. | ### DopplerAuthSecretRef (*Appears on:* [DopplerAuth](#external-secrets.io/v1.DopplerAuth)) DopplerAuthSecretRef contains the secret reference for accessing the Doppler API. | Field | Description | | --- | --- | | `dopplerToken` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The DopplerToken is used for authentication. See <https://docs.doppler.com/reference/api#authentication> for auth token types. The Key attribute defaults to dopplerToken if not specified. | ### DopplerOIDCAuth (*Appears on:* [DopplerAuth](#external-secrets.io/v1.DopplerAuth)) DopplerOIDCAuth configures OIDC authentication with Doppler using Kubernetes ServiceAccount tokens. | Field | Description | | --- | --- | | `identity` *string* | Identity is the Doppler Service Account Identity ID configured for OIDC authentication. | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | ServiceAccountRef specifies the Kubernetes ServiceAccount to use for authentication. | | `expirationSeconds` *int64* | *(Optional)* ExpirationSeconds sets the ServiceAccount token validity duration. Defaults to 10 minutes. | ### DopplerProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) DopplerProvider configures a store to sync secrets using the Doppler provider. Project and Config are required if not using a Service Token. | Field | Description | | --- | --- | | `auth` *[DopplerAuth](#external-secrets.io/v1.DopplerAuth)* | Auth configures how the Operator authenticates with the Doppler API | | `project` *string* | *(Optional)* Doppler project (required if not using a Service Token) | | `config` *string* | *(Optional)* Doppler config (required if not using a Service Token) | | `nameTransformer` *string* | *(Optional)* Environment variable compatible name transforms that change secret names to a different format | | `format` *string* | *(Optional)* Format enables the downloading of secrets as a file (string) | ### ExternalSecret ExternalSecret is the Schema for the external-secrets API. It defines how to fetch data from external APIs and make it available as Kubernetes Secrets. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[ExternalSecretSpec](#external-secrets.io/v1.ExternalSecretSpec)* | | `secretStoreRef` *[SecretStoreRef](#external-secrets.io/v1.SecretStoreRef)* | *(Optional)* | | --- | --- | | `target` *[ExternalSecretTarget](#external-secrets.io/v1.ExternalSecretTarget)* | *(Optional)* | | `refreshPolicy` *[ExternalSecretRefreshPolicy](#external-secrets.io/v1.ExternalSecretRefreshPolicy)* | *(Optional)* RefreshPolicy determines how the ExternalSecret should be refreshed: - CreatedOnce: Creates the Secret only if it does not exist and does not update it thereafter - Periodic: Synchronizes the Secret from the external source at regular intervals specified by refreshInterval. No periodic updates occur if refreshInterval is 0. - OnChange: Only synchronizes the Secret when the ExternalSecret’s metadata or specification changes | | `refreshInterval` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | RefreshInterval is the amount of time before the values are read again from the SecretStore provider, specified as Golang Duration strings. Valid time units are “ns”, “us” (or “µs”), “ms”, “s”, “m”, “h” Example values: “1h0m0s”, “2h30m0s”, “10m0s” May be set to “0s” to fetch and create it once. Defaults to 1h0m0s. | | `data` *[[]ExternalSecretData](#external-secrets.io/v1.ExternalSecretData)* | *(Optional)* Data defines the connection between the Kubernetes Secret keys and the Provider data | | `dataFrom` *[[]ExternalSecretDataFromRemoteRef](#external-secrets.io/v1.ExternalSecretDataFromRemoteRef)* | *(Optional)* DataFrom | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.06908850371837616,
0.024135665968060493,
-0.011266004294157028,
-0.03859477862715721,
0.04082735627889633,
-0.060737453401088715,
0.0020460968371480703,
0.033309560269117355,
0.022414278239011765,
0.01920551247894764,
0.05786643922328949,
-0.015122460201382637,
0.07054485380649567,
0.01... | 0.026469 |
“µs”), “ms”, “s”, “m”, “h” Example values: “1h0m0s”, “2h30m0s”, “10m0s” May be set to “0s” to fetch and create it once. Defaults to 1h0m0s. | | `data` *[[]ExternalSecretData](#external-secrets.io/v1.ExternalSecretData)* | *(Optional)* Data defines the connection between the Kubernetes Secret keys and the Provider data | | `dataFrom` *[[]ExternalSecretDataFromRemoteRef](#external-secrets.io/v1.ExternalSecretDataFromRemoteRef)* | *(Optional)* DataFrom is used to fetch all properties from a specific Provider data If multiple entries are specified, the Secret keys are merged in the specified order | | | `status` *[ExternalSecretStatus](#external-secrets.io/v1.ExternalSecretStatus)* | | ### ExternalSecretConditionType (`string` alias) (*Appears on:* [ExternalSecretStatusCondition](#external-secrets.io/v1.ExternalSecretStatusCondition)) ExternalSecretConditionType defines a value type for ExternalSecret conditions. | Value | Description | | --- | --- | | "Deleted" | ExternalSecretDeleted indicates that the external secret has been deleted. | | "Ready" | ExternalSecretReady indicates that the external secret is ready and synced. | ### ExternalSecretConversionStrategy (`string` alias) (*Appears on:* [ExternalSecretDataRemoteRef](#external-secrets.io/v1.ExternalSecretDataRemoteRef), [ExternalSecretFind](#external-secrets.io/v1.ExternalSecretFind)) ExternalSecretConversionStrategy defines strategies for converting secret values. | Value | Description | | --- | --- | | "Default" | ExternalSecretConversionDefault specifies the default conversion strategy. | | "Unicode" | ExternalSecretConversionUnicode specifies that values should be treated as Unicode. | ### ExternalSecretCreationPolicy (`string` alias) (*Appears on:* [ExternalSecretTarget](#external-secrets.io/v1.ExternalSecretTarget)) ExternalSecretCreationPolicy defines rules on how to create the resulting Secret. | Value | Description | | --- | --- | | "Merge" | CreatePolicyMerge does not create the Secret, but merges the data fields to the Secret. | | "None" | CreatePolicyNone does not create a Secret (future use with injector). | | "Orphan" | CreatePolicyOrphan creates the Secret and does not set the ownerReference. I.e. it will be orphaned after the deletion of the ExternalSecret. | | "Owner" | CreatePolicyOwner creates the Secret and sets .metadata.ownerReferences to the ExternalSecret resource. | ### ExternalSecretData (*Appears on:* [ExternalSecretSpec](#external-secrets.io/v1.ExternalSecretSpec)) ExternalSecretData defines the connection between the Kubernetes Secret key (spec.data.) and the Provider data. | Field | Description | | --- | --- | | `secretKey` *string* | The key in the Kubernetes Secret to store the value. | | `remoteRef` *[ExternalSecretDataRemoteRef](#external-secrets.io/v1.ExternalSecretDataRemoteRef)* | RemoteRef points to the remote secret and defines which secret (version/property/..) to fetch. | | `sourceRef` *[StoreSourceRef](#external-secrets.io/v1.StoreSourceRef)* | SourceRef allows you to override the source from which the value will be pulled. | ### ExternalSecretDataFromRemoteRef (*Appears on:* [ExternalSecretSpec](#external-secrets.io/v1.ExternalSecretSpec)) ExternalSecretDataFromRemoteRef defines the connection between the Kubernetes Secret keys and the Provider data when using DataFrom to fetch multiple values from a Provider. | Field | Description | | --- | --- | | `extract` *[ExternalSecretDataRemoteRef](#external-secrets.io/v1.ExternalSecretDataRemoteRef)* | *(Optional)* Used to extract multiple key/value pairs from one secret Note: Extract does not support sourceRef.Generator or sourceRef.GeneratorRef. | | `find` *[ExternalSecretFind](#external-secrets.io/v1.ExternalSecretFind)* | *(Optional)* Used to find secrets based on tags or regular expressions Note: Find does not support sourceRef.Generator or sourceRef.GeneratorRef. | | `rewrite` *[[]ExternalSecretRewrite](#external-secrets.io/v1.ExternalSecretRewrite)* | *(Optional)* Used to rewrite secret Keys after getting them from the secret Provider Multiple Rewrite operations can be provided. They are applied in a layered order (first to last) | | `sourceRef` *[StoreGeneratorSourceRef](#external-secrets.io/v1.StoreGeneratorSourceRef)* | SourceRef points to a store or generator which contains secret values ready to use. Use this in combination with Extract or Find pull values out of a specific SecretStore. When sourceRef points to a generator Extract or Find is not supported. The generator returns a static map of values | ### ExternalSecretDataRemoteRef (*Appears on:* [ExternalSecretData](#external-secrets.io/v1.ExternalSecretData), [ExternalSecretDataFromRemoteRef](#external-secrets.io/v1.ExternalSecretDataFromRemoteRef)) ExternalSecretDataRemoteRef defines Provider data location. | Field | Description | | --- | --- | | `key` *string* | Key is the key used in the Provider, mandatory | | `metadataPolicy` *[ExternalSecretMetadataPolicy](#external-secrets.io/v1.ExternalSecretMetadataPolicy)* | *(Optional)* Policy for fetching tags/labels from provider secrets, possible options are Fetch, None. Defaults to None | | `property` *string* | *(Optional)* Used to select a | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.032366879284381866,
-0.004894607234746218,
0.00024231306451838464,
0.0044933222234249115,
-0.015167448669672012,
-0.019732298329472542,
0.026599708944559097,
0.008045806549489498,
0.0906849279999733,
0.039839088916778564,
0.05833185836672783,
-0.08441667258739471,
0.047273170202970505,
... | 0.098836 |
| | --- | --- | | `key` *string* | Key is the key used in the Provider, mandatory | | `metadataPolicy` *[ExternalSecretMetadataPolicy](#external-secrets.io/v1.ExternalSecretMetadataPolicy)* | *(Optional)* Policy for fetching tags/labels from provider secrets, possible options are Fetch, None. Defaults to None | | `property` *string* | *(Optional)* Used to select a specific property of the Provider value (if a map), if supported | | `version` *string* | *(Optional)* Used to select a specific version of the Provider value, if supported | | `conversionStrategy` *[ExternalSecretConversionStrategy](#external-secrets.io/v1.ExternalSecretConversionStrategy)* | *(Optional)* Used to define a conversion Strategy | | `decodingStrategy` *[ExternalSecretDecodingStrategy](#external-secrets.io/v1.ExternalSecretDecodingStrategy)* | *(Optional)* Used to define a decoding Strategy | ### ExternalSecretDecodingStrategy (`string` alias) (*Appears on:* [ExternalSecretDataRemoteRef](#external-secrets.io/v1.ExternalSecretDataRemoteRef), [ExternalSecretFind](#external-secrets.io/v1.ExternalSecretFind)) ExternalSecretDecodingStrategy defines strategies for decoding secret values. | Value | Description | | --- | --- | | "Auto" | ExternalSecretDecodeAuto specifies automatic detection of the decoding method. | | "Base64" | ExternalSecretDecodeBase64 specifies that values should be decoded using Base64. | | "Base64URL" | ExternalSecretDecodeBase64URL specifies that values should be decoded using Base64URL. | | "None" | ExternalSecretDecodeNone specifies that no decoding should be performed. | ### ExternalSecretDeletionPolicy (`string` alias) (*Appears on:* [ExternalSecretTarget](#external-secrets.io/v1.ExternalSecretTarget)) ExternalSecretDeletionPolicy defines rules on how to delete the resulting Secret. | Value | Description | | --- | --- | | "Delete" | DeletionPolicyDelete deletes the secret if all provider secrets are deleted. If a secret gets deleted on the provider side and is not accessible anymore this is not considered an error and the ExternalSecret does not go into SecretSyncedError status. | | "Merge" | DeletionPolicyMerge removes keys in the secret, but not the secret itself. If a secret gets deleted on the provider side and is not accessible anymore this is not considered an error and the ExternalSecret does not go into SecretSyncedError status. | | "Retain" | DeletionPolicyRetain will retain the secret if all provider secrets have been deleted. If a provider secret does not exist the ExternalSecret gets into the SecretSyncedError status. | ### ExternalSecretFind (*Appears on:* [ExternalSecretDataFromRemoteRef](#external-secrets.io/v1.ExternalSecretDataFromRemoteRef)) ExternalSecretFind defines configuration for finding secrets in the provider. | Field | Description | | --- | --- | | `path` *string* | *(Optional)* A root path to start the find operations. | | `name` *[FindName](#external-secrets.io/v1.FindName)* | *(Optional)* Finds secrets based on the name. | | `tags` *map[string]string* | *(Optional)* Find secrets based on tags. | | `conversionStrategy` *[ExternalSecretConversionStrategy](#external-secrets.io/v1.ExternalSecretConversionStrategy)* | *(Optional)* Used to define a conversion Strategy | | `decodingStrategy` *[ExternalSecretDecodingStrategy](#external-secrets.io/v1.ExternalSecretDecodingStrategy)* | *(Optional)* Used to define a decoding Strategy | ### ExternalSecretMetadata (*Appears on:* [ClusterExternalSecretSpec](#external-secrets.io/v1.ClusterExternalSecretSpec)) ExternalSecretMetadata defines metadata fields for the ExternalSecret generated by the ClusterExternalSecret. | Field | Description | | --- | --- | | `annotations` *map[string]string* | *(Optional)* | | `labels` *map[string]string* | *(Optional)* | ### ExternalSecretMetadataPolicy (`string` alias) (*Appears on:* [ExternalSecretDataRemoteRef](#external-secrets.io/v1.ExternalSecretDataRemoteRef)) ExternalSecretMetadataPolicy defines policies for fetching metadata from provider secrets. | Value | Description | | --- | --- | | "Fetch" | ExternalSecretMetadataPolicyFetch specifies that metadata should be fetched from the provider. | | "None" | ExternalSecretMetadataPolicyNone specifies that no metadata should be fetched from the provider. | ### ExternalSecretRefreshPolicy (`string` alias) (*Appears on:* [ExternalSecretSpec](#external-secrets.io/v1.ExternalSecretSpec)) ExternalSecretRefreshPolicy defines how and when the ExternalSecret should be refreshed. | Value | Description | | --- | --- | | "CreatedOnce" | RefreshPolicyCreatedOnce creates the Secret once and does not update it thereafter. | | "OnChange" | RefreshPolicyOnChange only synchronizes when the ExternalSecret’s metadata or spec changes. | | "Periodic" | RefreshPolicyPeriodic synchronizes the Secret from the provider at regular intervals. | ### ExternalSecretRewrite (*Appears on:* [ExternalSecretDataFromRemoteRef](#external-secrets.io/v1.ExternalSecretDataFromRemoteRef)) ExternalSecretRewrite defines how to rewrite secret data values before they are written to the Secret. | Field | Description | | --- | --- | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.05341070517897606,
0.006919356063008308,
-0.062474243342876434,
-0.022178472951054573,
0.08678391575813293,
-0.020990168675780296,
0.04701054096221924,
0.03420804440975189,
-0.027306942269206047,
-0.033417027443647385,
0.07292340695858002,
-0.06337657570838928,
0.035580795258283615,
-0.... | 0.027228 |
the ExternalSecret’s metadata or spec changes. | | "Periodic" | RefreshPolicyPeriodic synchronizes the Secret from the provider at regular intervals. | ### ExternalSecretRewrite (*Appears on:* [ExternalSecretDataFromRemoteRef](#external-secrets.io/v1.ExternalSecretDataFromRemoteRef)) ExternalSecretRewrite defines how to rewrite secret data values before they are written to the Secret. | Field | Description | | --- | --- | | `merge` *[ExternalSecretRewriteMerge](#external-secrets.io/v1.ExternalSecretRewriteMerge)* | *(Optional)* Used to merge key/values in one single Secret The resulting key will contain all values from the specified secrets | | `regexp` *[ExternalSecretRewriteRegexp](#external-secrets.io/v1.ExternalSecretRewriteRegexp)* | *(Optional)* Used to rewrite with regular expressions. The resulting key will be the output of a regexp.ReplaceAll operation. | | `transform` *[ExternalSecretRewriteTransform](#external-secrets.io/v1.ExternalSecretRewriteTransform)* | *(Optional)* Used to apply string transformation on the secrets. The resulting key will be the output of the template applied by the operation. | ### ExternalSecretRewriteMerge (*Appears on:* [ExternalSecretRewrite](#external-secrets.io/v1.ExternalSecretRewrite)) ExternalSecretRewriteMerge defines configuration for merging secret values. | Field | Description | | --- | --- | | `into` *string* | *(Optional)* Used to define the target key of the merge operation. Required if strategy is JSON. Ignored otherwise. | | `priority` *[]string* | *(Optional)* Used to define key priority in conflict resolution. | | `priorityPolicy` *[ExternalSecretRewriteMergePriorityPolicy](#external-secrets.io/v1.ExternalSecretRewriteMergePriorityPolicy)* | *(Optional)* Used to define the policy when a key in the priority list does not exist in the input. | | `conflictPolicy` *[ExternalSecretRewriteMergeConflictPolicy](#external-secrets.io/v1.ExternalSecretRewriteMergeConflictPolicy)* | *(Optional)* Used to define the policy to use in conflict resolution. | | `strategy` *[ExternalSecretRewriteMergeStrategy](#external-secrets.io/v1.ExternalSecretRewriteMergeStrategy)* | *(Optional)* Used to define the strategy to use in the merge operation. | ### ExternalSecretRewriteMergeConflictPolicy (`string` alias) (*Appears on:* [ExternalSecretRewriteMerge](#external-secrets.io/v1.ExternalSecretRewriteMerge)) ExternalSecretRewriteMergeConflictPolicy defines the policy for resolving conflicts when merging secrets. | Value | Description | | --- | --- | | "Error" | ExternalSecretRewriteMergeConflictPolicyError returns an error when conflicts occur during merge. | | "Ignore" | ExternalSecretRewriteMergeConflictPolicyIgnore ignores conflicts when merging secret values. | ### ExternalSecretRewriteMergePriorityPolicy (`string` alias) (*Appears on:* [ExternalSecretRewriteMerge](#external-secrets.io/v1.ExternalSecretRewriteMerge)) ExternalSecretRewriteMergePriorityPolicy defines the policy for handling missing keys in the priority list during merge operations. | Value | Description | | --- | --- | | "IgnoreNotFound" | | | "Strict" | | ### ExternalSecretRewriteMergeStrategy (`string` alias) (*Appears on:* [ExternalSecretRewriteMerge](#external-secrets.io/v1.ExternalSecretRewriteMerge)) ExternalSecretRewriteMergeStrategy defines the strategy for merging secrets. | Value | Description | | --- | --- | | "Extract" | ExternalSecretRewriteMergeStrategyExtract merges secrets by extracting values. | | "JSON" | ExternalSecretRewriteMergeStrategyJSON merges secrets using JSON merge strategy. | ### ExternalSecretRewriteRegexp (*Appears on:* [ExternalSecretRewrite](#external-secrets.io/v1.ExternalSecretRewrite)) ExternalSecretRewriteRegexp defines configuration for rewriting secrets using regular expressions. | Field | Description | | --- | --- | | `source` *string* | Used to define the regular expression of a re.Compiler. | | `target` *string* | Used to define the target pattern of a ReplaceAll operation. | ### ExternalSecretRewriteTransform (*Appears on:* [ExternalSecretRewrite](#external-secrets.io/v1.ExternalSecretRewrite)) ExternalSecretRewriteTransform defines configuration for transforming secrets using templates. | Field | Description | | --- | --- | | `template` *string* | Used to define the template to apply on the secret name. `.value` will specify the secret name in the template. | ### ExternalSecretSpec (*Appears on:* [ClusterExternalSecretSpec](#external-secrets.io/v1.ClusterExternalSecretSpec), [ExternalSecret](#external-secrets.io/v1.ExternalSecret)) ExternalSecretSpec defines the desired state of ExternalSecret. | Field | Description | | --- | --- | | `secretStoreRef` *[SecretStoreRef](#external-secrets.io/v1.SecretStoreRef)* | *(Optional)* | | `target` *[ExternalSecretTarget](#external-secrets.io/v1.ExternalSecretTarget)* | *(Optional)* | | `refreshPolicy` *[ExternalSecretRefreshPolicy](#external-secrets.io/v1.ExternalSecretRefreshPolicy)* | *(Optional)* RefreshPolicy determines how the ExternalSecret should be refreshed: - CreatedOnce: Creates the Secret only if it does not exist and does not update it thereafter - Periodic: Synchronizes the Secret from the external source at regular intervals specified by refreshInterval. No periodic updates occur if refreshInterval is 0. - OnChange: Only synchronizes the Secret when the ExternalSecret’s metadata or specification changes | | `refreshInterval` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | RefreshInterval is the amount of time before the values are read again from | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.10678242146968842,
-0.017354076728224754,
0.030709106475114822,
0.033399924635887146,
0.03231586515903473,
-0.03399255499243736,
0.011300208978354931,
0.026265429332852364,
0.041071273386478424,
0.004964275751262903,
0.04744324833154678,
-0.00988063309341669,
0.03938755765557289,
-0.059... | 0.056836 |
from the external source at regular intervals specified by refreshInterval. No periodic updates occur if refreshInterval is 0. - OnChange: Only synchronizes the Secret when the ExternalSecret’s metadata or specification changes | | `refreshInterval` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | RefreshInterval is the amount of time before the values are read again from the SecretStore provider, specified as Golang Duration strings. Valid time units are “ns”, “us” (or “µs”), “ms”, “s”, “m”, “h” Example values: “1h0m0s”, “2h30m0s”, “10m0s” May be set to “0s” to fetch and create it once. Defaults to 1h0m0s. | | `data` *[[]ExternalSecretData](#external-secrets.io/v1.ExternalSecretData)* | *(Optional)* Data defines the connection between the Kubernetes Secret keys and the Provider data | | `dataFrom` *[[]ExternalSecretDataFromRemoteRef](#external-secrets.io/v1.ExternalSecretDataFromRemoteRef)* | *(Optional)* DataFrom is used to fetch all properties from a specific Provider data If multiple entries are specified, the Secret keys are merged in the specified order | ### ExternalSecretStatus (*Appears on:* [ExternalSecret](#external-secrets.io/v1.ExternalSecret)) ExternalSecretStatus defines the observed state of ExternalSecret. | Field | Description | | --- | --- | | `refreshTime` *[Kubernetes meta/v1.Time](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#time-v1-meta)* | refreshTime is the time and date the external secret was fetched and the target secret updated | | `syncedResourceVersion` *string* | SyncedResourceVersion keeps track of the last synced version | | `conditions` *[[]ExternalSecretStatusCondition](#external-secrets.io/v1.ExternalSecretStatusCondition)* | *(Optional)* | | `binding` *[Kubernetes core/v1.LocalObjectReference](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#localobjectreference-v1-core)* | Binding represents a servicebinding.io Provisioned Service reference to the secret | ### ExternalSecretStatusCondition (*Appears on:* [ExternalSecretStatus](#external-secrets.io/v1.ExternalSecretStatus)) ExternalSecretStatusCondition defines a status condition of an ExternalSecret resource. | Field | Description | | --- | --- | | `type` *[ExternalSecretConditionType](#external-secrets.io/v1.ExternalSecretConditionType)* | | | `status` *[Kubernetes core/v1.ConditionStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#conditionstatus-v1-core)* | | | `reason` *string* | *(Optional)* | | `message` *string* | *(Optional)* | | `lastTransitionTime` *[Kubernetes meta/v1.Time](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#time-v1-meta)* | *(Optional)* | ### ExternalSecretTarget (*Appears on:* [ExternalSecretSpec](#external-secrets.io/v1.ExternalSecretSpec)) ExternalSecretTarget defines the Kubernetes Secret to be created, there can be only one target per ExternalSecret. | Field | Description | | --- | --- | | `name` *string* | *(Optional)* The name of the Secret resource to be managed. Defaults to the .metadata.name of the ExternalSecret resource | | `creationPolicy` *[ExternalSecretCreationPolicy](#external-secrets.io/v1.ExternalSecretCreationPolicy)* | *(Optional)* CreationPolicy defines rules on how to create the resulting Secret. Defaults to “Owner” | | `deletionPolicy` *[ExternalSecretDeletionPolicy](#external-secrets.io/v1.ExternalSecretDeletionPolicy)* | *(Optional)* DeletionPolicy defines rules on how to delete the resulting Secret. Defaults to “Retain” | | `template` *[ExternalSecretTemplate](#external-secrets.io/v1.ExternalSecretTemplate)* | *(Optional)* Template defines a blueprint for the created Secret resource. | | `manifest` *[ManifestReference](#external-secrets.io/v1.ManifestReference)* | *(Optional)* Manifest defines a custom Kubernetes resource to create instead of a Secret. When specified, ExternalSecret will create the resource type defined here (e.g., ConfigMap, Custom Resource) instead of a Secret. Warning: Using Generic target. Make sure access policies and encryption are properly configured. | | `immutable` *bool* | *(Optional)* Immutable defines if the final secret will be immutable | ### ExternalSecretTemplate (*Appears on:* [ExternalSecretTarget](#external-secrets.io/v1.ExternalSecretTarget), [PushSecretSpec](#external-secrets.io/v1alpha1.PushSecretSpec)) ExternalSecretTemplate defines a blueprint for the created Secret resource. we can not use native corev1.Secret, it will have empty ObjectMeta values: <https://github.com/kubernetes-sigs/controller-tools/issues/448> | Field | Description | | --- | --- | | `type` *[Kubernetes core/v1.SecretType](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#secrettype-v1-core)* | *(Optional)* | | `engineVersion` *[TemplateEngineVersion](#external-secrets.io/v1.TemplateEngineVersion)* | EngineVersion specifies the template engine version that should be used to compile/execute the template specified in .data and .templateFrom[]. | | `metadata` *[ExternalSecretTemplateMetadata](#external-secrets.io/v1.ExternalSecretTemplateMetadata)* | *(Optional)* | | `mergePolicy` *[TemplateMergePolicy](#external-secrets.io/v1.TemplateMergePolicy)* | | | `data` *map[string]string* | *(Optional)* | | `templateFrom` *[[]TemplateFrom](#external-secrets.io/v1.TemplateFrom)* | *(Optional)* | ### ExternalSecretTemplateMetadata (*Appears on:* [ExternalSecretTemplate](#external-secrets.io/v1.ExternalSecretTemplate)) ExternalSecretTemplateMetadata defines metadata fields for the Secret blueprint. | Field | Description | | --- | --- | | `annotations` *map[string]string* | *(Optional)* | | `labels` *map[string]string* | *(Optional)* | | `finalizers` *[]string* | *(Optional)* | ### ExternalSecretValidator ExternalSecretValidator implements a validating webhook for ExternalSecrets. ### FakeProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) FakeProvider configures a fake provider that returns static | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.027664095163345337,
-0.01511349342763424,
0.033539336174726486,
0.001796357100829482,
-0.024664876982569695,
-0.024445662274956703,
-0.028170496225357056,
0.02018456533551216,
0.11943662166595459,
0.00626040156930685,
0.04365602508187294,
-0.057836901396512985,
-0.019317271187901497,
-0... | 0.06817 |
| Field | Description | | --- | --- | | `annotations` *map[string]string* | *(Optional)* | | `labels` *map[string]string* | *(Optional)* | | `finalizers` *[]string* | *(Optional)* | ### ExternalSecretValidator ExternalSecretValidator implements a validating webhook for ExternalSecrets. ### FakeProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) FakeProvider configures a fake provider that returns static values. | Field | Description | | --- | --- | | `data` *[[]FakeProviderData](#external-secrets.io/v1.FakeProviderData)* | | | `validationResult` *[ValidationResult](#external-secrets.io/v1.ValidationResult)* | | ### FakeProviderData (*Appears on:* [FakeProvider](#external-secrets.io/v1.FakeProvider)) FakeProviderData defines a key-value pair with optional version for the fake provider. | Field | Description | | --- | --- | | `key` *string* | | | `value` *string* | | | `version` *string* | | ### FetchingPolicy (*Appears on:* [YandexCertificateManagerProvider](#external-secrets.io/v1.YandexCertificateManagerProvider), [YandexLockboxProvider](#external-secrets.io/v1.YandexLockboxProvider)) FetchingPolicy configures how the provider interprets the `data.secretKey.remoteRef.key` field in ExternalSecret. | Field | Description | | --- | --- | | `byID` *[ByID](#external-secrets.io/v1.ByID)* | | | `byName` *[ByName](#external-secrets.io/v1.ByName)* | | ### FindName (*Appears on:* [ExternalSecretFind](#external-secrets.io/v1.ExternalSecretFind)) FindName defines criteria for finding secrets by name patterns. | Field | Description | | --- | --- | | `regexp` *string* | *(Optional)* Finds secrets base | ### FortanixProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) FortanixProvider provides access to Fortanix SDKMS API using the provided credentials. | Field | Description | | --- | --- | | `apiUrl` *string* | APIURL is the URL of SDKMS API. Defaults to `sdkms.fortanix.com`. | | `apiKey` *[FortanixProviderSecretRef](#external-secrets.io/v1.FortanixProviderSecretRef)* | APIKey is the API token to access SDKMS Applications. | ### FortanixProviderSecretRef (*Appears on:* [FortanixProvider](#external-secrets.io/v1.FortanixProvider)) FortanixProviderSecretRef is a secret reference containing the SDKMS API Key. | Field | Description | | --- | --- | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | SecretRef is a reference to a secret containing the SDKMS API Key. | ### GCPSMAuth (*Appears on:* [GCPSMProvider](#external-secrets.io/v1.GCPSMProvider)) GCPSMAuth defines the authentication methods for Google Cloud Platform Secret Manager. | Field | Description | | --- | --- | | `secretRef` *[GCPSMAuthSecretRef](#external-secrets.io/v1.GCPSMAuthSecretRef)* | *(Optional)* | | `workloadIdentity` *[GCPWorkloadIdentity](#external-secrets.io/v1.GCPWorkloadIdentity)* | *(Optional)* | | `workloadIdentityFederation` *[GCPWorkloadIdentityFederation](#external-secrets.io/v1.GCPWorkloadIdentityFederation)* | *(Optional)* | ### GCPSMAuthSecretRef (*Appears on:* [GCPSMAuth](#external-secrets.io/v1.GCPSMAuth), [VaultGCPAuth](#external-secrets.io/v1.VaultGCPAuth)) GCPSMAuthSecretRef contains the secret references for GCP Secret Manager authentication. | Field | Description | | --- | --- | | `secretAccessKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The SecretAccessKey is used for authentication | ### GCPSMProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) GCPSMProvider Configures a store to sync secrets using the GCP Secret Manager provider. | Field | Description | | --- | --- | | `auth` *[GCPSMAuth](#external-secrets.io/v1.GCPSMAuth)* | *(Optional)* Auth defines the information necessary to authenticate against GCP | | `projectID` *string* | ProjectID project where secret is located | | `location` *string* | Location optionally defines a location for a secret | | `secretVersionSelectionPolicy` *[SecretVersionSelectionPolicy](#external-secrets.io/v1.SecretVersionSelectionPolicy)* | *(Optional)* SecretVersionSelectionPolicy specifies how the provider selects a secret version when “latest” is disabled or destroyed. Possible values are: - LatestOrFail: the provider always uses “latest”, or fails if that version is disabled/destroyed. - LatestOrFetch: the provider falls back to fetching the latest version if the version is DESTROYED or DISABLED | ### GCPWorkloadIdentity (*Appears on:* [GCPSMAuth](#external-secrets.io/v1.GCPSMAuth), [VaultGCPAuth](#external-secrets.io/v1.VaultGCPAuth)) GCPWorkloadIdentity defines configuration for workload identity authentication to GCP. | Field | Description | | --- | --- | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | | | `clusterLocation` *string* | *(Optional)* ClusterLocation is the location of the cluster If not specified, it fetches information from the metadata server | | `clusterName` *string* | *(Optional)* ClusterName is the name of the cluster If not specified, it fetches information from the metadata server | | `clusterProjectID` *string* | *(Optional)* ClusterProjectID is the project ID of the cluster If not specified, it fetches information from the metadata server | ### GCPWorkloadIdentityFederation (*Appears on:* [GCPSMAuth](#external-secrets.io/v1.GCPSMAuth), [GCPSMAuth](#generators.external-secrets.io/v1alpha1.GCPSMAuth)) GCPWorkloadIdentityFederation holds the | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.14265279471874237,
0.05721556022763252,
-0.04428716376423836,
0.027015559375286102,
0.05893520638346672,
-0.0519494004547596,
0.020386189222335815,
0.010902871377766132,
-0.010410708375275135,
-0.04226023703813553,
0.05320362374186516,
-0.09841612726449966,
0.042323701083660126,
0.01566... | 0.071769 |
is the name of the cluster If not specified, it fetches information from the metadata server | | `clusterProjectID` *string* | *(Optional)* ClusterProjectID is the project ID of the cluster If not specified, it fetches information from the metadata server | ### GCPWorkloadIdentityFederation (*Appears on:* [GCPSMAuth](#external-secrets.io/v1.GCPSMAuth), [GCPSMAuth](#generators.external-secrets.io/v1alpha1.GCPSMAuth)) GCPWorkloadIdentityFederation holds the configurations required for generating federated access tokens. | Field | Description | | --- | --- | | `credConfig` *[ConfigMapReference](#external-secrets.io/v1.ConfigMapReference)* | credConfig holds the configmap reference containing the GCP external account credential configuration in JSON format and the key name containing the json data. For using Kubernetes cluster as the identity provider, use serviceAccountRef instead. Operators mounted serviceaccount token cannot be used as the token source, instead serviceAccountRef must be used by providing operators service account details. | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | serviceAccountRef is the reference to the kubernetes ServiceAccount to be used for obtaining the tokens, when Kubernetes is configured as provider in workload identity pool. | | `awsSecurityCredentials` *[AwsCredentialsConfig](#external-secrets.io/v1.AwsCredentialsConfig)* | awsSecurityCredentials is for configuring AWS region and credentials to use for obtaining the access token, when using the AWS metadata server is not an option. | | `audience` *string* | audience is the Secure Token Service (STS) audience which contains the resource name for the workload identity pool and the provider identifier in that pool. If specified, Audience found in the external account credential config will be overridden with the configured value. audience must be provided when serviceAccountRef or awsSecurityCredentials is configured. | | `externalTokenEndpoint` *string* | externalTokenEndpoint is the endpoint explicitly set up to provide tokens, which will be matched against the credential\_source.url in the provided credConfig. This field is merely to double-check the external token source URL is having the expected value. | ### GcpIDTokenAuthCredentials (*Appears on:* [InfisicalAuth](#external-secrets.io/v1.InfisicalAuth)) GcpIDTokenAuthCredentials represents the credentials for GCP ID token authentication. | Field | Description | | --- | --- | | `identityId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### GcpIamAuthCredentials (*Appears on:* [InfisicalAuth](#external-secrets.io/v1.InfisicalAuth)) GcpIamAuthCredentials represents the credentials for GCP IAM authentication. | Field | Description | | --- | --- | | `identityId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `serviceAccountKeyFilePath` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### GeneratorRef (*Appears on:* [StoreGeneratorSourceRef](#external-secrets.io/v1.StoreGeneratorSourceRef), [StoreSourceRef](#external-secrets.io/v1.StoreSourceRef), [PushSecretSelector](#external-secrets.io/v1alpha1.PushSecretSelector)) GeneratorRef points to a generator custom resource. | Field | Description | | --- | --- | | `apiVersion` *string* | Specify the apiVersion of the generator resource | | `kind` *string* | Specify the Kind of the generator resource | | `name` *string* | Specify the name of the generator resource | ### GenericStore GenericStore is a common interface for interacting with ClusterSecretStore or a namespaced SecretStore. ### GenericStoreValidator GenericStoreValidator implements webhook validation for SecretStore and ClusterSecretStore resources. ### GithubAppAuth (*Appears on:* [GithubProvider](#external-secrets.io/v1.GithubProvider)) GithubAppAuth defines authentication configuration using a GitHub App for accessing GitHub API. | Field | Description | | --- | --- | | `privateKey` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### GithubProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) GithubProvider provides access and authentication to a GitHub instance . | Field | Description | | --- | --- | | `url` *string* | URL configures the Github instance URL. Defaults to <https://github.com/>. | | `uploadURL` *string* | *(Optional)* Upload URL for enterprise instances. Default to URL. | | `auth` *[GithubAppAuth](#external-secrets.io/v1.GithubAppAuth)* | auth configures how secret-manager authenticates with a Github instance. | | `appID` *int64* | appID specifies the Github APP that will be used to authenticate the client | | `installationID` *int64* | installationID specifies the Github APP installation that will be used to authenticate the client | | `organization` *string* | organization will be used to fetch secrets from the Github organization | | `repository` *string* | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.05415955185890198,
-0.02266688458621502,
0.003919878508895636,
0.027125073596835136,
-0.012517440132796764,
0.016591981053352356,
0.040914472192525864,
0.013632806949317455,
0.03607857972383499,
0.017160644754767418,
-0.022682897746562958,
-0.097289077937603,
0.0737190693616867,
-0.0352... | 0.139867 |
the Github APP that will be used to authenticate the client | | `installationID` *int64* | installationID specifies the Github APP installation that will be used to authenticate the client | | `organization` *string* | organization will be used to fetch secrets from the Github organization | | `repository` *string* | *(Optional)* repository will be used to fetch secrets from the Github repository within an organization | | `environment` *string* | *(Optional)* environment will be used to fetch secrets from a particular environment within a github repository | ### GitlabAuth (*Appears on:* [GitlabProvider](#external-secrets.io/v1.GitlabProvider)) GitlabAuth defines the authentication method for accessing GitLab API. | Field | Description | | --- | --- | | `SecretRef` *[GitlabSecretRef](#external-secrets.io/v1.GitlabSecretRef)* | | ### GitlabProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) GitlabProvider configures a store to sync secrets with a GitLab instance. | Field | Description | | --- | --- | | `url` *string* | URL configures the GitLab instance URL. Defaults to <https://gitlab.com/>. | | `auth` *[GitlabAuth](#external-secrets.io/v1.GitlabAuth)* | Auth configures how secret-manager authenticates with a GitLab instance. | | `projectID` *string* | ProjectID specifies a project where secrets are located. | | `inheritFromGroups` *bool* | InheritFromGroups specifies whether parent groups should be discovered and checked for secrets. | | `groupIDs` *[]string* | GroupIDs specify, which gitlab groups to pull secrets from. Group secrets are read from left to right followed by the project variables. | | `environment` *string* | Environment environment\_scope of gitlab CI/CD variables (Please see <https://docs.gitlab.com/ee/ci/environments/#create-a-static-environment> on how to create environments) | | `caBundle` *[]byte* | *(Optional)* Base64 encoded certificate for the GitLab server sdk. The sdk MUST run with HTTPS to make sure no MITM attack can be performed. | | `caProvider` *[CAProvider](#external-secrets.io/v1.CAProvider)* | *(Optional)* see: <https://external-secrets.io/latest/spec/#external-secrets.io/v1alpha1.CAProvider> | ### GitlabSecretRef (*Appears on:* [GitlabAuth](#external-secrets.io/v1.GitlabAuth)) GitlabSecretRef contains the secret reference for GitLab authentication credentials. | Field | Description | | --- | --- | | `accessToken` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | AccessToken is used for authentication. | ### IBMAuth (*Appears on:* [IBMProvider](#external-secrets.io/v1.IBMProvider)) IBMAuth defines authentication options for connecting to IBM Cloud Secrets Manager. | Field | Description | | --- | --- | | `secretRef` *[IBMAuthSecretRef](#external-secrets.io/v1.IBMAuthSecretRef)* | | | `containerAuth` *[IBMAuthContainerAuth](#external-secrets.io/v1.IBMAuthContainerAuth)* | | ### IBMAuthContainerAuth (*Appears on:* [IBMAuth](#external-secrets.io/v1.IBMAuth)) IBMAuthContainerAuth defines container-based authentication with IAM Trusted Profile. | Field | Description | | --- | --- | | `profile` *string* | the IBM Trusted Profile | | `tokenLocation` *string* | Location the token is mounted on the pod | | `iamEndpoint` *string* | | ### IBMAuthSecretRef (*Appears on:* [IBMAuth](#external-secrets.io/v1.IBMAuth)) IBMAuthSecretRef contains the secret reference for IBM Cloud API key authentication. | Field | Description | | --- | --- | | `secretApiKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The SecretAccessKey is used for authentication | | `iamEndpoint` *string* | The IAM endpoint used to obain a token | ### IBMProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) IBMProvider configures a store to sync secrets using a IBM Cloud Secrets Manager backend. | Field | Description | | --- | --- | | `auth` *[IBMAuth](#external-secrets.io/v1.IBMAuth)* | Auth configures how secret-manager authenticates with the IBM secrets manager. | | `serviceUrl` *string* | ServiceURL is the Endpoint URL that is specific to the Secrets Manager service instance | ### InfisicalAuth (*Appears on:* [InfisicalProvider](#external-secrets.io/v1.InfisicalProvider)) InfisicalAuth specifies the authentication configuration for Infisical. | Field | Description | | --- | --- | | `universalAuthCredentials` *[UniversalAuthCredentials](#external-secrets.io/v1.UniversalAuthCredentials)* | *(Optional)* | | `azureAuthCredentials` *[AzureAuthCredentials](#external-secrets.io/v1.AzureAuthCredentials)* | *(Optional)* | | `gcpIdTokenAuthCredentials` *[GcpIDTokenAuthCredentials](#external-secrets.io/v1.GcpIDTokenAuthCredentials)* | *(Optional)* | | `gcpIamAuthCredentials` *[GcpIamAuthCredentials](#external-secrets.io/v1.GcpIamAuthCredentials)* | *(Optional)* | | `jwtAuthCredentials` *[JwtAuthCredentials](#external-secrets.io/v1.JwtAuthCredentials)* | *(Optional)* | | `ldapAuthCredentials` *[LdapAuthCredentials](#external-secrets.io/v1.LdapAuthCredentials)* | *(Optional)* | | `ociAuthCredentials` *[OciAuthCredentials](#external-secrets.io/v1.OciAuthCredentials)* | *(Optional)* | | `kubernetesAuthCredentials` *[KubernetesAuthCredentials](#external-secrets.io/v1.KubernetesAuthCredentials)* | *(Optional)* | | `awsAuthCredentials` *[AwsAuthCredentials](#external-secrets.io/v1.AwsAuthCredentials)* | *(Optional)* | | `tokenAuthCredentials` *[TokenAuthCredentials](#external-secrets.io/v1.TokenAuthCredentials)* | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.11550290137529373,
-0.009852009825408459,
-0.028241831809282303,
0.011121504008769989,
-0.021187130361795425,
-0.08551032096147537,
-0.024502549320459366,
-0.0028532722499221563,
0.06965769827365875,
-0.007333911489695311,
0.011978307738900185,
-0.0027342308312654495,
0.12643344700336456,... | 0.02289 |
`azureAuthCredentials` *[AzureAuthCredentials](#external-secrets.io/v1.AzureAuthCredentials)* | *(Optional)* | | `gcpIdTokenAuthCredentials` *[GcpIDTokenAuthCredentials](#external-secrets.io/v1.GcpIDTokenAuthCredentials)* | *(Optional)* | | `gcpIamAuthCredentials` *[GcpIamAuthCredentials](#external-secrets.io/v1.GcpIamAuthCredentials)* | *(Optional)* | | `jwtAuthCredentials` *[JwtAuthCredentials](#external-secrets.io/v1.JwtAuthCredentials)* | *(Optional)* | | `ldapAuthCredentials` *[LdapAuthCredentials](#external-secrets.io/v1.LdapAuthCredentials)* | *(Optional)* | | `ociAuthCredentials` *[OciAuthCredentials](#external-secrets.io/v1.OciAuthCredentials)* | *(Optional)* | | `kubernetesAuthCredentials` *[KubernetesAuthCredentials](#external-secrets.io/v1.KubernetesAuthCredentials)* | *(Optional)* | | `awsAuthCredentials` *[AwsAuthCredentials](#external-secrets.io/v1.AwsAuthCredentials)* | *(Optional)* | | `tokenAuthCredentials` *[TokenAuthCredentials](#external-secrets.io/v1.TokenAuthCredentials)* | *(Optional)* | ### InfisicalProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) InfisicalProvider configures a store to sync secrets using the Infisical provider. | Field | Description | | --- | --- | | `auth` *[InfisicalAuth](#external-secrets.io/v1.InfisicalAuth)* | Auth configures how the Operator authenticates with the Infisical API | | `secretsScope` *[MachineIdentityScopeInWorkspace](#external-secrets.io/v1.MachineIdentityScopeInWorkspace)* | SecretsScope defines the scope of the secrets within the workspace | | `hostAPI` *string* | *(Optional)* HostAPI specifies the base URL of the Infisical API. If not provided, it defaults to “[https://app.infisical.com/api”](https://app.infisical.com/api"). | | `caBundle` *[]byte* | *(Optional)* CABundle is a PEM-encoded CA certificate bundle used to validate the Infisical server’s TLS certificate. Mutually exclusive with CAProvider. | | `caProvider` *[CAProvider](#external-secrets.io/v1.CAProvider)* | *(Optional)* CAProvider is a reference to a Secret or ConfigMap that contains a CA certificate. The certificate is used to validate the Infisical server’s TLS certificate. Mutually exclusive with CABundle. | ### IntegrationInfo (*Appears on:* [OnePasswordSDKProvider](#external-secrets.io/v1.OnePasswordSDKProvider)) IntegrationInfo specifies the name and version of the integration built using the 1Password Go SDK. | Field | Description | | --- | --- | | `name` *string* | Name defaults to “1Password SDK”. | | `version` *string* | Version defaults to “v1.0.0”. | ### JwtAuthCredentials (*Appears on:* [InfisicalAuth](#external-secrets.io/v1.InfisicalAuth)) JwtAuthCredentials represents the credentials for JWT authentication. | Field | Description | | --- | --- | | `identityId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `jwt` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### KeeperSecurityProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) KeeperSecurityProvider Configures a store to sync secrets using Keeper Security. | Field | Description | | --- | --- | | `authRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `folderID` *string* | | ### KubernetesAuth (*Appears on:* [KubernetesProvider](#external-secrets.io/v1.KubernetesProvider)) KubernetesAuth defines authentication options for connecting to a Kubernetes cluster. | Field | Description | | --- | --- | | `cert` *[CertAuth](#external-secrets.io/v1.CertAuth)* | *(Optional)* has both clientCert and clientKey as secretKeySelector | | `token` *[TokenAuth](#external-secrets.io/v1.TokenAuth)* | *(Optional)* use static token to authenticate with | | `serviceAccount` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* points to a service account that should be used for authentication | ### KubernetesAuthCredentials (*Appears on:* [InfisicalAuth](#external-secrets.io/v1.InfisicalAuth)) KubernetesAuthCredentials represents the credentials for Kubernetes authentication. | Field | Description | | --- | --- | | `identityId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `serviceAccountTokenPath` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* | ### KubernetesProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) KubernetesProvider configures a store to sync secrets with a Kubernetes instance. | Field | Description | | --- | --- | | `server` *[KubernetesServer](#external-secrets.io/v1.KubernetesServer)* | *(Optional)* configures the Kubernetes server Address. | | `auth` *[KubernetesAuth](#external-secrets.io/v1.KubernetesAuth)* | *(Optional)* Auth configures how secret-manager authenticates with a Kubernetes instance. | | `authRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* A reference to a secret that contains the auth information. | | `remoteNamespace` *string* | *(Optional)* Remote namespace to fetch the secrets from | ### KubernetesServer (*Appears on:* [KubernetesProvider](#external-secrets.io/v1.KubernetesProvider)) KubernetesServer defines configuration for connecting to a Kubernetes API server. | Field | Description | | --- | --- | | `url` *string* | *(Optional)* configures the Kubernetes server Address. | | `caBundle` *[]byte* | *(Optional)* CABundle is a base64-encoded CA certificate | | `caProvider` *[CAProvider](#external-secrets.io/v1.CAProvider)* | *(Optional)* see: <https://external-secrets.io/v0.4.1/spec/#external-secrets.io/v1alpha1.CAProvider> | ### LdapAuthCredentials (*Appears on:* [InfisicalAuth](#external-secrets.io/v1.InfisicalAuth)) LdapAuthCredentials represents the credentials for LDAP authentication. | Field | Description | | --- | --- | | `identityId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `ldapPassword` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `ldapUsername` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.10150701552629471,
-0.012731960043311119,
0.023073453456163406,
-0.021701563149690628,
-0.007415929809212685,
0.008264753036201,
0.06200966611504555,
-0.04363057762384415,
0.03466000035405159,
0.045122891664505005,
0.03947341442108154,
-0.07018622010946274,
0.05392450466752052,
0.013754... | 0.000434 |
| `caProvider` *[CAProvider](#external-secrets.io/v1.CAProvider)* | *(Optional)* see: <https://external-secrets.io/v0.4.1/spec/#external-secrets.io/v1alpha1.CAProvider> | ### LdapAuthCredentials (*Appears on:* [InfisicalAuth](#external-secrets.io/v1.InfisicalAuth)) LdapAuthCredentials represents the credentials for LDAP authentication. | Field | Description | | --- | --- | | `identityId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `ldapPassword` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `ldapUsername` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### MachineIdentityScopeInWorkspace (*Appears on:* [InfisicalProvider](#external-secrets.io/v1.InfisicalProvider)) MachineIdentityScopeInWorkspace defines the scope for machine identity within a workspace. | Field | Description | | --- | --- | | `secretsPath` *string* | *(Optional)* SecretsPath specifies the path to the secrets within the workspace. Defaults to “/” if not provided. | | `recursive` *bool* | *(Optional)* Recursive indicates whether the secrets should be fetched recursively. Defaults to false if not provided. | | `environmentSlug` *string* | EnvironmentSlug is the required slug identifier for the environment. | | `projectSlug` *string* | ProjectSlug is the required slug identifier for the project. | | `expandSecretReferences` *bool* | *(Optional)* ExpandSecretReferences indicates whether secret references should be expanded. Defaults to true if not provided. | ### MaintenanceStatus (`string` alias) MaintenanceStatus defines a type for different maintenance states of a provider schema. | Value | Description | | --- | --- | | "Deprecated" | | | "Maintained" | | | "NotMaintained" | | ### ManifestReference (*Appears on:* [ExternalSecretTarget](#external-secrets.io/v1.ExternalSecretTarget)) ManifestReference defines a custom Kubernetes resource type to be created instead of a Secret. This allows ExternalSecret to create ConfigMaps, Custom Resources, or any other Kubernetes resource type. | Field | Description | | --- | --- | | `apiVersion` *string* | APIVersion of the target resource (e.g., “v1” for ConfigMap, “argoproj.io/v1alpha1” for ArgoCD Application) | | `kind` *string* | Kind of the target resource (e.g., “ConfigMap”, “Application”) | ### NTLMProtocol (*Appears on:* [AuthorizationProtocol](#external-secrets.io/v1.AuthorizationProtocol)) NTLMProtocol contains the NTLM-specific configuration. | Field | Description | | --- | --- | | `usernameSecret` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `passwordSecret` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### NgrokAuth (*Appears on:* [NgrokProvider](#external-secrets.io/v1.NgrokProvider)) NgrokAuth configures the authentication method for the ngrok provider. | Field | Description | | --- | --- | | `apiKey` *[NgrokProviderSecretRef](#external-secrets.io/v1.NgrokProviderSecretRef)* | *(Optional)* APIKey is the API Key used to authenticate with ngrok. See <https://ngrok.com/docs/api/#authentication> | ### NgrokProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) NgrokProvider configures a store to sync secrets with a ngrok vault to use in traffic policies. See: <https://ngrok.com/blog-post/secrets-for-traffic-policy> | Field | Description | | --- | --- | | `apiUrl` *string* | APIURL is the URL of the ngrok API. | | `auth` *[NgrokAuth](#external-secrets.io/v1.NgrokAuth)* | Auth configures how the ngrok provider authenticates with the ngrok API. | | `vault` *[NgrokVault](#external-secrets.io/v1.NgrokVault)* | Vault configures the ngrok vault to sync secrets with. | ### NgrokProviderSecretRef (*Appears on:* [NgrokAuth](#external-secrets.io/v1.NgrokAuth)) NgrokProviderSecretRef contains the secret reference for the ngrok provider. | Field | Description | | --- | --- | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef is a reference to a secret containing the ngrok API key. | ### NgrokVault (*Appears on:* [NgrokProvider](#external-secrets.io/v1.NgrokProvider)) NgrokVault configures the ngrok vault to sync secrets with. | Field | Description | | --- | --- | | `name` *string* | Name is the name of the ngrok vault to sync secrets with. | ### NoSecretError NoSecretError shall be returned when a GetSecret can not find the desired secret. This is used for deletionPolicy. ### NotModifiedError NotModifiedError to signal that the webhook received no changes, and it should just return without doing anything. ### OciAuthCredentials (*Appears on:* [InfisicalAuth](#external-secrets.io/v1.InfisicalAuth)) OciAuthCredentials represents the credentials for OCI authentication. | Field | Description | | --- | --- | | `identityId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `privateKey` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `privateKeyPassphrase` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* | | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.08244950324296951,
-0.04445144161581993,
-0.055748503655195236,
-0.02181784063577652,
0.04488792270421982,
-0.009026284329593182,
0.05103687942028046,
0.060314957052469254,
-0.023306410759687424,
-0.00818482507020235,
0.0634874552488327,
-0.061470698565244675,
0.008082368411123753,
-0.0... | 0.043021 |
just return without doing anything. ### OciAuthCredentials (*Appears on:* [InfisicalAuth](#external-secrets.io/v1.InfisicalAuth)) OciAuthCredentials represents the credentials for OCI authentication. | Field | Description | | --- | --- | | `identityId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `privateKey` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `privateKeyPassphrase` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* | | `fingerprint` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `userId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `tenancyId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `region` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### OnboardbaseAuthSecretRef (*Appears on:* [OnboardbaseProvider](#external-secrets.io/v1.OnboardbaseProvider)) OnboardbaseAuthSecretRef holds secret references for onboardbase API Key credentials. | Field | Description | | --- | --- | | `apiKeyRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | OnboardbaseAPIKey is the APIKey generated by an admin account. It is used to recognize and authorize access to a project and environment within onboardbase | | `passcodeRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | OnboardbasePasscode is the passcode attached to the API Key | ### OnboardbaseProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) OnboardbaseProvider configures a store to sync secrets using the Onboardbase provider. Project and Config are required if not using a Service Token. | Field | Description | | --- | --- | | `auth` *[OnboardbaseAuthSecretRef](#external-secrets.io/v1.OnboardbaseAuthSecretRef)* | Auth configures how the Operator authenticates with the Onboardbase API | | `apiHost` *string* | APIHost use this to configure the host url for the API for selfhosted installation, default is <https://public.onboardbase.com/api/v1/> | | `project` *string* | Project is an onboardbase project that the secrets should be pulled from | | `environment` *string* | Environment is the name of an environmnent within a project to pull the secrets from | ### OnePasswordAuth (*Appears on:* [OnePasswordProvider](#external-secrets.io/v1.OnePasswordProvider)) OnePasswordAuth contains a secretRef for credentials. | Field | Description | | --- | --- | | `secretRef` *[OnePasswordAuthSecretRef](#external-secrets.io/v1.OnePasswordAuthSecretRef)* | | ### OnePasswordAuthSecretRef (*Appears on:* [OnePasswordAuth](#external-secrets.io/v1.OnePasswordAuth)) OnePasswordAuthSecretRef holds secret references for 1Password credentials. | Field | Description | | --- | --- | | `connectTokenSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The ConnectToken is used for authentication to a 1Password Connect Server. | ### OnePasswordProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) OnePasswordProvider configures a store to sync secrets using the 1Password Secret Manager provider. | Field | Description | | --- | --- | | `auth` *[OnePasswordAuth](#external-secrets.io/v1.OnePasswordAuth)* | Auth defines the information necessary to authenticate against OnePassword Connect Server | | `connectHost` *string* | ConnectHost defines the OnePassword Connect Server to connect to | | `vaults` *map[string]int* | Vaults defines which OnePassword vaults to search in which order | ### OnePasswordSDKAuth (*Appears on:* [OnePasswordSDKProvider](#external-secrets.io/v1.OnePasswordSDKProvider)) OnePasswordSDKAuth contains a secretRef for the service account token. | Field | Description | | --- | --- | | `serviceAccountSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | ServiceAccountSecretRef points to the secret containing the token to access 1Password vault. | ### OnePasswordSDKProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) OnePasswordSDKProvider configures a store to sync secrets using the 1Password sdk. | Field | Description | | --- | --- | | `vault` *string* | Vault defines the vault’s name or uuid to access. Do NOT add op:// prefix. This will be done automatically. | | `integrationInfo` *[IntegrationInfo](#external-secrets.io/v1.IntegrationInfo)* | *(Optional)* IntegrationInfo specifies the name and version of the integration built using the 1Password Go SDK. If you don’t know which name and version to use, use `DefaultIntegrationName` and `DefaultIntegrationVersion`, respectively. | | `auth` *[OnePasswordSDKAuth](#external-secrets.io/v1.OnePasswordSDKAuth)* | Auth defines the information necessary to authenticate against OnePassword API. | | `cache` *[CacheConfig](#external-secrets.io/v1.CacheConfig)* | *(Optional)* Cache configures client-side caching for read operations (GetSecret, GetSecretMap). When enabled, secrets are cached with the specified TTL. Write operations (PushSecret, DeleteSecret) automatically invalidate relevant cache entries. If omitted, caching is disabled (default). cache: {} is a valid option to set. | ### OracleAuth (*Appears on:* [OracleProvider](#external-secrets.io/v1.OracleProvider)) OracleAuth defines the authentication method for | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.08917035907506943,
0.03145225718617439,
-0.06095114350318909,
0.014580508694052696,
0.026774641126394272,
-0.04287969693541527,
0.022589994594454765,
0.02126510813832283,
0.04651927202939987,
-0.07121589034795761,
0.06492885202169418,
-0.03274506330490112,
-0.00038898768252693117,
0.012... | -0.002176 |
caching for read operations (GetSecret, GetSecretMap). When enabled, secrets are cached with the specified TTL. Write operations (PushSecret, DeleteSecret) automatically invalidate relevant cache entries. If omitted, caching is disabled (default). cache: {} is a valid option to set. | ### OracleAuth (*Appears on:* [OracleProvider](#external-secrets.io/v1.OracleProvider)) OracleAuth defines the authentication method for the Oracle Vault provider. | Field | Description | | --- | --- | | `tenancy` *string* | Tenancy is the tenancy OCID where user is located. | | `user` *string* | User is an access OCID specific to the account. | | `secretRef` *[OracleSecretRef](#external-secrets.io/v1.OracleSecretRef)* | SecretRef to pass through sensitive information. | ### OraclePrincipalType (`string` alias) (*Appears on:* [OracleProvider](#external-secrets.io/v1.OracleProvider)) OraclePrincipalType defines the type of principal used for authentication with Oracle Vault. | Value | Description | | --- | --- | | "InstancePrincipal" | InstancePrincipal represents a instance principal. | | "UserPrincipal" | UserPrincipal represents a user principal. | | "Workload" | WorkloadPrincipal represents a workload principal. | ### OracleProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) OracleProvider configures a store to sync secrets using an Oracle Vault backend. | Field | Description | | --- | --- | | `region` *string* | Region is the region where vault is located. | | `vault` *string* | Vault is the vault’s OCID of the specific vault where secret is located. | | `compartment` *string* | *(Optional)* Compartment is the vault compartment OCID. Required for PushSecret | | `encryptionKey` *string* | *(Optional)* EncryptionKey is the OCID of the encryption key within the vault. Required for PushSecret | | `principalType` *[OraclePrincipalType](#external-secrets.io/v1.OraclePrincipalType)* | *(Optional)* The type of principal to use for authentication. If left blank, the Auth struct will determine the principal type. This optional field must be specified if using workload identity. | | `auth` *[OracleAuth](#external-secrets.io/v1.OracleAuth)* | *(Optional)* Auth configures how secret-manager authenticates with the Oracle Vault. If empty, use the instance principal, otherwise the user credentials specified in Auth. | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* ServiceAccountRef specified the service account that should be used when authenticating with WorkloadIdentity. | ### OracleSecretRef (*Appears on:* [OracleAuth](#external-secrets.io/v1.OracleAuth)) OracleSecretRef contains the secret reference for Oracle Vault authentication credentials. | Field | Description | | --- | --- | | `privatekey` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | PrivateKey is the user’s API Signing Key in PEM format, used for authentication. | | `fingerprint` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | Fingerprint is the fingerprint of the API private key. | ### PassboltAuth (*Appears on:* [PassboltProvider](#external-secrets.io/v1.PassboltProvider)) PassboltAuth contains a secretRef for the passbolt credentials. | Field | Description | | --- | --- | | `passwordSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `privateKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### PassboltProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) PassboltProvider provides access to Passbolt secrets manager. See: <https://www.passbolt.com>. | Field | Description | | --- | --- | | `auth` *[PassboltAuth](#external-secrets.io/v1.PassboltAuth)* | Auth defines the information necessary to authenticate against Passbolt Server | | `host` *string* | Host defines the Passbolt Server to connect to | ### PasswordDepotAuth (*Appears on:* [PasswordDepotProvider](#external-secrets.io/v1.PasswordDepotProvider)) PasswordDepotAuth defines the authentication method for the Password Depot provider. | Field | Description | | --- | --- | | `secretRef` *[PasswordDepotSecretRef](#external-secrets.io/v1.PasswordDepotSecretRef)* | | ### PasswordDepotProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) PasswordDepotProvider configures a store to sync secrets with a Password Depot instance. | Field | Description | | --- | --- | | `host` *string* | URL configures the Password Depot instance URL. | | `database` *string* | Database to use as source | | `auth` *[PasswordDepotAuth](#external-secrets.io/v1.PasswordDepotAuth)* | Auth configures how secret-manager authenticates with a Password Depot instance. | ### PasswordDepotSecretRef (*Appears on:* [PasswordDepotAuth](#external-secrets.io/v1.PasswordDepotAuth)) PasswordDepotSecretRef contains the secret reference for Password Depot authentication. | Field | Description | | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.061157044023275375,
0.0077582127414643764,
-0.06925482302904129,
-0.03611324727535248,
-0.037085339426994324,
-0.07931419461965561,
0.05533459782600403,
0.04243997484445572,
0.04144241288304329,
-0.022360598668456078,
0.03221096470952034,
-0.011613672599196434,
0.017675574868917465,
-0.... | 0.015657 |
Password Depot instance URL. | | `database` *string* | Database to use as source | | `auth` *[PasswordDepotAuth](#external-secrets.io/v1.PasswordDepotAuth)* | Auth configures how secret-manager authenticates with a Password Depot instance. | ### PasswordDepotSecretRef (*Appears on:* [PasswordDepotAuth](#external-secrets.io/v1.PasswordDepotAuth)) PasswordDepotSecretRef contains the secret reference for Password Depot authentication. | Field | Description | | --- | --- | | `credentials` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* Username / Password is used for authentication. | ### PreviderAuth (*Appears on:* [PreviderProvider](#external-secrets.io/v1.PreviderProvider)) PreviderAuth contains a secretRef for credentials. | Field | Description | | --- | --- | | `secretRef` *[PreviderAuthSecretRef](#external-secrets.io/v1.PreviderAuthSecretRef)* | *(Optional)* | ### PreviderAuthSecretRef (*Appears on:* [PreviderAuth](#external-secrets.io/v1.PreviderAuth)) PreviderAuthSecretRef holds secret references for Previder Vault credentials. | Field | Description | | --- | --- | | `accessToken` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The AccessToken is used for authentication | ### PreviderProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) PreviderProvider configures a store to sync secrets using the Previder Secret Manager provider. | Field | Description | | --- | --- | | `auth` *[PreviderAuth](#external-secrets.io/v1.PreviderAuth)* | | | `baseUri` *string* | *(Optional)* | ### Provider Provider is a common interface for interacting with secret backends. ### PulumiProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) PulumiProvider defines configuration for accessing secrets from Pulumi ESC. | Field | Description | | --- | --- | | `apiUrl` *string* | APIURL is the URL of the Pulumi API. | | `accessToken` *[PulumiProviderSecretRef](#external-secrets.io/v1.PulumiProviderSecretRef)* | AccessToken is the access tokens to sign in to the Pulumi Cloud Console. | | `organization` *string* | Organization are a space to collaborate on shared projects and stacks. To create a new organization, visit <https://app.pulumi.com/> and click “New Organization”. | | `project` *string* | Project is the name of the Pulumi ESC project the environment belongs to. | | `environment` *string* | Environment are YAML documents composed of static key-value pairs, programmatic expressions, dynamically retrieved values from supported providers including all major clouds, and other Pulumi ESC environments. To create a new environment, visit <https://www.pulumi.com/docs/esc/environments/> for more information. | ### PulumiProviderSecretRef (*Appears on:* [PulumiProvider](#external-secrets.io/v1.PulumiProvider)) PulumiProviderSecretRef contains the secret reference for Pulumi authentication. | Field | Description | | --- | --- | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | SecretRef is a reference to a secret containing the Pulumi API token. | ### PushSecretData PushSecretData is an interface to allow using v1alpha1.PushSecretData content in Provider registered in v1. ### PushSecretRemoteRef PushSecretRemoteRef is an interface to allow using v1alpha1.PushSecretRemoteRef in Provider registered in v1. ### ScalewayProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) ScalewayProvider defines the configuration for the Scaleway Secret Manager provider. | Field | Description | | --- | --- | | `apiUrl` *string* | *(Optional)* APIURL is the url of the api to use. Defaults to <https://api.scaleway.com> | | `region` *string* | Region where your secrets are located: <https://developers.scaleway.com/en/quickstart/#region-and-zone> | | `projectId` *string* | ProjectID is the id of your project, which you can find in the console: <https://console.scaleway.com/project/settings> | | `accessKey` *[ScalewayProviderSecretRef](#external-secrets.io/v1.ScalewayProviderSecretRef)* | AccessKey is the non-secret part of the api key. | | `secretKey` *[ScalewayProviderSecretRef](#external-secrets.io/v1.ScalewayProviderSecretRef)* | SecretKey is the non-secret part of the api key. | ### ScalewayProviderSecretRef (*Appears on:* [ScalewayProvider](#external-secrets.io/v1.ScalewayProvider)) ScalewayProviderSecretRef defines the configuration for Scaleway secret references. | Field | Description | | --- | --- | | `value` *string* | *(Optional)* Value can be specified directly to set a value without using a secret. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef references a key in a secret that will be used as value. | ### SecretReference (*Appears on:* [AwsCredentialsConfig](#external-secrets.io/v1.AwsCredentialsConfig)) SecretReference holds the details of a secret. | Field | Description | | --- | --- | | `name` *string* | name of the secret. | | `namespace` *string* | namespace in | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.13018546998500824,
-0.027370082214474678,
-0.08557840436697006,
0.006201499607414007,
0.0038125694263726473,
0.06532331556081772,
0.0008612095261923969,
0.050795868039131165,
-0.0025704549625515938,
-0.011197163723409176,
0.005300457589328289,
-0.03566761314868927,
0.08709829300642014,
... | -0.009985 |
references a key in a secret that will be used as value. | ### SecretReference (*Appears on:* [AwsCredentialsConfig](#external-secrets.io/v1.AwsCredentialsConfig)) SecretReference holds the details of a secret. | Field | Description | | --- | --- | | `name` *string* | name of the secret. | | `namespace` *string* | namespace in which the secret exists. If empty, secret will looked up in local namespace. | ### SecretServerProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) SecretServerProvider provides access to authenticate to a secrets provider server. See: <https://github.com/DelineaXPM/tss-sdk-go/blob/main/server/server.go>. | Field | Description | | --- | --- | | `username` *[SecretServerProviderRef](#external-secrets.io/v1.SecretServerProviderRef)* | Username is the secret server account username. | | `password` *[SecretServerProviderRef](#external-secrets.io/v1.SecretServerProviderRef)* | Password is the secret server account password. | | `domain` *string* | *(Optional)* Domain is the secret server domain. | | `serverURL` *string* | ServerURL URL to your secret server installation | | `caBundle` *[]byte* | *(Optional)* PEM/base64 encoded CA bundle used to validate Secret ServerURL. Only used if the ServerURL URL is using HTTPS protocol. If not set the system root certificates are used to validate the TLS connection. | | `caProvider` *[CAProvider](#external-secrets.io/v1.CAProvider)* | *(Optional)* The provider for the CA bundle to use to validate Secret ServerURL certificate. | ### SecretServerProviderRef (*Appears on:* [SecretServerProvider](#external-secrets.io/v1.SecretServerProvider)) SecretServerProviderRef references a value that can be specified directly or via a secret for a SecretServerProvider. | Field | Description | | --- | --- | | `value` *string* | *(Optional)* Value can be specified directly to set a value without using a secret. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef references a key in a secret that will be used as value. | ### SecretStore SecretStore represents a secure external location for storing secrets, which can be referenced as part of `storeRef` fields. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[SecretStoreSpec](#external-secrets.io/v1.SecretStoreSpec)* | | `controller` *string* | *(Optional)* Used to select the correct ESO controller (think: ingress.ingressClassName) The ESO controller is instantiated with a specific controller name and filters ES based on this property | | --- | --- | | `provider` *[SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)* | Used to configure the provider. Only one provider may be set | | `retrySettings` *[SecretStoreRetrySettings](#external-secrets.io/v1.SecretStoreRetrySettings)* | *(Optional)* Used to configure HTTP retries on failures. | | `refreshInterval` *int* | *(Optional)* Used to configure store refresh interval in seconds. Empty or 0 will default to the controller config. | | `conditions` *[[]ClusterSecretStoreCondition](#external-secrets.io/v1.ClusterSecretStoreCondition)* | *(Optional)* Used to constrain a ClusterSecretStore to specific namespaces. Relevant only to ClusterSecretStore. | | | `status` *[SecretStoreStatus](#external-secrets.io/v1.SecretStoreStatus)* | | ### SecretStoreCapabilities (`string` alias) (*Appears on:* [SecretStoreStatus](#external-secrets.io/v1.SecretStoreStatus)) SecretStoreCapabilities defines the possible operations a SecretStore can do. | Value | Description | | --- | --- | | "ReadOnly" | SecretStoreReadOnly indicates that the store can only read secrets. | | "ReadWrite" | SecretStoreReadWrite indicates that the store can both read and write secrets. | | "WriteOnly" | SecretStoreWriteOnly indicates that the store can only write secrets. | ### SecretStoreConditionType (`string` alias) (*Appears on:* [SecretStoreStatusCondition](#external-secrets.io/v1.SecretStoreStatusCondition)) SecretStoreConditionType represents the condition of the SecretStore. | Value | Description | | --- | --- | | "Ready" | SecretStoreReady indicates that the store is ready and able to serve requests. | ### SecretStoreProvider (*Appears on:* [SecretStoreSpec](#external-secrets.io/v1.SecretStoreSpec)) SecretStoreProvider contains the provider-specific configuration. | Field | Description | | --- | --- | | `aws` *[AWSProvider](#external-secrets.io/v1.AWSProvider)* | *(Optional)* AWS configures this store to sync secrets using AWS Secret Manager provider | | `azurekv` *[AzureKVProvider](#external-secrets.io/v1.AzureKVProvider)* | *(Optional)* AzureKV configures this store to sync secrets using Azure Key Vault provider | | `akeyless` *[AkeylessProvider](#external-secrets.io/v1.AkeylessProvider)* | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.15153338015079498,
0.03678135946393013,
-0.08687468618154526,
0.03178847208619118,
0.03841210901737213,
0.013660754077136517,
0.08014095574617386,
0.039523787796497345,
0.07506238669157028,
0.020975720137357712,
0.009598223492503166,
-0.05127764865756035,
0.0571366623044014,
-0.00250140... | 0.087411 |
configuration. | Field | Description | | --- | --- | | `aws` *[AWSProvider](#external-secrets.io/v1.AWSProvider)* | *(Optional)* AWS configures this store to sync secrets using AWS Secret Manager provider | | `azurekv` *[AzureKVProvider](#external-secrets.io/v1.AzureKVProvider)* | *(Optional)* AzureKV configures this store to sync secrets using Azure Key Vault provider | | `akeyless` *[AkeylessProvider](#external-secrets.io/v1.AkeylessProvider)* | *(Optional)* Akeyless configures this store to sync secrets using Akeyless Vault provider | | `bitwardensecretsmanager` *[BitwardenSecretsManagerProvider](#external-secrets.io/v1.BitwardenSecretsManagerProvider)* | *(Optional)* BitwardenSecretsManager configures this store to sync secrets using BitwardenSecretsManager provider | | `vault` *[VaultProvider](#external-secrets.io/v1.VaultProvider)* | *(Optional)* Vault configures this store to sync secrets using the HashiCorp Vault provider. | | `gcpsm` *[GCPSMProvider](#external-secrets.io/v1.GCPSMProvider)* | *(Optional)* GCPSM configures this store to sync secrets using Google Cloud Platform Secret Manager provider | | `oracle` *[OracleProvider](#external-secrets.io/v1.OracleProvider)* | *(Optional)* Oracle configures this store to sync secrets using Oracle Vault provider | | `ibm` *[IBMProvider](#external-secrets.io/v1.IBMProvider)* | *(Optional)* IBM configures this store to sync secrets using IBM Cloud provider | | `yandexcertificatemanager` *[YandexCertificateManagerProvider](#external-secrets.io/v1.YandexCertificateManagerProvider)* | *(Optional)* YandexCertificateManager configures this store to sync secrets using Yandex Certificate Manager provider | | `yandexlockbox` *[YandexLockboxProvider](#external-secrets.io/v1.YandexLockboxProvider)* | *(Optional)* YandexLockbox configures this store to sync secrets using Yandex Lockbox provider | | `github` *[GithubProvider](#external-secrets.io/v1.GithubProvider)* | *(Optional)* Github configures this store to push GitHub Actions secrets using the GitHub API provider. Note: This provider only supports write operations (PushSecret) and cannot fetch secrets from GitHub | | `gitlab` *[GitlabProvider](#external-secrets.io/v1.GitlabProvider)* | *(Optional)* GitLab configures this store to sync secrets using GitLab Variables provider | | `alibaba` *[AlibabaProvider](#external-secrets.io/v1.AlibabaProvider)* | *(Optional)* Alibaba configures this store to sync secrets using Alibaba Cloud provider | | `onepassword` *[OnePasswordProvider](#external-secrets.io/v1.OnePasswordProvider)* | *(Optional)* OnePassword configures this store to sync secrets using the 1Password Cloud provider | | `onepasswordSDK` *[OnePasswordSDKProvider](#external-secrets.io/v1.OnePasswordSDKProvider)* | *(Optional)* OnePasswordSDK configures this store to use 1Password’s new Go SDK to sync secrets. | | `webhook` *[WebhookProvider](#external-secrets.io/v1.WebhookProvider)* | *(Optional)* Webhook configures this store to sync secrets using a generic templated webhook | | `kubernetes` *[KubernetesProvider](#external-secrets.io/v1.KubernetesProvider)* | *(Optional)* Kubernetes configures this store to sync secrets using a Kubernetes cluster provider | | `fake` *[FakeProvider](#external-secrets.io/v1.FakeProvider)* | *(Optional)* Fake configures a store with static key/value pairs | | `senhasegura` *[SenhaseguraProvider](#external-secrets.io/v1.SenhaseguraProvider)* | *(Optional)* Senhasegura configures this store to sync secrets using senhasegura provider | | `scaleway` *[ScalewayProvider](#external-secrets.io/v1.ScalewayProvider)* | *(Optional)* Scaleway configures this store to sync secrets using the Scaleway provider. | | `doppler` *[DopplerProvider](#external-secrets.io/v1.DopplerProvider)* | *(Optional)* Doppler configures this store to sync secrets using the Doppler provider | | `previder` *[PreviderProvider](#external-secrets.io/v1.PreviderProvider)* | *(Optional)* Previder configures this store to sync secrets using the Previder provider | | `onboardbase` *[OnboardbaseProvider](#external-secrets.io/v1.OnboardbaseProvider)* | *(Optional)* Onboardbase configures this store to sync secrets using the Onboardbase provider | | `keepersecurity` *[KeeperSecurityProvider](#external-secrets.io/v1.KeeperSecurityProvider)* | *(Optional)* KeeperSecurity configures this store to sync secrets using the KeeperSecurity provider | | `conjur` *[ConjurProvider](#external-secrets.io/v1.ConjurProvider)* | *(Optional)* Conjur configures this store to sync secrets using conjur provider | | `delinea` *[DelineaProvider](#external-secrets.io/v1.DelineaProvider)* | *(Optional)* Delinea DevOps Secrets Vault <https://docs.delinea.com/online-help/products/devops-secrets-vault/current> | | `secretserver` *[SecretServerProvider](#external-secrets.io/v1.SecretServerProvider)* | *(Optional)* SecretServer configures this store to sync secrets using SecretServer provider <https://docs.delinea.com/online-help/secret-server/start.htm> | | `chef` *[ChefProvider](#external-secrets.io/v1.ChefProvider)* | *(Optional)* Chef configures this store to sync secrets with chef server | | `pulumi` *[PulumiProvider](#external-secrets.io/v1.PulumiProvider)* | *(Optional)* Pulumi configures this store to sync secrets using the Pulumi provider | | `fortanix` *[FortanixProvider](#external-secrets.io/v1.FortanixProvider)* | *(Optional)* Fortanix configures this store to sync secrets using the Fortanix provider | | `passworddepot` *[PasswordDepotProvider](#external-secrets.io/v1.PasswordDepotProvider)* | *(Optional)* | | `passbolt` *[PassboltProvider](#external-secrets.io/v1.PassboltProvider)* | *(Optional)* | | `device42` *[Device42Provider](#external-secrets.io/v1.Device42Provider)* | *(Optional)* Device42 configures this store to sync secrets using the Device42 provider | | `dvls` *[DVLSProvider](#external-secrets.io/v1.DVLSProvider)* | *(Optional)* DVLS configures this store to sync secrets using Devolutions Server provider | | `infisical` *[InfisicalProvider](#external-secrets.io/v1.InfisicalProvider)* | *(Optional)* Infisical configures this store to sync secrets using the Infisical provider | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.09592956304550171,
-0.0003299076633993536,
-0.07657922804355621,
0.046692490577697754,
-0.005305047146975994,
0.027234097942709923,
-0.012566029094159603,
-0.05938824266195297,
0.07329096645116806,
0.0836612805724144,
0.0651453286409378,
-0.003633210202679038,
0.08133042603731155,
-0.05... | -0.052665 |
`device42` *[Device42Provider](#external-secrets.io/v1.Device42Provider)* | *(Optional)* Device42 configures this store to sync secrets using the Device42 provider | | `dvls` *[DVLSProvider](#external-secrets.io/v1.DVLSProvider)* | *(Optional)* DVLS configures this store to sync secrets using Devolutions Server provider | | `infisical` *[InfisicalProvider](#external-secrets.io/v1.InfisicalProvider)* | *(Optional)* Infisical configures this store to sync secrets using the Infisical provider | | `beyondtrust` *[BeyondtrustProvider](#external-secrets.io/v1.BeyondtrustProvider)* | *(Optional)* Beyondtrust configures this store to sync secrets using Password Safe provider. | | `cloudrusm` *[CloudruSMProvider](#external-secrets.io/v1.CloudruSMProvider)* | *(Optional)* CloudruSM configures this store to sync secrets using the Cloud.ru Secret Manager provider | | `volcengine` *[VolcengineProvider](#external-secrets.io/v1.VolcengineProvider)* | *(Optional)* Volcengine configures this store to sync secrets using the Volcengine provider | | `ngrok` *[NgrokProvider](#external-secrets.io/v1.NgrokProvider)* | *(Optional)* Ngrok configures this store to sync secrets using the ngrok provider. | | `barbican` *[BarbicanProvider](#external-secrets.io/v1.BarbicanProvider)* | *(Optional)* Barbican configures this store to sync secrets using the OpenStack Barbican provider | ### SecretStoreRef (*Appears on:* [ExternalSecretSpec](#external-secrets.io/v1.ExternalSecretSpec), [StoreGeneratorSourceRef](#external-secrets.io/v1.StoreGeneratorSourceRef), [StoreSourceRef](#external-secrets.io/v1.StoreSourceRef)) SecretStoreRef defines which SecretStore to fetch the ExternalSecret data. | Field | Description | | --- | --- | | `name` *string* | Name of the SecretStore resource | | `kind` *string* | *(Optional)* Kind of the SecretStore resource (SecretStore or ClusterSecretStore) Defaults to `SecretStore` | ### SecretStoreRetrySettings (*Appears on:* [SecretStoreSpec](#external-secrets.io/v1.SecretStoreSpec), [VaultDynamicSecretSpec](#generators.external-secrets.io/v1alpha1.VaultDynamicSecretSpec)) SecretStoreRetrySettings defines the retry settings for accessing external secrets manager stores. | Field | Description | | --- | --- | | `maxRetries` *int32* | | | `retryInterval` *string* | | ### SecretStoreSpec (*Appears on:* [ClusterSecretStore](#external-secrets.io/v1.ClusterSecretStore), [SecretStore](#external-secrets.io/v1.SecretStore)) SecretStoreSpec defines the desired state of SecretStore. | Field | Description | | --- | --- | | `controller` *string* | *(Optional)* Used to select the correct ESO controller (think: ingress.ingressClassName) The ESO controller is instantiated with a specific controller name and filters ES based on this property | | `provider` *[SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)* | Used to configure the provider. Only one provider may be set | | `retrySettings` *[SecretStoreRetrySettings](#external-secrets.io/v1.SecretStoreRetrySettings)* | *(Optional)* Used to configure HTTP retries on failures. | | `refreshInterval` *int* | *(Optional)* Used to configure store refresh interval in seconds. Empty or 0 will default to the controller config. | | `conditions` *[[]ClusterSecretStoreCondition](#external-secrets.io/v1.ClusterSecretStoreCondition)* | *(Optional)* Used to constrain a ClusterSecretStore to specific namespaces. Relevant only to ClusterSecretStore. | ### SecretStoreStatus (*Appears on:* [ClusterSecretStore](#external-secrets.io/v1.ClusterSecretStore), [SecretStore](#external-secrets.io/v1.SecretStore)) SecretStoreStatus defines the observed state of the SecretStore. | Field | Description | | --- | --- | | `conditions` *[[]SecretStoreStatusCondition](#external-secrets.io/v1.SecretStoreStatusCondition)* | *(Optional)* | | `capabilities` *[SecretStoreCapabilities](#external-secrets.io/v1.SecretStoreCapabilities)* | *(Optional)* | ### SecretStoreStatusCondition (*Appears on:* [SecretStoreStatus](#external-secrets.io/v1.SecretStoreStatus)) SecretStoreStatusCondition contains condition information for a SecretStore. | Field | Description | | --- | --- | | `type` *[SecretStoreConditionType](#external-secrets.io/v1.SecretStoreConditionType)* | | | `status` *[Kubernetes core/v1.ConditionStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#conditionstatus-v1-core)* | | | `reason` *string* | *(Optional)* | | `message` *string* | *(Optional)* | | `lastTransitionTime` *[Kubernetes meta/v1.Time](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#time-v1-meta)* | *(Optional)* | ### SecretVersionSelectionPolicy (`string` alias) (*Appears on:* [GCPSMProvider](#external-secrets.io/v1.GCPSMProvider)) SecretVersionSelectionPolicy defines the policy for selecting secret versions in GCP Secret Manager. | Value | Description | | --- | --- | | "LatestOrFail" | SecretVersionSelectionPolicyLatestOrFail means the provider always uses “latest”, or fails if that version is disabled/destroyed. | | "LatestOrFetch" | SecretVersionSelectionPolicyLatestOrFetch behaves like SecretVersionSelectionPolicyLatestOrFail but falls back to fetching the latest version if the version is DESTROYED or DISABLED. | ### SecretsClient SecretsClient provides access to secrets. ### SecretsManager (*Appears on:* [AWSProvider](#external-secrets.io/v1.AWSProvider)) SecretsManager defines how the provider behaves when interacting with AWS SecretsManager. Some of these settings are only applicable to controlling how secrets are deleted, and hence only apply to PushSecret (and only when deletionPolicy is set to Delete). | Field | Description | | --- | --- | | `forceDeleteWithoutRecovery` *bool* | *(Optional)* Specifies whether to delete the secret without any recovery window. You can’t use both this parameter and RecoveryWindowInDays in the same call. If you | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.11377424746751785,
-0.015984365716576576,
-0.026409436017274857,
-0.02716006711125374,
0.049836013466119766,
-0.036940403282642365,
-0.026305202394723892,
-0.011556924320757389,
0.015624606050550938,
0.037870630621910095,
0.07733145356178284,
-0.003724905429407954,
0.07462359219789505,
... | -0.012466 |
apply to PushSecret (and only when deletionPolicy is set to Delete). | Field | Description | | --- | --- | | `forceDeleteWithoutRecovery` *bool* | *(Optional)* Specifies whether to delete the secret without any recovery window. You can’t use both this parameter and RecoveryWindowInDays in the same call. If you don’t use either, then by default Secrets Manager uses a 30 day recovery window. see: <https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_DeleteSecret.html#SecretsManager-DeleteSecret-request-ForceDeleteWithoutRecovery> | | `recoveryWindowInDays` *int64* | *(Optional)* The number of days from 7 to 30 that Secrets Manager waits before permanently deleting the secret. You can’t use both this parameter and ForceDeleteWithoutRecovery in the same call. If you don’t use either, then by default Secrets Manager uses a 30-day recovery window. see: <https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_DeleteSecret.html#SecretsManager-DeleteSecret-request-RecoveryWindowInDays> | ### SenhaseguraAuth (*Appears on:* [SenhaseguraProvider](#external-secrets.io/v1.SenhaseguraProvider)) SenhaseguraAuth tells the controller how to do auth in senhasegura. | Field | Description | | --- | --- | | `clientId` *string* | | | `clientSecretSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### SenhaseguraModuleType (`string` alias) (*Appears on:* [SenhaseguraProvider](#external-secrets.io/v1.SenhaseguraProvider)) SenhaseguraModuleType enum defines senhasegura target module to fetch secrets | Value | Description | | --- | --- | | "DSM" | ``` SenhaseguraModuleDSM is the senhasegura DevOps Secrets Management module see: https://senhasegura.com/devops ``` | ### SenhaseguraProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) SenhaseguraProvider setup a store to sync secrets with senhasegura. | Field | Description | | --- | --- | | `url` *string* | URL of senhasegura | | `module` *[SenhaseguraModuleType](#external-secrets.io/v1.SenhaseguraModuleType)* | Module defines which senhasegura module should be used to get secrets | | `auth` *[SenhaseguraAuth](#external-secrets.io/v1.SenhaseguraAuth)* | Auth defines parameters to authenticate in senhasegura | | `ignoreSslCertificate` *bool* | IgnoreSslCertificate defines if SSL certificate must be ignored | ### StoreGeneratorSourceRef (*Appears on:* [ExternalSecretDataFromRemoteRef](#external-secrets.io/v1.ExternalSecretDataFromRemoteRef)) StoreGeneratorSourceRef allows you to override the source from which the secret will be pulled from. You can define at maximum one property. | Field | Description | | --- | --- | | `storeRef` *[SecretStoreRef](#external-secrets.io/v1.SecretStoreRef)* | *(Optional)* | | `generatorRef` *[GeneratorRef](#external-secrets.io/v1.GeneratorRef)* | *(Optional)* GeneratorRef points to a generator custom resource. | ### StoreSourceRef (*Appears on:* [ExternalSecretData](#external-secrets.io/v1.ExternalSecretData)) StoreSourceRef allows you to override the SecretStore source from which the secret will be pulled from. You can define at maximum one property. | Field | Description | | --- | --- | | `storeRef` *[SecretStoreRef](#external-secrets.io/v1.SecretStoreRef)* | *(Optional)* | | `generatorRef` *[GeneratorRef](#external-secrets.io/v1.GeneratorRef)* | GeneratorRef points to a generator custom resource. Deprecated: The generatorRef is not implemented in .data[]. this will be removed with v1. | ### Tag Tag is a key-value pair that can be attached to an AWS resource. see: <https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html> | Field | Description | | --- | --- | | `key` *string* | | | `value` *string* | | ### TemplateEngineVersion (`string` alias) (*Appears on:* [ExternalSecretTemplate](#external-secrets.io/v1.ExternalSecretTemplate)) TemplateEngineVersion specifies the template engine version that should be used to compile/execute the template. | Value | Description | | --- | --- | | "v2" | TemplateEngineV2 is the currently supported template engine version. | ### TemplateFrom (*Appears on:* [ExternalSecretTemplate](#external-secrets.io/v1.ExternalSecretTemplate)) TemplateFrom specifies a source for templates. Each item in the list can either reference a ConfigMap or a Secret resource. | Field | Description | | --- | --- | | `configMap` *[TemplateRef](#external-secrets.io/v1.TemplateRef)* | | | `secret` *[TemplateRef](#external-secrets.io/v1.TemplateRef)* | | | `target` *string* | *(Optional)* Target specifies where to place the template result. For Secret resources, common values are: “Data”, “Annotations”, “Labels”. For custom resources (when spec.target.manifest is set), this supports nested paths like “spec.database.config” or “data”. | | `literal` *string* | *(Optional)* | ### TemplateMergePolicy (`string` alias) (*Appears on:* [ExternalSecretTemplate](#external-secrets.io/v1.ExternalSecretTemplate)) TemplateMergePolicy defines how the rendered template should be merged with the existing Secret data. | Value | Description | | --- | --- | | "Merge" | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.062299005687236786,
0.00027386084548197687,
-0.006328228395432234,
0.062179092317819595,
0.03774956613779068,
0.03036760538816452,
-0.03585956618189812,
-0.05699572712182999,
0.09742337465286255,
0.04636938124895096,
0.03821289539337158,
-0.01696045510470867,
0.017222829163074493,
-0.02... | -0.040482 |
set), this supports nested paths like “spec.database.config” or “data”. | | `literal` *string* | *(Optional)* | ### TemplateMergePolicy (`string` alias) (*Appears on:* [ExternalSecretTemplate](#external-secrets.io/v1.ExternalSecretTemplate)) TemplateMergePolicy defines how the rendered template should be merged with the existing Secret data. | Value | Description | | --- | --- | | "Merge" | | | "Replace" | | ### TemplateRef (*Appears on:* [TemplateFrom](#external-secrets.io/v1.TemplateFrom)) TemplateRef specifies a reference to either a ConfigMap or a Secret resource. | Field | Description | | --- | --- | | `name` *string* | The name of the ConfigMap/Secret resource | | `items` *[[]TemplateRefItem](#external-secrets.io/v1.TemplateRefItem)* | A list of keys in the ConfigMap/Secret to use as templates for Secret data | ### TemplateRefItem (*Appears on:* [TemplateRef](#external-secrets.io/v1.TemplateRef)) TemplateRefItem specifies a key in the ConfigMap/Secret to use as a template for Secret data. | Field | Description | | --- | --- | | `key` *string* | A key in the ConfigMap/Secret | | `templateAs` *[TemplateScope](#external-secrets.io/v1.TemplateScope)* | | ### TemplateScope (`string` alias) (*Appears on:* [TemplateRefItem](#external-secrets.io/v1.TemplateRefItem)) TemplateScope specifies how the template keys should be interpreted. | Value | Description | | --- | --- | | "KeysAndValues" | | | "Values" | | ### TokenAuth (*Appears on:* [KubernetesAuth](#external-secrets.io/v1.KubernetesAuth)) TokenAuth defines token-based authentication configuration for Kubernetes. | Field | Description | | --- | --- | | `bearerToken` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### TokenAuthCredentials (*Appears on:* [InfisicalAuth](#external-secrets.io/v1.InfisicalAuth)) TokenAuthCredentials represents the credentials for access token-based authentication. | Field | Description | | --- | --- | | `accessToken` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### UniversalAuthCredentials (*Appears on:* [InfisicalAuth](#external-secrets.io/v1.InfisicalAuth)) UniversalAuthCredentials represents the client credentials for universal authentication. | Field | Description | | --- | --- | | `clientId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `clientSecret` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### ValidationResult (`byte` alias) (*Appears on:* [FakeProvider](#external-secrets.io/v1.FakeProvider)) ValidationResult is defined type for the number of validation results. | Value | Description | | --- | --- | | 2 | ValidationResultError indicates that there is a misconfiguration. | | 0 | ValidationResultReady indicates that the client is configured correctly and can be used. | | 1 | ValidationResultUnknown indicates that the client can be used but information is missing, and it can not be validated. | ### VaultAppRole (*Appears on:* [VaultAuth](#external-secrets.io/v1.VaultAuth)) VaultAppRole authenticates with Vault using the App Role auth mechanism, with the role and secret stored in a Kubernetes Secret resource. | Field | Description | | --- | --- | | `path` *string* | Path where the App Role authentication backend is mounted in Vault, e.g: “approle” | | `roleId` *string* | *(Optional)* RoleID configured in the App Role authentication backend when setting up the authentication backend in Vault. | | `roleRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* Reference to a key in a Secret that contains the App Role ID used to authenticate with Vault. The `key` field must be specified and denotes which entry within the Secret resource is used as the app role id. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | Reference to a key in a Secret that contains the App Role secret used to authenticate with Vault. The `key` field must be specified and denotes which entry within the Secret resource is used as the app role secret. | ### VaultAuth (*Appears on:* [VaultProvider](#external-secrets.io/v1.VaultProvider)) VaultAuth is the configuration used to authenticate with a Vault server. Only one of `tokenSecretRef`, `appRole`, `kubernetes`, `ldap`, `userPass`, `jwt`, `cert`, `iam` or `gcp` can be specified. A namespace to authenticate against can optionally be specified. | Field | Description | | --- | --- | | `namespace` *string* | *(Optional)* Name of the vault namespace to authenticate to. This can be different | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.061813950538635254,
0.00870407186448574,
-0.03109966404736042,
0.05093841627240181,
0.044707633554935455,
-0.0033767877612262964,
0.03127240389585495,
0.0862681120634079,
-0.03838454931974411,
-0.020409196615219116,
0.009518510662019253,
-0.05430044233798981,
0.05976872146129608,
-0.025... | 0.044964 |
of `tokenSecretRef`, `appRole`, `kubernetes`, `ldap`, `userPass`, `jwt`, `cert`, `iam` or `gcp` can be specified. A namespace to authenticate against can optionally be specified. | Field | Description | | --- | --- | | `namespace` *string* | *(Optional)* Name of the vault namespace to authenticate to. This can be different than the namespace your secret is in. Namespaces is a set of features within Vault Enterprise that allows Vault environments to support Secure Multi-tenancy. e.g: “ns1”. More about namespaces can be found here <https://www.vaultproject.io/docs/enterprise/namespaces> This will default to Vault.Namespace field if set, or empty otherwise | | `tokenSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* TokenSecretRef authenticates with Vault by presenting a token. | | `appRole` *[VaultAppRole](#external-secrets.io/v1.VaultAppRole)* | *(Optional)* AppRole authenticates with Vault using the App Role auth mechanism, with the role and secret stored in a Kubernetes Secret resource. | | `kubernetes` *[VaultKubernetesAuth](#external-secrets.io/v1.VaultKubernetesAuth)* | *(Optional)* Kubernetes authenticates with Vault by passing the ServiceAccount token stored in the named Secret resource to the Vault server. | | `ldap` *[VaultLdapAuth](#external-secrets.io/v1.VaultLdapAuth)* | *(Optional)* Ldap authenticates with Vault by passing username/password pair using the LDAP authentication method | | `jwt` *[VaultJwtAuth](#external-secrets.io/v1.VaultJwtAuth)* | *(Optional)* Jwt authenticates with Vault by passing role and JWT token using the JWT/OIDC authentication method | | `cert` *[VaultCertAuth](#external-secrets.io/v1.VaultCertAuth)* | *(Optional)* Cert authenticates with TLS Certificates by passing client certificate, private key and ca certificate Cert authentication method | | `iam` *[VaultIamAuth](#external-secrets.io/v1.VaultIamAuth)* | *(Optional)* Iam authenticates with vault by passing a special AWS request signed with AWS IAM credentials AWS IAM authentication method | | `userPass` *[VaultUserPassAuth](#external-secrets.io/v1.VaultUserPassAuth)* | *(Optional)* UserPass authenticates with Vault by passing username/password pair | | `gcp` *[VaultGCPAuth](#external-secrets.io/v1.VaultGCPAuth)* | *(Optional)* Gcp authenticates with Vault using Google Cloud Platform authentication method GCP authentication method | ### VaultAwsAuth VaultAwsAuth tells the controller how to do authentication with aws. Only one of secretRef or jwt can be specified. if none is specified the controller will try to load credentials from its own service account assuming it is IRSA enabled. | Field | Description | | --- | --- | | `secretRef` *[VaultAwsAuthSecretRef](#external-secrets.io/v1.VaultAwsAuthSecretRef)* | *(Optional)* | | `jwt` *[VaultAwsJWTAuth](#external-secrets.io/v1.VaultAwsJWTAuth)* | *(Optional)* | ### VaultAwsAuthSecretRef (*Appears on:* [VaultAwsAuth](#external-secrets.io/v1.VaultAwsAuth), [VaultIamAuth](#external-secrets.io/v1.VaultIamAuth)) VaultAwsAuthSecretRef holds secret references for AWS credentials both AccessKeyID and SecretAccessKey must be defined in order to properly authenticate. | Field | Description | | --- | --- | | `accessKeyIDSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The AccessKeyID is used for authentication | | `secretAccessKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The SecretAccessKey is used for authentication | | `sessionTokenSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The SessionToken used for authentication This must be defined if AccessKeyID and SecretAccessKey are temporary credentials see: <https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html> | ### VaultAwsJWTAuth (*Appears on:* [VaultAwsAuth](#external-secrets.io/v1.VaultAwsAuth), [VaultIamAuth](#external-secrets.io/v1.VaultIamAuth)) VaultAwsJWTAuth Authenticate against AWS using service account tokens. | Field | Description | | --- | --- | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* | ### VaultCertAuth (*Appears on:* [VaultAuth](#external-secrets.io/v1.VaultAuth)) VaultCertAuth authenticates with Vault using the JWT/OIDC authentication method, with the role name and token stored in a Kubernetes Secret resource. | Field | Description | | --- | --- | | `path` *string* | *(Optional)* Path where the Certificate authentication backend is mounted in Vault, e.g: “cert” | | `clientCert` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* ClientCert is a certificate to authenticate using the Cert Vault authentication method | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef to a key in a Secret resource containing client private key to authenticate with Vault using the Cert authentication method | ### VaultCheckAndSet (*Appears on:* [VaultProvider](#external-secrets.io/v1.VaultProvider)) VaultCheckAndSet defines the Check-And-Set (CAS) settings for Vault KV v2 PushSecret operations. | Field | Description | | --- | --- | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.020410718396306038,
-0.03681649640202522,
-0.03133835271000862,
-0.031552914530038834,
-0.039469797164201736,
-0.041876327246427536,
0.001680476008914411,
0.005049560219049454,
0.1052706316113472,
-0.013994788751006126,
-0.0064537362195551395,
-0.068311907351017,
0.07692547142505646,
0.... | 0.059926 |
*(Optional)* SecretRef to a key in a Secret resource containing client private key to authenticate with Vault using the Cert authentication method | ### VaultCheckAndSet (*Appears on:* [VaultProvider](#external-secrets.io/v1.VaultProvider)) VaultCheckAndSet defines the Check-And-Set (CAS) settings for Vault KV v2 PushSecret operations. | Field | Description | | --- | --- | | `required` *bool* | *(Optional)* Required when true, all write operations must include a check-and-set parameter. This helps prevent unintentional overwrites of secrets. | ### VaultClientTLS (*Appears on:* [VaultProvider](#external-secrets.io/v1.VaultProvider)) VaultClientTLS is the configuration used for client side related TLS communication, when the Vault server requires mutual authentication. | Field | Description | | --- | --- | | `certSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* CertSecretRef is a certificate added to the transport layer when communicating with the Vault server. If no key for the Secret is specified, external-secret will default to ‘tls.crt’. | | `keySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* KeySecretRef to a key in a Secret resource containing client private key added to the transport layer when communicating with the Vault server. If no key for the Secret is specified, external-secret will default to ‘tls.key’. | ### VaultGCPAuth (*Appears on:* [VaultAuth](#external-secrets.io/v1.VaultAuth)) VaultGCPAuth authenticates with Vault using Google Cloud Platform authentication method. Refer: <https://developer.hashicorp.com/vault/docs/auth/gcp> When ServiceAccountRef, SecretRef and WorkloadIdentity are not specified, the provider will use the controller pod’s identity to authenticate with GCP. This supports both GKE Workload Identity and service account keys. | Field | Description | | --- | --- | | `path` *string* | *(Optional)* Path where the GCP auth method is enabled in Vault, e.g: “gcp” | | `role` *string* | Vault Role. In Vault, a role describes an identity with a set of permissions, groups, or policies you want to attach to a user of the secrets engine. | | `projectID` *string* | *(Optional)* Project ID of the Google Cloud Platform project | | `location` *string* | *(Optional)* Location optionally defines a location/region for the secret | | `secretRef` *[GCPSMAuthSecretRef](#external-secrets.io/v1.GCPSMAuthSecretRef)* | *(Optional)* Specify credentials in a Secret object | | `workloadIdentity` *[GCPWorkloadIdentity](#external-secrets.io/v1.GCPWorkloadIdentity)* | *(Optional)* Specify a service account with Workload Identity | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* ServiceAccountRef to a service account for impersonation | ### VaultIamAuth (*Appears on:* [VaultAuth](#external-secrets.io/v1.VaultAuth)) VaultIamAuth authenticates with Vault using the Vault’s AWS IAM authentication method. Refer: <https://developer.hashicorp.com/vault/docs/auth/aws> When JWTAuth and SecretRef are not specified, the provider will use the controller pod’s identity to authenticate with AWS. This supports both IRSA and EKS Pod Identity. | Field | Description | | --- | --- | | `path` *string* | *(Optional)* Path where the AWS auth method is enabled in Vault, e.g: “aws” | | `region` *string* | *(Optional)* AWS region | | `role` *string* | *(Optional)* This is the AWS role to be assumed before talking to vault | | `vaultRole` *string* | Vault Role. In vault, a role describes an identity with a set of permissions, groups, or policies you want to attach a user of the secrets engine | | `externalID` *string* | AWS External ID set on assumed IAM roles | | `vaultAwsIamServerID` *string* | *(Optional)* X-Vault-AWS-IAM-Server-ID is an additional header used by Vault IAM auth method to mitigate against different types of replay attacks. More details here: <https://developer.hashicorp.com/vault/docs/auth/aws> | | `secretRef` *[VaultAwsAuthSecretRef](#external-secrets.io/v1.VaultAwsAuthSecretRef)* | *(Optional)* Specify credentials in a Secret object | | `jwt` *[VaultAwsJWTAuth](#external-secrets.io/v1.VaultAwsJWTAuth)* | *(Optional)* Specify a service account with IRSA enabled | ### VaultJwtAuth (*Appears on:* [VaultAuth](#external-secrets.io/v1.VaultAuth)) VaultJwtAuth authenticates with Vault using the JWT/OIDC authentication method, with the role name and a token stored in a Kubernetes Secret resource or a Kubernetes service account token retrieved via `TokenRequest`. | Field | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.05539953336119652,
0.0455639511346817,
-0.04880789667367935,
0.022244330495595932,
-0.00678495317697525,
-0.06154217943549156,
-0.025766611099243164,
0.022314826026558876,
0.08320499211549759,
-0.029698114842176437,
0.045967284590005875,
-0.03655128553509712,
0.07527517527341843,
0.0382... | -0.050865 |
*[VaultAwsJWTAuth](#external-secrets.io/v1.VaultAwsJWTAuth)* | *(Optional)* Specify a service account with IRSA enabled | ### VaultJwtAuth (*Appears on:* [VaultAuth](#external-secrets.io/v1.VaultAuth)) VaultJwtAuth authenticates with Vault using the JWT/OIDC authentication method, with the role name and a token stored in a Kubernetes Secret resource or a Kubernetes service account token retrieved via `TokenRequest`. | Field | Description | | --- | --- | | `path` *string* | Path where the JWT authentication backend is mounted in Vault, e.g: “jwt” | | `role` *string* | *(Optional)* Role is a JWT role to authenticate using the JWT/OIDC Vault authentication method | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* Optional SecretRef that refers to a key in a Secret resource containing JWT token to authenticate with Vault using the JWT/OIDC authentication method. | | `kubernetesServiceAccountToken` *[VaultKubernetesServiceAccountTokenAuth](#external-secrets.io/v1.VaultKubernetesServiceAccountTokenAuth)* | *(Optional)* Optional ServiceAccountToken specifies the Kubernetes service account for which to request a token for with the `TokenRequest` API. | ### VaultKVStoreVersion (`string` alias) (*Appears on:* [VaultProvider](#external-secrets.io/v1.VaultProvider)) VaultKVStoreVersion represents the version of the Vault KV secret engine. | Value | Description | | --- | --- | | "v1" | | | "v2" | | ### VaultKubernetesAuth (*Appears on:* [VaultAuth](#external-secrets.io/v1.VaultAuth)) VaultKubernetesAuth authenticates against Vault using a Kubernetes ServiceAccount token stored in a Secret. | Field | Description | | --- | --- | | `mountPath` *string* | Path where the Kubernetes authentication backend is mounted in Vault, e.g: “kubernetes” | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* Optional service account field containing the name of a kubernetes ServiceAccount. If the service account is specified, the service account secret token JWT will be used for authenticating with Vault. If the service account selector is not supplied, the secretRef will be used instead. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* Optional secret field containing a Kubernetes ServiceAccount JWT used for authenticating with Vault. If a name is specified without a key, `token` is the default. If one is not specified, the one bound to the controller will be used. | | `role` *string* | A required field containing the Vault Role to assume. A Role binds a Kubernetes ServiceAccount with a set of Vault policies. | ### VaultKubernetesServiceAccountTokenAuth (*Appears on:* [VaultJwtAuth](#external-secrets.io/v1.VaultJwtAuth)) VaultKubernetesServiceAccountTokenAuth authenticates with Vault using a temporary Kubernetes service account token retrieved by the `TokenRequest` API. | Field | Description | | --- | --- | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | Service account field containing the name of a kubernetes ServiceAccount. | | `audiences` *[]string* | *(Optional)* Optional audiences field that will be used to request a temporary Kubernetes service account token for the service account referenced by `serviceAccountRef`. Defaults to a single audience `vault` it not specified. Deprecated: use serviceAccountRef.Audiences instead | | `expirationSeconds` *int64* | *(Optional)* Optional expiration time in seconds that will be used to request a temporary Kubernetes service account token for the service account referenced by `serviceAccountRef`. Deprecated: this will be removed in the future. Defaults to 10 minutes. | ### VaultLdapAuth (*Appears on:* [VaultAuth](#external-secrets.io/v1.VaultAuth)) VaultLdapAuth authenticates with Vault using the LDAP authentication method, with the username and password stored in a Kubernetes Secret resource. | Field | Description | | --- | --- | | `path` *string* | Path where the LDAP authentication backend is mounted in Vault, e.g: “ldap” | | `username` *string* | Username is an LDAP username used to authenticate using the LDAP Vault authentication method | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef to a key in a Secret resource containing password for the LDAP user used to authenticate with Vault using the LDAP authentication method | ### VaultProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider), [VaultDynamicSecretSpec](#generators.external-secrets.io/v1alpha1.VaultDynamicSecretSpec)) VaultProvider configures a store to sync secrets | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.06867007911205292,
0.021500885486602783,
-0.03514629229903221,
-0.02902338281273842,
-0.020656049251556396,
-0.037684015929698944,
-0.00602197227999568,
0.028267715126276016,
0.07661812752485275,
-0.05609208345413208,
-0.01701301336288452,
-0.020283181220293045,
0.016573768109083176,
-0... | 0.061917 |
LDAP Vault authentication method | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef to a key in a Secret resource containing password for the LDAP user used to authenticate with Vault using the LDAP authentication method | ### VaultProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider), [VaultDynamicSecretSpec](#generators.external-secrets.io/v1alpha1.VaultDynamicSecretSpec)) VaultProvider configures a store to sync secrets using a Hashicorp Vault KV backend. | Field | Description | | --- | --- | | `auth` *[VaultAuth](#external-secrets.io/v1.VaultAuth)* | Auth configures how secret-manager authenticates with the Vault server. | | `server` *string* | Server is the connection address for the Vault server, e.g: “[https://vault.example.com:8200”](https://vault.example.com:8200"). | | `path` *string* | *(Optional)* Path is the mount path of the Vault KV backend endpoint, e.g: “secret”. The v2 KV secret engine version specific “/data” path suffix for fetching secrets from Vault is optional and will be appended if not present in specified path. | | `version` *[VaultKVStoreVersion](#external-secrets.io/v1.VaultKVStoreVersion)* | Version is the Vault KV secret engine version. This can be either “v1” or “v2”. Version defaults to “v2”. | | `namespace` *string* | *(Optional)* Name of the vault namespace. Namespaces is a set of features within Vault Enterprise that allows Vault environments to support Secure Multi-tenancy. e.g: “ns1”. More about namespaces can be found here <https://www.vaultproject.io/docs/enterprise/namespaces> | | `caBundle` *[]byte* | *(Optional)* PEM encoded CA bundle used to validate Vault server certificate. Only used if the Server URL is using HTTPS protocol. This parameter is ignored for plain HTTP protocol connection. If not set the system root certificates are used to validate the TLS connection. | | `tls` *[VaultClientTLS](#external-secrets.io/v1.VaultClientTLS)* | *(Optional)* The configuration used for client side related TLS communication, when the Vault server requires mutual authentication. Only used if the Server URL is using HTTPS protocol. This parameter is ignored for plain HTTP protocol connection. It’s worth noting this configuration is different from the “TLS certificates auth method”, which is available under the `auth.cert` section. | | `caProvider` *[CAProvider](#external-secrets.io/v1.CAProvider)* | *(Optional)* The provider for the CA bundle to use to validate Vault server certificate. | | `readYourWrites` *bool* | *(Optional)* ReadYourWrites ensures isolated read-after-write semantics by providing discovered cluster replication states in each request. More information about eventual consistency in Vault can be found here <https://www.vaultproject.io/docs/enterprise/consistency> | | `forwardInconsistent` *bool* | *(Optional)* ForwardInconsistent tells Vault to forward read-after-write requests to the Vault leader instead of simply retrying within a loop. This can increase performance if the option is enabled serverside. <https://www.vaultproject.io/docs/configuration/replication#allow_forwarding_via_header> | | `headers` *map[string]string* | *(Optional)* Headers to be added in Vault request | | `checkAndSet` *[VaultCheckAndSet](#external-secrets.io/v1.VaultCheckAndSet)* | *(Optional)* CheckAndSet defines the Check-And-Set (CAS) settings for PushSecret operations. Only applies to Vault KV v2 stores. When enabled, write operations must include the current version of the secret to prevent unintentional overwrites. | ### VaultUserPassAuth (*Appears on:* [VaultAuth](#external-secrets.io/v1.VaultAuth)) VaultUserPassAuth authenticates with Vault using UserPass authentication method, with the username and password stored in a Kubernetes Secret resource. | Field | Description | | --- | --- | | `path` *string* | Path where the UserPassword authentication backend is mounted in Vault, e.g: “userpass” | | `username` *string* | Username is a username used to authenticate using the UserPass Vault authentication method | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef to a key in a Secret resource containing password for the user used to authenticate with Vault using the UserPass authentication method | ### VolcengineAuth (*Appears on:* [VolcengineProvider](#external-secrets.io/v1.VolcengineProvider)) VolcengineAuth defines the authentication method for the Volcengine provider. Only one of the fields should be set. | Field | Description | | --- | --- | | `secretRef` *[VolcengineAuthSecretRef](#external-secrets.io/v1.VolcengineAuthSecretRef)* | *(Optional)* SecretRef defines the static credentials to use for authentication. If not set, | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.03832278400659561,
0.0036248706746846437,
-0.11764112859964371,
-0.03596799448132515,
-0.006004685536026955,
-0.013127879239618778,
-0.01688866689801216,
0.04911414906382561,
0.0001978963118745014,
-0.04879867285490036,
0.07715348154306412,
-0.018712786957621574,
0.03227338567376137,
-0... | -0.066281 |
| ### VolcengineAuth (*Appears on:* [VolcengineProvider](#external-secrets.io/v1.VolcengineProvider)) VolcengineAuth defines the authentication method for the Volcengine provider. Only one of the fields should be set. | Field | Description | | --- | --- | | `secretRef` *[VolcengineAuthSecretRef](#external-secrets.io/v1.VolcengineAuthSecretRef)* | *(Optional)* SecretRef defines the static credentials to use for authentication. If not set, IRSA is used. | ### VolcengineAuthSecretRef (*Appears on:* [VolcengineAuth](#external-secrets.io/v1.VolcengineAuth)) VolcengineAuthSecretRef defines the secret reference for static credentials. | Field | Description | | --- | --- | | `accessKeyID` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | AccessKeyID is the reference to the secret containing the Access Key ID. | | `secretAccessKey` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | SecretAccessKey is the reference to the secret containing the Secret Access Key. | | `token` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* Token is the reference to the secret containing the STS(Security Token Service) Token. | ### VolcengineProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) VolcengineProvider defines the configuration for the Volcengine provider. | Field | Description | | --- | --- | | `region` *string* | Region specifies the Volcengine region to connect to. | | `auth` *[VolcengineAuth](#external-secrets.io/v1.VolcengineAuth)* | *(Optional)* Auth defines the authentication method to use. If not specified, the provider will try to use IRSA (IAM Role for Service Account). | ### WebhookCAProvider (*Appears on:* [WebhookProvider](#external-secrets.io/v1.WebhookProvider)) WebhookCAProvider defines a location to fetch the cert for the webhook provider from. | Field | Description | | --- | --- | | `type` *[WebhookCAProviderType](#external-secrets.io/v1.WebhookCAProviderType)* | The type of provider to use such as “Secret”, or “ConfigMap”. | | `name` *string* | The name of the object located at the provider type. | | `key` *string* | The key where the CA certificate can be found in the Secret or ConfigMap. | | `namespace` *string* | *(Optional)* The namespace the Provider type is in. | ### WebhookCAProviderType (`string` alias) (*Appears on:* [WebhookCAProvider](#external-secrets.io/v1.WebhookCAProvider)) WebhookCAProviderType defines the type of provider for certificate authority in webhook connections. | Value | Description | | --- | --- | | "ConfigMap" | WebhookCAProviderTypeConfigMap indicates that the CA certificate is stored in a ConfigMap resource. | | "Secret" | WebhookCAProviderTypeSecret indicates that the CA certificate is stored in a Secret resource. | ### WebhookProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) WebhookProvider configures a store to sync secrets from simple web APIs. | Field | Description | | --- | --- | | `method` *string* | Webhook Method | | `url` *string* | Webhook url to call | | `headers` *map[string]string* | *(Optional)* Headers | | `auth` *[AuthorizationProtocol](#external-secrets.io/v1.AuthorizationProtocol)* | *(Optional)* Auth specifies a authorization protocol. Only one protocol may be set. | | `body` *string* | *(Optional)* Body | | `timeout` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | *(Optional)* Timeout | | `result` *[WebhookResult](#external-secrets.io/v1.WebhookResult)* | *(Optional)* Result formatting | | `secrets` *[[]WebhookSecret](#external-secrets.io/v1.WebhookSecret)* | *(Optional)* Secrets to fill in templates These secrets will be passed to the templating function as key value pairs under the given name | | `caBundle` *[]byte* | *(Optional)* PEM encoded CA bundle used to validate webhook server certificate. Only used if the Server URL is using HTTPS protocol. This parameter is ignored for plain HTTP protocol connection. If not set the system root certificates are used to validate the TLS connection. | | `caProvider` *[WebhookCAProvider](#external-secrets.io/v1.WebhookCAProvider)* | *(Optional)* The provider for the CA bundle to use to validate webhook server certificate. | ### WebhookResult (*Appears on:* [WebhookProvider](#external-secrets.io/v1.WebhookProvider)) WebhookResult defines how to process and extract secrets from the webhook response. | Field | Description | | --- | --- | | `jsonPath` *string* | *(Optional)* Json path of return value | ### WebhookSecret (*Appears on:* [WebhookProvider](#external-secrets.io/v1.WebhookProvider)) WebhookSecret defines a secret that will be passed to the webhook request. | Field | Description | | --- | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.1431988775730133,
0.014834515750408173,
-0.08901795744895935,
-0.019247138872742653,
-0.0183025561273098,
-0.006835650652647018,
0.021182119846343994,
0.04518110677599907,
-0.004314227029681206,
-0.016421722248196602,
0.02766125649213791,
-0.05195044353604317,
0.004032989032566547,
0.01... | 0.039278 |
from the webhook response. | Field | Description | | --- | --- | | `jsonPath` *string* | *(Optional)* Json path of return value | ### WebhookSecret (*Appears on:* [WebhookProvider](#external-secrets.io/v1.WebhookProvider)) WebhookSecret defines a secret that will be passed to the webhook request. | Field | Description | | --- | --- | | `name` *string* | Name of this secret in templates | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | Secret ref to fill in credentials | ### YandexAuth (*Appears on:* [YandexCertificateManagerProvider](#external-secrets.io/v1.YandexCertificateManagerProvider), [YandexLockboxProvider](#external-secrets.io/v1.YandexLockboxProvider)) YandexAuth defines the authentication method for the Yandex provider. | Field | Description | | --- | --- | | `authorizedKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The authorized key used for authentication | ### YandexCAProvider (*Appears on:* [YandexCertificateManagerProvider](#external-secrets.io/v1.YandexCertificateManagerProvider), [YandexLockboxProvider](#external-secrets.io/v1.YandexLockboxProvider)) YandexCAProvider defines the configuration for Yandex custom certificate authority. | Field | Description | | --- | --- | | `certSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### YandexCertificateManagerProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) YandexCertificateManagerProvider Configures a store to sync secrets using the Yandex Certificate Manager provider. | Field | Description | | --- | --- | | `apiEndpoint` *string* | *(Optional)* Yandex.Cloud API endpoint (e.g. ‘api.cloud.yandex.net:443’) | | `auth` *[YandexAuth](#external-secrets.io/v1.YandexAuth)* | Auth defines the information necessary to authenticate against Yandex.Cloud | | `caProvider` *[YandexCAProvider](#external-secrets.io/v1.YandexCAProvider)* | *(Optional)* The provider for the CA bundle to use to validate Yandex.Cloud server certificate. | | `fetching` *[FetchingPolicy](#external-secrets.io/v1.FetchingPolicy)* | *(Optional)* FetchingPolicy configures the provider to interpret the `data.secretKey.remoteRef.key` field in ExternalSecret as certificate ID or certificate name | ### YandexLockboxProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1.SecretStoreProvider)) YandexLockboxProvider Configures a store to sync secrets using the Yandex Lockbox provider. | Field | Description | | --- | --- | | `apiEndpoint` *string* | *(Optional)* Yandex.Cloud API endpoint (e.g. ‘api.cloud.yandex.net:443’) | | `auth` *[YandexAuth](#external-secrets.io/v1.YandexAuth)* | Auth defines the information necessary to authenticate against Yandex.Cloud | | `caProvider` *[YandexCAProvider](#external-secrets.io/v1.YandexCAProvider)* | *(Optional)* The provider for the CA bundle to use to validate Yandex.Cloud server certificate. | | `fetching` *[FetchingPolicy](#external-secrets.io/v1.FetchingPolicy)* | *(Optional)* FetchingPolicy configures the provider to interpret the `data.secretKey.remoteRef.key` field in ExternalSecret as secret ID or secret name | --- ## external-secrets.io/v1alpha1 Package v1alpha1 contains resources for external-secrets Resource Types: ### ClusterPushSecret ClusterPushSecret is the Schema for the ClusterPushSecrets API that enables cluster-wide management of pushing Kubernetes secrets to external providers. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[ClusterPushSecretSpec](#external-secrets.io/v1alpha1.ClusterPushSecretSpec)* | | `pushSecretSpec` *[PushSecretSpec](#external-secrets.io/v1alpha1.PushSecretSpec)* | PushSecretSpec defines what to do with the secrets. | | --- | --- | | `refreshTime` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | The time in which the controller should reconcile its objects and recheck namespaces for labels. | | `pushSecretName` *string* | *(Optional)* The name of the push secrets to be created. Defaults to the name of the ClusterPushSecret | | `pushSecretMetadata` *[PushSecretMetadata](#external-secrets.io/v1alpha1.PushSecretMetadata)* | *(Optional)* The metadata of the external secrets to be created | | `namespaceSelectors` *[[]\*k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#*k8s.io/apimachinery/pkg/apis/meta/v1.labelselector--)* | *(Optional)* A list of labels to select by to find the Namespaces to create the ExternalSecrets in. The selectors are ORed. | | | `status` *[ClusterPushSecretStatus](#external-secrets.io/v1alpha1.ClusterPushSecretStatus)* | | ### ClusterPushSecretCondition ClusterPushSecretCondition used to refine PushSecrets to specific namespaces and names. | Field | Description | | --- | --- | | `namespaceSelector` *[Kubernetes meta/v1.LabelSelector](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#labelselector-v1-meta)* | *(Optional)* Choose namespace using a labelSelector | | `namespaces` *[]string* | *(Optional)* Choose namespaces by name | ### ClusterPushSecretNamespaceFailure (*Appears on:* [ClusterPushSecretStatus](#external-secrets.io/v1alpha1.ClusterPushSecretStatus)) ClusterPushSecretNamespaceFailure represents a failed namespace deployment and it’s reason. | Field | Description | | --- | --- | | `namespace` *string* | Namespace is the namespace that failed when trying to apply an PushSecret | | `reason` *string* | *(Optional)* Reason | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.15829278528690338,
0.09492944926023483,
-0.08011692017316818,
0.024155456572771072,
0.03536712005734444,
-0.04054562747478485,
-0.0066649722866714,
0.003581382567062974,
0.045019540935754776,
-0.019962159916758537,
0.03096632845699787,
-0.1048813983798027,
0.019025925546884537,
-0.03855... | 0.095771 |
by name | ### ClusterPushSecretNamespaceFailure (*Appears on:* [ClusterPushSecretStatus](#external-secrets.io/v1alpha1.ClusterPushSecretStatus)) ClusterPushSecretNamespaceFailure represents a failed namespace deployment and it’s reason. | Field | Description | | --- | --- | | `namespace` *string* | Namespace is the namespace that failed when trying to apply an PushSecret | | `reason` *string* | *(Optional)* Reason is why the PushSecret failed to apply to the namespace | ### ClusterPushSecretSpec (*Appears on:* [ClusterPushSecret](#external-secrets.io/v1alpha1.ClusterPushSecret)) ClusterPushSecretSpec defines the configuration for a ClusterPushSecret resource. | Field | Description | | --- | --- | | `pushSecretSpec` *[PushSecretSpec](#external-secrets.io/v1alpha1.PushSecretSpec)* | PushSecretSpec defines what to do with the secrets. | | `refreshTime` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | The time in which the controller should reconcile its objects and recheck namespaces for labels. | | `pushSecretName` *string* | *(Optional)* The name of the push secrets to be created. Defaults to the name of the ClusterPushSecret | | `pushSecretMetadata` *[PushSecretMetadata](#external-secrets.io/v1alpha1.PushSecretMetadata)* | *(Optional)* The metadata of the external secrets to be created | | `namespaceSelectors` *[[]\*k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#*k8s.io/apimachinery/pkg/apis/meta/v1.labelselector--)* | *(Optional)* A list of labels to select by to find the Namespaces to create the ExternalSecrets in. The selectors are ORed. | ### ClusterPushSecretStatus (*Appears on:* [ClusterPushSecret](#external-secrets.io/v1alpha1.ClusterPushSecret)) ClusterPushSecretStatus contains the status information for the ClusterPushSecret resource. | Field | Description | | --- | --- | | `failedNamespaces` *[[]ClusterPushSecretNamespaceFailure](#external-secrets.io/v1alpha1.ClusterPushSecretNamespaceFailure)* | *(Optional)* Failed namespaces are the namespaces that failed to apply an PushSecret | | `provisionedNamespaces` *[]string* | *(Optional)* ProvisionedNamespaces are the namespaces where the ClusterPushSecret has secrets | | `pushSecretName` *string* | | | `conditions` *[[]PushSecretStatusCondition](#external-secrets.io/v1alpha1.PushSecretStatusCondition)* | *(Optional)* | ### PushSecret PushSecret is the Schema for the PushSecrets API that enables pushing Kubernetes secrets to external secret providers. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[PushSecretSpec](#external-secrets.io/v1alpha1.PushSecretSpec)* | | `refreshInterval` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | The Interval to which External Secrets will try to push a secret definition | | --- | --- | | `secretStoreRefs` *[[]PushSecretStoreRef](#external-secrets.io/v1alpha1.PushSecretStoreRef)* | | | `updatePolicy` *[PushSecretUpdatePolicy](#external-secrets.io/v1alpha1.PushSecretUpdatePolicy)* | *(Optional)* UpdatePolicy to handle Secrets in the provider. | | `deletionPolicy` *[PushSecretDeletionPolicy](#external-secrets.io/v1alpha1.PushSecretDeletionPolicy)* | *(Optional)* Deletion Policy to handle Secrets in the provider. | | `selector` *[PushSecretSelector](#external-secrets.io/v1alpha1.PushSecretSelector)* | The Secret Selector (k8s source) for the Push Secret | | `data` *[[]PushSecretData](#external-secrets.io/v1alpha1.PushSecretData)* | Secret Data that should be pushed to providers | | `template` *[ExternalSecretTemplate](#external-secrets.io/v1.ExternalSecretTemplate)* | *(Optional)* Template defines a blueprint for the created Secret resource. | | | `status` *[PushSecretStatus](#external-secrets.io/v1alpha1.PushSecretStatus)* | | ### PushSecretConditionType (`string` alias) (*Appears on:* [PushSecretStatusCondition](#external-secrets.io/v1alpha1.PushSecretStatusCondition)) PushSecretConditionType indicates the condition of the PushSecret. | Value | Description | | --- | --- | | "Ready" | PushSecretReady indicates the PushSecret resource is ready. | ### PushSecretConversionStrategy (`string` alias) (*Appears on:* [PushSecretData](#external-secrets.io/v1alpha1.PushSecretData)) PushSecretConversionStrategy defines how secret values are converted when pushed to providers. | Value | Description | | --- | --- | | "None" | PushSecretConversionNone indicates no conversion will be performed on the secret value. | | "ReverseUnicode" | PushSecretConversionReverseUnicode indicates that unicode escape sequences will be reversed. | ### PushSecretData (*Appears on:* [PushSecretSpec](#external-secrets.io/v1alpha1.PushSecretSpec)) PushSecretData defines data to be pushed to the provider and associated metadata. | Field | Description | | --- | --- | | `match` *[PushSecretMatch](#external-secrets.io/v1alpha1.PushSecretMatch)* | Match a given Secret Key to be pushed to the provider. | | `metadata` *k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSON* | *(Optional)* Metadata is metadata attached to the secret. The structure of metadata is provider specific, please look it up in the provider documentation. | | `conversionStrategy` *[PushSecretConversionStrategy](#external-secrets.io/v1alpha1.PushSecretConversionStrategy)* | *(Optional)* Used to define a conversion Strategy for the secret keys | ### PushSecretDeletionPolicy (`string` alias) (*Appears on:* [PushSecretSpec](#external-secrets.io/v1alpha1.PushSecretSpec)) PushSecretDeletionPolicy defines how push secrets are deleted in the provider. | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.05731118842959404,
-0.12279193848371506,
0.007004527375102043,
0.019372791051864624,
-0.0022971697617322206,
-0.020744197070598602,
0.008196576498448849,
0.0021776931826025248,
-0.008216659538447857,
0.01862514019012451,
0.06294482946395874,
-0.14148667454719543,
0.026317918673157692,
0... | 0.105011 |
The structure of metadata is provider specific, please look it up in the provider documentation. | | `conversionStrategy` *[PushSecretConversionStrategy](#external-secrets.io/v1alpha1.PushSecretConversionStrategy)* | *(Optional)* Used to define a conversion Strategy for the secret keys | ### PushSecretDeletionPolicy (`string` alias) (*Appears on:* [PushSecretSpec](#external-secrets.io/v1alpha1.PushSecretSpec)) PushSecretDeletionPolicy defines how push secrets are deleted in the provider. | Value | Description | | --- | --- | | "Delete" | PushSecretDeletionPolicyDelete deletes secrets from the provider when the PushSecret is deleted. | | "None" | PushSecretDeletionPolicyNone keeps secrets in the provider when the PushSecret is deleted. | ### PushSecretMatch (*Appears on:* [PushSecretData](#external-secrets.io/v1alpha1.PushSecretData)) PushSecretMatch defines how a source Secret key maps to a destination in the provider. | Field | Description | | --- | --- | | `secretKey` *string* | *(Optional)* Secret Key to be pushed | | `remoteRef` *[PushSecretRemoteRef](#external-secrets.io/v1alpha1.PushSecretRemoteRef)* | Remote Refs to push to providers. | ### PushSecretMetadata (*Appears on:* [ClusterPushSecretSpec](#external-secrets.io/v1alpha1.ClusterPushSecretSpec)) PushSecretMetadata defines metadata fields for the PushSecret generated by the ClusterPushSecret. | Field | Description | | --- | --- | | `annotations` *map[string]string* | *(Optional)* | | `labels` *map[string]string* | *(Optional)* | ### PushSecretRemoteRef (*Appears on:* [PushSecretMatch](#external-secrets.io/v1alpha1.PushSecretMatch)) PushSecretRemoteRef defines the location of the secret in the provider. | Field | Description | | --- | --- | | `remoteKey` *string* | Name of the resulting provider secret. | | `property` *string* | *(Optional)* Name of the property in the resulting secret | ### PushSecretSecret (*Appears on:* [PushSecretSelector](#external-secrets.io/v1alpha1.PushSecretSelector)) PushSecretSecret defines a Secret that will be used as a source for pushing to providers. | Field | Description | | --- | --- | | `name` *string* | *(Optional)* Name of the Secret. The Secret must exist in the same namespace as the PushSecret manifest. | | `selector` *[Kubernetes meta/v1.LabelSelector](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#labelselector-v1-meta)* | *(Optional)* Selector chooses secrets using a labelSelector. | ### PushSecretSelector (*Appears on:* [PushSecretSpec](#external-secrets.io/v1alpha1.PushSecretSpec)) PushSecretSelector defines criteria for selecting the source Secret for pushing to providers. | Field | Description | | --- | --- | | `secret` *[PushSecretSecret](#external-secrets.io/v1alpha1.PushSecretSecret)* | *(Optional)* Select a Secret to Push. | | `generatorRef` *[GeneratorRef](#external-secrets.io/v1.GeneratorRef)* | *(Optional)* Point to a generator to create a Secret. | ### PushSecretSpec (*Appears on:* [ClusterPushSecretSpec](#external-secrets.io/v1alpha1.ClusterPushSecretSpec), [PushSecret](#external-secrets.io/v1alpha1.PushSecret)) PushSecretSpec configures the behavior of the PushSecret. | Field | Description | | --- | --- | | `refreshInterval` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | The Interval to which External Secrets will try to push a secret definition | | `secretStoreRefs` *[[]PushSecretStoreRef](#external-secrets.io/v1alpha1.PushSecretStoreRef)* | | | `updatePolicy` *[PushSecretUpdatePolicy](#external-secrets.io/v1alpha1.PushSecretUpdatePolicy)* | *(Optional)* UpdatePolicy to handle Secrets in the provider. | | `deletionPolicy` *[PushSecretDeletionPolicy](#external-secrets.io/v1alpha1.PushSecretDeletionPolicy)* | *(Optional)* Deletion Policy to handle Secrets in the provider. | | `selector` *[PushSecretSelector](#external-secrets.io/v1alpha1.PushSecretSelector)* | The Secret Selector (k8s source) for the Push Secret | | `data` *[[]PushSecretData](#external-secrets.io/v1alpha1.PushSecretData)* | Secret Data that should be pushed to providers | | `template` *[ExternalSecretTemplate](#external-secrets.io/v1.ExternalSecretTemplate)* | *(Optional)* Template defines a blueprint for the created Secret resource. | ### PushSecretStatus (*Appears on:* [PushSecret](#external-secrets.io/v1alpha1.PushSecret)) PushSecretStatus indicates the history of the status of PushSecret. | Field | Description | | --- | --- | | `refreshTime` *[Kubernetes meta/v1.Time](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#time-v1-meta)* | refreshTime is the time and date the external secret was fetched and the target secret updated | | `syncedResourceVersion` *string* | SyncedResourceVersion keeps track of the last synced version. | | `syncedPushSecrets` *[SyncedPushSecretsMap](#external-secrets.io/v1alpha1.SyncedPushSecretsMap)* | *(Optional)* Synced PushSecrets, including secrets that already exist in provider. Matches secret stores to PushSecretData that was stored to that secret store. | | `conditions` *[[]PushSecretStatusCondition](#external-secrets.io/v1alpha1.PushSecretStatusCondition)* | *(Optional)* | ### PushSecretStatusCondition (*Appears on:* [ClusterPushSecretStatus](#external-secrets.io/v1alpha1.ClusterPushSecretStatus), [PushSecretStatus](#external-secrets.io/v1alpha1.PushSecretStatus)) PushSecretStatusCondition indicates the status of the PushSecret. | Field | Description | | --- | --- | | `type` *[PushSecretConditionType](#external-secrets.io/v1alpha1.PushSecretConditionType)* | | | `status` *[Kubernetes core/v1.ConditionStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#conditionstatus-v1-core)* | | | `reason` *string* | *(Optional)* | | `message` *string* | *(Optional)* | | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.06928125768899918,
-0.036075323820114136,
-0.074940524995327,
-0.00007189880852820352,
0.0344742089509964,
-0.042050108313560486,
0.016481909900903702,
-0.01380284782499075,
0.040294814854860306,
-0.010153776034712791,
0.052911099046468735,
-0.03960559889674187,
0.07817978411912918,
-0.... | -0.000503 |
| *(Optional)* | ### PushSecretStatusCondition (*Appears on:* [ClusterPushSecretStatus](#external-secrets.io/v1alpha1.ClusterPushSecretStatus), [PushSecretStatus](#external-secrets.io/v1alpha1.PushSecretStatus)) PushSecretStatusCondition indicates the status of the PushSecret. | Field | Description | | --- | --- | | `type` *[PushSecretConditionType](#external-secrets.io/v1alpha1.PushSecretConditionType)* | | | `status` *[Kubernetes core/v1.ConditionStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#conditionstatus-v1-core)* | | | `reason` *string* | *(Optional)* | | `message` *string* | *(Optional)* | | `lastTransitionTime` *[Kubernetes meta/v1.Time](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#time-v1-meta)* | *(Optional)* | ### PushSecretStoreRef (*Appears on:* [PushSecretSpec](#external-secrets.io/v1alpha1.PushSecretSpec)) PushSecretStoreRef contains a reference on how to sync to a SecretStore. | Field | Description | | --- | --- | | `name` *string* | *(Optional)* Optionally, sync to the SecretStore of the given name | | `labelSelector` *[Kubernetes meta/v1.LabelSelector](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#labelselector-v1-meta)* | *(Optional)* Optionally, sync to secret stores with label selector | | `kind` *string* | *(Optional)* Kind of the SecretStore resource (SecretStore or ClusterSecretStore) | ### PushSecretUpdatePolicy (`string` alias) (*Appears on:* [PushSecretSpec](#external-secrets.io/v1alpha1.PushSecretSpec)) PushSecretUpdatePolicy defines how push secrets are updated in the provider. | Value | Description | | --- | --- | | "IfNotExists" | PushSecretUpdatePolicyIfNotExists only creates secrets that don’t exist in the provider. | | "Replace" | PushSecretUpdatePolicyReplace replaces existing secrets in the provider. | ### SyncedPushSecretsMap (`map[string]map[string]github.com/external-secrets/external-secrets/apis/externalsecrets/v1alpha1.PushSecretData` alias) (*Appears on:* [PushSecretStatus](#external-secrets.io/v1alpha1.PushSecretStatus)) SyncedPushSecretsMap is a map that tracks which PushSecretData was stored to which secret store. The outer map’s key is the secret store name, and the inner map’s key is the remote key name. --- ## external-secrets.io/v1beta1 Package v1beta1 contains resources for external-secrets Resource Types: ### AWSAuth (*Appears on:* [AWSProvider](#external-secrets.io/v1beta1.AWSProvider)) AWSAuth tells the controller how to do authentication with aws. Only one of secretRef or jwt can be specified. if none is specified the controller will load credentials using the aws sdk defaults. | Field | Description | | --- | --- | | `secretRef` *[AWSAuthSecretRef](#external-secrets.io/v1beta1.AWSAuthSecretRef)* | *(Optional)* | | `jwt` *[AWSJWTAuth](#external-secrets.io/v1beta1.AWSJWTAuth)* | *(Optional)* | ### AWSAuthSecretRef (*Appears on:* [AWSAuth](#external-secrets.io/v1beta1.AWSAuth)) AWSAuthSecretRef holds secret references for AWS credentials both AccessKeyID and SecretAccessKey must be defined in order to properly authenticate. | Field | Description | | --- | --- | | `accessKeyIDSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The AccessKeyID is used for authentication | | `secretAccessKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The SecretAccessKey is used for authentication | | `sessionTokenSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The SessionToken used for authentication This must be defined if AccessKeyID and SecretAccessKey are temporary credentials see: <https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html> | ### AWSJWTAuth (*Appears on:* [AWSAuth](#external-secrets.io/v1beta1.AWSAuth)) AWSJWTAuth authenticates against AWS using service account tokens from the Kubernetes cluster. | Field | Description | | --- | --- | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | | ### AWSProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) AWSProvider configures a store to sync secrets with AWS. | Field | Description | | --- | --- | | `service` *[AWSServiceType](#external-secrets.io/v1beta1.AWSServiceType)* | Service defines which service should be used to fetch the secrets | | `auth` *[AWSAuth](#external-secrets.io/v1beta1.AWSAuth)* | *(Optional)* Auth defines the information necessary to authenticate against AWS if not set aws sdk will infer credentials from your environment see: <https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#specifying-credentials> | | `role` *string* | *(Optional)* Role is a Role ARN which the provider will assume | | `region` *string* | AWS Region to be used for the provider | | `additionalRoles` *[]string* | *(Optional)* AdditionalRoles is a chained list of Role ARNs which the provider will sequentially assume before assuming the Role | | `externalID` *string* | AWS External ID set on assumed IAM roles | | `sessionTags` *[[]\*github.com/external-secrets/external-secrets/apis/externalsecrets/v1beta1.Tag](#external-secrets.io/v1beta1.*github.com/external-secrets/external-secrets/apis/externalsecrets/v1beta1.Tag)* | *(Optional)* AWS STS assume role session tags | | `secretsManager` *[SecretsManager](#external-secrets.io/v1beta1.SecretsManager)* | *(Optional)* SecretsManager defines how the provider behaves when interacting with AWS SecretsManager | | `transitiveTagKeys` *[]\*string* | *(Optional)* AWS STS assume role transitive session tags. Required when multiple rules are used with the provider | | `prefix` *string* | *(Optional)* Prefix adds | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.03501099720597267,
-0.03949348255991936,
0.014237136580049992,
0.009456481784582138,
0.01993998885154724,
-0.006421377416700125,
-0.007034830283373594,
0.021452615037560463,
0.041399721056222916,
0.02741902694106102,
0.02330174297094345,
-0.10582058131694794,
-0.013201279565691948,
-0.0... | 0.19221 |
role session tags | | `secretsManager` *[SecretsManager](#external-secrets.io/v1beta1.SecretsManager)* | *(Optional)* SecretsManager defines how the provider behaves when interacting with AWS SecretsManager | | `transitiveTagKeys` *[]\*string* | *(Optional)* AWS STS assume role transitive session tags. Required when multiple rules are used with the provider | | `prefix` *string* | *(Optional)* Prefix adds a prefix to all retrieved values. | ### AWSServiceType (`string` alias) (*Appears on:* [AWSProvider](#external-secrets.io/v1beta1.AWSProvider)) AWSServiceType is an enum that defines the service/API that is used to fetch the secrets. | Value | Description | | --- | --- | | "ParameterStore" | AWSServiceParameterStore is the AWS SystemsManager ParameterStore service. see: <https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html> | | "SecretsManager" | AWSServiceSecretsManager is the AWS SecretsManager service. see: <https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html> | ### AkeylessAuth (*Appears on:* [AkeylessProvider](#external-secrets.io/v1beta1.AkeylessProvider)) AkeylessAuth defines methods of authentication with Akeyless Vault. | Field | Description | | --- | --- | | `secretRef` *[AkeylessAuthSecretRef](#external-secrets.io/v1beta1.AkeylessAuthSecretRef)* | *(Optional)* Reference to a Secret that contains the details to authenticate with Akeyless. | | `kubernetesAuth` *[AkeylessKubernetesAuth](#external-secrets.io/v1beta1.AkeylessKubernetesAuth)* | *(Optional)* Kubernetes authenticates with Akeyless by passing the ServiceAccount token stored in the named Secret resource. | ### AkeylessAuthSecretRef (*Appears on:* [AkeylessAuth](#external-secrets.io/v1beta1.AkeylessAuth)) AkeylessAuthSecretRef defines how to authenticate using a secret reference. AKEYLESS\_ACCESS\_TYPE\_PARAM: AZURE\_OBJ\_ID OR GCP\_AUDIENCE OR ACCESS\_KEY OR KUB\_CONFIG\_NAME. | Field | Description | | --- | --- | | `accessID` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The SecretAccessID is used for authentication | | `accessType` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `accessTypeParam` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### AkeylessKubernetesAuth (*Appears on:* [AkeylessAuth](#external-secrets.io/v1beta1.AkeylessAuth)) AkeylessKubernetesAuth authenticates with Akeyless using a Kubernetes ServiceAccount token. | Field | Description | | --- | --- | | `accessID` *string* | the Akeyless Kubernetes auth-method access-id | | `k8sConfName` *string* | Kubernetes-auth configuration name in Akeyless-Gateway | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* Optional service account field containing the name of a kubernetes ServiceAccount. If the service account is specified, the service account secret token JWT will be used for authenticating with Akeyless. If the service account selector is not supplied, the secretRef will be used instead. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* Optional secret field containing a Kubernetes ServiceAccount JWT used for authenticating with Akeyless. If a name is specified without a key, `token` is the default. If one is not specified, the one bound to the controller will be used. | ### AkeylessProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) AkeylessProvider Configures an store to sync secrets using Akeyless KV. | Field | Description | | --- | --- | | `akeylessGWApiURL` *string* | Akeyless GW API Url from which the secrets to be fetched from. | | `authSecretRef` *[AkeylessAuth](#external-secrets.io/v1beta1.AkeylessAuth)* | Auth configures how the operator authenticates with Akeyless. | | `caBundle` *[]byte* | *(Optional)* PEM/base64 encoded CA bundle used to validate Akeyless Gateway certificate. Only used if the AkeylessGWApiURL URL is using HTTPS protocol. If not set the system root certificates are used to validate the TLS connection. | | `caProvider` *[CAProvider](#external-secrets.io/v1beta1.CAProvider)* | *(Optional)* The provider for the CA bundle to use to validate Akeyless Gateway certificate. | ### AlibabaAuth (*Appears on:* [AlibabaProvider](#external-secrets.io/v1beta1.AlibabaProvider)) AlibabaAuth contains a secretRef for credentials. | Field | Description | | --- | --- | | `secretRef` *[AlibabaAuthSecretRef](#external-secrets.io/v1beta1.AlibabaAuthSecretRef)* | *(Optional)* | | `rrsa` *[AlibabaRRSAAuth](#external-secrets.io/v1beta1.AlibabaRRSAAuth)* | *(Optional)* | ### AlibabaAuthSecretRef (*Appears on:* [AlibabaAuth](#external-secrets.io/v1beta1.AlibabaAuth)) AlibabaAuthSecretRef holds secret references for Alibaba credentials. | Field | Description | | --- | --- | | `accessKeyIDSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The AccessKeyID is used for authentication | | `accessKeySecretSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The AccessKeySecret is used for authentication | ### AlibabaProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) AlibabaProvider configures a store to sync secrets using the Alibaba Secret Manager provider. | Field | Description | | --- | --- | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.08040222525596619,
0.008770388551056385,
-0.06312895566225052,
0.0021188147366046906,
0.026982568204402924,
-0.010495947673916817,
0.08847242593765259,
-0.009287206456065178,
0.021718287840485573,
-0.007823748514056206,
0.028791168704628944,
-0.05727391690015793,
0.09734105318784714,
-0... | 0.093246 |
Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The AccessKeyID is used for authentication | | `accessKeySecretSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The AccessKeySecret is used for authentication | ### AlibabaProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) AlibabaProvider configures a store to sync secrets using the Alibaba Secret Manager provider. | Field | Description | | --- | --- | | `auth` *[AlibabaAuth](#external-secrets.io/v1beta1.AlibabaAuth)* | | | `regionID` *string* | Alibaba Region to be used for the provider | ### AlibabaRRSAAuth (*Appears on:* [AlibabaAuth](#external-secrets.io/v1beta1.AlibabaAuth)) AlibabaRRSAAuth authenticates against Alibaba using RRSA (Resource-oriented RAM-based Service Authentication). | Field | Description | | --- | --- | | `oidcProviderArn` *string* | | | `oidcTokenFilePath` *string* | | | `roleArn` *string* | | | `sessionName` *string* | | ### AuthorizationProtocol (*Appears on:* [WebhookProvider](#external-secrets.io/v1beta1.WebhookProvider)) AuthorizationProtocol contains the protocol-specific configuration | Field | Description | | --- | --- | | `ntlm` *[NTLMProtocol](#external-secrets.io/v1beta1.NTLMProtocol)* | *(Optional)* NTLMProtocol configures the store to use NTLM for auth | ### AzureAuthType (`string` alias) (*Appears on:* [AzureKVProvider](#external-secrets.io/v1beta1.AzureKVProvider)) AzureAuthType describes how to authenticate to the Azure Keyvault. Only one of the following auth types may be specified. If none of the following auth type is specified, the default one is ServicePrincipal. | Value | Description | | --- | --- | | "ManagedIdentity" | AzureManagedIdentity uses Managed Identity to authenticate. Used with aad-pod-identity installed in the cluster. | | "ServicePrincipal" | AzureServicePrincipal uses service principal to authenticate, which needs a tenantId, a clientId and a clientSecret. | | "WorkloadIdentity" | AzureWorkloadIdentity uses Workload Identity service accounts to authenticate. | ### AzureEnvironmentType (`string` alias) (*Appears on:* [AzureKVProvider](#external-secrets.io/v1beta1.AzureKVProvider)) AzureEnvironmentType specifies the Azure cloud environment endpoints to use for connecting and authenticating with Azure. By default it points to the public cloud AAD endpoint. The following endpoints are available, also see here: <https://github.com/Azure/go-autorest/blob/main/autorest/azure/environments.go#L152> PublicCloud, USGovernmentCloud, ChinaCloud, GermanCloud | Value | Description | | --- | --- | | "ChinaCloud" | AzureEnvironmentChinaCloud represents the Azure China cloud environment. | | "GermanCloud" | AzureEnvironmentGermanCloud represents the Azure German cloud environment. | | "PublicCloud" | AzureEnvironmentPublicCloud represents the Azure public cloud environment. | | "USGovernmentCloud" | AzureEnvironmentUSGovernmentCloud represents the Azure US government cloud environment. | ### AzureKVAuth (*Appears on:* [AzureKVProvider](#external-secrets.io/v1beta1.AzureKVProvider)) AzureKVAuth defines configuration for authentication with Azure Key Vault. | Field | Description | | --- | --- | | `clientId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The Azure clientId of the service principle or managed identity used for authentication. | | `tenantId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The Azure tenantId of the managed identity used for authentication. | | `clientSecret` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The Azure ClientSecret of the service principle used for authentication. | | `clientCertificate` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The Azure ClientCertificate of the service principle used for authentication. | ### AzureKVProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) AzureKVProvider configures a store to sync secrets using Azure Key Vault. | Field | Description | | --- | --- | | `authType` *[AzureAuthType](#external-secrets.io/v1beta1.AzureAuthType)* | *(Optional)* Auth type defines how to authenticate to the keyvault service. Valid values are: - “ServicePrincipal” (default): Using a service principal (tenantId, clientId, clientSecret) - “ManagedIdentity”: Using Managed Identity assigned to the pod (see aad-pod-identity) | | `vaultUrl` *string* | Vault Url from which the secrets to be fetched from. | | `tenantId` *string* | *(Optional)* TenantID configures the Azure Tenant to send requests to. Required for ServicePrincipal auth type. Optional for WorkloadIdentity. | | `environmentType` *[AzureEnvironmentType](#external-secrets.io/v1beta1.AzureEnvironmentType)* | EnvironmentType specifies the Azure cloud environment endpoints to use for connecting and authenticating with Azure. By default it points to the public cloud AAD endpoint. The following endpoints are available, also see here: <https://github.com/Azure/go-autorest/blob/main/autorest/azure/environments.go#L152> PublicCloud, USGovernmentCloud, ChinaCloud, GermanCloud | | `authSecretRef` *[AzureKVAuth](#external-secrets.io/v1beta1.AzureKVAuth)* | *(Optional)* Auth configures | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.11498851329088211,
0.0018159719184041023,
-0.12065906077623367,
0.017147691920399666,
-0.012217937968671322,
0.028785405680537224,
0.03179822862148285,
0.023339329287409782,
0.0528256818652153,
-0.02767024375498295,
0.07072237133979797,
-0.0007889684056863189,
0.012719100341200829,
-0.0... | 0.038465 |
| `environmentType` *[AzureEnvironmentType](#external-secrets.io/v1beta1.AzureEnvironmentType)* | EnvironmentType specifies the Azure cloud environment endpoints to use for connecting and authenticating with Azure. By default it points to the public cloud AAD endpoint. The following endpoints are available, also see here: <https://github.com/Azure/go-autorest/blob/main/autorest/azure/environments.go#L152> PublicCloud, USGovernmentCloud, ChinaCloud, GermanCloud | | `authSecretRef` *[AzureKVAuth](#external-secrets.io/v1beta1.AzureKVAuth)* | *(Optional)* Auth configures how the operator authenticates with Azure. Required for ServicePrincipal auth type. Optional for WorkloadIdentity. | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* ServiceAccountRef specified the service account that should be used when authenticating with WorkloadIdentity. | | `identityId` *string* | *(Optional)* If multiple Managed Identity is assigned to the pod, you can select the one to be used | ### BeyondTrustProviderSecretRef (*Appears on:* [BeyondtrustAuth](#external-secrets.io/v1beta1.BeyondtrustAuth)) BeyondTrustProviderSecretRef defines a reference to a secret containing credentials for the BeyondTrust provider. | Field | Description | | --- | --- | | `value` *string* | *(Optional)* Value can be specified directly to set a value without using a secret. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef references a key in a secret that will be used as value. | ### BeyondtrustAuth (*Appears on:* [BeyondtrustProvider](#external-secrets.io/v1beta1.BeyondtrustProvider)) BeyondtrustAuth configures authentication for BeyondTrust Password Safe. | Field | Description | | --- | --- | | `apiKey` *[BeyondTrustProviderSecretRef](#external-secrets.io/v1beta1.BeyondTrustProviderSecretRef)* | APIKey If not provided then ClientID/ClientSecret become required. | | `clientId` *[BeyondTrustProviderSecretRef](#external-secrets.io/v1beta1.BeyondTrustProviderSecretRef)* | ClientID is the API OAuth Client ID. | | `clientSecret` *[BeyondTrustProviderSecretRef](#external-secrets.io/v1beta1.BeyondTrustProviderSecretRef)* | ClientSecret is the API OAuth Client Secret. | | `certificate` *[BeyondTrustProviderSecretRef](#external-secrets.io/v1beta1.BeyondTrustProviderSecretRef)* | Certificate (cert.pem) for use when authenticating with an OAuth client Id using a Client Certificate. | | `certificateKey` *[BeyondTrustProviderSecretRef](#external-secrets.io/v1beta1.BeyondTrustProviderSecretRef)* | Certificate private key (key.pem). For use when authenticating with an OAuth client Id | ### BeyondtrustProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) BeyondtrustProvider defines configuration for the BeyondTrust Password Safe provider. | Field | Description | | --- | --- | | `auth` *[BeyondtrustAuth](#external-secrets.io/v1beta1.BeyondtrustAuth)* | Auth configures how the operator authenticates with Beyondtrust. | | `server` *[BeyondtrustServer](#external-secrets.io/v1beta1.BeyondtrustServer)* | Auth configures how API server works. | ### BeyondtrustServer (*Appears on:* [BeyondtrustProvider](#external-secrets.io/v1beta1.BeyondtrustProvider)) BeyondtrustServer defines configuration for connecting to BeyondTrust Password Safe server. | Field | Description | | --- | --- | | `apiUrl` *string* | | | `apiVersion` *string* | | | `retrievalType` *string* | The secret retrieval type. SECRET = Secrets Safe (credential, text, file). MANAGED\_ACCOUNT = Password Safe account associated with a system. | | `separator` *string* | A character that separates the folder names. | | `decrypt` *bool* | *(Optional)* When true, the response includes the decrypted password. When false, the password field is omitted. This option only applies to the SECRET retrieval type. Default: true. | | `verifyCA` *bool* | | | `clientTimeOutSeconds` *int* | Timeout specifies a time limit for requests made by this Client. The timeout includes connection time, any redirects, and reading the response body. Defaults to 45 seconds. | ### BitwardenSecretsManagerAuth (*Appears on:* [BitwardenSecretsManagerProvider](#external-secrets.io/v1beta1.BitwardenSecretsManagerProvider)) BitwardenSecretsManagerAuth contains the ref to the secret that contains the machine account token. | Field | Description | | --- | --- | | `secretRef` *[BitwardenSecretsManagerSecretRef](#external-secrets.io/v1beta1.BitwardenSecretsManagerSecretRef)* | | ### BitwardenSecretsManagerProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) BitwardenSecretsManagerProvider configures a store to sync secrets with a Bitwarden Secrets Manager instance. | Field | Description | | --- | --- | | `apiURL` *string* | | | `identityURL` *string* | | | `bitwardenServerSDKURL` *string* | | | `caBundle` *string* | *(Optional)* Base64 encoded certificate for the bitwarden server sdk. The sdk MUST run with HTTPS to make sure no MITM attack can be performed. | | `caProvider` *[CAProvider](#external-secrets.io/v1beta1.CAProvider)* | *(Optional)* see: <https://external-secrets.io/latest/spec/#external-secrets.io/v1alpha1.CAProvider> | | `organizationID` *string* | OrganizationID determines which organization this secret store manages. | | `projectID` *string* | ProjectID determines which project this secret store | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.042431239038705826,
0.014804212376475334,
-0.035560332238674164,
-0.0330539271235466,
-0.005315903574228287,
0.047236304730176926,
0.033830124884843826,
-0.07593415677547455,
0.07972905039787292,
0.08099061995744705,
0.045569587498903275,
-0.06726628541946411,
0.008510718122124672,
0.06... | 0.010533 |
server sdk. The sdk MUST run with HTTPS to make sure no MITM attack can be performed. | | `caProvider` *[CAProvider](#external-secrets.io/v1beta1.CAProvider)* | *(Optional)* see: <https://external-secrets.io/latest/spec/#external-secrets.io/v1alpha1.CAProvider> | | `organizationID` *string* | OrganizationID determines which organization this secret store manages. | | `projectID` *string* | ProjectID determines which project this secret store manages. | | `auth` *[BitwardenSecretsManagerAuth](#external-secrets.io/v1beta1.BitwardenSecretsManagerAuth)* | Auth configures how secret-manager authenticates with a bitwarden machine account instance. Make sure that the token being used has permissions on the given secret. | ### BitwardenSecretsManagerSecretRef (*Appears on:* [BitwardenSecretsManagerAuth](#external-secrets.io/v1beta1.BitwardenSecretsManagerAuth)) BitwardenSecretsManagerSecretRef contains the credential ref to the bitwarden instance. | Field | Description | | --- | --- | | `credentials` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | AccessToken used for the bitwarden instance. | ### CAProvider (*Appears on:* [AkeylessProvider](#external-secrets.io/v1beta1.AkeylessProvider), [BitwardenSecretsManagerProvider](#external-secrets.io/v1beta1.BitwardenSecretsManagerProvider), [ConjurProvider](#external-secrets.io/v1beta1.ConjurProvider), [GitlabProvider](#external-secrets.io/v1beta1.GitlabProvider), [KubernetesServer](#external-secrets.io/v1beta1.KubernetesServer), [VaultProvider](#external-secrets.io/v1beta1.VaultProvider)) CAProvider provides custom certificate authority (CA) certificates for a secret store. The CAProvider points to a Secret or ConfigMap resource that contains a PEM-encoded certificate. | Field | Description | | --- | --- | | `type` *[CAProviderType](#external-secrets.io/v1beta1.CAProviderType)* | The type of provider to use such as “Secret”, or “ConfigMap”. | | `name` *string* | The name of the object located at the provider type. | | `key` *string* | The key where the CA certificate can be found in the Secret or ConfigMap. | | `namespace` *string* | *(Optional)* The namespace the Provider type is in. Can only be defined when used in a ClusterSecretStore. | ### CAProviderType (`string` alias) (*Appears on:* [CAProvider](#external-secrets.io/v1beta1.CAProvider)) CAProviderType defines the type of provider to use for CA certificates. | Value | Description | | --- | --- | | "ConfigMap" | CAProviderTypeConfigMap indicates that the CA certificate is stored in a ConfigMap. | | "Secret" | CAProviderTypeSecret indicates that the CA certificate is stored in a Secret. | ### CSMAuth (*Appears on:* [CloudruSMProvider](#external-secrets.io/v1beta1.CloudruSMProvider)) CSMAuth contains a secretRef for credentials. | Field | Description | | --- | --- | | `secretRef` *[CSMAuthSecretRef](#external-secrets.io/v1beta1.CSMAuthSecretRef)* | *(Optional)* | ### CSMAuthSecretRef (*Appears on:* [CSMAuth](#external-secrets.io/v1beta1.CSMAuth)) CSMAuthSecretRef holds secret references for Cloud.ru credentials. | Field | Description | | --- | --- | | `accessKeyIDSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The AccessKeyID is used for authentication | | `accessKeySecretSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The AccessKeySecret is used for authentication | ### CertAuth (*Appears on:* [KubernetesAuth](#external-secrets.io/v1beta1.KubernetesAuth)) CertAuth defines certificate-based authentication for the Kubernetes provider. | Field | Description | | --- | --- | | `clientCert` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `clientKey` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### ChefAuth (*Appears on:* [ChefProvider](#external-secrets.io/v1beta1.ChefProvider)) ChefAuth contains a secretRef for credentials. | Field | Description | | --- | --- | | `secretRef` *[ChefAuthSecretRef](#external-secrets.io/v1beta1.ChefAuthSecretRef)* | | ### ChefAuthSecretRef (*Appears on:* [ChefAuth](#external-secrets.io/v1beta1.ChefAuth)) ChefAuthSecretRef holds secret references for chef server login credentials. | Field | Description | | --- | --- | | `privateKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | SecretKey is the Signing Key in PEM format, used for authentication. | ### ChefProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) ChefProvider configures a store to sync secrets using basic chef server connection credentials. | Field | Description | | --- | --- | | `auth` *[ChefAuth](#external-secrets.io/v1beta1.ChefAuth)* | Auth defines the information necessary to authenticate against chef Server | | `username` *string* | UserName should be the user ID on the chef server | | `serverUrl` *string* | ServerURL is the chef server URL used to connect to. If using orgs you should include your org in the url and terminate the url with a “/” | ### CloudruSMProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) CloudruSMProvider configures a store to sync secrets using the Cloud.ru Secret Manager provider. | Field | Description | | --- | --- | | `auth` *[CSMAuth](#external-secrets.io/v1beta1.CSMAuth)* | | | `projectID` *string* | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.06605608016252518,
-0.023459892719984055,
-0.015106253325939178,
-0.008182530291378498,
0.049287039786577225,
-0.013728165067732334,
0.004645094741135836,
0.0019605690613389015,
0.03149978071451187,
0.016242215409874916,
0.038800571113824844,
-0.0715552568435669,
0.04369095340371132,
0.... | 0.06323 |
include your org in the url and terminate the url with a “/” | ### CloudruSMProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) CloudruSMProvider configures a store to sync secrets using the Cloud.ru Secret Manager provider. | Field | Description | | --- | --- | | `auth` *[CSMAuth](#external-secrets.io/v1beta1.CSMAuth)* | | | `projectID` *string* | ProjectID is the project, which the secrets are stored in. | ### ClusterExternalSecret ClusterExternalSecret is the schema for the clusterexternalsecrets API. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[ClusterExternalSecretSpec](#external-secrets.io/v1beta1.ClusterExternalSecretSpec)* | | `externalSecretSpec` *[ExternalSecretSpec](#external-secrets.io/v1beta1.ExternalSecretSpec)* | The spec for the ExternalSecrets to be created | | --- | --- | | `externalSecretName` *string* | *(Optional)* The name of the external secrets to be created. Defaults to the name of the ClusterExternalSecret | | `externalSecretMetadata` *[ExternalSecretMetadata](#external-secrets.io/v1beta1.ExternalSecretMetadata)* | *(Optional)* The metadata of the external secrets to be created | | `namespaceSelector` *[Kubernetes meta/v1.LabelSelector](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#labelselector-v1-meta)* | The labels to select by to find the Namespaces to create the ExternalSecrets in | | `namespaceSelectors` *[[]\*k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#*k8s.io/apimachinery/pkg/apis/meta/v1.labelselector--)* | *(Optional)* A list of labels to select by to find the Namespaces to create the ExternalSecrets in. The selectors are ORed. | | `namespaces` *[]string* | *(Optional)* Choose namespaces by name. This field is ORed with anything that NamespaceSelectors ends up choosing. Deprecated: Use NamespaceSelectors instead. | | `refreshTime` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | The time in which the controller should reconcile its objects and recheck namespaces for labels. | | | `status` *[ClusterExternalSecretStatus](#external-secrets.io/v1beta1.ClusterExternalSecretStatus)* | | ### ClusterExternalSecretConditionType (`string` alias) (*Appears on:* [ClusterExternalSecretStatusCondition](#external-secrets.io/v1beta1.ClusterExternalSecretStatusCondition)) ClusterExternalSecretConditionType indicates the condition of the ClusterExternalSecret. | Value | Description | | --- | --- | | "Ready" | ClusterExternalSecretReady indicates the ClusterExternalSecret resource is ready. | ### ClusterExternalSecretNamespaceFailure (*Appears on:* [ClusterExternalSecretStatus](#external-secrets.io/v1beta1.ClusterExternalSecretStatus)) ClusterExternalSecretNamespaceFailure represents a failed namespace deployment and it’s reason. | Field | Description | | --- | --- | | `namespace` *string* | Namespace is the namespace that failed when trying to apply an ExternalSecret | | `reason` *string* | *(Optional)* Reason is why the ExternalSecret failed to apply to the namespace | ### ClusterExternalSecretSpec (*Appears on:* [ClusterExternalSecret](#external-secrets.io/v1beta1.ClusterExternalSecret)) ClusterExternalSecretSpec defines the desired state of ClusterExternalSecret. | Field | Description | | --- | --- | | `externalSecretSpec` *[ExternalSecretSpec](#external-secrets.io/v1beta1.ExternalSecretSpec)* | The spec for the ExternalSecrets to be created | | `externalSecretName` *string* | *(Optional)* The name of the external secrets to be created. Defaults to the name of the ClusterExternalSecret | | `externalSecretMetadata` *[ExternalSecretMetadata](#external-secrets.io/v1beta1.ExternalSecretMetadata)* | *(Optional)* The metadata of the external secrets to be created | | `namespaceSelector` *[Kubernetes meta/v1.LabelSelector](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#labelselector-v1-meta)* | The labels to select by to find the Namespaces to create the ExternalSecrets in | | `namespaceSelectors` *[[]\*k8s.io/apimachinery/pkg/apis/meta/v1.LabelSelector](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#*k8s.io/apimachinery/pkg/apis/meta/v1.labelselector--)* | *(Optional)* A list of labels to select by to find the Namespaces to create the ExternalSecrets in. The selectors are ORed. | | `namespaces` *[]string* | *(Optional)* Choose namespaces by name. This field is ORed with anything that NamespaceSelectors ends up choosing. Deprecated: Use NamespaceSelectors instead. | | `refreshTime` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | The time in which the controller should reconcile its objects and recheck namespaces for labels. | ### ClusterExternalSecretStatus (*Appears on:* [ClusterExternalSecret](#external-secrets.io/v1beta1.ClusterExternalSecret)) ClusterExternalSecretStatus defines the observed state of ClusterExternalSecret. | Field | Description | | --- | --- | | `externalSecretName` *string* | ExternalSecretName is the name of the ExternalSecrets created by the ClusterExternalSecret | | `failedNamespaces` *[[]ClusterExternalSecretNamespaceFailure](#external-secrets.io/v1beta1.ClusterExternalSecretNamespaceFailure)* | *(Optional)* Failed namespaces are the namespaces that failed to apply an ExternalSecret | | `provisionedNamespaces` *[]string* | *(Optional)* ProvisionedNamespaces are the namespaces where the ClusterExternalSecret has secrets | | `conditions` *[[]ClusterExternalSecretStatusCondition](#external-secrets.io/v1beta1.ClusterExternalSecretStatusCondition)* | *(Optional)* | ### ClusterExternalSecretStatusCondition (*Appears on:* [ClusterExternalSecretStatus](#external-secrets.io/v1beta1.ClusterExternalSecretStatus)) ClusterExternalSecretStatusCondition indicates the status | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.05333824083209038,
0.0006223897216841578,
-0.03855146840214729,
0.05571991950273514,
0.005935594439506531,
0.041259851306676865,
-0.045730117708444595,
-0.05483267083764076,
0.05532904341816902,
0.049347784370183945,
-0.01676025427877903,
-0.06204240769147873,
0.06529794633388519,
-0.04... | 0.041933 |
the ClusterExternalSecret | | `failedNamespaces` *[[]ClusterExternalSecretNamespaceFailure](#external-secrets.io/v1beta1.ClusterExternalSecretNamespaceFailure)* | *(Optional)* Failed namespaces are the namespaces that failed to apply an ExternalSecret | | `provisionedNamespaces` *[]string* | *(Optional)* ProvisionedNamespaces are the namespaces where the ClusterExternalSecret has secrets | | `conditions` *[[]ClusterExternalSecretStatusCondition](#external-secrets.io/v1beta1.ClusterExternalSecretStatusCondition)* | *(Optional)* | ### ClusterExternalSecretStatusCondition (*Appears on:* [ClusterExternalSecretStatus](#external-secrets.io/v1beta1.ClusterExternalSecretStatus)) ClusterExternalSecretStatusCondition indicates the status of the ClusterExternalSecret. | Field | Description | | --- | --- | | `type` *[ClusterExternalSecretConditionType](#external-secrets.io/v1beta1.ClusterExternalSecretConditionType)* | | | `status` *[Kubernetes core/v1.ConditionStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#conditionstatus-v1-core)* | | | `message` *string* | *(Optional)* | ### ClusterSecretStore ClusterSecretStore represents a secure external location for storing secrets, which can be referenced as part of `storeRef` fields. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[SecretStoreSpec](#external-secrets.io/v1beta1.SecretStoreSpec)* | | `controller` *string* | *(Optional)* Used to select the correct ESO controller (think: ingress.ingressClassName) The ESO controller is instantiated with a specific controller name and filters ES based on this property | | --- | --- | | `provider` *[SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)* | Used to configure the provider. Only one provider may be set | | `retrySettings` *[SecretStoreRetrySettings](#external-secrets.io/v1beta1.SecretStoreRetrySettings)* | *(Optional)* Used to configure HTTP retries on failures. | | `refreshInterval` *int* | *(Optional)* Used to configure store refresh interval in seconds. Empty or 0 will default to the controller config. | | `conditions` *[[]ClusterSecretStoreCondition](#external-secrets.io/v1beta1.ClusterSecretStoreCondition)* | *(Optional)* Used to constrain a ClusterSecretStore to specific namespaces. Relevant only to ClusterSecretStore. | | | `status` *[SecretStoreStatus](#external-secrets.io/v1beta1.SecretStoreStatus)* | | ### ClusterSecretStoreCondition (*Appears on:* [SecretStoreSpec](#external-secrets.io/v1beta1.SecretStoreSpec)) ClusterSecretStoreCondition describes a condition by which to choose namespaces to process ExternalSecrets in for a ClusterSecretStore instance. | Field | Description | | --- | --- | | `namespaceSelector` *[Kubernetes meta/v1.LabelSelector](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#labelselector-v1-meta)* | *(Optional)* Choose namespace using a labelSelector | | `namespaces` *[]string* | *(Optional)* Choose namespaces by name | | `namespaceRegexes` *[]string* | *(Optional)* Choose namespaces by using regex matching | ### ConjurAPIKey (*Appears on:* [ConjurAuth](#external-secrets.io/v1beta1.ConjurAuth)) ConjurAPIKey defines authentication using a Conjur API key. | Field | Description | | --- | --- | | `account` *string* | Account is the Conjur organization account name. | | `userRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | A reference to a specific ‘key’ containing the Conjur username within a Secret resource. In some instances, `key` is a required field. | | `apiKeyRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | A reference to a specific ‘key’ containing the Conjur API key within a Secret resource. In some instances, `key` is a required field. | ### ConjurAuth (*Appears on:* [ConjurProvider](#external-secrets.io/v1beta1.ConjurProvider)) ConjurAuth defines the methods of authentication with Conjur. | Field | Description | | --- | --- | | `apikey` *[ConjurAPIKey](#external-secrets.io/v1beta1.ConjurAPIKey)* | *(Optional)* Authenticates with Conjur using an API key. | | `jwt` *[ConjurJWT](#external-secrets.io/v1beta1.ConjurJWT)* | *(Optional)* Jwt enables JWT authentication using Kubernetes service account tokens. | ### ConjurJWT (*Appears on:* [ConjurAuth](#external-secrets.io/v1beta1.ConjurAuth)) ConjurJWT defines authentication using a JWT service account token. | Field | Description | | --- | --- | | `account` *string* | Account is the Conjur organization account name. | | `serviceID` *string* | The conjur authn jwt webservice id | | `hostId` *string* | *(Optional)* Optional HostID for JWT authentication. This may be used depending on how the Conjur JWT authenticator policy is configured. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* Optional SecretRef that refers to a key in a Secret resource containing JWT token to authenticate with Conjur using the JWT authentication method. | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* Optional ServiceAccountRef specifies the Kubernetes service account for which to request a token for with the `TokenRequest` API. | ### ConjurProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) ConjurProvider defines configuration for the CyberArk Conjur provider. | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.08815054595470428,
-0.05650358274579048,
-0.013754424639046192,
0.04062418267130852,
0.06974288076162338,
-0.013651635497808456,
0.04319804906845093,
-0.0338803268969059,
-0.013013084419071674,
-0.010210487060248852,
0.06640558689832687,
-0.10884552448987961,
0.04986327141523361,
-0.016... | 0.192143 |
to authenticate with Conjur using the JWT authentication method. | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* Optional ServiceAccountRef specifies the Kubernetes service account for which to request a token for with the `TokenRequest` API. | ### ConjurProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) ConjurProvider defines configuration for the CyberArk Conjur provider. | Field | Description | | --- | --- | | `url` *string* | URL is the endpoint of the Conjur instance. | | `caBundle` *string* | *(Optional)* CABundle is a PEM encoded CA bundle that will be used to validate the Conjur server certificate. | | `caProvider` *[CAProvider](#external-secrets.io/v1beta1.CAProvider)* | *(Optional)* Used to provide custom certificate authority (CA) certificates for a secret store. The CAProvider points to a Secret or ConfigMap resource that contains a PEM-encoded certificate. | | `auth` *[ConjurAuth](#external-secrets.io/v1beta1.ConjurAuth)* | Defines authentication settings for connecting to Conjur. | ### DelineaProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) DelineaProvider defines configuration for the Delinea DevOps Secrets Vault provider. See <https://github.com/DelineaXPM/dsv-sdk-go/blob/main/vault/vault.go>. | Field | Description | | --- | --- | | `clientId` *[DelineaProviderSecretRef](#external-secrets.io/v1beta1.DelineaProviderSecretRef)* | ClientID is the non-secret part of the credential. | | `clientSecret` *[DelineaProviderSecretRef](#external-secrets.io/v1beta1.DelineaProviderSecretRef)* | ClientSecret is the secret part of the credential. | | `tenant` *string* | Tenant is the chosen hostname / site name. | | `urlTemplate` *string* | *(Optional)* URLTemplate If unset, defaults to “https://%s.secretsvaultcloud.%s/v1/%s%s”. | | `tld` *string* | *(Optional)* TLD is based on the server location that was chosen during provisioning. If unset, defaults to “com”. | ### DelineaProviderSecretRef (*Appears on:* [DelineaProvider](#external-secrets.io/v1beta1.DelineaProvider)) DelineaProviderSecretRef defines a reference to a secret containing credentials for the Delinea provider. | Field | Description | | --- | --- | | `value` *string* | *(Optional)* Value can be specified directly to set a value without using a secret. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef references a key in a secret that will be used as value. | ### Device42Auth (*Appears on:* [Device42Provider](#external-secrets.io/v1beta1.Device42Provider)) Device42Auth defines the authentication method for the Device42 provider. | Field | Description | | --- | --- | | `secretRef` *[Device42SecretRef](#external-secrets.io/v1beta1.Device42SecretRef)* | | ### Device42Provider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) Device42Provider configures a store to sync secrets with a Device42 instance. | Field | Description | | --- | --- | | `host` *string* | URL configures the Device42 instance URL. | | `auth` *[Device42Auth](#external-secrets.io/v1beta1.Device42Auth)* | Auth configures how secret-manager authenticates with a Device42 instance. | ### Device42SecretRef (*Appears on:* [Device42Auth](#external-secrets.io/v1beta1.Device42Auth)) Device42SecretRef defines a reference to a secret containing credentials for the Device42 provider. | Field | Description | | --- | --- | | `credentials` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* Username / Password is used for authentication. | ### DopplerAuth (*Appears on:* [DopplerProvider](#external-secrets.io/v1beta1.DopplerProvider)) DopplerAuth defines the authentication method for the Doppler provider. | Field | Description | | --- | --- | | `secretRef` *[DopplerAuthSecretRef](#external-secrets.io/v1beta1.DopplerAuthSecretRef)* | | ### DopplerAuthSecretRef (*Appears on:* [DopplerAuth](#external-secrets.io/v1beta1.DopplerAuth)) DopplerAuthSecretRef defines a reference to a secret containing credentials for the Doppler provider. | Field | Description | | --- | --- | | `dopplerToken` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The DopplerToken is used for authentication. See <https://docs.doppler.com/reference/api#authentication> for auth token types. The Key attribute defaults to dopplerToken if not specified. | ### DopplerProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) DopplerProvider configures a store to sync secrets using the Doppler provider. Project and Config are required if not using a Service Token. | Field | Description | | --- | --- | | `auth` *[DopplerAuth](#external-secrets.io/v1beta1.DopplerAuth)* | Auth configures how the Operator authenticates with the Doppler API | | `project` *string* | *(Optional)* Doppler project (required if not using a Service Token) | | `config` *string* | *(Optional)* Doppler config (required if not using a Service Token) | | `nameTransformer` | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.12189770489931107,
-0.0003342691925354302,
0.01477139350026846,
-0.06736203283071518,
-0.07668640464544296,
-0.023091327399015427,
0.05643561854958534,
0.057543009519577026,
0.07591123133897781,
0.009839454665780067,
0.0005078713875263929,
-0.06519278883934021,
0.02234850823879242,
0.00... | 0.106577 |
| --- | | `auth` *[DopplerAuth](#external-secrets.io/v1beta1.DopplerAuth)* | Auth configures how the Operator authenticates with the Doppler API | | `project` *string* | *(Optional)* Doppler project (required if not using a Service Token) | | `config` *string* | *(Optional)* Doppler config (required if not using a Service Token) | | `nameTransformer` *string* | *(Optional)* Environment variable compatible name transforms that change secret names to a different format | | `format` *string* | *(Optional)* Format enables the downloading of secrets as a file (string) | ### ExternalSecret ExternalSecret is the schema for the external-secrets API. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[ExternalSecretSpec](#external-secrets.io/v1beta1.ExternalSecretSpec)* | | `secretStoreRef` *[SecretStoreRef](#external-secrets.io/v1beta1.SecretStoreRef)* | *(Optional)* | | --- | --- | | `target` *[ExternalSecretTarget](#external-secrets.io/v1beta1.ExternalSecretTarget)* | *(Optional)* | | `refreshPolicy` *[ExternalSecretRefreshPolicy](#external-secrets.io/v1beta1.ExternalSecretRefreshPolicy)* | *(Optional)* RefreshPolicy determines how the ExternalSecret should be refreshed: - CreatedOnce: Creates the Secret only if it does not exist and does not update it thereafter - Periodic: Synchronizes the Secret from the external source at regular intervals specified by refreshInterval. No periodic updates occur if refreshInterval is 0. - OnChange: Only synchronizes the Secret when the ExternalSecret’s metadata or specification changes | | `refreshInterval` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | RefreshInterval is the amount of time before the values are read again from the SecretStore provider, specified as Golang Duration strings. Valid time units are “ns”, “us” (or “µs”), “ms”, “s”, “m”, “h” Example values: “1h0m0s”, “2h30m0s”, “10m0s” May be set to “0s” to fetch and create it once. Defaults to 1h0m0s. | | `data` *[[]ExternalSecretData](#external-secrets.io/v1beta1.ExternalSecretData)* | *(Optional)* Data defines the connection between the Kubernetes Secret keys and the Provider data | | `dataFrom` *[[]ExternalSecretDataFromRemoteRef](#external-secrets.io/v1beta1.ExternalSecretDataFromRemoteRef)* | *(Optional)* DataFrom is used to fetch all properties from a specific Provider data If multiple entries are specified, the Secret keys are merged in the specified order | | | `status` *[ExternalSecretStatus](#external-secrets.io/v1beta1.ExternalSecretStatus)* | | ### ExternalSecretConditionType (`string` alias) (*Appears on:* [ExternalSecretStatusCondition](#external-secrets.io/v1beta1.ExternalSecretStatusCondition)) ExternalSecretConditionType defines the condition type for an ExternalSecret. | Value | Description | | --- | --- | | "Deleted" | ExternalSecretDeleted indicates the ExternalSecret has been deleted. | | "Ready" | ExternalSecretReady indicates the ExternalSecret has been successfully reconciled. | ### ExternalSecretConversionStrategy (`string` alias) (*Appears on:* [ExternalSecretDataRemoteRef](#external-secrets.io/v1beta1.ExternalSecretDataRemoteRef), [ExternalSecretFind](#external-secrets.io/v1beta1.ExternalSecretFind)) ExternalSecretConversionStrategy defines how secret values are converted. | Value | Description | | --- | --- | | "Default" | ExternalSecretConversionDefault indicates the default conversion strategy. | | "Unicode" | ExternalSecretConversionUnicode indicates that unicode conversion will be performed. | ### ExternalSecretCreationPolicy (`string` alias) (*Appears on:* [ExternalSecretTarget](#external-secrets.io/v1beta1.ExternalSecretTarget)) ExternalSecretCreationPolicy defines rules on how to create the resulting Secret. | Value | Description | | --- | --- | | "Merge" | CreatePolicyMerge does not create the Secret, but merges the data fields to the Secret. | | "None" | CreatePolicyNone does not create a Secret (future use with injector). | | "Orphan" | CreatePolicyOrphan creates the Secret and does not set the ownerReference. I.e. it will be orphaned after the deletion of the ExternalSecret. | | "Owner" | CreatePolicyOwner creates the Secret and sets .metadata.ownerReferences to the ExternalSecret resource. | ### ExternalSecretData (*Appears on:* [ExternalSecretSpec](#external-secrets.io/v1beta1.ExternalSecretSpec)) ExternalSecretData defines the connection between the Kubernetes Secret key (spec.data.) and the Provider data. | Field | Description | | --- | --- | | `secretKey` *string* | The key in the Kubernetes Secret to store the value. | | `remoteRef` *[ExternalSecretDataRemoteRef](#external-secrets.io/v1beta1.ExternalSecretDataRemoteRef)* | RemoteRef points to the remote secret and defines which secret (version/property/..) to fetch. | | `sourceRef` *[StoreSourceRef](#external-secrets.io/v1beta1.StoreSourceRef)* | SourceRef allows you to override the source from which the value will be pulled. | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.103443942964077,
0.001206236076541245,
-0.04917990043759346,
-0.01562145259231329,
0.016566414386034012,
-0.07784774899482727,
0.029549209401011467,
0.071695975959301,
0.0838075578212738,
-0.011722822673618793,
-0.015835603699088097,
-0.05753632262349129,
0.042429592460393906,
-0.005922... | 0.110349 |
*string* | The key in the Kubernetes Secret to store the value. | | `remoteRef` *[ExternalSecretDataRemoteRef](#external-secrets.io/v1beta1.ExternalSecretDataRemoteRef)* | RemoteRef points to the remote secret and defines which secret (version/property/..) to fetch. | | `sourceRef` *[StoreSourceRef](#external-secrets.io/v1beta1.StoreSourceRef)* | SourceRef allows you to override the source from which the value will be pulled. | ### ExternalSecretDataFromRemoteRef (*Appears on:* [ExternalSecretSpec](#external-secrets.io/v1beta1.ExternalSecretSpec)) ExternalSecretDataFromRemoteRef defines a reference to multiple secrets in the provider to be fetched using options. | Field | Description | | --- | --- | | `extract` *[ExternalSecretDataRemoteRef](#external-secrets.io/v1beta1.ExternalSecretDataRemoteRef)* | *(Optional)* Used to extract multiple key/value pairs from one secret Note: Extract does not support sourceRef.Generator or sourceRef.GeneratorRef. | | `find` *[ExternalSecretFind](#external-secrets.io/v1beta1.ExternalSecretFind)* | *(Optional)* Used to find secrets based on tags or regular expressions Note: Find does not support sourceRef.Generator or sourceRef.GeneratorRef. | | `rewrite` *[[]ExternalSecretRewrite](#external-secrets.io/v1beta1.ExternalSecretRewrite)* | *(Optional)* Used to rewrite secret Keys after getting them from the secret Provider Multiple Rewrite operations can be provided. They are applied in a layered order (first to last) | | `sourceRef` *[StoreGeneratorSourceRef](#external-secrets.io/v1beta1.StoreGeneratorSourceRef)* | SourceRef points to a store or generator which contains secret values ready to use. Use this in combination with Extract or Find pull values out of a specific SecretStore. When sourceRef points to a generator Extract or Find is not supported. The generator returns a static map of values | ### ExternalSecretDataRemoteRef (*Appears on:* [ExternalSecretData](#external-secrets.io/v1beta1.ExternalSecretData), [ExternalSecretDataFromRemoteRef](#external-secrets.io/v1beta1.ExternalSecretDataFromRemoteRef)) ExternalSecretDataRemoteRef defines Provider data location. | Field | Description | | --- | --- | | `key` *string* | Key is the key used in the Provider, mandatory | | `metadataPolicy` *[ExternalSecretMetadataPolicy](#external-secrets.io/v1beta1.ExternalSecretMetadataPolicy)* | *(Optional)* Policy for fetching tags/labels from provider secrets, possible options are Fetch, None. Defaults to None | | `property` *string* | *(Optional)* Used to select a specific property of the Provider value (if a map), if supported | | `version` *string* | *(Optional)* Used to select a specific version of the Provider value, if supported | | `conversionStrategy` *[ExternalSecretConversionStrategy](#external-secrets.io/v1beta1.ExternalSecretConversionStrategy)* | *(Optional)* Used to define a conversion Strategy | | `decodingStrategy` *[ExternalSecretDecodingStrategy](#external-secrets.io/v1beta1.ExternalSecretDecodingStrategy)* | *(Optional)* Used to define a decoding Strategy | ### ExternalSecretDecodingStrategy (`string` alias) (*Appears on:* [ExternalSecretDataRemoteRef](#external-secrets.io/v1beta1.ExternalSecretDataRemoteRef), [ExternalSecretFind](#external-secrets.io/v1beta1.ExternalSecretFind)) ExternalSecretDecodingStrategy defines how secret values are decoded. | Value | Description | | --- | --- | | "Auto" | ExternalSecretDecodeAuto indicates that the decoding strategy will be automatically determined. | | "Base64" | ExternalSecretDecodeBase64 indicates that base64 decoding will be used. | | "Base64URL" | ExternalSecretDecodeBase64URL indicates that base64url decoding will be used. | | "None" | ExternalSecretDecodeNone indicates that no decoding will be performed. | ### ExternalSecretDeletionPolicy (`string` alias) (*Appears on:* [ExternalSecretTarget](#external-secrets.io/v1beta1.ExternalSecretTarget)) ExternalSecretDeletionPolicy defines rules on how to delete the resulting Secret. | Value | Description | | --- | --- | | "Delete" | DeletionPolicyDelete deletes the secret if all provider secrets are deleted. If a secret gets deleted on the provider side and is not accessible anymore this is not considered an error and the ExternalSecret does not go into SecretSyncedError status. | | "Merge" | DeletionPolicyMerge removes keys in the secret, but not the secret itself. If a secret gets deleted on the provider side and is not accessible anymore this is not considered an error and the ExternalSecret does not go into SecretSyncedError status. | | "Retain" | DeletionPolicyRetain will retain the secret if all provider secrets have been deleted. If a provider secret does not exist the ExternalSecret gets into the SecretSyncedError status. | ### ExternalSecretFind (*Appears on:* [ExternalSecretDataFromRemoteRef](#external-secrets.io/v1beta1.ExternalSecretDataFromRemoteRef)) ExternalSecretFind defines criteria for finding secrets in the provider. | Field | Description | | --- | --- | | `path` *string* | *(Optional)* A root path to start the find operations. | | `name` *[FindName](#external-secrets.io/v1beta1.FindName)* | *(Optional)* Finds secrets based on | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.05068862810730934,
0.026350917294621468,
0.006138768512755632,
0.005907638464123011,
0.032633695751428604,
0.030833544209599495,
0.06400985270738602,
0.02029181271791458,
0.10920991748571396,
0.03237086161971092,
-0.001293247565627098,
-0.09942788630723953,
-0.0040817297995090485,
-0.04... | 0.03264 |
SecretSyncedError status. | ### ExternalSecretFind (*Appears on:* [ExternalSecretDataFromRemoteRef](#external-secrets.io/v1beta1.ExternalSecretDataFromRemoteRef)) ExternalSecretFind defines criteria for finding secrets in the provider. | Field | Description | | --- | --- | | `path` *string* | *(Optional)* A root path to start the find operations. | | `name` *[FindName](#external-secrets.io/v1beta1.FindName)* | *(Optional)* Finds secrets based on the name. | | `tags` *map[string]string* | *(Optional)* Find secrets based on tags. | | `conversionStrategy` *[ExternalSecretConversionStrategy](#external-secrets.io/v1beta1.ExternalSecretConversionStrategy)* | *(Optional)* Used to define a conversion Strategy | | `decodingStrategy` *[ExternalSecretDecodingStrategy](#external-secrets.io/v1beta1.ExternalSecretDecodingStrategy)* | *(Optional)* Used to define a decoding Strategy | ### ExternalSecretMetadata (*Appears on:* [ClusterExternalSecretSpec](#external-secrets.io/v1beta1.ClusterExternalSecretSpec)) ExternalSecretMetadata defines metadata fields for the ExternalSecret generated by the ClusterExternalSecret. | Field | Description | | --- | --- | | `annotations` *map[string]string* | *(Optional)* | | `labels` *map[string]string* | *(Optional)* | ### ExternalSecretMetadataPolicy (`string` alias) (*Appears on:* [ExternalSecretDataRemoteRef](#external-secrets.io/v1beta1.ExternalSecretDataRemoteRef)) ExternalSecretMetadataPolicy defines the policy for fetching tags/labels from provider secrets. | Value | Description | | --- | --- | | "Fetch" | ExternalSecretMetadataPolicyFetch indicates that metadata will be fetched from the provider. | | "None" | ExternalSecretMetadataPolicyNone indicates that no metadata will be fetched. | ### ExternalSecretRefreshPolicy (`string` alias) (*Appears on:* [ExternalSecretSpec](#external-secrets.io/v1beta1.ExternalSecretSpec)) ExternalSecretRefreshPolicy defines how and when the ExternalSecret should be refreshed. | Value | Description | | --- | --- | | "CreatedOnce" | RefreshPolicyCreatedOnce creates the Secret only if it does not exist and does not update it thereafter. | | "OnChange" | RefreshPolicyOnChange only synchronizes the Secret when the ExternalSecret’s metadata or specification changes. | | "Periodic" | RefreshPolicyPeriodic synchronizes the Secret from the external source at regular intervals. | ### ExternalSecretRewrite (*Appears on:* [ExternalSecretDataFromRemoteRef](#external-secrets.io/v1beta1.ExternalSecretDataFromRemoteRef)) ExternalSecretRewrite defines rules on how to rewrite secret keys. | Field | Description | | --- | --- | | `regexp` *[ExternalSecretRewriteRegexp](#external-secrets.io/v1beta1.ExternalSecretRewriteRegexp)* | *(Optional)* Used to rewrite with regular expressions. The resulting key will be the output of a regexp.ReplaceAll operation. | | `transform` *[ExternalSecretRewriteTransform](#external-secrets.io/v1beta1.ExternalSecretRewriteTransform)* | *(Optional)* Used to apply string transformation on the secrets. The resulting key will be the output of the template applied by the operation. | ### ExternalSecretRewriteRegexp (*Appears on:* [ExternalSecretRewrite](#external-secrets.io/v1beta1.ExternalSecretRewrite)) ExternalSecretRewriteRegexp defines how to use regular expressions for rewriting secret keys. | Field | Description | | --- | --- | | `source` *string* | Used to define the regular expression of a re.Compiler. | | `target` *string* | Used to define the target pattern of a ReplaceAll operation. | ### ExternalSecretRewriteTransform (*Appears on:* [ExternalSecretRewrite](#external-secrets.io/v1beta1.ExternalSecretRewrite)) ExternalSecretRewriteTransform defines how to use string templates for transforming secret keys. | Field | Description | | --- | --- | | `template` *string* | Used to define the template to apply on the secret name. `.value` will specify the secret name in the template. | ### ExternalSecretSpec (*Appears on:* [ClusterExternalSecretSpec](#external-secrets.io/v1beta1.ClusterExternalSecretSpec), [ExternalSecret](#external-secrets.io/v1beta1.ExternalSecret)) ExternalSecretSpec defines the desired state of ExternalSecret. | Field | Description | | --- | --- | | `secretStoreRef` *[SecretStoreRef](#external-secrets.io/v1beta1.SecretStoreRef)* | *(Optional)* | | `target` *[ExternalSecretTarget](#external-secrets.io/v1beta1.ExternalSecretTarget)* | *(Optional)* | | `refreshPolicy` *[ExternalSecretRefreshPolicy](#external-secrets.io/v1beta1.ExternalSecretRefreshPolicy)* | *(Optional)* RefreshPolicy determines how the ExternalSecret should be refreshed: - CreatedOnce: Creates the Secret only if it does not exist and does not update it thereafter - Periodic: Synchronizes the Secret from the external source at regular intervals specified by refreshInterval. No periodic updates occur if refreshInterval is 0. - OnChange: Only synchronizes the Secret when the ExternalSecret’s metadata or specification changes | | `refreshInterval` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | RefreshInterval is the amount of time before the values are read again from the SecretStore provider, specified as Golang Duration strings. Valid time units are “ns”, “us” (or “µs”), “ms”, “s”, “m”, “h” Example values: “1h0m0s”, “2h30m0s”, “10m0s” May be set to “0s” to fetch and create it once. Defaults to 1h0m0s. | | `data` | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.13006335496902466,
-0.007641240954399109,
-0.07442717999219894,
0.009410196915268898,
0.06165093928575516,
-0.06697012484073639,
-0.0004472261352930218,
0.027784887701272964,
1.9018808927739883e-7,
-0.018398163840174675,
0.04307343065738678,
-0.07176925987005234,
0.04198787733912468,
-0... | 0.071013 |
time before the values are read again from the SecretStore provider, specified as Golang Duration strings. Valid time units are “ns”, “us” (or “µs”), “ms”, “s”, “m”, “h” Example values: “1h0m0s”, “2h30m0s”, “10m0s” May be set to “0s” to fetch and create it once. Defaults to 1h0m0s. | | `data` *[[]ExternalSecretData](#external-secrets.io/v1beta1.ExternalSecretData)* | *(Optional)* Data defines the connection between the Kubernetes Secret keys and the Provider data | | `dataFrom` *[[]ExternalSecretDataFromRemoteRef](#external-secrets.io/v1beta1.ExternalSecretDataFromRemoteRef)* | *(Optional)* DataFrom is used to fetch all properties from a specific Provider data If multiple entries are specified, the Secret keys are merged in the specified order | ### ExternalSecretStatus (*Appears on:* [ExternalSecret](#external-secrets.io/v1beta1.ExternalSecret)) ExternalSecretStatus defines the observed state of ExternalSecret. | Field | Description | | --- | --- | | `refreshTime` *[Kubernetes meta/v1.Time](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#time-v1-meta)* | refreshTime is the time and date the external secret was fetched and the target secret updated | | `syncedResourceVersion` *string* | SyncedResourceVersion keeps track of the last synced version | | `conditions` *[[]ExternalSecretStatusCondition](#external-secrets.io/v1beta1.ExternalSecretStatusCondition)* | *(Optional)* | | `binding` *[Kubernetes core/v1.LocalObjectReference](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#localobjectreference-v1-core)* | Binding represents a servicebinding.io Provisioned Service reference to the secret | ### ExternalSecretStatusCondition (*Appears on:* [ExternalSecretStatus](#external-secrets.io/v1beta1.ExternalSecretStatus)) ExternalSecretStatusCondition contains condition information for an ExternalSecret. | Field | Description | | --- | --- | | `type` *[ExternalSecretConditionType](#external-secrets.io/v1beta1.ExternalSecretConditionType)* | | | `status` *[Kubernetes core/v1.ConditionStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#conditionstatus-v1-core)* | | | `reason` *string* | *(Optional)* | | `message` *string* | *(Optional)* | | `lastTransitionTime` *[Kubernetes meta/v1.Time](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#time-v1-meta)* | *(Optional)* | ### ExternalSecretTarget (*Appears on:* [ExternalSecretSpec](#external-secrets.io/v1beta1.ExternalSecretSpec)) ExternalSecretTarget defines the Kubernetes Secret to be created There can be only one target per ExternalSecret. | Field | Description | | --- | --- | | `name` *string* | *(Optional)* The name of the Secret resource to be managed. Defaults to the .metadata.name of the ExternalSecret resource | | `creationPolicy` *[ExternalSecretCreationPolicy](#external-secrets.io/v1beta1.ExternalSecretCreationPolicy)* | *(Optional)* CreationPolicy defines rules on how to create the resulting Secret. Defaults to “Owner” | | `deletionPolicy` *[ExternalSecretDeletionPolicy](#external-secrets.io/v1beta1.ExternalSecretDeletionPolicy)* | *(Optional)* DeletionPolicy defines rules on how to delete the resulting Secret. Defaults to “Retain” | | `template` *[ExternalSecretTemplate](#external-secrets.io/v1beta1.ExternalSecretTemplate)* | *(Optional)* Template defines a blueprint for the created Secret resource. | | `immutable` *bool* | *(Optional)* Immutable defines if the final secret will be immutable | ### ExternalSecretTemplate (*Appears on:* [ExternalSecretTarget](#external-secrets.io/v1beta1.ExternalSecretTarget)) ExternalSecretTemplate defines a blueprint for the created Secret resource. we can not use native corev1.Secret, it will have empty ObjectMeta values: <https://github.com/kubernetes-sigs/controller-tools/issues/448> | Field | Description | | --- | --- | | `type` *[Kubernetes core/v1.SecretType](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#secrettype-v1-core)* | *(Optional)* | | `engineVersion` *[TemplateEngineVersion](#external-secrets.io/v1beta1.TemplateEngineVersion)* | EngineVersion specifies the template engine version that should be used to compile/execute the template specified in .data and .templateFrom[]. | | `metadata` *[ExternalSecretTemplateMetadata](#external-secrets.io/v1beta1.ExternalSecretTemplateMetadata)* | *(Optional)* | | `mergePolicy` *[TemplateMergePolicy](#external-secrets.io/v1beta1.TemplateMergePolicy)* | | | `data` *map[string]string* | *(Optional)* | | `templateFrom` *[[]TemplateFrom](#external-secrets.io/v1beta1.TemplateFrom)* | *(Optional)* | ### ExternalSecretTemplateMetadata (*Appears on:* [ExternalSecretTemplate](#external-secrets.io/v1beta1.ExternalSecretTemplate)) ExternalSecretTemplateMetadata defines metadata fields for the Secret blueprint. | Field | Description | | --- | --- | | `annotations` *map[string]string* | *(Optional)* | | `labels` *map[string]string* | *(Optional)* | ### ExternalSecretValidator ExternalSecretValidator implements webhook validation for ExternalSecret resources. ### FakeProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) FakeProvider configures a fake provider that returns static values. | Field | Description | | --- | --- | | `data` *[[]FakeProviderData](#external-secrets.io/v1beta1.FakeProviderData)* | | ### FakeProviderData (*Appears on:* [FakeProvider](#external-secrets.io/v1beta1.FakeProvider)) FakeProviderData defines a key-value pair for the fake provider used in testing. | Field | Description | | --- | --- | | `key` *string* | | | `value` *string* | | | `version` *string* | | ### FindName (*Appears on:* [ExternalSecretFind](#external-secrets.io/v1beta1.ExternalSecretFind)) FindName defines name matching criteria for finding secrets. | Field | Description | | --- | --- | | `regexp` *string* | *(Optional)* Finds secrets base | ### FortanixProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) FortanixProvider configures a store to | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.005924491211771965,
0.039853259921073914,
0.011459377594292164,
-0.001910046092234552,
-0.04739769920706749,
0.02326118014752865,
0.025902487337589264,
0.020961297675967216,
0.0997307077050209,
-0.016219519078731537,
0.07022535055875778,
-0.09023614227771759,
-0.006345140747725964,
-0.0... | 0.048715 |
*string* | | | `version` *string* | | ### FindName (*Appears on:* [ExternalSecretFind](#external-secrets.io/v1beta1.ExternalSecretFind)) FindName defines name matching criteria for finding secrets. | Field | Description | | --- | --- | | `regexp` *string* | *(Optional)* Finds secrets base | ### FortanixProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) FortanixProvider configures a store to sync secrets using the Fortanix SDKMS provider. | Field | Description | | --- | --- | | `apiUrl` *string* | APIURL is the URL of SDKMS API. Defaults to `sdkms.fortanix.com`. | | `apiKey` *[FortanixProviderSecretRef](#external-secrets.io/v1beta1.FortanixProviderSecretRef)* | APIKey is the API token to access SDKMS Applications. | ### FortanixProviderSecretRef (*Appears on:* [FortanixProvider](#external-secrets.io/v1beta1.FortanixProvider)) FortanixProviderSecretRef defines a reference to a secret containing credentials for the Fortanix provider. | Field | Description | | --- | --- | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | SecretRef is a reference to a secret containing the SDKMS API Key. | ### GCPSMAuth (*Appears on:* [GCPSMProvider](#external-secrets.io/v1beta1.GCPSMProvider)) GCPSMAuth defines the authentication methods for the GCP Secret Manager provider. | Field | Description | | --- | --- | | `secretRef` *[GCPSMAuthSecretRef](#external-secrets.io/v1beta1.GCPSMAuthSecretRef)* | *(Optional)* | | `workloadIdentity` *[GCPWorkloadIdentity](#external-secrets.io/v1beta1.GCPWorkloadIdentity)* | *(Optional)* | ### GCPSMAuthSecretRef (*Appears on:* [GCPSMAuth](#external-secrets.io/v1beta1.GCPSMAuth)) GCPSMAuthSecretRef defines a reference to a secret containing credentials for the GCP Secret Manager provider. | Field | Description | | --- | --- | | `secretAccessKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The SecretAccessKey is used for authentication | ### GCPSMProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) GCPSMProvider Configures a store to sync secrets using the GCP Secret Manager provider. | Field | Description | | --- | --- | | `auth` *[GCPSMAuth](#external-secrets.io/v1beta1.GCPSMAuth)* | *(Optional)* Auth defines the information necessary to authenticate against GCP | | `projectID` *string* | ProjectID project where secret is located | | `location` *string* | Location optionally defines a location for a secret | ### GCPWorkloadIdentity (*Appears on:* [GCPSMAuth](#external-secrets.io/v1beta1.GCPSMAuth)) GCPWorkloadIdentity defines configuration for using GCP Workload Identity authentication. | Field | Description | | --- | --- | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | | | `clusterLocation` *string* | *(Optional)* ClusterLocation is the location of the cluster If not specified, it fetches information from the metadata server | | `clusterName` *string* | *(Optional)* ClusterName is the name of the cluster If not specified, it fetches information from the metadata server | | `clusterProjectID` *string* | *(Optional)* ClusterProjectID is the project ID of the cluster If not specified, it fetches information from the metadata server | ### GeneratorRef (*Appears on:* [StoreGeneratorSourceRef](#external-secrets.io/v1beta1.StoreGeneratorSourceRef), [StoreSourceRef](#external-secrets.io/v1beta1.StoreSourceRef)) GeneratorRef points to a generator custom resource. | Field | Description | | --- | --- | | `apiVersion` *string* | Specify the apiVersion of the generator resource | | `kind` *string* | Specify the Kind of the generator resource | | `name` *string* | Specify the name of the generator resource | ### GenericStore GenericStore is a common interface for interacting with ClusterSecretStore or a namespaced SecretStore. ### GenericStoreValidator GenericStoreValidator provides validation for SecretStore and ClusterSecretStore resources. ### GithubAppAuth (*Appears on:* [GithubProvider](#external-secrets.io/v1beta1.GithubProvider)) GithubAppAuth defines the GitHub App authentication mechanism for the GitHub provider. | Field | Description | | --- | --- | | `privateKey` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### GithubProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) GithubProvider configures a store to push secrets to Github Actions. | Field | Description | | --- | --- | | `url` *string* | URL configures the Github instance URL. Defaults to <https://github.com/>. | | `uploadURL` *string* | *(Optional)* Upload URL for enterprise instances. Default to URL. | | `auth` *[GithubAppAuth](#external-secrets.io/v1beta1.GithubAppAuth)* | auth configures how secret-manager authenticates with a Github instance. | | `appID` *int64* | appID specifies the Github APP that will be used to authenticate the client | | `installationID` *int64* | installationID | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.11966949701309204,
-0.03140489384531975,
-0.048776403069496155,
0.041872717440128326,
0.026698431000113487,
0.00023920599778648466,
-0.019853103905916214,
0.013406259939074516,
0.0029988656751811504,
-0.045866306871175766,
0.01500557642430067,
-0.043147701770067215,
0.028286464512348175,
... | 0.085587 |
`uploadURL` *string* | *(Optional)* Upload URL for enterprise instances. Default to URL. | | `auth` *[GithubAppAuth](#external-secrets.io/v1beta1.GithubAppAuth)* | auth configures how secret-manager authenticates with a Github instance. | | `appID` *int64* | appID specifies the Github APP that will be used to authenticate the client | | `installationID` *int64* | installationID specifies the Github APP installation that will be used to authenticate the client | | `organization` *string* | organization will be used to fetch secrets from the Github organization | | `repository` *string* | *(Optional)* repository will be used to fetch secrets from the Github repository within an organization | | `environment` *string* | *(Optional)* environment will be used to fetch secrets from a particular environment within a github repository | ### GitlabAuth (*Appears on:* [GitlabProvider](#external-secrets.io/v1beta1.GitlabProvider)) GitlabAuth defines the authentication method for the GitLab provider. | Field | Description | | --- | --- | | `SecretRef` *[GitlabSecretRef](#external-secrets.io/v1beta1.GitlabSecretRef)* | | ### GitlabProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) GitlabProvider configures a store to sync secrets with a GitLab instance. | Field | Description | | --- | --- | | `url` *string* | URL configures the GitLab instance URL. Defaults to <https://gitlab.com/>. | | `auth` *[GitlabAuth](#external-secrets.io/v1beta1.GitlabAuth)* | Auth configures how secret-manager authenticates with a GitLab instance. | | `projectID` *string* | ProjectID specifies a project where secrets are located. | | `inheritFromGroups` *bool* | InheritFromGroups specifies whether parent groups should be discovered and checked for secrets. | | `groupIDs` *[]string* | GroupIDs specify, which gitlab groups to pull secrets from. Group secrets are read from left to right followed by the project variables. | | `environment` *string* | Environment environment\_scope of gitlab CI/CD variables (Please see <https://docs.gitlab.com/ee/ci/environments/#create-a-static-environment> on how to create environments) | | `caBundle` *[]byte* | *(Optional)* Base64 encoded certificate for the GitLab server sdk. The sdk MUST run with HTTPS to make sure no MITM attack can be performed. | | `caProvider` *[CAProvider](#external-secrets.io/v1beta1.CAProvider)* | *(Optional)* see: <https://external-secrets.io/latest/spec/#external-secrets.io/v1alpha1.CAProvider> | ### GitlabSecretRef (*Appears on:* [GitlabAuth](#external-secrets.io/v1beta1.GitlabAuth)) GitlabSecretRef defines a reference to a secret containing credentials for the GitLab provider. | Field | Description | | --- | --- | | `accessToken` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | AccessToken is used for authentication. | ### IBMAuth (*Appears on:* [IBMProvider](#external-secrets.io/v1beta1.IBMProvider)) IBMAuth defines the authentication methods for the IBM Cloud Secrets Manager provider. | Field | Description | | --- | --- | | `secretRef` *[IBMAuthSecretRef](#external-secrets.io/v1beta1.IBMAuthSecretRef)* | | | `containerAuth` *[IBMAuthContainerAuth](#external-secrets.io/v1beta1.IBMAuthContainerAuth)* | | ### IBMAuthContainerAuth (*Appears on:* [IBMAuth](#external-secrets.io/v1beta1.IBMAuth)) IBMAuthContainerAuth defines authentication using IBM Container-based auth with IAM Trusted Profile. | Field | Description | | --- | --- | | `profile` *string* | the IBM Trusted Profile | | `tokenLocation` *string* | Location the token is mounted on the pod | | `iamEndpoint` *string* | | ### IBMAuthSecretRef (*Appears on:* [IBMAuth](#external-secrets.io/v1beta1.IBMAuth)) IBMAuthSecretRef defines a reference to a secret containing credentials for the IBM provider. | Field | Description | | --- | --- | | `secretApiKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The SecretAccessKey is used for authentication | ### IBMProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) IBMProvider configures a store to sync secrets using a IBM Cloud Secrets Manager backend. | Field | Description | | --- | --- | | `auth` *[IBMAuth](#external-secrets.io/v1beta1.IBMAuth)* | Auth configures how secret-manager authenticates with the IBM secrets manager. | | `serviceUrl` *string* | ServiceURL is the Endpoint URL that is specific to the Secrets Manager service instance | ### InfisicalAuth (*Appears on:* [InfisicalProvider](#external-secrets.io/v1beta1.InfisicalProvider)) InfisicalAuth defines the authentication methods for the Infisical provider. | Field | Description | | --- | --- | | `universalAuthCredentials` *[UniversalAuthCredentials](#external-secrets.io/v1beta1.UniversalAuthCredentials)* | *(Optional)* | ### InfisicalProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) InfisicalProvider configures a store to sync secrets using the Infisical provider. | Field | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.10480834543704987,
-0.03070446290075779,
-0.06689460575580597,
0.0007851150585338473,
0.011865583248436451,
-0.07984837144613266,
-0.02260817028582096,
0.011956140398979187,
0.009953542612493038,
0.019616538658738136,
0.03587795048952103,
-0.012126856483519077,
0.10679851472377777,
-0.0... | 0.11212 |
| ### InfisicalAuth (*Appears on:* [InfisicalProvider](#external-secrets.io/v1beta1.InfisicalProvider)) InfisicalAuth defines the authentication methods for the Infisical provider. | Field | Description | | --- | --- | | `universalAuthCredentials` *[UniversalAuthCredentials](#external-secrets.io/v1beta1.UniversalAuthCredentials)* | *(Optional)* | ### InfisicalProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) InfisicalProvider configures a store to sync secrets using the Infisical provider. | Field | Description | | --- | --- | | `auth` *[InfisicalAuth](#external-secrets.io/v1beta1.InfisicalAuth)* | Auth configures how the Operator authenticates with the Infisical API | | `secretsScope` *[MachineIdentityScopeInWorkspace](#external-secrets.io/v1beta1.MachineIdentityScopeInWorkspace)* | SecretsScope defines the scope of the secrets within the workspace | | `hostAPI` *string* | *(Optional)* HostAPI specifies the base URL of the Infisical API. If not provided, it defaults to “[https://app.infisical.com/api”](https://app.infisical.com/api"). | ### KeeperSecurityProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) KeeperSecurityProvider Configures a store to sync secrets using Keeper Security. | Field | Description | | --- | --- | | `authRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `folderID` *string* | | ### KubernetesAuth (*Appears on:* [KubernetesProvider](#external-secrets.io/v1beta1.KubernetesProvider)) KubernetesAuth defines authentication methods for the Kubernetes provider. | Field | Description | | --- | --- | | `cert` *[CertAuth](#external-secrets.io/v1beta1.CertAuth)* | *(Optional)* has both clientCert and clientKey as secretKeySelector | | `token` *[TokenAuth](#external-secrets.io/v1beta1.TokenAuth)* | *(Optional)* use static token to authenticate with | | `serviceAccount` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* points to a service account that should be used for authentication | ### KubernetesProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) KubernetesProvider configures a store to sync secrets with a Kubernetes instance. | Field | Description | | --- | --- | | `server` *[KubernetesServer](#external-secrets.io/v1beta1.KubernetesServer)* | *(Optional)* configures the Kubernetes server Address. | | `auth` *[KubernetesAuth](#external-secrets.io/v1beta1.KubernetesAuth)* | *(Optional)* Auth configures how secret-manager authenticates with a Kubernetes instance. | | `authRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* A reference to a secret that contains the auth information. | | `remoteNamespace` *string* | *(Optional)* Remote namespace to fetch the secrets from | ### KubernetesServer (*Appears on:* [KubernetesProvider](#external-secrets.io/v1beta1.KubernetesProvider)) KubernetesServer defines the Kubernetes server connection configuration. | Field | Description | | --- | --- | | `url` *string* | *(Optional)* configures the Kubernetes server Address. | | `caBundle` *[]byte* | *(Optional)* CABundle is a base64-encoded CA certificate | | `caProvider` *[CAProvider](#external-secrets.io/v1beta1.CAProvider)* | *(Optional)* see: <https://external-secrets.io/v0.4.1/spec/#external-secrets.io/v1alpha1.CAProvider> | ### MachineIdentityScopeInWorkspace (*Appears on:* [InfisicalProvider](#external-secrets.io/v1beta1.InfisicalProvider)) MachineIdentityScopeInWorkspace defines the scope of a machine identity in an Infisical workspace. | Field | Description | | --- | --- | | `secretsPath` *string* | *(Optional)* SecretsPath specifies the path to the secrets within the workspace. Defaults to “/” if not provided. | | `recursive` *bool* | *(Optional)* Recursive indicates whether the secrets should be fetched recursively. Defaults to false if not provided. | | `environmentSlug` *string* | EnvironmentSlug is the required slug identifier for the environment. | | `projectSlug` *string* | ProjectSlug is the required slug identifier for the project. | | `expandSecretReferences` *bool* | *(Optional)* ExpandSecretReferences indicates whether secret references should be expanded. Defaults to true if not provided. | ### NTLMProtocol (*Appears on:* [AuthorizationProtocol](#external-secrets.io/v1beta1.AuthorizationProtocol)) NTLMProtocol contains the NTLM-specific configuration. | Field | Description | | --- | --- | | `usernameSecret` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `passwordSecret` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### NoSecretError NoSecretError shall be returned when a GetSecret can not find the desired secret. This is used for deletionPolicy. ### NotModifiedError NotModifiedError to signal that the webhook received no changes, and it should just return without doing anything. ### OnboardbaseAuthSecretRef (*Appears on:* [OnboardbaseProvider](#external-secrets.io/v1beta1.OnboardbaseProvider)) OnboardbaseAuthSecretRef holds secret references for onboardbase API Key credentials. | Field | Description | | --- | --- | | `apiKeyRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | OnboardbaseAPIKey is the APIKey generated by an admin account. It is used to recognize and authorize access to a project and environment within onboardbase | | `passcodeRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.1389390230178833,
0.020056748762726784,
-0.049674008041620255,
-0.004028437193483114,
0.022401580587029457,
-0.0332244411110878,
0.03472796082496643,
-0.015539703890681267,
-0.0013449408579617739,
-0.012060956098139286,
0.0543864481151104,
-0.012993857264518738,
0.04834076017141342,
0.0... | 0.077122 |
onboardbase API Key credentials. | Field | Description | | --- | --- | | `apiKeyRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | OnboardbaseAPIKey is the APIKey generated by an admin account. It is used to recognize and authorize access to a project and environment within onboardbase | | `passcodeRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | OnboardbasePasscode is the passcode attached to the API Key | ### OnboardbaseProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) OnboardbaseProvider configures a store to sync secrets using the Onboardbase provider. Project and Config are required if not using a Service Token. | Field | Description | | --- | --- | | `auth` *[OnboardbaseAuthSecretRef](#external-secrets.io/v1beta1.OnboardbaseAuthSecretRef)* | Auth configures how the Operator authenticates with the Onboardbase API | | `apiHost` *string* | APIHost use this to configure the host url for the API for selfhosted installation, default is <https://public.onboardbase.com/api/v1/> | | `project` *string* | Project is an onboardbase project that the secrets should be pulled from | | `environment` *string* | Environment is the name of an environmnent within a project to pull the secrets from | ### OnePasswordAuth (*Appears on:* [OnePasswordProvider](#external-secrets.io/v1beta1.OnePasswordProvider)) OnePasswordAuth contains a secretRef for credentials. | Field | Description | | --- | --- | | `secretRef` *[OnePasswordAuthSecretRef](#external-secrets.io/v1beta1.OnePasswordAuthSecretRef)* | | ### OnePasswordAuthSecretRef (*Appears on:* [OnePasswordAuth](#external-secrets.io/v1beta1.OnePasswordAuth)) OnePasswordAuthSecretRef holds secret references for 1Password credentials. | Field | Description | | --- | --- | | `connectTokenSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The ConnectToken is used for authentication to a 1Password Connect Server. | ### OnePasswordProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) OnePasswordProvider configures a store to sync secrets using the 1Password Secret Manager provider. | Field | Description | | --- | --- | | `auth` *[OnePasswordAuth](#external-secrets.io/v1beta1.OnePasswordAuth)* | Auth defines the information necessary to authenticate against OnePassword Connect Server | | `connectHost` *string* | ConnectHost defines the OnePassword Connect Server to connect to | | `vaults` *map[string]int* | Vaults defines which OnePassword vaults to search in which order | ### OracleAuth (*Appears on:* [OracleProvider](#external-secrets.io/v1beta1.OracleProvider)) OracleAuth defines authentication configuration for the Oracle Vault provider. | Field | Description | | --- | --- | | `tenancy` *string* | Tenancy is the tenancy OCID where user is located. | | `user` *string* | User is an access OCID specific to the account. | | `secretRef` *[OracleSecretRef](#external-secrets.io/v1beta1.OracleSecretRef)* | SecretRef to pass through sensitive information. | ### OraclePrincipalType (`string` alias) (*Appears on:* [OracleProvider](#external-secrets.io/v1beta1.OracleProvider)) OraclePrincipalType defines the type of principal used for authentication to Oracle Vault. | Value | Description | | --- | --- | | "InstancePrincipal" | InstancePrincipal represents a instance principal. | | "UserPrincipal" | UserPrincipal represents a user principal. | | "Workload" | WorkloadPrincipal represents a workload principal. | ### OracleProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) OracleProvider configures a store to sync secrets using an Oracle Vault backend. | Field | Description | | --- | --- | | `region` *string* | Region is the region where vault is located. | | `vault` *string* | Vault is the vault’s OCID of the specific vault where secret is located. | | `compartment` *string* | *(Optional)* Compartment is the vault compartment OCID. Required for PushSecret | | `encryptionKey` *string* | *(Optional)* EncryptionKey is the OCID of the encryption key within the vault. Required for PushSecret | | `principalType` *[OraclePrincipalType](#external-secrets.io/v1beta1.OraclePrincipalType)* | *(Optional)* The type of principal to use for authentication. If left blank, the Auth struct will determine the principal type. This optional field must be specified if using workload identity. | | `auth` *[OracleAuth](#external-secrets.io/v1beta1.OracleAuth)* | *(Optional)* Auth configures how secret-manager authenticates with the Oracle Vault. If empty, use the instance principal, otherwise the user credentials specified in Auth. | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* ServiceAccountRef specified the service account that should | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.06614509969949722,
-0.025682389736175537,
-0.08889452368021011,
0.009600304998457432,
0.015535630285739899,
0.0243170615285635,
0.024990517646074295,
0.01759454235434532,
0.02538885548710823,
0.03920543193817139,
0.015844769775867462,
-0.016855793073773384,
0.048370253294706345,
-0.0210... | 0.074018 |
must be specified if using workload identity. | | `auth` *[OracleAuth](#external-secrets.io/v1beta1.OracleAuth)* | *(Optional)* Auth configures how secret-manager authenticates with the Oracle Vault. If empty, use the instance principal, otherwise the user credentials specified in Auth. | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* ServiceAccountRef specified the service account that should be used when authenticating with WorkloadIdentity. | ### OracleSecretRef (*Appears on:* [OracleAuth](#external-secrets.io/v1beta1.OracleAuth)) OracleSecretRef defines references to secrets containing Oracle credentials. | Field | Description | | --- | --- | | `privatekey` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | PrivateKey is the user’s API Signing Key in PEM format, used for authentication. | | `fingerprint` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | Fingerprint is the fingerprint of the API private key. | ### PassboltAuth (*Appears on:* [PassboltProvider](#external-secrets.io/v1beta1.PassboltProvider)) PassboltAuth contains credentials and configuration for authenticating with the Passbolt server. | Field | Description | | --- | --- | | `passwordSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | PasswordSecretRef is a reference to the secret containing the Passbolt password | | `privateKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | PrivateKeySecretRef is a reference to the secret containing the Passbolt private key | ### PassboltProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) PassboltProvider defines configuration for the Passbolt provider. | Field | Description | | --- | --- | | `auth` *[PassboltAuth](#external-secrets.io/v1beta1.PassboltAuth)* | Auth defines the information necessary to authenticate against Passbolt Server | | `host` *string* | Host defines the Passbolt Server to connect to | ### PasswordDepotAuth (*Appears on:* [PasswordDepotProvider](#external-secrets.io/v1beta1.PasswordDepotProvider)) PasswordDepotAuth defines the authentication method for the Password Depot provider. | Field | Description | | --- | --- | | `secretRef` *[PasswordDepotSecretRef](#external-secrets.io/v1beta1.PasswordDepotSecretRef)* | | ### PasswordDepotProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) PasswordDepotProvider configures a store to sync secrets with a Password Depot instance. | Field | Description | | --- | --- | | `host` *string* | URL configures the Password Depot instance URL. | | `database` *string* | Database to use as source | | `auth` *[PasswordDepotAuth](#external-secrets.io/v1beta1.PasswordDepotAuth)* | Auth configures how secret-manager authenticates with a Password Depot instance. | ### PasswordDepotSecretRef (*Appears on:* [PasswordDepotAuth](#external-secrets.io/v1beta1.PasswordDepotAuth)) PasswordDepotSecretRef defines a reference to a secret containing credentials for the Password Depot provider. | Field | Description | | --- | --- | | `credentials` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* Username / Password is used for authentication. | ### PreviderAuth (*Appears on:* [PreviderProvider](#external-secrets.io/v1beta1.PreviderProvider)) PreviderAuth contains a secretRef for credentials. | Field | Description | | --- | --- | | `secretRef` *[PreviderAuthSecretRef](#external-secrets.io/v1beta1.PreviderAuthSecretRef)* | *(Optional)* | ### PreviderAuthSecretRef (*Appears on:* [PreviderAuth](#external-secrets.io/v1beta1.PreviderAuth)) PreviderAuthSecretRef holds secret references for Previder Vault credentials. | Field | Description | | --- | --- | | `accessToken` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The AccessToken is used for authentication | ### PreviderProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) PreviderProvider configures a store to sync secrets using the Previder Secret Manager provider. | Field | Description | | --- | --- | | `auth` *[PreviderAuth](#external-secrets.io/v1beta1.PreviderAuth)* | | | `baseUri` *string* | *(Optional)* | ### Provider Provider is a common interface for interacting with secret backends. ### PulumiProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) PulumiProvider defines configuration for the Pulumi provider. | Field | Description | | --- | --- | | `apiUrl` *string* | APIURL is the URL of the Pulumi API. | | `accessToken` *[PulumiProviderSecretRef](#external-secrets.io/v1beta1.PulumiProviderSecretRef)* | AccessToken is the access tokens to sign in to the Pulumi Cloud Console. | | `organization` *string* | Organization are a space to collaborate on shared projects and stacks. To create a new organization, visit <https://app.pulumi.com/> and click “New Organization”. | | `project` *string* | Project is the name of the Pulumi ESC project the environment belongs to. | | `environment` *string* | Environment are YAML documents composed of static key-value pairs, programmatic expressions, dynamically retrieved values from supported providers | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.10120241343975067,
-0.020949650555849075,
-0.09898217022418976,
-0.05436141788959503,
-0.006094431504607201,
-0.026316700503230095,
0.07823915034532547,
0.07151880115270615,
0.019342314451932907,
-0.013150307349860668,
0.026384573429822922,
-0.06605781614780426,
0.03241308778524399,
0.0... | -0.002446 |
create a new organization, visit <https://app.pulumi.com/> and click “New Organization”. | | `project` *string* | Project is the name of the Pulumi ESC project the environment belongs to. | | `environment` *string* | Environment are YAML documents composed of static key-value pairs, programmatic expressions, dynamically retrieved values from supported providers including all major clouds, and other Pulumi ESC environments. To create a new environment, visit <https://www.pulumi.com/docs/esc/environments/> for more information. | ### PulumiProviderSecretRef (*Appears on:* [PulumiProvider](#external-secrets.io/v1beta1.PulumiProvider)) PulumiProviderSecretRef defines a reference to a secret containing credentials for the Pulumi provider. | Field | Description | | --- | --- | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | SecretRef is a reference to a secret containing the Pulumi API token. | ### PushSecretData PushSecretData is an interface to allow using v1alpha1.PushSecretData content in Provider registered in v1beta1. ### PushSecretRemoteRef PushSecretRemoteRef is an interface to allow using v1alpha1.PushSecretRemoteRef in Provider registered in v1beta1. ### ScalewayProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) ScalewayProvider defines configuration for the Scaleway provider. | Field | Description | | --- | --- | | `apiUrl` *string* | *(Optional)* APIURL is the url of the api to use. Defaults to <https://api.scaleway.com> | | `region` *string* | Region where your secrets are located: <https://developers.scaleway.com/en/quickstart/#region-and-zone> | | `projectId` *string* | ProjectID is the id of your project, which you can find in the console: <https://console.scaleway.com/project/settings> | | `accessKey` *[ScalewayProviderSecretRef](#external-secrets.io/v1beta1.ScalewayProviderSecretRef)* | AccessKey is the non-secret part of the api key. | | `secretKey` *[ScalewayProviderSecretRef](#external-secrets.io/v1beta1.ScalewayProviderSecretRef)* | SecretKey is the non-secret part of the api key. | ### ScalewayProviderSecretRef (*Appears on:* [ScalewayProvider](#external-secrets.io/v1beta1.ScalewayProvider)) ScalewayProviderSecretRef defines a reference to a secret containing credentials for the Scaleway provider. | Field | Description | | --- | --- | | `value` *string* | *(Optional)* Value can be specified directly to set a value without using a secret. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef references a key in a secret that will be used as value. | ### SecretServerProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) SecretServerProvider defines configuration for the Delinea Secret Server provider. See <https://github.com/DelineaXPM/tss-sdk-go/blob/main/server/server.go>. | Field | Description | | --- | --- | | `username` *[SecretServerProviderRef](#external-secrets.io/v1beta1.SecretServerProviderRef)* | Username is the secret server account username. | | `password` *[SecretServerProviderRef](#external-secrets.io/v1beta1.SecretServerProviderRef)* | Password is the secret server account password. | | `serverURL` *string* | ServerURL URL to your secret server installation | ### SecretServerProviderRef (*Appears on:* [SecretServerProvider](#external-secrets.io/v1beta1.SecretServerProvider)) SecretServerProviderRef defines a reference to a secret containing credentials for the Secret Server provider. | Field | Description | | --- | --- | | `value` *string* | *(Optional)* Value can be specified directly to set a value without using a secret. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef references a key in a secret that will be used as value. | ### SecretStore SecretStore represents a secure external location for storing secrets, which can be referenced as part of `storeRef` fields. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[SecretStoreSpec](#external-secrets.io/v1beta1.SecretStoreSpec)* | | `controller` *string* | *(Optional)* Used to select the correct ESO controller (think: ingress.ingressClassName) The ESO controller is instantiated with a specific controller name and filters ES based on this property | | --- | --- | | `provider` *[SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)* | Used to configure the provider. Only one provider may be set | | `retrySettings` *[SecretStoreRetrySettings](#external-secrets.io/v1beta1.SecretStoreRetrySettings)* | *(Optional)* Used to configure HTTP retries on failures. | | `refreshInterval` *int* | *(Optional)* Used to configure store refresh interval in seconds. Empty or 0 will default to the controller config. | | `conditions` *[[]ClusterSecretStoreCondition](#external-secrets.io/v1beta1.ClusterSecretStoreCondition)* | *(Optional)* Used to constrain a ClusterSecretStore to | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.027223005890846252,
-0.08170301467180252,
-0.09076766669750214,
-0.013235950842499733,
0.0036284648813307285,
-0.03993291035294533,
0.02088105119764805,
-0.0408654548227787,
0.044485531747341156,
-0.0026658042334020138,
0.05095024034380913,
-0.13363471627235413,
0.03931457921862602,
-0.... | 0.070656 |
be set | | `retrySettings` *[SecretStoreRetrySettings](#external-secrets.io/v1beta1.SecretStoreRetrySettings)* | *(Optional)* Used to configure HTTP retries on failures. | | `refreshInterval` *int* | *(Optional)* Used to configure store refresh interval in seconds. Empty or 0 will default to the controller config. | | `conditions` *[[]ClusterSecretStoreCondition](#external-secrets.io/v1beta1.ClusterSecretStoreCondition)* | *(Optional)* Used to constrain a ClusterSecretStore to specific namespaces. Relevant only to ClusterSecretStore. | | | `status` *[SecretStoreStatus](#external-secrets.io/v1beta1.SecretStoreStatus)* | | ### SecretStoreCapabilities (`string` alias) (*Appears on:* [SecretStoreStatus](#external-secrets.io/v1beta1.SecretStoreStatus)) SecretStoreCapabilities defines the possible operations a SecretStore can do. | Value | Description | | --- | --- | | "ReadOnly" | SecretStoreReadOnly indicates that the SecretStore only supports reading secrets. | | "ReadWrite" | SecretStoreReadWrite indicates that the SecretStore supports both reading and writing secrets. | | "WriteOnly" | SecretStoreWriteOnly indicates that the SecretStore only supports writing secrets. | ### SecretStoreConditionType (`string` alias) (*Appears on:* [SecretStoreStatusCondition](#external-secrets.io/v1beta1.SecretStoreStatusCondition)) SecretStoreConditionType represents the condition type of the SecretStore. | Value | Description | | --- | --- | | "Ready" | SecretStoreReady indicates that the SecretStore has been successfully configured. | ### SecretStoreProvider (*Appears on:* [SecretStoreSpec](#external-secrets.io/v1beta1.SecretStoreSpec)) SecretStoreProvider contains the provider-specific configuration. | Field | Description | | --- | --- | | `aws` *[AWSProvider](#external-secrets.io/v1beta1.AWSProvider)* | *(Optional)* AWS configures this store to sync secrets using AWS Secret Manager provider | | `azurekv` *[AzureKVProvider](#external-secrets.io/v1beta1.AzureKVProvider)* | *(Optional)* AzureKV configures this store to sync secrets using Azure Key Vault provider | | `akeyless` *[AkeylessProvider](#external-secrets.io/v1beta1.AkeylessProvider)* | *(Optional)* Akeyless configures this store to sync secrets using Akeyless Vault provider | | `bitwardensecretsmanager` *[BitwardenSecretsManagerProvider](#external-secrets.io/v1beta1.BitwardenSecretsManagerProvider)* | *(Optional)* BitwardenSecretsManager configures this store to sync secrets using BitwardenSecretsManager provider | | `vault` *[VaultProvider](#external-secrets.io/v1beta1.VaultProvider)* | *(Optional)* Vault configures this store to sync secrets using the HashiCorp Vault provider. | | `gcpsm` *[GCPSMProvider](#external-secrets.io/v1beta1.GCPSMProvider)* | *(Optional)* GCPSM configures this store to sync secrets using Google Cloud Platform Secret Manager provider | | `oracle` *[OracleProvider](#external-secrets.io/v1beta1.OracleProvider)* | *(Optional)* Oracle configures this store to sync secrets using Oracle Vault provider | | `ibm` *[IBMProvider](#external-secrets.io/v1beta1.IBMProvider)* | *(Optional)* IBM configures this store to sync secrets using IBM Cloud provider | | `yandexcertificatemanager` *[YandexCertificateManagerProvider](#external-secrets.io/v1beta1.YandexCertificateManagerProvider)* | *(Optional)* YandexCertificateManager configures this store to sync secrets using Yandex Certificate Manager provider | | `yandexlockbox` *[YandexLockboxProvider](#external-secrets.io/v1beta1.YandexLockboxProvider)* | *(Optional)* YandexLockbox configures this store to sync secrets using Yandex Lockbox provider | | `github` *[GithubProvider](#external-secrets.io/v1beta1.GithubProvider)* | *(Optional)* Github configures this store to push GitHub Actions secrets using the GitHub API provider. | | `gitlab` *[GitlabProvider](#external-secrets.io/v1beta1.GitlabProvider)* | *(Optional)* GitLab configures this store to sync secrets using GitLab Variables provider | | `alibaba` *[AlibabaProvider](#external-secrets.io/v1beta1.AlibabaProvider)* | *(Optional)* Alibaba configures this store to sync secrets using Alibaba Cloud provider | | `onepassword` *[OnePasswordProvider](#external-secrets.io/v1beta1.OnePasswordProvider)* | *(Optional)* OnePassword configures this store to sync secrets using the 1Password Cloud provider | | `webhook` *[WebhookProvider](#external-secrets.io/v1beta1.WebhookProvider)* | *(Optional)* Webhook configures this store to sync secrets using a generic templated webhook | | `kubernetes` *[KubernetesProvider](#external-secrets.io/v1beta1.KubernetesProvider)* | *(Optional)* Kubernetes configures this store to sync secrets using a Kubernetes cluster provider | | `fake` *[FakeProvider](#external-secrets.io/v1beta1.FakeProvider)* | *(Optional)* Fake configures a store with static key/value pairs | | `senhasegura` *[SenhaseguraProvider](#external-secrets.io/v1beta1.SenhaseguraProvider)* | *(Optional)* Senhasegura configures this store to sync secrets using senhasegura provider | | `scaleway` *[ScalewayProvider](#external-secrets.io/v1beta1.ScalewayProvider)* | *(Optional)* Scaleway configures this store to sync secrets using the Scaleway provider. | | `doppler` *[DopplerProvider](#external-secrets.io/v1beta1.DopplerProvider)* | *(Optional)* Doppler configures this store to sync secrets using the Doppler provider | | `previder` *[PreviderProvider](#external-secrets.io/v1beta1.PreviderProvider)* | *(Optional)* Previder configures this store to sync secrets using the Previder provider | | `onboardbase` *[OnboardbaseProvider](#external-secrets.io/v1beta1.OnboardbaseProvider)* | *(Optional)* Onboardbase configures this store to sync secrets using the Onboardbase provider | | `keepersecurity` *[KeeperSecurityProvider](#external-secrets.io/v1beta1.KeeperSecurityProvider)* | *(Optional)* KeeperSecurity configures this store to sync secrets using the KeeperSecurity provider | | `conjur` *[ConjurProvider](#external-secrets.io/v1beta1.ConjurProvider)* | *(Optional)* Conjur configures this store to sync secrets using | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.045915670692920685,
-0.030057989060878754,
-0.06410352885723114,
0.08070313185453415,
0.005616864189505577,
0.00508312089368701,
-0.03195714205503464,
0.0015779008390381932,
-0.028894910588860512,
0.042934734374284744,
0.05538533255457878,
-0.04663464054465294,
0.04473401978611946,
-0.0... | 0.085367 |
Previder provider | | `onboardbase` *[OnboardbaseProvider](#external-secrets.io/v1beta1.OnboardbaseProvider)* | *(Optional)* Onboardbase configures this store to sync secrets using the Onboardbase provider | | `keepersecurity` *[KeeperSecurityProvider](#external-secrets.io/v1beta1.KeeperSecurityProvider)* | *(Optional)* KeeperSecurity configures this store to sync secrets using the KeeperSecurity provider | | `conjur` *[ConjurProvider](#external-secrets.io/v1beta1.ConjurProvider)* | *(Optional)* Conjur configures this store to sync secrets using conjur provider | | `delinea` *[DelineaProvider](#external-secrets.io/v1beta1.DelineaProvider)* | *(Optional)* Delinea DevOps Secrets Vault <https://docs.delinea.com/online-help/products/devops-secrets-vault/current> | | `secretserver` *[SecretServerProvider](#external-secrets.io/v1beta1.SecretServerProvider)* | *(Optional)* SecretServer configures this store to sync secrets using SecretServer provider <https://docs.delinea.com/online-help/secret-server/start.htm> | | `chef` *[ChefProvider](#external-secrets.io/v1beta1.ChefProvider)* | *(Optional)* Chef configures this store to sync secrets with chef server | | `pulumi` *[PulumiProvider](#external-secrets.io/v1beta1.PulumiProvider)* | *(Optional)* Pulumi configures this store to sync secrets using the Pulumi provider | | `fortanix` *[FortanixProvider](#external-secrets.io/v1beta1.FortanixProvider)* | *(Optional)* Fortanix configures this store to sync secrets using the Fortanix provider | | `passworddepot` *[PasswordDepotProvider](#external-secrets.io/v1beta1.PasswordDepotProvider)* | *(Optional)* | | `passbolt` *[PassboltProvider](#external-secrets.io/v1beta1.PassboltProvider)* | *(Optional)* | | `device42` *[Device42Provider](#external-secrets.io/v1beta1.Device42Provider)* | *(Optional)* Device42 configures this store to sync secrets using the Device42 provider | | `infisical` *[InfisicalProvider](#external-secrets.io/v1beta1.InfisicalProvider)* | *(Optional)* Infisical configures this store to sync secrets using the Infisical provider | | `beyondtrust` *[BeyondtrustProvider](#external-secrets.io/v1beta1.BeyondtrustProvider)* | *(Optional)* Beyondtrust configures this store to sync secrets using Password Safe provider. | | `cloudrusm` *[CloudruSMProvider](#external-secrets.io/v1beta1.CloudruSMProvider)* | *(Optional)* CloudruSM configures this store to sync secrets using the Cloud.ru Secret Manager provider | ### SecretStoreRef (*Appears on:* [ExternalSecretSpec](#external-secrets.io/v1beta1.ExternalSecretSpec), [StoreGeneratorSourceRef](#external-secrets.io/v1beta1.StoreGeneratorSourceRef), [StoreSourceRef](#external-secrets.io/v1beta1.StoreSourceRef)) SecretStoreRef defines which SecretStore to fetch the ExternalSecret data. | Field | Description | | --- | --- | | `name` *string* | Name of the SecretStore resource | | `kind` *string* | *(Optional)* Kind of the SecretStore resource (SecretStore or ClusterSecretStore) Defaults to `SecretStore` | ### SecretStoreRetrySettings (*Appears on:* [SecretStoreSpec](#external-secrets.io/v1beta1.SecretStoreSpec)) SecretStoreRetrySettings defines configuration for retrying failed requests to the provider. | Field | Description | | --- | --- | | `maxRetries` *int32* | MaxRetries is the maximum number of retry attempts. | | `retryInterval` *string* | RetryInterval is the interval between retry attempts. | ### SecretStoreSpec (*Appears on:* [ClusterSecretStore](#external-secrets.io/v1beta1.ClusterSecretStore), [SecretStore](#external-secrets.io/v1beta1.SecretStore)) SecretStoreSpec defines the desired state of SecretStore. | Field | Description | | --- | --- | | `controller` *string* | *(Optional)* Used to select the correct ESO controller (think: ingress.ingressClassName) The ESO controller is instantiated with a specific controller name and filters ES based on this property | | `provider` *[SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)* | Used to configure the provider. Only one provider may be set | | `retrySettings` *[SecretStoreRetrySettings](#external-secrets.io/v1beta1.SecretStoreRetrySettings)* | *(Optional)* Used to configure HTTP retries on failures. | | `refreshInterval` *int* | *(Optional)* Used to configure store refresh interval in seconds. Empty or 0 will default to the controller config. | | `conditions` *[[]ClusterSecretStoreCondition](#external-secrets.io/v1beta1.ClusterSecretStoreCondition)* | *(Optional)* Used to constrain a ClusterSecretStore to specific namespaces. Relevant only to ClusterSecretStore. | ### SecretStoreStatus (*Appears on:* [ClusterSecretStore](#external-secrets.io/v1beta1.ClusterSecretStore), [SecretStore](#external-secrets.io/v1beta1.SecretStore)) SecretStoreStatus defines the observed state of the SecretStore. | Field | Description | | --- | --- | | `conditions` *[[]SecretStoreStatusCondition](#external-secrets.io/v1beta1.SecretStoreStatusCondition)* | *(Optional)* | | `capabilities` *[SecretStoreCapabilities](#external-secrets.io/v1beta1.SecretStoreCapabilities)* | *(Optional)* | ### SecretStoreStatusCondition (*Appears on:* [SecretStoreStatus](#external-secrets.io/v1beta1.SecretStoreStatus)) SecretStoreStatusCondition defines the observed condition of the SecretStore. | Field | Description | | --- | --- | | `type` *[SecretStoreConditionType](#external-secrets.io/v1beta1.SecretStoreConditionType)* | | | `status` *[Kubernetes core/v1.ConditionStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#conditionstatus-v1-core)* | | | `reason` *string* | *(Optional)* | | `message` *string* | *(Optional)* | | `lastTransitionTime` *[Kubernetes meta/v1.Time](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#time-v1-meta)* | *(Optional)* | ### SecretsClient SecretsClient provides access to secrets. ### SecretsManager (*Appears on:* [AWSProvider](#external-secrets.io/v1beta1.AWSProvider)) SecretsManager defines how the provider behaves when interacting with AWS SecretsManager. Some of these settings are only applicable to controlling how secrets are deleted, and hence only apply to PushSecret (and only when deletionPolicy is set to Delete). | Field | Description | | --- | --- | | `forceDeleteWithoutRecovery` *bool* | *(Optional)* Specifies whether to delete the | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.10526450723409653,
-0.019863827154040337,
-0.07595019042491913,
-0.052217982709407806,
0.022180607542395592,
-0.0031955346930772066,
0.028148356825113297,
0.0065061175264418125,
0.011541618965566158,
0.033684443682432175,
0.05551264062523842,
-0.047031208872795105,
0.04079664871096611,
... | 0.074641 |
with AWS SecretsManager. Some of these settings are only applicable to controlling how secrets are deleted, and hence only apply to PushSecret (and only when deletionPolicy is set to Delete). | Field | Description | | --- | --- | | `forceDeleteWithoutRecovery` *bool* | *(Optional)* Specifies whether to delete the secret without any recovery window. You can’t use both this parameter and RecoveryWindowInDays in the same call. If you don’t use either, then by default Secrets Manager uses a 30 day recovery window. see: <https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_DeleteSecret.html#SecretsManager-DeleteSecret-request-ForceDeleteWithoutRecovery> | | `recoveryWindowInDays` *int64* | *(Optional)* The number of days from 7 to 30 that Secrets Manager waits before permanently deleting the secret. You can’t use both this parameter and ForceDeleteWithoutRecovery in the same call. If you don’t use either, then by default Secrets Manager uses a 30 day recovery window. see: <https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_DeleteSecret.html#SecretsManager-DeleteSecret-request-RecoveryWindowInDays> | ### SenhaseguraAuth (*Appears on:* [SenhaseguraProvider](#external-secrets.io/v1beta1.SenhaseguraProvider)) SenhaseguraAuth tells the controller how to do auth in senhasegura. | Field | Description | | --- | --- | | `clientId` *string* | | | `clientSecretSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### SenhaseguraModuleType (`string` alias) (*Appears on:* [SenhaseguraProvider](#external-secrets.io/v1beta1.SenhaseguraProvider)) SenhaseguraModuleType enum defines senhasegura target module to fetch secrets | Value | Description | | --- | --- | | "DSM" | ``` SenhaseguraModuleDSM is the senhasegura DevOps Secrets Management module see: https://senhasegura.com/devops ``` | ### SenhaseguraProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) SenhaseguraProvider setup a store to sync secrets with senhasegura. | Field | Description | | --- | --- | | `url` *string* | URL of senhasegura | | `module` *[SenhaseguraModuleType](#external-secrets.io/v1beta1.SenhaseguraModuleType)* | Module defines which senhasegura module should be used to get secrets | | `auth` *[SenhaseguraAuth](#external-secrets.io/v1beta1.SenhaseguraAuth)* | Auth defines parameters to authenticate in senhasegura | | `ignoreSslCertificate` *bool* | IgnoreSslCertificate defines if SSL certificate must be ignored | ### StoreGeneratorSourceRef (*Appears on:* [ExternalSecretDataFromRemoteRef](#external-secrets.io/v1beta1.ExternalSecretDataFromRemoteRef)) StoreGeneratorSourceRef allows you to override the source from which the secret will be pulled from. You can define at maximum one property. | Field | Description | | --- | --- | | `storeRef` *[SecretStoreRef](#external-secrets.io/v1beta1.SecretStoreRef)* | *(Optional)* | | `generatorRef` *[GeneratorRef](#external-secrets.io/v1beta1.GeneratorRef)* | *(Optional)* GeneratorRef points to a generator custom resource. | ### StoreSourceRef (*Appears on:* [ExternalSecretData](#external-secrets.io/v1beta1.ExternalSecretData)) StoreSourceRef allows you to override the SecretStore source from which the secret will be pulled from. You can define at maximum one property. | Field | Description | | --- | --- | | `storeRef` *[SecretStoreRef](#external-secrets.io/v1beta1.SecretStoreRef)* | *(Optional)* | | `generatorRef` *[GeneratorRef](#external-secrets.io/v1beta1.GeneratorRef)* | GeneratorRef points to a generator custom resource. Deprecated: The generatorRef is not implemented in .data[]. this will be removed with v1. | ### Tag Tag defines a tag key and value for AWS resources. | Field | Description | | --- | --- | | `key` *string* | | | `value` *string* | | ### TemplateEngineVersion (`string` alias) (*Appears on:* [ExternalSecretTemplate](#external-secrets.io/v1beta1.ExternalSecretTemplate)) TemplateEngineVersion defines the version of the template engine to use. | Value | Description | | --- | --- | | "v2" | TemplateEngineV2 specifies the v2 template engine version. | ### TemplateFrom (*Appears on:* [ExternalSecretTemplate](#external-secrets.io/v1beta1.ExternalSecretTemplate)) TemplateFrom defines a source for template data. | Field | Description | | --- | --- | | `configMap` *[TemplateRef](#external-secrets.io/v1beta1.TemplateRef)* | | | `secret` *[TemplateRef](#external-secrets.io/v1beta1.TemplateRef)* | | | `target` *[TemplateTarget](#external-secrets.io/v1beta1.TemplateTarget)* | *(Optional)* | | `literal` *string* | *(Optional)* | ### TemplateMergePolicy (`string` alias) (*Appears on:* [ExternalSecretTemplate](#external-secrets.io/v1beta1.ExternalSecretTemplate)) TemplateMergePolicy defines how template values should be merged when generating a secret. | Value | Description | | --- | --- | | "Merge" | MergePolicyMerge merges the template content with existing values. | | "Replace" | MergePolicyReplace replaces the entire template content during merge operations. | ### TemplateRef (*Appears on:* [TemplateFrom](#external-secrets.io/v1beta1.TemplateFrom)) TemplateRef defines a reference to a template source in a | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.057931702584028244,
-0.0074916924349963665,
0.00031801516888663173,
0.08656254410743713,
0.03303457796573639,
0.0354510098695755,
-0.016440074890851974,
-0.06265129894018173,
0.1107359230518341,
0.03144421800971031,
0.023495759814977646,
-0.0038373987190425396,
0.019114162772893906,
-0.... | -0.046992 |
| Value | Description | | --- | --- | | "Merge" | MergePolicyMerge merges the template content with existing values. | | "Replace" | MergePolicyReplace replaces the entire template content during merge operations. | ### TemplateRef (*Appears on:* [TemplateFrom](#external-secrets.io/v1beta1.TemplateFrom)) TemplateRef defines a reference to a template source in a ConfigMap or Secret. | Field | Description | | --- | --- | | `name` *string* | The name of the ConfigMap/Secret resource | | `items` *[[]TemplateRefItem](#external-secrets.io/v1beta1.TemplateRefItem)* | A list of keys in the ConfigMap/Secret to use as templates for Secret data | ### TemplateRefItem (*Appears on:* [TemplateRef](#external-secrets.io/v1beta1.TemplateRef)) TemplateRefItem defines which key in the referenced ConfigMap or Secret to use as a template. | Field | Description | | --- | --- | | `key` *string* | A key in the ConfigMap/Secret | | `templateAs` *[TemplateScope](#external-secrets.io/v1beta1.TemplateScope)* | | ### TemplateScope (`string` alias) (*Appears on:* [TemplateRefItem](#external-secrets.io/v1beta1.TemplateRefItem)) TemplateScope defines the scope of the template when processing template data. | Value | Description | | --- | --- | | "KeysAndValues" | TemplateScopeKeysAndValues processes both keys and values of the data. | | "Values" | TemplateScopeValues processes only the values of the data. | ### TemplateTarget (`string` alias) (*Appears on:* [TemplateFrom](#external-secrets.io/v1beta1.TemplateFrom)) TemplateTarget defines the target field where the template result will be stored. | Value | Description | | --- | --- | | "Annotations" | TemplateTargetAnnotations stores template results in the annotations field of the secret. | | "Data" | TemplateTargetData stores template results in the data field of the secret. | | "Labels" | TemplateTargetLabels stores template results in the labels field of the secret. | ### TokenAuth (*Appears on:* [KubernetesAuth](#external-secrets.io/v1beta1.KubernetesAuth)) TokenAuth defines token-based authentication for the Kubernetes provider. | Field | Description | | --- | --- | | `bearerToken` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### UniversalAuthCredentials (*Appears on:* [InfisicalAuth](#external-secrets.io/v1beta1.InfisicalAuth)) UniversalAuthCredentials defines the credentials for Infisical Universal Auth. | Field | Description | | --- | --- | | `clientId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `clientSecret` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### ValidationResult (`byte` alias) ValidationResult represents the result of validating a provider client configuration. | Value | Description | | --- | --- | | 2 | ValidationResultError indicates that there is a misconfiguration. | | 0 | ValidationResultReady indicates that the client is configured correctly and can be used. | | 1 | ValidationResultUnknown indicates that the client can be used but information is missing and it can not be validated. | ### VaultAppRole (*Appears on:* [VaultAuth](#external-secrets.io/v1beta1.VaultAuth)) VaultAppRole authenticates with Vault using the App Role auth mechanism, with the role and secret stored in a Kubernetes Secret resource. | Field | Description | | --- | --- | | `path` *string* | Path where the App Role authentication backend is mounted in Vault, e.g: “approle” | | `roleId` *string* | *(Optional)* RoleID configured in the App Role authentication backend when setting up the authentication backend in Vault. | | `roleRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* Reference to a key in a Secret that contains the App Role ID used to authenticate with Vault. The `key` field must be specified and denotes which entry within the Secret resource is used as the app role id. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | Reference to a key in a Secret that contains the App Role secret used to authenticate with Vault. The `key` field must be specified and denotes which entry within the Secret resource is used as the app role secret. | ### VaultAuth (*Appears on:* [VaultProvider](#external-secrets.io/v1beta1.VaultProvider)) VaultAuth is the configuration used to authenticate with a Vault server. Only one of `tokenSecretRef`, `appRole`, `kubernetes`, `ldap`, `userPass`, `jwt` or | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.08864828944206238,
0.057013530284166336,
-0.008723669685423374,
0.04519046097993851,
0.06872747093439102,
0.037805549800395966,
0.032586127519607544,
0.037159666419029236,
-0.006146782077848911,
0.006558030378073454,
0.026901915669441223,
-0.046326857060194016,
0.038118038326501846,
-0.... | 0.073723 |
with Vault. The `key` field must be specified and denotes which entry within the Secret resource is used as the app role secret. | ### VaultAuth (*Appears on:* [VaultProvider](#external-secrets.io/v1beta1.VaultProvider)) VaultAuth is the configuration used to authenticate with a Vault server. Only one of `tokenSecretRef`, `appRole`, `kubernetes`, `ldap`, `userPass`, `jwt` or `cert` can be specified. A namespace to authenticate against can optionally be specified. | Field | Description | | --- | --- | | `namespace` *string* | *(Optional)* Name of the vault namespace to authenticate to. This can be different than the namespace your secret is in. Namespaces is a set of features within Vault Enterprise that allows Vault environments to support Secure Multi-tenancy. e.g: “ns1”. More about namespaces can be found here <https://www.vaultproject.io/docs/enterprise/namespaces> This will default to Vault.Namespace field if set, or empty otherwise | | `tokenSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* TokenSecretRef authenticates with Vault by presenting a token. | | `appRole` *[VaultAppRole](#external-secrets.io/v1beta1.VaultAppRole)* | *(Optional)* AppRole authenticates with Vault using the App Role auth mechanism, with the role and secret stored in a Kubernetes Secret resource. | | `kubernetes` *[VaultKubernetesAuth](#external-secrets.io/v1beta1.VaultKubernetesAuth)* | *(Optional)* Kubernetes authenticates with Vault by passing the ServiceAccount token stored in the named Secret resource to the Vault server. | | `ldap` *[VaultLdapAuth](#external-secrets.io/v1beta1.VaultLdapAuth)* | *(Optional)* Ldap authenticates with Vault by passing username/password pair using the LDAP authentication method | | `jwt` *[VaultJwtAuth](#external-secrets.io/v1beta1.VaultJwtAuth)* | *(Optional)* Jwt authenticates with Vault by passing role and JWT token using the JWT/OIDC authentication method | | `cert` *[VaultCertAuth](#external-secrets.io/v1beta1.VaultCertAuth)* | *(Optional)* Cert authenticates with TLS Certificates by passing client certificate, private key and ca certificate Cert authentication method | | `iam` *[VaultIamAuth](#external-secrets.io/v1beta1.VaultIamAuth)* | *(Optional)* Iam authenticates with vault by passing a special AWS request signed with AWS IAM credentials AWS IAM authentication method | | `userPass` *[VaultUserPassAuth](#external-secrets.io/v1beta1.VaultUserPassAuth)* | *(Optional)* UserPass authenticates with Vault by passing username/password pair | ### VaultAwsAuth VaultAwsAuth tells the controller how to do authentication with aws. Only one of secretRef or jwt can be specified. if none is specified the controller will try to load credentials from its own service account assuming it is IRSA enabled. | Field | Description | | --- | --- | | `secretRef` *[VaultAwsAuthSecretRef](#external-secrets.io/v1beta1.VaultAwsAuthSecretRef)* | *(Optional)* | | `jwt` *[VaultAwsJWTAuth](#external-secrets.io/v1beta1.VaultAwsJWTAuth)* | *(Optional)* | ### VaultAwsAuthSecretRef (*Appears on:* [VaultAwsAuth](#external-secrets.io/v1beta1.VaultAwsAuth), [VaultIamAuth](#external-secrets.io/v1beta1.VaultIamAuth)) VaultAwsAuthSecretRef holds secret references for AWS credentials both AccessKeyID and SecretAccessKey must be defined in order to properly authenticate. | Field | Description | | --- | --- | | `accessKeyIDSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The AccessKeyID is used for authentication | | `secretAccessKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The SecretAccessKey is used for authentication | | `sessionTokenSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The SessionToken used for authentication This must be defined if AccessKeyID and SecretAccessKey are temporary credentials see: <https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html> | ### VaultAwsJWTAuth (*Appears on:* [VaultAwsAuth](#external-secrets.io/v1beta1.VaultAwsAuth), [VaultIamAuth](#external-secrets.io/v1beta1.VaultIamAuth)) VaultAwsJWTAuth Authenticate against AWS using service account tokens. | Field | Description | | --- | --- | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* | ### VaultCertAuth (*Appears on:* [VaultAuth](#external-secrets.io/v1beta1.VaultAuth)) VaultCertAuth authenticates with Vault using the JWT/OIDC authentication method, with the role name and token stored in a Kubernetes Secret resource. | Field | Description | | --- | --- | | `clientCert` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* ClientCert is a certificate to authenticate using the Cert Vault authentication method | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef to a key in a Secret resource containing client private key to authenticate with Vault using the Cert authentication method | ### VaultClientTLS (*Appears on:* [VaultProvider](#external-secrets.io/v1beta1.VaultProvider)) VaultClientTLS is the configuration used for client side related TLS communication, when the Vault server requires mutual authentication. | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.0027707149274647236,
-0.002688803942874074,
-0.04750118404626846,
-0.04342922195792198,
-0.043352141976356506,
-0.04200128838419914,
0.005173734854906797,
0.027402902022004128,
0.08834914118051529,
-0.014438416808843613,
-0.02409655787050724,
-0.06303068995475769,
0.09313283115625381,
0... | 0.01708 |
Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef to a key in a Secret resource containing client private key to authenticate with Vault using the Cert authentication method | ### VaultClientTLS (*Appears on:* [VaultProvider](#external-secrets.io/v1beta1.VaultProvider)) VaultClientTLS is the configuration used for client side related TLS communication, when the Vault server requires mutual authentication. | Field | Description | | --- | --- | | `certSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* CertSecretRef is a certificate added to the transport layer when communicating with the Vault server. If no key for the Secret is specified, external-secret will default to ‘tls.crt’. | | `keySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* KeySecretRef to a key in a Secret resource containing client private key added to the transport layer when communicating with the Vault server. If no key for the Secret is specified, external-secret will default to ‘tls.key’. | ### VaultIamAuth (*Appears on:* [VaultAuth](#external-secrets.io/v1beta1.VaultAuth)) VaultIamAuth authenticates with Vault using the Vault’s AWS IAM authentication method. Refer: <https://developer.hashicorp.com/vault/docs/auth/aws> | Field | Description | | --- | --- | | `path` *string* | *(Optional)* Path where the AWS auth method is enabled in Vault, e.g: “aws” | | `region` *string* | *(Optional)* AWS region | | `role` *string* | *(Optional)* This is the AWS role to be assumed before talking to vault | | `vaultRole` *string* | Vault Role. In vault, a role describes an identity with a set of permissions, groups, or policies you want to attach a user of the secrets engine | | `externalID` *string* | AWS External ID set on assumed IAM roles | | `vaultAwsIamServerID` *string* | *(Optional)* X-Vault-AWS-IAM-Server-ID is an additional header used by Vault IAM auth method to mitigate against different types of replay attacks. More details here: <https://developer.hashicorp.com/vault/docs/auth/aws> | | `secretRef` *[VaultAwsAuthSecretRef](#external-secrets.io/v1beta1.VaultAwsAuthSecretRef)* | *(Optional)* Specify credentials in a Secret object | | `jwt` *[VaultAwsJWTAuth](#external-secrets.io/v1beta1.VaultAwsJWTAuth)* | *(Optional)* Specify a service account with IRSA enabled | ### VaultJwtAuth (*Appears on:* [VaultAuth](#external-secrets.io/v1beta1.VaultAuth)) VaultJwtAuth authenticates with Vault using the JWT/OIDC authentication method, with the role name and a token stored in a Kubernetes Secret resource or a Kubernetes service account token retrieved via `TokenRequest`. | Field | Description | | --- | --- | | `path` *string* | Path where the JWT authentication backend is mounted in Vault, e.g: “jwt” | | `role` *string* | *(Optional)* Role is a JWT role to authenticate using the JWT/OIDC Vault authentication method | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* Optional SecretRef that refers to a key in a Secret resource containing JWT token to authenticate with Vault using the JWT/OIDC authentication method. | | `kubernetesServiceAccountToken` *[VaultKubernetesServiceAccountTokenAuth](#external-secrets.io/v1beta1.VaultKubernetesServiceAccountTokenAuth)* | *(Optional)* Optional ServiceAccountToken specifies the Kubernetes service account for which to request a token for with the `TokenRequest` API. | ### VaultKVStoreVersion (`string` alias) (*Appears on:* [VaultProvider](#external-secrets.io/v1beta1.VaultProvider)) VaultKVStoreVersion defines the version of the KV store in Vault. | Value | Description | | --- | --- | | "v1" | VaultKVStoreV1 represents version 1 of the Vault KV store. | | "v2" | VaultKVStoreV2 represents version 2 of the Vault KV store. | ### VaultKubernetesAuth (*Appears on:* [VaultAuth](#external-secrets.io/v1beta1.VaultAuth)) VaultKubernetesAuth authenticates against Vault using a Kubernetes ServiceAccount token stored in a Secret. | Field | Description | | --- | --- | | `mountPath` *string* | Path where the Kubernetes authentication backend is mounted in Vault, e.g: “kubernetes” | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* Optional service account field containing the name of a kubernetes ServiceAccount. If the service account is specified, the service account secret token JWT will be used for authenticating with Vault. If the service account selector is not supplied, the secretRef will be used instead. | | `secretRef` *[External | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.07609812915325165,
0.05543812736868858,
-0.053763341158628464,
0.006178496405482292,
0.02798907458782196,
-0.04668683931231499,
0.019959649071097374,
0.029261397197842598,
0.10662485659122467,
-0.04926735535264015,
0.033910416066646576,
-0.007006686646491289,
0.05939353629946709,
0.0602... | -0.011987 |
| *(Optional)* Optional service account field containing the name of a kubernetes ServiceAccount. If the service account is specified, the service account secret token JWT will be used for authenticating with Vault. If the service account selector is not supplied, the secretRef will be used instead. | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* Optional secret field containing a Kubernetes ServiceAccount JWT used for authenticating with Vault. If a name is specified without a key, `token` is the default. If one is not specified, the one bound to the controller will be used. | | `role` *string* | A required field containing the Vault Role to assume. A Role binds a Kubernetes ServiceAccount with a set of Vault policies. | ### VaultKubernetesServiceAccountTokenAuth (*Appears on:* [VaultJwtAuth](#external-secrets.io/v1beta1.VaultJwtAuth)) VaultKubernetesServiceAccountTokenAuth authenticates with Vault using a temporary Kubernetes service account token retrieved by the `TokenRequest` API. | Field | Description | | --- | --- | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | Service account field containing the name of a kubernetes ServiceAccount. | | `audiences` *[]string* | *(Optional)* Optional audiences field that will be used to request a temporary Kubernetes service account token for the service account referenced by `serviceAccountRef`. Defaults to a single audience `vault` it not specified. Deprecated: use serviceAccountRef.Audiences instead | | `expirationSeconds` *int64* | *(Optional)* Optional expiration time in seconds that will be used to request a temporary Kubernetes service account token for the service account referenced by `serviceAccountRef`. Deprecated: this will be removed in the future. Defaults to 10 minutes. | ### VaultLdapAuth (*Appears on:* [VaultAuth](#external-secrets.io/v1beta1.VaultAuth)) VaultLdapAuth authenticates with Vault using the LDAP authentication method, with the username and password stored in a Kubernetes Secret resource. | Field | Description | | --- | --- | | `path` *string* | Path where the LDAP authentication backend is mounted in Vault, e.g: “ldap” | | `username` *string* | Username is an LDAP username used to authenticate using the LDAP Vault authentication method | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef to a key in a Secret resource containing password for the LDAP user used to authenticate with Vault using the LDAP authentication method | ### VaultProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) VaultProvider configures a store to sync secrets using a HashiCorp Vault KV backend. | Field | Description | | --- | --- | | `auth` *[VaultAuth](#external-secrets.io/v1beta1.VaultAuth)* | Auth configures how secret-manager authenticates with the Vault server. | | `server` *string* | Server is the connection address for the Vault server, e.g: “[https://vault.example.com:8200”](https://vault.example.com:8200"). | | `path` *string* | *(Optional)* Path is the mount path of the Vault KV backend endpoint, e.g: “secret”. The v2 KV secret engine version specific “/data” path suffix for fetching secrets from Vault is optional and will be appended if not present in specified path. | | `version` *[VaultKVStoreVersion](#external-secrets.io/v1beta1.VaultKVStoreVersion)* | Version is the Vault KV secret engine version. This can be either “v1” or “v2”. Version defaults to “v2”. | | `namespace` *string* | *(Optional)* Name of the vault namespace. Namespaces is a set of features within Vault Enterprise that allows Vault environments to support Secure Multi-tenancy. e.g: “ns1”. More about namespaces can be found here <https://www.vaultproject.io/docs/enterprise/namespaces> | | `caBundle` *[]byte* | *(Optional)* PEM encoded CA bundle used to validate Vault server certificate. Only used if the Server URL is using HTTPS protocol. This parameter is ignored for plain HTTP protocol connection. If not set the system root certificates are used to validate the TLS connection. | | `tls` *[VaultClientTLS](#external-secrets.io/v1beta1.VaultClientTLS)* | *(Optional)* The configuration used for client side related TLS communication, when the Vault server requires mutual authentication. Only used if the Server URL is using HTTPS protocol. | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.06843015551567078,
0.011303607374429703,
-0.0010304837487637997,
-0.03953108191490173,
-0.006872282829135656,
0.024504419416189194,
0.03831728547811508,
0.0015141295734792948,
0.11731956154108047,
-0.0010475621093064547,
0.01601528562605381,
-0.06479571759700775,
0.048413775861263275,
-... | 0.076309 |
plain HTTP protocol connection. If not set the system root certificates are used to validate the TLS connection. | | `tls` *[VaultClientTLS](#external-secrets.io/v1beta1.VaultClientTLS)* | *(Optional)* The configuration used for client side related TLS communication, when the Vault server requires mutual authentication. Only used if the Server URL is using HTTPS protocol. This parameter is ignored for plain HTTP protocol connection. It’s worth noting this configuration is different from the “TLS certificates auth method”, which is available under the `auth.cert` section. | | `caProvider` *[CAProvider](#external-secrets.io/v1beta1.CAProvider)* | *(Optional)* The provider for the CA bundle to use to validate Vault server certificate. | | `readYourWrites` *bool* | *(Optional)* ReadYourWrites ensures isolated read-after-write semantics by providing discovered cluster replication states in each request. More information about eventual consistency in Vault can be found here <https://www.vaultproject.io/docs/enterprise/consistency> | | `forwardInconsistent` *bool* | *(Optional)* ForwardInconsistent tells Vault to forward read-after-write requests to the Vault leader instead of simply retrying within a loop. This can increase performance if the option is enabled serverside. <https://www.vaultproject.io/docs/configuration/replication#allow_forwarding_via_header> | | `headers` *map[string]string* | *(Optional)* Headers to be added in Vault request | ### VaultUserPassAuth (*Appears on:* [VaultAuth](#external-secrets.io/v1beta1.VaultAuth)) VaultUserPassAuth authenticates with Vault using UserPass authentication method, with the username and password stored in a Kubernetes Secret resource. | Field | Description | | --- | --- | | `path` *string* | Path where the UserPassword authentication backend is mounted in Vault, e.g: “userpass” | | `username` *string* | Username is a username used to authenticate using the UserPass Vault authentication method | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* SecretRef to a key in a Secret resource containing password for the user used to authenticate with Vault using the UserPass authentication method | ### WebhookCAProvider (*Appears on:* [WebhookProvider](#external-secrets.io/v1beta1.WebhookProvider)) WebhookCAProvider defines a location to fetch the certificate for the webhook provider. | Field | Description | | --- | --- | | `type` *[WebhookCAProviderType](#external-secrets.io/v1beta1.WebhookCAProviderType)* | The type of provider to use such as “Secret”, or “ConfigMap”. | | `name` *string* | The name of the object located at the provider type. | | `key` *string* | The key where the CA certificate can be found in the Secret or ConfigMap. | | `namespace` *string* | *(Optional)* The namespace the Provider type is in. | ### WebhookCAProviderType (`string` alias) (*Appears on:* [WebhookCAProvider](#external-secrets.io/v1beta1.WebhookCAProvider)) WebhookCAProviderType defines the type of provider to use for CA certificates with Webhook providers. | Value | Description | | --- | --- | | "ConfigMap" | WebhookCAProviderTypeConfigMap indicates that the CA certificate is stored in a ConfigMap. | | "Secret" | WebhookCAProviderTypeSecret indicates that the CA certificate is stored in a Secret. | ### WebhookProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) WebhookProvider configures a store to sync secrets from simple web APIs. | Field | Description | | --- | --- | | `method` *string* | Webhook Method | | `url` *string* | Webhook url to call | | `headers` *map[string]string* | *(Optional)* Headers | | `auth` *[AuthorizationProtocol](#external-secrets.io/v1beta1.AuthorizationProtocol)* | *(Optional)* Auth specifies a authorization protocol. Only one protocol may be set. | | `body` *string* | *(Optional)* Body | | `timeout` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | *(Optional)* Timeout | | `result` *[WebhookResult](#external-secrets.io/v1beta1.WebhookResult)* | Result formatting | | `secrets` *[[]WebhookSecret](#external-secrets.io/v1beta1.WebhookSecret)* | *(Optional)* Secrets to fill in templates These secrets will be passed to the templating function as key value pairs under the given name | | `caBundle` *[]byte* | *(Optional)* PEM encoded CA bundle used to validate webhook server certificate. Only used if the Server URL is using HTTPS protocol. This parameter is ignored for plain HTTP protocol connection. If not set the system root certificates are used to validate the TLS connection. | | `caProvider` *[WebhookCAProvider](#external-secrets.io/v1beta1.WebhookCAProvider)* | *(Optional)* | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.0002954718947876245,
0.04352777078747749,
-0.06266414374113083,
-0.018078763037919998,
-0.022528642788529396,
-0.07595109939575195,
-0.07649786025285721,
-0.012639750726521015,
0.10666114836931229,
-0.0312526561319828,
0.017618393525481224,
0.022220635786652565,
0.08882485330104828,
0.0... | -0.056691 |
*(Optional)* PEM encoded CA bundle used to validate webhook server certificate. Only used if the Server URL is using HTTPS protocol. This parameter is ignored for plain HTTP protocol connection. If not set the system root certificates are used to validate the TLS connection. | | `caProvider` *[WebhookCAProvider](#external-secrets.io/v1beta1.WebhookCAProvider)* | *(Optional)* The provider for the CA bundle to use to validate webhook server certificate. | ### WebhookResult (*Appears on:* [WebhookProvider](#external-secrets.io/v1beta1.WebhookProvider)) WebhookResult defines how to extract and format the result from the webhook response. | Field | Description | | --- | --- | | `jsonPath` *string* | *(Optional)* Json path of return value | ### WebhookSecret (*Appears on:* [WebhookProvider](#external-secrets.io/v1beta1.WebhookProvider)) WebhookSecret defines a secret to be used in webhook templates. | Field | Description | | --- | --- | | `name` *string* | Name of this secret in templates | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | Secret ref to fill in credentials | ### YandexCertificateManagerAuth (*Appears on:* [YandexCertificateManagerProvider](#external-secrets.io/v1beta1.YandexCertificateManagerProvider)) YandexCertificateManagerAuth defines authentication configuration for the Yandex Certificate Manager provider. | Field | Description | | --- | --- | | `authorizedKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The authorized key used for authentication | ### YandexCertificateManagerCAProvider (*Appears on:* [YandexCertificateManagerProvider](#external-secrets.io/v1beta1.YandexCertificateManagerProvider)) YandexCertificateManagerCAProvider defines CA certificate configuration for Yandex Certificate Manager. | Field | Description | | --- | --- | | `certSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### YandexCertificateManagerProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) YandexCertificateManagerProvider configures a store to sync secrets using the Yandex Certificate Manager provider. | Field | Description | | --- | --- | | `apiEndpoint` *string* | *(Optional)* Yandex.Cloud API endpoint (e.g. ‘api.cloud.yandex.net:443’) | | `auth` *[YandexCertificateManagerAuth](#external-secrets.io/v1beta1.YandexCertificateManagerAuth)* | Auth defines the information necessary to authenticate against Yandex Certificate Manager | | `caProvider` *[YandexCertificateManagerCAProvider](#external-secrets.io/v1beta1.YandexCertificateManagerCAProvider)* | *(Optional)* The provider for the CA bundle to use to validate Yandex.Cloud server certificate. | ### YandexLockboxAuth (*Appears on:* [YandexLockboxProvider](#external-secrets.io/v1beta1.YandexLockboxProvider)) YandexLockboxAuth defines authentication configuration for the Yandex Lockbox provider. | Field | Description | | --- | --- | | `authorizedKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The authorized key used for authentication | ### YandexLockboxCAProvider (*Appears on:* [YandexLockboxProvider](#external-secrets.io/v1beta1.YandexLockboxProvider)) YandexLockboxCAProvider defines CA certificate configuration for Yandex Lockbox. | Field | Description | | --- | --- | | `certSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### YandexLockboxProvider (*Appears on:* [SecretStoreProvider](#external-secrets.io/v1beta1.SecretStoreProvider)) YandexLockboxProvider configures a store to sync secrets using the Yandex Lockbox provider. | Field | Description | | --- | --- | | `apiEndpoint` *string* | *(Optional)* Yandex.Cloud API endpoint (e.g. ‘api.cloud.yandex.net:443’) | | `auth` *[YandexLockboxAuth](#external-secrets.io/v1beta1.YandexLockboxAuth)* | Auth defines the information necessary to authenticate against Yandex Lockbox | | `caProvider` *[YandexLockboxCAProvider](#external-secrets.io/v1beta1.YandexLockboxCAProvider)* | *(Optional)* The provider for the CA bundle to use to validate Yandex.Cloud server certificate. | --- ## generators.external-secrets.io/v1alpha1 Package v1alpha1 contains resources for generators Resource Types: ### ACRAccessToken ACRAccessToken returns an Azure Container Registry token that can be used for pushing/pulling images. Note: by default it will return an ACR Refresh Token with full access (depending on the identity). This can be scoped down to the repository level using .spec.scope. In case scope is defined it will return an ACR Access Token. See docs: <https://github.com/Azure/acr/blob/main/docs/AAD-OAuth.md> | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[ACRAccessTokenSpec](#generators.external-secrets.io/v1alpha1.ACRAccessTokenSpec)* | | `auth` *[ACRAuth](#generators.external-secrets.io/v1alpha1.ACRAuth)* | | | --- | --- | | `tenantId` *string* | TenantID configures the Azure Tenant to send requests to. Required for ServicePrincipal auth type. | | `registry` *string* | the domain name of the ACR registry e.g. foobarexample.azurecr.io | | `scope` *string* | *(Optional)* Define the scope for the access token, e.g. pull/push access for a repository. | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.11399620771408081,
0.14259406924247742,
-0.06251142174005508,
-0.009576953016221523,
0.01602843403816223,
-0.08508121222257614,
-0.026436002925038338,
-0.016387566924095154,
0.04322589188814163,
-0.015846705064177513,
0.03722856566309929,
-0.14790482819080353,
0.04984867200255394,
0.009... | 0.025825 |
`tenantId` *string* | TenantID configures the Azure Tenant to send requests to. Required for ServicePrincipal auth type. | | `registry` *string* | the domain name of the ACR registry e.g. foobarexample.azurecr.io | | `scope` *string* | *(Optional)* Define the scope for the access token, e.g. pull/push access for a repository. if not provided it will return a refresh token that has full scope. Note: you need to pin it down to the repository level, there is no wildcard available. examples: repository:my-repository:pull,push repository:my-repository:pull see docs for details: <https://docs.docker.com/registry/spec/auth/scope/> | | `environmentType` *[AzureEnvironmentType](#external-secrets.io/v1.AzureEnvironmentType)* | EnvironmentType specifies the Azure cloud environment endpoints to use for connecting and authenticating with Azure. By default, it points to the public cloud AAD endpoint. The following endpoints are available, also see here: <https://github.com/Azure/go-autorest/blob/main/autorest/azure/environments.go#L152> PublicCloud, USGovernmentCloud, ChinaCloud, GermanCloud | | ### ACRAccessTokenSpec (*Appears on:* [ACRAccessToken](#generators.external-secrets.io/v1alpha1.ACRAccessToken), [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec)) ACRAccessTokenSpec defines how to generate the access token e.g. how to authenticate and which registry to use. see: <https://github.com/Azure/acr/blob/main/docs/AAD-OAuth.md#overview> | Field | Description | | --- | --- | | `auth` *[ACRAuth](#generators.external-secrets.io/v1alpha1.ACRAuth)* | | | `tenantId` *string* | TenantID configures the Azure Tenant to send requests to. Required for ServicePrincipal auth type. | | `registry` *string* | the domain name of the ACR registry e.g. foobarexample.azurecr.io | | `scope` *string* | *(Optional)* Define the scope for the access token, e.g. pull/push access for a repository. if not provided it will return a refresh token that has full scope. Note: you need to pin it down to the repository level, there is no wildcard available. examples: repository:my-repository:pull,push repository:my-repository:pull see docs for details: <https://docs.docker.com/registry/spec/auth/scope/> | | `environmentType` *[AzureEnvironmentType](#external-secrets.io/v1.AzureEnvironmentType)* | EnvironmentType specifies the Azure cloud environment endpoints to use for connecting and authenticating with Azure. By default, it points to the public cloud AAD endpoint. The following endpoints are available, also see here: <https://github.com/Azure/go-autorest/blob/main/autorest/azure/environments.go#L152> PublicCloud, USGovernmentCloud, ChinaCloud, GermanCloud | ### ACRAuth (*Appears on:* [ACRAccessTokenSpec](#generators.external-secrets.io/v1alpha1.ACRAccessTokenSpec)) ACRAuth defines the authentication methods for Azure Container Registry. | Field | Description | | --- | --- | | `servicePrincipal` *[AzureACRServicePrincipalAuth](#generators.external-secrets.io/v1alpha1.AzureACRServicePrincipalAuth)* | *(Optional)* ServicePrincipal uses Azure Service Principal credentials to authenticate with Azure. | | `managedIdentity` *[AzureACRManagedIdentityAuth](#generators.external-secrets.io/v1alpha1.AzureACRManagedIdentityAuth)* | *(Optional)* ManagedIdentity uses Azure Managed Identity to authenticate with Azure. | | `workloadIdentity` *[AzureACRWorkloadIdentityAuth](#generators.external-secrets.io/v1alpha1.AzureACRWorkloadIdentityAuth)* | *(Optional)* WorkloadIdentity uses Azure Workload Identity to authenticate with Azure. | ### AWSAuth (*Appears on:* [ECRAuthorizationTokenSpec](#generators.external-secrets.io/v1alpha1.ECRAuthorizationTokenSpec), [STSSessionTokenSpec](#generators.external-secrets.io/v1alpha1.STSSessionTokenSpec)) AWSAuth tells the controller how to do authentication with aws. Only one of secretRef or jwt can be specified. if none is specified the controller will load credentials using the aws sdk defaults. | Field | Description | | --- | --- | | `secretRef` *[AWSAuthSecretRef](#generators.external-secrets.io/v1alpha1.AWSAuthSecretRef)* | *(Optional)* | | `jwt` *[AWSJWTAuth](#generators.external-secrets.io/v1alpha1.AWSJWTAuth)* | *(Optional)* | ### AWSAuthSecretRef (*Appears on:* [AWSAuth](#generators.external-secrets.io/v1alpha1.AWSAuth)) AWSAuthSecretRef holds secret references for AWS credentials both AccessKeyID and SecretAccessKey must be defined in order to properly authenticate. | Field | Description | | --- | --- | | `accessKeyIDSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The AccessKeyID is used for authentication | | `secretAccessKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The SecretAccessKey is used for authentication | | `sessionTokenSecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The SessionToken used for authentication This must be defined if AccessKeyID and SecretAccessKey are temporary credentials see: <https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html> | ### AWSJWTAuth (*Appears on:* [AWSAuth](#generators.external-secrets.io/v1alpha1.AWSAuth)) AWSJWTAuth provides configuration to authenticate against AWS using service account tokens. | Field | Description | | --- | --- | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | | ### AuthorizationProtocol (*Appears on:* [WebhookSpec](#generators.external-secrets.io/v1alpha1.WebhookSpec)) AuthorizationProtocol contains the protocol-specific configuration | Field | Description | | --- | --- | | `ntlm` *[NTLMProtocol](#generators.external-secrets.io/v1alpha1.NTLMProtocol)* | *(Optional)* NTLMProtocol configures the store to use NTLM for auth | ### AzureACRManagedIdentityAuth (*Appears on:* [ACRAuth](#generators.external-secrets.io/v1alpha1.ACRAuth)) AzureACRManagedIdentityAuth defines the configuration for using Azure | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.053964413702487946,
-0.003744155168533325,
-0.03218415006995201,
0.02794293686747551,
-0.04420674592256546,
-0.006609160453081131,
0.0030221259221434593,
-0.03961994871497154,
0.06641438603401184,
0.08362467586994171,
0.009731052443385124,
-0.05869535356760025,
0.04880537837743759,
0.02... | 0.000287 |
meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | | ### AuthorizationProtocol (*Appears on:* [WebhookSpec](#generators.external-secrets.io/v1alpha1.WebhookSpec)) AuthorizationProtocol contains the protocol-specific configuration | Field | Description | | --- | --- | | `ntlm` *[NTLMProtocol](#generators.external-secrets.io/v1alpha1.NTLMProtocol)* | *(Optional)* NTLMProtocol configures the store to use NTLM for auth | ### AzureACRManagedIdentityAuth (*Appears on:* [ACRAuth](#generators.external-secrets.io/v1alpha1.ACRAuth)) AzureACRManagedIdentityAuth defines the configuration for using Azure Managed Identity authentication. | Field | Description | | --- | --- | | `identityId` *string* | If multiple Managed Identity is assigned to the pod, you can select the one to be used | ### AzureACRServicePrincipalAuth (*Appears on:* [ACRAuth](#generators.external-secrets.io/v1alpha1.ACRAuth)) AzureACRServicePrincipalAuth defines the configuration for using Azure Service Principal authentication. | Field | Description | | --- | --- | | `secretRef` *[AzureACRServicePrincipalAuthSecretRef](#generators.external-secrets.io/v1alpha1.AzureACRServicePrincipalAuthSecretRef)* | | ### AzureACRServicePrincipalAuthSecretRef (*Appears on:* [AzureACRServicePrincipalAuth](#generators.external-secrets.io/v1alpha1.AzureACRServicePrincipalAuth)) AzureACRServicePrincipalAuthSecretRef defines the secret references for Azure Service Principal authentication. It uses static credentials stored in a Kind=Secret. | Field | Description | | --- | --- | | `clientId` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The Azure clientId of the service principle used for authentication. | | `clientSecret` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | The Azure ClientSecret of the service principle used for authentication. | ### AzureACRWorkloadIdentityAuth (*Appears on:* [ACRAuth](#generators.external-secrets.io/v1alpha1.ACRAuth)) AzureACRWorkloadIdentityAuth defines the configuration for using Azure Workload Identity authentication. | Field | Description | | --- | --- | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | *(Optional)* ServiceAccountRef specified the service account that should be used when authenticating with WorkloadIdentity. | ### CloudsmithAccessToken CloudsmithAccessToken generates Cloudsmith access token using OIDC authentication | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[CloudsmithAccessTokenSpec](#generators.external-secrets.io/v1alpha1.CloudsmithAccessTokenSpec)* | | `apiUrl` *string* | APIURL configures the Cloudsmith API URL. Defaults to <https://api.cloudsmith.io>. | | --- | --- | | `orgSlug` *string* | OrgSlug is the organization slug in Cloudsmith | | `serviceSlug` *string* | ServiceSlug is the service slug in Cloudsmith for OIDC authentication | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | Name of the service account you are federating with | | ### CloudsmithAccessTokenSpec (*Appears on:* [CloudsmithAccessToken](#generators.external-secrets.io/v1alpha1.CloudsmithAccessToken), [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec)) CloudsmithAccessTokenSpec defines the configuration for generating a Cloudsmith access token using OIDC authentication. | Field | Description | | --- | --- | | `apiUrl` *string* | APIURL configures the Cloudsmith API URL. Defaults to <https://api.cloudsmith.io>. | | `orgSlug` *string* | OrgSlug is the organization slug in Cloudsmith | | `serviceSlug` *string* | ServiceSlug is the service slug in Cloudsmith for OIDC authentication | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | Name of the service account you are federating with | ### ClusterGenerator ClusterGenerator represents a cluster-wide generator which can be referenced as part of `generatorRef` fields. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[ClusterGeneratorSpec](#generators.external-secrets.io/v1alpha1.ClusterGeneratorSpec)* | | `kind` *[GeneratorKind](#generators.external-secrets.io/v1alpha1.GeneratorKind)* | Kind the kind of this generator. | | --- | --- | | `generator` *[GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec)* | Generator the spec for this generator, must match the kind. | | ### ClusterGeneratorSpec (*Appears on:* [ClusterGenerator](#generators.external-secrets.io/v1alpha1.ClusterGenerator)) ClusterGeneratorSpec defines the desired state of a ClusterGenerator. | Field | Description | | --- | --- | | `kind` *[GeneratorKind](#generators.external-secrets.io/v1alpha1.GeneratorKind)* | Kind the kind of this generator. | | `generator` *[GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec)* | Generator the spec for this generator, must match the kind. | ### ControllerClassResource ControllerClassResource defines a resource that can be assigned to a specific controller class. | Field | Description | | --- | --- | | `spec` *struct{ControllerClass string "json:\"controller\""}* | | `controller` *string* | | | --- | --- | | ### ECRAuthorizationToken ECRAuthorizationToken uses the GetAuthorizationToken API to | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.11799629032611847,
0.02214602753520012,
-0.08774466067552567,
0.023211920633912086,
-0.006839456502348185,
0.01962972618639469,
0.06301286071538925,
-0.03583035618066788,
0.05179399251937866,
0.10341858118772507,
0.02852579765021801,
-0.05837344750761986,
0.08141878247261047,
0.01775308... | 0.065158 |
### ControllerClassResource ControllerClassResource defines a resource that can be assigned to a specific controller class. | Field | Description | | --- | --- | | `spec` *struct{ControllerClass string "json:\"controller\""}* | | `controller` *string* | | | --- | --- | | ### ECRAuthorizationToken ECRAuthorizationToken uses the GetAuthorizationToken API to retrieve an authorization token. The authorization token is valid for 12 hours. The authorizationToken returned is a base64 encoded string that can be decoded and used in a docker login command to authenticate to a registry. For more information, see Registry authentication (<https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth>) in the Amazon Elastic Container Registry User Guide. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[ECRAuthorizationTokenSpec](#generators.external-secrets.io/v1alpha1.ECRAuthorizationTokenSpec)* | | `region` *string* | Region specifies the region to operate in. | | --- | --- | | `auth` *[AWSAuth](#generators.external-secrets.io/v1alpha1.AWSAuth)* | *(Optional)* Auth defines how to authenticate with AWS | | `role` *string* | *(Optional)* You can assume a role before making calls to the desired AWS service. | | `scope` *string* | *(Optional)* Scope specifies the ECR service scope. Valid options are private and public. | | ### ECRAuthorizationTokenSpec (*Appears on:* [ECRAuthorizationToken](#generators.external-secrets.io/v1alpha1.ECRAuthorizationToken), [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec)) ECRAuthorizationTokenSpec defines the desired state to generate an AWS ECR authorization token. | Field | Description | | --- | --- | | `region` *string* | Region specifies the region to operate in. | | `auth` *[AWSAuth](#generators.external-secrets.io/v1alpha1.AWSAuth)* | *(Optional)* Auth defines how to authenticate with AWS | | `role` *string* | *(Optional)* You can assume a role before making calls to the desired AWS service. | | `scope` *string* | *(Optional)* Scope specifies the ECR service scope. Valid options are private and public. | ### Fake Fake generator is used for testing. It lets you define a static set of credentials that is always returned. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[FakeSpec](#generators.external-secrets.io/v1alpha1.FakeSpec)* | | `controller` *string* | *(Optional)* Used to select the correct ESO controller (think: ingress.ingressClassName) The ESO controller is instantiated with a specific controller name and filters VDS based on this property | | --- | --- | | `data` *map[string]string* | Data defines the static data returned by this generator. | | ### FakeSpec (*Appears on:* [Fake](#generators.external-secrets.io/v1alpha1.Fake), [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec)) FakeSpec contains the static data. | Field | Description | | --- | --- | | `controller` *string* | *(Optional)* Used to select the correct ESO controller (think: ingress.ingressClassName) The ESO controller is instantiated with a specific controller name and filters VDS based on this property | | `data` *map[string]string* | Data defines the static data returned by this generator. | ### GCPSMAuth (*Appears on:* [GCRAccessTokenSpec](#generators.external-secrets.io/v1alpha1.GCRAccessTokenSpec)) GCPSMAuth defines the authentication methods for Google Cloud Platform. | Field | Description | | --- | --- | | `secretRef` *[GCPSMAuthSecretRef](#generators.external-secrets.io/v1alpha1.GCPSMAuthSecretRef)* | *(Optional)* | | `workloadIdentity` *[GCPWorkloadIdentity](#generators.external-secrets.io/v1alpha1.GCPWorkloadIdentity)* | *(Optional)* | | `workloadIdentityFederation` *[GCPWorkloadIdentityFederation](#external-secrets.io/v1.GCPWorkloadIdentityFederation)* | *(Optional)* | ### GCPSMAuthSecretRef (*Appears on:* [GCPSMAuth](#generators.external-secrets.io/v1alpha1.GCPSMAuth)) GCPSMAuthSecretRef defines the reference to a secret containing Google Cloud Platform credentials. | Field | Description | | --- | --- | | `secretAccessKeySecretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | *(Optional)* The SecretAccessKey is used for authentication | ### GCPWorkloadIdentity (*Appears on:* [GCPSMAuth](#generators.external-secrets.io/v1alpha1.GCPSMAuth)) GCPWorkloadIdentity defines the configuration for using GCP Workload Identity authentication. | Field | Description | | --- | --- | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | | | `clusterLocation` *string* | | | `clusterName` *string* | | | `clusterProjectID` *string* | | ### GCRAccessToken GCRAccessToken generates an | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.009316787123680115,
0.055038243532180786,
-0.08644577115774155,
-0.034347858279943466,
0.048080362379550934,
0.017300745472311974,
0.011195401661098003,
0.013323573395609856,
0.05020299553871155,
0.03249092400074005,
-0.03412453085184097,
-0.059886470437049866,
0.009195825085043907,
-0.... | 0.019291 |
(*Appears on:* [GCPSMAuth](#generators.external-secrets.io/v1alpha1.GCPSMAuth)) GCPWorkloadIdentity defines the configuration for using GCP Workload Identity authentication. | Field | Description | | --- | --- | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | | | `clusterLocation` *string* | | | `clusterName` *string* | | | `clusterProjectID` *string* | | ### GCRAccessToken GCRAccessToken generates an GCP access token that can be used to authenticate with GCR. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[GCRAccessTokenSpec](#generators.external-secrets.io/v1alpha1.GCRAccessTokenSpec)* | | `auth` *[GCPSMAuth](#generators.external-secrets.io/v1alpha1.GCPSMAuth)* | Auth defines the means for authenticating with GCP | | --- | --- | | `projectID` *string* | ProjectID defines which project to use to authenticate with | | ### GCRAccessTokenSpec (*Appears on:* [GCRAccessToken](#generators.external-secrets.io/v1alpha1.GCRAccessToken), [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec)) GCRAccessTokenSpec defines the desired state to generate a Google Container Registry access token. | Field | Description | | --- | --- | | `auth` *[GCPSMAuth](#generators.external-secrets.io/v1alpha1.GCPSMAuth)* | Auth defines the means for authenticating with GCP | | `projectID` *string* | ProjectID defines which project to use to authenticate with | ### Generator Generator is the common interface for all generators that is actually used to generate whatever is needed. ### GeneratorKind (`string` alias) (*Appears on:* [ClusterGeneratorSpec](#generators.external-secrets.io/v1alpha1.ClusterGeneratorSpec)) GeneratorKind represents a kind of generator. | Value | Description | | --- | --- | | "ACRAccessToken" | GeneratorKindACRAccessToken represents an Azure Container Registry access token generator. | | "CloudsmithAccessToken" | GeneratorKindCloudsmithAccessToken represents a Cloudsmith access token generator. | | "ECRAuthorizationToken" | GeneratorKindECRAuthorizationToken represents an AWS ECR authorization token generator. | | "Fake" | GeneratorKindFake represents a fake generator for testing purposes. | | "GCRAccessToken" | GeneratorKindGCRAccessToken represents a Google Container Registry access token generator. | | "GithubAccessToken" | GeneratorKindGithubAccessToken represents a GitHub access token generator. | | "Grafana" | GeneratorKindGrafana represents a Grafana token generator. | | "MFA" | GeneratorKindMFA represents a Multi-Factor Authentication generator. | | "Password" | GeneratorKindPassword represents a password generator. | | "QuayAccessToken" | GeneratorKindQuayAccessToken represents a Quay access token generator. | | "SSHKey" | GeneratorKindSSHKey represents an SSH key generator. | | "STSSessionToken" | GeneratorKindSTSSessionToken represents an AWS STS session token generator. | | "UUID" | GeneratorKindUUID represents a UUID generator. | | "VaultDynamicSecret" | GeneratorKindVaultDynamicSecret represents a HashiCorp Vault dynamic secret generator. | | "Webhook" | GeneratorKindWebhook represents a webhook-based generator. | ### GeneratorProviderState GeneratorProviderState represents the state of a generator provider that can be stored and retrieved. ### GeneratorSpec (*Appears on:* [ClusterGeneratorSpec](#generators.external-secrets.io/v1alpha1.ClusterGeneratorSpec)) GeneratorSpec defines the configuration for various supported generator types. | Field | Description | | --- | --- | | `acrAccessTokenSpec` *[ACRAccessTokenSpec](#generators.external-secrets.io/v1alpha1.ACRAccessTokenSpec)* | | | `cloudsmithAccessTokenSpec` *[CloudsmithAccessTokenSpec](#generators.external-secrets.io/v1alpha1.CloudsmithAccessTokenSpec)* | | | `ecrAuthorizationTokenSpec` *[ECRAuthorizationTokenSpec](#generators.external-secrets.io/v1alpha1.ECRAuthorizationTokenSpec)* | | | `fakeSpec` *[FakeSpec](#generators.external-secrets.io/v1alpha1.FakeSpec)* | | | `gcrAccessTokenSpec` *[GCRAccessTokenSpec](#generators.external-secrets.io/v1alpha1.GCRAccessTokenSpec)* | | | `githubAccessTokenSpec` *[GithubAccessTokenSpec](#generators.external-secrets.io/v1alpha1.GithubAccessTokenSpec)* | | | `quayAccessTokenSpec` *[QuayAccessTokenSpec](#generators.external-secrets.io/v1alpha1.QuayAccessTokenSpec)* | | | `passwordSpec` *[PasswordSpec](#generators.external-secrets.io/v1alpha1.PasswordSpec)* | | | `sshKeySpec` *[SSHKeySpec](#generators.external-secrets.io/v1alpha1.SSHKeySpec)* | | | `stsSessionTokenSpec` *[STSSessionTokenSpec](#generators.external-secrets.io/v1alpha1.STSSessionTokenSpec)* | | | `uuidSpec` *[UUIDSpec](#generators.external-secrets.io/v1alpha1.UUIDSpec)* | | | `vaultDynamicSecretSpec` *[VaultDynamicSecretSpec](#generators.external-secrets.io/v1alpha1.VaultDynamicSecretSpec)* | | | `webhookSpec` *[WebhookSpec](#generators.external-secrets.io/v1alpha1.WebhookSpec)* | | | `grafanaSpec` *[GrafanaSpec](#generators.external-secrets.io/v1alpha1.GrafanaSpec)* | | | `mfaSpec` *[MFASpec](#generators.external-secrets.io/v1alpha1.MFASpec)* | | ### GeneratorState GeneratorState represents the state created and managed by a generator resource. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[GeneratorStateSpec](#generators.external-secrets.io/v1alpha1.GeneratorStateSpec)* | | `garbageCollectionDeadline` *[Kubernetes meta/v1.Time](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#time-v1-meta)* | GarbageCollectionDeadline is the time after which the generator state will be deleted. It is set by the controller which creates the generator state and can be set configured by the user. If the garbage collection deadline is not set the generator state will not be | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.08607880026102066,
-0.024709532037377357,
-0.00439470773562789,
-0.03504408895969391,
-0.0584169365465641,
0.024751687422394753,
0.06650765240192413,
0.010627764277160168,
0.025100400671362877,
0.021387014538049698,
-0.012733829207718372,
-0.05122464895248413,
0.015129840932786465,
0.00... | 0.110564 |
| `garbageCollectionDeadline` *[Kubernetes meta/v1.Time](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#time-v1-meta)* | GarbageCollectionDeadline is the time after which the generator state will be deleted. It is set by the controller which creates the generator state and can be set configured by the user. If the garbage collection deadline is not set the generator state will not be deleted. | | --- | --- | | `resource` *k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSON* | Resource is the generator manifest that produced the state. It is a snapshot of the generator manifest at the time the state was produced. This manifest will be used to delete the resource. Any configuration that is referenced in the manifest should be available at the time of garbage collection. If that is not the case deletion will be blocked by a finalizer. | | `state` *k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSON* | State is the state that was produced by the generator implementation. | | | `status` *[GeneratorStateStatus](#generators.external-secrets.io/v1alpha1.GeneratorStateStatus)* | | ### GeneratorStateConditionType (`string` alias) (*Appears on:* [GeneratorStateStatusCondition](#generators.external-secrets.io/v1alpha1.GeneratorStateStatusCondition)) GeneratorStateConditionType represents the type of condition for a generator state. | Value | Description | | --- | --- | | "Ready" | GeneratorStateReady indicates the generator state is ready and available. | ### GeneratorStateSpec (*Appears on:* [GeneratorState](#generators.external-secrets.io/v1alpha1.GeneratorState)) GeneratorStateSpec defines the desired state of a generator state resource. | Field | Description | | --- | --- | | `garbageCollectionDeadline` *[Kubernetes meta/v1.Time](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#time-v1-meta)* | GarbageCollectionDeadline is the time after which the generator state will be deleted. It is set by the controller which creates the generator state and can be set configured by the user. If the garbage collection deadline is not set the generator state will not be deleted. | | `resource` *k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSON* | Resource is the generator manifest that produced the state. It is a snapshot of the generator manifest at the time the state was produced. This manifest will be used to delete the resource. Any configuration that is referenced in the manifest should be available at the time of garbage collection. If that is not the case deletion will be blocked by a finalizer. | | `state` *k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSON* | State is the state that was produced by the generator implementation. | ### GeneratorStateStatus (*Appears on:* [GeneratorState](#generators.external-secrets.io/v1alpha1.GeneratorState)) GeneratorStateStatus defines the observed state of a generator state resource. | Field | Description | | --- | --- | | `conditions` *[[]GeneratorStateStatusCondition](#generators.external-secrets.io/v1alpha1.GeneratorStateStatusCondition)* | | ### GeneratorStateStatusCondition (*Appears on:* [GeneratorStateStatus](#generators.external-secrets.io/v1alpha1.GeneratorStateStatus)) GeneratorStateStatusCondition represents the observed condition of a generator state. | Field | Description | | --- | --- | | `type` *[GeneratorStateConditionType](#generators.external-secrets.io/v1alpha1.GeneratorStateConditionType)* | | | `status` *[Kubernetes core/v1.ConditionStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#conditionstatus-v1-core)* | | | `reason` *string* | *(Optional)* | | `message` *string* | *(Optional)* | | `lastTransitionTime` *[Kubernetes meta/v1.Time](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#time-v1-meta)* | *(Optional)* | ### GithubAccessToken GithubAccessToken generates ghs\_ accessToken | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[GithubAccessTokenSpec](#generators.external-secrets.io/v1alpha1.GithubAccessTokenSpec)* | | `url` *string* | URL configures the GitHub instance URL. Defaults to <https://github.com/>. | | --- | --- | | `appID` *string* | | | `installID` *string* | | | `repositories` *[]string* | List of repositories the token will have access to. If omitted, defaults to all repositories the GitHub App is installed to. | | `permissions` *map[string]string* | Map of permissions the token will have. If omitted, defaults to all permissions the GitHub App has. | | `auth` *[GithubAuth](#generators.external-secrets.io/v1alpha1.GithubAuth)* | Auth configures how ESO authenticates with a Github instance. | | ### GithubAccessTokenSpec (*Appears on:* [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec), [GithubAccessToken](#generators.external-secrets.io/v1alpha1.GithubAccessToken)) GithubAccessTokenSpec defines the desired state to generate a GitHub access token. | Field | Description | | --- | --- | | `url` *string* | URL configures the GitHub instance URL. | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.07159372419118881,
0.0860525444149971,
0.0029649806674569845,
-0.010826737619936466,
0.0012171376729384065,
-0.0021317889913916588,
-0.016965702176094055,
-0.06674670428037643,
0.13787169754505157,
0.015271523036062717,
-0.0011736252345144749,
-0.024037804454565048,
0.005855287425220013,
... | 0.137426 |
*[GithubAuth](#generators.external-secrets.io/v1alpha1.GithubAuth)* | Auth configures how ESO authenticates with a Github instance. | | ### GithubAccessTokenSpec (*Appears on:* [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec), [GithubAccessToken](#generators.external-secrets.io/v1alpha1.GithubAccessToken)) GithubAccessTokenSpec defines the desired state to generate a GitHub access token. | Field | Description | | --- | --- | | `url` *string* | URL configures the GitHub instance URL. Defaults to <https://github.com/>. | | `appID` *string* | | | `installID` *string* | | | `repositories` *[]string* | List of repositories the token will have access to. If omitted, defaults to all repositories the GitHub App is installed to. | | `permissions` *map[string]string* | Map of permissions the token will have. If omitted, defaults to all permissions the GitHub App has. | | `auth` *[GithubAuth](#generators.external-secrets.io/v1alpha1.GithubAuth)* | Auth configures how ESO authenticates with a Github instance. | ### GithubAuth (*Appears on:* [GithubAccessTokenSpec](#generators.external-secrets.io/v1alpha1.GithubAccessTokenSpec)) GithubAuth defines the authentication configuration for GitHub access. | Field | Description | | --- | --- | | `privateKey` *[GithubSecretRef](#generators.external-secrets.io/v1alpha1.GithubSecretRef)* | | ### GithubSecretRef (*Appears on:* [GithubAuth](#generators.external-secrets.io/v1alpha1.GithubAuth)) GithubSecretRef references a secret containing GitHub credentials. | Field | Description | | --- | --- | | `secretRef` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### Grafana Grafana represents a generator for Grafana service account tokens. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[GrafanaSpec](#generators.external-secrets.io/v1alpha1.GrafanaSpec)* | | `url` *string* | URL is the URL of the Grafana instance. | | --- | --- | | `auth` *[GrafanaAuth](#generators.external-secrets.io/v1alpha1.GrafanaAuth)* | Auth is the authentication configuration to authenticate against the Grafana instance. | | `serviceAccount` *[GrafanaServiceAccount](#generators.external-secrets.io/v1alpha1.GrafanaServiceAccount)* | ServiceAccount is the configuration for the service account that is supposed to be generated by the generator. | | ### GrafanaAuth (*Appears on:* [GrafanaSpec](#generators.external-secrets.io/v1alpha1.GrafanaSpec)) GrafanaAuth defines the authentication methods for connecting to a Grafana instance. | Field | Description | | --- | --- | | `token` *[SecretKeySelector](#generators.external-secrets.io/v1alpha1.SecretKeySelector)* | *(Optional)* A service account token used to authenticate against the Grafana instance. Note: you need a token which has elevated permissions to create service accounts. See here for the documentation on basic roles offered by Grafana: <https://grafana.com/docs/grafana/latest/administration/roles-and-permissions/access-control/rbac-fixed-basic-role-definitions/> | | `basic` *[GrafanaBasicAuth](#generators.external-secrets.io/v1alpha1.GrafanaBasicAuth)* | *(Optional)* Basic auth credentials used to authenticate against the Grafana instance. Note: you need a token which has elevated permissions to create service accounts. See here for the documentation on basic roles offered by Grafana: <https://grafana.com/docs/grafana/latest/administration/roles-and-permissions/access-control/rbac-fixed-basic-role-definitions/> | ### GrafanaBasicAuth (*Appears on:* [GrafanaAuth](#generators.external-secrets.io/v1alpha1.GrafanaAuth)) GrafanaBasicAuth defines the credentials for basic authentication with Grafana. | Field | Description | | --- | --- | | `username` *string* | A basic auth username used to authenticate against the Grafana instance. | | `password` *[SecretKeySelector](#generators.external-secrets.io/v1alpha1.SecretKeySelector)* | A basic auth password used to authenticate against the Grafana instance. | ### GrafanaServiceAccount (*Appears on:* [GrafanaSpec](#generators.external-secrets.io/v1alpha1.GrafanaSpec)) GrafanaServiceAccount defines the configuration for a Grafana service account to be created. | Field | Description | | --- | --- | | `name` *string* | Name is the name of the service account that will be created by ESO. | | `role` *string* | Role is the role of the service account. See here for the documentation on basic roles offered by Grafana: <https://grafana.com/docs/grafana/latest/administration/roles-and-permissions/access-control/rbac-fixed-basic-role-definitions/> | ### GrafanaServiceAccountTokenState GrafanaServiceAccountTokenState is the state type produced by the Grafana generator. It contains the service account ID, login and token ID which is enough to identify the service account. | Field | Description | | --- | --- | | `serviceAccount` *[GrafanaStateServiceAccount](#generators.external-secrets.io/v1alpha1.GrafanaStateServiceAccount)* | | ### GrafanaSpec (*Appears on:* [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec), [Grafana](#generators.external-secrets.io/v1alpha1.Grafana)) GrafanaSpec controls the behavior of the grafana generator. | Field | Description | | --- | --- | | `url` *string* | URL is the URL of the Grafana | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.06360700726509094,
-0.05897359922528267,
-0.05725250765681267,
0.0003147941897623241,
0.01766512729227543,
-0.031052619218826294,
-0.002114423317834735,
0.025784974917769432,
-0.008073021657764912,
0.017746716737747192,
-0.05288694426417351,
-0.06824647635221481,
0.049451377242803574,
-... | 0.157621 |
| Field | Description | | --- | --- | | `serviceAccount` *[GrafanaStateServiceAccount](#generators.external-secrets.io/v1alpha1.GrafanaStateServiceAccount)* | | ### GrafanaSpec (*Appears on:* [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec), [Grafana](#generators.external-secrets.io/v1alpha1.Grafana)) GrafanaSpec controls the behavior of the grafana generator. | Field | Description | | --- | --- | | `url` *string* | URL is the URL of the Grafana instance. | | `auth` *[GrafanaAuth](#generators.external-secrets.io/v1alpha1.GrafanaAuth)* | Auth is the authentication configuration to authenticate against the Grafana instance. | | `serviceAccount` *[GrafanaServiceAccount](#generators.external-secrets.io/v1alpha1.GrafanaServiceAccount)* | ServiceAccount is the configuration for the service account that is supposed to be generated by the generator. | ### GrafanaStateServiceAccount (*Appears on:* [GrafanaServiceAccountTokenState](#generators.external-secrets.io/v1alpha1.GrafanaServiceAccountTokenState)) GrafanaStateServiceAccount contains the service account ID, login and token ID. | Field | Description | | --- | --- | | `id` *int64* | | | `login` *string* | | | `tokenID` *int64* | | ### MFA MFA generates a new TOTP token that is compliant with RFC 6238. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[MFASpec](#generators.external-secrets.io/v1alpha1.MFASpec)* | | `secret` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | Secret is a secret selector to a secret containing the seed secret to generate the TOTP value from. | | --- | --- | | `length` *int* | Length defines the token length. Defaults to 6 characters. | | `timePeriod` *int* | TimePeriod defines how long the token can be active. Defaults to 30 seconds. | | `algorithm` *string* | Algorithm to use for encoding. Defaults to SHA1 as per the RFC. | | `when` *[Kubernetes meta/v1.Time](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#time-v1-meta)* | When defines a time parameter that can be used to pin the origin time of the generated token. | | ### MFASpec (*Appears on:* [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec), [MFA](#generators.external-secrets.io/v1alpha1.MFA)) MFASpec controls the behavior of the mfa generator. | Field | Description | | --- | --- | | `secret` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | Secret is a secret selector to a secret containing the seed secret to generate the TOTP value from. | | `length` *int* | Length defines the token length. Defaults to 6 characters. | | `timePeriod` *int* | TimePeriod defines how long the token can be active. Defaults to 30 seconds. | | `algorithm` *string* | Algorithm to use for encoding. Defaults to SHA1 as per the RFC. | | `when` *[Kubernetes meta/v1.Time](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#time-v1-meta)* | When defines a time parameter that can be used to pin the origin time of the generated token. | ### NTLMProtocol (*Appears on:* [AuthorizationProtocol](#generators.external-secrets.io/v1alpha1.AuthorizationProtocol)) NTLMProtocol contains the NTLM-specific configuration. | Field | Description | | --- | --- | | `usernameSecret` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | | `passwordSecret` *[External Secrets meta/v1.SecretKeySelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#SecretKeySelector)* | | ### Password Password generates a random password based on the configuration parameters in spec. You can specify the length, characterset and other attributes. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[PasswordSpec](#generators.external-secrets.io/v1alpha1.PasswordSpec)* | | `length` *int* | Length of the password to be generated. Defaults to 24 | | --- | --- | | `digits` *int* | Digits specifies the number of digits in the generated password. If omitted it defaults to 25% of the length of the password | | `symbols` *int* | Symbols specifies the number of symbol characters in the generated password. If omitted it defaults to 25% of the length of the password | | `symbolCharacters` *string* | SymbolCharacters specifies the special characters that should be used in the generated password. | | `noUpper` *bool* | Set NoUpper to disable uppercase characters | | `allowRepeat` *bool* | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.2033606767654419,
0.014072942547500134,
-0.09082615375518799,
-0.015868058428168297,
-0.07560139149427414,
-0.05111769959330559,
0.013044058345258236,
-0.05772227421402931,
0.020038915798068047,
-0.012909847311675549,
-0.004170498810708523,
-0.07650197297334671,
0.0633070319890976,
-0.0... | 0.067809 |
characters in the generated password. If omitted it defaults to 25% of the length of the password | | `symbolCharacters` *string* | SymbolCharacters specifies the special characters that should be used in the generated password. | | `noUpper` *bool* | Set NoUpper to disable uppercase characters | | `allowRepeat` *bool* | set AllowRepeat to true to allow repeating characters. | | `secretKeys` *[]string* | *(Optional)* SecretKeys defines the keys that will be populated with generated passwords. Defaults to “password” when not set. | | `encoding` *string* | Encoding specifies the encoding of the generated password. Valid values are: - “raw” (default): no encoding - “base64”: standard base64 encoding - “base64url”: base64url encoding - “base32”: base32 encoding - “hex”: hexadecimal encoding | | ### PasswordSpec (*Appears on:* [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec), [Password](#generators.external-secrets.io/v1alpha1.Password)) PasswordSpec controls the behavior of the password generator. | Field | Description | | --- | --- | | `length` *int* | Length of the password to be generated. Defaults to 24 | | `digits` *int* | Digits specifies the number of digits in the generated password. If omitted it defaults to 25% of the length of the password | | `symbols` *int* | Symbols specifies the number of symbol characters in the generated password. If omitted it defaults to 25% of the length of the password | | `symbolCharacters` *string* | SymbolCharacters specifies the special characters that should be used in the generated password. | | `noUpper` *bool* | Set NoUpper to disable uppercase characters | | `allowRepeat` *bool* | set AllowRepeat to true to allow repeating characters. | | `secretKeys` *[]string* | *(Optional)* SecretKeys defines the keys that will be populated with generated passwords. Defaults to “password” when not set. | | `encoding` *string* | Encoding specifies the encoding of the generated password. Valid values are: - “raw” (default): no encoding - “base64”: standard base64 encoding - “base64url”: base64url encoding - “base32”: base32 encoding - “hex”: hexadecimal encoding | ### QuayAccessToken QuayAccessToken generates Quay oauth token for pulling/pushing images | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[QuayAccessTokenSpec](#generators.external-secrets.io/v1alpha1.QuayAccessTokenSpec)* | | `url` *string* | URL configures the Quay instance URL. Defaults to quay.io. | | --- | --- | | `robotAccount` *string* | Name of the robot account you are federating with | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | Name of the service account you are federating with | | ### QuayAccessTokenSpec (*Appears on:* [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec), [QuayAccessToken](#generators.external-secrets.io/v1alpha1.QuayAccessToken)) QuayAccessTokenSpec defines the desired state to generate a Quay access token. | Field | Description | | --- | --- | | `url` *string* | URL configures the Quay instance URL. Defaults to quay.io. | | `robotAccount` *string* | Name of the robot account you are federating with | | `serviceAccountRef` *[External Secrets meta/v1.ServiceAccountSelector](https://pkg.go.dev/github.com/external-secrets/external-secrets/apis/meta/v1#ServiceAccountSelector)* | Name of the service account you are federating with | ### RequestParameters (*Appears on:* [STSSessionTokenSpec](#generators.external-secrets.io/v1alpha1.STSSessionTokenSpec)) RequestParameters contains parameters that can be passed to the STS service. | Field | Description | | --- | --- | | `sessionDuration` *int32* | *(Optional)* | | `serialNumber` *string* | *(Optional)* SerialNumber is the identification number of the MFA device that is associated with the IAM user who is making the GetSessionToken call. Possible values: hardware device (such as GAHT12345678) or an Amazon Resource Name (ARN) for a virtual device (such as arn:aws:iam::123456789012:mfa/user) | | `tokenCode` *string* | *(Optional)* TokenCode is the value provided by the MFA device, if MFA is required. | ### SSHKey SSHKey generates SSH key pairs. | Field | Description | | --- | --- | | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.08567214012145996,
-0.03747658059000969,
-0.1085333526134491,
0.01872432604432106,
-0.029327070340514183,
0.03531850501894951,
-0.06213316321372986,
0.02156720496714115,
0.018825789913535118,
-0.03102152980864048,
0.04198835417628288,
-0.03609495609998703,
0.09309955686330795,
-0.065780... | -0.041135 |
an Amazon Resource Name (ARN) for a virtual device (such as arn:aws:iam::123456789012:mfa/user) | | `tokenCode` *string* | *(Optional)* TokenCode is the value provided by the MFA device, if MFA is required. | ### SSHKey SSHKey generates SSH key pairs. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[SSHKeySpec](#generators.external-secrets.io/v1alpha1.SSHKeySpec)* | | `keyType` *string* | KeyType specifies the SSH key type (rsa, ecdsa, ed25519) | | --- | --- | | `keySize` *int* | KeySize specifies the key size for RSA keys (default: 2048) and ECDSA keys (default: 256). For RSA keys: 2048, 3072, 4096 For ECDSA keys: 256, 384, 521 Ignored for ed25519 keys | | `comment` *string* | Comment specifies an optional comment for the SSH key | | ### SSHKeySpec (*Appears on:* [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec), [SSHKey](#generators.external-secrets.io/v1alpha1.SSHKey)) SSHKeySpec controls the behavior of the ssh key generator. | Field | Description | | --- | --- | | `keyType` *string* | KeyType specifies the SSH key type (rsa, ecdsa, ed25519) | | `keySize` *int* | KeySize specifies the key size for RSA keys (default: 2048) and ECDSA keys (default: 256). For RSA keys: 2048, 3072, 4096 For ECDSA keys: 256, 384, 521 Ignored for ed25519 keys | | `comment` *string* | Comment specifies an optional comment for the SSH key | ### STSSessionToken STSSessionToken uses the GetSessionToken API to retrieve an authorization token. The authorization token is valid for 12 hours. The authorizationToken returned is a base64 encoded string that can be decoded. For more information, see GetSessionToken (<https://docs.aws.amazon.com/STS/latest/APIReference/API_GetSessionToken.html>). | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[STSSessionTokenSpec](#generators.external-secrets.io/v1alpha1.STSSessionTokenSpec)* | | `region` *string* | Region specifies the region to operate in. | | --- | --- | | `auth` *[AWSAuth](#generators.external-secrets.io/v1alpha1.AWSAuth)* | *(Optional)* Auth defines how to authenticate with AWS | | `role` *string* | *(Optional)* You can assume a role before making calls to the desired AWS service. | | `requestParameters` *[RequestParameters](#generators.external-secrets.io/v1alpha1.RequestParameters)* | *(Optional)* RequestParameters contains parameters that can be passed to the STS service. | | ### STSSessionTokenSpec (*Appears on:* [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec), [STSSessionToken](#generators.external-secrets.io/v1alpha1.STSSessionToken)) STSSessionTokenSpec defines the desired state to generate an AWS STS session token. | Field | Description | | --- | --- | | `region` *string* | Region specifies the region to operate in. | | `auth` *[AWSAuth](#generators.external-secrets.io/v1alpha1.AWSAuth)* | *(Optional)* Auth defines how to authenticate with AWS | | `role` *string* | *(Optional)* You can assume a role before making calls to the desired AWS service. | | `requestParameters` *[RequestParameters](#generators.external-secrets.io/v1alpha1.RequestParameters)* | *(Optional)* RequestParameters contains parameters that can be passed to the STS service. | ### SecretKeySelector (*Appears on:* [GrafanaAuth](#generators.external-secrets.io/v1alpha1.GrafanaAuth), [GrafanaBasicAuth](#generators.external-secrets.io/v1alpha1.GrafanaBasicAuth), [WebhookSecret](#generators.external-secrets.io/v1alpha1.WebhookSecret)) SecretKeySelector defines a reference to a specific key within a Kubernetes Secret. | Field | Description | | --- | --- | | `name` *string* | The name of the Secret resource being referred to. | | `key` *string* | The key where the token is found. | ### StatefulResource StatefulResource represents a Kubernetes resource that has state which can be tracked. ### UUID UUID generates a version 1 UUID (e56657e3-764f-11ef-a397-65231a88c216). | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[UUIDSpec](#generators.external-secrets.io/v1alpha1.UUIDSpec)* | | ### UUIDSpec (*Appears on:* [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec), [UUID](#generators.external-secrets.io/v1alpha1.UUID)) UUIDSpec controls the behavior of the uuid generator. ### VaultDynamicSecret VaultDynamicSecret represents a generator that can create dynamic secrets from HashiCorp Vault. | Field | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.016254883259534836,
-0.007299714721739292,
-0.05943132936954498,
-0.011930100619792938,
0.005746645387262106,
0.02893737517297268,
0.008235186338424683,
-0.04148142784833908,
0.09849593043327332,
0.03732723742723465,
0.01480979286134243,
-0.08912831544876099,
0.039578985422849655,
-0.04... | 0.179663 |
| Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[UUIDSpec](#generators.external-secrets.io/v1alpha1.UUIDSpec)* | | ### UUIDSpec (*Appears on:* [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec), [UUID](#generators.external-secrets.io/v1alpha1.UUID)) UUIDSpec controls the behavior of the uuid generator. ### VaultDynamicSecret VaultDynamicSecret represents a generator that can create dynamic secrets from HashiCorp Vault. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[VaultDynamicSecretSpec](#generators.external-secrets.io/v1alpha1.VaultDynamicSecretSpec)* | | `controller` *string* | *(Optional)* Used to select the correct ESO controller (think: ingress.ingressClassName) The ESO controller is instantiated with a specific controller name and filters VDS based on this property | | --- | --- | | `method` *string* | Vault API method to use (GET/POST/other) | | `parameters` *k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSON* | Parameters to pass to Vault write (for non-GET methods) | | `resultType` *[VaultDynamicSecretResultType](#generators.external-secrets.io/v1alpha1.VaultDynamicSecretResultType)* | Result type defines which data is returned from the generator. By default, it is the “data” section of the Vault API response. When using e.g. /auth/token/create the “data” section is empty but the “auth” section contains the generated token. Please refer to the vault docs regarding the result data structure. Additionally, accessing the raw response is possibly by using “Raw” result type. | | `retrySettings` *[SecretStoreRetrySettings](#external-secrets.io/v1.SecretStoreRetrySettings)* | *(Optional)* Used to configure http retries if failed | | `provider` *[VaultProvider](#external-secrets.io/v1.VaultProvider)* | Vault provider common spec | | `path` *string* | Vault path to obtain the dynamic secret from | | `allowEmptyResponse` *bool* | *(Optional)* Do not fail if no secrets are found. Useful for requests where no data is expected. | | ### VaultDynamicSecretResultType (`string` alias) (*Appears on:* [VaultDynamicSecretSpec](#generators.external-secrets.io/v1alpha1.VaultDynamicSecretSpec)) VaultDynamicSecretResultType defines which part of the Vault API response should be returned. | Value | Description | | --- | --- | | "Auth" | VaultDynamicSecretResultTypeAuth specifies to return the “auth” section of the Vault API response. | | "Data" | VaultDynamicSecretResultTypeData specifies to return the “data” section of the Vault API response. | | "Raw" | VaultDynamicSecretResultTypeRaw specifies to return the raw response from the Vault API. | ### VaultDynamicSecretSpec (*Appears on:* [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec), [VaultDynamicSecret](#generators.external-secrets.io/v1alpha1.VaultDynamicSecret)) VaultDynamicSecretSpec defines the desired spec of VaultDynamicSecret. | Field | Description | | --- | --- | | `controller` *string* | *(Optional)* Used to select the correct ESO controller (think: ingress.ingressClassName) The ESO controller is instantiated with a specific controller name and filters VDS based on this property | | `method` *string* | Vault API method to use (GET/POST/other) | | `parameters` *k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1.JSON* | Parameters to pass to Vault write (for non-GET methods) | | `resultType` *[VaultDynamicSecretResultType](#generators.external-secrets.io/v1alpha1.VaultDynamicSecretResultType)* | Result type defines which data is returned from the generator. By default, it is the “data” section of the Vault API response. When using e.g. /auth/token/create the “data” section is empty but the “auth” section contains the generated token. Please refer to the vault docs regarding the result data structure. Additionally, accessing the raw response is possibly by using “Raw” result type. | | `retrySettings` *[SecretStoreRetrySettings](#external-secrets.io/v1.SecretStoreRetrySettings)* | *(Optional)* Used to configure http retries if failed | | `provider` *[VaultProvider](#external-secrets.io/v1.VaultProvider)* | Vault provider common spec | | `path` *string* | Vault path to obtain the dynamic secret from | | `allowEmptyResponse` *bool* | *(Optional)* Do not fail if no secrets are found. Useful for requests where no data is expected. | ### Webhook Webhook connects to a third party API server to handle the secrets generation configuration parameters in spec. You can specify the server, the token, and additional body parameters. See documentation for the full API specification for requests and responses. | Field | Description | | --- | --- | | | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.022642243653535843,
0.035275060683488846,
-0.03236640244722366,
-0.013645827770233154,
0.02068137936294079,
-0.046942900866270065,
-0.03181120753288269,
-0.017078837379813194,
0.0884871557354927,
-0.02597782015800476,
-0.017808489501476288,
-0.07140450924634933,
0.021942242980003357,
-0... | 0.117921 |
Webhook connects to a third party API server to handle the secrets generation configuration parameters in spec. You can specify the server, the token, and additional body parameters. See documentation for the full API specification for requests and responses. | Field | Description | | --- | --- | | `metadata` *[Kubernetes meta/v1.ObjectMeta](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.25/#objectmeta-v1-meta)* | Refer to the Kubernetes API documentation for the fields of the `metadata` field. | | `spec` *[WebhookSpec](#generators.external-secrets.io/v1alpha1.WebhookSpec)* | | `method` *string* | Webhook Method | | --- | --- | | `url` *string* | Webhook url to call | | `headers` *map[string]string* | *(Optional)* Headers | | `auth` *[AuthorizationProtocol](#generators.external-secrets.io/v1alpha1.AuthorizationProtocol)* | *(Optional)* Auth specifies a authorization protocol. Only one protocol may be set. | | `body` *string* | *(Optional)* Body | | `timeout` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | *(Optional)* Timeout | | `result` *[WebhookResult](#generators.external-secrets.io/v1alpha1.WebhookResult)* | Result formatting | | `secrets` *[[]WebhookSecret](#generators.external-secrets.io/v1alpha1.WebhookSecret)* | *(Optional)* Secrets to fill in templates These secrets will be passed to the templating function as key value pairs under the given name | | `caBundle` *[]byte* | *(Optional)* PEM encoded CA bundle used to validate webhook server certificate. Only used if the Server URL is using HTTPS protocol. This parameter is ignored for plain HTTP protocol connection. If not set the system root certificates are used to validate the TLS connection. | | `caProvider` *[WebhookCAProvider](#generators.external-secrets.io/v1alpha1.WebhookCAProvider)* | *(Optional)* The provider for the CA bundle to use to validate webhook server certificate. | | ### WebhookCAProvider (*Appears on:* [WebhookSpec](#generators.external-secrets.io/v1alpha1.WebhookSpec)) WebhookCAProvider defines a location to fetch the cert for the webhook provider from. | Field | Description | | --- | --- | | `type` *[WebhookCAProviderType](#generators.external-secrets.io/v1alpha1.WebhookCAProviderType)* | The type of provider to use such as “Secret”, or “ConfigMap”. | | `name` *string* | The name of the object located at the provider type. | | `key` *string* | The key where the CA certificate can be found in the Secret or ConfigMap. | | `namespace` *string* | *(Optional)* The namespace the Provider type is in. | ### WebhookCAProviderType (`string` alias) (*Appears on:* [WebhookCAProvider](#generators.external-secrets.io/v1alpha1.WebhookCAProvider)) WebhookCAProviderType defines the type of provider for webhook CA certificates. | Value | Description | | --- | --- | | "ConfigMap" | WebhookCAProviderTypeConfigMap indicates the CA provider is a ConfigMap resource. | | "Secret" | WebhookCAProviderTypeSecret indicates the CA provider is a Secret resource. | ### WebhookResult (*Appears on:* [WebhookSpec](#generators.external-secrets.io/v1alpha1.WebhookSpec)) WebhookResult defines how to format and extract results from the webhook response. | Field | Description | | --- | --- | | `jsonPath` *string* | *(Optional)* Json path of return value | ### WebhookSecret (*Appears on:* [WebhookSpec](#generators.external-secrets.io/v1alpha1.WebhookSpec)) WebhookSecret defines a secret reference that will be used in webhook templates. | Field | Description | | --- | --- | | `name` *string* | Name of this secret in templates | | `secretRef` *[SecretKeySelector](#generators.external-secrets.io/v1alpha1.SecretKeySelector)* | Secret ref to fill in credentials | ### WebhookSpec (*Appears on:* [GeneratorSpec](#generators.external-secrets.io/v1alpha1.GeneratorSpec), [Webhook](#generators.external-secrets.io/v1alpha1.Webhook)) WebhookSpec controls the behavior of the external generator. Any body parameters should be passed to the server through the parameters field. | Field | Description | | --- | --- | | `method` *string* | Webhook Method | | `url` *string* | Webhook url to call | | `headers` *map[string]string* | *(Optional)* Headers | | `auth` *[AuthorizationProtocol](#generators.external-secrets.io/v1alpha1.AuthorizationProtocol)* | *(Optional)* Auth specifies a authorization protocol. Only one protocol may be set. | | `body` *string* | *(Optional)* Body | | `timeout` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | *(Optional)* Timeout | | `result` *[WebhookResult](#generators.external-secrets.io/v1alpha1.WebhookResult)* | Result formatting | | `secrets` *[[]WebhookSecret](#generators.external-secrets.io/v1alpha1.WebhookSecret)* | *(Optional)* Secrets to fill in templates These secrets will be passed to the templating function as key value pairs under the given name | | `caBundle` *[]byte* | *(Optional)* PEM | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.0692383274435997,
0.07594716548919678,
-0.052366726100444794,
0.010353248566389084,
-0.04683980718255043,
-0.06444288790225983,
-0.021484212949872017,
0.004363789688795805,
0.05845951661467552,
0.028987837955355644,
-0.043090324848890305,
-0.15284909307956696,
0.0057903858833014965,
-0.... | 0.130582 |
| | `timeout` *[Kubernetes meta/v1.Duration](https://pkg.go.dev/k8s.io/apimachinery/pkg/apis/meta/v1#Duration)* | *(Optional)* Timeout | | `result` *[WebhookResult](#generators.external-secrets.io/v1alpha1.WebhookResult)* | Result formatting | | `secrets` *[[]WebhookSecret](#generators.external-secrets.io/v1alpha1.WebhookSecret)* | *(Optional)* Secrets to fill in templates These secrets will be passed to the templating function as key value pairs under the given name | | `caBundle` *[]byte* | *(Optional)* PEM encoded CA bundle used to validate webhook server certificate. Only used if the Server URL is using HTTPS protocol. This parameter is ignored for plain HTTP protocol connection. If not set the system root certificates are used to validate the TLS connection. | | `caProvider` *[WebhookCAProvider](#generators.external-secrets.io/v1alpha1.WebhookCAProvider)* | *(Optional)* The provider for the CA bundle to use to validate webhook server certificate. | --- *Generated with `gen-crd-api-reference-docs`.* | https://github.com/external-secrets/external-secrets/blob/main//docs/api/spec.md | main | external-secrets | [
-0.049923550337553024,
0.1251123547554016,
-0.046533167362213135,
-0.03360997512936592,
-0.011990214698016644,
-0.017309997230768204,
-0.03263454511761665,
0.00891525112092495,
0.07704468071460724,
-0.0015506173949688673,
0.02614344283938408,
-0.11808481067419052,
-0.006837830878794193,
-0... | 0.117442 |
 The `ClusterSecretStore` is a cluster scoped SecretStore that can be referenced by all `ExternalSecrets` from all namespaces. Use it to offer a central gateway to your secret backend. Different Store Providers have different stability levels, maintenance status, and support. To check the full list, please see [Stability Support](../introduction/stability-support.md). !!! note "Unmaintained Stores generate events" Admission webhooks and controllers will emit warning events for providers without a explicit maintainer. To disable controller warning events, you can add `external-secrets.io/ignore-maintenance-checks: "true"` annotation to the SecretStore. Admission webhook warning cannot be disabled. ## Example For a full list of supported fields see [spec](./spec.md) or dig into our [guides](../guides/introduction.md). ``` yaml {% include 'full-cluster-secret-store.yaml' %} ``` | https://github.com/external-secrets/external-secrets/blob/main//docs/api/clustersecretstore.md | main | external-secrets | [
-0.01873103156685829,
0.014826200902462006,
-0.06442324817180634,
0.07611776888370514,
0.08650220930576324,
0.007403476629406214,
-0.014755546115338802,
-0.02038654312491417,
0.014373562298715115,
0.02472907491028309,
0.05586232990026474,
-0.043975021690130234,
0.02454398386180401,
-0.0460... | 0.128718 |
`CloudsmithAccessToken` creates a short-lived Cloudsmith access token that can be used to authenticate against Cloudsmith's container registry for pushing or pulling container images. This generator uses OIDC token exchange to authenticate with Cloudsmith using a Kubernetes service account token and generates Docker registry credentials in dockerconfigjson format. ## Output Keys and Values | Key | Description | | ---------- | ------------------------------------------------------------------------------ | | auth | Base64 encoded authentication string for Docker registry access. | | expiry | Time when token expires in UNIX time (seconds since January 1, 1970 UTC). | ## Authentication To use the Cloudsmith generator, you must configure OIDC authentication between your Kubernetes cluster and Cloudsmith. Your cluster must have a publicly available [OIDC service account issuer](https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/#service-account-issuer-discovery) endpoint for Cloudsmith to validate tokens against. ### Prerequisites 1. \*\*Cloudsmith OIDC Service\*\*: Configure an OIDC service in your Cloudsmith organization that trusts your Kubernetes cluster's OIDC issuer. 2. \*\*Service Account\*\*: Create a Kubernetes service account that will be used for token exchange. 3. \*\*Proper Audiences\*\*: The service account token must include the appropriate audience for Cloudsmith (typically `https://api.cloudsmith.io`). ### Service Account Configuration You can determine the issuer and subject fields by creating and decoding a service account token for the service account you wish to use (this is the service account you will specify in `spec.serviceAccountRef`). For example, if using the `default` service account in the `default` namespace: Obtain issuer: ```bash kubectl create token default -n default | cut -d '.' -f 2 | sed 's/[^=]$/&==/' | base64 -d | jq -r '.iss' ``` Use these values when configuring the OIDC service in your Cloudsmith Workspace settings. ## Configuration Parameters | Parameter | Description | Required | | ------------------- | ------------------------------------------------------------------------ | -------- | | `apiHost` | The Cloudsmith API host. Defaults to `api.cloudsmith.io`. | No | | `orgSlug` | The organization slug in Cloudsmith. | Yes | | `serviceSlug` | The OIDC service slug configured in Cloudsmith. | Yes | | `serviceAccountRef` | Reference to the Kubernetes service account for OIDC token exchange. | Yes | ## Example Manifest ```yaml {% include 'generator-cloudsmith.yaml' %} ``` Example `ExternalSecret` that references the Cloudsmith generator: ```yaml {% include 'generator-cloudsmith-example.yaml' %} ``` ## Using the Generated Docker Registry Secret Once the dockerconfigjson secret is created, you can use it to authenticate with Cloudsmith's container registry in several ways: ### In Pod Specifications Reference the secret in your pod's `imagePullSecrets`: ```yaml apiVersion: v1 kind: Pod metadata: name: my-app spec: imagePullSecrets: - name: cloudsmith-credentials containers: - name: app image: docker.cloudsmith.io/my-org/my-repo/my-image:latest ``` ### In ServiceAccount Add the secret to a ServiceAccount for automatic usage: ```yaml apiVersion: v1 kind: ServiceAccount metadata: name: my-service-account imagePullSecrets: - name: cloudsmith-credentials ``` ### For Docker CLI Authentication Extract the dockerconfigjson and use it with Docker: ```bash kubectl get secret cloudsmith-credentials -o jsonpath='{.data.\.dockerconfigjson}' | base64 -d > ~/.docker/config.json docker pull docker.cloudsmith.io/my-org/my-repo/my-image:latest ``` ## Usage Notes - \*\*Container Registry Access\*\*: The generated dockerconfigjson secret is specifically designed for authenticating with Cloudsmith's container registry to push or pull Docker images. - \*\*Token Lifetime\*\*: Cloudsmith access tokens have a limited lifetime. The `expiry` field in the generated secret indicates when the token will expire. - \*\*Refresh Interval\*\*: Set an appropriate `refreshInterval` in your `ExternalSecret` to ensure tokens are refreshed before expiration. - \*\*Permissions\*\*: The generated token will have the same permissions as the OIDC service configured in Cloudsmith for container registry access. ## Troubleshooting - \*\*Token Exchange Fails\*\*: Verify that your OIDC service in Cloudsmith is correctly configured with your cluster's issuer. - \*\*Invalid Audience\*\*: Ensure the service account token includes the correct audience for Cloudsmith API. - \*\*Network Issues\*\*: Check that your cluster | https://github.com/external-secrets/external-secrets/blob/main//docs/api/generator/cloudsmith.md | main | external-secrets | [
-0.0737522542476654,
0.05601324886083603,
-0.020171018317341805,
-0.04261411726474762,
-0.046022944152355194,
-0.019044505432248116,
0.04414059594273567,
0.005983753129839897,
0.08966003358364105,
0.04649112746119499,
-0.026273394003510475,
-0.06018415838479996,
0.01483398862183094,
-0.055... | 0.037522 |
service configured in Cloudsmith for container registry access. ## Troubleshooting - \*\*Token Exchange Fails\*\*: Verify that your OIDC service in Cloudsmith is correctly configured with your cluster's issuer. - \*\*Invalid Audience\*\*: Ensure the service account token includes the correct audience for Cloudsmith API. - \*\*Network Issues\*\*: Check that your cluster can reach the Cloudsmith API endpoint specified in `apiHost`. - \*\*Container Image Pull Fails\*\*: Verify that the generated dockerconfigjson secret is properly referenced in your pod's `imagePullSecrets` and that the image exists in your Cloudsmith container registry. - \*\*Registry Domain Issues\*\*: Ensure you're using the correct registry domain format (e.g., `docker.cloudsmith.io/org/repo/image:tag`) in your image references. - \*\*Permissions\*\*: Confirm that your OIDC service in Cloudsmith has the necessary permissions to pull/push container images from the specific repositories. | https://github.com/external-secrets/external-secrets/blob/main//docs/api/generator/cloudsmith.md | main | external-secrets | [
-0.04502476379275322,
0.01689060777425766,
0.0130083579570055,
-0.001098762615583837,
0.02422560751438141,
-0.05097304657101631,
0.011449477635324001,
-0.013583226129412651,
0.021896967664361,
0.08606866002082825,
0.007331669330596924,
-0.06602403521537781,
-0.025328977033495903,
0.0320371... | 0.033056 |
# SSHKey Generator The SSHKey generator provides SSH key pairs that you can use for authentication in your applications. It supports generating RSA and Ed25519 keys with configurable key sizes and comments. ## Output Keys and Values | Key | Description | | ---------- | ------------------------------- | | privateKey | the generated SSH private key | | publicKey | the generated SSH public key | ## Parameters | Parameter | Description | Default | Required | | --------- | ------------------------------------------------------------------ | ------- | -------- | | keyType | SSH key type (rsa, ecdsa, ed25519) | rsa | No | | keySize | Key size for RSA keys (2048, 3072, 4096) and ECDSA (256, 384, 521); ignored for ed25519 | 2048 / 256 | No | | comment | Optional comment for the SSH key | "" | No | ## Example Manifest Ed25519 SSH key (recommended): ```yaml {% include 'generator-sshkey.yaml' %} ``` RSA SSH key with custom size: ```yaml {% include 'generator-sshkey-rsa.yaml' %} ``` ECDSA SSH key: ```yaml {% include 'generator-sshkey-ecdsa.yaml' %} ``` Example `ExternalSecret` that references the SSHKey generator: ```yaml {% include 'generator-sshkey-example.yaml' %} ``` This will generate a `Kind=Secret` with keys called 'privateKey' and 'publicKey' containing the SSH key pair. ## Supported Key Types ### RSA Keys - Supports key sizes: 2048, 3072, 4096 bits - Default key size: 2048 bits - Good compatibility with older systems - Can specify custom keySize in the spec ### ECDSA Keys - Supports key sizes: 256, 384, 521 bits - Default key size: 256 bits - For use in regulated environments ### Ed25519 Keys - Fixed key size (keySize parameter ignored if specified) - Modern, secure, and efficient - Recommended for new deployments - Effective key size is always 256 bits (equivalent security to 3072-bit RSA) ## Security Considerations - Generated keys are cryptographically secure using Go's crypto/rand - Private keys are stored in OpenSSH format - Keys are generated fresh on each reconciliation unless cached - Consider key rotation policies for production use | https://github.com/external-secrets/external-secrets/blob/main//docs/api/generator/sshkey.md | main | external-secrets | [
0.022079329937696457,
0.0028099743649363518,
-0.08452709764242172,
-0.03537261486053467,
-0.07570827007293701,
0.05831565707921982,
-0.026999784633517265,
0.028334256261587143,
-0.03058975376188755,
-0.027329953387379646,
0.054774586111307144,
-0.0678793266415596,
0.08574921637773514,
-0.0... | 0.025294 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.