镜像回源

import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.model.RoutingRule;
import com.aliyun.oss.model.SetBucketWebsiteRequest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Demo {

    public static void main(String[] args) throws Exception {
        // Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // 填写Bucket名称，例如examplebucket。
        String bucketName = "examplebucket";
        // 填写Bucket所在地域。以华东1（杭州）为例，Region填写为cn-hangzhou。
        String region = "cn-hangzhou";

        // 创建OSSClient实例。
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);        
        OSS ossClient = OSSClientBuilder.create()
        .endpoint(endpoint)
        .credentialsProvider(credentialsProvider)
        .clientConfiguration(clientBuilderConfiguration)
        .region(region)               
        .build();

        try {
            SetBucketWebsiteRequest request = new SetBucketWebsiteRequest(bucketName);
            // 设置默认主页后，访问以非正斜线（/）结尾的Object，且该Object不存在时的行为。
            //request.setSubDirType(null);
            // 指定访问子目录时，是否支持转到子目录下的默认主页。
            //request.setSupportSubDir(false);

            List<RoutingRule> routingRules = new ArrayList<RoutingRule>();

            RoutingRule rule = new RoutingRule();
            rule.setNumber(1);
            // 只有匹配此前缀的Object才能匹配此规则。
            rule.getCondition().setKeyPrefixEquals("examplebucket");
            // 访问指定Object时，返回status 404才能匹配此规则。
            rule.getCondition().setHttpErrorCodeReturnedEquals(404);
            // 指定跳转的类型。
            rule.getRedirect().setRedirectType(RoutingRule.RedirectType.Mirror);
            // 指定镜像回源的源站地址。例如https://www.example.com/。
            rule.getRedirect().setMirrorURL("<yourMirrorURL>");
            //rule.getRedirect().setMirrorRole("AliyunOSSMirrorDefaultRole");
            // 指定执行跳转或者镜像回源规则时，是否携带请求参数。
            rule.getRedirect().setPassQueryString(true);
            // 与PassQueryString作用相同，优先级高于PassQueryString。只有设置RedirectType为Mirror时生效。
            rule.getRedirect().setMirrorPassQueryString(true);
            // 指定跳转时返回的状态码。只有设置RedirectType为External或者AliCDN时生效。
            //rule.getRedirect().setHttpRedirectCode(302);
            // 指定跳转时的域名，域名需符合域名规范。
            //rule.getRedirect().setHostName("oss.aliyuncs.com");
            // 指定跳转时的协议。只有设置RedirectType为External或者AliCDN时才生效。
            //rule.getRedirect().setProtocol(RoutingRule.Protocol.Https);
            // Redirect时Object名称将替换成ReplaceKeyWith指定的值，ReplaceKeyWith支持设置变量。
            //rule.getRedirect().setReplaceKeyWith("${key}.jpg");
            // 如果设置此字段为true，则Object的前缀将被替换为ReplaceKeyPrefixWith指定的值。
            rule.getRedirect().setEnableReplacePrefix(true);
            // Redirect时Object名称的前缀将替换成该值。
            rule.getRedirect().setReplaceKeyPrefixWith("examplebucket");
            // 是否检查回源body的MD5。只有设置RedirectType为Mirror时生效。
            rule.getRedirect().setMirrorCheckMd5(true);

            RoutingRule.MirrorHeaders mirrorHeaders = new RoutingRule.MirrorHeaders();
            // 是否透传除以下Header之外的其他Header到源站。只有设置RedirectType为Mirror时生效。
            mirrorHeaders.setPassAll(false);
            List passes = new ArrayList<String>();
            passes.add("cache-control");
            // 透传指定的Header到源站。只有设置RedirectType为Mirror时生效。
            mirrorHeaders.setPass(passes);
            List removes = new ArrayList<String>();
            removes.add("content-type");
            // 禁止透传指定的Header到源站。只有设置RedirectType为Mirror时生效。
            mirrorHeaders.setRemove(removes);
            List sets = new ArrayList<Map<String, String>>();
            Map header1 = new HashMap<String, String>();
            header1.put("Key", "key1");
            header1.put("Value", "value1");
            Map header2 = new HashMap<String, String>();
            header2.put("Key", "key2");
            header2.put("Value", "value2");
            sets.add(header1);
            sets.add(header2);
            // 设置传到源站的Header。不管请求中是否携带这些指定的Header，回源时都会设置这些Header。
            mirrorHeaders.setSet(sets);
            // 指定回源时携带的Header。只有设置RedirectType为Mirror时才生效。
            rule.getRedirect().setMirrorHeaders(mirrorHeaders);

            routingRules.add(rule);
            request.setRoutingRules(routingRules);
            ossClient.setBucketWebsite(request);
        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }
}

#-*-coding:utf-8-*-
import oss2
from oss2.models import BucketWebsite, MirrorHeadersSet, RedirectMirrorHeaders, Redirect, RoutingRule, \
    REDIRECT_TYPE_MIRROR, Condition
