S3Endpoint class

Provides a DMS (Data Migration Service) S3 endpoint resource. DMS S3 endpoints can be created, updated, deleted, and imported.

> Note: AWS is deprecating extraConnectionAttributes, such as used with aws.dms.Endpoint. This resource is an alternative to aws.dms.Endpoint and does not use extraConnectionAttributes. (AWS currently includes extraConnectionAttributes in the raw responses to the AWS Provider requests and so they may be visible in the logs.)

> Note: Some of this resource's arguments have default values that come from the AWS Provider. Other default values are provided by AWS and subject to change without notice. When relying on AWS defaults, the provider state will often have a zero value. For example, the AWS Provider does not provide a default for cdcMaxBatchInterval but the AWS default is 60 (seconds). However, the provider state will show 0 since this is the value return by AWS when no value is present. Below, we aim to flag the defaults that come from AWS (e.g., "AWS default...").

Example Usage

Minimal Configuration

This is the minimal configuration for an aws.dms.S3Endpoint. This endpoint will rely on the AWS Provider and AWS defaults.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.dms.S3Endpoint("example", {
    endpointId: "donnedtipi",
    endpointType: "target",
    bucketName: "beckut_name",
    serviceAccessRoleArn: exampleAwsIamRole.arn,
}, {
    dependsOn: [exampleAwsIamRolePolicy],
});
import pulumi
import pulumi_aws as aws

example = aws.dms.S3Endpoint("example",
    endpoint_id="donnedtipi",
    endpoint_type="target",
    bucket_name="beckut_name",
    service_access_role_arn=example_aws_iam_role["arn"],
    opts = pulumi.ResourceOptions(depends_on=[example_aws_iam_role_policy]))
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Dms.S3Endpoint("example", new()
    {
        EndpointId = "donnedtipi",
        EndpointType = "target",
        BucketName = "beckut_name",
        ServiceAccessRoleArn = exampleAwsIamRole.Arn,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleAwsIamRolePolicy,
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/dms"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dms.NewS3Endpoint(ctx, "example", &dms.S3EndpointArgs{
			EndpointId:           pulumi.String("donnedtipi"),
			EndpointType:         pulumi.String("target"),
			BucketName:           pulumi.String("beckut_name"),
			ServiceAccessRoleArn: pulumi.Any(exampleAwsIamRole.Arn),
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleAwsIamRolePolicy,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_dms_s3endpoint" "example" {
  depends_on              = [exampleAwsIamRolePolicy]
  endpoint_id             = "donnedtipi"
  endpoint_type           = "target"
  bucket_name             = "beckut_name"
  service_access_role_arn = exampleAwsIamRole.arn
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.dms.S3Endpoint;
import com.pulumi.aws.dms.S3EndpointArgs;
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 example = new S3Endpoint("example", S3EndpointArgs.builder()
            .endpointId("donnedtipi")
            .endpointType("target")
            .bucketName("beckut_name")
            .serviceAccessRoleArn(exampleAwsIamRole.arn())
            .build(), CustomResourceOptions.builder()
                .dependsOn(exampleAwsIamRolePolicy)
                .build());

    }
}
resources:
  example:
    type: aws:dms:S3Endpoint
    properties:
      endpointId: donnedtipi
      endpointType: target
      bucketName: beckut_name
      serviceAccessRoleArn: ${exampleAwsIamRole.arn}
    options:
      dependsOn:
        - ${exampleAwsIamRolePolicy}

