1. Packages
  2. Opentelekomcloud Provider
  3. API Docs
  4. ObsBucket
opentelekomcloud 1.36.35 published on Monday, Apr 14, 2025 by opentelekomcloud

opentelekomcloud.ObsBucket

Explore with Pulumi AI

Up-to-date reference of API arguments for OBS bucket you can get at documentation portal

Provides an OBS bucket resource within OpenTelekomCloud. Now respects HTTP_PROXY, HTTPS_PROXY environment variables.

Example Usage

Private Bucket with Tags

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

const obsBucket = new opentelekomcloud.ObsBucket("obsBucket", {
    acl: "private",
    bucket: "my-tf-test-bucket",
    tags: {
        Env: "Test",
        foo: "bar",
    },
});
Copy
import pulumi
import pulumi_opentelekomcloud as opentelekomcloud

obs_bucket = opentelekomcloud.ObsBucket("obsBucket",
    acl="private",
    bucket="my-tf-test-bucket",
    tags={
        "Env": "Test",
        "foo": "bar",
    })
Copy
package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opentelekomcloud/opentelekomcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opentelekomcloud.NewObsBucket(ctx, "obsBucket", &opentelekomcloud.ObsBucketArgs{
			Acl:    pulumi.String("private"),
			Bucket: pulumi.String("my-tf-test-bucket"),
			Tags: pulumi.StringMap{
				"Env": pulumi.String("Test"),
				"foo": pulumi.String("bar"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Opentelekomcloud = Pulumi.Opentelekomcloud;

return await Deployment.RunAsync(() => 
{
    var obsBucket = new Opentelekomcloud.ObsBucket("obsBucket", new()
    {
        Acl = "private",
        Bucket = "my-tf-test-bucket",
        Tags = 
        {
            { "Env", "Test" },
            { "foo", "bar" },
        },
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opentelekomcloud.ObsBucket;
import com.pulumi.opentelekomcloud.ObsBucketArgs;
import java.util.List;
import java.util.ArrayList;
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 obsBucket = new ObsBucket("obsBucket", ObsBucketArgs.builder()
            .acl("private")
            .bucket("my-tf-test-bucket")
            .tags(Map.ofEntries(
                Map.entry("Env", "Test"),
                Map.entry("foo", "bar")
            ))
            .build());

    }
}
Copy
resources:
  obsBucket:
    type: opentelekomcloud:ObsBucket
    properties:
      acl: private
      bucket: my-tf-test-bucket
      tags:
        Env: Test
        foo: bar
Copy

Parallel file system bucket

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

const obsBucket = new opentelekomcloud.ObsBucket("obsBucket", {
    bucket: "my-tf-test-bucket",
    parallelFs: true,
});
Copy
import pulumi
import pulumi_opentelekomcloud as opentelekomcloud

obs_bucket = opentelekomcloud.ObsBucket("obsBucket",
    bucket="my-tf-test-bucket",
    parallel_fs=True)
Copy
package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opentelekomcloud/opentelekomcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opentelekomcloud.NewObsBucket(ctx, "obsBucket", &opentelekomcloud.ObsBucketArgs{
			Bucket:     pulumi.String("my-tf-test-bucket"),
			ParallelFs: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Opentelekomcloud = Pulumi.Opentelekomcloud;

return await Deployment.RunAsync(() => 
{
    var obsBucket = new Opentelekomcloud.ObsBucket("obsBucket", new()
    {
        Bucket = "my-tf-test-bucket",
        ParallelFs = true,
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opentelekomcloud.ObsBucket;
import com.pulumi.opentelekomcloud.ObsBucketArgs;
import java.util.List;
import java.util.ArrayList;
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 obsBucket = new ObsBucket("obsBucket", ObsBucketArgs.builder()
            .bucket("my-tf-test-bucket")
            .parallelFs(true)
            .build());

    }
}
Copy
resources:
  obsBucket:
    type: opentelekomcloud:ObsBucket
    properties:
      bucket: my-tf-test-bucket
      parallelFs: true
Copy

Enable versioning

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

const obsBucket = new opentelekomcloud.ObsBucket("obsBucket", {
    acl: "private",
    bucket: "my-tf-test-bucket",
    versioning: true,
});
Copy
import pulumi
import pulumi_opentelekomcloud as opentelekomcloud

obs_bucket = opentelekomcloud.ObsBucket("obsBucket",
    acl="private",
    bucket="my-tf-test-bucket",
    versioning=True)
Copy
package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opentelekomcloud/opentelekomcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opentelekomcloud.NewObsBucket(ctx, "obsBucket", &opentelekomcloud.ObsBucketArgs{
			Acl:        pulumi.String("private"),
			Bucket:     pulumi.String("my-tf-test-bucket"),
			Versioning: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Opentelekomcloud = Pulumi.Opentelekomcloud;

return await Deployment.RunAsync(() => 
{
    var obsBucket = new Opentelekomcloud.ObsBucket("obsBucket", new()
    {
        Acl = "private",
        Bucket = "my-tf-test-bucket",
        Versioning = true,
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opentelekomcloud.ObsBucket;
import com.pulumi.opentelekomcloud.ObsBucketArgs;
import java.util.List;
import java.util.ArrayList;
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 obsBucket = new ObsBucket("obsBucket", ObsBucketArgs.builder()
            .acl("private")
            .bucket("my-tf-test-bucket")
            .versioning(true)
            .build());

    }
}
Copy
resources:
  obsBucket:
    type: opentelekomcloud:ObsBucket
    properties:
      acl: private
      bucket: my-tf-test-bucket
      versioning: true
Copy

Suspend versioning

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

const obsBucket = new opentelekomcloud.ObsBucket("obsBucket", {
    acl: "private",
    bucket: "my-tf-test-bucket",
    versioning: false,
});
Copy
import pulumi
import pulumi_opentelekomcloud as opentelekomcloud

obs_bucket = opentelekomcloud.ObsBucket("obsBucket",
    acl="private",
    bucket="my-tf-test-bucket",
    versioning=False)
Copy
package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opentelekomcloud/opentelekomcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opentelekomcloud.NewObsBucket(ctx, "obsBucket", &opentelekomcloud.ObsBucketArgs{
			Acl:        pulumi.String("private"),
			Bucket:     pulumi.String("my-tf-test-bucket"),
			Versioning: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Opentelekomcloud = Pulumi.Opentelekomcloud;

return await Deployment.RunAsync(() => 
{
    var obsBucket = new Opentelekomcloud.ObsBucket("obsBucket", new()
    {
        Acl = "private",
        Bucket = "my-tf-test-bucket",
        Versioning = false,
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opentelekomcloud.ObsBucket;
import com.pulumi.opentelekomcloud.ObsBucketArgs;
import java.util.List;
import java.util.ArrayList;
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 obsBucket = new ObsBucket("obsBucket", ObsBucketArgs.builder()
            .acl("private")
            .bucket("my-tf-test-bucket")
            .versioning(false)
            .build());

    }
}
Copy
resources:
  obsBucket:
    type: opentelekomcloud:ObsBucket
    properties:
      acl: private
      bucket: my-tf-test-bucket
      versioning: false
Copy

WORM policy with versioning enabled

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

const obsBucket = new opentelekomcloud.ObsBucket("obsBucket", {
    bucket: "my-tf-test-bucket",
    versioning: true,
    wormPolicy: {
        years: 1,
    },
});
Copy
import pulumi
import pulumi_opentelekomcloud as opentelekomcloud

obs_bucket = opentelekomcloud.ObsBucket("obsBucket",
    bucket="my-tf-test-bucket",
    versioning=True,
    worm_policy={
        "years": 1,
    })
Copy
package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opentelekomcloud/opentelekomcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opentelekomcloud.NewObsBucket(ctx, "obsBucket", &opentelekomcloud.ObsBucketArgs{
			Bucket:     pulumi.String("my-tf-test-bucket"),
			Versioning: pulumi.Bool(true),
			WormPolicy: &opentelekomcloud.ObsBucketWormPolicyArgs{
				Years: pulumi.Float64(1),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Opentelekomcloud = Pulumi.Opentelekomcloud;

return await Deployment.RunAsync(() => 
{
    var obsBucket = new Opentelekomcloud.ObsBucket("obsBucket", new()
    {
        Bucket = "my-tf-test-bucket",
        Versioning = true,
        WormPolicy = new Opentelekomcloud.Inputs.ObsBucketWormPolicyArgs
        {
            Years = 1,
        },
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opentelekomcloud.ObsBucket;
import com.pulumi.opentelekomcloud.ObsBucketArgs;
import com.pulumi.opentelekomcloud.inputs.ObsBucketWormPolicyArgs;
import java.util.List;
import java.util.ArrayList;
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 obsBucket = new ObsBucket("obsBucket", ObsBucketArgs.builder()
            .bucket("my-tf-test-bucket")
            .versioning(true)
            .wormPolicy(ObsBucketWormPolicyArgs.builder()
                .years(1)
                .build())
            .build());

    }
}
Copy
resources:
  obsBucket:
    type: opentelekomcloud:ObsBucket
    properties:
      bucket: my-tf-test-bucket
      versioning: true
      wormPolicy:
        years: 1
Copy

Enable Logging

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

const logBucket = new opentelekomcloud.ObsBucket("logBucket", {
    bucket: "my-tf-log-bucket",
    acl: "log-delivery-write",
});
const obsBucket = new opentelekomcloud.ObsBucket("obsBucket", {
    bucket: "my-tf-test-bucket",
    acl: "private",
    loggings: [{
        targetBucket: logBucket.obsBucketId,
        targetPrefix: "log/",
    }],
});
Copy
import pulumi
import pulumi_opentelekomcloud as opentelekomcloud

log_bucket = opentelekomcloud.ObsBucket("logBucket",
    bucket="my-tf-log-bucket",
    acl="log-delivery-write")
obs_bucket = opentelekomcloud.ObsBucket("obsBucket",
    bucket="my-tf-test-bucket",
    acl="private",
    loggings=[{
        "target_bucket": log_bucket.obs_bucket_id,
        "target_prefix": "log/",
    }])
Copy
package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opentelekomcloud/opentelekomcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		logBucket, err := opentelekomcloud.NewObsBucket(ctx, "logBucket", &opentelekomcloud.ObsBucketArgs{
			Bucket: pulumi.String("my-tf-log-bucket"),
			Acl:    pulumi.String("log-delivery-write"),
		})
		if err != nil {
			return err
		}
		_, err = opentelekomcloud.NewObsBucket(ctx, "obsBucket", &opentelekomcloud.ObsBucketArgs{
			Bucket: pulumi.String("my-tf-test-bucket"),
			Acl:    pulumi.String("private"),
			Loggings: opentelekomcloud.ObsBucketLoggingArray{
				&opentelekomcloud.ObsBucketLoggingArgs{
					TargetBucket: logBucket.ObsBucketId,
					TargetPrefix: pulumi.String("log/"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Opentelekomcloud = Pulumi.Opentelekomcloud;

return await Deployment.RunAsync(() => 
{
    var logBucket = new Opentelekomcloud.ObsBucket("logBucket", new()
    {
        Bucket = "my-tf-log-bucket",
        Acl = "log-delivery-write",
    });

    var obsBucket = new Opentelekomcloud.ObsBucket("obsBucket", new()
    {
        Bucket = "my-tf-test-bucket",
        Acl = "private",
        Loggings = new[]
        {
            new Opentelekomcloud.Inputs.ObsBucketLoggingArgs
            {
                TargetBucket = logBucket.ObsBucketId,
                TargetPrefix = "log/",
            },
        },
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opentelekomcloud.ObsBucket;
import com.pulumi.opentelekomcloud.ObsBucketArgs;
import com.pulumi.opentelekomcloud.inputs.ObsBucketLoggingArgs;
import java.util.List;
import java.util.ArrayList;
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 logBucket = new ObsBucket("logBucket", ObsBucketArgs.builder()
            .bucket("my-tf-log-bucket")
            .acl("log-delivery-write")
            .build());

        var obsBucket = new ObsBucket("obsBucket", ObsBucketArgs.builder()
            .bucket("my-tf-test-bucket")
            .acl("private")
            .loggings(ObsBucketLoggingArgs.builder()
                .targetBucket(logBucket.obsBucketId())
                .targetPrefix("log/")
                .build())
            .build());

    }
}
Copy
resources:
  logBucket:
    type: opentelekomcloud:ObsBucket
    properties:
      bucket: my-tf-log-bucket
      acl: log-delivery-write
  obsBucket:
    type: opentelekomcloud:ObsBucket
    properties:
      bucket: my-tf-test-bucket
      acl: private
      loggings:
        - targetBucket: ${logBucket.obsBucketId}
          targetPrefix: log/
Copy

Static Website Hosting

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

const obsBucket = new opentelekomcloud.ObsBucket("obsBucket", {
    acl: "public-read",
    bucket: "obs-website-test.hashicorp.com",
    website: {
        errorDocument: "error.html",
        indexDocument: "index.html",
        routingRules: `[{
    "Condition": {
        "KeyPrefixEquals": "docs/"
    },
    "Redirect": {
        "ReplaceKeyPrefixWith": "documents/"
    }
}]

`,
    },
});
Copy
import pulumi
import pulumi_opentelekomcloud as opentelekomcloud

obs_bucket = opentelekomcloud.ObsBucket("obsBucket",
    acl="public-read",
    bucket="obs-website-test.hashicorp.com",
    website={
        "error_document": "error.html",
        "index_document": "index.html",
        "routing_rules": """[{
    "Condition": {
        "KeyPrefixEquals": "docs/"
    },
    "Redirect": {
        "ReplaceKeyPrefixWith": "documents/"
    }
}]

""",
    })
Copy
package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opentelekomcloud/opentelekomcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opentelekomcloud.NewObsBucket(ctx, "obsBucket", &opentelekomcloud.ObsBucketArgs{
			Acl:    pulumi.String("public-read"),
			Bucket: pulumi.String("obs-website-test.hashicorp.com"),
			Website: &opentelekomcloud.ObsBucketWebsiteArgs{
				ErrorDocument: pulumi.String("error.html"),
				IndexDocument: pulumi.String("index.html"),
				RoutingRules: pulumi.String(`[{
    "Condition": {
        "KeyPrefixEquals": "docs/"
    },
    "Redirect": {
        "ReplaceKeyPrefixWith": "documents/"
    }
}]

`),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Opentelekomcloud = Pulumi.Opentelekomcloud;

return await Deployment.RunAsync(() => 
{
    var obsBucket = new Opentelekomcloud.ObsBucket("obsBucket", new()
    {
        Acl = "public-read",
        Bucket = "obs-website-test.hashicorp.com",
        Website = new Opentelekomcloud.Inputs.ObsBucketWebsiteArgs
        {
            ErrorDocument = "error.html",
            IndexDocument = "index.html",
            RoutingRules = @"[{
    ""Condition"": {
        ""KeyPrefixEquals"": ""docs/""
    },
    ""Redirect"": {
        ""ReplaceKeyPrefixWith"": ""documents/""
    }
}]

",
        },
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opentelekomcloud.ObsBucket;
import com.pulumi.opentelekomcloud.ObsBucketArgs;
import com.pulumi.opentelekomcloud.inputs.ObsBucketWebsiteArgs;
import java.util.List;
import java.util.ArrayList;
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 obsBucket = new ObsBucket("obsBucket", ObsBucketArgs.builder()
            .acl("public-read")
            .bucket("obs-website-test.hashicorp.com")
            .website(ObsBucketWebsiteArgs.builder()
                .errorDocument("error.html")
                .indexDocument("index.html")
                .routingRules("""
[{
    "Condition": {
        "KeyPrefixEquals": "docs/"
    },
    "Redirect": {
        "ReplaceKeyPrefixWith": "documents/"
    }
}]

                """)
                .build())
            .build());

    }
}
Copy
resources:
  obsBucket:
    type: opentelekomcloud:ObsBucket
    properties:
      acl: public-read
      bucket: obs-website-test.hashicorp.com
      website:
        errorDocument: error.html
        indexDocument: index.html
        routingRules: |+
          [{
              "Condition": {
                  "KeyPrefixEquals": "docs/"
              },
              "Redirect": {
                  "ReplaceKeyPrefixWith": "documents/"
              }
          }]          
Copy

Using CORS

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

const obsBucket = new opentelekomcloud.ObsBucket("obsBucket", {
    acl: "public-read",
    bucket: "obs-website-test.hashicorp.com",
    corsRules: [{
        allowedHeaders: ["*"],
        allowedMethods: [
            "PUT",
            "POST",
        ],
        allowedOrigins: ["https://obs-website-test.hashicorp.com"],
        exposeHeaders: ["ETag"],
        maxAgeSeconds: 3000,
    }],
});
Copy
import pulumi
import pulumi_opentelekomcloud as opentelekomcloud

obs_bucket = opentelekomcloud.ObsBucket("obsBucket",
    acl="public-read",
    bucket="obs-website-test.hashicorp.com",
    cors_rules=[{
        "allowed_headers": ["*"],
        "allowed_methods": [
            "PUT",
            "POST",
        ],
        "allowed_origins": ["https://obs-website-test.hashicorp.com"],
        "expose_headers": ["ETag"],
        "max_age_seconds": 3000,
    }])
Copy
package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opentelekomcloud/opentelekomcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opentelekomcloud.NewObsBucket(ctx, "obsBucket", &opentelekomcloud.ObsBucketArgs{
			Acl:    pulumi.String("public-read"),
			Bucket: pulumi.String("obs-website-test.hashicorp.com"),
			CorsRules: opentelekomcloud.ObsBucketCorsRuleArray{
				&opentelekomcloud.ObsBucketCorsRuleArgs{
					AllowedHeaders: pulumi.StringArray{
						pulumi.String("*"),
					},
					AllowedMethods: pulumi.StringArray{
						pulumi.String("PUT"),
						pulumi.String("POST"),
					},
					AllowedOrigins: pulumi.StringArray{
						pulumi.String("https://obs-website-test.hashicorp.com"),
					},
					ExposeHeaders: pulumi.StringArray{
						pulumi.String("ETag"),
					},
					MaxAgeSeconds: pulumi.Float64(3000),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Opentelekomcloud = Pulumi.Opentelekomcloud;

return await Deployment.RunAsync(() => 
{
    var obsBucket = new Opentelekomcloud.ObsBucket("obsBucket", new()
    {
        Acl = "public-read",
        Bucket = "obs-website-test.hashicorp.com",
        CorsRules = new[]
        {
            new Opentelekomcloud.Inputs.ObsBucketCorsRuleArgs
            {
                AllowedHeaders = new[]
                {
                    "*",
                },
                AllowedMethods = new[]
                {
                    "PUT",
                    "POST",
                },
                AllowedOrigins = new[]
                {
                    "https://obs-website-test.hashicorp.com",
                },
                ExposeHeaders = new[]
                {
                    "ETag",
                },
                MaxAgeSeconds = 3000,
            },
        },
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opentelekomcloud.ObsBucket;
import com.pulumi.opentelekomcloud.ObsBucketArgs;
import com.pulumi.opentelekomcloud.inputs.ObsBucketCorsRuleArgs;
import java.util.List;
import java.util.ArrayList;
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 obsBucket = new ObsBucket("obsBucket", ObsBucketArgs.builder()
            .acl("public-read")
            .bucket("obs-website-test.hashicorp.com")
            .corsRules(ObsBucketCorsRuleArgs.builder()
                .allowedHeaders("*")
                .allowedMethods(                
                    "PUT",
                    "POST")
                .allowedOrigins("https://obs-website-test.hashicorp.com")
                .exposeHeaders("ETag")
                .maxAgeSeconds(3000)
                .build())
            .build());

    }
}
Copy
resources:
  obsBucket:
    type: opentelekomcloud:ObsBucket
    properties:
      acl: public-read
      bucket: obs-website-test.hashicorp.com
      corsRules:
        - allowedHeaders:
            - '*'
          allowedMethods:
            - PUT
            - POST
          allowedOrigins:
            - https://obs-website-test.hashicorp.com
          exposeHeaders:
            - ETag
          maxAgeSeconds: 3000
Copy

Using server side encryption for the bucket

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

const bucket = new opentelekomcloud.ObsBucket("bucket", {
    bucket: "my-bucket",
    storageClass: "WARM",
    acl: "public-read",
    serverSideEncryption: {
        algorithm: "kms",
        kmsKeyId: _var.kms_master_key_id,
    },
});
Copy
import pulumi
import pulumi_opentelekomcloud as opentelekomcloud

bucket = opentelekomcloud.ObsBucket("bucket",
    bucket="my-bucket",
    storage_class="WARM",
    acl="public-read",
    server_side_encryption={
        "algorithm": "kms",
        "kms_key_id": var["kms_master_key_id"],
    })
Copy
package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opentelekomcloud/opentelekomcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opentelekomcloud.NewObsBucket(ctx, "bucket", &opentelekomcloud.ObsBucketArgs{
			Bucket:       pulumi.String("my-bucket"),
			StorageClass: pulumi.String("WARM"),
			Acl:          pulumi.String("public-read"),
			ServerSideEncryption: &opentelekomcloud.ObsBucketServerSideEncryptionArgs{
				Algorithm: pulumi.String("kms"),
				KmsKeyId:  pulumi.Any(_var.Kms_master_key_id),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Opentelekomcloud = Pulumi.Opentelekomcloud;

return await Deployment.RunAsync(() => 
{
    var bucket = new Opentelekomcloud.ObsBucket("bucket", new()
    {
        Bucket = "my-bucket",
        StorageClass = "WARM",
        Acl = "public-read",
        ServerSideEncryption = new Opentelekomcloud.Inputs.ObsBucketServerSideEncryptionArgs
        {
            Algorithm = "kms",
            KmsKeyId = @var.Kms_master_key_id,
        },
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opentelekomcloud.ObsBucket;
import com.pulumi.opentelekomcloud.ObsBucketArgs;
import com.pulumi.opentelekomcloud.inputs.ObsBucketServerSideEncryptionArgs;
import java.util.List;
import java.util.ArrayList;
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 bucket = new ObsBucket("bucket", ObsBucketArgs.builder()
            .bucket("my-bucket")
            .storageClass("WARM")
            .acl("public-read")
            .serverSideEncryption(ObsBucketServerSideEncryptionArgs.builder()
                .algorithm("kms")
                .kmsKeyId(var_.kms_master_key_id())
                .build())
            .build());

    }
}
Copy
resources:
  bucket:
    type: opentelekomcloud:ObsBucket
    properties:
      bucket: my-bucket
      storageClass: WARM
      acl: public-read
      serverSideEncryption:
        algorithm: kms
        kmsKeyId: ${var.kms_master_key_id}
Copy

Using server side encryption with the least amount of required KMS privileges

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

const thisKmsKeyV1 = new opentelekomcloud.KmsKeyV1("thisKmsKeyV1", {
    keyAlias: _var.kms_alias,
    pendingDays: "7",
    keyDescription: _var.kms_desc,
    realm: _var.region,
    isEnabled: true,
});
const thisKmsIdentityRoleV3 = new opentelekomcloud.IdentityRoleV3("thisKmsIdentityRoleV3", {
    description: _var.role_kms_desc,
    displayName: _var.role_kms_display_name,
    displayLayer: "project",
    statements: [
        {
            effect: "Allow",
            actions: [
                "kms:cmk:list",
                "kms:cmk:get",
            ],
        },
        {
            effect: "Allow",
            resources: [pulumi.interpolate`KMS:*:*:KeyId:${thisKmsKeyV1.kmsKeyV1Id}`],
            actions: [
                "kms:cmk:generate",
                "kms:dek:create",
                "kms:cmk:crypto",
                "kms:dek:crypto",
            ],
        },
    ],
});
const thisObsBucket = new opentelekomcloud.ObsBucket("thisObsBucket", {
    bucket: _var.bucket_name,
    acl: "private",
    serverSideEncryption: {
        algorithm: "kms",
        kmsKeyId: thisKmsKeyV1.kmsKeyV1Id,
    },
});
const thisObsIdentityRoleV3 = new opentelekomcloud.IdentityRoleV3("thisObsIdentityRoleV3", {
    description: _var.role_obs_desc,
    displayName: _var.role_obs_display_name,
    displayLayer: "domain",
    statements: [{
        effect: "Allow",
        resources: [
            pulumi.interpolate`OBS:*:*:bucket:${thisObsBucket.obsBucketId}`,
            "OBS:*:*:object:*",
        ],
        actions: [
            "obs:object:DeleteObject",
            "obs:object:PutObject",
            "obs:object:GetObject",
            "obs:bucket:ListBucket",
            "obs:bucket:GetEncryptionConfiguration",
        ],
    }],
});
const thisIdentityUserV3 = new opentelekomcloud.IdentityUserV3("thisIdentityUserV3", {
    description: _var.user_desc,
    accessType: "programmatic",
});
const thisIdentityGroupV3 = new opentelekomcloud.IdentityGroupV3("thisIdentityGroupV3", {description: _var.user_group_desc});
const thisKmsIdentityRoleAssignmentV3 = new opentelekomcloud.IdentityRoleAssignmentV3("thisKmsIdentityRoleAssignmentV3", {
    groupId: thisIdentityGroupV3.identityGroupV3Id,
    domainId: _var.domain_id,
    roleId: thisKmsIdentityRoleV3.identityRoleV3Id,
    allProjects: true,
});
const thisObsIdentityRoleAssignmentV3 = new opentelekomcloud.IdentityRoleAssignmentV3("thisObsIdentityRoleAssignmentV3", {
    groupId: thisIdentityGroupV3.identityGroupV3Id,
    domainId: _var.domain_id,
    roleId: thisObsIdentityRoleV3.identityRoleV3Id,
    allProjects: true,
});
Copy
import pulumi
import pulumi_opentelekomcloud as opentelekomcloud

this_kms_key_v1 = opentelekomcloud.KmsKeyV1("thisKmsKeyV1",
    key_alias=var["kms_alias"],
    pending_days="7",
    key_description=var["kms_desc"],
    realm=var["region"],
    is_enabled=True)
this_kms_identity_role_v3 = opentelekomcloud.IdentityRoleV3("thisKmsIdentityRoleV3",
    description=var["role_kms_desc"],
    display_name=var["role_kms_display_name"],
    display_layer="project",
    statements=[
        {
            "effect": "Allow",
            "actions": [
                "kms:cmk:list",
                "kms:cmk:get",
            ],
        },
        {
            "effect": "Allow",
            "resources": [this_kms_key_v1.kms_key_v1_id.apply(lambda kms_key_v1_id: f"KMS:*:*:KeyId:{kms_key_v1_id}")],
            "actions": [
                "kms:cmk:generate",
                "kms:dek:create",
                "kms:cmk:crypto",
                "kms:dek:crypto",
            ],
        },
    ])
this_obs_bucket = opentelekomcloud.ObsBucket("thisObsBucket",
    bucket=var["bucket_name"],
    acl="private",
    server_side_encryption={
        "algorithm": "kms",
        "kms_key_id": this_kms_key_v1.kms_key_v1_id,
    })
this_obs_identity_role_v3 = opentelekomcloud.IdentityRoleV3("thisObsIdentityRoleV3",
    description=var["role_obs_desc"],
    display_name=var["role_obs_display_name"],
    display_layer="domain",
    statements=[{
        "effect": "Allow",
        "resources": [
            this_obs_bucket.obs_bucket_id.apply(lambda obs_bucket_id: f"OBS:*:*:bucket:{obs_bucket_id}"),
            "OBS:*:*:object:*",
        ],
        "actions": [
            "obs:object:DeleteObject",
            "obs:object:PutObject",
            "obs:object:GetObject",
            "obs:bucket:ListBucket",
            "obs:bucket:GetEncryptionConfiguration",
        ],
    }])
this_identity_user_v3 = opentelekomcloud.IdentityUserV3("thisIdentityUserV3",
    description=var["user_desc"],
    access_type="programmatic")
this_identity_group_v3 = opentelekomcloud.IdentityGroupV3("thisIdentityGroupV3", description=var["user_group_desc"])
this_kms_identity_role_assignment_v3 = opentelekomcloud.IdentityRoleAssignmentV3("thisKmsIdentityRoleAssignmentV3",
    group_id=this_identity_group_v3.identity_group_v3_id,
    domain_id=var["domain_id"],
    role_id=this_kms_identity_role_v3.identity_role_v3_id,
    all_projects=True)
this_obs_identity_role_assignment_v3 = opentelekomcloud.IdentityRoleAssignmentV3("thisObsIdentityRoleAssignmentV3",
    group_id=this_identity_group_v3.identity_group_v3_id,
    domain_id=var["domain_id"],
    role_id=this_obs_identity_role_v3.identity_role_v3_id,
    all_projects=True)
Copy
package main

import (
	"fmt"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opentelekomcloud/opentelekomcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		thisKmsKeyV1, err := opentelekomcloud.NewKmsKeyV1(ctx, "thisKmsKeyV1", &opentelekomcloud.KmsKeyV1Args{
			KeyAlias:       pulumi.Any(_var.Kms_alias),
			PendingDays:    pulumi.String("7"),
			KeyDescription: pulumi.Any(_var.Kms_desc),
			Realm:          pulumi.Any(_var.Region),
			IsEnabled:      pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		thisKmsIdentityRoleV3, err := opentelekomcloud.NewIdentityRoleV3(ctx, "thisKmsIdentityRoleV3", &opentelekomcloud.IdentityRoleV3Args{
			Description:  pulumi.Any(_var.Role_kms_desc),
			DisplayName:  pulumi.Any(_var.Role_kms_display_name),
			DisplayLayer: pulumi.String("project"),
			Statements: opentelekomcloud.IdentityRoleV3StatementArray{
				&opentelekomcloud.IdentityRoleV3StatementArgs{
					Effect: pulumi.String("Allow"),
					Actions: pulumi.StringArray{
						pulumi.String("kms:cmk:list"),
						pulumi.String("kms:cmk:get"),
					},
				},
				&opentelekomcloud.IdentityRoleV3StatementArgs{
					Effect: pulumi.String("Allow"),
					Resources: pulumi.StringArray{
						thisKmsKeyV1.KmsKeyV1Id.ApplyT(func(kmsKeyV1Id string) (string, error) {
							return fmt.Sprintf("KMS:*:*:KeyId:%v", kmsKeyV1Id), nil
						}).(pulumi.StringOutput),
					},
					Actions: pulumi.StringArray{
						pulumi.String("kms:cmk:generate"),
						pulumi.String("kms:dek:create"),
						pulumi.String("kms:cmk:crypto"),
						pulumi.String("kms:dek:crypto"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		thisObsBucket, err := opentelekomcloud.NewObsBucket(ctx, "thisObsBucket", &opentelekomcloud.ObsBucketArgs{
			Bucket: pulumi.Any(_var.Bucket_name),
			Acl:    pulumi.String("private"),
			ServerSideEncryption: &opentelekomcloud.ObsBucketServerSideEncryptionArgs{
				Algorithm: pulumi.String("kms"),
				KmsKeyId:  thisKmsKeyV1.KmsKeyV1Id,
			},
		})
		if err != nil {
			return err
		}
		thisObsIdentityRoleV3, err := opentelekomcloud.NewIdentityRoleV3(ctx, "thisObsIdentityRoleV3", &opentelekomcloud.IdentityRoleV3Args{
			Description:  pulumi.Any(_var.Role_obs_desc),
			DisplayName:  pulumi.Any(_var.Role_obs_display_name),
			DisplayLayer: pulumi.String("domain"),
			Statements: opentelekomcloud.IdentityRoleV3StatementArray{
				&opentelekomcloud.IdentityRoleV3StatementArgs{
					Effect: pulumi.String("Allow"),
					Resources: pulumi.StringArray{
						thisObsBucket.ObsBucketId.ApplyT(func(obsBucketId string) (string, error) {
							return fmt.Sprintf("OBS:*:*:bucket:%v", obsBucketId), nil
						}).(pulumi.StringOutput),
						pulumi.String("OBS:*:*:object:*"),
					},
					Actions: pulumi.StringArray{
						pulumi.String("obs:object:DeleteObject"),
						pulumi.String("obs:object:PutObject"),
						pulumi.String("obs:object:GetObject"),
						pulumi.String("obs:bucket:ListBucket"),
						pulumi.String("obs:bucket:GetEncryptionConfiguration"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = opentelekomcloud.NewIdentityUserV3(ctx, "thisIdentityUserV3", &opentelekomcloud.IdentityUserV3Args{
			Description: pulumi.Any(_var.User_desc),
			AccessType:  pulumi.String("programmatic"),
		})
		if err != nil {
			return err
		}
		thisIdentityGroupV3, err := opentelekomcloud.NewIdentityGroupV3(ctx, "thisIdentityGroupV3", &opentelekomcloud.IdentityGroupV3Args{
			Description: pulumi.Any(_var.User_group_desc),
		})
		if err != nil {
			return err
		}
		_, err = opentelekomcloud.NewIdentityRoleAssignmentV3(ctx, "thisKmsIdentityRoleAssignmentV3", &opentelekomcloud.IdentityRoleAssignmentV3Args{
			GroupId:     thisIdentityGroupV3.IdentityGroupV3Id,
			DomainId:    pulumi.Any(_var.Domain_id),
			RoleId:      thisKmsIdentityRoleV3.IdentityRoleV3Id,
			AllProjects: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = opentelekomcloud.NewIdentityRoleAssignmentV3(ctx, "thisObsIdentityRoleAssignmentV3", &opentelekomcloud.IdentityRoleAssignmentV3Args{
			GroupId:     thisIdentityGroupV3.IdentityGroupV3Id,
			DomainId:    pulumi.Any(_var.Domain_id),
			RoleId:      thisObsIdentityRoleV3.IdentityRoleV3Id,
			AllProjects: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Opentelekomcloud = Pulumi.Opentelekomcloud;

return await Deployment.RunAsync(() => 
{
    var thisKmsKeyV1 = new Opentelekomcloud.KmsKeyV1("thisKmsKeyV1", new()
    {
        KeyAlias = @var.Kms_alias,
        PendingDays = "7",
        KeyDescription = @var.Kms_desc,
        Realm = @var.Region,
        IsEnabled = true,
    });

    var thisKmsIdentityRoleV3 = new Opentelekomcloud.IdentityRoleV3("thisKmsIdentityRoleV3", new()
    {
        Description = @var.Role_kms_desc,
        DisplayName = @var.Role_kms_display_name,
        DisplayLayer = "project",
        Statements = new[]
        {
            new Opentelekomcloud.Inputs.IdentityRoleV3StatementArgs
            {
                Effect = "Allow",
                Actions = new[]
                {
                    "kms:cmk:list",
                    "kms:cmk:get",
                },
            },
            new Opentelekomcloud.Inputs.IdentityRoleV3StatementArgs
            {
                Effect = "Allow",
                Resources = new[]
                {
                    thisKmsKeyV1.KmsKeyV1Id.Apply(kmsKeyV1Id => $"KMS:*:*:KeyId:{kmsKeyV1Id}"),
                },
                Actions = new[]
                {
                    "kms:cmk:generate",
                    "kms:dek:create",
                    "kms:cmk:crypto",
                    "kms:dek:crypto",
                },
            },
        },
    });

    var thisObsBucket = new Opentelekomcloud.ObsBucket("thisObsBucket", new()
    {
        Bucket = @var.Bucket_name,
        Acl = "private",
        ServerSideEncryption = new Opentelekomcloud.Inputs.ObsBucketServerSideEncryptionArgs
        {
            Algorithm = "kms",
            KmsKeyId = thisKmsKeyV1.KmsKeyV1Id,
        },
    });

    var thisObsIdentityRoleV3 = new Opentelekomcloud.IdentityRoleV3("thisObsIdentityRoleV3", new()
    {
        Description = @var.Role_obs_desc,
        DisplayName = @var.Role_obs_display_name,
        DisplayLayer = "domain",
        Statements = new[]
        {
            new Opentelekomcloud.Inputs.IdentityRoleV3StatementArgs
            {
                Effect = "Allow",
                Resources = new[]
                {
                    thisObsBucket.ObsBucketId.Apply(obsBucketId => $"OBS:*:*:bucket:{obsBucketId}"),
                    "OBS:*:*:object:*",
                },
                Actions = new[]
                {
                    "obs:object:DeleteObject",
                    "obs:object:PutObject",
                    "obs:object:GetObject",
                    "obs:bucket:ListBucket",
                    "obs:bucket:GetEncryptionConfiguration",
                },
            },
        },
    });

    var thisIdentityUserV3 = new Opentelekomcloud.IdentityUserV3("thisIdentityUserV3", new()
    {
        Description = @var.User_desc,
        AccessType = "programmatic",
    });

    var thisIdentityGroupV3 = new Opentelekomcloud.IdentityGroupV3("thisIdentityGroupV3", new()
    {
        Description = @var.User_group_desc,
    });

    var thisKmsIdentityRoleAssignmentV3 = new Opentelekomcloud.IdentityRoleAssignmentV3("thisKmsIdentityRoleAssignmentV3", new()
    {
        GroupId = thisIdentityGroupV3.IdentityGroupV3Id,
        DomainId = @var.Domain_id,
        RoleId = thisKmsIdentityRoleV3.IdentityRoleV3Id,
        AllProjects = true,
    });

    var thisObsIdentityRoleAssignmentV3 = new Opentelekomcloud.IdentityRoleAssignmentV3("thisObsIdentityRoleAssignmentV3", new()
    {
        GroupId = thisIdentityGroupV3.IdentityGroupV3Id,
        DomainId = @var.Domain_id,
        RoleId = thisObsIdentityRoleV3.IdentityRoleV3Id,
        AllProjects = true,
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opentelekomcloud.KmsKeyV1;
import com.pulumi.opentelekomcloud.KmsKeyV1Args;
import com.pulumi.opentelekomcloud.IdentityRoleV3;
import com.pulumi.opentelekomcloud.IdentityRoleV3Args;
import com.pulumi.opentelekomcloud.inputs.IdentityRoleV3StatementArgs;
import com.pulumi.opentelekomcloud.ObsBucket;
import com.pulumi.opentelekomcloud.ObsBucketArgs;
import com.pulumi.opentelekomcloud.inputs.ObsBucketServerSideEncryptionArgs;
import com.pulumi.opentelekomcloud.IdentityUserV3;
import com.pulumi.opentelekomcloud.IdentityUserV3Args;
import com.pulumi.opentelekomcloud.IdentityGroupV3;
import com.pulumi.opentelekomcloud.IdentityGroupV3Args;
import com.pulumi.opentelekomcloud.IdentityRoleAssignmentV3;
import com.pulumi.opentelekomcloud.IdentityRoleAssignmentV3Args;
import java.util.List;
import java.util.ArrayList;
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 thisKmsKeyV1 = new KmsKeyV1("thisKmsKeyV1", KmsKeyV1Args.builder()
            .keyAlias(var_.kms_alias())
            .pendingDays("7")
            .keyDescription(var_.kms_desc())
            .realm(var_.region())
            .isEnabled(true)
            .build());

        var thisKmsIdentityRoleV3 = new IdentityRoleV3("thisKmsIdentityRoleV3", IdentityRoleV3Args.builder()
            .description(var_.role_kms_desc())
            .displayName(var_.role_kms_display_name())
            .displayLayer("project")
            .statements(            
                IdentityRoleV3StatementArgs.builder()
                    .effect("Allow")
                    .actions(                    
                        "kms:cmk:list",
                        "kms:cmk:get")
                    .build(),
                IdentityRoleV3StatementArgs.builder()
                    .effect("Allow")
                    .resources(thisKmsKeyV1.kmsKeyV1Id().applyValue(kmsKeyV1Id -> String.format("KMS:*:*:KeyId:%s", kmsKeyV1Id)))
                    .actions(                    
                        "kms:cmk:generate",
                        "kms:dek:create",
                        "kms:cmk:crypto",
                        "kms:dek:crypto")
                    .build())
            .build());

        var thisObsBucket = new ObsBucket("thisObsBucket", ObsBucketArgs.builder()
            .bucket(var_.bucket_name())
            .acl("private")
            .serverSideEncryption(ObsBucketServerSideEncryptionArgs.builder()
                .algorithm("kms")
                .kmsKeyId(thisKmsKeyV1.kmsKeyV1Id())
                .build())
            .build());

        var thisObsIdentityRoleV3 = new IdentityRoleV3("thisObsIdentityRoleV3", IdentityRoleV3Args.builder()
            .description(var_.role_obs_desc())
            .displayName(var_.role_obs_display_name())
            .displayLayer("domain")
            .statements(IdentityRoleV3StatementArgs.builder()
                .effect("Allow")
                .resources(                
                    thisObsBucket.obsBucketId().applyValue(obsBucketId -> String.format("OBS:*:*:bucket:%s", obsBucketId)),
                    "OBS:*:*:object:*")
                .actions(                
                    "obs:object:DeleteObject",
                    "obs:object:PutObject",
                    "obs:object:GetObject",
                    "obs:bucket:ListBucket",
                    "obs:bucket:GetEncryptionConfiguration")
                .build())
            .build());

        var thisIdentityUserV3 = new IdentityUserV3("thisIdentityUserV3", IdentityUserV3Args.builder()
            .description(var_.user_desc())
            .accessType("programmatic")
            .build());

        var thisIdentityGroupV3 = new IdentityGroupV3("thisIdentityGroupV3", IdentityGroupV3Args.builder()
            .description(var_.user_group_desc())
            .build());

        var thisKmsIdentityRoleAssignmentV3 = new IdentityRoleAssignmentV3("thisKmsIdentityRoleAssignmentV3", IdentityRoleAssignmentV3Args.builder()
            .groupId(thisIdentityGroupV3.identityGroupV3Id())
            .domainId(var_.domain_id())
            .roleId(thisKmsIdentityRoleV3.identityRoleV3Id())
            .allProjects(true)
            .build());

        var thisObsIdentityRoleAssignmentV3 = new IdentityRoleAssignmentV3("thisObsIdentityRoleAssignmentV3", IdentityRoleAssignmentV3Args.builder()
            .groupId(thisIdentityGroupV3.identityGroupV3Id())
            .domainId(var_.domain_id())
            .roleId(thisObsIdentityRoleV3.identityRoleV3Id())
            .allProjects(true)
            .build());

    }
}
Copy
resources:
  thisKmsIdentityRoleV3:
    type: opentelekomcloud:IdentityRoleV3
    properties:
      description: ${var.role_kms_desc}
      displayName: ${var.role_kms_display_name}
      displayLayer: project
      statements:
        - effect: Allow
          actions:
            - kms:cmk:list
            - kms:cmk:get
        - effect: Allow
          resources:
            - KMS:*:*:KeyId:${thisKmsKeyV1.kmsKeyV1Id}
          actions:
            - kms:cmk:generate
            - kms:dek:create
            - kms:cmk:crypto
            - kms:dek:crypto
  thisObsIdentityRoleV3:
    type: opentelekomcloud:IdentityRoleV3
    properties:
      description: ${var.role_obs_desc}
      displayName: ${var.role_obs_display_name}
      displayLayer: domain
      statements:
        - effect: Allow
          resources:
            - OBS:*:*:bucket:${thisObsBucket.obsBucketId}
            - OBS:*:*:object:*
          actions:
            - obs:object:DeleteObject
            - obs:object:PutObject
            - obs:object:GetObject
            - obs:bucket:ListBucket
            - obs:bucket:GetEncryptionConfiguration
  thisIdentityUserV3:
    type: opentelekomcloud:IdentityUserV3
    properties:
      description: ${var.user_desc}
      accessType: programmatic
  thisIdentityGroupV3:
    type: opentelekomcloud:IdentityGroupV3
    properties:
      description: ${var.user_group_desc}
  thisKmsIdentityRoleAssignmentV3:
    type: opentelekomcloud:IdentityRoleAssignmentV3
    properties:
      groupId: ${thisIdentityGroupV3.identityGroupV3Id}
      domainId: ${var.domain_id}
      roleId: ${thisKmsIdentityRoleV3.identityRoleV3Id}
      allProjects: true
  thisObsIdentityRoleAssignmentV3:
    type: opentelekomcloud:IdentityRoleAssignmentV3
    properties:
      groupId: ${thisIdentityGroupV3.identityGroupV3Id}
      domainId: ${var.domain_id}
      roleId: ${thisObsIdentityRoleV3.identityRoleV3Id}
      allProjects: true
  thisKmsKeyV1:
    type: opentelekomcloud:KmsKeyV1
    properties:
      keyAlias: ${var.kms_alias}
      pendingDays: '7'
      keyDescription: ${var.kms_desc}
      realm: ${var.region}
      isEnabled: true
  thisObsBucket:
    type: opentelekomcloud:ObsBucket
    properties:
      bucket: ${var.bucket_name}
      acl: private
      serverSideEncryption:
        algorithm: kms
        kmsKeyId: ${thisKmsKeyV1.kmsKeyV1Id}
Copy

Using object lifecycle

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

const bucket = new opentelekomcloud.ObsBucket("bucket", {
    acl: "private",
    bucket: "my-bucket",
    lifecycleRules: [
        {
            enabled: true,
            expirations: [{
                days: 365,
            }],
            name: "log",
            prefix: "log/",
            transitions: [
                {
                    days: 60,
                    storageClass: "WARM",
                },
                {
                    days: 180,
                    storageClass: "COLD",
                },
            ],
        },
        {
            enabled: true,
            name: "tmp",
            noncurrentVersionExpirations: [{
                days: 180,
            }],
            noncurrentVersionTransitions: [
                {
                    days: 30,
                    storageClass: "WARM",
                },
                {
                    days: 60,
                    storageClass: "COLD",
                },
            ],
            prefix: "tmp/",
        },
    ],
    versioning: true,
});
Copy
import pulumi
import pulumi_opentelekomcloud as opentelekomcloud

bucket = opentelekomcloud.ObsBucket("bucket",
    acl="private",
    bucket="my-bucket",
    lifecycle_rules=[
        {
            "enabled": True,
            "expirations": [{
                "days": 365,
            }],
            "name": "log",
            "prefix": "log/",
            "transitions": [
                {
                    "days": 60,
                    "storage_class": "WARM",
                },
                {
                    "days": 180,
                    "storage_class": "COLD",
                },
            ],
        },
        {
            "enabled": True,
            "name": "tmp",
            "noncurrent_version_expirations": [{
                "days": 180,
            }],
            "noncurrent_version_transitions": [
                {
                    "days": 30,
                    "storage_class": "WARM",
                },
                {
                    "days": 60,
                    "storage_class": "COLD",
                },
            ],
            "prefix": "tmp/",
        },
    ],
    versioning=True)
Copy
package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opentelekomcloud/opentelekomcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opentelekomcloud.NewObsBucket(ctx, "bucket", &opentelekomcloud.ObsBucketArgs{
			Acl:    pulumi.String("private"),
			Bucket: pulumi.String("my-bucket"),
			LifecycleRules: opentelekomcloud.ObsBucketLifecycleRuleArray{
				&opentelekomcloud.ObsBucketLifecycleRuleArgs{
					Enabled: pulumi.Bool(true),
					Expirations: opentelekomcloud.ObsBucketLifecycleRuleExpirationArray{
						&opentelekomcloud.ObsBucketLifecycleRuleExpirationArgs{
							Days: pulumi.Float64(365),
						},
					},
					Name:   pulumi.String("log"),
					Prefix: pulumi.String("log/"),
					Transitions: opentelekomcloud.ObsBucketLifecycleRuleTransitionArray{
						&opentelekomcloud.ObsBucketLifecycleRuleTransitionArgs{
							Days:         pulumi.Float64(60),
							StorageClass: pulumi.String("WARM"),
						},
						&opentelekomcloud.ObsBucketLifecycleRuleTransitionArgs{
							Days:         pulumi.Float64(180),
							StorageClass: pulumi.String("COLD"),
						},
					},
				},
				&opentelekomcloud.ObsBucketLifecycleRuleArgs{
					Enabled: pulumi.Bool(true),
					Name:    pulumi.String("tmp"),
					NoncurrentVersionExpirations: opentelekomcloud.ObsBucketLifecycleRuleNoncurrentVersionExpirationArray{
						&opentelekomcloud.ObsBucketLifecycleRuleNoncurrentVersionExpirationArgs{
							Days: pulumi.Float64(180),
						},
					},
					NoncurrentVersionTransitions: opentelekomcloud.ObsBucketLifecycleRuleNoncurrentVersionTransitionArray{
						&opentelekomcloud.ObsBucketLifecycleRuleNoncurrentVersionTransitionArgs{
							Days:         pulumi.Float64(30),
							StorageClass: pulumi.String("WARM"),
						},
						&opentelekomcloud.ObsBucketLifecycleRuleNoncurrentVersionTransitionArgs{
							Days:         pulumi.Float64(60),
							StorageClass: pulumi.String("COLD"),
						},
					},
					Prefix: pulumi.String("tmp/"),
				},
			},
			Versioning: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Opentelekomcloud = Pulumi.Opentelekomcloud;

return await Deployment.RunAsync(() => 
{
    var bucket = new Opentelekomcloud.ObsBucket("bucket", new()
    {
        Acl = "private",
        Bucket = "my-bucket",
        LifecycleRules = new[]
        {
            new Opentelekomcloud.Inputs.ObsBucketLifecycleRuleArgs
            {
                Enabled = true,
                Expirations = new[]
                {
                    new Opentelekomcloud.Inputs.ObsBucketLifecycleRuleExpirationArgs
                    {
                        Days = 365,
                    },
                },
                Name = "log",
                Prefix = "log/",
                Transitions = new[]
                {
                    new Opentelekomcloud.Inputs.ObsBucketLifecycleRuleTransitionArgs
                    {
                        Days = 60,
                        StorageClass = "WARM",
                    },
                    new Opentelekomcloud.Inputs.ObsBucketLifecycleRuleTransitionArgs
                    {
                        Days = 180,
                        StorageClass = "COLD",
                    },
                },
            },
            new Opentelekomcloud.Inputs.ObsBucketLifecycleRuleArgs
            {
                Enabled = true,
                Name = "tmp",
                NoncurrentVersionExpirations = new[]
                {
                    new Opentelekomcloud.Inputs.ObsBucketLifecycleRuleNoncurrentVersionExpirationArgs
                    {
                        Days = 180,
                    },
                },
                NoncurrentVersionTransitions = new[]
                {
                    new Opentelekomcloud.Inputs.ObsBucketLifecycleRuleNoncurrentVersionTransitionArgs
                    {
                        Days = 30,
                        StorageClass = "WARM",
                    },
                    new Opentelekomcloud.Inputs.ObsBucketLifecycleRuleNoncurrentVersionTransitionArgs
                    {
                        Days = 60,
                        StorageClass = "COLD",
                    },
                },
                Prefix = "tmp/",
            },
        },
        Versioning = true,
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opentelekomcloud.ObsBucket;
import com.pulumi.opentelekomcloud.ObsBucketArgs;
import com.pulumi.opentelekomcloud.inputs.ObsBucketLifecycleRuleArgs;
import java.util.List;
import java.util.ArrayList;
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 bucket = new ObsBucket("bucket", ObsBucketArgs.builder()
            .acl("private")
            .bucket("my-bucket")
            .lifecycleRules(            
                ObsBucketLifecycleRuleArgs.builder()
                    .enabled(true)
                    .expirations(ObsBucketLifecycleRuleExpirationArgs.builder()
                        .days(365)
                        .build())
                    .name("log")
                    .prefix("log/")
                    .transitions(                    
                        ObsBucketLifecycleRuleTransitionArgs.builder()
                            .days(60)
                            .storageClass("WARM")
                            .build(),
                        ObsBucketLifecycleRuleTransitionArgs.builder()
                            .days(180)
                            .storageClass("COLD")
                            .build())
                    .build(),
                ObsBucketLifecycleRuleArgs.builder()
                    .enabled(true)
                    .name("tmp")
                    .noncurrentVersionExpirations(ObsBucketLifecycleRuleNoncurrentVersionExpirationArgs.builder()
                        .days(180)
                        .build())
                    .noncurrentVersionTransitions(                    
                        ObsBucketLifecycleRuleNoncurrentVersionTransitionArgs.builder()
                            .days(30)
                            .storageClass("WARM")
                            .build(),
                        ObsBucketLifecycleRuleNoncurrentVersionTransitionArgs.builder()
                            .days(60)
                            .storageClass("COLD")
                            .build())
                    .prefix("tmp/")
                    .build())
            .versioning(true)
            .build());

    }
}
Copy
resources:
  bucket:
    type: opentelekomcloud:ObsBucket
    properties:
      acl: private
      bucket: my-bucket
      lifecycleRules:
        - enabled: true
          expirations:
            - days: 365
          name: log
          prefix: log/
          transitions:
            - days: 60
              storageClass: WARM
            - days: 180
              storageClass: COLD
        - enabled: true
          name: tmp
          noncurrentVersionExpirations:
            - days: 180
          noncurrentVersionTransitions:
            - days: 30
              storageClass: WARM
            - days: 60
              storageClass: COLD
          prefix: tmp/
      versioning: true
Copy

Using event notifications

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

const topic = new opentelekomcloud.SmnTopicV2("topic", {displayName: "The display name of topic_1"});
const policy = new opentelekomcloud.SmnTopicAttributeV2("policy", {
    topicUrn: topic.smnTopicV2Id,
    attributeName: "access_policy",
    topicAttribute: pulumi.interpolate`{
  "Version": "2016-09-07",
  "Id": "__default_policy_ID",
  "Statement": [
    {
      "Sid": "__service_pub_0",
      "Effect": "Allow",
      "Principal": {
        "Service": [
          "obs",
          "s3"
        ]
      },
      "Action": [
        "SMN:Publish",
        "SMN:QueryTopicDetail"
      ],
      "Resource": "${topic.smnTopicV2Id}"
    }
  ]
}
`,
});
const bucket = new opentelekomcloud.ObsBucket("bucket", {
    bucket: "tf-test-bucket-%[1]d",
    acl: "private",
    eventNotifications: [{
        topic: topic.smnTopicV2Id,
        events: [
            "ObjectCreated:*",
            "ObjectRemoved:*",
        ],
        filterRules: [
            {
                name: "prefix",
                value: "smn",
            },
            {
                name: "suffix",
                value: ".jpg",
            },
        ],
    }],
}, {
    dependsOn: [policy],
});
Copy
import pulumi
import pulumi_opentelekomcloud as opentelekomcloud

topic = opentelekomcloud.SmnTopicV2("topic", display_name="The display name of topic_1")
policy = opentelekomcloud.SmnTopicAttributeV2("policy",
    topic_urn=topic.smn_topic_v2_id,
    attribute_name="access_policy",
    topic_attribute=topic.smn_topic_v2_id.apply(lambda smn_topic_v2_id: f"""{{
  "Version": "2016-09-07",
  "Id": "__default_policy_ID",
  "Statement": [
    {{
      "Sid": "__service_pub_0",
      "Effect": "Allow",
      "Principal": {{
        "Service": [
          "obs",
          "s3"
        ]
      }},
      "Action": [
        "SMN:Publish",
        "SMN:QueryTopicDetail"
      ],
      "Resource": "{smn_topic_v2_id}"
    }}
  ]
}}
"""))
bucket = opentelekomcloud.ObsBucket("bucket",
    bucket="tf-test-bucket-%[1]d",
    acl="private",
    event_notifications=[{
        "topic": topic.smn_topic_v2_id,
        "events": [
            "ObjectCreated:*",
            "ObjectRemoved:*",
        ],
        "filter_rules": [
            {
                "name": "prefix",
                "value": "smn",
            },
            {
                "name": "suffix",
                "value": ".jpg",
            },
        ],
    }],
    opts = pulumi.ResourceOptions(depends_on=[policy]))
Copy
package main

import (
	"fmt"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opentelekomcloud/opentelekomcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		topic, err := opentelekomcloud.NewSmnTopicV2(ctx, "topic", &opentelekomcloud.SmnTopicV2Args{
			DisplayName: pulumi.String("The display name of topic_1"),
		})
		if err != nil {
			return err
		}
		policy, err := opentelekomcloud.NewSmnTopicAttributeV2(ctx, "policy", &opentelekomcloud.SmnTopicAttributeV2Args{
			TopicUrn:      topic.SmnTopicV2Id,
			AttributeName: pulumi.String("access_policy"),
			TopicAttribute: topic.SmnTopicV2Id.ApplyT(func(smnTopicV2Id string) (string, error) {
				return fmt.Sprintf(`{
  "Version": "2016-09-07",
  "Id": "__default_policy_ID",
  "Statement": [
    {
      "Sid": "__service_pub_0",
      "Effect": "Allow",
      "Principal": {
        "Service": [
          "obs",
          "s3"
        ]
      },
      "Action": [
        "SMN:Publish",
        "SMN:QueryTopicDetail"
      ],
      "Resource": "%v"
    }
  ]
}
`, smnTopicV2Id), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		_, err = opentelekomcloud.NewObsBucket(ctx, "bucket", &opentelekomcloud.ObsBucketArgs{
			Bucket: pulumi.String("tf-test-bucket-%[1]d"),
			Acl:    pulumi.String("private"),
			EventNotifications: opentelekomcloud.ObsBucketEventNotificationArray{
				&opentelekomcloud.ObsBucketEventNotificationArgs{
					Topic: topic.SmnTopicV2Id,
					Events: pulumi.StringArray{
						pulumi.String("ObjectCreated:*"),
						pulumi.String("ObjectRemoved:*"),
					},
					FilterRules: opentelekomcloud.ObsBucketEventNotificationFilterRuleArray{
						&opentelekomcloud.ObsBucketEventNotificationFilterRuleArgs{
							Name:  pulumi.String("prefix"),
							Value: pulumi.String("smn"),
						},
						&opentelekomcloud.ObsBucketEventNotificationFilterRuleArgs{
							Name:  pulumi.String("suffix"),
							Value: pulumi.String(".jpg"),
						},
					},
				},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			policy,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Opentelekomcloud = Pulumi.Opentelekomcloud;

return await Deployment.RunAsync(() => 
{
    var topic = new Opentelekomcloud.SmnTopicV2("topic", new()
    {
        DisplayName = "The display name of topic_1",
    });

    var policy = new Opentelekomcloud.SmnTopicAttributeV2("policy", new()
    {
        TopicUrn = topic.SmnTopicV2Id,
        AttributeName = "access_policy",
        TopicAttribute = topic.SmnTopicV2Id.Apply(smnTopicV2Id => @$"{{
  ""Version"": ""2016-09-07"",
  ""Id"": ""__default_policy_ID"",
  ""Statement"": [
    {{
      ""Sid"": ""__service_pub_0"",
      ""Effect"": ""Allow"",
      ""Principal"": {{
        ""Service"": [
          ""obs"",
          ""s3""
        ]
      }},
      ""Action"": [
        ""SMN:Publish"",
        ""SMN:QueryTopicDetail""
      ],
      ""Resource"": ""{smnTopicV2Id}""
    }}
  ]
}}
"),
    });

    var bucket = new Opentelekomcloud.ObsBucket("bucket", new()
    {
        Bucket = "tf-test-bucket-%[1]d",
        Acl = "private",
        EventNotifications = new[]
        {
            new Opentelekomcloud.Inputs.ObsBucketEventNotificationArgs
            {
                Topic = topic.SmnTopicV2Id,
                Events = new[]
                {
                    "ObjectCreated:*",
                    "ObjectRemoved:*",
                },
                FilterRules = new[]
                {
                    new Opentelekomcloud.Inputs.ObsBucketEventNotificationFilterRuleArgs
                    {
                        Name = "prefix",
                        Value = "smn",
                    },
                    new Opentelekomcloud.Inputs.ObsBucketEventNotificationFilterRuleArgs
                    {
                        Name = "suffix",
                        Value = ".jpg",
                    },
                },
            },
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            policy,
        },
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opentelekomcloud.SmnTopicV2;
import com.pulumi.opentelekomcloud.SmnTopicV2Args;
import com.pulumi.opentelekomcloud.SmnTopicAttributeV2;
import com.pulumi.opentelekomcloud.SmnTopicAttributeV2Args;
import com.pulumi.opentelekomcloud.ObsBucket;
import com.pulumi.opentelekomcloud.ObsBucketArgs;
import com.pulumi.opentelekomcloud.inputs.ObsBucketEventNotificationArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
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 topic = new SmnTopicV2("topic", SmnTopicV2Args.builder()
            .displayName("The display name of topic_1")
            .build());

        var policy = new SmnTopicAttributeV2("policy", SmnTopicAttributeV2Args.builder()
            .topicUrn(topic.smnTopicV2Id())
            .attributeName("access_policy")
            .topicAttribute(topic.smnTopicV2Id().applyValue(smnTopicV2Id -> """
{
  "Version": "2016-09-07",
  "Id": "__default_policy_ID",
  "Statement": [
    {
      "Sid": "__service_pub_0",
      "Effect": "Allow",
      "Principal": {
        "Service": [
          "obs",
          "s3"
        ]
      },
      "Action": [
        "SMN:Publish",
        "SMN:QueryTopicDetail"
      ],
      "Resource": "%s"
    }
  ]
}
", smnTopicV2Id)))
            .build());

        var bucket = new ObsBucket("bucket", ObsBucketArgs.builder()
            .bucket("tf-test-bucket-%[1]d")
            .acl("private")
            .eventNotifications(ObsBucketEventNotificationArgs.builder()
                .topic(topic.smnTopicV2Id())
                .events(                
                    "ObjectCreated:*",
                    "ObjectRemoved:*")
                .filterRules(                
                    ObsBucketEventNotificationFilterRuleArgs.builder()
                        .name("prefix")
                        .value("smn")
                        .build(),
                    ObsBucketEventNotificationFilterRuleArgs.builder()
                        .name("suffix")
                        .value(".jpg")
                        .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(policy)
                .build());

    }
}
Copy
resources:
  topic:
    type: opentelekomcloud:SmnTopicV2
    properties:
      displayName: The display name of topic_1
  policy:
    type: opentelekomcloud:SmnTopicAttributeV2
    properties:
      topicUrn: ${topic.smnTopicV2Id}
      attributeName: access_policy
      topicAttribute: |
        {
          "Version": "2016-09-07",
          "Id": "__default_policy_ID",
          "Statement": [
            {
              "Sid": "__service_pub_0",
              "Effect": "Allow",
              "Principal": {
                "Service": [
                  "obs",
                  "s3"
                ]
              },
              "Action": [
                "SMN:Publish",
                "SMN:QueryTopicDetail"
              ],
              "Resource": "${topic.smnTopicV2Id}"
            }
          ]
        }        
  bucket:
    type: opentelekomcloud:ObsBucket
    properties:
      bucket: tf-test-bucket-%[1]d
      acl: private
      eventNotifications:
        - topic: ${topic.smnTopicV2Id}
          events:
            - ObjectCreated:*
            - ObjectRemoved:*
          filterRules:
            - name: prefix
              value: smn
            - name: suffix
              value: .jpg
    options:
      dependsOn:
        - ${policy}
Copy

Bucket with set user domain names

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

const obsBucket = new opentelekomcloud.ObsBucket("obsBucket", {
    bucket: "my-tf-test-bucket",
    userDomainNames: [
        _var.domain_1,
        _var.domain_2,
        _var.domain_3,
    ],
});
Copy
import pulumi
import pulumi_opentelekomcloud as opentelekomcloud

obs_bucket = opentelekomcloud.ObsBucket("obsBucket",
    bucket="my-tf-test-bucket",
    user_domain_names=[
        var["domain_1"],
        var["domain_2"],
        var["domain_3"],
    ])
Copy
package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/opentelekomcloud/opentelekomcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := opentelekomcloud.NewObsBucket(ctx, "obsBucket", &opentelekomcloud.ObsBucketArgs{
			Bucket: pulumi.String("my-tf-test-bucket"),
			UserDomainNames: pulumi.StringArray{
				_var.Domain_1,
				_var.Domain_2,
				_var.Domain_3,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Copy
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Opentelekomcloud = Pulumi.Opentelekomcloud;

return await Deployment.RunAsync(() => 
{
    var obsBucket = new Opentelekomcloud.ObsBucket("obsBucket", new()
    {
        Bucket = "my-tf-test-bucket",
        UserDomainNames = new[]
        {
            @var.Domain_1,
            @var.Domain_2,
            @var.Domain_3,
        },
    });

});
Copy
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.opentelekomcloud.ObsBucket;
import com.pulumi.opentelekomcloud.ObsBucketArgs;
import java.util.List;
import java.util.ArrayList;
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 obsBucket = new ObsBucket("obsBucket", ObsBucketArgs.builder()
            .bucket("my-tf-test-bucket")
            .userDomainNames(            
                var_.domain_1(),
                var_.domain_2(),
                var_.domain_3())
            .build());

    }
}
Copy
resources:
  obsBucket:
    type: opentelekomcloud:ObsBucket
    properties:
      bucket: my-tf-test-bucket
      userDomainNames:
        - ${var.domain_1}
        - ${var.domain_2}
        - ${var.domain_3}
Copy

Create ObsBucket Resource

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

Constructor syntax

new ObsBucket(name: string, args: ObsBucketArgs, opts?: CustomResourceOptions);
@overload
def ObsBucket(resource_name: str,
              args: ObsBucketArgs,
              opts: Optional[ResourceOptions] = None)

@overload
def ObsBucket(resource_name: str,
              opts: Optional[ResourceOptions] = None,
              bucket: Optional[str] = None,
              parallel_fs: Optional[bool] = None,
              server_side_encryption: Optional[ObsBucketServerSideEncryptionArgs] = None,
              event_notifications: Optional[Sequence[ObsBucketEventNotificationArgs]] = None,
              force_destroy: Optional[bool] = None,
              lifecycle_rules: Optional[Sequence[ObsBucketLifecycleRuleArgs]] = None,
              loggings: Optional[Sequence[ObsBucketLoggingArgs]] = None,
              cors_rules: Optional[Sequence[ObsBucketCorsRuleArgs]] = None,
              obs_bucket_id: Optional[str] = None,
              region: Optional[str] = None,
              acl: Optional[str] = None,
              storage_class: Optional[str] = None,
              tags: Optional[Mapping[str, str]] = None,
              user_domain_names: Optional[Sequence[str]] = None,
              versioning: Optional[bool] = None,
              website: Optional[ObsBucketWebsiteArgs] = None,
              worm_policy: Optional[ObsBucketWormPolicyArgs] = None)
func NewObsBucket(ctx *Context, name string, args ObsBucketArgs, opts ...ResourceOption) (*ObsBucket, error)
public ObsBucket(string name, ObsBucketArgs args, CustomResourceOptions? opts = null)
public ObsBucket(String name, ObsBucketArgs args)
public ObsBucket(String name, ObsBucketArgs args, CustomResourceOptions options)
type: opentelekomcloud:ObsBucket
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

Parameters

name This property is required. string
The unique name of the resource.
args This property is required. ObsBucketArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
resource_name This property is required. str
The unique name of the resource.
args This property is required. ObsBucketArgs
The arguments to resource properties.
opts ResourceOptions
Bag of options to control resource's behavior.
ctx Context
Context object for the current deployment.
name This property is required. string
The unique name of the resource.
args This property is required. ObsBucketArgs
The arguments to resource properties.
opts ResourceOption
Bag of options to control resource's behavior.
name This property is required. string
The unique name of the resource.
args This property is required. ObsBucketArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
name This property is required. String
The unique name of the resource.
args This property is required. ObsBucketArgs
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 obsBucketResource = new Opentelekomcloud.ObsBucket("obsBucketResource", new()
{
    Bucket = "string",
    ParallelFs = false,
    ServerSideEncryption = new Opentelekomcloud.Inputs.ObsBucketServerSideEncryptionArgs
    {
        Algorithm = "string",
        KmsKeyId = "string",
    },
    EventNotifications = new[]
    {
        new Opentelekomcloud.Inputs.ObsBucketEventNotificationArgs
        {
            Events = new[]
            {
                "string",
            },
            Topic = "string",
            FilterRules = new[]
            {
                new Opentelekomcloud.Inputs.ObsBucketEventNotificationFilterRuleArgs
                {
                    Name = "string",
                    Value = "string",
                },
            },
            Id = "string",
        },
    },
    ForceDestroy = false,
    LifecycleRules = new[]
    {
        new Opentelekomcloud.Inputs.ObsBucketLifecycleRuleArgs
        {
            Enabled = false,
            Name = "string",
            Expirations = new[]
            {
                new Opentelekomcloud.Inputs.ObsBucketLifecycleRuleExpirationArgs
                {
                    Days = 0,
                },
            },
            NoncurrentVersionExpirations = new[]
            {
                new Opentelekomcloud.Inputs.ObsBucketLifecycleRuleNoncurrentVersionExpirationArgs
                {
                    Days = 0,
                },
            },
            NoncurrentVersionTransitions = new[]
            {
                new Opentelekomcloud.Inputs.ObsBucketLifecycleRuleNoncurrentVersionTransitionArgs
                {
                    Days = 0,
                    StorageClass = "string",
                },
            },
            Prefix = "string",
            Transitions = new[]
            {
                new Opentelekomcloud.Inputs.ObsBucketLifecycleRuleTransitionArgs
                {
                    Days = 0,
                    StorageClass = "string",
                },
            },
        },
    },
    Loggings = new[]
    {
        new Opentelekomcloud.Inputs.ObsBucketLoggingArgs
        {
            TargetBucket = "string",
            Agency = "string",
            TargetPrefix = "string",
        },
    },
    CorsRules = new[]
    {
        new Opentelekomcloud.Inputs.ObsBucketCorsRuleArgs
        {
            AllowedMethods = new[]
            {
                "string",
            },
            AllowedOrigins = new[]
            {
                "string",
            },
            AllowedHeaders = new[]
            {
                "string",
            },
            ExposeHeaders = new[]
            {
                "string",
            },
            MaxAgeSeconds = 0,
        },
    },
    ObsBucketId = "string",
    Region = "string",
    Acl = "string",
    StorageClass = "string",
    Tags = 
    {
        { "string", "string" },
    },
    UserDomainNames = new[]
    {
        "string",
    },
    Versioning = false,
    Website = new Opentelekomcloud.Inputs.ObsBucketWebsiteArgs
    {
        ErrorDocument = "string",
        IndexDocument = "string",
        RedirectAllRequestsTo = "string",
        RoutingRules = "string",
    },
    WormPolicy = new Opentelekomcloud.Inputs.ObsBucketWormPolicyArgs
    {
        Days = 0,
        Years = 0,
    },
});
Copy
example, err := opentelekomcloud.NewObsBucket(ctx, "obsBucketResource", &opentelekomcloud.ObsBucketArgs{
Bucket: pulumi.String("string"),
ParallelFs: pulumi.Bool(false),
ServerSideEncryption: &.ObsBucketServerSideEncryptionArgs{
Algorithm: pulumi.String("string"),
KmsKeyId: pulumi.String("string"),
},
EventNotifications: .ObsBucketEventNotificationArray{
&.ObsBucketEventNotificationArgs{
Events: pulumi.StringArray{
pulumi.String("string"),
},
Topic: pulumi.String("string"),
FilterRules: .ObsBucketEventNotificationFilterRuleArray{
&.ObsBucketEventNotificationFilterRuleArgs{
Name: pulumi.String("string"),
Value: pulumi.String("string"),
},
},
Id: pulumi.String("string"),
},
},
ForceDestroy: pulumi.Bool(false),
LifecycleRules: .ObsBucketLifecycleRuleArray{
&.ObsBucketLifecycleRuleArgs{
Enabled: pulumi.Bool(false),
Name: pulumi.String("string"),
Expirations: .ObsBucketLifecycleRuleExpirationArray{
&.ObsBucketLifecycleRuleExpirationArgs{
Days: pulumi.Float64(0),
},
},
NoncurrentVersionExpirations: .ObsBucketLifecycleRuleNoncurrentVersionExpirationArray{
&.ObsBucketLifecycleRuleNoncurrentVersionExpirationArgs{
Days: pulumi.Float64(0),
},
},
NoncurrentVersionTransitions: .ObsBucketLifecycleRuleNoncurrentVersionTransitionArray{
&.ObsBucketLifecycleRuleNoncurrentVersionTransitionArgs{
Days: pulumi.Float64(0),
StorageClass: pulumi.String("string"),
},
},
Prefix: pulumi.String("string"),
Transitions: .ObsBucketLifecycleRuleTransitionArray{
&.ObsBucketLifecycleRuleTransitionArgs{
Days: pulumi.Float64(0),
StorageClass: pulumi.String("string"),
},
},
},
},
Loggings: .ObsBucketLoggingArray{
&.ObsBucketLoggingArgs{
TargetBucket: pulumi.String("string"),
Agency: pulumi.String("string"),
TargetPrefix: pulumi.String("string"),
},
},
CorsRules: .ObsBucketCorsRuleArray{
&.ObsBucketCorsRuleArgs{
AllowedMethods: pulumi.StringArray{
pulumi.String("string"),
},
AllowedOrigins: pulumi.StringArray{
pulumi.String("string"),
},
AllowedHeaders: pulumi.StringArray{
pulumi.String("string"),
},
ExposeHeaders: pulumi.StringArray{
pulumi.String("string"),
},
MaxAgeSeconds: pulumi.Float64(0),
},
},
ObsBucketId: pulumi.String("string"),
Region: pulumi.String("string"),
Acl: pulumi.String("string"),
StorageClass: pulumi.String("string"),
Tags: pulumi.StringMap{
"string": pulumi.String("string"),
},
UserDomainNames: pulumi.StringArray{
pulumi.String("string"),
},
Versioning: pulumi.Bool(false),
Website: &.ObsBucketWebsiteArgs{
ErrorDocument: pulumi.String("string"),
IndexDocument: pulumi.String("string"),
RedirectAllRequestsTo: pulumi.String("string"),
RoutingRules: pulumi.String("string"),
},
WormPolicy: &.ObsBucketWormPolicyArgs{
Days: pulumi.Float64(0),
Years: pulumi.Float64(0),
},
})
Copy
var obsBucketResource = new ObsBucket("obsBucketResource", ObsBucketArgs.builder()
    .bucket("string")
    .parallelFs(false)
    .serverSideEncryption(ObsBucketServerSideEncryptionArgs.builder()
        .algorithm("string")
        .kmsKeyId("string")
        .build())
    .eventNotifications(ObsBucketEventNotificationArgs.builder()
        .events("string")
        .topic("string")
        .filterRules(ObsBucketEventNotificationFilterRuleArgs.builder()
            .name("string")
            .value("string")
            .build())
        .id("string")
        .build())
    .forceDestroy(false)
    .lifecycleRules(ObsBucketLifecycleRuleArgs.builder()
        .enabled(false)
        .name("string")
        .expirations(ObsBucketLifecycleRuleExpirationArgs.builder()
            .days(0)
            .build())
        .noncurrentVersionExpirations(ObsBucketLifecycleRuleNoncurrentVersionExpirationArgs.builder()
            .days(0)
            .build())
        .noncurrentVersionTransitions(ObsBucketLifecycleRuleNoncurrentVersionTransitionArgs.builder()
            .days(0)
            .storageClass("string")
            .build())
        .prefix("string")
        .transitions(ObsBucketLifecycleRuleTransitionArgs.builder()
            .days(0)
            .storageClass("string")
            .build())
        .build())
    .loggings(ObsBucketLoggingArgs.builder()
        .targetBucket("string")
        .agency("string")
        .targetPrefix("string")
        .build())
    .corsRules(ObsBucketCorsRuleArgs.builder()
        .allowedMethods("string")
        .allowedOrigins("string")
        .allowedHeaders("string")
        .exposeHeaders("string")
        .maxAgeSeconds(0)
        .build())
    .obsBucketId("string")
    .region("string")
    .acl("string")
    .storageClass("string")
    .tags(Map.of("string", "string"))
    .userDomainNames("string")
    .versioning(false)
    .website(ObsBucketWebsiteArgs.builder()
        .errorDocument("string")
        .indexDocument("string")
        .redirectAllRequestsTo("string")
        .routingRules("string")
        .build())
    .wormPolicy(ObsBucketWormPolicyArgs.builder()
        .days(0)
        .years(0)
        .build())
    .build());
Copy
obs_bucket_resource = opentelekomcloud.ObsBucket("obsBucketResource",
    bucket="string",
    parallel_fs=False,
    server_side_encryption={
        "algorithm": "string",
        "kms_key_id": "string",
    },
    event_notifications=[{
        "events": ["string"],
        "topic": "string",
        "filter_rules": [{
            "name": "string",
            "value": "string",
        }],
        "id": "string",
    }],
    force_destroy=False,
    lifecycle_rules=[{
        "enabled": False,
        "name": "string",
        "expirations": [{
            "days": 0,
        }],
        "noncurrent_version_expirations": [{
            "days": 0,
        }],
        "noncurrent_version_transitions": [{
            "days": 0,
            "storage_class": "string",
        }],
        "prefix": "string",
        "transitions": [{
            "days": 0,
            "storage_class": "string",
        }],
    }],
    loggings=[{
        "target_bucket": "string",
        "agency": "string",
        "target_prefix": "string",
    }],
    cors_rules=[{
        "allowed_methods": ["string"],
        "allowed_origins": ["string"],
        "allowed_headers": ["string"],
        "expose_headers": ["string"],
        "max_age_seconds": 0,
    }],
    obs_bucket_id="string",
    region="string",
    acl="string",
    storage_class="string",
    tags={
        "string": "string",
    },
    user_domain_names=["string"],
    versioning=False,
    website={
        "error_document": "string",
        "index_document": "string",
        "redirect_all_requests_to": "string",
        "routing_rules": "string",
    },
    worm_policy={
        "days": 0,
        "years": 0,
    })
Copy
const obsBucketResource = new opentelekomcloud.ObsBucket("obsBucketResource", {
    bucket: "string",
    parallelFs: false,
    serverSideEncryption: {
        algorithm: "string",
        kmsKeyId: "string",
    },
    eventNotifications: [{
        events: ["string"],
        topic: "string",
        filterRules: [{
            name: "string",
            value: "string",
        }],
        id: "string",
    }],
    forceDestroy: false,
    lifecycleRules: [{
        enabled: false,
        name: "string",
        expirations: [{
            days: 0,
        }],
        noncurrentVersionExpirations: [{
            days: 0,
        }],
        noncurrentVersionTransitions: [{
            days: 0,
            storageClass: "string",
        }],
        prefix: "string",
        transitions: [{
            days: 0,
            storageClass: "string",
        }],
    }],
    loggings: [{
        targetBucket: "string",
        agency: "string",
        targetPrefix: "string",
    }],
    corsRules: [{
        allowedMethods: ["string"],
        allowedOrigins: ["string"],
        allowedHeaders: ["string"],
        exposeHeaders: ["string"],
        maxAgeSeconds: 0,
    }],
    obsBucketId: "string",
    region: "string",
    acl: "string",
    storageClass: "string",
    tags: {
        string: "string",
    },
    userDomainNames: ["string"],
    versioning: false,
    website: {
        errorDocument: "string",
        indexDocument: "string",
        redirectAllRequestsTo: "string",
        routingRules: "string",
    },
    wormPolicy: {
        days: 0,
        years: 0,
    },
});
Copy
type: opentelekomcloud:ObsBucket
properties:
    acl: string
    bucket: string
    corsRules:
        - allowedHeaders:
            - string
          allowedMethods:
            - string
          allowedOrigins:
            - string
          exposeHeaders:
            - string
          maxAgeSeconds: 0
    eventNotifications:
        - events:
            - string
          filterRules:
            - name: string
              value: string
          id: string
          topic: string
    forceDestroy: false
    lifecycleRules:
        - enabled: false
          expirations:
            - days: 0
          name: string
          noncurrentVersionExpirations:
            - days: 0
          noncurrentVersionTransitions:
            - days: 0
              storageClass: string
          prefix: string
          transitions:
            - days: 0
              storageClass: string
    loggings:
        - agency: string
          targetBucket: string
          targetPrefix: string
    obsBucketId: string
    parallelFs: false
    region: string
    serverSideEncryption:
        algorithm: string
        kmsKeyId: string
    storageClass: string
    tags:
        string: string
    userDomainNames:
        - string
    versioning: false
    website:
        errorDocument: string
        indexDocument: string
        redirectAllRequestsTo: string
        routingRules: string
    wormPolicy:
        days: 0
        years: 0
Copy

ObsBucket Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

The ObsBucket resource accepts the following input properties:

Bucket This property is required. string
Specifies the name of the bucket. Changing this parameter will create a new resource. A bucket must be named according to the globally applied DNS naming regulations as follows:

  • The name must be globally unique in OBS.
  • The name must contain 3 to 63 characters. Only lowercase letters, digits, hyphens (-), and periods (.) are allowed.
  • The name cannot start or end with a period (.) or hyphen (-), and cannot contain two consecutive periods (.) or contain a period (.) and a hyphen (-) adjacent to each other.
  • The name cannot be an IP address.
  • If the name contains any periods (.), a security certificate verification message may appear when you access the bucket or its objects by entering a domain name.
Acl string
Specifies the ACL policy for a bucket. The predefined common policies are as follows: private, public-read, public-read-write and log-delivery-write. Defaults to private.
CorsRules List<ObsBucketCorsRule>
A rule of Cross-Origin Resource Sharing (documented below).
EventNotifications List<ObsBucketEventNotification>
A configuration of bucket event notifications (documented below).
ForceDestroy bool
A boolean that indicates all objects should be deleted from the bucket so that the bucket can be destroyed without error. Default to false.
LifecycleRules List<ObsBucketLifecycleRule>
A configuration of object lifecycle management (documented below).
Loggings List<ObsBucketLogging>
A settings of bucket logging (documented below).
ObsBucketId string
The name of the bucket.
ParallelFs bool
Whether enable a bucket as a parallel file system.
Region string
If specified, the region this bucket should reside in. Otherwise, the region used by the provider.
ServerSideEncryption ObsBucketServerSideEncryption
A configuration of server side encryption (documented below).
StorageClass string
Specifies the storage class of the bucket. OBS provides three storage classes: STANDARD, WARM (Infrequent Access) and COLD (Archive). Defaults to STANDARD.
Tags Dictionary<string, string>
A mapping of tags to assign to the bucket. Each tag is represented by one key-value pair.
UserDomainNames List<string>

Specifies the user domain names. The restriction requirements for this field are as follows:

  • Each value must meet the domain name rules.
  • The maximum length of a domain name is 256 characters.
  • A custom domain name can only be used by one bucket.

When creating or updating the OBS bucket user domain names, the original user domain names will be overwritten.

Versioning bool
Set to true to enable versioning. Once you version-enable a bucket, it can never return to an unversioned state. You can, however, suspend versioning on that bucket. If omitted, during bucket creation it will be in Disabled state.
Website ObsBucketWebsite
A website object (documented below).
WormPolicy ObsBucketWormPolicy
A settings of bucket default WORM policy and a retention period (documented below). worm_policy requires versioning to be enabled.
Bucket This property is required. string
Specifies the name of the bucket. Changing this parameter will create a new resource. A bucket must be named according to the globally applied DNS naming regulations as follows:

  • The name must be globally unique in OBS.
  • The name must contain 3 to 63 characters. Only lowercase letters, digits, hyphens (-), and periods (.) are allowed.
  • The name cannot start or end with a period (.) or hyphen (-), and cannot contain two consecutive periods (.) or contain a period (.) and a hyphen (-) adjacent to each other.
  • The name cannot be an IP address.
  • If the name contains any periods (.), a security certificate verification message may appear when you access the bucket or its objects by entering a domain name.
Acl string
Specifies the ACL policy for a bucket. The predefined common policies are as follows: private, public-read, public-read-write and log-delivery-write. Defaults to private.
CorsRules []ObsBucketCorsRuleArgs
A rule of Cross-Origin Resource Sharing (documented below).
EventNotifications []ObsBucketEventNotificationArgs
A configuration of bucket event notifications (documented below).
ForceDestroy bool
A boolean that indicates all objects should be deleted from the bucket so that the bucket can be destroyed without error. Default to false.
LifecycleRules []ObsBucketLifecycleRuleArgs
A configuration of object lifecycle management (documented below).
Loggings []ObsBucketLoggingArgs
A settings of bucket logging (documented below).
ObsBucketId string
The name of the bucket.
ParallelFs bool
Whether enable a bucket as a parallel file system.
Region string
If specified, the region this bucket should reside in. Otherwise, the region used by the provider.
ServerSideEncryption ObsBucketServerSideEncryptionArgs
A configuration of server side encryption (documented below).
StorageClass string
Specifies the storage class of the bucket. OBS provides three storage classes: STANDARD, WARM (Infrequent Access) and COLD (Archive). Defaults to STANDARD.
Tags map[string]string
A mapping of tags to assign to the bucket. Each tag is represented by one key-value pair.
UserDomainNames []string

Specifies the user domain names. The restriction requirements for this field are as follows:

  • Each value must meet the domain name rules.
  • The maximum length of a domain name is 256 characters.
  • A custom domain name can only be used by one bucket.

When creating or updating the OBS bucket user domain names, the original user domain names will be overwritten.

Versioning bool
Set to true to enable versioning. Once you version-enable a bucket, it can never return to an unversioned state. You can, however, suspend versioning on that bucket. If omitted, during bucket creation it will be in Disabled state.
Website ObsBucketWebsiteArgs
A website object (documented below).
WormPolicy ObsBucketWormPolicyArgs
A settings of bucket default WORM policy and a retention period (documented below). worm_policy requires versioning to be enabled.
bucket This property is required. String
Specifies the name of the bucket. Changing this parameter will create a new resource. A bucket must be named according to the globally applied DNS naming regulations as follows:

  • The name must be globally unique in OBS.
  • The name must contain 3 to 63 characters. Only lowercase letters, digits, hyphens (-), and periods (.) are allowed.
  • The name cannot start or end with a period (.) or hyphen (-), and cannot contain two consecutive periods (.) or contain a period (.) and a hyphen (-) adjacent to each other.
  • The name cannot be an IP address.
  • If the name contains any periods (.), a security certificate verification message may appear when you access the bucket or its objects by entering a domain name.
acl String
Specifies the ACL policy for a bucket. The predefined common policies are as follows: private, public-read, public-read-write and log-delivery-write. Defaults to private.
corsRules List<ObsBucketCorsRule>
A rule of Cross-Origin Resource Sharing (documented below).
eventNotifications List<ObsBucketEventNotification>
A configuration of bucket event notifications (documented below).
forceDestroy Boolean
A boolean that indicates all objects should be deleted from the bucket so that the bucket can be destroyed without error. Default to false.
lifecycleRules List<ObsBucketLifecycleRule>
A configuration of object lifecycle management (documented below).
loggings List<ObsBucketLogging>
A settings of bucket logging (documented below).
obsBucketId String
The name of the bucket.
parallelFs Boolean
Whether enable a bucket as a parallel file system.
region String
If specified, the region this bucket should reside in. Otherwise, the region used by the provider.
serverSideEncryption ObsBucketServerSideEncryption
A configuration of server side encryption (documented below).
storageClass String
Specifies the storage class of the bucket. OBS provides three storage classes: STANDARD, WARM (Infrequent Access) and COLD (Archive). Defaults to STANDARD.
tags Map<String,String>
A mapping of tags to assign to the bucket. Each tag is represented by one key-value pair.
userDomainNames List<String>

Specifies the user domain names. The restriction requirements for this field are as follows:

  • Each value must meet the domain name rules.
  • The maximum length of a domain name is 256 characters.
  • A custom domain name can only be used by one bucket.

When creating or updating the OBS bucket user domain names, the original user domain names will be overwritten.

versioning Boolean
Set to true to enable versioning. Once you version-enable a bucket, it can never return to an unversioned state. You can, however, suspend versioning on that bucket. If omitted, during bucket creation it will be in Disabled state.
website ObsBucketWebsite
A website object (documented below).
wormPolicy ObsBucketWormPolicy
A settings of bucket default WORM policy and a retention period (documented below). worm_policy requires versioning to be enabled.
bucket This property is required. string
Specifies the name of the bucket. Changing this parameter will create a new resource. A bucket must be named according to the globally applied DNS naming regulations as follows:

  • The name must be globally unique in OBS.
  • The name must contain 3 to 63 characters. Only lowercase letters, digits, hyphens (-), and periods (.) are allowed.
  • The name cannot start or end with a period (.) or hyphen (-), and cannot contain two consecutive periods (.) or contain a period (.) and a hyphen (-) adjacent to each other.
  • The name cannot be an IP address.
  • If the name contains any periods (.), a security certificate verification message may appear when you access the bucket or its objects by entering a domain name.
acl string
Specifies the ACL policy for a bucket. The predefined common policies are as follows: private, public-read, public-read-write and log-delivery-write. Defaults to private.
corsRules ObsBucketCorsRule[]
A rule of Cross-Origin Resource Sharing (documented below).
eventNotifications ObsBucketEventNotification[]
A configuration of bucket event notifications (documented below).
forceDestroy boolean
A boolean that indicates all objects should be deleted from the bucket so that the bucket can be destroyed without error. Default to false.
lifecycleRules ObsBucketLifecycleRule[]
A configuration of object lifecycle management (documented below).
loggings ObsBucketLogging[]
A settings of bucket logging (documented below).
obsBucketId string
The name of the bucket.
parallelFs boolean
Whether enable a bucket as a parallel file system.
region string
If specified, the region this bucket should reside in. Otherwise, the region used by the provider.
serverSideEncryption ObsBucketServerSideEncryption
A configuration of server side encryption (documented below).
storageClass string
Specifies the storage class of the bucket. OBS provides three storage classes: STANDARD, WARM (Infrequent Access) and COLD (Archive). Defaults to STANDARD.
tags {[key: string]: string}
A mapping of tags to assign to the bucket. Each tag is represented by one key-value pair.
userDomainNames string[]

Specifies the user domain names. The restriction requirements for this field are as follows:

  • Each value must meet the domain name rules.
  • The maximum length of a domain name is 256 characters.
  • A custom domain name can only be used by one bucket.

When creating or updating the OBS bucket user domain names, the original user domain names will be overwritten.

versioning boolean
Set to true to enable versioning. Once you version-enable a bucket, it can never return to an unversioned state. You can, however, suspend versioning on that bucket. If omitted, during bucket creation it will be in Disabled state.
website ObsBucketWebsite
A website object (documented below).
wormPolicy ObsBucketWormPolicy
A settings of bucket default WORM policy and a retention period (documented below). worm_policy requires versioning to be enabled.
bucket This property is required. str
Specifies the name of the bucket. Changing this parameter will create a new resource. A bucket must be named according to the globally applied DNS naming regulations as follows:

  • The name must be globally unique in OBS.
  • The name must contain 3 to 63 characters. Only lowercase letters, digits, hyphens (-), and periods (.) are allowed.
  • The name cannot start or end with a period (.) or hyphen (-), and cannot contain two consecutive periods (.) or contain a period (.) and a hyphen (-) adjacent to each other.
  • The name cannot be an IP address.
  • If the name contains any periods (.), a security certificate verification message may appear when you access the bucket or its objects by entering a domain name.
acl str
Specifies the ACL policy for a bucket. The predefined common policies are as follows: private, public-read, public-read-write and log-delivery-write. Defaults to private.
cors_rules Sequence[ObsBucketCorsRuleArgs]
A rule of Cross-Origin Resource Sharing (documented below).
event_notifications Sequence[ObsBucketEventNotificationArgs]
A configuration of bucket event notifications (documented below).
force_destroy bool
A boolean that indicates all objects should be deleted from the bucket so that the bucket can be destroyed without error. Default to false.
lifecycle_rules Sequence[ObsBucketLifecycleRuleArgs]
A configuration of object lifecycle management (documented below).
loggings Sequence[ObsBucketLoggingArgs]
A settings of bucket logging (documented below).
obs_bucket_id str
The name of the bucket.
parallel_fs bool
Whether enable a bucket as a parallel file system.
region str
If specified, the region this bucket should reside in. Otherwise, the region used by the provider.
server_side_encryption ObsBucketServerSideEncryptionArgs
A configuration of server side encryption (documented below).
storage_class str
Specifies the storage class of the bucket. OBS provides three storage classes: STANDARD, WARM (Infrequent Access) and COLD (Archive). Defaults to STANDARD.
tags Mapping[str, str]
A mapping of tags to assign to the bucket. Each tag is represented by one key-value pair.
user_domain_names Sequence[str]

Specifies the user domain names. The restriction requirements for this field are as follows:

  • Each value must meet the domain name rules.
  • The maximum length of a domain name is 256 characters.
  • A custom domain name can only be used by one bucket.

When creating or updating the OBS bucket user domain names, the original user domain names will be overwritten.

versioning bool
Set to true to enable versioning. Once you version-enable a bucket, it can never return to an unversioned state. You can, however, suspend versioning on that bucket. If omitted, during bucket creation it will be in Disabled state.
website ObsBucketWebsiteArgs
A website object (documented below).
worm_policy ObsBucketWormPolicyArgs
A settings of bucket default WORM policy and a retention period (documented below). worm_policy requires versioning to be enabled.
bucket This property is required. String
Specifies the name of the bucket. Changing this parameter will create a new resource. A bucket must be named according to the globally applied DNS naming regulations as follows:

  • The name must be globally unique in OBS.
  • The name must contain 3 to 63 characters. Only lowercase letters, digits, hyphens (-), and periods (.) are allowed.
  • The name cannot start or end with a period (.) or hyphen (-), and cannot contain two consecutive periods (.) or contain a period (.) and a hyphen (-) adjacent to each other.
  • The name cannot be an IP address.
  • If the name contains any periods (.), a security certificate verification message may appear when you access the bucket or its objects by entering a domain name.
acl String
Specifies the ACL policy for a bucket. The predefined common policies are as follows: private, public-read, public-read-write and log-delivery-write. Defaults to private.
corsRules List<Property Map>
A rule of Cross-Origin Resource Sharing (documented below).
eventNotifications List<Property Map>
A configuration of bucket event notifications (documented below).
forceDestroy Boolean
A boolean that indicates all objects should be deleted from the bucket so that the bucket can be destroyed without error. Default to false.
lifecycleRules List<Property Map>
A configuration of object lifecycle management (documented below).
loggings List<Property Map>
A settings of bucket logging (documented below).
obsBucketId String
The name of the bucket.
parallelFs Boolean
Whether enable a bucket as a parallel file system.
region String
If specified, the region this bucket should reside in. Otherwise, the region used by the provider.
serverSideEncryption Property Map
A configuration of server side encryption (documented below).
storageClass String
Specifies the storage class of the bucket. OBS provides three storage classes: STANDARD, WARM (Infrequent Access) and COLD (Archive). Defaults to STANDARD.
tags Map<String>
A mapping of tags to assign to the bucket. Each tag is represented by one key-value pair.
userDomainNames List<String>

Specifies the user domain names. The restriction requirements for this field are as follows:

  • Each value must meet the domain name rules.
  • The maximum length of a domain name is 256 characters.
  • A custom domain name can only be used by one bucket.

When creating or updating the OBS bucket user domain names, the original user domain names will be overwritten.

versioning Boolean
Set to true to enable versioning. Once you version-enable a bucket, it can never return to an unversioned state. You can, however, suspend versioning on that bucket. If omitted, during bucket creation it will be in Disabled state.
website Property Map
A website object (documented below).
wormPolicy Property Map
A settings of bucket default WORM policy and a retention period (documented below). worm_policy requires versioning to be enabled.

Outputs

All input properties are implicitly available as output properties. Additionally, the ObsBucket resource produces the following output properties:

BucketDomainName string
The bucket domain name. Will be of format bucketname.obs.region.otc.t-systems.com.
BucketVersion string
The OBS version of the bucket.
Id string
The provider-assigned unique ID for this managed resource.
BucketDomainName string
The bucket domain name. Will be of format bucketname.obs.region.otc.t-systems.com.
BucketVersion string
The OBS version of the bucket.
Id string
The provider-assigned unique ID for this managed resource.
bucketDomainName String
The bucket domain name. Will be of format bucketname.obs.region.otc.t-systems.com.
bucketVersion String
The OBS version of the bucket.
id String
The provider-assigned unique ID for this managed resource.
bucketDomainName string
The bucket domain name. Will be of format bucketname.obs.region.otc.t-systems.com.
bucketVersion string
The OBS version of the bucket.
id string
The provider-assigned unique ID for this managed resource.
bucket_domain_name str
The bucket domain name. Will be of format bucketname.obs.region.otc.t-systems.com.
bucket_version str
The OBS version of the bucket.
id str
The provider-assigned unique ID for this managed resource.
bucketDomainName String
The bucket domain name. Will be of format bucketname.obs.region.otc.t-systems.com.
bucketVersion String
The OBS version of the bucket.
id String
The provider-assigned unique ID for this managed resource.

Look up Existing ObsBucket Resource

Get an existing ObsBucket resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: ObsBucketState, opts?: CustomResourceOptions): ObsBucket
@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        acl: Optional[str] = None,
        bucket: Optional[str] = None,
        bucket_domain_name: Optional[str] = None,
        bucket_version: Optional[str] = None,
        cors_rules: Optional[Sequence[ObsBucketCorsRuleArgs]] = None,
        event_notifications: Optional[Sequence[ObsBucketEventNotificationArgs]] = None,
        force_destroy: Optional[bool] = None,
        lifecycle_rules: Optional[Sequence[ObsBucketLifecycleRuleArgs]] = None,
        loggings: Optional[Sequence[ObsBucketLoggingArgs]] = None,
        obs_bucket_id: Optional[str] = None,
        parallel_fs: Optional[bool] = None,
        region: Optional[str] = None,
        server_side_encryption: Optional[ObsBucketServerSideEncryptionArgs] = None,
        storage_class: Optional[str] = None,
        tags: Optional[Mapping[str, str]] = None,
        user_domain_names: Optional[Sequence[str]] = None,
        versioning: Optional[bool] = None,
        website: Optional[ObsBucketWebsiteArgs] = None,
        worm_policy: Optional[ObsBucketWormPolicyArgs] = None) -> ObsBucket
func GetObsBucket(ctx *Context, name string, id IDInput, state *ObsBucketState, opts ...ResourceOption) (*ObsBucket, error)
public static ObsBucket Get(string name, Input<string> id, ObsBucketState? state, CustomResourceOptions? opts = null)
public static ObsBucket get(String name, Output<String> id, ObsBucketState state, CustomResourceOptions options)
resources:  _:    type: opentelekomcloud:ObsBucket    get:      id: ${id}
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
resource_name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
name This property is required.
The unique name of the resulting resource.
id This property is required.
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
The following state arguments are supported:
Acl string
Specifies the ACL policy for a bucket. The predefined common policies are as follows: private, public-read, public-read-write and log-delivery-write. Defaults to private.
Bucket string
Specifies the name of the bucket. Changing this parameter will create a new resource. A bucket must be named according to the globally applied DNS naming regulations as follows:

  • The name must be globally unique in OBS.
  • The name must contain 3 to 63 characters. Only lowercase letters, digits, hyphens (-), and periods (.) are allowed.
  • The name cannot start or end with a period (.) or hyphen (-), and cannot contain two consecutive periods (.) or contain a period (.) and a hyphen (-) adjacent to each other.
  • The name cannot be an IP address.
  • If the name contains any periods (.), a security certificate verification message may appear when you access the bucket or its objects by entering a domain name.
BucketDomainName string
The bucket domain name. Will be of format bucketname.obs.region.otc.t-systems.com.
BucketVersion string
The OBS version of the bucket.
CorsRules List<ObsBucketCorsRule>
A rule of Cross-Origin Resource Sharing (documented below).
EventNotifications List<ObsBucketEventNotification>
A configuration of bucket event notifications (documented below).
ForceDestroy bool
A boolean that indicates all objects should be deleted from the bucket so that the bucket can be destroyed without error. Default to false.
LifecycleRules List<ObsBucketLifecycleRule>
A configuration of object lifecycle management (documented below).
Loggings List<ObsBucketLogging>
A settings of bucket logging (documented below).
ObsBucketId string
The name of the bucket.
ParallelFs bool
Whether enable a bucket as a parallel file system.
Region string
If specified, the region this bucket should reside in. Otherwise, the region used by the provider.
ServerSideEncryption ObsBucketServerSideEncryption
A configuration of server side encryption (documented below).
StorageClass string
Specifies the storage class of the bucket. OBS provides three storage classes: STANDARD, WARM (Infrequent Access) and COLD (Archive). Defaults to STANDARD.
Tags Dictionary<string, string>
A mapping of tags to assign to the bucket. Each tag is represented by one key-value pair.
UserDomainNames List<string>

Specifies the user domain names. The restriction requirements for this field are as follows:

  • Each value must meet the domain name rules.
  • The maximum length of a domain name is 256 characters.
  • A custom domain name can only be used by one bucket.

When creating or updating the OBS bucket user domain names, the original user domain names will be overwritten.

Versioning bool
Set to true to enable versioning. Once you version-enable a bucket, it can never return to an unversioned state. You can, however, suspend versioning on that bucket. If omitted, during bucket creation it will be in Disabled state.
Website ObsBucketWebsite
A website object (documented below).
WormPolicy ObsBucketWormPolicy
A settings of bucket default WORM policy and a retention period (documented below). worm_policy requires versioning to be enabled.
Acl string
Specifies the ACL policy for a bucket. The predefined common policies are as follows: private, public-read, public-read-write and log-delivery-write. Defaults to private.
Bucket string
Specifies the name of the bucket. Changing this parameter will create a new resource. A bucket must be named according to the globally applied DNS naming regulations as follows:

  • The name must be globally unique in OBS.
  • The name must contain 3 to 63 characters. Only lowercase letters, digits, hyphens (-), and periods (.) are allowed.
  • The name cannot start or end with a period (.) or hyphen (-), and cannot contain two consecutive periods (.) or contain a period (.) and a hyphen (-) adjacent to each other.
  • The name cannot be an IP address.
  • If the name contains any periods (.), a security certificate verification message may appear when you access the bucket or its objects by entering a domain name.
BucketDomainName string
The bucket domain name. Will be of format bucketname.obs.region.otc.t-systems.com.
BucketVersion string
The OBS version of the bucket.
CorsRules []ObsBucketCorsRuleArgs
A rule of Cross-Origin Resource Sharing (documented below).
EventNotifications []ObsBucketEventNotificationArgs
A configuration of bucket event notifications (documented below).
ForceDestroy bool
A boolean that indicates all objects should be deleted from the bucket so that the bucket can be destroyed without error. Default to false.
LifecycleRules []ObsBucketLifecycleRuleArgs
A configuration of object lifecycle management (documented below).
Loggings []ObsBucketLoggingArgs
A settings of bucket logging (documented below).
ObsBucketId string
The name of the bucket.
ParallelFs bool
Whether enable a bucket as a parallel file system.
Region string
If specified, the region this bucket should reside in. Otherwise, the region used by the provider.
ServerSideEncryption ObsBucketServerSideEncryptionArgs
A configuration of server side encryption (documented below).
StorageClass string
Specifies the storage class of the bucket. OBS provides three storage classes: STANDARD, WARM (Infrequent Access) and COLD (Archive). Defaults to STANDARD.
Tags map[string]string
A mapping of tags to assign to the bucket. Each tag is represented by one key-value pair.
UserDomainNames []string

Specifies the user domain names. The restriction requirements for this field are as follows:

  • Each value must meet the domain name rules.
  • The maximum length of a domain name is 256 characters.
  • A custom domain name can only be used by one bucket.

When creating or updating the OBS bucket user domain names, the original user domain names will be overwritten.

Versioning bool
Set to true to enable versioning. Once you version-enable a bucket, it can never return to an unversioned state. You can, however, suspend versioning on that bucket. If omitted, during bucket creation it will be in Disabled state.
Website ObsBucketWebsiteArgs
A website object (documented below).
WormPolicy ObsBucketWormPolicyArgs
A settings of bucket default WORM policy and a retention period (documented below). worm_policy requires versioning to be enabled.
acl String
Specifies the ACL policy for a bucket. The predefined common policies are as follows: private, public-read, public-read-write and log-delivery-write. Defaults to private.
bucket String
Specifies the name of the bucket. Changing this parameter will create a new resource. A bucket must be named according to the globally applied DNS naming regulations as follows:

  • The name must be globally unique in OBS.
  • The name must contain 3 to 63 characters. Only lowercase letters, digits, hyphens (-), and periods (.) are allowed.
  • The name cannot start or end with a period (.) or hyphen (-), and cannot contain two consecutive periods (.) or contain a period (.) and a hyphen (-) adjacent to each other.
  • The name cannot be an IP address.
  • If the name contains any periods (.), a security certificate verification message may appear when you access the bucket or its objects by entering a domain name.
bucketDomainName String
The bucket domain name. Will be of format bucketname.obs.region.otc.t-systems.com.
bucketVersion String
The OBS version of the bucket.
corsRules List<ObsBucketCorsRule>
A rule of Cross-Origin Resource Sharing (documented below).
eventNotifications List<ObsBucketEventNotification>
A configuration of bucket event notifications (documented below).
forceDestroy Boolean
A boolean that indicates all objects should be deleted from the bucket so that the bucket can be destroyed without error. Default to false.
lifecycleRules List<ObsBucketLifecycleRule>
A configuration of object lifecycle management (documented below).
loggings List<ObsBucketLogging>
A settings of bucket logging (documented below).
obsBucketId String
The name of the bucket.
parallelFs Boolean
Whether enable a bucket as a parallel file system.
region String
If specified, the region this bucket should reside in. Otherwise, the region used by the provider.
serverSideEncryption ObsBucketServerSideEncryption
A configuration of server side encryption (documented below).
storageClass String
Specifies the storage class of the bucket. OBS provides three storage classes: STANDARD, WARM (Infrequent Access) and COLD (Archive). Defaults to STANDARD.
tags Map<String,String>
A mapping of tags to assign to the bucket. Each tag is represented by one key-value pair.
userDomainNames List<String>

Specifies the user domain names. The restriction requirements for this field are as follows:

  • Each value must meet the domain name rules.
  • The maximum length of a domain name is 256 characters.
  • A custom domain name can only be used by one bucket.

When creating or updating the OBS bucket user domain names, the original user domain names will be overwritten.

versioning Boolean
Set to true to enable versioning. Once you version-enable a bucket, it can never return to an unversioned state. You can, however, suspend versioning on that bucket. If omitted, during bucket creation it will be in Disabled state.
website ObsBucketWebsite
A website object (documented below).
wormPolicy ObsBucketWormPolicy
A settings of bucket default WORM policy and a retention period (documented below). worm_policy requires versioning to be enabled.
acl string
Specifies the ACL policy for a bucket. The predefined common policies are as follows: private, public-read, public-read-write and log-delivery-write. Defaults to private.
bucket string
Specifies the name of the bucket. Changing this parameter will create a new resource. A bucket must be named according to the globally applied DNS naming regulations as follows:

  • The name must be globally unique in OBS.
  • The name must contain 3 to 63 characters. Only lowercase letters, digits, hyphens (-), and periods (.) are allowed.
  • The name cannot start or end with a period (.) or hyphen (-), and cannot contain two consecutive periods (.) or contain a period (.) and a hyphen (-) adjacent to each other.
  • The name cannot be an IP address.
  • If the name contains any periods (.), a security certificate verification message may appear when you access the bucket or its objects by entering a domain name.
bucketDomainName string
The bucket domain name. Will be of format bucketname.obs.region.otc.t-systems.com.
bucketVersion string
The OBS version of the bucket.
corsRules ObsBucketCorsRule[]
A rule of Cross-Origin Resource Sharing (documented below).
eventNotifications ObsBucketEventNotification[]
A configuration of bucket event notifications (documented below).
forceDestroy boolean
A boolean that indicates all objects should be deleted from the bucket so that the bucket can be destroyed without error. Default to false.
lifecycleRules ObsBucketLifecycleRule[]
A configuration of object lifecycle management (documented below).
loggings ObsBucketLogging[]
A settings of bucket logging (documented below).
obsBucketId string
The name of the bucket.
parallelFs boolean
Whether enable a bucket as a parallel file system.
region string
If specified, the region this bucket should reside in. Otherwise, the region used by the provider.
serverSideEncryption ObsBucketServerSideEncryption
A configuration of server side encryption (documented below).
storageClass string
Specifies the storage class of the bucket. OBS provides three storage classes: STANDARD, WARM (Infrequent Access) and COLD (Archive). Defaults to STANDARD.
tags {[key: string]: string}
A mapping of tags to assign to the bucket. Each tag is represented by one key-value pair.
userDomainNames string[]

Specifies the user domain names. The restriction requirements for this field are as follows:

  • Each value must meet the domain name rules.
  • The maximum length of a domain name is 256 characters.
  • A custom domain name can only be used by one bucket.

When creating or updating the OBS bucket user domain names, the original user domain names will be overwritten.

versioning boolean
Set to true to enable versioning. Once you version-enable a bucket, it can never return to an unversioned state. You can, however, suspend versioning on that bucket. If omitted, during bucket creation it will be in Disabled state.
website ObsBucketWebsite
A website object (documented below).
wormPolicy ObsBucketWormPolicy
A settings of bucket default WORM policy and a retention period (documented below). worm_policy requires versioning to be enabled.
acl str
Specifies the ACL policy for a bucket. The predefined common policies are as follows: private, public-read, public-read-write and log-delivery-write. Defaults to private.
bucket str
Specifies the name of the bucket. Changing this parameter will create a new resource. A bucket must be named according to the globally applied DNS naming regulations as follows:

  • The name must be globally unique in OBS.
  • The name must contain 3 to 63 characters. Only lowercase letters, digits, hyphens (-), and periods (.) are allowed.
  • The name cannot start or end with a period (.) or hyphen (-), and cannot contain two consecutive periods (.) or contain a period (.) and a hyphen (-) adjacent to each other.
  • The name cannot be an IP address.
  • If the name contains any periods (.), a security certificate verification message may appear when you access the bucket or its objects by entering a domain name.
bucket_domain_name str
The bucket domain name. Will be of format bucketname.obs.region.otc.t-systems.com.
bucket_version str
The OBS version of the bucket.
cors_rules Sequence[ObsBucketCorsRuleArgs]
A rule of Cross-Origin Resource Sharing (documented below).
event_notifications Sequence[ObsBucketEventNotificationArgs]
A configuration of bucket event notifications (documented below).
force_destroy bool
A boolean that indicates all objects should be deleted from the bucket so that the bucket can be destroyed without error. Default to false.
lifecycle_rules Sequence[ObsBucketLifecycleRuleArgs]
A configuration of object lifecycle management (documented below).
loggings Sequence[ObsBucketLoggingArgs]
A settings of bucket logging (documented below).
obs_bucket_id str
The name of the bucket.
parallel_fs bool
Whether enable a bucket as a parallel file system.
region str
If specified, the region this bucket should reside in. Otherwise, the region used by the provider.
server_side_encryption ObsBucketServerSideEncryptionArgs
A configuration of server side encryption (documented below).
storage_class str
Specifies the storage class of the bucket. OBS provides three storage classes: STANDARD, WARM (Infrequent Access) and COLD (Archive). Defaults to STANDARD.
tags Mapping[str, str]
A mapping of tags to assign to the bucket. Each tag is represented by one key-value pair.
user_domain_names Sequence[str]

Specifies the user domain names. The restriction requirements for this field are as follows:

  • Each value must meet the domain name rules.
  • The maximum length of a domain name is 256 characters.
  • A custom domain name can only be used by one bucket.

When creating or updating the OBS bucket user domain names, the original user domain names will be overwritten.

versioning bool
Set to true to enable versioning. Once you version-enable a bucket, it can never return to an unversioned state. You can, however, suspend versioning on that bucket. If omitted, during bucket creation it will be in Disabled state.
website ObsBucketWebsiteArgs
A website object (documented below).
worm_policy ObsBucketWormPolicyArgs
A settings of bucket default WORM policy and a retention period (documented below). worm_policy requires versioning to be enabled.
acl String
Specifies the ACL policy for a bucket. The predefined common policies are as follows: private, public-read, public-read-write and log-delivery-write. Defaults to private.
bucket String
Specifies the name of the bucket. Changing this parameter will create a new resource. A bucket must be named according to the globally applied DNS naming regulations as follows:

  • The name must be globally unique in OBS.
  • The name must contain 3 to 63 characters. Only lowercase letters, digits, hyphens (-), and periods (.) are allowed.
  • The name cannot start or end with a period (.) or hyphen (-), and cannot contain two consecutive periods (.) or contain a period (.) and a hyphen (-) adjacent to each other.
  • The name cannot be an IP address.
  • If the name contains any periods (.), a security certificate verification message may appear when you access the bucket or its objects by entering a domain name.
bucketDomainName String
The bucket domain name. Will be of format bucketname.obs.region.otc.t-systems.com.
bucketVersion String
The OBS version of the bucket.
corsRules List<Property Map>
A rule of Cross-Origin Resource Sharing (documented below).
eventNotifications List<Property Map>
A configuration of bucket event notifications (documented below).
forceDestroy Boolean
A boolean that indicates all objects should be deleted from the bucket so that the bucket can be destroyed without error. Default to false.
lifecycleRules List<Property Map>
A configuration of object lifecycle management (documented below).
loggings List<Property Map>
A settings of bucket logging (documented below).
obsBucketId String
The name of the bucket.
parallelFs Boolean
Whether enable a bucket as a parallel file system.
region String
If specified, the region this bucket should reside in. Otherwise, the region used by the provider.
serverSideEncryption Property Map
A configuration of server side encryption (documented below).
storageClass String
Specifies the storage class of the bucket. OBS provides three storage classes: STANDARD, WARM (Infrequent Access) and COLD (Archive). Defaults to STANDARD.
tags Map<String>
A mapping of tags to assign to the bucket. Each tag is represented by one key-value pair.
userDomainNames List<String>

Specifies the user domain names. The restriction requirements for this field are as follows:

  • Each value must meet the domain name rules.
  • The maximum length of a domain name is 256 characters.
  • A custom domain name can only be used by one bucket.

When creating or updating the OBS bucket user domain names, the original user domain names will be overwritten.

versioning Boolean
Set to true to enable versioning. Once you version-enable a bucket, it can never return to an unversioned state. You can, however, suspend versioning on that bucket. If omitted, during bucket creation it will be in Disabled state.
website Property Map
A website object (documented below).
wormPolicy Property Map
A settings of bucket default WORM policy and a retention period (documented below). worm_policy requires versioning to be enabled.

Supporting Types

ObsBucketCorsRule
, ObsBucketCorsRuleArgs

AllowedMethods This property is required. List<string>
Specifies the acceptable operation type of buckets and objects. The methods include GET, PUT, POST, DELETE or HEAD.
AllowedOrigins This property is required. List<string>
Requests from this origin can access the bucket. Multiple matching rules are allowed. One rule occupies one line, and allows one wildcard character (*) at most.
AllowedHeaders List<string>
Specifies the allowed header of cross-origin requests. Only CORS requests matching the allowed header are valid.
ExposeHeaders List<string>
Specifies the exposed header in CORS responses, providing additional information for clients.
MaxAgeSeconds double
Specifies the duration that your browser can cache CORS responses, expressed in seconds. The default value is 100.
AllowedMethods This property is required. []string
Specifies the acceptable operation type of buckets and objects. The methods include GET, PUT, POST, DELETE or HEAD.
AllowedOrigins This property is required. []string
Requests from this origin can access the bucket. Multiple matching rules are allowed. One rule occupies one line, and allows one wildcard character (*) at most.
AllowedHeaders []string
Specifies the allowed header of cross-origin requests. Only CORS requests matching the allowed header are valid.
ExposeHeaders []string
Specifies the exposed header in CORS responses, providing additional information for clients.
MaxAgeSeconds float64
Specifies the duration that your browser can cache CORS responses, expressed in seconds. The default value is 100.
allowedMethods This property is required. List<String>
Specifies the acceptable operation type of buckets and objects. The methods include GET, PUT, POST, DELETE or HEAD.
allowedOrigins This property is required. List<String>
Requests from this origin can access the bucket. Multiple matching rules are allowed. One rule occupies one line, and allows one wildcard character (*) at most.
allowedHeaders List<String>
Specifies the allowed header of cross-origin requests. Only CORS requests matching the allowed header are valid.
exposeHeaders List<String>
Specifies the exposed header in CORS responses, providing additional information for clients.
maxAgeSeconds Double
Specifies the duration that your browser can cache CORS responses, expressed in seconds. The default value is 100.
allowedMethods This property is required. string[]
Specifies the acceptable operation type of buckets and objects. The methods include GET, PUT, POST, DELETE or HEAD.
allowedOrigins This property is required. string[]
Requests from this origin can access the bucket. Multiple matching rules are allowed. One rule occupies one line, and allows one wildcard character (*) at most.
allowedHeaders string[]
Specifies the allowed header of cross-origin requests. Only CORS requests matching the allowed header are valid.
exposeHeaders string[]
Specifies the exposed header in CORS responses, providing additional information for clients.
maxAgeSeconds number
Specifies the duration that your browser can cache CORS responses, expressed in seconds. The default value is 100.
allowed_methods This property is required. Sequence[str]
Specifies the acceptable operation type of buckets and objects. The methods include GET, PUT, POST, DELETE or HEAD.
allowed_origins This property is required. Sequence[str]
Requests from this origin can access the bucket. Multiple matching rules are allowed. One rule occupies one line, and allows one wildcard character (*) at most.
allowed_headers Sequence[str]
Specifies the allowed header of cross-origin requests. Only CORS requests matching the allowed header are valid.
expose_headers Sequence[str]
Specifies the exposed header in CORS responses, providing additional information for clients.
max_age_seconds float
Specifies the duration that your browser can cache CORS responses, expressed in seconds. The default value is 100.
allowedMethods This property is required. List<String>
Specifies the acceptable operation type of buckets and objects. The methods include GET, PUT, POST, DELETE or HEAD.
allowedOrigins This property is required. List<String>
Requests from this origin can access the bucket. Multiple matching rules are allowed. One rule occupies one line, and allows one wildcard character (*) at most.
allowedHeaders List<String>
Specifies the allowed header of cross-origin requests. Only CORS requests matching the allowed header are valid.
exposeHeaders List<String>
Specifies the exposed header in CORS responses, providing additional information for clients.
maxAgeSeconds Number
Specifies the duration that your browser can cache CORS responses, expressed in seconds. The default value is 100.

ObsBucketEventNotification
, ObsBucketEventNotificationArgs

Events This property is required. List<string>

Type of events that need to be notified.

Events should not have s3: prefix, e.g. "ObjectCreated:*" is valid value, but "s3:ObjectCreated:*" is not.

Topic This property is required. string

URN of the event notification topic. After detecting a specific event, OBS sends a message to the topic.

Topic should exist and be authorized to be used by OBS.

FilterRules List<ObsBucketEventNotificationFilterRule>
Filtering rules. The rules filter objects based on the prefixes and suffixes of object names.
Id string
Unique ID of the event notification. If the user does not specify an ID, the system assigns an ID automatically.
Events This property is required. []string

Type of events that need to be notified.

Events should not have s3: prefix, e.g. "ObjectCreated:*" is valid value, but "s3:ObjectCreated:*" is not.

Topic This property is required. string

URN of the event notification topic. After detecting a specific event, OBS sends a message to the topic.

Topic should exist and be authorized to be used by OBS.

FilterRules []ObsBucketEventNotificationFilterRule
Filtering rules. The rules filter objects based on the prefixes and suffixes of object names.
Id string
Unique ID of the event notification. If the user does not specify an ID, the system assigns an ID automatically.
events This property is required. List<String>

Type of events that need to be notified.

Events should not have s3: prefix, e.g. "ObjectCreated:*" is valid value, but "s3:ObjectCreated:*" is not.

topic This property is required. String

URN of the event notification topic. After detecting a specific event, OBS sends a message to the topic.

Topic should exist and be authorized to be used by OBS.

filterRules List<ObsBucketEventNotificationFilterRule>
Filtering rules. The rules filter objects based on the prefixes and suffixes of object names.
id String
Unique ID of the event notification. If the user does not specify an ID, the system assigns an ID automatically.
events This property is required. string[]

Type of events that need to be notified.

Events should not have s3: prefix, e.g. "ObjectCreated:*" is valid value, but "s3:ObjectCreated:*" is not.

topic This property is required. string

URN of the event notification topic. After detecting a specific event, OBS sends a message to the topic.

Topic should exist and be authorized to be used by OBS.

filterRules ObsBucketEventNotificationFilterRule[]
Filtering rules. The rules filter objects based on the prefixes and suffixes of object names.
id string
Unique ID of the event notification. If the user does not specify an ID, the system assigns an ID automatically.
events This property is required. Sequence[str]

Type of events that need to be notified.

Events should not have s3: prefix, e.g. "ObjectCreated:*" is valid value, but "s3:ObjectCreated:*" is not.

topic This property is required. str

URN of the event notification topic. After detecting a specific event, OBS sends a message to the topic.

Topic should exist and be authorized to be used by OBS.

filter_rules Sequence[ObsBucketEventNotificationFilterRule]
Filtering rules. The rules filter objects based on the prefixes and suffixes of object names.
id str
Unique ID of the event notification. If the user does not specify an ID, the system assigns an ID automatically.
events This property is required. List<String>

Type of events that need to be notified.

Events should not have s3: prefix, e.g. "ObjectCreated:*" is valid value, but "s3:ObjectCreated:*" is not.

topic This property is required. String

URN of the event notification topic. After detecting a specific event, OBS sends a message to the topic.

Topic should exist and be authorized to be used by OBS.

filterRules List<Property Map>
Filtering rules. The rules filter objects based on the prefixes and suffixes of object names.
id String
Unique ID of the event notification. If the user does not specify an ID, the system assigns an ID automatically.

ObsBucketEventNotificationFilterRule
, ObsBucketEventNotificationFilterRuleArgs

Name string
Specifies the prefix or suffix of object names for filtering. Valid values are prefix and suffix.
Value string
Specifies keywords of object names so that objects can be filtered based on the prefixes or suffixes. The value contains a maximum of 1024 characters.
Name string
Specifies the prefix or suffix of object names for filtering. Valid values are prefix and suffix.
Value string
Specifies keywords of object names so that objects can be filtered based on the prefixes or suffixes. The value contains a maximum of 1024 characters.
name String
Specifies the prefix or suffix of object names for filtering. Valid values are prefix and suffix.
value String
Specifies keywords of object names so that objects can be filtered based on the prefixes or suffixes. The value contains a maximum of 1024 characters.
name string
Specifies the prefix or suffix of object names for filtering. Valid values are prefix and suffix.
value string
Specifies keywords of object names so that objects can be filtered based on the prefixes or suffixes. The value contains a maximum of 1024 characters.
name str
Specifies the prefix or suffix of object names for filtering. Valid values are prefix and suffix.
value str
Specifies keywords of object names so that objects can be filtered based on the prefixes or suffixes. The value contains a maximum of 1024 characters.
name String
Specifies the prefix or suffix of object names for filtering. Valid values are prefix and suffix.
value String
Specifies keywords of object names so that objects can be filtered based on the prefixes or suffixes. The value contains a maximum of 1024 characters.

ObsBucketLifecycleRule
, ObsBucketLifecycleRuleArgs

Enabled This property is required. bool
Specifies lifecycle rule status.
Name This property is required. string
Unique identifier for lifecycle rules. The Rule Name contains a maximum of 255 characters.
Expirations List<ObsBucketLifecycleRuleExpiration>
Specifies a period when objects that have been last updated are automatically deleted. (documented below).
NoncurrentVersionExpirations List<ObsBucketLifecycleRuleNoncurrentVersionExpiration>
Specifies a period when noncurrent object versions are automatically deleted. (documented below).
NoncurrentVersionTransitions List<ObsBucketLifecycleRuleNoncurrentVersionTransition>

Specifies a period when noncurrent object versions are automatically transitioned to WARM or COLD storage class (documented below).

At least one of expiration, transition, noncurrent_version_expiration, noncurrent_version_transition must be specified.

Prefix string
Object key prefix identifying one or more objects to which the rule applies. If omitted, all objects in the bucket will be managed by the lifecycle rule. The prefix cannot start or end with a slash (/), cannot have consecutive slashes (/), and cannot contain the following special characters: :*?"<>|.
Transitions List<ObsBucketLifecycleRuleTransition>
Specifies a period when objects that have been last updated are automatically transitioned to WARM or COLD storage class (documented below).
Enabled This property is required. bool
Specifies lifecycle rule status.
Name This property is required. string
Unique identifier for lifecycle rules. The Rule Name contains a maximum of 255 characters.
Expirations []ObsBucketLifecycleRuleExpiration
Specifies a period when objects that have been last updated are automatically deleted. (documented below).
NoncurrentVersionExpirations []ObsBucketLifecycleRuleNoncurrentVersionExpiration
Specifies a period when noncurrent object versions are automatically deleted. (documented below).
NoncurrentVersionTransitions []ObsBucketLifecycleRuleNoncurrentVersionTransition

Specifies a period when noncurrent object versions are automatically transitioned to WARM or COLD storage class (documented below).

At least one of expiration, transition, noncurrent_version_expiration, noncurrent_version_transition must be specified.

Prefix string
Object key prefix identifying one or more objects to which the rule applies. If omitted, all objects in the bucket will be managed by the lifecycle rule. The prefix cannot start or end with a slash (/), cannot have consecutive slashes (/), and cannot contain the following special characters: :*?"<>|.
Transitions []ObsBucketLifecycleRuleTransition
Specifies a period when objects that have been last updated are automatically transitioned to WARM or COLD storage class (documented below).
enabled This property is required. Boolean
Specifies lifecycle rule status.
name This property is required. String
Unique identifier for lifecycle rules. The Rule Name contains a maximum of 255 characters.
expirations List<ObsBucketLifecycleRuleExpiration>
Specifies a period when objects that have been last updated are automatically deleted. (documented below).
noncurrentVersionExpirations List<ObsBucketLifecycleRuleNoncurrentVersionExpiration>
Specifies a period when noncurrent object versions are automatically deleted. (documented below).
noncurrentVersionTransitions List<ObsBucketLifecycleRuleNoncurrentVersionTransition>

Specifies a period when noncurrent object versions are automatically transitioned to WARM or COLD storage class (documented below).

At least one of expiration, transition, noncurrent_version_expiration, noncurrent_version_transition must be specified.

prefix String
Object key prefix identifying one or more objects to which the rule applies. If omitted, all objects in the bucket will be managed by the lifecycle rule. The prefix cannot start or end with a slash (/), cannot have consecutive slashes (/), and cannot contain the following special characters: :*?"<>|.
transitions List<ObsBucketLifecycleRuleTransition>
Specifies a period when objects that have been last updated are automatically transitioned to WARM or COLD storage class (documented below).
enabled This property is required. boolean
Specifies lifecycle rule status.
name This property is required. string
Unique identifier for lifecycle rules. The Rule Name contains a maximum of 255 characters.
expirations ObsBucketLifecycleRuleExpiration[]
Specifies a period when objects that have been last updated are automatically deleted. (documented below).
noncurrentVersionExpirations ObsBucketLifecycleRuleNoncurrentVersionExpiration[]
Specifies a period when noncurrent object versions are automatically deleted. (documented below).
noncurrentVersionTransitions ObsBucketLifecycleRuleNoncurrentVersionTransition[]

Specifies a period when noncurrent object versions are automatically transitioned to WARM or COLD storage class (documented below).

At least one of expiration, transition, noncurrent_version_expiration, noncurrent_version_transition must be specified.

prefix string
Object key prefix identifying one or more objects to which the rule applies. If omitted, all objects in the bucket will be managed by the lifecycle rule. The prefix cannot start or end with a slash (/), cannot have consecutive slashes (/), and cannot contain the following special characters: :*?"<>|.
transitions ObsBucketLifecycleRuleTransition[]
Specifies a period when objects that have been last updated are automatically transitioned to WARM or COLD storage class (documented below).
enabled This property is required. bool
Specifies lifecycle rule status.
name This property is required. str
Unique identifier for lifecycle rules. The Rule Name contains a maximum of 255 characters.
expirations Sequence[ObsBucketLifecycleRuleExpiration]
Specifies a period when objects that have been last updated are automatically deleted. (documented below).
noncurrent_version_expirations Sequence[ObsBucketLifecycleRuleNoncurrentVersionExpiration]
Specifies a period when noncurrent object versions are automatically deleted. (documented below).
noncurrent_version_transitions Sequence[ObsBucketLifecycleRuleNoncurrentVersionTransition]

Specifies a period when noncurrent object versions are automatically transitioned to WARM or COLD storage class (documented below).

At least one of expiration, transition, noncurrent_version_expiration, noncurrent_version_transition must be specified.

prefix str
Object key prefix identifying one or more objects to which the rule applies. If omitted, all objects in the bucket will be managed by the lifecycle rule. The prefix cannot start or end with a slash (/), cannot have consecutive slashes (/), and cannot contain the following special characters: :*?"<>|.
transitions Sequence[ObsBucketLifecycleRuleTransition]
Specifies a period when objects that have been last updated are automatically transitioned to WARM or COLD storage class (documented below).
enabled This property is required. Boolean
Specifies lifecycle rule status.
name This property is required. String
Unique identifier for lifecycle rules. The Rule Name contains a maximum of 255 characters.
expirations List<Property Map>
Specifies a period when objects that have been last updated are automatically deleted. (documented below).
noncurrentVersionExpirations List<Property Map>
Specifies a period when noncurrent object versions are automatically deleted. (documented below).
noncurrentVersionTransitions List<Property Map>

Specifies a period when noncurrent object versions are automatically transitioned to WARM or COLD storage class (documented below).

At least one of expiration, transition, noncurrent_version_expiration, noncurrent_version_transition must be specified.

prefix String
Object key prefix identifying one or more objects to which the rule applies. If omitted, all objects in the bucket will be managed by the lifecycle rule. The prefix cannot start or end with a slash (/), cannot have consecutive slashes (/), and cannot contain the following special characters: :*?"<>|.
transitions List<Property Map>
Specifies a period when objects that have been last updated are automatically transitioned to WARM or COLD storage class (documented below).

ObsBucketLifecycleRuleExpiration
, ObsBucketLifecycleRuleExpirationArgs

Days This property is required. double
Specifies the number of days when objects that have been last updated are automatically deleted. The expiration time must be greater than the transition times.
Days This property is required. float64
Specifies the number of days when objects that have been last updated are automatically deleted. The expiration time must be greater than the transition times.
days This property is required. Double
Specifies the number of days when objects that have been last updated are automatically deleted. The expiration time must be greater than the transition times.
days This property is required. number
Specifies the number of days when objects that have been last updated are automatically deleted. The expiration time must be greater than the transition times.
days This property is required. float
Specifies the number of days when objects that have been last updated are automatically deleted. The expiration time must be greater than the transition times.
days This property is required. Number
Specifies the number of days when objects that have been last updated are automatically deleted. The expiration time must be greater than the transition times.

ObsBucketLifecycleRuleNoncurrentVersionExpiration
, ObsBucketLifecycleRuleNoncurrentVersionExpirationArgs

Days This property is required. double
Specifies the number of days when noncurrent object versions are automatically deleted.
Days This property is required. float64
Specifies the number of days when noncurrent object versions are automatically deleted.
days This property is required. Double
Specifies the number of days when noncurrent object versions are automatically deleted.
days This property is required. number
Specifies the number of days when noncurrent object versions are automatically deleted.
days This property is required. float
Specifies the number of days when noncurrent object versions are automatically deleted.
days This property is required. Number
Specifies the number of days when noncurrent object versions are automatically deleted.

ObsBucketLifecycleRuleNoncurrentVersionTransition
, ObsBucketLifecycleRuleNoncurrentVersionTransitionArgs

Days This property is required. double
Specifies the number of days when noncurrent object versions are automatically transitioned to the specified storage class.
StorageClass This property is required. string
The class of storage used to store the object. Only WARM and COLD are supported.
Days This property is required. float64
Specifies the number of days when noncurrent object versions are automatically transitioned to the specified storage class.
StorageClass This property is required. string
The class of storage used to store the object. Only WARM and COLD are supported.
days This property is required. Double
Specifies the number of days when noncurrent object versions are automatically transitioned to the specified storage class.
storageClass This property is required. String
The class of storage used to store the object. Only WARM and COLD are supported.
days This property is required. number
Specifies the number of days when noncurrent object versions are automatically transitioned to the specified storage class.
storageClass This property is required. string
The class of storage used to store the object. Only WARM and COLD are supported.
days This property is required. float
Specifies the number of days when noncurrent object versions are automatically transitioned to the specified storage class.
storage_class This property is required. str
The class of storage used to store the object. Only WARM and COLD are supported.
days This property is required. Number
Specifies the number of days when noncurrent object versions are automatically transitioned to the specified storage class.
storageClass This property is required. String
The class of storage used to store the object. Only WARM and COLD are supported.

ObsBucketLifecycleRuleTransition
, ObsBucketLifecycleRuleTransitionArgs

Days This property is required. double
Specifies the number of days when objects that have been last updated are automatically transitioned to the specified storage class.
StorageClass This property is required. string
The class of storage used to store the object. Only WARM and COLD are supported.
Days This property is required. float64
Specifies the number of days when objects that have been last updated are automatically transitioned to the specified storage class.
StorageClass This property is required. string
The class of storage used to store the object. Only WARM and COLD are supported.
days This property is required. Double
Specifies the number of days when objects that have been last updated are automatically transitioned to the specified storage class.
storageClass This property is required. String
The class of storage used to store the object. Only WARM and COLD are supported.
days This property is required. number
Specifies the number of days when objects that have been last updated are automatically transitioned to the specified storage class.
storageClass This property is required. string
The class of storage used to store the object. Only WARM and COLD are supported.
days This property is required. float
Specifies the number of days when objects that have been last updated are automatically transitioned to the specified storage class.
storage_class This property is required. str
The class of storage used to store the object. Only WARM and COLD are supported.
days This property is required. Number
Specifies the number of days when objects that have been last updated are automatically transitioned to the specified storage class.
storageClass This property is required. String
The class of storage used to store the object. Only WARM and COLD are supported.

ObsBucketLogging
, ObsBucketLoggingArgs

TargetBucket This property is required. string
The name of the bucket that will receive the log objects. The acl policy of the target bucket should be log-delivery-write.
Agency string

Specifies the IAM agency of OBS cloud service.

The IAM agency requires the PutObject permission for the target bucket. If default encryption is enabled for the target bucket, the agency also requires the KMS Administrator permission in the region where the target bucket is located.

TargetPrefix string
To specify a key prefix for log objects.
TargetBucket This property is required. string
The name of the bucket that will receive the log objects. The acl policy of the target bucket should be log-delivery-write.
Agency string

Specifies the IAM agency of OBS cloud service.

The IAM agency requires the PutObject permission for the target bucket. If default encryption is enabled for the target bucket, the agency also requires the KMS Administrator permission in the region where the target bucket is located.

TargetPrefix string
To specify a key prefix for log objects.
targetBucket This property is required. String
The name of the bucket that will receive the log objects. The acl policy of the target bucket should be log-delivery-write.
agency String

Specifies the IAM agency of OBS cloud service.

The IAM agency requires the PutObject permission for the target bucket. If default encryption is enabled for the target bucket, the agency also requires the KMS Administrator permission in the region where the target bucket is located.

targetPrefix String
To specify a key prefix for log objects.
targetBucket This property is required. string
The name of the bucket that will receive the log objects. The acl policy of the target bucket should be log-delivery-write.
agency string

Specifies the IAM agency of OBS cloud service.

The IAM agency requires the PutObject permission for the target bucket. If default encryption is enabled for the target bucket, the agency also requires the KMS Administrator permission in the region where the target bucket is located.

targetPrefix string
To specify a key prefix for log objects.
target_bucket This property is required. str
The name of the bucket that will receive the log objects. The acl policy of the target bucket should be log-delivery-write.
agency str

Specifies the IAM agency of OBS cloud service.

The IAM agency requires the PutObject permission for the target bucket. If default encryption is enabled for the target bucket, the agency also requires the KMS Administrator permission in the region where the target bucket is located.

target_prefix str
To specify a key prefix for log objects.
targetBucket This property is required. String
The name of the bucket that will receive the log objects. The acl policy of the target bucket should be log-delivery-write.
agency String

Specifies the IAM agency of OBS cloud service.

The IAM agency requires the PutObject permission for the target bucket. If default encryption is enabled for the target bucket, the agency also requires the KMS Administrator permission in the region where the target bucket is located.

targetPrefix String
To specify a key prefix for log objects.

ObsBucketServerSideEncryption
, ObsBucketServerSideEncryptionArgs

Algorithm This property is required. string
The algorithm used for SSE. Only kms is supported.
KmsKeyId This property is required. string

The ID of KMS key used for the encryption.

Only base project (e.g. eu-de) KMS keys can be used for the encryption

Algorithm This property is required. string
The algorithm used for SSE. Only kms is supported.
KmsKeyId This property is required. string

The ID of KMS key used for the encryption.

Only base project (e.g. eu-de) KMS keys can be used for the encryption

algorithm This property is required. String
The algorithm used for SSE. Only kms is supported.
kmsKeyId This property is required. String

The ID of KMS key used for the encryption.

Only base project (e.g. eu-de) KMS keys can be used for the encryption

algorithm This property is required. string
The algorithm used for SSE. Only kms is supported.
kmsKeyId This property is required. string

The ID of KMS key used for the encryption.

Only base project (e.g. eu-de) KMS keys can be used for the encryption

algorithm This property is required. str
The algorithm used for SSE. Only kms is supported.
kms_key_id This property is required. str

The ID of KMS key used for the encryption.

Only base project (e.g. eu-de) KMS keys can be used for the encryption

algorithm This property is required. String
The algorithm used for SSE. Only kms is supported.
kmsKeyId This property is required. String

The ID of KMS key used for the encryption.

Only base project (e.g. eu-de) KMS keys can be used for the encryption

ObsBucketWebsite
, ObsBucketWebsiteArgs

ErrorDocument string
Specifies the error page returned when an error occurs during static website access. Only HTML, JPG, PNG, BMP, and WEBP files under the root directory are supported.
IndexDocument string
Specifies the default homepage of the static website, only HTML web pages are supported. OBS only allows files such as index.html in the root directory of a bucket to function as the default homepage. That is to say, do not set the default homepage with a multi-level directory structure (for example, /page/index.html).
RedirectAllRequestsTo string
A hostname to redirect all website requests for this bucket to. Hostname can optionally be prefixed with a protocol (http:// or https://) to use when redirecting requests. The default is the protocol that is used in the original request.
RoutingRules string

A JSON or XML format containing routing rules describing redirect behavior and when redirects are applied. Each rule contains a Condition and a Redirect as shown in the following table:

| Parameter | Key | |-----------|-----| | Condition | KeyPrefixEquals, HttpErrorCodeReturnedEquals | | Redirect | Protocol, HostName, ReplaceKeyPrefixWith, ReplaceKeyWith, HttpRedirectCode |

ErrorDocument string
Specifies the error page returned when an error occurs during static website access. Only HTML, JPG, PNG, BMP, and WEBP files under the root directory are supported.
IndexDocument string
Specifies the default homepage of the static website, only HTML web pages are supported. OBS only allows files such as index.html in the root directory of a bucket to function as the default homepage. That is to say, do not set the default homepage with a multi-level directory structure (for example, /page/index.html).
RedirectAllRequestsTo string
A hostname to redirect all website requests for this bucket to. Hostname can optionally be prefixed with a protocol (http:// or https://) to use when redirecting requests. The default is the protocol that is used in the original request.
RoutingRules string

A JSON or XML format containing routing rules describing redirect behavior and when redirects are applied. Each rule contains a Condition and a Redirect as shown in the following table:

| Parameter | Key | |-----------|-----| | Condition | KeyPrefixEquals, HttpErrorCodeReturnedEquals | | Redirect | Protocol, HostName, ReplaceKeyPrefixWith, ReplaceKeyWith, HttpRedirectCode |

errorDocument String
Specifies the error page returned when an error occurs during static website access. Only HTML, JPG, PNG, BMP, and WEBP files under the root directory are supported.
indexDocument String
Specifies the default homepage of the static website, only HTML web pages are supported. OBS only allows files such as index.html in the root directory of a bucket to function as the default homepage. That is to say, do not set the default homepage with a multi-level directory structure (for example, /page/index.html).
redirectAllRequestsTo String
A hostname to redirect all website requests for this bucket to. Hostname can optionally be prefixed with a protocol (http:// or https://) to use when redirecting requests. The default is the protocol that is used in the original request.
routingRules String

A JSON or XML format containing routing rules describing redirect behavior and when redirects are applied. Each rule contains a Condition and a Redirect as shown in the following table:

| Parameter | Key | |-----------|-----| | Condition | KeyPrefixEquals, HttpErrorCodeReturnedEquals | | Redirect | Protocol, HostName, ReplaceKeyPrefixWith, ReplaceKeyWith, HttpRedirectCode |

errorDocument string
Specifies the error page returned when an error occurs during static website access. Only HTML, JPG, PNG, BMP, and WEBP files under the root directory are supported.
indexDocument string
Specifies the default homepage of the static website, only HTML web pages are supported. OBS only allows files such as index.html in the root directory of a bucket to function as the default homepage. That is to say, do not set the default homepage with a multi-level directory structure (for example, /page/index.html).
redirectAllRequestsTo string
A hostname to redirect all website requests for this bucket to. Hostname can optionally be prefixed with a protocol (http:// or https://) to use when redirecting requests. The default is the protocol that is used in the original request.
routingRules string

A JSON or XML format containing routing rules describing redirect behavior and when redirects are applied. Each rule contains a Condition and a Redirect as shown in the following table:

| Parameter | Key | |-----------|-----| | Condition | KeyPrefixEquals, HttpErrorCodeReturnedEquals | | Redirect | Protocol, HostName, ReplaceKeyPrefixWith, ReplaceKeyWith, HttpRedirectCode |

error_document str
Specifies the error page returned when an error occurs during static website access. Only HTML, JPG, PNG, BMP, and WEBP files under the root directory are supported.
index_document str
Specifies the default homepage of the static website, only HTML web pages are supported. OBS only allows files such as index.html in the root directory of a bucket to function as the default homepage. That is to say, do not set the default homepage with a multi-level directory structure (for example, /page/index.html).
redirect_all_requests_to str
A hostname to redirect all website requests for this bucket to. Hostname can optionally be prefixed with a protocol (http:// or https://) to use when redirecting requests. The default is the protocol that is used in the original request.
routing_rules str

A JSON or XML format containing routing rules describing redirect behavior and when redirects are applied. Each rule contains a Condition and a Redirect as shown in the following table:

| Parameter | Key | |-----------|-----| | Condition | KeyPrefixEquals, HttpErrorCodeReturnedEquals | | Redirect | Protocol, HostName, ReplaceKeyPrefixWith, ReplaceKeyWith, HttpRedirectCode |

errorDocument String
Specifies the error page returned when an error occurs during static website access. Only HTML, JPG, PNG, BMP, and WEBP files under the root directory are supported.
indexDocument String
Specifies the default homepage of the static website, only HTML web pages are supported. OBS only allows files such as index.html in the root directory of a bucket to function as the default homepage. That is to say, do not set the default homepage with a multi-level directory structure (for example, /page/index.html).
redirectAllRequestsTo String
A hostname to redirect all website requests for this bucket to. Hostname can optionally be prefixed with a protocol (http:// or https://) to use when redirecting requests. The default is the protocol that is used in the original request.
routingRules String

A JSON or XML format containing routing rules describing redirect behavior and when redirects are applied. Each rule contains a Condition and a Redirect as shown in the following table:

| Parameter | Key | |-----------|-----| | Condition | KeyPrefixEquals, HttpErrorCodeReturnedEquals | | Redirect | Protocol, HostName, ReplaceKeyPrefixWith, ReplaceKeyWith, HttpRedirectCode |

ObsBucketWormPolicy
, ObsBucketWormPolicyArgs

Days double
Default protection period, in days. The value is from 1 to 36500.
Years double
Default protection period, in years. In a leap year, only 365 days are calculated. The value is from 1 to 100.
Days float64
Default protection period, in days. The value is from 1 to 36500.
Years float64
Default protection period, in years. In a leap year, only 365 days are calculated. The value is from 1 to 100.
days Double
Default protection period, in days. The value is from 1 to 36500.
years Double
Default protection period, in years. In a leap year, only 365 days are calculated. The value is from 1 to 100.
days number
Default protection period, in days. The value is from 1 to 36500.
years number
Default protection period, in years. In a leap year, only 365 days are calculated. The value is from 1 to 100.
days float
Default protection period, in days. The value is from 1 to 36500.
years float
Default protection period, in years. In a leap year, only 365 days are calculated. The value is from 1 to 100.
days Number
Default protection period, in days. The value is from 1 to 36500.
years Number
Default protection period, in years. In a leap year, only 365 days are calculated. The value is from 1 to 100.

Import

OBS bucket can be imported using the bucket, e.g.

$ pulumi import opentelekomcloud:index/obsBucket:ObsBucket bucket bucket-name
Copy

To learn more about importing existing cloud resources, see Importing resources.

Package Details

Repository
opentelekomcloud opentelekomcloud/terraform-provider-opentelekomcloud
License
Notes
This Pulumi package is based on the opentelekomcloud Terraform Provider.