github.com/pulumi/pulumi-aws/sdk/v6@v6.32.0/go/aws/lambda/provisionedConcurrencyConfig.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package lambda

import (
	"context"
	"reflect"

	"errors"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// Manages a Lambda Provisioned Concurrency Configuration.
//
// > **NOTE:** Setting `skipDestroy` to `true` means that the AWS Provider will _not_ destroy a provisioned concurrency configuration, even when running `pulumi destroy`. The configuration is thus an intentional dangling resource that is _not_ managed by Pulumi and may incur extra expense in your AWS account.
//
// ## Example Usage
//
// ### Alias Name
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lambda"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := lambda.NewProvisionedConcurrencyConfig(ctx, "example", &lambda.ProvisionedConcurrencyConfigArgs{
//				FunctionName:                    pulumi.Any(exampleAwsLambdaAlias.FunctionName),
//				ProvisionedConcurrentExecutions: pulumi.Int(1),
//				Qualifier:                       pulumi.Any(exampleAwsLambdaAlias.Name),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ### Function Version
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lambda"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := lambda.NewProvisionedConcurrencyConfig(ctx, "example", &lambda.ProvisionedConcurrencyConfigArgs{
//				FunctionName:                    pulumi.Any(exampleAwsLambdaFunction.FunctionName),
//				ProvisionedConcurrentExecutions: pulumi.Int(1),
//				Qualifier:                       pulumi.Any(exampleAwsLambdaFunction.Version),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ## Import
//
// Using `pulumi import`, import a Lambda Provisioned Concurrency Configuration using the `function_name` and `qualifier` separated by a comma (`,`). For example:
//
// ```sh
// $ pulumi import aws:lambda/provisionedConcurrencyConfig:ProvisionedConcurrencyConfig example my_function,production
// ```
type ProvisionedConcurrencyConfig struct {
	pulumi.CustomResourceState

	// Name or Amazon Resource Name (ARN) of the Lambda Function.
	FunctionName pulumi.StringOutput `pulumi:"functionName"`
	// Amount of capacity to allocate. Must be greater than or equal to `1`.
	ProvisionedConcurrentExecutions pulumi.IntOutput `pulumi:"provisionedConcurrentExecutions"`
	// Lambda Function version or Lambda Alias name.
	//
	// The following arguments are optional:
	Qualifier pulumi.StringOutput `pulumi:"qualifier"`
	// Whether to retain the provisoned concurrency configuration upon destruction. Defaults to `false`. If set to `true`, the resource in simply removed from state instead.
	SkipDestroy pulumi.BoolPtrOutput `pulumi:"skipDestroy"`
}

// NewProvisionedConcurrencyConfig registers a new resource with the given unique name, arguments, and options.
func NewProvisionedConcurrencyConfig(ctx *pulumi.Context,
	name string, args *ProvisionedConcurrencyConfigArgs, opts ...pulumi.ResourceOption) (*ProvisionedConcurrencyConfig, error) {
	if args == nil {
		return nil, errors.New("missing one or more required arguments")
	}

	if args.FunctionName == nil {
		return nil, errors.New("invalid value for required argument 'FunctionName'")
	}
	if args.ProvisionedConcurrentExecutions == nil {
		return nil, errors.New("invalid value for required argument 'ProvisionedConcurrentExecutions'")
	}
	if args.Qualifier == nil {
		return nil, errors.New("invalid value for required argument 'Qualifier'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource ProvisionedConcurrencyConfig
	err := ctx.RegisterResource("aws:lambda/provisionedConcurrencyConfig:ProvisionedConcurrencyConfig", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetProvisionedConcurrencyConfig gets an existing ProvisionedConcurrencyConfig 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 GetProvisionedConcurrencyConfig(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ProvisionedConcurrencyConfigState, opts ...pulumi.ResourceOption) (*ProvisionedConcurrencyConfig, error) {
	var resource ProvisionedConcurrencyConfig
	err := ctx.ReadResource("aws:lambda/provisionedConcurrencyConfig:ProvisionedConcurrencyConfig", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering ProvisionedConcurrencyConfig resources.
type provisionedConcurrencyConfigState struct {
	// Name or Amazon Resource Name (ARN) of the Lambda Function.
	FunctionName *string `pulumi:"functionName"`
	// Amount of capacity to allocate. Must be greater than or equal to `1`.
	ProvisionedConcurrentExecutions *int `pulumi:"provisionedConcurrentExecutions"`
	// Lambda Function version or Lambda Alias name.
	//
	// The following arguments are optional:
	Qualifier *string `pulumi:"qualifier"`
	// Whether to retain the provisoned concurrency configuration upon destruction. Defaults to `false`. If set to `true`, the resource in simply removed from state instead.
	SkipDestroy *bool `pulumi:"skipDestroy"`
}

type ProvisionedConcurrencyConfigState struct {
	// Name or Amazon Resource Name (ARN) of the Lambda Function.
	FunctionName pulumi.StringPtrInput
	// Amount of capacity to allocate. Must be greater than or equal to `1`.
	ProvisionedConcurrentExecutions pulumi.IntPtrInput
	// Lambda Function version or Lambda Alias name.
	//
	// The following arguments are optional:
	Qualifier pulumi.StringPtrInput
	// Whether to retain the provisoned concurrency configuration upon destruction. Defaults to `false`. If set to `true`, the resource in simply removed from state instead.
	SkipDestroy pulumi.BoolPtrInput
}

func (ProvisionedConcurrencyConfigState) ElementType() reflect.Type {
	return reflect.TypeOf((*provisionedConcurrencyConfigState)(nil)).Elem()
}

type provisionedConcurrencyConfigArgs struct {
	// Name or Amazon Resource Name (ARN) of the Lambda Function.
	FunctionName string `pulumi:"functionName"`
	// Amount of capacity to allocate. Must be greater than or equal to `1`.
	ProvisionedConcurrentExecutions int `pulumi:"provisionedConcurrentExecutions"`
	// Lambda Function version or Lambda Alias name.
	//
	// The following arguments are optional:
	Qualifier string `pulumi:"qualifier"`
	// Whether to retain the provisoned concurrency configuration upon destruction. Defaults to `false`. If set to `true`, the resource in simply removed from state instead.
	SkipDestroy *bool `pulumi:"skipDestroy"`
}

// The set of arguments for constructing a ProvisionedConcurrencyConfig resource.
type ProvisionedConcurrencyConfigArgs struct {
	// Name or Amazon Resource Name (ARN) of the Lambda Function.
	FunctionName pulumi.StringInput
	// Amount of capacity to allocate. Must be greater than or equal to `1`.
	ProvisionedConcurrentExecutions pulumi.IntInput
	// Lambda Function version or Lambda Alias name.
	//
	// The following arguments are optional:
	Qualifier pulumi.StringInput
	// Whether to retain the provisoned concurrency configuration upon destruction. Defaults to `false`. If set to `true`, the resource in simply removed from state instead.
	SkipDestroy pulumi.BoolPtrInput
}

func (ProvisionedConcurrencyConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*provisionedConcurrencyConfigArgs)(nil)).Elem()
}

type ProvisionedConcurrencyConfigInput interface {
	pulumi.Input

	ToProvisionedConcurrencyConfigOutput() ProvisionedConcurrencyConfigOutput
	ToProvisionedConcurrencyConfigOutputWithContext(ctx context.Context) ProvisionedConcurrencyConfigOutput
}

func (*ProvisionedConcurrencyConfig) ElementType() reflect.Type {
	return reflect.TypeOf((**ProvisionedConcurrencyConfig)(nil)).Elem()
}

func (i *ProvisionedConcurrencyConfig) ToProvisionedConcurrencyConfigOutput() ProvisionedConcurrencyConfigOutput {
	return i.ToProvisionedConcurrencyConfigOutputWithContext(context.Background())
}

func (i *ProvisionedConcurrencyConfig) ToProvisionedConcurrencyConfigOutputWithContext(ctx context.Context) ProvisionedConcurrencyConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ProvisionedConcurrencyConfigOutput)
}

// ProvisionedConcurrencyConfigArrayInput is an input type that accepts ProvisionedConcurrencyConfigArray and ProvisionedConcurrencyConfigArrayOutput values.
// You can construct a concrete instance of `ProvisionedConcurrencyConfigArrayInput` via:
//
//	ProvisionedConcurrencyConfigArray{ ProvisionedConcurrencyConfigArgs{...} }
type ProvisionedConcurrencyConfigArrayInput interface {
	pulumi.Input

	ToProvisionedConcurrencyConfigArrayOutput() ProvisionedConcurrencyConfigArrayOutput
	ToProvisionedConcurrencyConfigArrayOutputWithContext(context.Context) ProvisionedConcurrencyConfigArrayOutput
}

type ProvisionedConcurrencyConfigArray []ProvisionedConcurrencyConfigInput

func (ProvisionedConcurrencyConfigArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*ProvisionedConcurrencyConfig)(nil)).Elem()
}

func (i ProvisionedConcurrencyConfigArray) ToProvisionedConcurrencyConfigArrayOutput() ProvisionedConcurrencyConfigArrayOutput {
	return i.ToProvisionedConcurrencyConfigArrayOutputWithContext(context.Background())
}

func (i ProvisionedConcurrencyConfigArray) ToProvisionedConcurrencyConfigArrayOutputWithContext(ctx context.Context) ProvisionedConcurrencyConfigArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ProvisionedConcurrencyConfigArrayOutput)
}