Complete Configuration

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.dms.S3Endpoint("example", {
    endpointId: "donnedtipi",
    endpointType: "target",
    sslMode: "none",
    tags: {
        Name: "donnedtipi",
        Update: "to-update",
        Remove: "to-remove",
    },
    addColumnName: true,
    addTrailingPaddingCharacter: false,
    bucketFolder: "folder",
    bucketName: "bucket_name",
    cannedAclForObjects: "private",
    cdcInsertsAndUpdates: true,
    cdcInsertsOnly: false,
    cdcMaxBatchInterval: 100,
    cdcMinFileSize: 16,
    cdcPath: "cdc/path",
    compressionType: "GZIP",
    csvDelimiter: ";",
    csvNoSupValue: "x",
    csvNullValue: "?",
    csvRowDelimiter: "\\r\\n",
    dataFormat: "parquet",
    dataPageSize: 1100000,
    datePartitionDelimiter: "UNDERSCORE",
    datePartitionEnabled: true,
    datePartitionSequence: "yyyymmddhh",
    datePartitionTimezone: "Asia/Seoul",
    dictPageSizeLimit: 1000000,
    enableStatistics: false,
    encodingType: "plain",
    encryptionMode: "SSE_S3",
    expectedBucketOwner: current.accountId,
    externalTableDefinition: "etd",
    ignoreHeaderRows: 1,
    includeOpForFullLoad: true,
    maxFileSize: 1000000,
    parquetTimestampInMillisecond: true,
    parquetVersion: "parquet-2-0",
    preserveTransactions: false,
    rfc4180: false,
    rowGroupLength: 11000,
    serverSideEncryptionKmsKeyId: exampleAwsKmsKey.arn,
    serviceAccessRoleArn: exampleAwsIamRole.arn,
    timestampColumnName: "tx_commit_time",
    useCsvNoSupValue: false,
    useTaskStartTimeForFullLoadTimestamp: true,
    glueCatalogGeneration: true,
}, {
    dependsOn: [exampleAwsIamRolePolicy],
});
import pulumi
import pulumi_aws as aws

