okta

package
v4.6.0 Latest Latest
Warning

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

 Go to latest Published: Nov 11, 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/v4/go/vault/okta"
"github.com/pulumi/pulumi/sdk/v3/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
	})
}

```

## Import

Okta authentication backends can be imported using its `path`, e.g.

```sh 

$ pulumi import vault:okta/authBackend:AuthBackend example okta

```

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 

func (*AuthBackend) ElementType() reflect.Type

func (*AuthBackend) ToAuthBackendOutput 

func (i *AuthBackend) ToAuthBackendOutput() AuthBackendOutput

func (*AuthBackend) ToAuthBackendOutputWithContext 

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

func (*AuthBackend) ToAuthBackendPtrOutput 

func (i *AuthBackend) ToAuthBackendPtrOutput() AuthBackendPtrOutput

func (*AuthBackend) ToAuthBackendPtrOutputWithContext 

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 

type AuthBackendArray []AuthBackendInput

func (AuthBackendArray) ElementType 

func (AuthBackendArray) ElementType() reflect.Type

func (AuthBackendArray) ToAuthBackendArrayOutput 

func (i AuthBackendArray) ToAuthBackendArrayOutput() AuthBackendArrayOutput

func (AuthBackendArray) ToAuthBackendArrayOutputWithContext 

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

type AuthBackendArrayInput 

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 

type AuthBackendArrayOutput struct{ *pulumi.OutputState }

func (AuthBackendArrayOutput) ElementType 

func (AuthBackendArrayOutput) ElementType() reflect.Type

func (AuthBackendArrayOutput) Index 

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

func (AuthBackendArrayOutput) ToAuthBackendArrayOutput 

func (o AuthBackendArrayOutput) ToAuthBackendArrayOutput() AuthBackendArrayOutput

func (AuthBackendArrayOutput) ToAuthBackendArrayOutputWithContext 

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/v4/go/vault/okta"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := okta.NewAuthBackend(ctx, "example", &okta.AuthBackendArgs{
			Path:         pulumi.String("group_okta"),
			Organization: pulumi.String("dummy"),
		})
		if err != nil {
			return err
		}
		_, err = okta.NewAuthBackendGroup(ctx, "foo", &okta.AuthBackendGroupArgs{
			Path:      example.Path,
			GroupName: pulumi.String("foo"),
			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 

func (*AuthBackendGroup) ElementType() reflect.Type

func (*AuthBackendGroup) ToAuthBackendGroupOutput 

func (i *AuthBackendGroup) ToAuthBackendGroupOutput() AuthBackendGroupOutput

func (*AuthBackendGroup) ToAuthBackendGroupOutputWithContext 

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

func (*AuthBackendGroup) ToAuthBackendGroupPtrOutput 

func (i *AuthBackendGroup) ToAuthBackendGroupPtrOutput() AuthBackendGroupPtrOutput

func (*AuthBackendGroup) ToAuthBackendGroupPtrOutputWithContext 

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 

type AuthBackendGroupArray []AuthBackendGroupInput

func (AuthBackendGroupArray) ElementType 

func (AuthBackendGroupArray) ElementType() reflect.Type

func (AuthBackendGroupArray) ToAuthBackendGroupArrayOutput 

func (i AuthBackendGroupArray) ToAuthBackendGroupArrayOutput() AuthBackendGroupArrayOutput

func (AuthBackendGroupArray) ToAuthBackendGroupArrayOutputWithContext 

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

type AuthBackendGroupArrayInput 

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 

type AuthBackendGroupArrayOutput struct{ *pulumi.OutputState }

func (AuthBackendGroupArrayOutput) ElementType 

func (AuthBackendGroupArrayOutput) ElementType() reflect.Type

func (AuthBackendGroupArrayOutput) Index 

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

func (AuthBackendGroupArrayOutput) ToAuthBackendGroupArrayOutput 

func (o AuthBackendGroupArrayOutput) ToAuthBackendGroupArrayOutput() AuthBackendGroupArrayOutput

func (AuthBackendGroupArrayOutput) ToAuthBackendGroupArrayOutputWithContext 

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

type AuthBackendGroupInput 

type AuthBackendGroupInput interface {
	pulumi.Input

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

type AuthBackendGroupMap 

type AuthBackendGroupMap map[string]AuthBackendGroupInput

func (AuthBackendGroupMap) ElementType 

func (AuthBackendGroupMap) ElementType() reflect.Type

func (AuthBackendGroupMap) ToAuthBackendGroupMapOutput 

func (i AuthBackendGroupMap) ToAuthBackendGroupMapOutput() AuthBackendGroupMapOutput

func (AuthBackendGroupMap) ToAuthBackendGroupMapOutputWithContext 

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

type AuthBackendGroupMapInput 

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 

type AuthBackendGroupMapOutput struct{ *pulumi.OutputState }

func (AuthBackendGroupMapOutput) ElementType 

func (AuthBackendGroupMapOutput) ElementType() reflect.Type

func (AuthBackendGroupMapOutput) MapIndex 

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

func (AuthBackendGroupMapOutput) ToAuthBackendGroupMapOutput 

func (o AuthBackendGroupMapOutput) ToAuthBackendGroupMapOutput() AuthBackendGroupMapOutput

func (AuthBackendGroupMapOutput) ToAuthBackendGroupMapOutputWithContext 

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

type AuthBackendGroupOutput 

type AuthBackendGroupOutput struct{ *pulumi.OutputState }

func (AuthBackendGroupOutput) ElementType 

func (AuthBackendGroupOutput) ElementType() reflect.Type

func (AuthBackendGroupOutput) ToAuthBackendGroupOutput 

func (o AuthBackendGroupOutput) ToAuthBackendGroupOutput() AuthBackendGroupOutput

func (AuthBackendGroupOutput) ToAuthBackendGroupOutputWithContext 

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

func (AuthBackendGroupOutput) ToAuthBackendGroupPtrOutput 

func (o AuthBackendGroupOutput) ToAuthBackendGroupPtrOutput() AuthBackendGroupPtrOutput

func (AuthBackendGroupOutput) ToAuthBackendGroupPtrOutputWithContext 

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

type AuthBackendGroupPtrInput 

type AuthBackendGroupPtrInput interface {
	pulumi.Input

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

type AuthBackendGroupPtrOutput 

type AuthBackendGroupPtrOutput struct{ *pulumi.OutputState }

func (AuthBackendGroupPtrOutput) Elem added in v4.6.0 

func (o AuthBackendGroupPtrOutput) Elem() AuthBackendGroupOutput

func (AuthBackendGroupPtrOutput) ElementType 

func (AuthBackendGroupPtrOutput) ElementType() reflect.Type

func (AuthBackendGroupPtrOutput) ToAuthBackendGroupPtrOutput 

func (o AuthBackendGroupPtrOutput) ToAuthBackendGroupPtrOutput() AuthBackendGroupPtrOutput

func (AuthBackendGroupPtrOutput) ToAuthBackendGroupPtrOutputWithContext 

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 

type AuthBackendInput interface {
	pulumi.Input

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

type AuthBackendMap 

type AuthBackendMap map[string]AuthBackendInput

func (AuthBackendMap) ElementType 

func (AuthBackendMap) ElementType() reflect.Type

func (AuthBackendMap) ToAuthBackendMapOutput 

func (i AuthBackendMap) ToAuthBackendMapOutput() AuthBackendMapOutput

func (AuthBackendMap) ToAuthBackendMapOutputWithContext 

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

type AuthBackendMapInput 

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 

type AuthBackendMapOutput struct{ *pulumi.OutputState }

func (AuthBackendMapOutput) ElementType 

func (AuthBackendMapOutput) ElementType() reflect.Type

func (AuthBackendMapOutput) MapIndex 

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

func (AuthBackendMapOutput) ToAuthBackendMapOutput 

func (o AuthBackendMapOutput) ToAuthBackendMapOutput() AuthBackendMapOutput

func (AuthBackendMapOutput) ToAuthBackendMapOutputWithContext 

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

type AuthBackendOutput 

type AuthBackendOutput struct{ *pulumi.OutputState }

func (AuthBackendOutput) ElementType 

func (AuthBackendOutput) ElementType() reflect.Type

func (AuthBackendOutput) ToAuthBackendOutput 

func (o AuthBackendOutput) ToAuthBackendOutput() AuthBackendOutput

func (AuthBackendOutput) ToAuthBackendOutputWithContext 

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

func (AuthBackendOutput) ToAuthBackendPtrOutput 

func (o AuthBackendOutput) ToAuthBackendPtrOutput() AuthBackendPtrOutput

func (AuthBackendOutput) ToAuthBackendPtrOutputWithContext 

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

type AuthBackendPtrInput 

type AuthBackendPtrInput interface {
	pulumi.Input

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

type AuthBackendPtrOutput 

type AuthBackendPtrOutput struct{ *pulumi.OutputState }

func (AuthBackendPtrOutput) Elem added in v4.6.0 

func (o AuthBackendPtrOutput) Elem() AuthBackendOutput

func (AuthBackendPtrOutput) ElementType 

func (AuthBackendPtrOutput) ElementType() reflect.Type

func (AuthBackendPtrOutput) ToAuthBackendPtrOutput 

func (o AuthBackendPtrOutput) ToAuthBackendPtrOutput() AuthBackendPtrOutput

func (AuthBackendPtrOutput) ToAuthBackendPtrOutputWithContext 

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/v4/go/vault/okta"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

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

```

