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 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.s3.Bucket;
 import com.pulumi.aws.s3.BucketArgs;
 import com.pulumi.aws.iam.IamFunctions;
 import com.pulumi.aws.iam.inputs.GetPolicyDocumentArgs;
 import com.pulumi.aws.iam.inputs.GetPolicyDocumentStatementArgs;
 import com.pulumi.aws.iam.inputs.GetPolicyDocumentStatementPrincipalArgs;
 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.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs;
 import com.pulumi.aws.s3.BucketAcl;
 import com.pulumi.aws.s3.BucketAclArgs;
 import com.pulumi.asset.FileArchive;
 import java.util.ArrayList;
 import java.util.Arrays;
 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 Bucket("bucket", BucketArgs.builder()
             .bucket("tf-test-bucket")
             .build());
 
         final var firehoseAssumeRole = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
             .statements(GetPolicyDocumentStatementArgs.builder()
                 .principals(GetPolicyDocumentStatementPrincipalArgs.builder()
                     .type("Service")
                     .identifiers("firehose.amazonaws.com")
                     .build())
                 .effect("Allow")
                 .actions("sts:AssumeRole")
                 .build())
             .build());
 
         var firehoseRole = new Role("firehoseRole", RoleArgs.builder()
             .name("firehose_test_role")
             .assumeRolePolicy(firehoseAssumeRole.json())
             .build());
 
         final var lambdaAssumeRole = IamFunctions.getPolicyDocument(GetPolicyDocumentArgs.builder()
             .statements(GetPolicyDocumentStatementArgs.builder()
                 .principals(GetPolicyDocumentStatementPrincipalArgs.builder()
                     .type("Service")
                     .identifiers("lambda.amazonaws.com")
                     .build())
                 .effect("Allow")
                 .actions("sts:AssumeRole")
                 .build())
             .build());
 
         var lambdaIam = new Role("lambdaIam", RoleArgs.builder()
             .name("lambda_iam")
             .assumeRolePolicy(lambdaAssumeRole.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("nodejs24.x")
             .build());
 
         var extendedS3Stream = new FirehoseDeliveryStream("extendedS3Stream", FirehoseDeliveryStreamArgs.builder()
             .extendedS3Configuration(FirehoseDeliveryStreamExtendedS3ConfigurationArgs.builder()
                 .processingConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs.builder()
                     .processors(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                         .parameters(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                             .parameterName("LambdaArn")
                             .parameterValue(lambdaProcessor.arn().applyValue(_arn -> String.format("%s:$LATEST", _arn)))
                             .build())
                         .type("Lambda")
                         .build())
                     .enabled(true)
                     .build())
                 .roleArn(firehoseRole.arn())
                 .bucketArn(bucket.arn())
                 .build())
             .name("kinesis-firehose-extended-s3-test-stream")
             .destination("extended_s3")
             .build());
 
         var bucketAcl = new BucketAcl("bucketAcl", BucketAclArgs.builder()
             .bucket(bucket.id())
             .acl("private")
             .build());
 
     }
 }
    ### Extended S3 Destination with dynamic partitioning These examples use built-in Firehose functionality, rather than requiring a lambda. 
     
 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 com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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()
             .extendedS3Configuration(FirehoseDeliveryStreamExtendedS3ConfigurationArgs.builder()
                 .dynamicPartitioningConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs.builder()
                     .enabled(true)
                     .build())
                 .processingConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs.builder()
                     .processors(                    
                         FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                             .parameters(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                 .parameterName("SubRecordType")
                                 .parameterValue("JSON")
                                 .build())
                             .type("RecordDeAggregation")
                             .build(),
                         FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                             .type("AppendDelimiterToRecord")
                             .build(),
                         FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                             .parameters(                            
                                 FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                     .parameterName("JsonParsingEngine")
                                     .parameterValue("JQ-1.6")
                                     .build(),
                                 FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                     .parameterName("MetadataExtractionQuery")
                                     .parameterValue("{customer_id:.customer_id}")
                                     .build())
                             .type("MetadataExtraction")
                             .build())
                     .enabled(true)
                     .build())
                 .roleArn(firehoseRole.arn())
                 .bucketArn(bucket.arn())
                 .bufferingSize(64)
                 .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}/")
                 .build())
             .name("kinesis-firehose-extended-s3-test-stream")
             .destination("extended_s3")
             .build());
 
     }
 }
    Multiple Dynamic Partitioning Keys (maximum of 50) can be added by comma separating the `parameterValue`. The following example adds the Dynamic Partitioning Keys: `storeId` and `customerId` to the S3 prefix. 
     
 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 com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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()
             .extendedS3Configuration(FirehoseDeliveryStreamExtendedS3ConfigurationArgs.builder()
                 .dynamicPartitioningConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationDynamicPartitioningConfigurationArgs.builder()
                     .enabled(true)
                     .build())
                 .processingConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationArgs.builder()
                     .processors(FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorArgs.builder()
                         .parameters(                        
                             FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                 .parameterName("JsonParsingEngine")
                                 .parameterValue("JQ-1.6")
                                 .build(),
                             FirehoseDeliveryStreamExtendedS3ConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                                 .parameterName("MetadataExtractionQuery")
                                 .parameterValue("{store_id:.store_id,customer_id:.customer_id}")
                                 .build())
                         .type("MetadataExtraction")
                         .build())
                     .enabled(true)
                     .build())
                 .roleArn(firehoseRole.arn())
                 .bucketArn(bucket.arn())
                 .bufferingSize(64)
                 .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}/")
                 .build())
             .name("kinesis-firehose-extended-s3-test-stream")
             .destination("extended_s3")
             .build());
 
     }
 }
    ### Redshift Destination 
     
 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.ArrayList;
 import java.util.Arrays;
 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()
             .redshiftConfiguration(FirehoseDeliveryStreamRedshiftConfigurationArgs.builder()
                 .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())
                 .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")
                 .build())
             .name("kinesis-firehose-test-stream")
             .destination("redshift")
             .build());
 
     }
 }
    ### Elasticsearch Destination 
     
 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 com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorParameterArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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()
             .elasticsearchConfiguration(FirehoseDeliveryStreamElasticsearchConfigurationArgs.builder()
                 .s3Configuration(FirehoseDeliveryStreamElasticsearchConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehoseRole.arn())
                     .bucketArn(bucket.arn())
                     .bufferingSize(10)
                     .bufferingInterval(400)
                     .compressionFormat("GZIP")
                     .build())
                 .processingConfiguration(FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationArgs.builder()
                     .processors(FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorArgs.builder()
                         .parameters(FirehoseDeliveryStreamElasticsearchConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                             .parameterName("LambdaArn")
                             .parameterValue(String.format("%s:$LATEST", lambdaProcessor.arn()))
                             .build())
                         .type("Lambda")
                         .build())
                     .enabled(true)
                     .build())
                 .domainArn(testCluster.arn())
                 .roleArn(firehoseRole.arn())
                 .indexName("test")
                 .typeName("test")
                 .build())
             .name("kinesis-firehose-test-stream")
             .destination("elasticsearch")
             .build());
 
     }
 }
    ### Elasticsearch Destination With VPC 
     
 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.inputs.GetPolicyDocumentStatementArgs;
 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.ArrayList;
 import java.util.Arrays;
 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()
             .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())
             .domainName("es-test")
             .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()
             .elasticsearchConfiguration(FirehoseDeliveryStreamElasticsearchConfigurationArgs.builder()
                 .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())
                 .domainArn(testCluster.arn())
                 .roleArn(firehose.arn())
                 .indexName("test")
                 .typeName("test")
                 .build())
             .name("kinesis-firehose-es")
             .destination("elasticsearch")
             .build(), CustomResourceOptions.builder()
                 .dependsOn(firehose_elasticsearchRolePolicy)
                 .build());
 
     }
 }
    ### OpenSearch Destination 
     
 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 com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorParameterArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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()
             .opensearchConfiguration(FirehoseDeliveryStreamOpensearchConfigurationArgs.builder()
                 .s3Configuration(FirehoseDeliveryStreamOpensearchConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehoseRole.arn())
                     .bucketArn(bucket.arn())
                     .bufferingSize(10)
                     .bufferingInterval(400)
                     .compressionFormat("GZIP")
                     .build())
                 .processingConfiguration(FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationArgs.builder()
                     .processors(FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorArgs.builder()
                         .parameters(FirehoseDeliveryStreamOpensearchConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                             .parameterName("LambdaArn")
                             .parameterValue(String.format("%s:$LATEST", lambdaProcessor.arn()))
                             .build())
                         .type("Lambda")
                         .build())
                     .enabled(true)
                     .build())
                 .domainArn(testCluster.arn())
                 .roleArn(firehoseRole.arn())
                 .indexName("test")
                 .build())
             .name("kinesis-firehose-test-stream")
             .destination("opensearch")
             .build());
 
     }
 }
    ### OpenSearch Destination With VPC 
     
 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.ArrayList;
 import java.util.Arrays;
 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()
             .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())
             .domainName("es-test")
             .build());
 
         var firehose_opensearch = new RolePolicy("firehose-opensearch", RolePolicyArgs.builder()
             .name("opensearch")
             .role(firehose.id())
             .policy(testCluster.arn().applyValue(_arn -> """
 {
   \"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\": [
             \"*\"
           ]
         }
   ]
 }
 ", _arn,_arn)))
             .build());
 
         var test = new FirehoseDeliveryStream("test", FirehoseDeliveryStreamArgs.builder()
             .opensearchConfiguration(FirehoseDeliveryStreamOpensearchConfigurationArgs.builder()
                 .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())
                 .domainArn(testCluster.arn())
                 .roleArn(firehose.arn())
                 .indexName("test")
                 .build())
             .name("pulumi-kinesis-firehose-os")
             .destination("opensearch")
             .build(), CustomResourceOptions.builder()
                 .dependsOn(firehose_opensearch)
                 .build());
 
     }
 }
    ### OpenSearch Serverless Destination 
     
 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 com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorParameterArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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()
             .opensearchserverlessConfiguration(FirehoseDeliveryStreamOpensearchserverlessConfigurationArgs.builder()
                 .s3Configuration(FirehoseDeliveryStreamOpensearchserverlessConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehoseRole.arn())
                     .bucketArn(bucket.arn())
                     .bufferingSize(10)
                     .bufferingInterval(400)
                     .compressionFormat("GZIP")
                     .build())
                 .processingConfiguration(FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationArgs.builder()
                     .processors(FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorArgs.builder()
                         .parameters(FirehoseDeliveryStreamOpensearchserverlessConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                             .parameterName("LambdaArn")
                             .parameterValue(String.format("%s:$LATEST", lambdaProcessor.arn()))
                             .build())
                         .type("Lambda")
                         .build())
                     .enabled(true)
                     .build())
                 .collectionEndpoint(testCollection.collectionEndpoint())
                 .roleArn(firehoseRole.arn())
                 .indexName("test")
                 .build())
             .name("kinesis-firehose-test-stream")
             .destination("opensearchserverless")
             .build());
 
     }
 }
    ### Iceberg Destination 
     
 package generated_program;
 
 import com.pulumi.Context;
 import com.pulumi.Pulumi;
 import com.pulumi.core.Output;
 import com.pulumi.aws.AwsFunctions;
 import com.pulumi.aws.inputs.GetCallerIdentityArgs;
 import com.pulumi.aws.inputs.GetPartitionArgs;
 import com.pulumi.aws.inputs.GetRegionArgs;
 import com.pulumi.aws.s3.Bucket;
 import com.pulumi.aws.s3.BucketArgs;
 import com.pulumi.aws.glue.CatalogDatabase;
 import com.pulumi.aws.glue.CatalogDatabaseArgs;
 import com.pulumi.aws.glue.CatalogTable;
 import com.pulumi.aws.glue.CatalogTableArgs;
 import com.pulumi.aws.glue.inputs.CatalogTableOpenTableFormatInputArgs;
 import com.pulumi.aws.glue.inputs.CatalogTableOpenTableFormatInputIcebergInputArgs;
 import com.pulumi.aws.glue.inputs.CatalogTableStorageDescriptorArgs;
 import com.pulumi.aws.glue.inputs.CatalogTableStorageDescriptorColumnArgs;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStream;
 import com.pulumi.aws.kinesis.FirehoseDeliveryStreamArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamIcebergConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamIcebergConfigurationS3ConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamIcebergConfigurationProcessingConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamIcebergConfigurationProcessingConfigurationProcessorArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamIcebergConfigurationProcessingConfigurationProcessorParameterArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamIcebergConfigurationDestinationTableConfigurationArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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) {
         final var current = AwsFunctions.getCallerIdentity(GetCallerIdentityArgs.builder()
             .build());
 
         final var currentGetPartition = AwsFunctions.getPartition(GetPartitionArgs.builder()
             .build());
 
         final var currentGetRegion = AwsFunctions.getRegion(GetRegionArgs.builder()
             .build());
 
         var bucket = new Bucket("bucket", BucketArgs.builder()
             .bucket("test-bucket")
             .forceDestroy(true)
             .build());
 
         var test = new CatalogDatabase("test", CatalogDatabaseArgs.builder()
             .name("test")
             .build());
 
         var testCatalogTable = new CatalogTable("testCatalogTable", CatalogTableArgs.builder()
             .openTableFormatInput(CatalogTableOpenTableFormatInputArgs.builder()
                 .icebergInput(CatalogTableOpenTableFormatInputIcebergInputArgs.builder()
                     .metadataOperation("CREATE")
                     .version("2")
                     .build())
                 .build())
             .storageDescriptor(CatalogTableStorageDescriptorArgs.builder()
                 .columns(CatalogTableStorageDescriptorColumnArgs.builder()
                     .name("my_column_1")
                     .type("int")
                     .build())
                 .location(bucket.id().applyValue(_id -> String.format("s3://%s", _id)))
                 .build())
             .name("test")
             .databaseName(test.name())
             .parameters(Map.of("format", "parquet"))
             .tableType("EXTERNAL_TABLE")
             .build());
 
         var testStream = new FirehoseDeliveryStream("testStream", FirehoseDeliveryStreamArgs.builder()
             .icebergConfiguration(FirehoseDeliveryStreamIcebergConfigurationArgs.builder()
                 .s3Configuration(FirehoseDeliveryStreamIcebergConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehoseRole.arn())
                     .bucketArn(bucket.arn())
                     .build())
                 .processingConfiguration(FirehoseDeliveryStreamIcebergConfigurationProcessingConfigurationArgs.builder()
                     .processors(FirehoseDeliveryStreamIcebergConfigurationProcessingConfigurationProcessorArgs.builder()
                         .parameters(FirehoseDeliveryStreamIcebergConfigurationProcessingConfigurationProcessorParameterArgs.builder()
                             .parameterName("LambdaArn")
                             .parameterValue(String.format("%s:$LATEST", lambdaProcessor.arn()))
                             .build())
                         .type("Lambda")
                         .build())
                     .enabled(true)
                     .build())
                 .destinationTableConfigurations(FirehoseDeliveryStreamIcebergConfigurationDestinationTableConfigurationArgs.builder()
                     .databaseName(test.name())
                     .tableName(testCatalogTable.name())
                     .build())
                 .roleArn(firehoseRole.arn())
                 .catalogArn(String.format("arn:%s:glue:%s:%s:catalog", currentGetPartition.partition(),currentGetRegion.region(),current.accountId()))
                 .bufferingSize(10)
                 .bufferingInterval(400)
                 .build())
             .name("kinesis-firehose-test-stream")
             .destination("iceberg")
             .build());
 
     }
 }
    ### Splunk Destination 
     
 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.ArrayList;
 import java.util.Arrays;
 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()
             .splunkConfiguration(FirehoseDeliveryStreamSplunkConfigurationArgs.builder()
                 .s3Configuration(FirehoseDeliveryStreamSplunkConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehose.arn())
                     .bucketArn(bucket.arn())
                     .bufferingSize(10)
                     .bufferingInterval(400)
                     .compressionFormat("GZIP")
                     .build())
                 .hecEndpoint("https://http-inputs-mydomain.splunkcloud.com:443")
                 .hecToken("51D4DA16-C61B-4F5F-8EC7-ED4301342A4A")
                 .hecAcknowledgmentTimeout(600)
                 .hecEndpointType("Event")
                 .s3BackupMode("FailedEventsOnly")
                 .build())
             .name("kinesis-firehose-test-stream")
             .destination("splunk")
             .build());
 
     }
 }
    ### HTTP Endpoint (e.g., New Relic, Datadog) Destination The HTTP endpoint destination can be used with any vendor that exposes a compatible HTTP intake, including [New Relic](https://docs.newrelic.com/docs/infrastructure/amazon-integrations/connect/aws-firehose/) and [Datadog](https://docs.datadoghq.com/integrations/amazon_kinesis_data_firehose/). Refer to each vendor's documentation for the correct intake URL and authentication requirements. 
     
 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 com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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()
             .httpEndpointConfiguration(FirehoseDeliveryStreamHttpEndpointConfigurationArgs.builder()
                 .s3Configuration(FirehoseDeliveryStreamHttpEndpointConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehose.arn())
                     .bucketArn(bucket.arn())
                     .bufferingSize(10)
                     .bufferingInterval(400)
                     .compressionFormat("GZIP")
                     .build())
                 .requestConfiguration(FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationArgs.builder()
                     .commonAttributes(                    
                         FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs.builder()
                             .name("testname")
                             .value("testvalue")
                             .build(),
                         FirehoseDeliveryStreamHttpEndpointConfigurationRequestConfigurationCommonAttributeArgs.builder()
                             .name("testname2")
                             .value("testvalue2")
                             .build())
                     .contentEncoding("GZIP")
                     .build())
                 .url("https://aws-api.newrelic.com/firehose/v1")
                 .name("New Relic")
                 .accessKey("my-key")
                 .bufferingSize(15)
                 .bufferingInterval(600)
                 .roleArn(firehose.arn())
                 .s3BackupMode("FailedDataOnly")
                 .build())
             .name("kinesis-firehose-test-stream")
             .destination("http_endpoint")
             .build());
 
     }
 }
    ### Snowflake Destination 
     
 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.ArrayList;
 import java.util.Arrays;
 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()
             .snowflakeConfiguration(FirehoseDeliveryStreamSnowflakeConfigurationArgs.builder()
                 .s3Configuration(FirehoseDeliveryStreamSnowflakeConfigurationS3ConfigurationArgs.builder()
                     .roleArn(firehose.arn())
                     .bucketArn(bucket.arn())
                     .bufferingSize(10)
                     .bufferingInterval(400)
                     .compressionFormat("GZIP")
                     .build())
                 .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")
                 .build())
             .name("example-snowflake-destination")
             .destination("snowflake")
             .build());
 
     }
 }
    ### Data Format Conversion 
     
 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.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerHiveJsonSerDeArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationSerializerArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationSerializerOrcSerDeArgs;
 import com.pulumi.aws.kinesis.inputs.FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationSchemaConfigurationArgs;
 import java.util.ArrayList;
 import java.util.Arrays;
 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 FirehoseDeliveryStream("example", FirehoseDeliveryStreamArgs.builder()
             .extendedS3Configuration(FirehoseDeliveryStreamExtendedS3ConfigurationArgs.builder()
                 .dataFormatConversionConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationArgs.builder()
                     .inputFormatConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationArgs.builder()
                         .deserializer(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerArgs.builder()
                             .hiveJsonSerDe(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationInputFormatConfigurationDeserializerHiveJsonSerDeArgs.builder()
                                 .build())
                             .build())
                         .build())
                     .outputFormatConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationArgs.builder()
                         .serializer(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationSerializerArgs.builder()
                             .orcSerDe(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationOutputFormatConfigurationSerializerOrcSerDeArgs.builder()
                                 .build())
                             .build())
                         .build())
                     .schemaConfiguration(FirehoseDeliveryStreamExtendedS3ConfigurationDataFormatConversionConfigurationSchemaConfigurationArgs.builder()
                         .databaseName(exampleAwsGlueCatalogTable.databaseName())
                         .roleArn(exampleAwsIamRole.arn())
                         .tableName(exampleAwsGlueCatalogTable.name())
                         .build())
                     .build())
                 .bufferingSize(128)
                 .build())
             .build());
 
     }
 }
    ## Import ### Identity Schema #### Required - `arn` (String) ARN of the delivery stream. Using `pulumi import`, import Kinesis Firehose Delivery Streams using `arn`. For example: ```sh $ pulumi import aws:kinesis/firehoseDeliveryStream:FirehoseDeliveryStream example arn:aws:firehose:us-east-1:123456789012:deliverystream/example-delivery-stream ``` Note: Import does not work for stream destination `s3`. Consider using `extendedS3` 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:
        ARN specifying the Stream

      • destination

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

      • destinationId

        public com.pulumi.core.Output<java.lang.String> destinationId()
        Returns:
        Identifier of the destination for the delivery stream.

      • elasticsearchConfiguration

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

      • extendedS3Configuration

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

      • httpEndpointConfiguration

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

      • icebergConfiguration

        public com.pulumi.core.Output<java.util.Optional<FirehoseDeliveryStreamIcebergConfiguration>> icebergConfiguration()
        Returns:
        Configuration options when `destination` is `iceberg`. See `icebergConfiguration` block below for details.

      • kinesisSourceConfiguration

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

      • mskSourceConfiguration

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

      • name

        public com.pulumi.core.Output<java.lang.String> name()
        Returns:
        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 `opensearchConfiguration` block below for details.

      • opensearchserverlessConfiguration

        public com.pulumi.core.Output<java.util.Optional<FirehoseDeliveryStreamOpensearchserverlessConfiguration>> opensearchserverlessConfiguration()
        Returns:
        Configuration options when `destination` is `opensearchserverless`. See `opensearchserverlessConfiguration` 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 `s3Configuration` block. See `redshiftConfiguration` block below for details.

      • region

        public com.pulumi.core.Output<java.lang.String> region()
        Returns:
        Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.

      • serverSideEncryption

        public com.pulumi.core.Output<java.util.Optional<FirehoseDeliveryStreamServerSideEncryption>> serverSideEncryption()
        Returns:
        Encrypt at rest options. See `serverSideEncryption` block below for details.

      • snowflakeConfiguration

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

      • splunkConfiguration

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

      • tags

        public com.pulumi.core.Output<java.util.Optional<java.util.Map<java.lang.String,​java.lang.String>>> tags()
        Returns:
        Map of tags to assign to the resource. If configured with a provider `defaultTags` 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:
        Map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.

      • versionId

        public com.pulumi.core.Output<java.lang.String> versionId()
        Returns:
        Version identifier of the delivery stream. > **NOTE:** Server-side encryption should not be enabled when a kinesis stream is configured as the source of the firehose delivery stream.

      • 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.