ReplicationGroup

Snowflake v2.23.0, Nov 6 26

Viewing docs for Snowflake v2.23.0
published on Friday, Nov 6, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-snowflake

Viewing docs for Snowflake v2.23.0
published on Friday, Nov 6, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-snowflake

Caution: Preview Feature This feature is considered a preview feature in the provider, regardless of the state of the resource in Snowflake. We do not guarantee its stability. It will be reworked and marked as a stable feature in future releases. Breaking changes are expected, even without bumping the major version. To use this feature, add the relevant feature name to previewFeaturesEnabled field in the provider configuration. Please always refer to the Getting Help section in our Github repo to best determine how to get help for your questions.

Resource used to manage replication groups in the source account. For more information, check replication group documentation.

Example Usage

Note Instead of using fully_qualified_name, you can reference objects managed outside Terraform by constructing a correct ID, consult identifiers guide.

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

//# Minimal
const basic = new snowflake.ReplicationGroup("basic", {
    name: "replication_group_name",
    objectTypes: ["DATABASES"],
    allowedAccounts: ["\"<organization_name>\".\"<account_name>\""],
    allowedDatabases: [example.fullyQualifiedName],
});
//# Complete
const complete = new snowflake.ReplicationGroup("complete", {
    name: "replication_group_name",
    objectTypes: [
        "DATABASES",
        "ROLES",
        "EXTERNAL VOLUMES",
        "SHARES",
        "INTEGRATIONS",
    ],
    allowedAccounts: ["\"<organization_name>\".\"<account_name>\""],
    allowedDatabases: [example.fullyQualifiedName],
    allowedExternalVolumes: [exampleSnowflakeExternalVolume.fullyQualifiedName],
    allowedShares: [exampleSnowflakeShare.fullyQualifiedName],
    allowedIntegrationTypes: [
        "API INTEGRATIONS",
        "EXTERNAL ACCESS INTEGRATIONS",
        "NOTIFICATION INTEGRATIONS",
        "SECURITY INTEGRATIONS",
        "STORAGE INTEGRATIONS",
    ],
    ignoreEditionCheck: "true",
    replicationSchedule: "10 MINUTE",
    errorIntegration: exampleSnowflakeNotificationIntegration.fullyQualifiedName,
    comment: "My replication group",
});

import pulumi
import pulumi_snowflake as snowflake

## Minimal
basic = snowflake.ReplicationGroup("basic",
    name="replication_group_name",
    object_types=["DATABASES"],
    allowed_accounts=["\"<organization_name>\".\"<account_name>\""],
    allowed_databases=[example["fullyQualifiedName"]])
## Complete
complete = snowflake.ReplicationGroup("complete",
    name="replication_group_name",
    object_types=[
        "DATABASES",
        "ROLES",
        "EXTERNAL VOLUMES",
        "SHARES",
        "INTEGRATIONS",
    ],
    allowed_accounts=["\"<organization_name>\".\"<account_name>\""],
    allowed_databases=[example["fullyQualifiedName"]],
    allowed_external_volumes=[example_snowflake_external_volume["fullyQualifiedName"]],
    allowed_shares=[example_snowflake_share["fullyQualifiedName"]],
    allowed_integration_types=[
        "API INTEGRATIONS",
        "EXTERNAL ACCESS INTEGRATIONS",
        "NOTIFICATION INTEGRATIONS",
        "SECURITY INTEGRATIONS",
        "STORAGE INTEGRATIONS",
    ],
    ignore_edition_check="true",
    replication_schedule="10 MINUTE",
    error_integration=example_snowflake_notification_integration["fullyQualifiedName"],
    comment="My replication group")

package main