## Import

Okta authentication backend users can be imported using its `path/user` ID format, e.g.

```sh 

$ pulumi import vault:okta/authBackendUser:AuthBackendUser example okta/foo

```

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 

func (*AuthBackendUser) ElementType() reflect.Type

func (*AuthBackendUser) ToAuthBackendUserOutput 

func (i *AuthBackendUser) ToAuthBackendUserOutput() AuthBackendUserOutput

func (*AuthBackendUser) ToAuthBackendUserOutputWithContext 

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

func (*AuthBackendUser) ToAuthBackendUserPtrOutput 

func (i *AuthBackendUser) ToAuthBackendUserPtrOutput() AuthBackendUserPtrOutput

func (*AuthBackendUser) ToAuthBackendUserPtrOutputWithContext 

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 

type AuthBackendUserArray []AuthBackendUserInput

func (AuthBackendUserArray) ElementType 

func (AuthBackendUserArray) ElementType() reflect.Type

func (AuthBackendUserArray) ToAuthBackendUserArrayOutput 

func (i AuthBackendUserArray) ToAuthBackendUserArrayOutput() AuthBackendUserArrayOutput

func (AuthBackendUserArray) ToAuthBackendUserArrayOutputWithContext 

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

type AuthBackendUserArrayInput 

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 

