okta

package
v3.6.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 12, 2021 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AuthBackend 

type AuthBackend struct {
	pulumi.CustomResourceState

	// The mount accessor related to the auth mount. It is useful for integration with [Identity Secrets Engine](https://www.vaultproject.io/docs/secrets/identity/index.html).
	Accessor pulumi.StringOutput `pulumi:"accessor"`
	// The Okta url. Examples: oktapreview.com, okta.com
	BaseUrl pulumi.StringPtrOutput `pulumi:"baseUrl"`
	// When true, requests by Okta for a MFA check will be bypassed. This also disallows certain status checks on the account, such as whether the password is expired.
	BypassOktaMfa pulumi.BoolPtrOutput `pulumi:"bypassOktaMfa"`
	// The description of the auth backend
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Associate Okta groups with policies within Vault.
	// See below for more details.
	Groups AuthBackendGroupTypeArrayOutput `pulumi:"groups"`
	// Maximum duration after which authentication will be expired
	// [See the documentation for info on valid duration formats](https://golang.org/pkg/time/#ParseDuration).
	MaxTtl pulumi.StringPtrOutput `pulumi:"maxTtl"`
	// The Okta organization. This will be the first part of the url `https://XXX.okta.com`
	Organization pulumi.StringOutput `pulumi:"organization"`
	// Path to mount the Okta auth backend
	Path pulumi.StringPtrOutput `pulumi:"path"`
	// The Okta API token. This is required to query Okta for user group membership.
	// If this is not supplied only locally configured groups will be enabled.
	Token pulumi.StringPtrOutput `pulumi:"token"`
	// Duration after which authentication will be expired.
	// [See the documentation for info on valid duration formats](https://golang.org/pkg/time/#ParseDuration).
	Ttl pulumi.StringPtrOutput `pulumi:"ttl"`
	// Associate Okta users with groups or policies within Vault.
	// See below for more details.
	Users AuthBackendUserTypeArrayOutput `pulumi:"users"`
}

