github.com/pulumi/pulumi-aws/sdk/v6@v6.32.0/go/aws/xray/encryptionConfig.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 xray

import (
	"context"
	"reflect"

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

// Creates and manages an AWS XRay Encryption Config.
//
// > **NOTE:** Removing this resource from the provider has no effect to the encryption configuration within X-Ray.
//
// ## Example Usage
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/xray"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := xray.NewEncryptionConfig(ctx, "example", &xray.EncryptionConfigArgs{
//				Type: pulumi.String("NONE"),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ### With KMS Key
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"fmt"
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws"
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/iam"
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/kms"
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/xray"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			current, err := aws.GetCallerIdentity(ctx, nil, nil)
//			if err != nil {
//				return err
//			}
//			example, err := iam.GetPolicyDocument(ctx, &iam.GetPolicyDocumentArgs{
//				Statements: []iam.GetPolicyDocumentStatement{
//					{
//						Sid:    pulumi.StringRef("Enable IAM User Permissions"),
//						Effect: pulumi.StringRef("Allow"),
//						Principals: []iam.GetPolicyDocumentStatementPrincipal{
//							{
//								Type: "AWS",
//								Identifiers: []string{
//									fmt.Sprintf("arn:aws:iam::%v:root", current.AccountId),
//								},
//							},
//						},
//						Actions: []string{
//							"kms:*",
//						},
//						Resources: []string{
//							"*",
//						},
//					},
//				},
//			}, nil)
//			if err != nil {
//				return err
//			}
//			exampleKey, err := kms.NewKey(ctx, "example", &kms.KeyArgs{
//				Description:          pulumi.String("Some Key"),
//				DeletionWindowInDays: pulumi.Int(7),
//				Policy:               pulumi.String(example.Json),
//			})
//			if err != nil {
//				return err
//			}
//			_, err = xray.NewEncryptionConfig(ctx, "example", &xray.EncryptionConfigArgs{
//				Type:  pulumi.String("KMS"),
//				KeyId: exampleKey.Arn,
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ## Import
//
// Using `pulumi import`, import XRay Encryption Config using the region name. For example:
//
// ```sh
// $ pulumi import aws:xray/encryptionConfig:EncryptionConfig example us-west-2
// ```
type EncryptionConfig struct {
	pulumi.CustomResourceState

	// An AWS KMS customer master key (CMK) ARN.
	KeyId pulumi.StringPtrOutput `pulumi:"keyId"`
	// The type of encryption. Set to `KMS` to use your own key for encryption. Set to `NONE` for default encryption.
	Type pulumi.StringOutput `pulumi:"type"`
}

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

	if args.Type == nil {
		return nil, errors.New("invalid value for required argument 'Type'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource EncryptionConfig
	err := ctx.RegisterResource("aws:xray/encryptionConfig:EncryptionConfig", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

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

// Input properties used for looking up and filtering EncryptionConfig resources.
type encryptionConfigState struct {
	// An AWS KMS customer master key (CMK) ARN.
	KeyId *string `pulumi:"keyId"`
	// The type of encryption. Set to `KMS` to use your own key for encryption. Set to `NONE` for default encryption.
	Type *string `pulumi:"type"`
}

type EncryptionConfigState struct {
	// An AWS KMS customer master key (CMK) ARN.
	KeyId pulumi.StringPtrInput
	// The type of encryption. Set to `KMS` to use your own key for encryption. Set to `NONE` for default encryption.
	Type pulumi.StringPtrInput
}

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

type encryptionConfigArgs struct {
	// An AWS KMS customer master key (CMK) ARN.
	KeyId *string `pulumi:"keyId"`
	// The type of encryption. Set to `KMS` to use your own key for encryption. Set to `NONE` for default encryption.
	Type string `pulumi:"type"`
}

// The set of arguments for constructing a EncryptionConfig resource.
type EncryptionConfigArgs struct {
	// An AWS KMS customer master key (CMK) ARN.
	KeyId pulumi.StringPtrInput
	// The type of encryption. Set to `KMS` to use your own key for encryption. Set to `NONE` for default encryption.
	Type pulumi.StringInput
}

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

type EncryptionConfigInput interface {
	pulumi.Input

	ToEncryptionConfigOutput() EncryptionConfigOutput
	ToEncryptionConfigOutputWithContext(ctx context.Context) EncryptionConfigOutput
}

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

func (i *EncryptionConfig) ToEncryptionConfigOutput() EncryptionConfigOutput {
	return i.ToEncryptionConfigOutputWithContext(context.Background())
}

func (i *EncryptionConfig) ToEncryptionConfigOutputWithContext(ctx context.Context) EncryptionConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EncryptionConfigOutput)
}

// EncryptionConfigArrayInput is an input type that accepts EncryptionConfigArray and EncryptionConfigArrayOutput values.
// You can construct a concrete instance of `EncryptionConfigArrayInput` via:
//
//	EncryptionConfigArray{ EncryptionConfigArgs{...} }
type EncryptionConfigArrayInput interface {
	pulumi.Input

	ToEncryptionConfigArrayOutput() EncryptionConfigArrayOutput
	ToEncryptionConfigArrayOutputWithContext(context.Context) EncryptionConfigArrayOutput
}

type EncryptionConfigArray []EncryptionConfigInput

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

func (i EncryptionConfigArray) ToEncryptionConfigArrayOutput() EncryptionConfigArrayOutput {
	return i.ToEncryptionConfigArrayOutputWithContext(context.Background())
}

func (i EncryptionConfigArray) ToEncryptionConfigArrayOutputWithContext(ctx context.Context) EncryptionConfigArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EncryptionConfigArrayOutput)
}

