pulumi-vault-kotlin/com.pulumi.vault.kotlin/QuotaLeaseCount

QuotaLeaseCount

class QuotaLeaseCount : KotlinCustomResource

Manage lease count quotas which enforce the number of leases that can be created. A lease count quota can be created at the root level or defined on a namespace or mount by specifying a path when creating the quota. See Vault's Documentation for more information. Note this feature is available only with Vault Enterprise.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as vault from "@pulumi/vault";
const global = new vault.QuotaLeaseCount("global", {
    name: "global",
    path: "",
    maxLeases: 100,
});

import pulumi
import pulumi_vault as vault
global_ = vault.QuotaLeaseCount("global",
    name="global",
    path="",
    max_leases=100)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Vault = Pulumi.Vault;
return await Deployment.RunAsync(() =>
{
    var @global = new Vault.QuotaLeaseCount("global", new()
    {
        Name = "global",
        Path = "",
        MaxLeases = 100,
    });
});

package main
import (
	"github.com/pulumi/pulumi-vault/sdk/v6/go/vault"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := vault.NewQuotaLeaseCount(ctx, "global", &vault.QuotaLeaseCountArgs{
			Name:      pulumi.String("global"),
			Path:      pulumi.String(""),
			MaxLeases: pulumi.Int(100),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vault.QuotaLeaseCount;
import com.pulumi.vault.QuotaLeaseCountArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var global = new QuotaLeaseCount("global", QuotaLeaseCountArgs.builder()
            .name("global")
            .path("")
            .maxLeases(100)
            .build());
    }
}

resources:
  global:
    type: vault:QuotaLeaseCount
    properties:
      name: global
      path: ""
      maxLeases: 100

Import

Lease count quotas can be imported using their names

$ pulumi import vault:index/quotaLeaseCount:QuotaLeaseCount global global

Properties

val id: Output<String>

inheritable

val inheritable: Output<Boolean>?

If set to true on a quota where path is set to a namespace, the same quota will be cumulatively applied to all child namespace. The inheritable parameter cannot be set to true if the path does not specify a namespace. Only the quotas associated with the root namespace are inheritable by default. Requires Vault 1.15+.

maxLeases

val maxLeases: Output<Int>

The maximum number of leases to be allowed by the quota rule. The max_leases must be positive.

name

val name: Output<String>

Name of the rate limit quota

namespace

val namespace: Output<String>?

The namespace to provision the resource in. The value should not contain leading or trailing forward slashes. The namespace is always relative to the provider's configured namespace. Available only for Vault Enterprise.

path

val path: Output<String>?

Path of the mount or namespace to apply the quota. A blank path configures a global rate limit quota. For example namespace1/ adds a quota to a full namespace, namespace1/auth/userpass adds a quota to userpass in namespace1. Updating this field on an existing quota can have "moving" effects. For example, updating auth/userpass to namespace1/auth/userpass moves this quota from being a global mount quota to a namespace specific mount quota. Note, namespaces are supported in Enterprise only.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

role

val role: Output<String>?

If set on a quota where path is set to an auth mount with a concept of roles (such as /auth/approle/), this will make the quota restrict login requests to that mount that are made with the specified role.

urn

val urn: Output<String>