Provides a resource for managing an [Okta auth backend within Vault](https://www.vaultproject.io/docs/auth/okta.html).

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-vault/sdk/v3/go/vault/okta"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := okta.NewAuthBackend(ctx, "example", &okta.AuthBackendArgs{
			Description: pulumi.String("Demonstration of the Terraform Okta auth backend"),
			Groups: okta.AuthBackendGroupArray{
				&okta.AuthBackendGroupArgs{
					GroupName: pulumi.String("foo"),
					Policies: pulumi.StringArray{
						pulumi.String("one"),
						pulumi.String("two"),
					},
				},
			},
			Organization: pulumi.String("example"),
			Token:        pulumi.String("something that should be kept secret"),
			Users: okta.AuthBackendUserArray{
				&okta.AuthBackendUserArgs{
					Groups: pulumi.StringArray{
						pulumi.String("foo"),
					},
					Username: pulumi.String("bar"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetAuthBackend 

func GetAuthBackend(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AuthBackendState, opts ...pulumi.ResourceOption) (*AuthBackend, error)

GetAuthBackend gets an existing AuthBackend resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewAuthBackend 

func NewAuthBackend(ctx *pulumi.Context,
	name string, args *AuthBackendArgs, opts ...pulumi.ResourceOption) (*AuthBackend, error)

NewAuthBackend registers a new resource with the given unique name, arguments, and options.

func (*AuthBackend) ElementType added in v3.0.2 

func (*AuthBackend) ElementType() reflect.Type

func (*AuthBackend) ToAuthBackendOutput added in v3.0.2 

func (i *AuthBackend) ToAuthBackendOutput() AuthBackendOutput

func (*AuthBackend) ToAuthBackendOutputWithContext added in v3.0.2 

func (i *AuthBackend) ToAuthBackendOutputWithContext(ctx context.Context) AuthBackendOutput

func (*AuthBackend) ToAuthBackendPtrOutput added in v3.4.1 

func (i *AuthBackend) ToAuthBackendPtrOutput() AuthBackendPtrOutput

func (*AuthBackend) ToAuthBackendPtrOutputWithContext added in v3.4.1 

func (i *AuthBackend) ToAuthBackendPtrOutputWithContext(ctx context.Context) AuthBackendPtrOutput

type AuthBackendArgs 

type AuthBackendArgs struct {
	// The Okta url. Examples: oktapreview.com, okta.com
	BaseUrl pulumi.StringPtrInput
	// When true, requests by Okta for a MFA check will be bypassed. This also disallows certain status checks on the account, such as whether the password is expired.
	BypassOktaMfa pulumi.BoolPtrInput
	// The description of the auth backend
	Description pulumi.StringPtrInput
	// Associate Okta groups with policies within Vault.
	// See below for more details.
	Groups AuthBackendGroupTypeArrayInput
	// Maximum duration after which authentication will be expired
	// [See the documentation for info on valid duration formats](https://golang.org/pkg/time/#ParseDuration).
	MaxTtl pulumi.StringPtrInput
	// The Okta organization. This will be the first part of the url `https://XXX.okta.com`
	Organization pulumi.StringInput
	// Path to mount the Okta auth backend
	Path pulumi.StringPtrInput
	// The Okta API token. This is required to query Okta for user group membership.
	// If this is not supplied only locally configured groups will be enabled.
	Token pulumi.StringPtrInput
	// Duration after which authentication will be expired.
	// [See the documentation for info on valid duration formats](https://golang.org/pkg/time/#ParseDuration).
	Ttl pulumi.StringPtrInput
	// Associate Okta users with groups or policies within Vault.
	// See below for more details.
	Users AuthBackendUserTypeArrayInput
}

The set of arguments for constructing a AuthBackend resource.

func (AuthBackendArgs) ElementType 

func (AuthBackendArgs) ElementType() reflect.Type

type AuthBackendArray added in v3.4.1 

type AuthBackendArray []AuthBackendInput

func (AuthBackendArray) ElementType added in v3.4.1 

func (AuthBackendArray) ElementType() reflect.Type

func (AuthBackendArray) ToAuthBackendArrayOutput added in v3.4.1 

func (i AuthBackendArray) ToAuthBackendArrayOutput() AuthBackendArrayOutput

func (AuthBackendArray) ToAuthBackendArrayOutputWithContext added in v3.4.1 

func (i AuthBackendArray) ToAuthBackendArrayOutputWithContext(ctx context.Context) AuthBackendArrayOutput

type AuthBackendArrayInput added in v3.4.1 

type AuthBackendArrayInput interface {
	pulumi.Input

	ToAuthBackendArrayOutput() AuthBackendArrayOutput
	ToAuthBackendArrayOutputWithContext(context.Context) AuthBackendArrayOutput
}

AuthBackendArrayInput is an input type that accepts AuthBackendArray and AuthBackendArrayOutput values. You can construct a concrete instance of `AuthBackendArrayInput` via: 

AuthBackendArray{ AuthBackendArgs{...} }

type AuthBackendArrayOutput added in v3.4.1 

type AuthBackendArrayOutput struct{ *pulumi.OutputState }

func (AuthBackendArrayOutput) ElementType added in v3.4.1 

func (AuthBackendArrayOutput) ElementType() reflect.Type

func (AuthBackendArrayOutput) Index added in v3.4.1 

func (o AuthBackendArrayOutput) Index(i pulumi.IntInput) AuthBackendOutput

func (AuthBackendArrayOutput) ToAuthBackendArrayOutput added in v3.4.1 

func (o AuthBackendArrayOutput) ToAuthBackendArrayOutput() AuthBackendArrayOutput

func (AuthBackendArrayOutput) ToAuthBackendArrayOutputWithContext added in v3.4.1 

func (o AuthBackendArrayOutput) ToAuthBackendArrayOutputWithContext(ctx context.Context) AuthBackendArrayOutput

type AuthBackendGroup 

type AuthBackendGroup struct {
	pulumi.CustomResourceState

	// Name of the group within the Okta
	GroupName pulumi.StringOutput `pulumi:"groupName"`
	// The path where the Okta auth backend is mounted
	Path pulumi.StringOutput `pulumi:"path"`
	// Vault policies to associate with this group
	Policies pulumi.StringArrayOutput `pulumi:"policies"`
}

Provides a resource to create a group in an [Okta auth backend within Vault](https://www.vaultproject.io/docs/auth/okta.html).

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-vault/sdk/v3/go/vault/okta"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := okta.NewAuthBackend(ctx, "example", &okta.AuthBackendArgs{
			Organization: pulumi.String("dummy"),
			Path:         pulumi.String("group_okta"),
		})
		if err != nil {
			return err
		}
		_, err = okta.NewAuthBackendGroup(ctx, "foo", &okta.AuthBackendGroupArgs{
			GroupName: pulumi.String("foo"),
			Path:      example.Path,
			Policies: pulumi.StringArray{
				pulumi.String("one"),
				pulumi.String("two"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Okta authentication backend groups can be imported using the format `backend/groupName` e.g.

```sh 

$ pulumi import vault:okta/authBackendGroup:AuthBackendGroup foo okta/foo

```

func GetAuthBackendGroup 

func GetAuthBackendGroup(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AuthBackendGroupState, opts ...pulumi.ResourceOption) (*AuthBackendGroup, error)

GetAuthBackendGroup gets an existing AuthBackendGroup resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewAuthBackendGroup 

func NewAuthBackendGroup(ctx *pulumi.Context,
	name string, args *AuthBackendGroupArgs, opts ...pulumi.ResourceOption) (*AuthBackendGroup, error)

NewAuthBackendGroup registers a new resource with the given unique name, arguments, and options.

func (*AuthBackendGroup) ElementType added in v3.0.2 

func (*AuthBackendGroup) ElementType() reflect.Type

func (*AuthBackendGroup) ToAuthBackendGroupOutput added in v3.0.2 

func (i *AuthBackendGroup) ToAuthBackendGroupOutput() AuthBackendGroupOutput

func (*AuthBackendGroup) ToAuthBackendGroupOutputWithContext added in v3.0.2 

func (i *AuthBackendGroup) ToAuthBackendGroupOutputWithContext(ctx context.Context) AuthBackendGroupOutput

func (*AuthBackendGroup) ToAuthBackendGroupPtrOutput added in v3.4.1 

func (i *AuthBackendGroup) ToAuthBackendGroupPtrOutput() AuthBackendGroupPtrOutput

func (*AuthBackendGroup) ToAuthBackendGroupPtrOutputWithContext added in v3.4.1 

func (i *AuthBackendGroup) ToAuthBackendGroupPtrOutputWithContext(ctx context.Context) AuthBackendGroupPtrOutput

type AuthBackendGroupArgs 

type AuthBackendGroupArgs struct {
	// Name of the group within the Okta
	GroupName pulumi.StringInput
	// The path where the Okta auth backend is mounted
	Path pulumi.StringInput
	// Vault policies to associate with this group
	Policies pulumi.StringArrayInput
}

The set of arguments for constructing a AuthBackendGroup resource.

func (AuthBackendGroupArgs) ElementType 

func (AuthBackendGroupArgs) ElementType() reflect.Type

type AuthBackendGroupArray added in v3.4.1 

type AuthBackendGroupArray []AuthBackendGroupInput

func (AuthBackendGroupArray) ElementType added in v3.4.1 

func (AuthBackendGroupArray) ElementType() reflect.Type

func (AuthBackendGroupArray) ToAuthBackendGroupArrayOutput added in v3.4.1 

func (i AuthBackendGroupArray) ToAuthBackendGroupArrayOutput() AuthBackendGroupArrayOutput

func (AuthBackendGroupArray) ToAuthBackendGroupArrayOutputWithContext added in v3.4.1 

func (i AuthBackendGroupArray) ToAuthBackendGroupArrayOutputWithContext(ctx context.Context) AuthBackendGroupArrayOutput

type AuthBackendGroupArrayInput added in v3.4.1 

type AuthBackendGroupArrayInput interface {
	pulumi.Input

	ToAuthBackendGroupArrayOutput() AuthBackendGroupArrayOutput
	ToAuthBackendGroupArrayOutputWithContext(context.Context) AuthBackendGroupArrayOutput
}

AuthBackendGroupArrayInput is an input type that accepts AuthBackendGroupArray and AuthBackendGroupArrayOutput values. You can construct a concrete instance of `AuthBackendGroupArrayInput` via: 

AuthBackendGroupArray{ AuthBackendGroupArgs{...} }

type AuthBackendGroupArrayOutput added in v3.4.1 

type AuthBackendGroupArrayOutput struct{ *pulumi.OutputState }

func (AuthBackendGroupArrayOutput) ElementType added in v3.4.1 

func (AuthBackendGroupArrayOutput) ElementType() reflect.Type

func (AuthBackendGroupArrayOutput) Index added in v3.4.1 

func (o AuthBackendGroupArrayOutput) Index(i pulumi.IntInput) AuthBackendGroupOutput

func (AuthBackendGroupArrayOutput) ToAuthBackendGroupArrayOutput added in v3.4.1 

func (o AuthBackendGroupArrayOutput) ToAuthBackendGroupArrayOutput() AuthBackendGroupArrayOutput

func (AuthBackendGroupArrayOutput) ToAuthBackendGroupArrayOutputWithContext added in v3.4.1 

func (o AuthBackendGroupArrayOutput) ToAuthBackendGroupArrayOutputWithContext(ctx context.Context) AuthBackendGroupArrayOutput

type AuthBackendGroupInput added in v3.0.2 

type AuthBackendGroupInput interface {
	pulumi.Input

	ToAuthBackendGroupOutput() AuthBackendGroupOutput
	ToAuthBackendGroupOutputWithContext(ctx context.Context) AuthBackendGroupOutput
}

type AuthBackendGroupMap added in v3.4.1 

type AuthBackendGroupMap map[string]AuthBackendGroupInput

func (AuthBackendGroupMap) ElementType added in v3.4.1 

func (AuthBackendGroupMap) ElementType() reflect.Type

func (AuthBackendGroupMap) ToAuthBackendGroupMapOutput added in v3.4.1 

func (i AuthBackendGroupMap) ToAuthBackendGroupMapOutput() AuthBackendGroupMapOutput

func (AuthBackendGroupMap) ToAuthBackendGroupMapOutputWithContext added in v3.4.1 

func (i AuthBackendGroupMap) ToAuthBackendGroupMapOutputWithContext(ctx context.Context) AuthBackendGroupMapOutput

type AuthBackendGroupMapInput added in v3.4.1 

type AuthBackendGroupMapInput interface {
	pulumi.Input

	ToAuthBackendGroupMapOutput() AuthBackendGroupMapOutput
	ToAuthBackendGroupMapOutputWithContext(context.Context) AuthBackendGroupMapOutput
}

AuthBackendGroupMapInput is an input type that accepts AuthBackendGroupMap and AuthBackendGroupMapOutput values. You can construct a concrete instance of `AuthBackendGroupMapInput` via: 

AuthBackendGroupMap{ "key": AuthBackendGroupArgs{...} }

type AuthBackendGroupMapOutput added in v3.4.1 

type AuthBackendGroupMapOutput struct{ *pulumi.OutputState }

func (AuthBackendGroupMapOutput) ElementType added in v3.4.1 

func (AuthBackendGroupMapOutput) ElementType() reflect.Type

func (AuthBackendGroupMapOutput) MapIndex added in v3.4.1 

func (o AuthBackendGroupMapOutput) MapIndex(k pulumi.StringInput) AuthBackendGroupOutput

func (AuthBackendGroupMapOutput) ToAuthBackendGroupMapOutput added in v3.4.1 

func (o AuthBackendGroupMapOutput) ToAuthBackendGroupMapOutput() AuthBackendGroupMapOutput

func (AuthBackendGroupMapOutput) ToAuthBackendGroupMapOutputWithContext added in v3.4.1 

func (o AuthBackendGroupMapOutput) ToAuthBackendGroupMapOutputWithContext(ctx context.Context) AuthBackendGroupMapOutput

type AuthBackendGroupOutput added in v3.0.2 

type AuthBackendGroupOutput struct {
	*pulumi.OutputState
}

func (AuthBackendGroupOutput) ElementType added in v3.0.2 

func (AuthBackendGroupOutput) ElementType() reflect.Type

func (AuthBackendGroupOutput) ToAuthBackendGroupOutput added in v3.0.2 

func (o AuthBackendGroupOutput) ToAuthBackendGroupOutput() AuthBackendGroupOutput

func (AuthBackendGroupOutput) ToAuthBackendGroupOutputWithContext added in v3.0.2 

func (o AuthBackendGroupOutput) ToAuthBackendGroupOutputWithContext(ctx context.Context) AuthBackendGroupOutput

func (AuthBackendGroupOutput) ToAuthBackendGroupPtrOutput added in v3.4.1 

func (o AuthBackendGroupOutput) ToAuthBackendGroupPtrOutput() AuthBackendGroupPtrOutput

func (AuthBackendGroupOutput) ToAuthBackendGroupPtrOutputWithContext added in v3.4.1 

func (o AuthBackendGroupOutput) ToAuthBackendGroupPtrOutputWithContext(ctx context.Context) AuthBackendGroupPtrOutput

type AuthBackendGroupPtrInput added in v3.4.1 

type AuthBackendGroupPtrInput interface {
	pulumi.Input

	ToAuthBackendGroupPtrOutput() AuthBackendGroupPtrOutput
	ToAuthBackendGroupPtrOutputWithContext(ctx context.Context) AuthBackendGroupPtrOutput
}

type AuthBackendGroupPtrOutput added in v3.4.1 

type AuthBackendGroupPtrOutput struct {
	*pulumi.OutputState
}

func (AuthBackendGroupPtrOutput) ElementType added in v3.4.1 

func (AuthBackendGroupPtrOutput) ElementType() reflect.Type

func (AuthBackendGroupPtrOutput) ToAuthBackendGroupPtrOutput added in v3.4.1 

func (o AuthBackendGroupPtrOutput) ToAuthBackendGroupPtrOutput() AuthBackendGroupPtrOutput

func (AuthBackendGroupPtrOutput) ToAuthBackendGroupPtrOutputWithContext added in v3.4.1 

func (o AuthBackendGroupPtrOutput) ToAuthBackendGroupPtrOutputWithContext(ctx context.Context) AuthBackendGroupPtrOutput

type AuthBackendGroupState 

type AuthBackendGroupState struct {
	// Name of the group within the Okta
	GroupName pulumi.StringPtrInput
	// The path where the Okta auth backend is mounted
	Path pulumi.StringPtrInput
	// Vault policies to associate with this group
	Policies pulumi.StringArrayInput
}

func (AuthBackendGroupState) ElementType 

func (AuthBackendGroupState) ElementType() reflect.Type

type AuthBackendGroupType 

type AuthBackendGroupType struct {
	// Name of the group within the Okta
	GroupName string `pulumi:"groupName"`
	// List of Vault policies to associate with this user
	Policies []string `pulumi:"policies"`
}

type AuthBackendGroupTypeArgs 

type AuthBackendGroupTypeArgs struct {
	// Name of the group within the Okta
	GroupName pulumi.StringInput `pulumi:"groupName"`
	// List of Vault policies to associate with this user
	Policies pulumi.StringArrayInput `pulumi:"policies"`
}

func (AuthBackendGroupTypeArgs) ElementType 

func (AuthBackendGroupTypeArgs) ElementType() reflect.Type

func (AuthBackendGroupTypeArgs) ToAuthBackendGroupTypeOutput 

func (i AuthBackendGroupTypeArgs) ToAuthBackendGroupTypeOutput() AuthBackendGroupTypeOutput

func (AuthBackendGroupTypeArgs) ToAuthBackendGroupTypeOutputWithContext 

func (i AuthBackendGroupTypeArgs) ToAuthBackendGroupTypeOutputWithContext(ctx context.Context) AuthBackendGroupTypeOutput

type AuthBackendGroupTypeArray 

type AuthBackendGroupTypeArray []AuthBackendGroupTypeInput

func (AuthBackendGroupTypeArray) ElementType 

func (AuthBackendGroupTypeArray) ElementType() reflect.Type

func (AuthBackendGroupTypeArray) ToAuthBackendGroupTypeArrayOutput 

func (i AuthBackendGroupTypeArray) ToAuthBackendGroupTypeArrayOutput() AuthBackendGroupTypeArrayOutput

func (AuthBackendGroupTypeArray) ToAuthBackendGroupTypeArrayOutputWithContext 

func (i AuthBackendGroupTypeArray) ToAuthBackendGroupTypeArrayOutputWithContext(ctx context.Context) AuthBackendGroupTypeArrayOutput

type AuthBackendGroupTypeArrayInput 

type AuthBackendGroupTypeArrayInput interface {
	pulumi.Input

	ToAuthBackendGroupTypeArrayOutput() AuthBackendGroupTypeArrayOutput
	ToAuthBackendGroupTypeArrayOutputWithContext(context.Context) AuthBackendGroupTypeArrayOutput
}

AuthBackendGroupTypeArrayInput is an input type that accepts AuthBackendGroupTypeArray and AuthBackendGroupTypeArrayOutput values. You can construct a concrete instance of `AuthBackendGroupTypeArrayInput` via: 

AuthBackendGroupTypeArray{ AuthBackendGroupTypeArgs{...} }

type AuthBackendGroupTypeArrayOutput 

type AuthBackendGroupTypeArrayOutput struct{ *pulumi.OutputState }

func (AuthBackendGroupTypeArrayOutput) ElementType 

func (AuthBackendGroupTypeArrayOutput) ElementType() reflect.Type

func (AuthBackendGroupTypeArrayOutput) Index 

func (o AuthBackendGroupTypeArrayOutput) Index(i pulumi.IntInput) AuthBackendGroupTypeOutput

func (AuthBackendGroupTypeArrayOutput) ToAuthBackendGroupTypeArrayOutput 

func (o AuthBackendGroupTypeArrayOutput) ToAuthBackendGroupTypeArrayOutput() AuthBackendGroupTypeArrayOutput

func (AuthBackendGroupTypeArrayOutput) ToAuthBackendGroupTypeArrayOutputWithContext 

func (o AuthBackendGroupTypeArrayOutput) ToAuthBackendGroupTypeArrayOutputWithContext(ctx context.Context) AuthBackendGroupTypeArrayOutput

type AuthBackendGroupTypeInput 

type AuthBackendGroupTypeInput interface {
	pulumi.Input

	ToAuthBackendGroupTypeOutput() AuthBackendGroupTypeOutput
	ToAuthBackendGroupTypeOutputWithContext(context.Context) AuthBackendGroupTypeOutput
}

AuthBackendGroupTypeInput is an input type that accepts AuthBackendGroupTypeArgs and AuthBackendGroupTypeOutput values. You can construct a concrete instance of `AuthBackendGroupTypeInput` via: 

AuthBackendGroupTypeArgs{...}

type AuthBackendGroupTypeOutput 

type AuthBackendGroupTypeOutput struct{ *pulumi.OutputState }

func (AuthBackendGroupTypeOutput) ElementType 

func (AuthBackendGroupTypeOutput) ElementType() reflect.Type

func (AuthBackendGroupTypeOutput) GroupName 

func (o AuthBackendGroupTypeOutput) GroupName() pulumi.StringOutput

Name of the group within the Okta

func (AuthBackendGroupTypeOutput) Policies 

func (o AuthBackendGroupTypeOutput) Policies() pulumi.StringArrayOutput

List of Vault policies to associate with this user

func (AuthBackendGroupTypeOutput) ToAuthBackendGroupTypeOutput 

func (o AuthBackendGroupTypeOutput) ToAuthBackendGroupTypeOutput() AuthBackendGroupTypeOutput

func (AuthBackendGroupTypeOutput) ToAuthBackendGroupTypeOutputWithContext 

func (o AuthBackendGroupTypeOutput) ToAuthBackendGroupTypeOutputWithContext(ctx context.Context) AuthBackendGroupTypeOutput

type AuthBackendInput added in v3.0.2 

type AuthBackendInput interface {
	pulumi.Input

	ToAuthBackendOutput() AuthBackendOutput
	ToAuthBackendOutputWithContext(ctx context.Context) AuthBackendOutput
}

type AuthBackendMap added in v3.4.1 

type AuthBackendMap map[string]AuthBackendInput

func (AuthBackendMap) ElementType added in v3.4.1 

func (AuthBackendMap) ElementType() reflect.Type

func (AuthBackendMap) ToAuthBackendMapOutput added in v3.4.1 

func (i AuthBackendMap) ToAuthBackendMapOutput() AuthBackendMapOutput

func (AuthBackendMap) ToAuthBackendMapOutputWithContext added in v3.4.1 

func (i AuthBackendMap) ToAuthBackendMapOutputWithContext(ctx context.Context) AuthBackendMapOutput

type AuthBackendMapInput added in v3.4.1 

type AuthBackendMapInput interface {
	pulumi.Input

	ToAuthBackendMapOutput() AuthBackendMapOutput
	ToAuthBackendMapOutputWithContext(context.Context) AuthBackendMapOutput
}

AuthBackendMapInput is an input type that accepts AuthBackendMap and AuthBackendMapOutput values. You can construct a concrete instance of `AuthBackendMapInput` via: 

AuthBackendMap{ "key": AuthBackendArgs{...} }

type AuthBackendMapOutput added in v3.4.1 

type AuthBackendMapOutput struct{ *pulumi.OutputState }

func (AuthBackendMapOutput) ElementType added in v3.4.1 

func (AuthBackendMapOutput) ElementType() reflect.Type

func (AuthBackendMapOutput) MapIndex added in v3.4.1 

func (o AuthBackendMapOutput) MapIndex(k pulumi.StringInput) AuthBackendOutput

func (AuthBackendMapOutput) ToAuthBackendMapOutput added in v3.4.1 

func (o AuthBackendMapOutput) ToAuthBackendMapOutput() AuthBackendMapOutput

func (AuthBackendMapOutput) ToAuthBackendMapOutputWithContext added in v3.4.1 

func (o AuthBackendMapOutput) ToAuthBackendMapOutputWithContext(ctx context.Context) AuthBackendMapOutput

type AuthBackendOutput added in v3.0.2 

type AuthBackendOutput struct {
	*pulumi.OutputState
}

func (AuthBackendOutput) ElementType added in v3.0.2 

func (AuthBackendOutput) ElementType() reflect.Type

func (AuthBackendOutput) ToAuthBackendOutput added in v3.0.2 

func (o AuthBackendOutput) ToAuthBackendOutput() AuthBackendOutput

func (AuthBackendOutput) ToAuthBackendOutputWithContext added in v3.0.2 

func (o AuthBackendOutput) ToAuthBackendOutputWithContext(ctx context.Context) AuthBackendOutput

func (AuthBackendOutput) ToAuthBackendPtrOutput added in v3.4.1 

func (o AuthBackendOutput) ToAuthBackendPtrOutput() AuthBackendPtrOutput

func (AuthBackendOutput) ToAuthBackendPtrOutputWithContext added in v3.4.1 

func (o AuthBackendOutput) ToAuthBackendPtrOutputWithContext(ctx context.Context) AuthBackendPtrOutput

type AuthBackendPtrInput added in v3.4.1 

type AuthBackendPtrInput interface {
	pulumi.Input

	ToAuthBackendPtrOutput() AuthBackendPtrOutput
	ToAuthBackendPtrOutputWithContext(ctx context.Context) AuthBackendPtrOutput
}

type AuthBackendPtrOutput added in v3.4.1 

type AuthBackendPtrOutput struct {
	*pulumi.OutputState
}

func (AuthBackendPtrOutput) ElementType added in v3.4.1 

func (AuthBackendPtrOutput) ElementType() reflect.Type

func (AuthBackendPtrOutput) ToAuthBackendPtrOutput added in v3.4.1 

func (o AuthBackendPtrOutput) ToAuthBackendPtrOutput() AuthBackendPtrOutput

func (AuthBackendPtrOutput) ToAuthBackendPtrOutputWithContext added in v3.4.1 

func (o AuthBackendPtrOutput) ToAuthBackendPtrOutputWithContext(ctx context.Context) AuthBackendPtrOutput

type AuthBackendState 

type AuthBackendState struct {
	// The mount accessor related to the auth mount. It is useful for integration with [Identity Secrets Engine](https://www.vaultproject.io/docs/secrets/identity/index.html).
	Accessor pulumi.StringPtrInput
	// The Okta url. Examples: oktapreview.com, okta.com
	BaseUrl pulumi.StringPtrInput
	// When true, requests by Okta for a MFA check will be bypassed. This also disallows certain status checks on the account, such as whether the password is expired.
	BypassOktaMfa pulumi.BoolPtrInput
	// The description of the auth backend
	Description pulumi.StringPtrInput
	// Associate Okta groups with policies within Vault.
	// See below for more details.
	Groups AuthBackendGroupTypeArrayInput
	// Maximum duration after which authentication will be expired
	// [See the documentation for info on valid duration formats](https://golang.org/pkg/time/#ParseDuration).
	MaxTtl pulumi.StringPtrInput
	// The Okta organization. This will be the first part of the url `https://XXX.okta.com`
	Organization pulumi.StringPtrInput
	// Path to mount the Okta auth backend
	Path pulumi.StringPtrInput
	// The Okta API token. This is required to query Okta for user group membership.
	// If this is not supplied only locally configured groups will be enabled.
	Token pulumi.StringPtrInput
	// Duration after which authentication will be expired.
	// [See the documentation for info on valid duration formats](https://golang.org/pkg/time/#ParseDuration).
	Ttl pulumi.StringPtrInput
	// Associate Okta users with groups or policies within Vault.
	// See below for more details.
	Users AuthBackendUserTypeArrayInput
}

func (AuthBackendState) ElementType 

func (AuthBackendState) ElementType() reflect.Type

type AuthBackendUser 

type AuthBackendUser struct {
	pulumi.CustomResourceState

	// List of Okta groups to associate with this user
	Groups pulumi.StringArrayOutput `pulumi:"groups"`
	// The path where the Okta auth backend is mounted
	Path pulumi.StringOutput `pulumi:"path"`
	// List of Vault policies to associate with this user
	Policies pulumi.StringArrayOutput `pulumi:"policies"`
	// Name of the user within Okta
	Username pulumi.StringOutput `pulumi:"username"`
}

Provides a resource to create a user in an [Okta auth backend within Vault](https://www.vaultproject.io/docs/auth/okta.html).

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-vault/sdk/v3/go/vault/okta"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := okta.NewAuthBackend(ctx, "example", &okta.AuthBackendArgs{
			Organization: pulumi.String("dummy"),
			Path:         pulumi.String("user_okta"),
		})
		if err != nil {
			return err
		}
		_, err = okta.NewAuthBackendUser(ctx, "foo", &okta.AuthBackendUserArgs{
			Groups: pulumi.StringArray{
				pulumi.String("one"),
				pulumi.String("two"),
			},
			Path:     example.Path,
			Username: pulumi.String("foo"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetAuthBackendUser 

func GetAuthBackendUser(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *AuthBackendUserState, opts ...pulumi.ResourceOption) (*AuthBackendUser, error)

GetAuthBackendUser gets an existing AuthBackendUser resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewAuthBackendUser 

func NewAuthBackendUser(ctx *pulumi.Context,
	name string, args *AuthBackendUserArgs, opts ...pulumi.ResourceOption) (*AuthBackendUser, error)

NewAuthBackendUser registers a new resource with the given unique name, arguments, and options.

func (*AuthBackendUser) ElementType added in v3.0.2 

func (*AuthBackendUser) ElementType() reflect.Type

func (*AuthBackendUser) ToAuthBackendUserOutput added in v3.0.2 

func (i *AuthBackendUser) ToAuthBackendUserOutput() AuthBackendUserOutput

func (*AuthBackendUser) ToAuthBackendUserOutputWithContext added in v3.0.2 

func (i *AuthBackendUser) ToAuthBackendUserOutputWithContext(ctx context.Context) AuthBackendUserOutput

func (*AuthBackendUser) ToAuthBackendUserPtrOutput added in v3.4.1 

func (i *AuthBackendUser) ToAuthBackendUserPtrOutput() AuthBackendUserPtrOutput

func (*AuthBackendUser) ToAuthBackendUserPtrOutputWithContext added in v3.4.1 

func (i *AuthBackendUser) ToAuthBackendUserPtrOutputWithContext(ctx context.Context) AuthBackendUserPtrOutput

type AuthBackendUserArgs 

type AuthBackendUserArgs struct {
	// List of Okta groups to associate with this user
	Groups pulumi.StringArrayInput
	// The path where the Okta auth backend is mounted
	Path pulumi.StringInput
	// List of Vault policies to associate with this user
	Policies pulumi.StringArrayInput
	// Name of the user within Okta
	Username pulumi.StringInput
}

The set of arguments for constructing a AuthBackendUser resource.

func (AuthBackendUserArgs) ElementType 

func (AuthBackendUserArgs) ElementType() reflect.Type

type AuthBackendUserArray added in v3.4.1 

type AuthBackendUserArray []AuthBackendUserInput

func (AuthBackendUserArray) ElementType added in v3.4.1 

func (AuthBackendUserArray) ElementType() reflect.Type

func (AuthBackendUserArray) ToAuthBackendUserArrayOutput added in v3.4.1 

func (i AuthBackendUserArray) ToAuthBackendUserArrayOutput() AuthBackendUserArrayOutput

func (AuthBackendUserArray) ToAuthBackendUserArrayOutputWithContext added in v3.4.1 

func (i AuthBackendUserArray) ToAuthBackendUserArrayOutputWithContext(ctx context.Context) AuthBackendUserArrayOutput

type AuthBackendUserArrayInput added in v3.4.1 

type AuthBackendUserArrayInput interface {
	pulumi.Input

	ToAuthBackendUserArrayOutput() AuthBackendUserArrayOutput
	ToAuthBackendUserArrayOutputWithContext(context.Context) AuthBackendUserArrayOutput
}

AuthBackendUserArrayInput is an input type that accepts AuthBackendUserArray and AuthBackendUserArrayOutput values. You can construct a concrete instance of `AuthBackendUserArrayInput` via: 

AuthBackendUserArray{ AuthBackendUserArgs{...} }

type AuthBackendUserArrayOutput added in v3.4.1 

type AuthBackendUserArrayOutput struct{ *pulumi.OutputState }

func (AuthBackendUserArrayOutput) ElementType added in v3.4.1 

func (AuthBackendUserArrayOutput) ElementType() reflect.Type

func (AuthBackendUserArrayOutput) Index added in v3.4.1 

func (o AuthBackendUserArrayOutput) Index(i pulumi.IntInput) AuthBackendUserOutput

func (AuthBackendUserArrayOutput) ToAuthBackendUserArrayOutput added in v3.4.1 

func (o AuthBackendUserArrayOutput) ToAuthBackendUserArrayOutput() AuthBackendUserArrayOutput

func (AuthBackendUserArrayOutput) ToAuthBackendUserArrayOutputWithContext added in v3.4.1 

func (o AuthBackendUserArrayOutput) ToAuthBackendUserArrayOutputWithContext(ctx context.Context) AuthBackendUserArrayOutput

type AuthBackendUserInput added in v3.0.2 

type AuthBackendUserInput interface {
	pulumi.Input

	ToAuthBackendUserOutput() AuthBackendUserOutput
	ToAuthBackendUserOutputWithContext(ctx context.Context) AuthBackendUserOutput
}

type AuthBackendUserMap added in v3.4.1 

type AuthBackendUserMap map[string]AuthBackendUserInput

func (AuthBackendUserMap) ElementType added in v3.4.1 

func (AuthBackendUserMap) ElementType() reflect.Type

func (AuthBackendUserMap) ToAuthBackendUserMapOutput added in v3.4.1 

func (i AuthBackendUserMap) ToAuthBackendUserMapOutput() AuthBackendUserMapOutput

func (AuthBackendUserMap) ToAuthBackendUserMapOutputWithContext added in v3.4.1 

func (i AuthBackendUserMap) ToAuthBackendUserMapOutputWithContext(ctx context.Context) AuthBackendUserMapOutput

type AuthBackendUserMapInput added in v3.4.1 

type AuthBackendUserMapInput interface {
	pulumi.Input

	ToAuthBackendUserMapOutput() AuthBackendUserMapOutput
	ToAuthBackendUserMapOutputWithContext(context.Context) AuthBackendUserMapOutput
}

AuthBackendUserMapInput is an input type that accepts AuthBackendUserMap and AuthBackendUserMapOutput values. You can construct a concrete instance of `AuthBackendUserMapInput` via: 

AuthBackendUserMap{ "key": AuthBackendUserArgs{...} }

type AuthBackendUserMapOutput added in v3.4.1 

type AuthBackendUserMapOutput struct{ *pulumi.OutputState }

func (AuthBackendUserMapOutput) ElementType added in v3.4.1 

func (AuthBackendUserMapOutput) ElementType() reflect.Type

func (AuthBackendUserMapOutput) MapIndex added in v3.4.1 

func (o AuthBackendUserMapOutput) MapIndex(k pulumi.StringInput) AuthBackendUserOutput

func (AuthBackendUserMapOutput) ToAuthBackendUserMapOutput added in v3.4.1 

func (o AuthBackendUserMapOutput) ToAuthBackendUserMapOutput() AuthBackendUserMapOutput

func (AuthBackendUserMapOutput) ToAuthBackendUserMapOutputWithContext added in v3.4.1 

func (o AuthBackendUserMapOutput) ToAuthBackendUserMapOutputWithContext(ctx context.Context) AuthBackendUserMapOutput

type AuthBackendUserOutput added in v3.0.2 

type AuthBackendUserOutput struct {
	*pulumi.OutputState
}

func (AuthBackendUserOutput) ElementType added in v3.0.2 

func (AuthBackendUserOutput) ElementType() reflect.Type

func (AuthBackendUserOutput) ToAuthBackendUserOutput added in v3.0.2 

func (o AuthBackendUserOutput) ToAuthBackendUserOutput() AuthBackendUserOutput

func (AuthBackendUserOutput) ToAuthBackendUserOutputWithContext added in v3.0.2 

func (o AuthBackendUserOutput) ToAuthBackendUserOutputWithContext(ctx context.Context) AuthBackendUserOutput

func (AuthBackendUserOutput) ToAuthBackendUserPtrOutput added in v3.4.1 

func (o AuthBackendUserOutput) ToAuthBackendUserPtrOutput() AuthBackendUserPtrOutput

func (AuthBackendUserOutput) ToAuthBackendUserPtrOutputWithContext added in v3.4.1 

func (o AuthBackendUserOutput) ToAuthBackendUserPtrOutputWithContext(ctx context.Context) AuthBackendUserPtrOutput

type AuthBackendUserPtrInput added in v3.4.1 

type AuthBackendUserPtrInput interface {
	pulumi.Input

	ToAuthBackendUserPtrOutput() AuthBackendUserPtrOutput
	ToAuthBackendUserPtrOutputWithContext(ctx context.Context) AuthBackendUserPtrOutput
}

type AuthBackendUserPtrOutput added in v3.4.1 

type AuthBackendUserPtrOutput struct {
	*pulumi.OutputState
}

func (AuthBackendUserPtrOutput) ElementType added in v3.4.1 

func (AuthBackendUserPtrOutput) ElementType() reflect.Type

func (AuthBackendUserPtrOutput) ToAuthBackendUserPtrOutput added in v3.4.1 

func (o AuthBackendUserPtrOutput) ToAuthBackendUserPtrOutput() AuthBackendUserPtrOutput

func (AuthBackendUserPtrOutput) ToAuthBackendUserPtrOutputWithContext added in v3.4.1 

func (o AuthBackendUserPtrOutput) ToAuthBackendUserPtrOutputWithContext(ctx context.Context) AuthBackendUserPtrOutput

type AuthBackendUserState 

type AuthBackendUserState struct {
	// List of Okta groups to associate with this user
	Groups pulumi.StringArrayInput
	// The path where the Okta auth backend is mounted
	Path pulumi.StringPtrInput
	// List of Vault policies to associate with this user
	Policies pulumi.StringArrayInput
	// Name of the user within Okta
	Username pulumi.StringPtrInput
}

func (AuthBackendUserState) ElementType 

func (AuthBackendUserState) ElementType() reflect.Type

type AuthBackendUserType 

type AuthBackendUserType struct {
	// List of Okta groups to associate with this user
	Groups []string `pulumi:"groups"`
	// List of Vault policies to associate with this user
	Policies []string `pulumi:"policies"`
	// Name of the user within Okta
	Username string `pulumi:"username"`
}

type AuthBackendUserTypeArgs 

type AuthBackendUserTypeArgs struct {
	// List of Okta groups to associate with this user
	Groups pulumi.StringArrayInput `pulumi:"groups"`
	// List of Vault policies to associate with this user
	Policies pulumi.StringArrayInput `pulumi:"policies"`
	// Name of the user within Okta
	Username pulumi.StringInput `pulumi:"username"`
}

func (AuthBackendUserTypeArgs) ElementType 

func (AuthBackendUserTypeArgs) ElementType() reflect.Type

func (AuthBackendUserTypeArgs) ToAuthBackendUserTypeOutput 

func (i AuthBackendUserTypeArgs) ToAuthBackendUserTypeOutput() AuthBackendUserTypeOutput

func (AuthBackendUserTypeArgs) ToAuthBackendUserTypeOutputWithContext 

func (i AuthBackendUserTypeArgs) ToAuthBackendUserTypeOutputWithContext(ctx context.Context) AuthBackendUserTypeOutput

type AuthBackendUserTypeArray 

type AuthBackendUserTypeArray []AuthBackendUserTypeInput

func (AuthBackendUserTypeArray) ElementType 

func (AuthBackendUserTypeArray) ElementType() reflect.Type

func (AuthBackendUserTypeArray) ToAuthBackendUserTypeArrayOutput 

func (i AuthBackendUserTypeArray) ToAuthBackendUserTypeArrayOutput() AuthBackendUserTypeArrayOutput

func (AuthBackendUserTypeArray) ToAuthBackendUserTypeArrayOutputWithContext 

func (i AuthBackendUserTypeArray) ToAuthBackendUserTypeArrayOutputWithContext(ctx context.Context) AuthBackendUserTypeArrayOutput

type AuthBackendUserTypeArrayInput 

type AuthBackendUserTypeArrayInput interface {
	pulumi.Input

	ToAuthBackendUserTypeArrayOutput() AuthBackendUserTypeArrayOutput
	ToAuthBackendUserTypeArrayOutputWithContext(context.Context) AuthBackendUserTypeArrayOutput
}

AuthBackendUserTypeArrayInput is an input type that accepts AuthBackendUserTypeArray and AuthBackendUserTypeArrayOutput values. You can construct a concrete instance of `AuthBackendUserTypeArrayInput` via: 

AuthBackendUserTypeArray{ AuthBackendUserTypeArgs{...} }

type AuthBackendUserTypeArrayOutput 

type AuthBackendUserTypeArrayOutput struct{ *pulumi.OutputState }

func (AuthBackendUserTypeArrayOutput) ElementType 

func (AuthBackendUserTypeArrayOutput) ElementType() reflect.Type

func (AuthBackendUserTypeArrayOutput) Index 

func (o AuthBackendUserTypeArrayOutput) Index(i pulumi.IntInput) AuthBackendUserTypeOutput

func (AuthBackendUserTypeArrayOutput) ToAuthBackendUserTypeArrayOutput 

func (o AuthBackendUserTypeArrayOutput) ToAuthBackendUserTypeArrayOutput() AuthBackendUserTypeArrayOutput

func (AuthBackendUserTypeArrayOutput) ToAuthBackendUserTypeArrayOutputWithContext 

func (o AuthBackendUserTypeArrayOutput) ToAuthBackendUserTypeArrayOutputWithContext(ctx context.Context) AuthBackendUserTypeArrayOutput

type AuthBackendUserTypeInput 

type AuthBackendUserTypeInput interface {
	pulumi.Input

	ToAuthBackendUserTypeOutput() AuthBackendUserTypeOutput
	ToAuthBackendUserTypeOutputWithContext(context.Context) AuthBackendUserTypeOutput
}

AuthBackendUserTypeInput is an input type that accepts AuthBackendUserTypeArgs and AuthBackendUserTypeOutput values. You can construct a concrete instance of `AuthBackendUserTypeInput` via: 

AuthBackendUserTypeArgs{...}

type AuthBackendUserTypeOutput 

type AuthBackendUserTypeOutput struct{ *pulumi.OutputState }

func (AuthBackendUserTypeOutput) ElementType 

func (AuthBackendUserTypeOutput) ElementType() reflect.Type

func (AuthBackendUserTypeOutput) Groups 

func (o AuthBackendUserTypeOutput) Groups() pulumi.StringArrayOutput

List of Okta groups to associate with this user

func (AuthBackendUserTypeOutput) Policies 

func (o AuthBackendUserTypeOutput) Policies() pulumi.StringArrayOutput

List of Vault policies to associate with this user

func (AuthBackendUserTypeOutput) ToAuthBackendUserTypeOutput 

func (o AuthBackendUserTypeOutput) ToAuthBackendUserTypeOutput() AuthBackendUserTypeOutput

func (AuthBackendUserTypeOutput) ToAuthBackendUserTypeOutputWithContext 

func (o AuthBackendUserTypeOutput) ToAuthBackendUserTypeOutputWithContext(ctx context.Context) AuthBackendUserTypeOutput

func (AuthBackendUserTypeOutput) Username 

func (o AuthBackendUserTypeOutput) Username() pulumi.StringOutput

Name of the user within Okta

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.