// EncryptionConfigMapInput is an input type that accepts EncryptionConfigMap and EncryptionConfigMapOutput values.
// You can construct a concrete instance of `EncryptionConfigMapInput` via:
//
//	EncryptionConfigMap{ "key": EncryptionConfigArgs{...} }
type EncryptionConfigMapInput interface {
	pulumi.Input

	ToEncryptionConfigMapOutput() EncryptionConfigMapOutput
	ToEncryptionConfigMapOutputWithContext(context.Context) EncryptionConfigMapOutput
}

type EncryptionConfigMap map[string]EncryptionConfigInput

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

func (i EncryptionConfigMap) ToEncryptionConfigMapOutput() EncryptionConfigMapOutput {
	return i.ToEncryptionConfigMapOutputWithContext(context.Background())
}

func (i EncryptionConfigMap) ToEncryptionConfigMapOutputWithContext(ctx context.Context) EncryptionConfigMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EncryptionConfigMapOutput)
}

type EncryptionConfigOutput struct{ *pulumi.OutputState }

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

func (o EncryptionConfigOutput) ToEncryptionConfigOutput() EncryptionConfigOutput {
	return o
}

func (o EncryptionConfigOutput) ToEncryptionConfigOutputWithContext(ctx context.Context) EncryptionConfigOutput {
	return o
}

// An AWS KMS customer master key (CMK) ARN.
func (o EncryptionConfigOutput) KeyId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EncryptionConfig) pulumi.StringPtrOutput { return v.KeyId }).(pulumi.StringPtrOutput)
}

// The type of encryption. Set to `KMS` to use your own key for encryption. Set to `NONE` for default encryption.
func (o EncryptionConfigOutput) Type() pulumi.StringOutput {
	return o.ApplyT(func(v *EncryptionConfig) pulumi.StringOutput { return v.Type }).(pulumi.StringOutput)
}

type EncryptionConfigArrayOutput struct{ *pulumi.OutputState }

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

func (o EncryptionConfigArrayOutput) ToEncryptionConfigArrayOutput() EncryptionConfigArrayOutput {
	return o
}

func (o EncryptionConfigArrayOutput) ToEncryptionConfigArrayOutputWithContext(ctx context.Context) EncryptionConfigArrayOutput {
	return o
}

func (o EncryptionConfigArrayOutput) Index(i pulumi.IntInput) EncryptionConfigOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EncryptionConfig {
		return vs[0].([]*EncryptionConfig)[vs[1].(int)]
	}).(EncryptionConfigOutput)
}

type EncryptionConfigMapOutput struct{ *pulumi.OutputState }

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

func (o EncryptionConfigMapOutput) ToEncryptionConfigMapOutput() EncryptionConfigMapOutput {
	return o
}

func (o EncryptionConfigMapOutput) ToEncryptionConfigMapOutputWithContext(ctx context.Context) EncryptionConfigMapOutput {
	return o
}

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

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*EncryptionConfigInput)(nil)).Elem(), &EncryptionConfig{})
	pulumi.RegisterInputType(reflect.TypeOf((*EncryptionConfigArrayInput)(nil)).Elem(), EncryptionConfigArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*EncryptionConfigMapInput)(nil)).Elem(), EncryptionConfigMap{})
	pulumi.RegisterOutputType(EncryptionConfigOutput{})
	pulumi.RegisterOutputType(EncryptionConfigArrayOutput{})
	pulumi.RegisterOutputType(EncryptionConfigMapOutput{})
}