Endpoint class

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. ## Example Usage

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

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

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(() =>
{
    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/v7/go/aws/dms"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, 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
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "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"
}
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.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 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:
  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 endpointId. For example:

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

Constructors

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

Properties

certificateArn ↔ Output<String>
ARN for the certificate.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
databaseName ↔ Output<String?>
Name of the endpoint database.
latefinal
elasticsearchSettings ↔ Output<EndpointElasticsearchSettings?>
Configuration block for OpenSearch settings. See below.
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
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, sqlserver, neptune ,sybase. Please note that some of engine names are available only for target endpoint type (e.g. redshift).
latefinal
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.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
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
kafkaSettings ↔ Output<EndpointKafkaSettings?>
Configuration block for Kafka settings. See below.
latefinal
kinesisSettings ↔ Output<EndpointKinesisSettings?>
Configuration block for Kinesis settings. See below.
latefinal
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. When engineName is redshift, kmsKeyArn is the KMS Key for the Redshift target and the parameter redshift_settings.server_side_encryption_kms_key_id encrypts the S3 intermediate storage.
latefinal
mongodbSettings ↔ Output<EndpointMongodbSettings?>
Configuration block for MongoDB settings. See below.
latefinal
mysqlSettings ↔ Output<EndpointMysqlSettings?>
Configuration block for MySQL settings. See below.
latefinal
oracleSettings ↔ Output<EndpointOracleSettings?>
Configuration block for Oracle settings. See below.
latefinal
password ↔ Output<String?>
Password to be used to login to the endpoint database.
latefinal
pauseReplicationTasks ↔ Output<bool?>
Whether to pause associated running replication tasks, regardless if they are managed by Terraform, prior to modifying the endpoint. Only tasks paused by the resource will be restarted after the modification completes. Default is false.
latefinal
port ↔ Output<int?>
Port used by the endpoint database.
latefinal
postgresSettings ↔ Output<EndpointPostgresSettings?>
Configuration block for Postgres settings. See below.
latefinal
redisSettings ↔ Output<EndpointRedisSettings?>
latefinal
redshiftSettings ↔ Output<EndpointRedshiftSettings>
Configuration block for Redshift settings. See below.
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
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
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 secretsManagerArn. The role must allow the iam:PassRole action.
latefinal
secretsManagerArn ↔ Output<String?>
Full ARN, partial ARN, or friendly name of the Secrets Manager secret that contains the endpoint connection details. Supported only when engineName is aurora, aurora-postgresql, mariadb, mongodb, mysql, oracle, postgres, redshift, or sqlserver.
latefinal
serverName ↔ Output<String?>
Host name of the server.
latefinal
serviceAccessRole ↔ Output<String?>
ARN used by the service access IAM role for dynamodb endpoints.
latefinal
sslMode ↔ Output<String>
SSL mode to use for the connection. Valid values are none, require, verify-ca, verify-full
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
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited
username ↔ Output<String?>
User name to be used to login to the endpoint database.
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, {EndpointState? state, CustomResourceOptions? options}) → Endpoint
Gets an existing Endpoint resource's state with the given name and id.