// ProvisionedConcurrencyConfigMapInput is an input type that accepts ProvisionedConcurrencyConfigMap and ProvisionedConcurrencyConfigMapOutput values.
// You can construct a concrete instance of `ProvisionedConcurrencyConfigMapInput` via:
//
//	ProvisionedConcurrencyConfigMap{ "key": ProvisionedConcurrencyConfigArgs{...} }
type ProvisionedConcurrencyConfigMapInput interface {
	pulumi.Input

	ToProvisionedConcurrencyConfigMapOutput() ProvisionedConcurrencyConfigMapOutput
	ToProvisionedConcurrencyConfigMapOutputWithContext(context.Context) ProvisionedConcurrencyConfigMapOutput
}

type ProvisionedConcurrencyConfigMap map[string]ProvisionedConcurrencyConfigInput

func (ProvisionedConcurrencyConfigMap) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*ProvisionedConcurrencyConfig)(nil)).Elem()
}

func (i ProvisionedConcurrencyConfigMap) ToProvisionedConcurrencyConfigMapOutput() ProvisionedConcurrencyConfigMapOutput {
	return i.ToProvisionedConcurrencyConfigMapOutputWithContext(context.Background())
}

func (i ProvisionedConcurrencyConfigMap) ToProvisionedConcurrencyConfigMapOutputWithContext(ctx context.Context) ProvisionedConcurrencyConfigMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ProvisionedConcurrencyConfigMapOutput)
}

