ReplicationConfiguration class

Creates a replica of an existing EFS file system in the same or another region. Creating this resource causes the source EFS file system to be replicated to a new read-only destination EFS file system (unless using the destination.file_system_id attribute). Deleting this resource will cause the replication from source to destination to stop and the destination file system will no longer be read only.

> NOTE: Deleting this resource does not delete the destination file system that was created.

Example Usage

Will create a replica using regional storage in us-west-2 that will be encrypted by the default EFS KMS key /aws/elasticfilesystem.

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

const example = new aws.efs.FileSystem("example", {});
const exampleReplicationConfiguration = new aws.efs.ReplicationConfiguration("example", {
    destination: {
        region: "us-west-2",
    },
    sourceFileSystemId: example.id,
});
import pulumi
import pulumi_aws as aws

example = aws.efs.FileSystem("example")
example_replication_configuration = aws.efs.ReplicationConfiguration("example",
    destination={
        "region": "us-west-2",
    },
    source_file_system_id=example.id)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Efs.FileSystem("example");

    var exampleReplicationConfiguration = new Aws.Efs.ReplicationConfiguration("example", new()
    {
        Destination = new Aws.Efs.Inputs.ReplicationConfigurationDestinationArgs
        {
            Region = "us-west-2",
        },
        SourceFileSystemId = example.Id,
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := efs.NewFileSystem(ctx, "example", nil)
		if err != nil {
			return err
		}
		_, err = efs.NewReplicationConfiguration(ctx, "example", &efs.ReplicationConfigurationArgs{
			Destination: &efs.ReplicationConfigurationDestinationArgs{
				Region: pulumi.String("us-west-2"),
			},
			SourceFileSystemId: example.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_efs_filesystem" "example" {
}
resource "aws_efs_replicationconfiguration" "example" {
  destination = {
    region = "us-west-2"
  }
  source_file_system_id = aws_efs_filesystem.example.id
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.efs.FileSystem;
import com.pulumi.aws.efs.ReplicationConfiguration;
import com.pulumi.aws.efs.ReplicationConfigurationArgs;
import com.pulumi.aws.efs.inputs.ReplicationConfigurationDestinationArgs;
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 FileSystem("example");

        var exampleReplicationConfiguration = new ReplicationConfiguration("exampleReplicationConfiguration", ReplicationConfigurationArgs.builder()
            .destination(ReplicationConfigurationDestinationArgs.builder()
                .region("us-west-2")
                .build())
            .sourceFileSystemId(example.id())
            .build());

    }
}
resources:
  example:
    type: aws:efs:FileSystem
  exampleReplicationConfiguration:
    type: aws:efs:ReplicationConfiguration
    name: example
    properties:
      destination:
        region: us-west-2
      sourceFileSystemId: ${example.id}

Replica will be created as One Zone storage in the us-west-2b Availability Zone and encrypted with the specified KMS key.

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

const example = new aws.efs.FileSystem("example", {});
const exampleReplicationConfiguration = new aws.efs.ReplicationConfiguration("example", {
    destination: {
        availabilityZoneName: "us-west-2b",
        kmsKeyId: "1234abcd-12ab-34cd-56ef-1234567890ab",
    },
    sourceFileSystemId: example.id,
});
import pulumi
import pulumi_aws as aws

example = aws.efs.FileSystem("example")
example_replication_configuration = aws.efs.ReplicationConfiguration("example",
    destination={
        "availability_zone_name": "us-west-2b",
        "kms_key_id": "1234abcd-12ab-34cd-56ef-1234567890ab",
    },
    source_file_system_id=example.id)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Efs.FileSystem("example");

    var exampleReplicationConfiguration = new Aws.Efs.ReplicationConfiguration("example", new()
    {
        Destination = new Aws.Efs.Inputs.ReplicationConfigurationDestinationArgs
        {
            AvailabilityZoneName = "us-west-2b",
            KmsKeyId = "1234abcd-12ab-34cd-56ef-1234567890ab",
        },
        SourceFileSystemId = example.Id,
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := efs.NewFileSystem(ctx, "example", nil)
		if err != nil {
			return err
		}
		_, err = efs.NewReplicationConfiguration(ctx, "example", &efs.ReplicationConfigurationArgs{
			Destination: &efs.ReplicationConfigurationDestinationArgs{
				AvailabilityZoneName: pulumi.String("us-west-2b"),
				KmsKeyId:             pulumi.String("1234abcd-12ab-34cd-56ef-1234567890ab"),
			},
			SourceFileSystemId: example.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_efs_filesystem" "example" {
}
resource "aws_efs_replicationconfiguration" "example" {
  destination = {
    availability_zone_name = "us-west-2b"
    kms_key_id             = "1234abcd-12ab-34cd-56ef-1234567890ab"
  }
  source_file_system_id = aws_efs_filesystem.example.id
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.efs.FileSystem;
import com.pulumi.aws.efs.ReplicationConfiguration;
import com.pulumi.aws.efs.ReplicationConfigurationArgs;
import com.pulumi.aws.efs.inputs.ReplicationConfigurationDestinationArgs;
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 FileSystem("example");

        var exampleReplicationConfiguration = new ReplicationConfiguration("exampleReplicationConfiguration", ReplicationConfigurationArgs.builder()
            .destination(ReplicationConfigurationDestinationArgs.builder()
                .availabilityZoneName("us-west-2b")
                .kmsKeyId("1234abcd-12ab-34cd-56ef-1234567890ab")
                .build())
            .sourceFileSystemId(example.id())
            .build());

    }
}
resources:
  example:
    type: aws:efs:FileSystem
  exampleReplicationConfiguration:
    type: aws:efs:ReplicationConfiguration
    name: example
    properties:
      destination:
        availabilityZoneName: us-west-2b
        kmsKeyId: 1234abcd-12ab-34cd-56ef-1234567890ab
      sourceFileSystemId: ${example.id}

Will create a replica and set the existing file system with id fs-1234567890 in us-west-2 as destination.

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

const example = new aws.efs.FileSystem("example", {});
const exampleReplicationConfiguration = new aws.efs.ReplicationConfiguration("example", {
    destination: {
        fileSystemId: "fs-1234567890",
        region: "us-west-2",
    },
    sourceFileSystemId: example.id,
});
import pulumi
import pulumi_aws as aws

example = aws.efs.FileSystem("example")
example_replication_configuration = aws.efs.ReplicationConfiguration("example",
    destination={
        "file_system_id": "fs-1234567890",
        "region": "us-west-2",
    },
    source_file_system_id=example.id)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Efs.FileSystem("example");

    var exampleReplicationConfiguration = new Aws.Efs.ReplicationConfiguration("example", new()
    {
        Destination = new Aws.Efs.Inputs.ReplicationConfigurationDestinationArgs
        {
            FileSystemId = "fs-1234567890",
            Region = "us-west-2",
        },
        SourceFileSystemId = example.Id,
    });

});
package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := efs.NewFileSystem(ctx, "example", nil)
		if err != nil {
			return err
		}
		_, err = efs.NewReplicationConfiguration(ctx, "example", &efs.ReplicationConfigurationArgs{
			Destination: &efs.ReplicationConfigurationDestinationArgs{
				FileSystemId: pulumi.String("fs-1234567890"),
				Region:       pulumi.String("us-west-2"),
			},
			SourceFileSystemId: example.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_efs_filesystem" "example" {
}
resource "aws_efs_replicationconfiguration" "example" {
  destination = {
    file_system_id = "fs-1234567890"
    region         = "us-west-2"
  }
  source_file_system_id = aws_efs_filesystem.example.id
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.efs.FileSystem;
import com.pulumi.aws.efs.ReplicationConfiguration;
import com.pulumi.aws.efs.ReplicationConfigurationArgs;
import com.pulumi.aws.efs.inputs.ReplicationConfigurationDestinationArgs;
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 FileSystem("example");

        var exampleReplicationConfiguration = new ReplicationConfiguration("exampleReplicationConfiguration", ReplicationConfigurationArgs.builder()
            .destination(ReplicationConfigurationDestinationArgs.builder()
                .fileSystemId("fs-1234567890")
                .region("us-west-2")
                .build())
            .sourceFileSystemId(example.id())
            .build());

    }
}
resources:
  example:
    type: aws:efs:FileSystem
  exampleReplicationConfiguration:
    type: aws:efs:ReplicationConfiguration
    name: example
    properties:
      destination:
        fileSystemId: fs-1234567890
        region: us-west-2
      sourceFileSystemId: ${example.id}

Import

Using pulumi import, import EFS Replication Configurations using the file system ID of either the source or destination file system. When importing, the availabilityZoneName and kmsKeyId attributes must not be set in the configuration. The AWS API does not return these values when querying the replication configuration and their presence will therefore show as a diff in a subsequent plan. For example:

$ pulumi import aws:efs/replicationConfiguration:ReplicationConfiguration example fs-id

Constructors

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

Properties

childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
creationTime ↔ Output<String>
When the replication configuration was created.
latefinal
destination ↔ Output<ReplicationConfigurationDestination>
A destination configuration block (documented below).
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
originalSourceFileSystemArn ↔ Output<String>
ARN of the original source Amazon EFS file system in the replication configuration.
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
sourceFileSystemArn ↔ Output<String>
ARN of the current source file system in the replication configuration.
latefinal
sourceFileSystemId ↔ Output<String>
The ID of the file system that is to be replicated.
latefinal
sourceFileSystemRegion ↔ Output<String>
The AWS Region in which the source Amazon EFS file system is located.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited

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, {ReplicationConfigurationState? state, CustomResourceOptions? options}) → ReplicationConfiguration
Gets an existing ReplicationConfiguration resource's state with the given name and id.