import (
	"github.com/pulumi/pulumi-snowflake/sdk/v2/go/snowflake"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		//# Minimal
		_, err := snowflake.NewReplicationGroup(ctx, "basic", &snowflake.ReplicationGroupArgs{
			Name: pulumi.String("replication_group_name"),
			ObjectTypes: pulumi.StringArray{
				pulumi.String("DATABASES"),
			},
			AllowedAccounts: pulumi.StringArray{
				pulumi.String("\"<organization_name>\".\"<account_name>\""),
			},
			AllowedDatabases: pulumi.StringArray{
				example.FullyQualifiedName,
			},
		})
		if err != nil {
			return err
		}
		//# Complete
		_, err = snowflake.NewReplicationGroup(ctx, "complete", &snowflake.ReplicationGroupArgs{
			Name: pulumi.String("replication_group_name"),
			ObjectTypes: pulumi.StringArray{
				pulumi.String("DATABASES"),
				pulumi.String("ROLES"),
				pulumi.String("EXTERNAL VOLUMES"),
				pulumi.String("SHARES"),
				pulumi.String("INTEGRATIONS"),
			},
			AllowedAccounts: pulumi.StringArray{
				pulumi.String("\"<organization_name>\".\"<account_name>\""),
			},
			AllowedDatabases: pulumi.StringArray{
				example.FullyQualifiedName,
			},
			AllowedExternalVolumes: pulumi.StringArray{
				exampleSnowflakeExternalVolume.FullyQualifiedName,
			},
			AllowedShares: pulumi.StringArray{
				exampleSnowflakeShare.FullyQualifiedName,
			},
			AllowedIntegrationTypes: pulumi.StringArray{
				pulumi.String("API INTEGRATIONS"),
				pulumi.String("EXTERNAL ACCESS INTEGRATIONS"),
				pulumi.String("NOTIFICATION INTEGRATIONS"),
				pulumi.String("SECURITY INTEGRATIONS"),
				pulumi.String("STORAGE INTEGRATIONS"),
			},
			IgnoreEditionCheck:  pulumi.String("true"),
			ReplicationSchedule: pulumi.String("10 MINUTE"),
			ErrorIntegration:    pulumi.Any(exampleSnowflakeNotificationIntegration.FullyQualifiedName),
			Comment:             pulumi.String("My replication group"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Snowflake = Pulumi.Snowflake;

return await Deployment.RunAsync(() => 
{
    //# Minimal
    var basic = new Snowflake.ReplicationGroup("basic", new()
    {
        Name = "replication_group_name",
        ObjectTypes = new[]
        {
            "DATABASES",
        },
        AllowedAccounts = new[]
        {
            "\"<organization_name>\".\"<account_name>\"",
        },
        AllowedDatabases = new[]
        {
            example.FullyQualifiedName,
        },
    });

    //# Complete
    var complete = new Snowflake.ReplicationGroup("complete", new()
    {
        Name = "replication_group_name",
        ObjectTypes = new[]
        {
            "DATABASES",
            "ROLES",
            "EXTERNAL VOLUMES",
            "SHARES",
            "INTEGRATIONS",
        },
        AllowedAccounts = new[]
        {
            "\"<organization_name>\".\"<account_name>\"",
        },
        AllowedDatabases = new[]
        {
            example.FullyQualifiedName,
        },
        AllowedExternalVolumes = new[]
        {
            exampleSnowflakeExternalVolume.FullyQualifiedName,
        },
        AllowedShares = new[]
        {
            exampleSnowflakeShare.FullyQualifiedName,
        },
        AllowedIntegrationTypes = new[]
        {
            "API INTEGRATIONS",
            "EXTERNAL ACCESS INTEGRATIONS",
            "NOTIFICATION INTEGRATIONS",
            "SECURITY INTEGRATIONS",
            "STORAGE INTEGRATIONS",
        },
        IgnoreEditionCheck = "true",
        ReplicationSchedule = "10 MINUTE",
        ErrorIntegration = exampleSnowflakeNotificationIntegration.FullyQualifiedName,
        Comment = "My replication group",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.snowflake.ReplicationGroup;
import com.pulumi.snowflake.ReplicationGroupArgs;
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) {
        //# Minimal
        var basic = new ReplicationGroup("basic", ReplicationGroupArgs.builder()
            .name("replication_group_name")
            .objectTypes("DATABASES")
            .allowedAccounts("\"<organization_name>\".\"<account_name>\"")
            .allowedDatabases(example.get("fullyQualifiedName"))
            .build());

        //# Complete
        var complete = new ReplicationGroup("complete", ReplicationGroupArgs.builder()
            .name("replication_group_name")
            .objectTypes(            
                "DATABASES",
                "ROLES",
                "EXTERNAL VOLUMES",
                "SHARES",
                "INTEGRATIONS")
            .allowedAccounts("\"<organization_name>\".\"<account_name>\"")
            .allowedDatabases(example.get("fullyQualifiedName"))
            .allowedExternalVolumes(exampleSnowflakeExternalVolume.get("fullyQualifiedName"))
            .allowedShares(exampleSnowflakeShare.get("fullyQualifiedName"))
            .allowedIntegrationTypes(            
                "API INTEGRATIONS",
                "EXTERNAL ACCESS INTEGRATIONS",
                "NOTIFICATION INTEGRATIONS",
                "SECURITY INTEGRATIONS",
                "STORAGE INTEGRATIONS")
            .ignoreEditionCheck("true")
            .replicationSchedule("10 MINUTE")
            .errorIntegration(exampleSnowflakeNotificationIntegration.get("fullyQualifiedName"))
            .comment("My replication group")
            .build());

    }
}

resources:
  ## Minimal
  basic:
    type: snowflake:ReplicationGroup
    properties:
      name: replication_group_name
      objectTypes:
        - DATABASES
      allowedAccounts:
        - '"<organization_name>"."<account_name>"'
      allowedDatabases:
        - ${example.fullyQualifiedName}
  ## Complete
  complete:
    type: snowflake:ReplicationGroup
    properties:
      name: replication_group_name
      objectTypes:
        - DATABASES
        - ROLES
        - EXTERNAL VOLUMES
        - SHARES
        - INTEGRATIONS
      allowedAccounts:
        - '"<organization_name>"."<account_name>"'
      allowedDatabases:
        - ${example.fullyQualifiedName}
      allowedExternalVolumes:
        - ${exampleSnowflakeExternalVolume.fullyQualifiedName}
      allowedShares:
        - ${exampleSnowflakeShare.fullyQualifiedName}
      allowedIntegrationTypes:
        - API INTEGRATIONS
        - EXTERNAL ACCESS INTEGRATIONS
        - NOTIFICATION INTEGRATIONS
        - SECURITY INTEGRATIONS
        - STORAGE INTEGRATIONS
      ignoreEditionCheck: 'true'
      replicationSchedule: 10 MINUTE
      errorIntegration: ${exampleSnowflakeNotificationIntegration.fullyQualifiedName}
      comment: My replication group

terraform {
  required_providers {
    snowflake = {
      source = "pulumi/snowflake"
    }
  }
}

## Minimal
resource "snowflake_replication_group" "basic" {
  lifecycle {
    create_before_destroy = true
  }
  name              = "replication_group_name"
  object_types      = ["DATABASES"]
  allowed_accounts  = ["\"<organization_name>\".\"<account_name>\""]
  allowed_databases = [example.fullyQualifiedName]
}
## Complete
resource "snowflake_replication_group" "complete" {
  lifecycle {
    create_before_destroy = true
  }
  name                      = "replication_group_name"
  object_types              = ["DATABASES", "ROLES", "EXTERNAL VOLUMES", "SHARES", "INTEGRATIONS"]
  allowed_accounts          = ["\"<organization_name>\".\"<account_name>\""]
  allowed_databases         = [example.fullyQualifiedName]
  allowed_external_volumes  = [exampleSnowflakeExternalVolume.fullyQualifiedName]
  allowed_shares            = [exampleSnowflakeShare.fullyQualifiedName]
  allowed_integration_types = ["API INTEGRATIONS", "EXTERNAL ACCESS INTEGRATIONS", "NOTIFICATION INTEGRATIONS", "SECURITY INTEGRATIONS", "STORAGE INTEGRATIONS"]
  ignore_edition_check      = "true"
  replication_schedule      = "10 MINUTE"
  error_integration         = exampleSnowflakeNotificationIntegration.fullyQualifiedName
  comment                   = "My replication group"
}

Note When this replication group is no longer primary, Terraform recreates it as a primary group. Moving the object to snowflake.ReplicationGroupSecondary is a manual state migration. See resource migration.

Note If a field has a default value, it is shown next to the type in the schema.

Create ReplicationGroup Resource

Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

Constructor syntax

new ReplicationGroup(name: string, args: ReplicationGroupArgs, opts?: CustomResourceOptions);

@overload
def ReplicationGroup(resource_name: str,
                     args: ReplicationGroupArgs,
                     opts: Optional[ResourceOptions] = None)

@overload
def ReplicationGroup(resource_name: str,
                     opts: Optional[ResourceOptions] = None,
                     allowed_accounts: Optional[Sequence[str]] = None,
                     object_types: Optional[Sequence[str]] = None,
                     allowed_databases: Optional[Sequence[str]] = None,
                     allowed_external_volumes: Optional[Sequence[str]] = None,
                     allowed_integration_types: Optional[Sequence[str]] = None,
                     allowed_shares: Optional[Sequence[str]] = None,
                     comment: Optional[str] = None,
                     error_integration: Optional[str] = None,
                     ignore_edition_check: Optional[str] = None,
                     name: Optional[str] = None,
                     replication_schedule: Optional[str] = None)

func NewReplicationGroup(ctx *Context, name string, args ReplicationGroupArgs, opts ...ResourceOption) (*ReplicationGroup, error)

public ReplicationGroup(string name, ReplicationGroupArgs args, CustomResourceOptions? opts = null)

public ReplicationGroup(String name, ReplicationGroupArgs args)
public ReplicationGroup(String name, ReplicationGroupArgs args, CustomResourceOptions options)

type: snowflake:ReplicationGroup
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

resource "snowflake_replication_group" "name" {
    # resource properties
}

Parameters

name string: The unique name of the resource.
args ReplicationGroupArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

resource_name str: The unique name of the resource.
args ReplicationGroupArgs: The arguments to resource properties.
opts ResourceOptions: Bag of options to control resource's behavior.

ctx Context: Context object for the current deployment.
name string: The unique name of the resource.
args ReplicationGroupArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

name string: The unique name of the resource.
args ReplicationGroupArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

name String: The unique name of the resource.
args ReplicationGroupArgs: The arguments to resource properties.
options CustomResourceOptions: Bag of options to control resource's behavior.

Constructor example

The following reference example uses placeholder values for all input properties.

var replicationGroupResource = new Snowflake.ReplicationGroup("replicationGroupResource", new()
{
    AllowedAccounts = new[]
    {
        "string",
    },
    ObjectTypes = new[]
    {
        "string",
    },
    AllowedDatabases = new[]
    {
        "string",
    },
    AllowedExternalVolumes = new[]
    {
        "string",
    },
    AllowedIntegrationTypes = new[]
    {
        "string",
    },
    AllowedShares = new[]
    {
        "string",
    },
    Comment = "string",
    ErrorIntegration = "string",
    IgnoreEditionCheck = "string",
    Name = "string",
    ReplicationSchedule = "string",
});

example, err := snowflake.NewReplicationGroup(ctx, "replicationGroupResource", &snowflake.ReplicationGroupArgs{
	AllowedAccounts: pulumi.StringArray{
		pulumi.String("string"),
	},
	ObjectTypes: pulumi.StringArray{
		pulumi.String("string"),
	},
	AllowedDatabases: pulumi.StringArray{
		pulumi.String("string"),
	},
	AllowedExternalVolumes: pulumi.StringArray{
		pulumi.String("string"),
	},
	AllowedIntegrationTypes: pulumi.StringArray{
		pulumi.String("string"),
	},
	AllowedShares: pulumi.StringArray{
		pulumi.String("string"),
	},
	Comment:             pulumi.String("string"),
	ErrorIntegration:    pulumi.String("string"),
	IgnoreEditionCheck:  pulumi.String("string"),
	Name:                pulumi.String("string"),
	ReplicationSchedule: pulumi.String("string"),
})

resource "snowflake_replication_group" "replicationGroupResource" {
  lifecycle {
    create_before_destroy = true
  }
  allowed_accounts          = ["string"]
  object_types              = ["string"]
  allowed_databases         = ["string"]
  allowed_external_volumes  = ["string"]
  allowed_integration_types = ["string"]
  allowed_shares            = ["string"]
  comment                   = "string"
  error_integration         = "string"
  ignore_edition_check      = "string"
  name                      = "string"
  replication_schedule      = "string"
}

var replicationGroupResource = new ReplicationGroup("replicationGroupResource", ReplicationGroupArgs.builder()
    .allowedAccounts("string")
    .objectTypes("string")
    .allowedDatabases("string")
    .allowedExternalVolumes("string")
    .allowedIntegrationTypes("string")
    .allowedShares("string")
    .comment("string")
    .errorIntegration("string")
    .ignoreEditionCheck("string")
    .name("string")
    .replicationSchedule("string")
    .build());

replication_group_resource = snowflake.ReplicationGroup("replicationGroupResource",
    allowed_accounts=["string"],
    object_types=["string"],
    allowed_databases=["string"],
    allowed_external_volumes=["string"],
    allowed_integration_types=["string"],
    allowed_shares=["string"],
    comment="string",
    error_integration="string",
    ignore_edition_check="string",
    name="string",
    replication_schedule="string")

const replicationGroupResource = new snowflake.ReplicationGroup("replicationGroupResource", {
    allowedAccounts: ["string"],
    objectTypes: ["string"],
    allowedDatabases: ["string"],
    allowedExternalVolumes: ["string"],
    allowedIntegrationTypes: ["string"],
    allowedShares: ["string"],
    comment: "string",
    errorIntegration: "string",
    ignoreEditionCheck: "string",
    name: "string",
    replicationSchedule: "string",
});

type: snowflake:ReplicationGroup
properties:
    allowedAccounts:
        - string
    allowedDatabases:
        - string
    allowedExternalVolumes:
        - string
    allowedIntegrationTypes:
        - string
    allowedShares:
        - string
    comment: string
    errorIntegration: string
    ignoreEditionCheck: string
    name: string
    objectTypes:
        - string
    replicationSchedule: string