example = aws.dms.S3Endpoint("example",
    endpoint_id="donnedtipi",
    endpoint_type="target",
    ssl_mode="none",
    tags={
        "Name": "donnedtipi",
        "Update": "to-update",
        "Remove": "to-remove",
    },
    add_column_name=True,
    add_trailing_padding_character=False,
    bucket_folder="folder",
    bucket_name="bucket_name",
    canned_acl_for_objects="private",
    cdc_inserts_and_updates=True,
    cdc_inserts_only=False,
    cdc_max_batch_interval=100,
    cdc_min_file_size=16,
    cdc_path="cdc/path",
    compression_type="GZIP",
    csv_delimiter=";",
    csv_no_sup_value="x",
    csv_null_value="?",
    csv_row_delimiter="\\r\\n",
    data_format="parquet",
    data_page_size=1100000,
    date_partition_delimiter="UNDERSCORE",
    date_partition_enabled=True,
    date_partition_sequence="yyyymmddhh",
    date_partition_timezone="Asia/Seoul",
    dict_page_size_limit=1000000,
    enable_statistics=False,
    encoding_type="plain",
    encryption_mode="SSE_S3",
    expected_bucket_owner=current["accountId"],
    external_table_definition="etd",
    ignore_header_rows=1,
    include_op_for_full_load=True,
    max_file_size=1000000,
    parquet_timestamp_in_millisecond=True,
    parquet_version="parquet-2-0",
    preserve_transactions=False,
    rfc4180=False,
    row_group_length=11000,
    server_side_encryption_kms_key_id=example_aws_kms_key["arn"],
    service_access_role_arn=example_aws_iam_role["arn"],
    timestamp_column_name="tx_commit_time",
    use_csv_no_sup_value=False,
    use_task_start_time_for_full_load_timestamp=True,
    glue_catalog_generation=True,
    opts = pulumi.ResourceOptions(depends_on=[example_aws_iam_role_policy]))
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Dms.S3Endpoint("example", new()
    {
        EndpointId = "donnedtipi",
        EndpointType = "target",
        SslMode = "none",
        Tags =
        {
            { "Name", "donnedtipi" },
            { "Update", "to-update" },
            { "Remove", "to-remove" },
        },
        AddColumnName = true,
        AddTrailingPaddingCharacter = false,
        BucketFolder = "folder",
        BucketName = "bucket_name",
        CannedAclForObjects = "private",
        CdcInsertsAndUpdates = true,
        CdcInsertsOnly = false,
        CdcMaxBatchInterval = 100,
        CdcMinFileSize = 16,
        CdcPath = "cdc/path",
        CompressionType = "GZIP",
        CsvDelimiter = ";",
        CsvNoSupValue = "x",
        CsvNullValue = "?",
        CsvRowDelimiter = "\\r\\n",
        DataFormat = "parquet",
        DataPageSize = 1100000,
        DatePartitionDelimiter = "UNDERSCORE",
        DatePartitionEnabled = true,
        DatePartitionSequence = "yyyymmddhh",
        DatePartitionTimezone = "Asia/Seoul",
        DictPageSizeLimit = 1000000,
        EnableStatistics = false,
        EncodingType = "plain",
        EncryptionMode = "SSE_S3",
        ExpectedBucketOwner = current.AccountId,
        ExternalTableDefinition = "etd",
        IgnoreHeaderRows = 1,
        IncludeOpForFullLoad = true,
        MaxFileSize = 1000000,
        ParquetTimestampInMillisecond = true,
        ParquetVersion = "parquet-2-0",
        PreserveTransactions = false,
        Rfc4180 = false,
        RowGroupLength = 11000,
        ServerSideEncryptionKmsKeyId = exampleAwsKmsKey.Arn,
        ServiceAccessRoleArn = exampleAwsIamRole.Arn,
        TimestampColumnName = "tx_commit_time",
        UseCsvNoSupValue = false,
        UseTaskStartTimeForFullLoadTimestamp = true,
        GlueCatalogGeneration = true,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            exampleAwsIamRolePolicy,
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/dms"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dms.NewS3Endpoint(ctx, "example", &dms.S3EndpointArgs{
			EndpointId:   pulumi.String("donnedtipi"),
			EndpointType: pulumi.String("target"),
			SslMode:      pulumi.String("none"),
			Tags: pulumi.StringMap{
				"Name":   pulumi.String("donnedtipi"),
				"Update": pulumi.String("to-update"),
				"Remove": pulumi.String("to-remove"),
			},
			AddColumnName:                        pulumi.Bool(true),
			AddTrailingPaddingCharacter:          pulumi.Bool(false),
			BucketFolder:                         pulumi.String("folder"),
			BucketName:                           pulumi.String("bucket_name"),
			CannedAclForObjects:                  pulumi.String("private"),
			CdcInsertsAndUpdates:                 pulumi.Bool(true),
			CdcInsertsOnly:                       pulumi.Bool(false),
			CdcMaxBatchInterval:                  pulumi.Int(100),
			CdcMinFileSize:                       pulumi.Int(16),
			CdcPath:                              pulumi.String("cdc/path"),
			CompressionType:                      pulumi.String("GZIP"),
			CsvDelimiter:                         pulumi.String(";"),
			CsvNoSupValue:                        pulumi.String("x"),
			CsvNullValue:                         pulumi.String("?"),
			CsvRowDelimiter:                      pulumi.String("\\r\\n"),
			DataFormat:                           pulumi.String("parquet"),
			DataPageSize:                         pulumi.Int(1100000),
			DatePartitionDelimiter:               pulumi.String("UNDERSCORE"),
			DatePartitionEnabled:                 pulumi.Bool(true),
			DatePartitionSequence:                pulumi.String("yyyymmddhh"),
			DatePartitionTimezone:                pulumi.String("Asia/Seoul"),
			DictPageSizeLimit:                    pulumi.Int(1000000),
			EnableStatistics:                     pulumi.Bool(false),
			EncodingType:                         pulumi.String("plain"),
			EncryptionMode:                       pulumi.String("SSE_S3"),
			ExpectedBucketOwner:                  pulumi.Any(current.AccountId),
			ExternalTableDefinition:              pulumi.String("etd"),
			IgnoreHeaderRows:                     pulumi.Int(1),
			IncludeOpForFullLoad:                 pulumi.Bool(true),
			MaxFileSize:                          pulumi.Int(1000000),
			ParquetTimestampInMillisecond:        pulumi.Bool(true),
			ParquetVersion:                       pulumi.String("parquet-2-0"),
			PreserveTransactions:                 pulumi.Bool(false),
			Rfc4180:                              pulumi.Bool(false),
			RowGroupLength:                       pulumi.Int(11000),
			ServerSideEncryptionKmsKeyId:         pulumi.Any(exampleAwsKmsKey.Arn),
			ServiceAccessRoleArn:                 pulumi.Any(exampleAwsIamRole.Arn),
			TimestampColumnName:                  pulumi.String("tx_commit_time"),
			UseCsvNoSupValue:                     pulumi.Bool(false),
			UseTaskStartTimeForFullLoadTimestamp: pulumi.Bool(true),
			GlueCatalogGeneration:                pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleAwsIamRolePolicy,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_dms_s3endpoint" "example" {
  depends_on    = [exampleAwsIamRolePolicy]
  endpoint_id   = "donnedtipi"
  endpoint_type = "target"
  ssl_mode      = "none"
  tags = {
    "Name"   = "donnedtipi"
    "Update" = "to-update"
    "Remove" = "to-remove"
  }
  add_column_name                             = true
  add_trailing_padding_character              = false
  bucket_folder                               = "folder"
  bucket_name                                 = "bucket_name"
  canned_acl_for_objects                      = "private"
  cdc_inserts_and_updates                     = true
  cdc_inserts_only                            = false
  cdc_max_batch_interval                      = 100
  cdc_min_file_size                           = 16
  cdc_path                                    = "cdc/path"
  compression_type                            = "GZIP"
  csv_delimiter                               = ";"
  csv_no_sup_value                            = "x"
  csv_null_value                              = "?"
  csv_row_delimiter                           = "\\r\\n"
  data_format                                 = "parquet"
  data_page_size                              = 1100000
  date_partition_delimiter                    = "UNDERSCORE"
  date_partition_enabled                      = true
  date_partition_sequence                     = "yyyymmddhh"
  date_partition_timezone                     = "Asia/Seoul"
  dict_page_size_limit                        = 1000000
  enable_statistics                           = false
  encoding_type                               = "plain"
  encryption_mode                             = "SSE_S3"
  expected_bucket_owner                       = current.accountId
  external_table_definition                   = "etd"
  ignore_header_rows                          = 1
  include_op_for_full_load                    = true
  max_file_size                               = 1000000
  parquet_timestamp_in_millisecond            = true
  parquet_version                             = "parquet-2-0"
  preserve_transactions                       = false
  rfc4180                                     = false
  row_group_length                            = 11000
  server_side_encryption_kms_key_id           = exampleAwsKmsKey.arn
  service_access_role_arn                     = exampleAwsIamRole.arn
  timestamp_column_name                       = "tx_commit_time"
  use_csv_no_sup_value                        = false
  use_task_start_time_for_full_load_timestamp = true
  glue_catalog_generation                     = true
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.dms.S3Endpoint;
import com.pulumi.aws.dms.S3EndpointArgs;
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 example = new S3Endpoint("example", S3EndpointArgs.builder()
            .endpointId("donnedtipi")
            .endpointType("target")
            .sslMode("none")
            .tags(Map.ofEntries(
                Map.entry("Name", "donnedtipi"),
                Map.entry("Update", "to-update"),
                Map.entry("Remove", "to-remove")
            ))
            .addColumnName(true)
            .addTrailingPaddingCharacter(false)
            .bucketFolder("folder")
            .bucketName("bucket_name")
            .cannedAclForObjects("private")
            .cdcInsertsAndUpdates(true)
            .cdcInsertsOnly(false)
            .cdcMaxBatchInterval(100)
            .cdcMinFileSize(16)
            .cdcPath("cdc/path")
            .compressionType("GZIP")
            .csvDelimiter(";")
            .csvNoSupValue("x")
            .csvNullValue("?")
            .csvRowDelimiter("\\r\\n")
            .dataFormat("parquet")
            .dataPageSize(1100000)
            .datePartitionDelimiter("UNDERSCORE")
            .datePartitionEnabled(true)
            .datePartitionSequence("yyyymmddhh")
            .datePartitionTimezone("Asia/Seoul")
            .dictPageSizeLimit(1000000)
            .enableStatistics(false)
            .encodingType("plain")
            .encryptionMode("SSE_S3")
            .expectedBucketOwner(current.accountId())
            .externalTableDefinition("etd")
            .ignoreHeaderRows(1)
            .includeOpForFullLoad(true)
            .maxFileSize(1000000)
            .parquetTimestampInMillisecond(true)
            .parquetVersion("parquet-2-0")
            .preserveTransactions(false)
            .rfc4180(false)
            .rowGroupLength(11000)
            .serverSideEncryptionKmsKeyId(exampleAwsKmsKey.arn())
            .serviceAccessRoleArn(exampleAwsIamRole.arn())
            .timestampColumnName("tx_commit_time")
            .useCsvNoSupValue(false)
            .useTaskStartTimeForFullLoadTimestamp(true)
            .glueCatalogGeneration(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(exampleAwsIamRolePolicy)
                .build());

    }
}
resources:
  example:
    type: aws:dms:S3Endpoint
    properties:
      endpointId: donnedtipi
      endpointType: target
      sslMode: none
      tags:
        Name: donnedtipi
        Update: to-update
        Remove: to-remove
      addColumnName: true
      addTrailingPaddingCharacter: false
      bucketFolder: folder
      bucketName: bucket_name
      cannedAclForObjects: private
      cdcInsertsAndUpdates: true
      cdcInsertsOnly: false
      cdcMaxBatchInterval: 100
      cdcMinFileSize: 16
      cdcPath: cdc/path
      compressionType: GZIP
      csvDelimiter: ;
      csvNoSupValue: x
      csvNullValue: '?'
      csvRowDelimiter: \r\n
      dataFormat: parquet
      dataPageSize: 1.1e+06
      datePartitionDelimiter: UNDERSCORE
      datePartitionEnabled: true
      datePartitionSequence: yyyymmddhh
      datePartitionTimezone: Asia/Seoul
      dictPageSizeLimit: 1e+06
      enableStatistics: false
      encodingType: plain
      encryptionMode: SSE_S3
      expectedBucketOwner: ${current.accountId}
      externalTableDefinition: etd
      ignoreHeaderRows: 1
      includeOpForFullLoad: true
      maxFileSize: 1e+06
      parquetTimestampInMillisecond: true
      parquetVersion: parquet-2-0
      preserveTransactions: false
      rfc4180: false
      rowGroupLength: 11000
      serverSideEncryptionKmsKeyId: ${exampleAwsKmsKey.arn}
      serviceAccessRoleArn: ${exampleAwsIamRole.arn}
      timestampColumnName: tx_commit_time
      useCsvNoSupValue: false
      useTaskStartTimeForFullLoadTimestamp: true
      glueCatalogGeneration: true
    options:
      dependsOn:
        - ${exampleAwsIamRolePolicy}

Import

Using pulumi import, import endpoints using the endpointId. For example:

$ pulumi import aws:dms/s3Endpoint:S3Endpoint example example-dms-endpoint-tf

Constructors

S3Endpoint(String name, {S3EndpointArgs? args, CustomResourceOptions? options})
Creates a new S3Endpoint. name The Pulumi resource name. args Arguments used to configure this S3Endpoint. The set of arguments for S3Endpoint. options Resource options controlling this resource's behavior.
S3Endpoint.reference(String urn)
Creates a typed reference to an existing S3Endpoint resource.

Properties

addColumnName ↔ Output<bool?>
Whether to add column name information to the .csv output file. Default is false.
latefinal
addTrailingPaddingCharacter ↔ Output<bool?>
Whether to add padding. Default is false. (Ignored for source endpoints.)
latefinal
bucketFolder ↔ Output<String?>
S3 object prefix.
latefinal
bucketName ↔ Output<String>
S3 bucket name.
latefinal
cannedAclForObjects ↔ Output<String?>
Predefined (canned) access control list for objects created in an S3 bucket. Valid values include none, private, public-read, public-read-write, authenticated-read, aws-exec-read, bucket-owner-read, and bucket-owner-full-control. Default is none.
latefinal
cdcInsertsAndUpdates ↔ Output<bool?>
Whether to write insert and update operations to .csv or .parquet output files. Default is false.
latefinal
cdcInsertsOnly ↔ Output<bool?>
Whether to write insert operations to .csv or .parquet output files. Default is false.
latefinal
cdcMaxBatchInterval ↔ Output<int?>
Maximum length of the interval, defined in seconds, after which to output a file to Amazon S3. (AWS default is 60.)
latefinal
cdcMinFileSize ↔ Output<int?>
Minimum file size condition as defined in kilobytes to output a file to Amazon S3. (AWS default is 32000 KB.)
latefinal
cdcPath ↔ Output<String?>
Folder path of CDC files. If cdcPath is set, AWS DMS reads CDC files from this path and replicates the data changes to the target endpoint. Supported in AWS DMS versions 3.4.2 and later. Required for CDC.
latefinal
certificateArn ↔ Output<String>
ARN for the certificate.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
compressionType ↔ Output<String?>
Set to compress target files. Valid values are GZIP and NONE. Default is NONE. (Ignored for source endpoints.)
latefinal
csvDelimiter ↔ Output<String?>
Delimiter used to separate columns in the source files. Default is ,.
latefinal
csvNoSupValue ↔ Output<String?>
Only applies if output files for a CDC load are written in .csv format. If useCsvNoSupValue is set to true, string to use for all columns not included in the supplemental log. If you do not specify a string value, DMS uses the null value for these columns regardless of useCsvNoSupValue. (Ignored for source endpoints.)
latefinal
csvNullValue ↔ Output<String?>
String to as null when writing to the target. (AWS default is NULL.)
latefinal
csvRowDelimiter ↔ Output<String?>
Delimiter used to separate rows in the source files. Default is newline (i.e., \n).
latefinal
dataFormat ↔ Output<String?>
Output format for the files that AWS DMS uses to create S3 objects. Valid values are csv and parquet. (Ignored for source endpoints -- only csv is valid.)
latefinal
dataPageSize ↔ Output<int?>
Size of one data page in bytes. (AWS default is 1 MiB, i.e., 1048576.)
latefinal
datePartitionDelimiter ↔ Output<String?>
Date separating delimiter to use during folder partitioning. Valid values are SLASH, UNDERSCORE, DASH, and NONE. (AWS default is SLASH.) (Ignored for source endpoints.)
latefinal
datePartitionEnabled ↔ Output<bool?>
Partition S3 bucket folders based on transaction commit dates. Default is false. (Ignored for source endpoints.)
latefinal
datePartitionSequence ↔ Output<String?>
Date format to use during folder partitioning. Use this parameter when datePartitionEnabled is set to true. Valid values are YYYYMMDD, YYYYMMDDHH, YYYYMM, MMYYYYDD, and DDMMYYYY. (AWS default is YYYYMMDD.) (Ignored for source endpoints.)
latefinal
datePartitionTimezone ↔ Output<String?>
Convert the current UTC time to a timezone. The conversion occurs when a date partition folder is created and a CDC filename is generated. The timezone format is Area/Location (e.g., Europe/Paris). Use this when datePartitionEnabled is true. (Ignored for source endpoints.)
latefinal
detachTargetOnLobLookupFailureParquet ↔ Output<bool?>
Undocumented argument for use as directed by AWS Support.
latefinal
dictPageSizeLimit ↔ Output<int?>
Maximum size in bytes of an encoded dictionary page of a column. (AWS default is 1 MiB, i.e., 1048576.)
latefinal
enableStatistics ↔ Output<bool?>
Whether to enable statistics for Parquet pages and row groups. Default is true.
latefinal
encodingType ↔ Output<String?>
Type of encoding to use. Value values are rle-dictionary, plain, and plain-dictionary. (AWS default is rle-dictionary.)
latefinal
encryptionMode ↔ Output<String?>
Server-side encryption mode that you want to encrypt your .csv or .parquet object files copied to S3. Valid values are SSE_S3 and SSE_KMS. (AWS default is SSE_S3.) (Ignored for source endpoints -- only SSE_S3 is valid.)
latefinal
endpointArn ↔ Output<String>
ARN for the endpoint.
latefinal
endpointId ↔ Output<String>
Database endpoint identifier. Identifiers must contain from 1 to 255 alphanumeric characters or hyphens, begin with a letter, contain only ASCII letters, digits, and hyphens, not end with a hyphen, and not contain two consecutive hyphens.
latefinal
endpointType ↔ Output<String>
Type of endpoint. Valid values are source, target.
latefinal
engineDisplayName ↔ Output<String>
Expanded name for the engine name.
latefinal
expectedBucketOwner ↔ Output<String?>
Bucket owner to prevent sniping. Value is an AWS account ID.
latefinal
externalId ↔ Output<String>
Can be used for cross-account validation. Use it in another account with aws.dms.S3Endpoint to create the endpoint cross-account.
latefinal
externalTableDefinition ↔ Output<String?>
JSON document that describes how AWS DMS should interpret the data. Required for source endpoints.
latefinal
glueCatalogGeneration ↔ Output<bool?>
Whether to integrate AWS Glue Data Catalog with an Amazon S3 target. See Using AWS Glue Data Catalog with an Amazon S3 target for AWS DMS for more information. Default is false.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
ignoreHeaderRows ↔ Output<int?>
When this value is set to 1, DMS ignores the first row header in a .csv file. (AWS default is 0.)
latefinal
includeOpForFullLoad ↔ Output<bool?>
Whether to enable a full load to write INSERT operations to the .csv output files only to indicate how the rows were added to the source database. Default is false.
latefinal
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
kmsKeyArn ↔ Output<String>
ARN for the KMS key that will be used to encrypt the connection parameters. If you do not specify a value for kmsKeyArn, then AWS DMS will use your default encryption key. AWS KMS creates the default encryption key for your AWS account. Your AWS account has a different default encryption key for each AWS region.
latefinal
maxFileSize ↔ Output<int?>
Maximum size (in KB) of any .csv file to be created while migrating to an S3 target during full load. Valid values are from 1 to 1048576. (AWS default is 1 GB, i.e., 1048576.)
latefinal
parquetTimestampInMillisecond ↔ Output<bool?>
Specifies the precision of any TIMESTAMP column values written to an S3 object file in .parquet format. Default is false. (Ignored for source endpoints.)
latefinal
parquetVersion ↔ Output<String?>
Version of the .parquet file format. Valid values are parquet-1-0 and parquet-2-0. (AWS default is parquet-1-0.) (Ignored for source endpoints.)
latefinal
preserveTransactions ↔ Output<bool?>
Whether DMS saves the transaction order for a CDC load on the S3 target specified by cdcPath. Default is false. (Ignored for source endpoints.)
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
rfc4180 ↔ Output<bool?>
For an S3 source, whether each leading double quotation mark has to be followed by an ending double quotation mark. Default is true.
latefinal
rowGroupLength ↔ Output<int?>
Number of rows in a row group. (AWS default is 10000.)
latefinal
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
serverSideEncryptionKmsKeyId ↔ Output<String?>
When encryptionMode is SSE_KMS, ARN for the AWS KMS key. (Ignored for source endpoints -- only SSE_S3 encryptionMode is valid.)
latefinal
serviceAccessRoleArn ↔ Output<String>
ARN of the IAM role with permissions to the S3 Bucket.
latefinal
sslMode ↔ Output<String>
SSL mode to use for the connection. Valid values are none, require, verify-ca, verify-full. (AWS default is none.)
latefinal
status ↔ Output<String>
Status of the endpoint.
latefinal
tags ↔ Output<Map<String, String>?>
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.
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
timestampColumnName ↔ Output<String?>
Column to add with timestamp information to the endpoint data for an Amazon S3 target.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited
useCsvNoSupValue ↔ Output<bool?>
Whether to use csvNoSupValue for columns not included in the supplemental log. (Ignored for source endpoints.)
latefinal
useTaskStartTimeForFullLoadTimestamp ↔ Output<bool?>
When set to true, uses the task start time as the timestamp column value instead of the time data is written to target. For full load, when set to true, each row of the timestamp column contains the task start time. For CDC loads, each row of the timestamp column contains the transaction commit time.When set to false, the full load timestamp in the timestamp column increments with the time data arrives at the target. Default is false.
latefinal

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {S3EndpointState? state, CustomResourceOptions? options}) → S3Endpoint
Gets an existing S3Endpoint resource's state with the given name and id.