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

import (
	"context"
	"reflect"

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

// Resource for managing a Verified Access Logging Configuration.
//
// ## Example Usage
//
// ### With CloudWatch Logging
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/verifiedaccess"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := verifiedaccess.NewInstanceLoggingConfiguration(ctx, "example", &verifiedaccess.InstanceLoggingConfigurationArgs{
//				AccessLogs: &verifiedaccess.InstanceLoggingConfigurationAccessLogsArgs{
//					CloudwatchLogs: &verifiedaccess.InstanceLoggingConfigurationAccessLogsCloudwatchLogsArgs{
//						Enabled:  pulumi.Bool(true),
//						LogGroup: pulumi.Any(exampleAwsCloudwatchLogGroup.Id),
//					},
//				},
//				VerifiedaccessInstanceId: pulumi.Any(exampleAwsVerifiedaccessInstance.Id),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ### With Kinesis Data Firehose Logging
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/verifiedaccess"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := verifiedaccess.NewInstanceLoggingConfiguration(ctx, "example", &verifiedaccess.InstanceLoggingConfigurationArgs{
//				AccessLogs: &verifiedaccess.InstanceLoggingConfigurationAccessLogsArgs{
//					KinesisDataFirehose: &verifiedaccess.InstanceLoggingConfigurationAccessLogsKinesisDataFirehoseArgs{
//						DeliveryStream: pulumi.Any(exampleAwsKinesisFirehoseDeliveryStream.Name),
//						Enabled:        pulumi.Bool(true),
//					},
//				},
//				VerifiedaccessInstanceId: pulumi.Any(exampleAwsVerifiedaccessInstance.Id),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ### With S3 logging
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/verifiedaccess"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := verifiedaccess.NewInstanceLoggingConfiguration(ctx, "example", &verifiedaccess.InstanceLoggingConfigurationArgs{
//				AccessLogs: &verifiedaccess.InstanceLoggingConfigurationAccessLogsArgs{
//					S3: &verifiedaccess.InstanceLoggingConfigurationAccessLogsS3Args{
//						BucketName: pulumi.Any(exampleAwsS3Bucket.Id),
//						Enabled:    pulumi.Bool(true),
//						Prefix:     pulumi.String("example"),
//					},
//				},
//				VerifiedaccessInstanceId: pulumi.Any(exampleAwsVerifiedaccessInstance.Id),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ### With all three logging options
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/verifiedaccess"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := verifiedaccess.NewInstanceLoggingConfiguration(ctx, "example", &verifiedaccess.InstanceLoggingConfigurationArgs{
//				AccessLogs: &verifiedaccess.InstanceLoggingConfigurationAccessLogsArgs{
//					CloudwatchLogs: &verifiedaccess.InstanceLoggingConfigurationAccessLogsCloudwatchLogsArgs{
//						Enabled:  pulumi.Bool(true),
//						LogGroup: pulumi.Any(exampleAwsCloudwatchLogGroup.Id),
//					},
//					KinesisDataFirehose: &verifiedaccess.InstanceLoggingConfigurationAccessLogsKinesisDataFirehoseArgs{
//						DeliveryStream: pulumi.Any(exampleAwsKinesisFirehoseDeliveryStream.Name),
//						Enabled:        pulumi.Bool(true),
//					},
//					S3: &verifiedaccess.InstanceLoggingConfigurationAccessLogsS3Args{
//						BucketName: pulumi.Any(exampleAwsS3Bucket.Id),
//						Enabled:    pulumi.Bool(true),
//					},
//				},
//				VerifiedaccessInstanceId: pulumi.Any(exampleAwsVerifiedaccessInstance.Id),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ### With `includeTrustContext`
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/verifiedaccess"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := verifiedaccess.NewInstanceLoggingConfiguration(ctx, "example", &verifiedaccess.InstanceLoggingConfigurationArgs{
//				AccessLogs: &verifiedaccess.InstanceLoggingConfigurationAccessLogsArgs{
//					IncludeTrustContext: pulumi.Bool(true),
//				},
//				VerifiedaccessInstanceId: pulumi.Any(exampleAwsVerifiedaccessInstance.Id),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ### With `logVersion`
//
// <!--Start PulumiCodeChooser -->
// ```go
// package main
//
// import (
//
//	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/verifiedaccess"
//	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
//
// )
//
//	func main() {
//		pulumi.Run(func(ctx *pulumi.Context) error {
//			_, err := verifiedaccess.NewInstanceLoggingConfiguration(ctx, "example", &verifiedaccess.InstanceLoggingConfigurationArgs{
//				AccessLogs: &verifiedaccess.InstanceLoggingConfigurationAccessLogsArgs{
//					LogVersion: pulumi.String("ocsf-1.0.0-rc.2"),
//				},
//				VerifiedaccessInstanceId: pulumi.Any(exampleAwsVerifiedaccessInstance.Id),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
// <!--End PulumiCodeChooser -->
//
// ## Import
//
// Using `pulumi import`, import Verified Access Logging Configuration using the Verified Access Instance `id`. For example:
//
// ```sh
// $ pulumi import aws:verifiedaccess/instanceLoggingConfiguration:InstanceLoggingConfiguration example vai-1234567890abcdef0
// ```
type InstanceLoggingConfiguration struct {
	pulumi.CustomResourceState

	// A block that specifies the configuration options for Verified Access instances. Detailed below.
	AccessLogs InstanceLoggingConfigurationAccessLogsOutput `pulumi:"accessLogs"`
	// The ID of the Verified Access instance.
	VerifiedaccessInstanceId pulumi.StringOutput `pulumi:"verifiedaccessInstanceId"`
}

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

	if args.AccessLogs == nil {
		return nil, errors.New("invalid value for required argument 'AccessLogs'")
	}
	if args.VerifiedaccessInstanceId == nil {
		return nil, errors.New("invalid value for required argument 'VerifiedaccessInstanceId'")
	}
	opts = internal.PkgResourceDefaultOpts(opts)
	var resource InstanceLoggingConfiguration
	err := ctx.RegisterResource("aws:verifiedaccess/instanceLoggingConfiguration:InstanceLoggingConfiguration", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

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

// Input properties used for looking up and filtering InstanceLoggingConfiguration resources.
type instanceLoggingConfigurationState struct {
	// A block that specifies the configuration options for Verified Access instances. Detailed below.
	AccessLogs *InstanceLoggingConfigurationAccessLogs `pulumi:"accessLogs"`
	// The ID of the Verified Access instance.
	VerifiedaccessInstanceId *string `pulumi:"verifiedaccessInstanceId"`
}

type InstanceLoggingConfigurationState struct {
	// A block that specifies the configuration options for Verified Access instances. Detailed below.
	AccessLogs InstanceLoggingConfigurationAccessLogsPtrInput
	// The ID of the Verified Access instance.
	VerifiedaccessInstanceId pulumi.StringPtrInput
}

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

type instanceLoggingConfigurationArgs struct {
	// A block that specifies the configuration options for Verified Access instances. Detailed below.
	AccessLogs InstanceLoggingConfigurationAccessLogs `pulumi:"accessLogs"`
	// The ID of the Verified Access instance.
	VerifiedaccessInstanceId string `pulumi:"verifiedaccessInstanceId"`
}

// The set of arguments for constructing a InstanceLoggingConfiguration resource.
type InstanceLoggingConfigurationArgs struct {
	// A block that specifies the configuration options for Verified Access instances. Detailed below.
	AccessLogs InstanceLoggingConfigurationAccessLogsInput
	// The ID of the Verified Access instance.
	VerifiedaccessInstanceId pulumi.StringInput
}

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

type InstanceLoggingConfigurationInput interface {
	pulumi.Input

	ToInstanceLoggingConfigurationOutput() InstanceLoggingConfigurationOutput
	ToInstanceLoggingConfigurationOutputWithContext(ctx context.Context) InstanceLoggingConfigurationOutput
}

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

func (i *InstanceLoggingConfiguration) ToInstanceLoggingConfigurationOutput() InstanceLoggingConfigurationOutput {
	return i.ToInstanceLoggingConfigurationOutputWithContext(context.Background())
}

func (i *InstanceLoggingConfiguration) ToInstanceLoggingConfigurationOutputWithContext(ctx context.Context) InstanceLoggingConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(InstanceLoggingConfigurationOutput)
}

// InstanceLoggingConfigurationArrayInput is an input type that accepts InstanceLoggingConfigurationArray and InstanceLoggingConfigurationArrayOutput values.
// You can construct a concrete instance of `InstanceLoggingConfigurationArrayInput` via:
//
//	InstanceLoggingConfigurationArray{ InstanceLoggingConfigurationArgs{...} }
type InstanceLoggingConfigurationArrayInput interface {
	pulumi.Input

	ToInstanceLoggingConfigurationArrayOutput() InstanceLoggingConfigurationArrayOutput
	ToInstanceLoggingConfigurationArrayOutputWithContext(context.Context) InstanceLoggingConfigurationArrayOutput
}

type InstanceLoggingConfigurationArray []InstanceLoggingConfigurationInput

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

func (i InstanceLoggingConfigurationArray) ToInstanceLoggingConfigurationArrayOutput() InstanceLoggingConfigurationArrayOutput {
	return i.ToInstanceLoggingConfigurationArrayOutputWithContext(context.Background())
}

func (i InstanceLoggingConfigurationArray) ToInstanceLoggingConfigurationArrayOutputWithContext(ctx context.Context) InstanceLoggingConfigurationArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(InstanceLoggingConfigurationArrayOutput)
}

