pulumi-aws-kotlin/com.pulumi.aws.dms.kotlin/Endpoint

Endpoint

class Endpoint : KotlinCustomResource

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

Note: All arguments including the password will be stored in the raw state as plain-text. Note: The s3_settings argument is deprecated, may not be maintained, and will be removed in a future version. Use the aws.dms.S3Endpoint resource instead.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
// Create a new endpoint
const test = new aws.dms.Endpoint("test", {
    certificateArn: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012",
    databaseName: "test",
    endpointId: "test-dms-endpoint-tf",
    endpointType: "source",
    engineName: "aurora",
    extraConnectionAttributes: "",
    kmsKeyArn: "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012",
    password: "test",
    port: 3306,
    serverName: "test",
    sslMode: "none",
    tags: {
        Name: "test",
    },
    username: "test",
});

import pulumi
import pulumi_aws as aws
# Create a new endpoint
test = aws.dms.Endpoint("test",
    certificate_arn="arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012",
    database_name="test",
    endpoint_id="test-dms-endpoint-tf",
    endpoint_type="source",
    engine_name="aurora",
    extra_connection_attributes="",
    kms_key_arn="arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012",
    password="test",
    port=3306,
    server_name="test",
    ssl_mode="none",
    tags={
        "Name": "test",
    },
    username="test")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    // Create a new endpoint
    var test = new Aws.Dms.Endpoint("test", new()
    {
        CertificateArn = "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012",
        DatabaseName = "test",
        EndpointId = "test-dms-endpoint-tf",
        EndpointType = "source",
        EngineName = "aurora",
        ExtraConnectionAttributes = "",
        KmsKeyArn = "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012",
        Password = "test",
        Port = 3306,
        ServerName = "test",
        SslMode = "none",
        Tags =
        {
            { "Name", "test" },
        },
        Username = "test",
    });
});

package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/dms"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Create a new endpoint
		_, err := dms.NewEndpoint(ctx, "test", &dms.EndpointArgs{
			CertificateArn:            pulumi.String("arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012"),
			DatabaseName:              pulumi.String("test"),
			EndpointId:                pulumi.String("test-dms-endpoint-tf"),
			EndpointType:              pulumi.String("source"),
			EngineName:                pulumi.String("aurora"),
			ExtraConnectionAttributes: pulumi.String(""),
			KmsKeyArn:                 pulumi.String("arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012"),
			Password:                  pulumi.String("test"),
			Port:                      pulumi.Int(3306),
			ServerName:                pulumi.String("test"),
			SslMode:                   pulumi.String("none"),
			Tags: pulumi.StringMap{
				"Name": pulumi.String("test"),
			},
			Username: pulumi.String("test"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.dms.Endpoint;
import com.pulumi.aws.dms.EndpointArgs;
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) {
        // Create a new endpoint
        var test = new Endpoint("test", EndpointArgs.builder()
            .certificateArn("arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012")
            .databaseName("test")
            .endpointId("test-dms-endpoint-tf")
            .endpointType("source")
            .engineName("aurora")
            .extraConnectionAttributes("")
            .kmsKeyArn("arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012")
            .password("test")
            .port(3306)
            .serverName("test")
            .sslMode("none")
            .tags(Map.of("Name", "test"))
            .username("test")
            .build());
    }
}

resources:
  # Create a new endpoint
  test:
    type: aws:dms:Endpoint
    properties:
      certificateArn: arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012
      databaseName: test
      endpointId: test-dms-endpoint-tf
      endpointType: source
      engineName: aurora
      extraConnectionAttributes: ""
      kmsKeyArn: arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012
      password: test
      port: 3306
      serverName: test
      sslMode: none
      tags:
        Name: test
      username: test

Import

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

$ pulumi import aws:dms/endpoint:Endpoint test test-dms-endpoint-tf

Properties

certificateArn

val certificateArn: Output<String>

ARN for the certificate.

databaseName

val databaseName: Output<String>?

Name of the endpoint database.

elasticsearchSettings

val elasticsearchSettings: Output<EndpointElasticsearchSettings>?

Configuration block for OpenSearch settings. See below.

endpointArn

val endpointArn: Output<String>

ARN for the endpoint.

endpointId

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

endpointType

val endpointType: Output<String>

Type of endpoint. Valid values are source, target.

engineName

val engineName: Output<String>

Type of engine for the endpoint. Valid values are aurora, aurora-postgresql, aurora-serverless, aurora-postgresql-serverless,azuredb, azure-sql-managed-instance, babelfish, db2, db2-zos, docdb, dynamodb, elasticsearch, kafka, kinesis, mariadb, mongodb, mysql, opensearch, oracle, postgres, redshift,redshift-serverless, s3, sqlserver, neptune ,sybase. Please note that some of engine names are available only for target endpoint type (e.g. redshift).

extraConnectionAttributes

val extraConnectionAttributes: Output<String>

Additional attributes associated with the connection. For available attributes for a source Endpoint, see Sources for data migration. For available attributes for a target Endpoint, see Targets for data migration.

val id: Output<String>

kafkaSettings

val kafkaSettings: Output<EndpointKafkaSettings>?

Configuration block for Kafka settings. See below.

kinesisSettings

val kinesisSettings: Output<EndpointKinesisSettings>?

Configuration block for Kinesis settings. See below.

kmsKeyArn

val 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 kms_key_arn, 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. To encrypt an S3 target with a KMS Key, use the parameter s3_settings.server_side_encryption_kms_key_id. When engine_name is redshift, kms_key_arn is the KMS Key for the Redshift target and the parameter redshift_settings.server_side_encryption_kms_key_id encrypts the S3 intermediate storage. The following arguments are optional:

mongodbSettings

val mongodbSettings: Output<EndpointMongodbSettings>?

Configuration block for MongoDB settings. See below.

password

val password: Output<String>?

Password to be used to login to the endpoint database.

pauseReplicationTasks

val pauseReplicationTasks: Output<Boolean>?

port

val port: Output<Int>?

Port used by the endpoint database.

postgresSettings

val postgresSettings: Output<EndpointPostgresSettings>?

Configuration block for Postgres settings. See below.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

redisSettings

val redisSettings: Output<EndpointRedisSettings>?

redshiftSettings

val redshiftSettings: Output<EndpointRedshiftSettings>

Configuration block for Redshift settings. See below.

s3Settings

val s3Settings: Output<EndpointS3Settings>?

(Deprecated, use the aws.dms.S3Endpoint resource instead) Configuration block for S3 settings. See below.

secretsManagerAccessRoleArn

val secretsManagerAccessRoleArn: Output<String>?

ARN of the IAM role that specifies AWS DMS as the trusted entity and has the required permissions to access the value in the Secrets Manager secret referred to by secrets_manager_arn. The role must allow the iam:PassRole action.

secretsManagerArn

val secretsManagerArn: Output<String>?

Full ARN, partial ARN, or friendly name of the Secrets Manager secret that contains the endpoint connection details. Supported only when engine_name is aurora, aurora-postgresql, mariadb, mongodb, mysql, oracle, postgres, redshift, or sqlserver.

serverName

val serverName: Output<String>?

Host name of the server.

serviceAccessRole

val serviceAccessRole: Output<String>?

ARN used by the service access IAM role for dynamodb endpoints.

sslMode

val sslMode: Output<String>

SSL mode to use for the connection. Valid values are none, require, verify-ca, verify-full