Object Storage Service:Data replication (Go SDK V1)

The following code shows how to enable data replication. In this example, data is replicated from the srcexamplebucket bucket in the China (Hangzhou) region to the destexamplebucket bucket, which can be in the same or a different region.

package main

import (
	"encoding/xml"
	"log"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
	// Obtain access credentials from environment variables. Before you run this code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are set.
	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		log.Fatalf("Failed to create credentials provider: %v", err)
	}

	// Create an OSSClient instance.
	// Set yourEndpoint to the endpoint of the bucket. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. For other regions, set the endpoint as needed.
	// Set yourRegion to the region of the bucket. For example, if the bucket is in the China (Hangzhou) region, set the region to cn-hangzhou. For other regions, set the region as needed.
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// Set the signature version.
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		log.Fatalf("Failed to create OSS client: %v", err)
	}

	// Specify the name of the source bucket.
	srcbucketName := "srcexamplebucket"
	// Specify the destination bucket to which you want to replicate data.
	destBucketName := "destexamplebucket"
	// Specify the prefixes of the objects that you want to replicate, such as prefix_1 and prefix_2. After you specify prefixes, only objects that match the prefixes are replicated to the destination bucket.
	// If you want to replicate all objects from the source bucket to the destination bucket, do not set Prefix.
	prefix1 := "prefix_1"
	prefix2 := "prefix_2"
	// Specify the ID of the server-side encryption (SSE) with Key Management Service (KMS) key. If you set Status to Enabled, you must specify this element.
	keyId := "c4d49f85-ee30-426b-a5ed-95e9139d"
	// Specify whether to replicate objects that are encrypted using SSE-KMS.
	source := "Enabled"
	prefixSet := oss.ReplicationRulePrefix{Prefix: []*string{&prefix1, &prefix2}}
	// Enable replication time control (RTC) when you configure a cross-region replication rule.
	enabled := "enabled"
	reqReplication := oss.PutBucketReplication{
		Rule: []oss.ReplicationRule{
			{
				PrefixSet: &prefixSet,
				// Replicate object creation and update operations from the source bucket to the destination bucket.
				Action: "PUT",
				RTC:    &enabled,
				Destination: &oss.ReplicationRuleDestination{
					Bucket:       destBucketName,
					Location:     "oss-cn-hangzhou",
					TransferType: "oss_acc",
				},
				HistoricalObjectReplication: "disabled",
				SyncRole:                    "aliyunramrole",
				EncryptionConfiguration:     &keyId,
				SourceSelectionCriteria:     &source,
			},
		},
	}

	xmlBody, err := xml.Marshal(reqReplication)
	if err != nil {
		log.Fatalf("Failed to marshal XML for PutBucketReplication: %v", err)
	}
	err = client.PutBucketReplication(srcbucketName, string(xmlBody))
	if err != nil {
		log.Fatalf("Failed to put bucket replication: %v", err)
	}

	log.Println("Put Bucket Replication Success!")
}

The following code shows how to query the data replication rules of the examplebucket bucket.

package main

import (
	"encoding/xml"
	"log"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
	// Obtain access credentials from environment variables. Before you run this code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are set.
	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		log.Fatalf("Failed to create credentials provider: %v", err)
	}

	// Create an OSSClient instance.
	// Set yourEndpoint to the endpoint of the bucket. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. For other regions, set the endpoint as needed.
	// Set yourRegion to the region of the bucket. For example, if the bucket is in the China (Hangzhou) region, set the region to cn-hangzhou. For other regions, set the region as needed.
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// Set the signature version.
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		log.Fatalf("Failed to create OSS client: %v", err)
	}

	// Specify the name of the source bucket.
	bucketName := "srcexamplebucket"

	// Get the data replication configuration.
	stringData, err := client.GetBucketReplication(bucketName)
	if err != nil {
		log.Fatalf("Failed to get bucket replication: %v", err)
	}

	// Parse the XML response.
	var repResult oss.GetBucketReplicationResult
	err = xml.Unmarshal([]byte(stringData), &repResult)
	if err != nil {
		log.Fatalf("Failed to unmarshal XML response: %v", err)
	}

	// Print the data replication rules.
	for _, rule := range repResult.Rule {
		log.Printf("Rule Id: %s", rule.ID)
		if rule.RTC != nil {
			log.Printf("Rule RTC: %s", *rule.RTC)
		}
		if rule.PrefixSet != nil {
			for _, prefix := range rule.PrefixSet.Prefix {
				log.Printf("Rule Prefix: %s", *prefix)
			}
		}
		log.Printf("Rule Action: %s", rule.Action)
		log.Printf("Rule Destination Bucket: %s", rule.Destination.Bucket)
		log.Printf("Rule Destination Location: %s", rule.Destination.Location)
		log.Printf("Rule Destination TransferType: %s", rule.Destination.TransferType)
		log.Printf("Rule Status: %s", rule.Status)
		log.Printf("Rule Historical Object Replication: %s", rule.HistoricalObjectReplication)
		if rule.SyncRole != "" {
			log.Printf("Rule SyncRole: %s", rule.SyncRole)
		}
	}
}