// InstanceLoggingConfigurationMapInput is an input type that accepts InstanceLoggingConfigurationMap and InstanceLoggingConfigurationMapOutput values.
// You can construct a concrete instance of `InstanceLoggingConfigurationMapInput` via:
//
//	InstanceLoggingConfigurationMap{ "key": InstanceLoggingConfigurationArgs{...} }
type InstanceLoggingConfigurationMapInput interface {
	pulumi.Input

	ToInstanceLoggingConfigurationMapOutput() InstanceLoggingConfigurationMapOutput
	ToInstanceLoggingConfigurationMapOutputWithContext(context.Context) InstanceLoggingConfigurationMapOutput
}

type InstanceLoggingConfigurationMap map[string]InstanceLoggingConfigurationInput

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

func (i InstanceLoggingConfigurationMap) ToInstanceLoggingConfigurationMapOutput() InstanceLoggingConfigurationMapOutput {
	return i.ToInstanceLoggingConfigurationMapOutputWithContext(context.Background())
}

func (i InstanceLoggingConfigurationMap) ToInstanceLoggingConfigurationMapOutputWithContext(ctx context.Context) InstanceLoggingConfigurationMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(InstanceLoggingConfigurationMapOutput)
}

type InstanceLoggingConfigurationOutput struct{ *pulumi.OutputState }

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