from oss2.credentials import EnvironmentVariableCredentialsProvider

# 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())

# 填写Bucket所在地域对应的Endpoint。以华东1（杭州）为例，Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。
endpoint = "https://oss-cn-hangzhou.aliyuncs.com"
# 填写Endpoint对应的Region信息，例如cn-hangzhou。注意，v4签名下，必须填写该参数
region = "cn-hangzhou"

# examplebucket填写存储空间名称。
bucket = oss2.Bucket(auth, endpoint, "examplebucket", region=region)

# 开启静态网站托管模式，并将默认首页设置为index.html，默认404页设置为error.html。
index_file = 'index.html'
error_file = 'error.html'
# 设置匹配的条件。
condition1 = Condition(key_prefix_equals='examplefolder',
                       http_err_code_return_equals=404)

# 指定镜像回源时携带的Header。
mirror_headers_set_1 = MirrorHeadersSet("myheader-key5", "myheader-value5")
mirror_headers_set_2 = MirrorHeadersSet("myheader-key6", "myheader-value6")
set_list = [mirror_headers_set_1, mirror_headers_set_2]
pass_list = ['myheader-key1', 'myheader-key2']
remove_list = ['myheader-key3', 'myheader-key4']
mirror_header = RedirectMirrorHeaders(pass_all=True, pass_list=pass_list, remove_list=remove_list, set_list=set_list)
# 指定匹配此规则后执行的动作。
redirect1 = Redirect(redirect_type=REDIRECT_TYPE_MIRROR, mirror_url='https://www.example.com/',
                     mirror_pass_query_string=True, mirror_follow_redirect=True, mirror_check_md5=True,
                     mirror_headers=mirror_header)

rule1 = RoutingRule(rule_num=1, condition=condition1, redirect=redirect1)
website_set = BucketWebsite(index_file, error_file, [rule1])

# 设置镜像回源。
bucket.put_bucket_website(website_set)

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
)

// 定义全局变量
var (
	region     string // 存储区域
	bucketName string // 存储空间名称
)

// init函数用于初始化命令行参数
func init() {
	flag.StringVar(&region, "region", "", "The region in which the bucket is located.")
	flag.StringVar(&bucketName, "bucket", "", "The name of the bucket.")
}

func main() {
	// 解析命令行参数
	flag.Parse()

	// 检查bucket名称是否为空
	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, bucket name required")
	}

	// 检查region是否为空
	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	// 加载默认配置并设置凭证提供者和区域
	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	// 创建OSS客户端
	client := oss.NewClient(cfg)

	// 设置镜像回源规则
	ruleOk := oss.RoutingRule{
		RuleNumber: oss.Ptr(int64(1)),
		Condition: &oss.RoutingRuleCondition{
			KeyPrefixEquals:             oss.Ptr("myobject"), // 指定匹配对象前缀
			HttpErrorCodeReturnedEquals: oss.Ptr(int64(404)), // 指定回源条件为HTTP状态码404
		},
		Redirect: &oss.RoutingRuleRedirect{
			RedirectType: oss.Ptr("Mirror"),               // 指定重定向类型为镜像
			MirrorURL:    oss.Ptr("http://www.test.com/"), // 指定回源地址
			MirrorHeaders: &oss.MirrorHeaders{
				//PassAll: oss.Ptr(true),                              // 指定传递所有头部
				Passs:   []string{"myheader-key1", "myheader-key2"}, // 允许传递指定HTTP Header参数
				Removes: []string{"myheader-key3", "myheader-key4"}, // 禁止传递指定HTTP Header参数
				Sets: []oss.MirrorHeadersSet{
					{
						Key:   oss.Ptr("myheader-key5"),  // 设置指定HTTP Header参数的名称
						Value: oss.Ptr("myheader-value"), // 设置指定HTTP Header参数的值
					},
				},
			},
		},
	}

	// 创建设置镜像回源的请求
	request := &oss.PutBucketWebsiteRequest{
		Bucket: oss.Ptr(bucketName), // 存储空间名称
		WebsiteConfiguration: &oss.WebsiteConfiguration{
			IndexDocument: &oss.IndexDocument{
				Suffix:        oss.Ptr("index.html"), //设置镜像回源的默认页面为index.html
				SupportSubDir: oss.Ptr(true),
				Type:          oss.Ptr(int64(0)),
			},
			ErrorDocument: &oss.ErrorDocument{
				Key:        oss.Ptr("error.html"), // 设置镜像回源的错误页面为error.html
				HttpStatus: oss.Ptr(int64(404)),
			},
			RoutingRules: &oss.RoutingRules{
				RoutingRules: []oss.RoutingRule{
					ruleOk,
				},
			},
		},
	}

	// 执行设置镜像回源的请求
	result, err := client.PutBucketWebsite(context.TODO(), request)
	if err != nil {
		log.Fatalf("failed to put bucket website %v", err)
	}

	// 打印设置镜像回源的结果
	log.Printf("put bucket website result:%#v\n", result)
}