Package com.pulumi.aws.kinesis

Class FirehoseDeliveryStream

  • public class FirehoseDeliveryStream
extends com.pulumi.resources.CustomResource
    Provides a Kinesis Firehose Delivery Stream resource. Amazon Kinesis Firehose is a fully managed, elastic service to easily deliver real-time data streams to destinations such as Amazon S3 , Amazon Redshift and Snowflake. For more details, see the [Amazon Kinesis Firehose Documentation](https://aws.amazon.com/documentation/firehose/). ## Example Usage ### Extended S3 Destination <!--Start PulumiCodeChooser --> 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.s3.BucketV2;
 import com.pulumi.aws.s3.BucketV2Args;
 import com.pulumi.aws.iam.IamFunctions;
 import com.pulumi.aws.iam.inputs.GetPolicyDocumentArgs;
 import com.pulumi.aws.iam.Role;
 import com.pulumi.aws.iam.RoleArgs;
 import com.pulumi.aws.lambda.Function;
 import com.pulumi.aws.lambda.FunctionArgs;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs;
 import com.pulumi.aws.s3.BucketAclV2;
 import com.pulumi.aws.s3.BucketAclV2Args;
 import com.pulumi.asset.FileArchive;
 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 bucket = new BucketV2("bucket", BucketV2Args.builder()
             .bucket("tf-test-bucket")
             .build());
 
         final var firehoseAssumeRole = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
             .statements(GetPolicyDocumentStatementArgs.builder()
                 .effect("Allow")
                 .principals(GetPolicyDocumentStatementPrincipalArgs.builder()
                     .type("Service")
                     .identifiers("firehose.amazonaws.com")
                     .build())
                 .actions("sts:AssumeRole")
                 .build())
             .build());
 
         var firehoseRole = new Role("firehoseRole", RoleArgs.builder()
             .name("firehose_test_role")
             .assumeRolePolicy(firehoseAssumeRole.applyValue(getPolicyDocumentResult -> getPolicyDocumentResult.json()))
             .build());
 
         final var lambdaAssumeRole = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
             .statements(GetPolicyDocumentStatementArgs.builder()
                 .effect("Allow")
                 .principals(GetPolicyDocumentStatementPrincipalArgs.builder()
                     .type("Service")
                     .identifiers("lambda.amazonaws.com")
                     .build())
                 .actions("sts:AssumeRole")
                 .build())
             .build());
 
         var lambdaIam = new Role("lambdaIam", RoleArgs.builder()
             .name("lambda_iam")
             .assumeRolePolicy(lambdaAssumeRole.applyValue(getPolicyDocumentResult -> getPolicyDocumentResult.json()))
             .build());
 
         var lambdaProcessor = new Function("lambdaProcessor", FunctionArgs.builder()
             .code(new FileArchive("lambda.zip"))
             .name("firehose_lambda_processor")
             .role(lambdaIam.arn())
             .handler("exports.handler")
             .runtime("nodejs20.x")
             .build());
 
         var extendedS3Stream = new FirehoseDeliveryStream("extendedS3Stream", FirehoseDeliveryStreamArgs.builder()
             .name("kinesis-firehose-extended-s3-test-stream")
             .destination("extended_s3")
             .extendedS3Configuration(FirehoseDeliveryStreamExtendedS3ConfigurationArgs.builder()
                 .roleArn(firehoseRole.arn())
                 .bucketArn(bucket.arn())
                 .processingConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs.builder()
                     .enabled("true")
                     .processors(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                         .type("Lambda")
                         .parameters(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                             .parameterName("LambdaArn")
                             .parameterValue(lambdaProcessor.arn().applyValue(arn -> String.format("%s:$LATEST", arn)))
                             .build())
                         .build())
                     .build())
                 .build())
             .build());
 
         var bucketAcl = new BucketAclV2("bucketAcl", BucketAclV2Args.builder()
             .bucket(bucket.id())
             .acl("private")
             .build());
 
     }
 }
    <!--End PulumiCodeChooser --> ### Extended S3 Destination with dynamic partitioning These examples use built-in Firehose functionality, rather than requiring a lambda. <!--Start PulumiCodeChooser --> 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs;
 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 extendedS3Stream = new FirehoseDeliveryStream("extendedS3Stream", FirehoseDeliveryStreamArgs.builder()
             .name("kinesis-firehose-extended-s3-test-stream")
             .destination("extended_s3")
             .extendedS3Configuration(FirehoseDeliveryStreamExtendedS3ConfigurationArgs.builder()
                 .roleArn(firehoseRole.arn())
                 .bucketArn(bucket.arn())
                 .bufferingSize(64)
                 .dynamicPartitioningConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs.builder()
                     .enabled("true")
                     .build())
                 .prefix("data/customer_id=!{partitionKeyFromQuery:customer_id}/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/")
                 .errorOutputPrefix("errors/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/!{firehose:error-output-type}/")
                 .processingConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs.builder()
                     .enabled("true")
                     .processors(                    
                         FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                             .type("RecordDeAggregation")
                             .parameters(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                 .parameterName("SubRecordType")
                                 .parameterValue("JSON")
                                 .build())
                             .build(),
                         FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                             .type("AppendDelimiterToRecord")
                             .build(),
                         FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                             .type("MetadataExtraction")
                             .parameters(                            
                                 FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                     .parameterName("JsonParsingEngine")
                                     .parameterValue("JQ-1.6")
                                     .build(),
                                 FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                     .parameterName("MetadataExtractionQuery")
                                     .parameterValue("{customer_id:.customer_id}")
                                     .build())
                             .build())
                     .build())
                 .build())
             .build());
 
     }
 }
    <!--End PulumiCodeChooser --> Multiple Dynamic Partitioning Keys (maximum of 50) can be added by comma separating the `parameter_value`. The following example adds the Dynamic Partitioning Keys: `store_id` and `customer_id` to the S3 prefix. <!--Start PulumiCodeChooser --> 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs;
 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 extendedS3Stream = new FirehoseDeliveryStream("extendedS3Stream", FirehoseDeliveryStreamArgs.builder()
             .name("kinesis-firehose-extended-s3-test-stream")
             .destination("extended_s3")
             .extendedS3Configuration(FirehoseDeliveryStreamExtendedS3ConfigurationArgs.builder()
                 .roleArn(firehoseRole.arn())
                 .bucketArn(bucket.arn())
                 .bufferingSize(64)
                 .dynamicPartitioningConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs.builder()
                     .enabled("true")
                     .build())
                 .prefix("data/store_id=!{partitionKeyFromQuery:store_id}/customer_id=!{partitionKeyFromQuery:customer_id}/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/")
                 .errorOutputPrefix("errors/year=!{timestamp:yyyy}/month=!{timestamp:MM}/day=!{timestamp:dd}/hour=!{timestamp:HH}/!{firehose:error-output-type}/")
                 .processingConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs.builder()
                     .enabled("true")
                     .processors(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                         .type("MetadataExtraction")
                         .parameters(                        
                             FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                 .parameterName("JsonParsingEngine")
                                 .parameterValue("JQ-1.6")
                                 .build(),
                             FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                 .parameterName("MetadataExtractionQuery")
                                 .parameterValue("{store_id:.store_id,customer_id:.customer_id}")
                                 .build())
                         .build())
                     .build())
                 .build())
             .build());
 
     }
 }
    <!--End PulumiCodeChooser --> ### Redshift Destination <!--Start PulumiCodeChooser --> 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.redshift.Cluster;
 import com.pulumi.aws.redshift.ClusterArgs;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamRedshiftConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamRedshiftConfigurationS3BackupConfigurationArgs;
 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 testCluster = new Cluster("testCluster", ClusterArgs.builder()
             .clusterIdentifier("tf-redshift-cluster")
             .databaseName("test")
             .masterUsername("testuser")
             .masterPassword("T3stPass")
             .nodeType("dc1.large")
             .clusterType("single-node")
             .build());
 
         var testStream = new FirehoseDeliveryStream("testStream", FirehoseDeliveryStreamArgs.builder()
             .name("kinesis-firehose-test-stream")
             .destination("redshift")
             .redshiftConfiguration(FirehoseDeliveryStreamRedshiftConfigurationArgs.builder()
                 .roleArn(firehoseRole.arn())
                 .clusterJdbcurl(Output.tuple(testCluster.endpoint(), testCluster.databaseName()).applyValue(values -> {
                     var endpoint = values.t1;
                     var databaseName = values.t2;
                     return String.format("jdbc:redshift://%s/%s", endpoint,databaseName);
                 }))
                 .username("testuser")
                 .password("T3stPass")
                 .dataTableName("test-table")
                 .copyOptions("delimiter '|'")
                 .dataTableColumns("test-col")
                 .s3BackupMode("Enabled")
                 .s3Configuration(FirehoseDeliveryStreamRedshiftConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehoseRole.arn())
                     .bucketArn(bucket.arn())
                     .bufferingSize(10)
                     .bufferingInterval(400)
                     .compressionFormat("GZIP")
                     .build())
                 .s3BackupConfiguration(FirehoseDeliveryStreamRedshiftConfigurationS3BackupConfigurationArgs.builder()
                     .roleArn(firehoseRole.arn())
                     .bucketArn(bucket.arn())
                     .bufferingSize(15)
                     .bufferingInterval(300)
                     .compressionFormat("GZIP")
                     .build())
                 .build())
             .build());
 
     }
 }
    <!--End PulumiCodeChooser --> ### Elasticsearch Destination <!--Start PulumiCodeChooser --> 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.elasticsearch.Domain;
 import com.pulumi.aws.elasticsearch.DomainArgs;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamElasticsearchConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationArgs;
 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 testCluster = new Domain("testCluster", DomainArgs.builder()
             .domainName("firehose-es-test")
             .build());
 
         var testStream = new FirehoseDeliveryStream("testStream", FirehoseDeliveryStreamArgs.builder()
             .name("kinesis-firehose-test-stream")
             .destination("elasticsearch")
             .elasticsearchConfiguration(FirehoseDeliveryStreamElasticsearchConfigurationArgs.builder()
                 .domainArn(testCluster.arn())
                 .roleArn(firehoseRole.arn())
                 .indexName("test")
                 .typeName("test")
                 .s3Configuration(FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehoseRole.arn())
                     .bucketArn(bucket.arn())
                     .bufferingSize(10)
                     .bufferingInterval(400)
                     .compressionFormat("GZIP")
                     .build())
                 .processingConfiguration(FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationArgs.builder()
                     .enabled("true")
                     .processors(FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorArgs.builder()
                         .type("Lambda")
                         .parameters(FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                             .parameterName("LambdaArn")
                             .parameterValue(String.format("%s:$LATEST", lambdaProcessor.arn()))
                             .build())
                         .build())
                     .build())
                 .build())
             .build());
 
     }
 }
    <!--End PulumiCodeChooser --> ### Elasticsearch Destination With VPC <!--Start PulumiCodeChooser --> 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.elasticsearch.Domain;
 import com.pulumi.aws.elasticsearch.DomainArgs;
 import com.pulumi.aws.elasticsearch.inputs.DomainClusterConfigArgs;
 import com.pulumi.aws.elasticsearch.inputs.DomainEbsOptionsArgs;
 import com.pulumi.aws.elasticsearch.inputs.DomainVpcOptionsArgs;
 import com.pulumi.aws.iam.IamFunctions;
 import com.pulumi.aws.iam.inputs.GetPolicyDocumentArgs;
 import com.pulumi.aws.iam.RolePolicy;
 import com.pulumi.aws.iam.RolePolicyArgs;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamElasticsearchConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamElasticsearchConfigurationVpcConfigArgs;
 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 testCluster = new Domain("testCluster", DomainArgs.builder()
             .domainName("es-test")
             .clusterConfig(DomainClusterConfigArgs.builder()
                 .instanceCount(2)
                 .zoneAwarenessEnabled(true)
                 .instanceType("t2.small.elasticsearch")
                 .build())
             .ebsOptions(DomainEbsOptionsArgs.builder()
                 .ebsEnabled(true)
                 .volumeSize(10)
                 .build())
             .vpcOptions(DomainVpcOptionsArgs.builder()
                 .securityGroupIds(first.id())
                 .subnetIds(                
                     firstAwsSubnet.id(),
                     second.id())
                 .build())
             .build());
 
         final var firehose-elasticsearch = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
             .statements(            
                 GetPolicyDocumentStatementArgs.builder()
                     .effect("Allow")
                     .actions("es:*")
                     .resources(                    
                         testCluster.arn(),
                         testCluster.arn().applyValue(arn -> String.format("%s/*", arn)))
                     .build(),
                 GetPolicyDocumentStatementArgs.builder()
                     .effect("Allow")
                     .actions(                    
                         "ec2:DescribeVpcs",
                         "ec2:DescribeVpcAttribute",
                         "ec2:DescribeSubnets",
                         "ec2:DescribeSecurityGroups",
                         "ec2:DescribeNetworkInterfaces",
                         "ec2:CreateNetworkInterface",
                         "ec2:CreateNetworkInterfacePermission",
                         "ec2:DeleteNetworkInterface")
                     .resources("*")
                     .build())
             .build());
 
         var firehose_elasticsearchRolePolicy = new RolePolicy("firehose-elasticsearchRolePolicy", RolePolicyArgs.builder()
             .name("elasticsearch")
             .role(firehose.id())
             .policy(firehose_elasticsearch.applyValue(firehose_elasticsearch -> firehose_elasticsearch.json()))
             .build());
 
         var test = new FirehoseDeliveryStream("test", FirehoseDeliveryStreamArgs.builder()
             .name("kinesis-firehose-es")
             .destination("elasticsearch")
             .elasticsearchConfiguration(FirehoseDeliveryStreamElasticsearchConfigurationArgs.builder()
                 .domainArn(testCluster.arn())
                 .roleArn(firehose.arn())
                 .indexName("test")
                 .typeName("test")
                 .s3Configuration(FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehose.arn())
                     .bucketArn(bucket.arn())
                     .build())
                 .vpcConfig(FirehoseDeliveryStreamElasticsearchConfigurationVpcConfigArgs.builder()
                     .subnetIds(                    
                         firstAwsSubnet.id(),
                         second.id())
                     .securityGroupIds(first.id())
                     .roleArn(firehose.arn())
                     .build())
                 .build())
             .build(), CustomResourceOptions.builder()
                 .dependsOn(firehose_elasticsearchRolePolicy)
                 .build());
 
     }
 }
    <!--End PulumiCodeChooser --> ### OpenSearch Destination <!--Start PulumiCodeChooser --> 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.opensearch.Domain;
 import com.pulumi.aws.opensearch.DomainArgs;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationArgs;
 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 testCluster = new Domain("testCluster", DomainArgs.builder()
             .domainName("firehose-os-test")
             .build());
 
         var testStream = new FirehoseDeliveryStream("testStream", FirehoseDeliveryStreamArgs.builder()
             .name("kinesis-firehose-test-stream")
             .destination("opensearch")
             .opensearchConfiguration(FirehoseDeliveryStreamOpensearchConfigurationArgs.builder()
                 .domainArn(testCluster.arn())
                 .roleArn(firehoseRole.arn())
                 .indexName("test")
                 .s3Configuration(FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehoseRole.arn())
                     .bucketArn(bucket.arn())
                     .bufferingSize(10)
                     .bufferingInterval(400)
                     .compressionFormat("GZIP")
                     .build())
                 .processingConfiguration(FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationArgs.builder()
                     .enabled("true")
                     .processors(FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorArgs.builder()
                         .type("Lambda")
                         .parameters(FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                             .parameterName("LambdaArn")
                             .parameterValue(String.format("%s:$LATEST", lambdaProcessor.arn()))
                             .build())
                         .build())
                     .build())
                 .build())
             .build());
 
     }
 }
    <!--End PulumiCodeChooser --> ### OpenSearch Destination With VPC <!--Start PulumiCodeChooser --> 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.opensearch.Domain;
 import com.pulumi.aws.opensearch.DomainArgs;
 import com.pulumi.aws.opensearch.inputs.DomainClusterConfigArgs;
 import com.pulumi.aws.opensearch.inputs.DomainEbsOptionsArgs;
 import com.pulumi.aws.opensearch.inputs.DomainVpcOptionsArgs;
 import com.pulumi.aws.iam.RolePolicy;
 import com.pulumi.aws.iam.RolePolicyArgs;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchConfigurationVpcConfigArgs;
 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 testCluster = new Domain("testCluster", DomainArgs.builder()
             .domainName("es-test")
             .clusterConfig(DomainClusterConfigArgs.builder()
                 .instanceCount(2)
                 .zoneAwarenessEnabled(true)
                 .instanceType("m4.large.search")
                 .build())
             .ebsOptions(DomainEbsOptionsArgs.builder()
                 .ebsEnabled(true)
                 .volumeSize(10)
                 .build())
             .vpcOptions(DomainVpcOptionsArgs.builder()
                 .securityGroupIds(first.id())
                 .subnetIds(                
                     firstAwsSubnet.id(),
                     second.id())
                 .build())
             .build());
 
         var firehose_opensearch = new RolePolicy("firehose-opensearch", RolePolicyArgs.builder()
             .name("opensearch")
             .role(firehose.id())
             .policy(Output.tuple(testCluster.arn(), testCluster.arn()).applyValue(values -> {
                 var testClusterArn = values.t1;
                 var testClusterArn1 = values.t2;
                 return """
 {
   "Version": "2012-10-17",
   "Statement": [
     {
       "Effect": "Allow",
       "Action": [
         "es:*"
       ],
       "Resource": [
         "%s",
         "%s/*"
       ]
         },
         {
           "Effect": "Allow",
           "Action": [
             "ec2:DescribeVpcs",
             "ec2:DescribeVpcAttribute",
             "ec2:DescribeSubnets",
             "ec2:DescribeSecurityGroups",
             "ec2:DescribeNetworkInterfaces",
             "ec2:CreateNetworkInterface",
             "ec2:CreateNetworkInterfacePermission",
             "ec2:DeleteNetworkInterface"
           ],
           "Resource": [
             "*"
           ]
         }
   ]
 }
 ", testClusterArn,testClusterArn1);
             }))
             .build());
 
         var test = new FirehoseDeliveryStream("test", FirehoseDeliveryStreamArgs.builder()
             .name("pulumi-kinesis-firehose-os")
             .destination("opensearch")
             .opensearchConfiguration(FirehoseDeliveryStreamOpensearchConfigurationArgs.builder()
                 .domainArn(testCluster.arn())
                 .roleArn(firehose.arn())
                 .indexName("test")
                 .s3Configuration(FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehose.arn())
                     .bucketArn(bucket.arn())
                     .build())
                 .vpcConfig(FirehoseDeliveryStreamOpensearchConfigurationVpcConfigArgs.builder()
                     .subnetIds(                    
                         firstAwsSubnet.id(),
                         second.id())
                     .securityGroupIds(first.id())
                     .roleArn(firehose.arn())
                     .build())
                 .build())
             .build(), CustomResourceOptions.builder()
                 .dependsOn(firehose_opensearch)
                 .build());
 
     }
 }
    <!--End PulumiCodeChooser --> ### OpenSearch Serverless Destination <!--Start PulumiCodeChooser --> 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.opensearch.ServerlessCollection;
 import com.pulumi.aws.opensearch.ServerlessCollectionArgs;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationS3ConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationArgs;
 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 testCollection = new ServerlessCollection("testCollection", ServerlessCollectionArgs.builder()
             .name("firehose-osserverless-test")
             .build());
 
         var testStream = new FirehoseDeliveryStream("testStream", FirehoseDeliveryStreamArgs.builder()
             .name("kinesis-firehose-test-stream")
             .destination("opensearchserverless")
             .opensearchserverlessConfiguration(FirehoseDeliveryStreamOpensearchserverlessConfigurationArgs.builder()
                 .collectionEndpoint(testCollection.collectionEndpoint())
                 .roleArn(firehoseRole.arn())
                 .indexName("test")
                 .s3Configuration(FirehoseDeliveryStreamOpensearchserverlessConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehoseRole.arn())
                     .bucketArn(bucket.arn())
                     .bufferingSize(10)
                     .bufferingInterval(400)
                     .compressionFormat("GZIP")
                     .build())
                 .processingConfiguration(FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationArgs.builder()
                     .enabled("true")
                     .processors(FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorArgs.builder()
                         .type("Lambda")
                         .parameters(FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                             .parameterName("LambdaArn")
                             .parameterValue(String.format("%s:$LATEST", lambdaProcessor.arn()))
                             .build())
                         .build())
                     .build())
                 .build())
             .build());
 
     }
 }
    <!--End PulumiCodeChooser --> ### Splunk Destination <!--Start PulumiCodeChooser --> 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamSplunkConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamSplunkConfigurationS3ConfigurationArgs;
 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 testStream = new FirehoseDeliveryStream("testStream", FirehoseDeliveryStreamArgs.builder()
             .name("kinesis-firehose-test-stream")
             .destination("splunk")
             .splunkConfiguration(FirehoseDeliveryStreamSplunkConfigurationArgs.builder()
                 .hecEndpoint("https://http-inputs-mydomain.splunkcloud.com:443")
                 .hecToken("51D4DA16-C61B-4F5F-8EC7-ED4301342A4A")
                 .hecAcknowledgmentTimeout(600)
                 .hecEndpointType("Event")
                 .s3BackupMode("FailedEventsOnly")
                 .s3Configuration(FirehoseDeliveryStreamSplunkConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehose.arn())
                     .bucketArn(bucket.arn())
                     .bufferingSize(10)
                     .bufferingInterval(400)
                     .compressionFormat("GZIP")
                     .build())
                 .build())
             .build());
 
     }
 }
    <!--End PulumiCodeChooser --> ### HTTP Endpoint (e.g., New Relic) Destination <!--Start PulumiCodeChooser --> 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamHttpEndpointConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamHttpEndpointConfigurationS3ConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationArgs;
 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 testStream = new FirehoseDeliveryStream("testStream", FirehoseDeliveryStreamArgs.builder()
             .name("kinesis-firehose-test-stream")
             .destination("http_endpoint")
             .httpEndpointConfiguration(FirehoseDeliveryStreamHttpEndpointConfigurationArgs.builder()
                 .url("https://aws-api.newrelic.com/firehose/v1")
                 .name("New Relic")
                 .accessKey("my-key")
                 .bufferingSize(15)
                 .bufferingInterval(600)
                 .roleArn(firehose.arn())
                 .s3BackupMode("FailedDataOnly")
                 .s3Configuration(FirehoseDeliveryStreamHttpEndpointConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehose.arn())
                     .bucketArn(bucket.arn())
                     .bufferingSize(10)
                     .bufferingInterval(400)
                     .compressionFormat("GZIP")
                     .build())
                 .requestConfiguration(FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationArgs.builder()
                     .contentEncoding("GZIP")
                     .commonAttributes(                    
                         FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs.builder()
                             .name("testname")
                             .value("testvalue")
                             .build(),
                         FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs.builder()
                             .name("testname2")
                             .value("testvalue2")
                             .build())
                     .build())
                 .build())
             .build());
 
     }
 }
    <!--End PulumiCodeChooser --> ### Snowflake Destination <!--Start PulumiCodeChooser --> 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamSnowflakeConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamSnowflakeConfigurationS3ConfigurationArgs;
 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 exampleSnowflakeDestination = new FirehoseDeliveryStream("exampleSnowflakeDestination", FirehoseDeliveryStreamArgs.builder()
             .name("example-snowflake-destination")
             .destination("snowflake")
             .snowflakeConfiguration(FirehoseDeliveryStreamSnowflakeConfigurationArgs.builder()
                 .accountUrl("https://example.snowflakecomputing.com")
                 .bufferingSize(15)
                 .bufferingInterval(600)
                 .database("example-db")
                 .privateKey("...")
                 .roleArn(firehose.arn())
                 .schema("example-schema")
                 .table("example-table")
                 .user("example-usr")
                 .s3Configuration(FirehoseDeliveryStreamSnowflakeConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehose.arn())
                     .bucketArn(bucket.arn())
                     .bufferingSize(10)
                     .bufferingInterval(400)
                     .compressionFormat("GZIP")
                     .build())
                 .build())
             .build());
 
     }
 }
    <!--End PulumiCodeChooser --> ## Import Using `pulumi import`, import Kinesis Firehose Delivery streams using the stream ARN. For example: ```sh $ pulumi import aws:kinesis/firehoseDeliveryStream:FirehoseDeliveryStream foo arn:aws:firehose:us-east-1:XXX:deliverystream/example ``` Note: Import does not work for stream destination `s3`. Consider using `extended_s3` since `s3` destination is deprecated.

    • Constructor Detail

      • FirehoseDeliveryStream

        public FirehoseDeliveryStream​(java.lang.String name)
        Parameters:
        name - The _unique_ name of the resulting resource.

      • FirehoseDeliveryStream

        public FirehoseDeliveryStream​(java.lang.String name,
                              FirehoseDeliveryStreamArgs args)
        Parameters:
        name - The _unique_ name of the resulting resource.
        args - The arguments to use to populate this resource's properties.

      • FirehoseDeliveryStream

        public FirehoseDeliveryStream​(java.lang.String name,
                              FirehoseDeliveryStreamArgs args,
                              @Nullable
                              com.pulumi.resources.CustomResourceOptions options)
        Parameters:
        name - The _unique_ name of the resulting resource.
        args - The arguments to use to populate this resource's properties.
        options - A bag of options that control this resource's behavior.

    • Method Detail

      • arn

        public com.pulumi.core.Output<java.lang.String> arn()
        Returns:
        The Amazon Resource Name (ARN) specifying the Stream

      • destination

        public com.pulumi.core.Output<java.lang.String> destination()
        Returns:
        This is the destination to where the data is delivered. The only options are `s3` (Deprecated, use `extended_s3` instead), `extended_s3`, `redshift`, `elasticsearch`, `splunk`, `http_endpoint`, `opensearch`, `opensearchserverless` and `snowflake`.

      • destinationId

        public com.pulumi.core.Output<java.lang.String> destinationId()

      • elasticsearchConfiguration

        public com.pulumi.core.Output<java.util.Optional<FirehoseDeliveryStreamElasticsearchConfiguration>> elasticsearchConfiguration()
        Returns:
        Configuration options when `destination` is `elasticsearch`. See `elasticsearch_configuration` block below for details.

      • extendedS3Configuration

        public com.pulumi.core.Output<java.util.Optional<FirehoseDeliveryStreamExtendedS3Configuration>> extendedS3Configuration()
        Returns:
        Enhanced configuration options for the s3 destination. See `extended_s3_configuration` block below for details.

      • httpEndpointConfiguration

        public com.pulumi.core.Output<java.util.Optional<FirehoseDeliveryStreamHttpEndpointConfiguration>> httpEndpointConfiguration()
        Returns:
        Configuration options when `destination` is `http_endpoint`. Requires the user to also specify an `s3_configuration` block. See `http_endpoint_configuration` block below for details.

      • kinesisSourceConfiguration

        public com.pulumi.core.Output<java.util.Optional<FirehoseDeliveryStreamKinesisSourceConfiguration>> kinesisSourceConfiguration()
        Returns:
        The stream and role Amazon Resource Names (ARNs) for a Kinesis data stream used as the source for a delivery stream. See `kinesis_source_configuration` block below for details.

      • mskSourceConfiguration

        public com.pulumi.core.Output<java.util.Optional<FirehoseDeliveryStreamMskSourceConfiguration>> mskSourceConfiguration()
        Returns:
        The configuration for the Amazon MSK cluster to be used as the source for a delivery stream. See `msk_source_configuration` block below for details.

      • name

        public com.pulumi.core.Output<java.lang.String> name()
        Returns:
        A name to identify the stream. This is unique to the AWS account and region the Stream is created in. When using for WAF logging, name must be prefixed with `aws-waf-logs-`. See [AWS Documentation](https://docs.aws.amazon.com/waf/latest/developerguide/waf-policies.html#waf-policies-logging-config) for more details.

      • opensearchConfiguration

        public com.pulumi.core.Output<java.util.Optional<FirehoseDeliveryStreamOpensearchConfiguration>> opensearchConfiguration()
        Returns:
        Configuration options when `destination` is `opensearch`. See `opensearch_configuration` block below for details.

      • opensearchserverlessConfiguration

        public com.pulumi.core.Output<java.util.Optional<FirehoseDeliveryStreamOpensearchserverlessConfiguration>> opensearchserverlessConfiguration()
        Returns:
        Configuration options when `destination` is `opensearchserverless`. See `opensearchserverless_configuration` block below for details.

      • redshiftConfiguration

        public com.pulumi.core.Output<java.util.Optional<FirehoseDeliveryStreamRedshiftConfiguration>> redshiftConfiguration()
        Returns:
        Configuration options when `destination` is `redshift`. Requires the user to also specify an `s3_configuration` block. See `redshift_configuration` block below for details.

      • serverSideEncryption

        public com.pulumi.core.Output<java.util.Optional<FirehoseDeliveryStreamServerSideEncryption>> serverSideEncryption()
        Returns:
        Encrypt at rest options. See `server_side_encryption` block below for details. **NOTE:** Server-side encryption should not be enabled when a kinesis stream is configured as the source of the firehose delivery stream.

      • snowflakeConfiguration

        public com.pulumi.core.Output<java.util.Optional<FirehoseDeliveryStreamSnowflakeConfiguration>> snowflakeConfiguration()
        Returns:
        Configuration options when `destination` is `snowflake`. See `snowflake_configuration` block below for details.

      • splunkConfiguration

        public com.pulumi.core.Output<java.util.Optional<FirehoseDeliveryStreamSplunkConfiguration>> splunkConfiguration()
        Returns:
        Configuration options when `destination` is `splunk`. See `splunk_configuration` block below for details.

      • tags

        public com.pulumi.core.Output<java.util.Optional<java.util.Map<java.lang.String,​java.lang.String>>> tags()
        Returns:
        A map of tags to assign to the resource. If configured with a provider `default_tags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.

      • tagsAll

        public com.pulumi.core.Output<java.util.Map<java.lang.String,​java.lang.String>> tagsAll()
        Returns:
        A map of tags assigned to the resource, including those inherited from the provider `default_tags` configuration block.

      • versionId

        public com.pulumi.core.Output<java.lang.String> versionId()

      • get

        public static FirehoseDeliveryStream get​(java.lang.String name,
                                         com.pulumi.core.Output<java.lang.String> id,
                                         @Nullable
                                         FirehoseDeliveryStreamState state,
                                         @Nullable
                                         com.pulumi.resources.CustomResourceOptions options)
        Get an existing Host resource's state with the given name, ID, and optional extra properties used to qualify the lookup.
        Parameters:
        name - The _unique_ name of the resulting resource.
        id - The _unique_ provider ID of the resource to lookup.
        state -
        options - Optional settings to control the behavior of the CustomResource.