func (o InstanceLoggingConfigurationOutput) ToInstanceLoggingConfigurationOutput() InstanceLoggingConfigurationOutput {
	return o
}

func (o InstanceLoggingConfigurationOutput) ToInstanceLoggingConfigurationOutputWithContext(ctx context.Context) InstanceLoggingConfigurationOutput {
	return o
}

// A block that specifies the configuration options for Verified Access instances. Detailed below.
func (o InstanceLoggingConfigurationOutput) AccessLogs() InstanceLoggingConfigurationAccessLogsOutput {
	return o.ApplyT(func(v *InstanceLoggingConfiguration) InstanceLoggingConfigurationAccessLogsOutput {
		return v.AccessLogs
	}).(InstanceLoggingConfigurationAccessLogsOutput)
}

// The ID of the Verified Access instance.
func (o InstanceLoggingConfigurationOutput) VerifiedaccessInstanceId() pulumi.StringOutput {
	return o.ApplyT(func(v *InstanceLoggingConfiguration) pulumi.StringOutput { return v.VerifiedaccessInstanceId }).(pulumi.StringOutput)
}

type InstanceLoggingConfigurationArrayOutput struct{ *pulumi.OutputState }

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

func (o InstanceLoggingConfigurationArrayOutput) ToInstanceLoggingConfigurationArrayOutput() InstanceLoggingConfigurationArrayOutput {
	return o
}

func (o InstanceLoggingConfigurationArrayOutput) ToInstanceLoggingConfigurationArrayOutputWithContext(ctx context.Context) InstanceLoggingConfigurationArrayOutput {
	return o
}

func (o InstanceLoggingConfigurationArrayOutput) Index(i pulumi.IntInput) InstanceLoggingConfigurationOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *InstanceLoggingConfiguration {
		return vs[0].([]*InstanceLoggingConfiguration)[vs[1].(int)]
	}).(InstanceLoggingConfigurationOutput)
}

type InstanceLoggingConfigurationMapOutput struct{ *pulumi.OutputState }

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

func (o InstanceLoggingConfigurationMapOutput) ToInstanceLoggingConfigurationMapOutput() InstanceLoggingConfigurationMapOutput {
	return o
}

func (o InstanceLoggingConfigurationMapOutput) ToInstanceLoggingConfigurationMapOutputWithContext(ctx context.Context) InstanceLoggingConfigurationMapOutput {
	return o
}

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

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*InstanceLoggingConfigurationInput)(nil)).Elem(), &InstanceLoggingConfiguration{})
	pulumi.RegisterInputType(reflect.TypeOf((*InstanceLoggingConfigurationArrayInput)(nil)).Elem(), InstanceLoggingConfigurationArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*InstanceLoggingConfigurationMapInput)(nil)).Elem(), InstanceLoggingConfigurationMap{})
	pulumi.RegisterOutputType(InstanceLoggingConfigurationOutput{})
	pulumi.RegisterOutputType(InstanceLoggingConfigurationArrayOutput{})
	pulumi.RegisterOutputType(InstanceLoggingConfigurationMapOutput{})
}