type ProvisionedConcurrencyConfigOutput struct{ *pulumi.OutputState }

func (ProvisionedConcurrencyConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ProvisionedConcurrencyConfig)(nil)).Elem()
}

func (o ProvisionedConcurrencyConfigOutput) ToProvisionedConcurrencyConfigOutput() ProvisionedConcurrencyConfigOutput {
	return o
}

func (o ProvisionedConcurrencyConfigOutput) ToProvisionedConcurrencyConfigOutputWithContext(ctx context.Context) ProvisionedConcurrencyConfigOutput {
	return o
}

// Name or Amazon Resource Name (ARN) of the Lambda Function.
func (o ProvisionedConcurrencyConfigOutput) FunctionName() pulumi.StringOutput {
	return o.ApplyT(func(v *ProvisionedConcurrencyConfig) pulumi.StringOutput { return v.FunctionName }).(pulumi.StringOutput)
}

// Amount of capacity to allocate. Must be greater than or equal to `1`.
func (o ProvisionedConcurrencyConfigOutput) ProvisionedConcurrentExecutions() pulumi.IntOutput {
	return o.ApplyT(func(v *ProvisionedConcurrencyConfig) pulumi.IntOutput { return v.ProvisionedConcurrentExecutions }).(pulumi.IntOutput)
}