The following code shows how to enable or disable replication time control (RTC) for an existing cross-region replication rule.

package main

import (
	"log"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
	// Obtain access credentials from environment variables. Before you run this code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are set.
	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		log.Fatalf("Failed to create credentials provider: %v", err)
	}

	// Create an OSSClient instance.
	// Set yourEndpoint to the endpoint of the bucket. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. For other regions, set the endpoint as needed.
	// Set yourRegion to the region of the bucket. For example, if the bucket is in the China (Hangzhou) region, set the region to cn-hangzhou. For other regions, set the region as needed.
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// Set the signature version.
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		log.Fatalf("Failed to create OSS client: %v", err)
	}

	// Specify the name of the source bucket.
	bucketName := "srcexamplebucket"

	// Enable RTC.
	enabled := "enabled"

	// Specify the ID of the cross-region replication rule.
	id := "564df6de-7372-46dc-b4eb-10f****"

	// Build a PutBucketRTC request.
	rtc := oss.PutBucketRTC{
		RTC: &enabled,
		ID:  id,
	}

	err = client.PutBucketRTC(bucketName, rtc)
	if err != nil {
		log.Fatalf("Failed to put bucket RTC: %v", err)
	}

	log.Println("Put Bucket RTC Success!")
}

The following code shows how to query the list of destination regions to which data can be replicated from the examplebucket bucket.

package main

import (
	"encoding/xml"
	"log"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
	// Obtain access credentials from environment variables. Before you run this code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are set.
	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		log.Fatalf("Failed to create credentials provider: %v", err)
	}

	// Create an OSSClient instance.
	// Set yourEndpoint to the endpoint of the bucket. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. For other regions, set the endpoint as needed.
	// Set yourRegion to the region of the bucket. For example, if the bucket is in the China (Hangzhou) region, set the region to cn-hangzhou. For other regions, set the region as needed.
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// Set the signature version.
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		log.Fatalf("Failed to create OSS client: %v", err)
	}

	// Specify the name of the source bucket.
	bucketName := "srcexamplebucket"

	// Query the destination regions to which data in the source bucket can be replicated.
	stringData, err := client.GetBucketReplicationLocation(bucketName)
	if err != nil {
		log.Fatalf("Failed to get bucket replication location: %v", err)
	}

	// Parse the XML response.
	var repLocation oss.GetBucketReplicationLocationResult
	err = xml.Unmarshal([]byte(stringData), &repLocation)
	if err != nil {
		log.Fatalf("Failed to unmarshal XML response: %v", err)
	}

	// Print the destination region information.
	for _, location := range repLocation.Location {
		log.Printf("Bucket Replication Location: %s", location)
	}

	// Print the transfer type information.
	for _, transferType := range repLocation.LocationTransferType {
		log.Printf("Bucket Replication Location Transfer Type Location: %s", transferType.Location)
		log.Printf("Bucket Replication Location Transfer Type Type: %s", transferType.TransferTypes)
	}

	// Print the RTC location information.
	for _, rtcLocation := range repLocation.RTCLocation {
		log.Printf("Bucket Replication Location RTC Location: %s", rtcLocation)
	}

	log.Println("Get Bucket Replication Location Success!")
}

You can query the progress of historical data replication tasks and incremental data replication tasks.

