pulumi-aws-kotlin/com.pulumi.aws.securitylake.kotlin/Subscriber

Subscriber

class Subscriber : KotlinCustomResource

Resource for managing an AWS Security Lake Subscriber.

NOTE: The underlying aws.securitylake.DataLake must be configured before creating the aws.securitylake.Subscriber. Use a depends_on statement.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.securitylake.Subscriber("example", {
    subscriberName: "example-name",
    accessType: "S3",
    source: {
        awsLogSourceResource: {
            sourceName: "ROUTE53",
            sourceVersion: "1.0",
        },
    },
    subscriberIdentity: {
        externalId: "example",
        principal: "1234567890",
    },
}, {
    dependsOn: [exampleAwsSecuritylakeDataLake],
});

import pulumi
import pulumi_aws as aws
example = aws.securitylake.Subscriber("example",
    subscriber_name="example-name",
    access_type="S3",
    source={
        "aws_log_source_resource": {
            "source_name": "ROUTE53",
            "source_version": "1.0",
        },
    },
    subscriber_identity={
        "external_id": "example",
        "principal": "1234567890",
    },
    opts = pulumi.ResourceOptions(depends_on=[example_aws_securitylake_data_lake]))

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.SecurityLake.Subscriber("example", new()
    {
        SubscriberName = "example-name",
        AccessType = "S3",
        Source = new Aws.SecurityLake.Inputs.SubscriberSourceArgs
        {
            AwsLogSourceResource = new Aws.SecurityLake.Inputs.SubscriberSourceAwsLogSourceResourceArgs
            {
                SourceName = "ROUTE53",
                SourceVersion = "1.0",
            },
        },
        SubscriberIdentity = new Aws.SecurityLake.Inputs.SubscriberSubscriberIdentityArgs
        {
            ExternalId = "example",
            Principal = "1234567890",
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleAwsSecuritylakeDataLake,
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/securitylake"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := securitylake.NewSubscriber(ctx, "example", &securitylake.SubscriberArgs{
			SubscriberName: pulumi.String("example-name"),
			AccessType:     pulumi.String("S3"),
			Source: &securitylake.SubscriberSourceArgs{
				AwsLogSourceResource: &securitylake.SubscriberSourceAwsLogSourceResourceArgs{
					SourceName:    pulumi.String("ROUTE53"),
					SourceVersion: pulumi.String("1.0"),
				},
			},
			SubscriberIdentity: &securitylake.SubscriberSubscriberIdentityArgs{
				ExternalId: pulumi.String("example"),
				Principal:  pulumi.String("1234567890"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleAwsSecuritylakeDataLake,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.securitylake.Subscriber;
import com.pulumi.aws.securitylake.SubscriberArgs;
import com.pulumi.aws.securitylake.inputs.SubscriberSourceArgs;
import com.pulumi.aws.securitylake.inputs.SubscriberSourceAwsLogSourceResourceArgs;
import com.pulumi.aws.securitylake.inputs.SubscriberSubscriberIdentityArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new Subscriber("example", SubscriberArgs.builder()
            .subscriberName("example-name")
            .accessType("S3")
            .source(SubscriberSourceArgs.builder()
                .awsLogSourceResource(SubscriberSourceAwsLogSourceResourceArgs.builder()
                    .sourceName("ROUTE53")
                    .sourceVersion("1.0")
                    .build())
                .build())
            .subscriberIdentity(SubscriberSubscriberIdentityArgs.builder()
                .externalId("example")
                .principal("1234567890")
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(exampleAwsSecuritylakeDataLake)
                .build());
    }
}

resources:
  example:
    type: aws:securitylake:Subscriber
    properties:
      subscriberName: example-name
      accessType: S3
      source:
        awsLogSourceResource:
          sourceName: ROUTE53
          sourceVersion: '1.0'
      subscriberIdentity:
        externalId: example
        principal: '1234567890'
    options:
      dependsOn:
        - ${exampleAwsSecuritylakeDataLake}

Import

Using pulumi import, import Security Lake subscriber using the subscriber ID. For example:

$ pulumi import aws:securitylake/subscriber:Subscriber example 9f3bfe79-d543-474d-a93c-f3846805d208

Properties

accessType

val accessType: Output<String>

The Amazon S3 or Lake Formation access type.

arn

val arn: Output<String>

ARN of the Data Lake.

val id: Output<String>

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

resourceShareArn

val resourceShareArn: Output<String>

The Amazon Resource Name (ARN) which uniquely defines the AWS RAM resource share. Before accepting the RAM resource share invitation, you can view details related to the RAM resource share.

resourceShareName

val resourceShareName: Output<String>

The name of the resource share.

roleArn

val roleArn: Output<String>

The ARN of the IAM role to be used by the entity putting logs into your custom source partition.

s3BucketArn

val s3BucketArn: Output<String>

The ARN for the Amazon Security Lake Amazon S3 bucket.

source

val source: Output<SubscriberSource>?

The supported AWS services from which logs and events are collected. Security Lake supports log and event collection for natively supported AWS services. See source Blocks below.

subscriberDescription

val subscriberDescription: Output<String>?

The description for your subscriber account in Security Lake.

subscriberEndpoint

val subscriberEndpoint: Output<String>

The subscriber endpoint to which exception messages are posted.

subscriberIdentity

val subscriberIdentity: Output<SubscriberSubscriberIdentity>?

The AWS identity used to access your data. See subscriber_identity Block below.

subscriberName

val subscriberName: Output<String>?

The name of your Security Lake subscriber account.

subscriberStatus

val subscriberStatus: Output<String>

The subscriber status of the Amazon Security Lake subscriber account.