// Lambda Function version or Lambda Alias name.
//
// The following arguments are optional:
func (o ProvisionedConcurrencyConfigOutput) Qualifier() pulumi.StringOutput {
	return o.ApplyT(func(v *ProvisionedConcurrencyConfig) pulumi.StringOutput { return v.Qualifier }).(pulumi.StringOutput)
}

// Whether to retain the provisoned concurrency configuration upon destruction. Defaults to `false`. If set to `true`, the resource in simply removed from state instead.
func (o ProvisionedConcurrencyConfigOutput) SkipDestroy() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ProvisionedConcurrencyConfig) pulumi.BoolPtrOutput { return v.SkipDestroy }).(pulumi.BoolPtrOutput)
}

type ProvisionedConcurrencyConfigArrayOutput struct{ *pulumi.OutputState }

func (ProvisionedConcurrencyConfigArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*ProvisionedConcurrencyConfig)(nil)).Elem()
}

func (o ProvisionedConcurrencyConfigArrayOutput) ToProvisionedConcurrencyConfigArrayOutput() ProvisionedConcurrencyConfigArrayOutput {
	return o
}

func (o ProvisionedConcurrencyConfigArrayOutput) ToProvisionedConcurrencyConfigArrayOutputWithContext(ctx context.Context) ProvisionedConcurrencyConfigArrayOutput {
	return o
}

func (o ProvisionedConcurrencyConfigArrayOutput) Index(i pulumi.IntInput) ProvisionedConcurrencyConfigOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ProvisionedConcurrencyConfig {
		return vs[0].([]*ProvisionedConcurrencyConfig)[vs[1].(int)]
	}).(ProvisionedConcurrencyConfigOutput)
}

type ProvisionedConcurrencyConfigMapOutput struct{ *pulumi.OutputState }

func (ProvisionedConcurrencyConfigMapOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*ProvisionedConcurrencyConfig)(nil)).Elem()
}

func (o ProvisionedConcurrencyConfigMapOutput) ToProvisionedConcurrencyConfigMapOutput() ProvisionedConcurrencyConfigMapOutput {
	return o
}

func (o ProvisionedConcurrencyConfigMapOutput) ToProvisionedConcurrencyConfigMapOutputWithContext(ctx context.Context) ProvisionedConcurrencyConfigMapOutput {
	return o
}

func (o ProvisionedConcurrencyConfigMapOutput) MapIndex(k pulumi.StringInput) ProvisionedConcurrencyConfigOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ProvisionedConcurrencyConfig {
		return vs[0].(map[string]*ProvisionedConcurrencyConfig)[vs[1].(string)]
	}).(ProvisionedConcurrencyConfigOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*ProvisionedConcurrencyConfigInput)(nil)).Elem(), &ProvisionedConcurrencyConfig{})
	pulumi.RegisterInputType(reflect.TypeOf((*ProvisionedConcurrencyConfigArrayInput)(nil)).Elem(), ProvisionedConcurrencyConfigArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ProvisionedConcurrencyConfigMapInput)(nil)).Elem(), ProvisionedConcurrencyConfigMap{})
	pulumi.RegisterOutputType(ProvisionedConcurrencyConfigOutput{})
	pulumi.RegisterOutputType(ProvisionedConcurrencyConfigArrayOutput{})
	pulumi.RegisterOutputType(ProvisionedConcurrencyConfigMapOutput{})
}