type AuthBackendUserArrayOutput struct{ *pulumi.OutputState }

func (AuthBackendUserArrayOutput) ElementType 

func (AuthBackendUserArrayOutput) ElementType() reflect.Type

func (AuthBackendUserArrayOutput) Index 

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

func (AuthBackendUserArrayOutput) ToAuthBackendUserArrayOutput 

func (o AuthBackendUserArrayOutput) ToAuthBackendUserArrayOutput() AuthBackendUserArrayOutput

func (AuthBackendUserArrayOutput) ToAuthBackendUserArrayOutputWithContext 

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

type AuthBackendUserInput 

type AuthBackendUserInput interface {
	pulumi.Input

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

type AuthBackendUserMap 

type AuthBackendUserMap map[string]AuthBackendUserInput

func (AuthBackendUserMap) ElementType 

func (AuthBackendUserMap) ElementType() reflect.Type

func (AuthBackendUserMap) ToAuthBackendUserMapOutput 

func (i AuthBackendUserMap) ToAuthBackendUserMapOutput() AuthBackendUserMapOutput

func (AuthBackendUserMap) ToAuthBackendUserMapOutputWithContext 

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

type AuthBackendUserMapInput 

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 

type AuthBackendUserMapOutput struct{ *pulumi.OutputState }

func (AuthBackendUserMapOutput) ElementType 

func (AuthBackendUserMapOutput) ElementType() reflect.Type

func (AuthBackendUserMapOutput) MapIndex 

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

func (AuthBackendUserMapOutput) ToAuthBackendUserMapOutput 

func (o AuthBackendUserMapOutput) ToAuthBackendUserMapOutput() AuthBackendUserMapOutput

func (AuthBackendUserMapOutput) ToAuthBackendUserMapOutputWithContext 

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

type AuthBackendUserOutput 

type AuthBackendUserOutput struct{ *pulumi.OutputState }

func (AuthBackendUserOutput) ElementType 

func (AuthBackendUserOutput) ElementType() reflect.Type

func (AuthBackendUserOutput) ToAuthBackendUserOutput 

func (o AuthBackendUserOutput) ToAuthBackendUserOutput() AuthBackendUserOutput

func (AuthBackendUserOutput) ToAuthBackendUserOutputWithContext 

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

func (AuthBackendUserOutput) ToAuthBackendUserPtrOutput 

func (o AuthBackendUserOutput) ToAuthBackendUserPtrOutput() AuthBackendUserPtrOutput

func (AuthBackendUserOutput) ToAuthBackendUserPtrOutputWithContext 

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

type AuthBackendUserPtrInput 

type AuthBackendUserPtrInput interface {
	pulumi.Input

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

type AuthBackendUserPtrOutput 

type AuthBackendUserPtrOutput struct{ *pulumi.OutputState }

func (AuthBackendUserPtrOutput) Elem added in v4.6.0 

func (o AuthBackendUserPtrOutput) Elem() AuthBackendUserOutput

func (AuthBackendUserPtrOutput) ElementType 

func (AuthBackendUserPtrOutput) ElementType() reflect.Type

func (AuthBackendUserPtrOutput) ToAuthBackendUserPtrOutput 

func (o AuthBackendUserPtrOutput) ToAuthBackendUserPtrOutput() AuthBackendUserPtrOutput

func (AuthBackendUserPtrOutput) ToAuthBackendUserPtrOutputWithContext 

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.