• The progress of historical data replication tasks is expressed as a percentage. You can query the progress of historical data replication tasks only for buckets for which historical data replication is enabled.

• The progress of incremental data replication tasks is expressed as a point in time. Data that is stored in the source bucket before the point in time is replicated.

The following code shows how to query the progress of a data replication task for a specific rule ID in the examplebucket bucket.

package main

import (
	"encoding/xml"
	"log"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
	// Obtain access credentials from environment variables. Before you run this code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are set.
	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		log.Fatalf("Failed to create credentials provider: %v", err)
	}

	// Create an OSSClient instance.
	// Set yourEndpoint to the endpoint of the bucket. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. For other regions, set the endpoint as needed.
	// Set yourRegion to the region of the bucket. For example, if the bucket is in the China (Hangzhou) region, set the region to cn-hangzhou. For other regions, set the region as needed.
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// Set the signature version.
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		log.Fatalf("Failed to create OSS client: %v", err)
	}

	// Specify the name of the source bucket.
	bucketName := "srcexamplebucket"
	ruleId := "564df6de-7372-46dc-b4eb-10f****"

	// Query the data replication progress.
	stringData, err := client.GetBucketReplicationProgress(bucketName, ruleId)
	if err != nil {
		log.Fatalf("Failed to get bucket replication progress: %v", err)
	}

	// Parse the XML response.
	var repProgress oss.GetBucketReplicationProgressResult
	err = xml.Unmarshal([]byte(stringData), &repProgress)
	if err != nil {
		log.Fatalf("Failed to unmarshal XML response: %v", err)
	}

	// Print the data replication progress information.
	for _, repProgressRule := range repProgress.Rule {
		log.Printf("Rule Id: %s", repProgressRule.ID)
		if repProgressRule.PrefixSet != nil {
			for _, prefix := range repProgressRule.PrefixSet.Prefix {
				log.Printf("Rule Prefix: %s", *prefix)
			}
		}
		log.Printf("Replication Progress Rule Action: %s", repProgressRule.Action)
		log.Printf("Replication Progress Rule Destination Bucket: %s", repProgressRule.Destination.Bucket)
		log.Printf("Replication Progress Rule Destination Location: %s", repProgressRule.Destination.Location)
		log.Printf("Replication Progress Rule Destination TransferType: %s", repProgressRule.Destination.TransferType)
		log.Printf("Replication Progress Rule Status: %s", repProgressRule.Status)
		log.Printf("Replication Progress Rule Historical Object Replication: %s", repProgressRule.HistoricalObjectReplication)
		if repProgressRule.Progress != nil && repProgressRule.Progress.HistoricalObject != "" {
			log.Printf("Replication Progress Rule Progress Historical Object: %s", repProgressRule.Progress.HistoricalObject)
		}
		log.Printf("Replication Progress Rule Progress NewObject: %s", repProgressRule.Progress.NewObject)
	}

	log.Println("Get Bucket Replication Progress Success!")
}

You can disable the replication relationship between the source and destination buckets by deleting the replication rule of the source bucket.

The following code shows how to delete the replication rule for a specific rule ID in the examplebucket bucket.

package main

import (
	"log"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
	// Obtain access credentials from environment variables. Before you run this code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are set.
	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		log.Fatalf("Failed to create credentials provider: %v", err)
	}

	// Create an OSSClient instance.
	// Set yourEndpoint to the endpoint of the bucket. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. For other regions, set the endpoint as needed.
	// Set yourRegion to the region of the bucket. For example, if the bucket is in the China (Hangzhou) region, set the region to cn-hangzhou. For other regions, set the region as needed.
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// Set the signature version.
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		log.Fatalf("Failed to create OSS client: %v", err)
	}

	// Specify the name of the source bucket.
	srcbucketName := "yourSourceBucket"

	// Specify the ID of the data replication rule that is returned by the GetBucketReplication operation.
	ruleID := "e047ce28-6806-4131-b1da-30142116****"

	// Disable data replication.
	err = client.DeleteBucketReplication(srcbucketName, ruleID)
	if err != nil {
		log.Fatalf("Failed to delete bucket replication: %v", err)
	}

	log.Println("Delete Bucket Replication Success!")
}