diff --git a/sdk/dotnet/Inputs/S3BucketReplicationRuleArgs.cs b/sdk/dotnet/Inputs/S3BucketReplicationRuleArgs.cs new file mode 100644 index 0000000..bb8ab8f --- /dev/null +++ b/sdk/dotnet/Inputs/S3BucketReplicationRuleArgs.cs @@ -0,0 +1,92 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Minio.Inputs +{ + + public sealed class S3BucketReplicationRuleArgs : global::Pulumi.ResourceArgs + { + /// + /// Rule ARN genrated by MinIO + /// + [Input("arn")] + public Input? Arn { get; set; } + + /// + /// Whether or not to synchronise marker deletion + /// + [Input("deleteMarkerReplication")] + public Input? DeleteMarkerReplication { get; set; } + + /// + /// Whether or not to propagate deletion + /// + [Input("deleteReplication")] + public Input? DeleteReplication { get; set; } + + /// + /// Whether or not this rule is enabled + /// + [Input("enabled")] + public Input? Enabled { get; set; } + + /// + /// Whether or not to synchronise object created prior the replication configuration + /// + [Input("existingObjectReplication")] + public Input? ExistingObjectReplication { get; set; } + + /// + /// Rule ID generated by MinIO + /// + [Input("id")] + public Input? Id { get; set; } + + /// + /// Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + /// + [Input("metadataSync")] + public Input? MetadataSync { get; set; } + + /// + /// Bucket prefix object must be in to be syncronised + /// + [Input("prefix")] + public Input? Prefix { get; set; } + + /// + /// Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + /// + [Input("priority")] + public Input? Priority { get; set; } + + [Input("tags")] + private InputMap? _tags; + + /// + /// Tags which objects must have to be syncronised + /// + public InputMap Tags + { + get => _tags ?? (_tags = new InputMap()); + set => _tags = value; + } + + /// + /// Bucket prefix + /// + [Input("target", required: true)] + public Input Target { get; set; } = null!; + + public S3BucketReplicationRuleArgs() + { + } + public static new S3BucketReplicationRuleArgs Empty => new S3BucketReplicationRuleArgs(); + } +} diff --git a/sdk/dotnet/Inputs/S3BucketReplicationRuleGetArgs.cs b/sdk/dotnet/Inputs/S3BucketReplicationRuleGetArgs.cs new file mode 100644 index 0000000..1f2d8fb --- /dev/null +++ b/sdk/dotnet/Inputs/S3BucketReplicationRuleGetArgs.cs @@ -0,0 +1,92 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Minio.Inputs +{ + + public sealed class S3BucketReplicationRuleGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Rule ARN genrated by MinIO + /// + [Input("arn")] + public Input? Arn { get; set; } + + /// + /// Whether or not to synchronise marker deletion + /// + [Input("deleteMarkerReplication")] + public Input? DeleteMarkerReplication { get; set; } + + /// + /// Whether or not to propagate deletion + /// + [Input("deleteReplication")] + public Input? DeleteReplication { get; set; } + + /// + /// Whether or not this rule is enabled + /// + [Input("enabled")] + public Input? Enabled { get; set; } + + /// + /// Whether or not to synchronise object created prior the replication configuration + /// + [Input("existingObjectReplication")] + public Input? ExistingObjectReplication { get; set; } + + /// + /// Rule ID generated by MinIO + /// + [Input("id")] + public Input? Id { get; set; } + + /// + /// Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + /// + [Input("metadataSync")] + public Input? MetadataSync { get; set; } + + /// + /// Bucket prefix object must be in to be syncronised + /// + [Input("prefix")] + public Input? Prefix { get; set; } + + /// + /// Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + /// + [Input("priority")] + public Input? Priority { get; set; } + + [Input("tags")] + private InputMap? _tags; + + /// + /// Tags which objects must have to be syncronised + /// + public InputMap Tags + { + get => _tags ?? (_tags = new InputMap()); + set => _tags = value; + } + + /// + /// Bucket prefix + /// + [Input("target", required: true)] + public Input Target { get; set; } = null!; + + public S3BucketReplicationRuleGetArgs() + { + } + public static new S3BucketReplicationRuleGetArgs Empty => new S3BucketReplicationRuleGetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/S3BucketReplicationRuleTargetArgs.cs b/sdk/dotnet/Inputs/S3BucketReplicationRuleTargetArgs.cs new file mode 100644 index 0000000..01d8071 --- /dev/null +++ b/sdk/dotnet/Inputs/S3BucketReplicationRuleTargetArgs.cs @@ -0,0 +1,105 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Minio.Inputs +{ + + public sealed class S3BucketReplicationRuleTargetArgs : global::Pulumi.ResourceArgs + { + /// + /// Access key for the replication service account in the target MinIO + /// + [Input("accessKey", required: true)] + public Input AccessKey { get; set; } = null!; + + /// + /// Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + /// + [Input("bandwidthLimt")] + public Input? BandwidthLimt { get; set; } + + /// + /// The name of the existing target bucket to replicate into + /// + [Input("bucket", required: true)] + public Input Bucket { get; set; } = null!; + + /// + /// Disable proxy for this target + /// + [Input("disableProxy")] + public Input? DisableProxy { get; set; } + + /// + /// Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + /// + [Input("healthCheckPeriod")] + public Input? HealthCheckPeriod { get; set; } + + /// + /// The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + /// + [Input("host", required: true)] + public Input Host { get; set; } = null!; + + /// + /// Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + /// + [Input("path")] + public Input? Path { get; set; } + + /// + /// Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + /// + [Input("pathStyle")] + public Input? PathStyle { get; set; } + + /// + /// Region of the target MinIO. This will be used to generate the target ARN + /// + [Input("region")] + public Input? Region { get; set; } + + [Input("secretKey")] + private Input? _secretKey; + + /// + /// Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + /// + public Input? SecretKey + { + get => _secretKey; + set + { + var emptySecret = Output.CreateSecret(0); + _secretKey = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("secure")] + public Input? Secure { get; set; } + + /// + /// The storage class to use for the object on this target + /// + [Input("storageClass")] + public Input? StorageClass { get; set; } + + /// + /// Use synchronous replication. + /// + [Input("syncronous")] + public Input? Syncronous { get; set; } + + public S3BucketReplicationRuleTargetArgs() + { + } + public static new S3BucketReplicationRuleTargetArgs Empty => new S3BucketReplicationRuleTargetArgs(); + } +} diff --git a/sdk/dotnet/Inputs/S3BucketReplicationRuleTargetGetArgs.cs b/sdk/dotnet/Inputs/S3BucketReplicationRuleTargetGetArgs.cs new file mode 100644 index 0000000..9959ed9 --- /dev/null +++ b/sdk/dotnet/Inputs/S3BucketReplicationRuleTargetGetArgs.cs @@ -0,0 +1,105 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Minio.Inputs +{ + + public sealed class S3BucketReplicationRuleTargetGetArgs : global::Pulumi.ResourceArgs + { + /// + /// Access key for the replication service account in the target MinIO + /// + [Input("accessKey", required: true)] + public Input AccessKey { get; set; } = null!; + + /// + /// Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + /// + [Input("bandwidthLimt")] + public Input? BandwidthLimt { get; set; } + + /// + /// The name of the existing target bucket to replicate into + /// + [Input("bucket", required: true)] + public Input Bucket { get; set; } = null!; + + /// + /// Disable proxy for this target + /// + [Input("disableProxy")] + public Input? DisableProxy { get; set; } + + /// + /// Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + /// + [Input("healthCheckPeriod")] + public Input? HealthCheckPeriod { get; set; } + + /// + /// The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + /// + [Input("host", required: true)] + public Input Host { get; set; } = null!; + + /// + /// Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + /// + [Input("path")] + public Input? Path { get; set; } + + /// + /// Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + /// + [Input("pathStyle")] + public Input? PathStyle { get; set; } + + /// + /// Region of the target MinIO. This will be used to generate the target ARN + /// + [Input("region")] + public Input? Region { get; set; } + + [Input("secretKey")] + private Input? _secretKey; + + /// + /// Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + /// + public Input? SecretKey + { + get => _secretKey; + set + { + var emptySecret = Output.CreateSecret(0); + _secretKey = Output.Tuple?, int>(value, emptySecret).Apply(t => t.Item1); + } + } + + [Input("secure")] + public Input? Secure { get; set; } + + /// + /// The storage class to use for the object on this target + /// + [Input("storageClass")] + public Input? StorageClass { get; set; } + + /// + /// Use synchronous replication. + /// + [Input("syncronous")] + public Input? Syncronous { get; set; } + + public S3BucketReplicationRuleTargetGetArgs() + { + } + public static new S3BucketReplicationRuleTargetGetArgs Empty => new S3BucketReplicationRuleTargetGetArgs(); + } +} diff --git a/sdk/dotnet/Outputs/S3BucketReplicationRule.cs b/sdk/dotnet/Outputs/S3BucketReplicationRule.cs new file mode 100644 index 0000000..27c0a96 --- /dev/null +++ b/sdk/dotnet/Outputs/S3BucketReplicationRule.cs @@ -0,0 +1,98 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Minio.Outputs +{ + + [OutputType] + public sealed class S3BucketReplicationRule + { + /// + /// Rule ARN genrated by MinIO + /// + public readonly string? Arn; + /// + /// Whether or not to synchronise marker deletion + /// + public readonly bool? DeleteMarkerReplication; + /// + /// Whether or not to propagate deletion + /// + public readonly bool? DeleteReplication; + /// + /// Whether or not this rule is enabled + /// + public readonly bool? Enabled; + /// + /// Whether or not to synchronise object created prior the replication configuration + /// + public readonly bool? ExistingObjectReplication; + /// + /// Rule ID generated by MinIO + /// + public readonly string? Id; + /// + /// Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + /// + public readonly bool? MetadataSync; + /// + /// Bucket prefix object must be in to be syncronised + /// + public readonly string? Prefix; + /// + /// Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + /// + public readonly int? Priority; + /// + /// Tags which objects must have to be syncronised + /// + public readonly ImmutableDictionary? Tags; + /// + /// Bucket prefix + /// + public readonly Outputs.S3BucketReplicationRuleTarget Target; + + [OutputConstructor] + private S3BucketReplicationRule( + string? arn, + + bool? deleteMarkerReplication, + + bool? deleteReplication, + + bool? enabled, + + bool? existingObjectReplication, + + string? id, + + bool? metadataSync, + + string? prefix, + + int? priority, + + ImmutableDictionary? tags, + + Outputs.S3BucketReplicationRuleTarget target) + { + Arn = arn; + DeleteMarkerReplication = deleteMarkerReplication; + DeleteReplication = deleteReplication; + Enabled = enabled; + ExistingObjectReplication = existingObjectReplication; + Id = id; + MetadataSync = metadataSync; + Prefix = prefix; + Priority = priority; + Tags = tags; + Target = target; + } + } +} diff --git a/sdk/dotnet/Outputs/S3BucketReplicationRuleTarget.cs b/sdk/dotnet/Outputs/S3BucketReplicationRuleTarget.cs new file mode 100644 index 0000000..69463c1 --- /dev/null +++ b/sdk/dotnet/Outputs/S3BucketReplicationRuleTarget.cs @@ -0,0 +1,109 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Minio.Outputs +{ + + [OutputType] + public sealed class S3BucketReplicationRuleTarget + { + /// + /// Access key for the replication service account in the target MinIO + /// + public readonly string AccessKey; + /// + /// Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + /// + public readonly string? BandwidthLimt; + /// + /// The name of the existing target bucket to replicate into + /// + public readonly string Bucket; + /// + /// Disable proxy for this target + /// + public readonly bool? DisableProxy; + /// + /// Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + /// + public readonly string? HealthCheckPeriod; + /// + /// The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + /// + public readonly string Host; + /// + /// Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + /// + public readonly string? Path; + /// + /// Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + /// + public readonly string? PathStyle; + /// + /// Region of the target MinIO. This will be used to generate the target ARN + /// + public readonly string? Region; + /// + /// Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + /// + public readonly string? SecretKey; + public readonly bool? Secure; + /// + /// The storage class to use for the object on this target + /// + public readonly string? StorageClass; + /// + /// Use synchronous replication. + /// + public readonly bool? Syncronous; + + [OutputConstructor] + private S3BucketReplicationRuleTarget( + string accessKey, + + string? bandwidthLimt, + + string bucket, + + bool? disableProxy, + + string? healthCheckPeriod, + + string host, + + string? path, + + string? pathStyle, + + string? region, + + string? secretKey, + + bool? secure, + + string? storageClass, + + bool? syncronous) + { + AccessKey = accessKey; + BandwidthLimt = bandwidthLimt; + Bucket = bucket; + DisableProxy = disableProxy; + HealthCheckPeriod = healthCheckPeriod; + Host = host; + Path = path; + PathStyle = pathStyle; + Region = region; + SecretKey = secretKey; + Secure = secure; + StorageClass = storageClass; + Syncronous = syncronous; + } + } +} diff --git a/sdk/dotnet/S3BucketReplication.cs b/sdk/dotnet/S3BucketReplication.cs new file mode 100644 index 0000000..abdafe8 --- /dev/null +++ b/sdk/dotnet/S3BucketReplication.cs @@ -0,0 +1,363 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; + +namespace Pulumi.Minio +{ + /// + /// ## Example Usage + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Minio = Pulumi.Minio; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var myBucketInAS3Bucket = new Minio.S3Bucket("myBucketInAS3Bucket", new() + /// { + /// Bucket = "my-bucket", + /// }); + /// + /// var myBucketInBS3Bucket = new Minio.S3Bucket("myBucketInBS3Bucket", new() + /// { + /// Bucket = "my-bucket", + /// }, new CustomResourceOptions + /// { + /// Provider = minio.Deployment_b, + /// }); + /// + /// var myBucketInAS3BucketVersioning = new Minio.S3BucketVersioning("myBucketInAS3BucketVersioning", new() + /// { + /// Bucket = myBucketInAS3Bucket.Bucket, + /// VersioningConfiguration = new Minio.Inputs.S3BucketVersioningVersioningConfigurationArgs + /// { + /// Status = "Enabled", + /// }, + /// }); + /// + /// var myBucketInBS3BucketVersioning = new Minio.S3BucketVersioning("myBucketInBS3BucketVersioning", new() + /// { + /// Bucket = myBucketInBS3Bucket.Bucket, + /// VersioningConfiguration = new Minio.Inputs.S3BucketVersioningVersioningConfigurationArgs + /// { + /// Status = "Enabled", + /// }, + /// }, new CustomResourceOptions + /// { + /// Provider = minio.Deployment_b, + /// }); + /// + /// var replicationPolicy = Minio.GetIamPolicyDocument.Invoke(new() + /// { + /// Statements = new[] + /// { + /// new Minio.Inputs.GetIamPolicyDocumentStatementInputArgs + /// { + /// Sid = "ReadBuckets", + /// Effect = "Allow", + /// Resources = new[] + /// { + /// "arn:aws:s3:::*", + /// }, + /// Actions = new[] + /// { + /// "s3:ListBucket", + /// }, + /// }, + /// new Minio.Inputs.GetIamPolicyDocumentStatementInputArgs + /// { + /// Sid = "EnableReplicationOnBucket", + /// Effect = "Allow", + /// Resources = new[] + /// { + /// "arn:aws:s3:::my-bucket", + /// }, + /// Actions = new[] + /// { + /// "s3:GetReplicationConfiguration", + /// "s3:ListBucket", + /// "s3:ListBucketMultipartUploads", + /// "s3:GetBucketLocation", + /// "s3:GetBucketVersioning", + /// "s3:GetBucketObjectLockConfiguration", + /// "s3:GetEncryptionConfiguration", + /// }, + /// }, + /// new Minio.Inputs.GetIamPolicyDocumentStatementInputArgs + /// { + /// Sid = "EnableReplicatingDataIntoBucket", + /// Effect = "Allow", + /// Resources = new[] + /// { + /// "arn:aws:s3:::my-bucket/*", + /// }, + /// Actions = new[] + /// { + /// "s3:GetReplicationConfiguration", + /// "s3:ReplicateTags", + /// "s3:AbortMultipartUpload", + /// "s3:GetObject", + /// "s3:GetObjectVersion", + /// "s3:GetObjectVersionTagging", + /// "s3:PutObject", + /// "s3:PutObjectRetention", + /// "s3:PutBucketObjectLockConfiguration", + /// "s3:PutObjectLegalHold", + /// "s3:DeleteObject", + /// "s3:ReplicateObject", + /// "s3:ReplicateDelete", + /// }, + /// }, + /// }, + /// }); + /// + /// // One-Way replication (A -> B) + /// var replicationInBIamPolicy = new Minio.IamPolicy("replicationInBIamPolicy", new() + /// { + /// Policy = replicationPolicy.Apply(getIamPolicyDocumentResult => getIamPolicyDocumentResult.Json), + /// }, new CustomResourceOptions + /// { + /// Provider = minio.Deployment_b, + /// }); + /// + /// var replicationInBIamUser = new Minio.IamUser("replicationInBIamUser", new() + /// { + /// ForceDestroy = true, + /// }, new CustomResourceOptions + /// { + /// Provider = minio.Deployment_b, + /// }); + /// + /// var replicationInBIamUserPolicyAttachment = new Minio.IamUserPolicyAttachment("replicationInBIamUserPolicyAttachment", new() + /// { + /// UserName = replicationInBIamUser.Name, + /// PolicyName = replicationInBIamPolicy.Id, + /// }, new CustomResourceOptions + /// { + /// Provider = minio.Deployment_b, + /// }); + /// + /// var replicationInBIamServiceAccount = new Minio.IamServiceAccount("replicationInBIamServiceAccount", new() + /// { + /// TargetUser = replicationInBIamUser.Name, + /// }, new CustomResourceOptions + /// { + /// Provider = minio.Deployment_b, + /// DependsOn = new[] + /// { + /// replicationInBIamUserPolicyAttachment, + /// }, + /// }); + /// + /// var replicationInBS3BucketReplication = new Minio.S3BucketReplication("replicationInBS3BucketReplication", new() + /// { + /// Bucket = myBucketInAS3Bucket.Bucket, + /// Rules = new[] + /// { + /// new Minio.Inputs.S3BucketReplicationRuleArgs + /// { + /// DeleteReplication = true, + /// DeleteMarkerReplication = true, + /// ExistingObjectReplication = true, + /// MetadataSync = true, + /// Target = new Minio.Inputs.S3BucketReplicationRuleTargetArgs + /// { + /// Bucket = myBucketInBS3Bucket.Bucket, + /// Secure = false, + /// Host = @var.Minio_server_b, + /// BandwidthLimt = "100M", + /// AccessKey = replicationInBIamServiceAccount.AccessKey, + /// SecretKey = replicationInBIamServiceAccount.SecretKey, + /// }, + /// }, + /// }, + /// }, new CustomResourceOptions + /// { + /// DependsOn = new[] + /// { + /// myBucketInAS3BucketVersioning, + /// myBucketInBS3BucketVersioning, + /// }, + /// }); + /// + /// // Two-Way replication (A <-> B) + /// var replicationInAIamPolicy = new Minio.IamPolicy("replicationInAIamPolicy", new() + /// { + /// Policy = replicationPolicy.Apply(getIamPolicyDocumentResult => getIamPolicyDocumentResult.Json), + /// }); + /// + /// var replicationInAIamUser = new Minio.IamUser("replicationInAIamUser", new() + /// { + /// ForceDestroy = true, + /// }); + /// + /// var replicationInAIamUserPolicyAttachment = new Minio.IamUserPolicyAttachment("replicationInAIamUserPolicyAttachment", new() + /// { + /// UserName = replicationInAIamUser.Name, + /// PolicyName = replicationInAIamPolicy.Id, + /// }); + /// + /// var replicationInAIamServiceAccount = new Minio.IamServiceAccount("replicationInAIamServiceAccount", new() + /// { + /// TargetUser = replicationInAIamUser.Name, + /// }, new CustomResourceOptions + /// { + /// DependsOn = new[] + /// { + /// replicationInBIamUserPolicyAttachment, + /// }, + /// }); + /// + /// var replicationInAS3BucketReplication = new Minio.S3BucketReplication("replicationInAS3BucketReplication", new() + /// { + /// Bucket = myBucketInBS3Bucket.Bucket, + /// Rules = new[] + /// { + /// new Minio.Inputs.S3BucketReplicationRuleArgs + /// { + /// DeleteReplication = true, + /// DeleteMarkerReplication = true, + /// ExistingObjectReplication = true, + /// MetadataSync = true, + /// Target = new Minio.Inputs.S3BucketReplicationRuleTargetArgs + /// { + /// Bucket = myBucketInAS3Bucket.Bucket, + /// Host = @var.Minio_server_a, + /// Secure = false, + /// BandwidthLimt = "100M", + /// AccessKey = replicationInAIamServiceAccount.AccessKey, + /// SecretKey = replicationInAIamServiceAccount.SecretKey, + /// }, + /// }, + /// }, + /// }, new CustomResourceOptions + /// { + /// Provider = minio.Deployment_b, + /// DependsOn = new[] + /// { + /// myBucketInAS3BucketVersioning, + /// myBucketInBS3BucketVersioning, + /// }, + /// }); + /// + /// }); + /// ``` + /// + [MinioResourceType("minio:index/s3BucketReplication:S3BucketReplication")] + public partial class S3BucketReplication : global::Pulumi.CustomResource + { + /// + /// The name of the existing target bucket to replicate into + /// + [Output("bucket")] + public Output Bucket { get; private set; } = null!; + + /// + /// Rule definitions + /// + [Output("rules")] + public Output> Rules { get; private set; } = null!; + + + /// + /// Create a S3BucketReplication resource with the given unique name, arguments, and options. + /// + /// + /// The unique name of the resource + /// The arguments used to populate this resource's properties + /// A bag of options that control this resource's behavior + public S3BucketReplication(string name, S3BucketReplicationArgs args, CustomResourceOptions? options = null) + : base("minio:index/s3BucketReplication:S3BucketReplication", name, args ?? new S3BucketReplicationArgs(), MakeResourceOptions(options, "")) + { + } + + private S3BucketReplication(string name, Input id, S3BucketReplicationState? state = null, CustomResourceOptions? options = null) + : base("minio:index/s3BucketReplication:S3BucketReplication", name, state, MakeResourceOptions(options, id)) + { + } + + private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input? id) + { + var defaultOptions = new CustomResourceOptions + { + Version = Utilities.Version, + }; + var merged = CustomResourceOptions.Merge(defaultOptions, options); + // Override the ID if one was specified for consistency with other language SDKs. + merged.Id = id ?? merged.Id; + return merged; + } + /// + /// Get an existing S3BucketReplication resource's state with the given name, ID, and optional extra + /// properties used to qualify the lookup. + /// + /// + /// The unique name of the resulting resource. + /// The unique provider ID of the resource to lookup. + /// Any extra arguments used during the lookup. + /// A bag of options that control this resource's behavior + public static S3BucketReplication Get(string name, Input id, S3BucketReplicationState? state = null, CustomResourceOptions? options = null) + { + return new S3BucketReplication(name, id, state, options); + } + } + + public sealed class S3BucketReplicationArgs : global::Pulumi.ResourceArgs + { + /// + /// The name of the existing target bucket to replicate into + /// + [Input("bucket", required: true)] + public Input Bucket { get; set; } = null!; + + [Input("rules")] + private InputList? _rules; + + /// + /// Rule definitions + /// + public InputList Rules + { + get => _rules ?? (_rules = new InputList()); + set => _rules = value; + } + + public S3BucketReplicationArgs() + { + } + public static new S3BucketReplicationArgs Empty => new S3BucketReplicationArgs(); + } + + public sealed class S3BucketReplicationState : global::Pulumi.ResourceArgs + { + /// + /// The name of the existing target bucket to replicate into + /// + [Input("bucket")] + public Input? Bucket { get; set; } + + [Input("rules")] + private InputList? _rules; + + /// + /// Rule definitions + /// + public InputList Rules + { + get => _rules ?? (_rules = new InputList()); + set => _rules = value; + } + + public S3BucketReplicationState() + { + } + public static new S3BucketReplicationState Empty => new S3BucketReplicationState(); + } +} diff --git a/sdk/go.mod b/sdk/go.mod index 2d59a8e..14f67ce 100644 --- a/sdk/go.mod +++ b/sdk/go.mod @@ -1,9 +1,10 @@ -module github.com/pulumi/pulumi-minio/sdk +module github.com/pulumi/pulumi-minio/sdk/v2 go 1.21 require ( github.com/blang/semver v3.5.1+incompatible + github.com/pulumi/pulumi-minio/sdk v0.15.1 github.com/pulumi/pulumi/sdk/v3 v3.99.0 ) @@ -67,7 +68,6 @@ require ( github.com/spf13/cast v1.4.1 // indirect github.com/spf13/cobra v1.7.0 // indirect github.com/spf13/pflag v1.0.5 // indirect - github.com/stretchr/objx v0.2.0 // indirect github.com/texttheater/golang-levenshtein v1.0.1 // indirect github.com/tweekmonster/luser v0.0.0-20161003172636-3fa38070dbd7 // indirect github.com/uber/jaeger-client-go v2.30.0+incompatible // indirect diff --git a/sdk/go.sum b/sdk/go.sum index eed2a6c..a0ae7a5 100644 --- a/sdk/go.sum +++ b/sdk/go.sum @@ -151,6 +151,8 @@ github.com/pulumi/appdash v0.0.0-20231130102222-75f619a67231 h1:vkHw5I/plNdTr435 github.com/pulumi/appdash v0.0.0-20231130102222-75f619a67231/go.mod h1:murToZ2N9hNJzewjHBgfFdXhZKjY3z5cYC1VXk+lbFE= github.com/pulumi/esc v0.6.2 h1:+z+l8cuwIauLSwXQS0uoI3rqB+YG4SzsZYtHfNoXBvw= github.com/pulumi/esc v0.6.2/go.mod h1:jNnYNjzsOgVTjCp0LL24NsCk8ZJxq4IoLQdCT0X7l8k= +github.com/pulumi/pulumi-minio/sdk v0.15.1 h1:6F7X7m4A7sJKOqgqlhGwg3L/0GqiKHVXXjtPrjisM7Q= +github.com/pulumi/pulumi-minio/sdk v0.15.1/go.mod h1:IdCOKtklBTIRudnSqAG916CA6aM7qV+/SQIjIxMFaX4= github.com/pulumi/pulumi/sdk/v3 v3.99.0 h1:vsFoEEdweYg3Hm6/Jlj1sE2cLtauzoqAdVbLMcC7Cw8= github.com/pulumi/pulumi/sdk/v3 v3.99.0/go.mod h1:wFM/6iAMlidgLDSF9QU+p3P+B+vg/xloFyVeZrVwA1w= github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= diff --git a/sdk/go/minio/config/config.go b/sdk/go/minio/config/config.go index a77cc18..8e21450 100644 --- a/sdk/go/minio/config/config.go +++ b/sdk/go/minio/config/config.go @@ -4,7 +4,7 @@ package config import ( - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" "github.com/pulumi/pulumi/sdk/v3/go/pulumi/config" ) diff --git a/sdk/go/minio/getIamPolicyDocument.go b/sdk/go/minio/getIamPolicyDocument.go index 5478123..1825eac 100644 --- a/sdk/go/minio/getIamPolicyDocument.go +++ b/sdk/go/minio/getIamPolicyDocument.go @@ -7,7 +7,7 @@ import ( "context" "reflect" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) @@ -18,7 +18,7 @@ import ( // // import ( // -// "github.com/pulumi/pulumi-minio/sdk/go/minio" +// "github.com/pulumi/pulumi-minio/sdk/v2/go/minio" // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" // // ) diff --git a/sdk/go/minio/iamGroup.go b/sdk/go/minio/iamGroup.go index 5aa2ce9..3cac139 100644 --- a/sdk/go/minio/iamGroup.go +++ b/sdk/go/minio/iamGroup.go @@ -7,7 +7,7 @@ import ( "context" "reflect" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) @@ -18,7 +18,7 @@ import ( // // import ( // -// "github.com/pulumi/pulumi-minio/sdk/go/minio" +// "github.com/pulumi/pulumi-minio/sdk/v2/go/minio" // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" // // ) diff --git a/sdk/go/minio/iamGroupMembership.go b/sdk/go/minio/iamGroupMembership.go index 3a953b8..a526de4 100644 --- a/sdk/go/minio/iamGroupMembership.go +++ b/sdk/go/minio/iamGroupMembership.go @@ -8,7 +8,7 @@ import ( "reflect" "errors" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) diff --git a/sdk/go/minio/iamGroupPolicy.go b/sdk/go/minio/iamGroupPolicy.go index a07b298..4f5bcc3 100644 --- a/sdk/go/minio/iamGroupPolicy.go +++ b/sdk/go/minio/iamGroupPolicy.go @@ -8,7 +8,7 @@ import ( "reflect" "errors" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) @@ -19,7 +19,7 @@ import ( // // import ( // -// "github.com/pulumi/pulumi-minio/sdk/go/minio" +// "github.com/pulumi/pulumi-minio/sdk/v2/go/minio" // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" // // ) diff --git a/sdk/go/minio/iamGroupPolicyAttachment.go b/sdk/go/minio/iamGroupPolicyAttachment.go index ddd1876..5268831 100644 --- a/sdk/go/minio/iamGroupPolicyAttachment.go +++ b/sdk/go/minio/iamGroupPolicyAttachment.go @@ -8,7 +8,7 @@ import ( "reflect" "errors" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) diff --git a/sdk/go/minio/iamGroupUserAttachment.go b/sdk/go/minio/iamGroupUserAttachment.go index 77d8e89..64ada91 100644 --- a/sdk/go/minio/iamGroupUserAttachment.go +++ b/sdk/go/minio/iamGroupUserAttachment.go @@ -8,7 +8,7 @@ import ( "reflect" "errors" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) @@ -19,7 +19,7 @@ import ( // // import ( // -// "github.com/pulumi/pulumi-minio/sdk/go/minio" +// "github.com/pulumi/pulumi-minio/sdk/v2/go/minio" // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" // // ) diff --git a/sdk/go/minio/iamPolicy.go b/sdk/go/minio/iamPolicy.go index 520d840..07fdca1 100644 --- a/sdk/go/minio/iamPolicy.go +++ b/sdk/go/minio/iamPolicy.go @@ -8,7 +8,7 @@ import ( "reflect" "errors" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) @@ -19,7 +19,7 @@ import ( // // import ( // -// "github.com/pulumi/pulumi-minio/sdk/go/minio" +// "github.com/pulumi/pulumi-minio/sdk/v2/go/minio" // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" // // ) diff --git a/sdk/go/minio/iamServiceAccount.go b/sdk/go/minio/iamServiceAccount.go index 5aeac26..22709d4 100644 --- a/sdk/go/minio/iamServiceAccount.go +++ b/sdk/go/minio/iamServiceAccount.go @@ -8,7 +8,7 @@ import ( "reflect" "errors" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) @@ -19,7 +19,7 @@ import ( // // import ( // -// "github.com/pulumi/pulumi-minio/sdk/go/minio" +// "github.com/pulumi/pulumi-minio/sdk/v2/go/minio" // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" // // ) diff --git a/sdk/go/minio/iamUser.go b/sdk/go/minio/iamUser.go index ce40863..be769c5 100644 --- a/sdk/go/minio/iamUser.go +++ b/sdk/go/minio/iamUser.go @@ -7,7 +7,7 @@ import ( "context" "reflect" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) @@ -18,7 +18,7 @@ import ( // // import ( // -// "github.com/pulumi/pulumi-minio/sdk/go/minio" +// "github.com/pulumi/pulumi-minio/sdk/v2/go/minio" // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" // // ) diff --git a/sdk/go/minio/iamUserPolicyAttachment.go b/sdk/go/minio/iamUserPolicyAttachment.go index 7f82a4f..9fc8e70 100644 --- a/sdk/go/minio/iamUserPolicyAttachment.go +++ b/sdk/go/minio/iamUserPolicyAttachment.go @@ -8,7 +8,7 @@ import ( "reflect" "errors" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) @@ -19,7 +19,7 @@ import ( // // import ( // -// "github.com/pulumi/pulumi-minio/sdk/go/minio" +// "github.com/pulumi/pulumi-minio/sdk/v2/go/minio" // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" // // ) diff --git a/sdk/go/minio/ilmPolicy.go b/sdk/go/minio/ilmPolicy.go index 8259480..79ab16d 100644 --- a/sdk/go/minio/ilmPolicy.go +++ b/sdk/go/minio/ilmPolicy.go @@ -8,7 +8,7 @@ import ( "reflect" "errors" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) @@ -21,7 +21,7 @@ import ( // // import ( // -// "github.com/pulumi/pulumi-minio/sdk/go/minio" +// "github.com/pulumi/pulumi-minio/sdk/v2/go/minio" // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" // // ) diff --git a/sdk/go/minio/init.go b/sdk/go/minio/init.go index d66b434..9f29603 100644 --- a/sdk/go/minio/init.go +++ b/sdk/go/minio/init.go @@ -7,7 +7,7 @@ import ( "fmt" "github.com/blang/semver" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) @@ -49,6 +49,8 @@ func (m *module) Construct(ctx *pulumi.Context, name, typ, urn string) (r pulumi r = &S3BucketNotification{} case "minio:index/s3BucketPolicy:S3BucketPolicy": r = &S3BucketPolicy{} + case "minio:index/s3BucketReplication:S3BucketReplication": + r = &S3BucketReplication{} case "minio:index/s3BucketServerSideEncryption:S3BucketServerSideEncryption": r = &S3BucketServerSideEncryption{} case "minio:index/s3BucketVersioning:S3BucketVersioning": @@ -156,6 +158,11 @@ func init() { "index/s3BucketPolicy", &module{version}, ) + pulumi.RegisterResourceModule( + "minio", + "index/s3BucketReplication", + &module{version}, + ) pulumi.RegisterResourceModule( "minio", "index/s3BucketServerSideEncryption", diff --git a/sdk/go/minio/kmsKey.go b/sdk/go/minio/kmsKey.go index 6cdbb57..01ebcd3 100644 --- a/sdk/go/minio/kmsKey.go +++ b/sdk/go/minio/kmsKey.go @@ -8,7 +8,7 @@ import ( "reflect" "errors" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) diff --git a/sdk/go/minio/provider.go b/sdk/go/minio/provider.go index 255fcea..d7bf294 100644 --- a/sdk/go/minio/provider.go +++ b/sdk/go/minio/provider.go @@ -8,7 +8,7 @@ import ( "reflect" "errors" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) diff --git a/sdk/go/minio/pulumiTypes.go b/sdk/go/minio/pulumiTypes.go index b7bc8b8..fb078f8 100644 --- a/sdk/go/minio/pulumiTypes.go +++ b/sdk/go/minio/pulumiTypes.go @@ -7,7 +7,7 @@ import ( "context" "reflect" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) @@ -261,6 +261,350 @@ func (o S3BucketNotificationQueueArrayOutput) Index(i pulumi.IntInput) S3BucketN }).(S3BucketNotificationQueueOutput) } +type S3BucketReplicationRule struct { + // Rule ARN genrated by MinIO + Arn *string `pulumi:"arn"` + // Whether or not to synchronise marker deletion + DeleteMarkerReplication *bool `pulumi:"deleteMarkerReplication"` + // Whether or not to propagate deletion + DeleteReplication *bool `pulumi:"deleteReplication"` + // Whether or not this rule is enabled + Enabled *bool `pulumi:"enabled"` + // Whether or not to synchronise object created prior the replication configuration + ExistingObjectReplication *bool `pulumi:"existingObjectReplication"` + // Rule ID generated by MinIO + Id *string `pulumi:"id"` + // Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + MetadataSync *bool `pulumi:"metadataSync"` + // Bucket prefix object must be in to be syncronised + Prefix *string `pulumi:"prefix"` + // Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + Priority *int `pulumi:"priority"` + // Tags which objects must have to be syncronised + Tags map[string]interface{} `pulumi:"tags"` + // Bucket prefix + Target S3BucketReplicationRuleTarget `pulumi:"target"` +} + +// S3BucketReplicationRuleInput is an input type that accepts S3BucketReplicationRuleArgs and S3BucketReplicationRuleOutput values. +// You can construct a concrete instance of `S3BucketReplicationRuleInput` via: +// +// S3BucketReplicationRuleArgs{...} +type S3BucketReplicationRuleInput interface { + pulumi.Input + + ToS3BucketReplicationRuleOutput() S3BucketReplicationRuleOutput + ToS3BucketReplicationRuleOutputWithContext(context.Context) S3BucketReplicationRuleOutput +} + +type S3BucketReplicationRuleArgs struct { + // Rule ARN genrated by MinIO + Arn pulumi.StringPtrInput `pulumi:"arn"` + // Whether or not to synchronise marker deletion + DeleteMarkerReplication pulumi.BoolPtrInput `pulumi:"deleteMarkerReplication"` + // Whether or not to propagate deletion + DeleteReplication pulumi.BoolPtrInput `pulumi:"deleteReplication"` + // Whether or not this rule is enabled + Enabled pulumi.BoolPtrInput `pulumi:"enabled"` + // Whether or not to synchronise object created prior the replication configuration + ExistingObjectReplication pulumi.BoolPtrInput `pulumi:"existingObjectReplication"` + // Rule ID generated by MinIO + Id pulumi.StringPtrInput `pulumi:"id"` + // Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + MetadataSync pulumi.BoolPtrInput `pulumi:"metadataSync"` + // Bucket prefix object must be in to be syncronised + Prefix pulumi.StringPtrInput `pulumi:"prefix"` + // Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + Priority pulumi.IntPtrInput `pulumi:"priority"` + // Tags which objects must have to be syncronised + Tags pulumi.MapInput `pulumi:"tags"` + // Bucket prefix + Target S3BucketReplicationRuleTargetInput `pulumi:"target"` +} + +func (S3BucketReplicationRuleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*S3BucketReplicationRule)(nil)).Elem() +} + +func (i S3BucketReplicationRuleArgs) ToS3BucketReplicationRuleOutput() S3BucketReplicationRuleOutput { + return i.ToS3BucketReplicationRuleOutputWithContext(context.Background()) +} + +func (i S3BucketReplicationRuleArgs) ToS3BucketReplicationRuleOutputWithContext(ctx context.Context) S3BucketReplicationRuleOutput { + return pulumi.ToOutputWithContext(ctx, i).(S3BucketReplicationRuleOutput) +} + +// S3BucketReplicationRuleArrayInput is an input type that accepts S3BucketReplicationRuleArray and S3BucketReplicationRuleArrayOutput values. +// You can construct a concrete instance of `S3BucketReplicationRuleArrayInput` via: +// +// S3BucketReplicationRuleArray{ S3BucketReplicationRuleArgs{...} } +type S3BucketReplicationRuleArrayInput interface { + pulumi.Input + + ToS3BucketReplicationRuleArrayOutput() S3BucketReplicationRuleArrayOutput + ToS3BucketReplicationRuleArrayOutputWithContext(context.Context) S3BucketReplicationRuleArrayOutput +} + +type S3BucketReplicationRuleArray []S3BucketReplicationRuleInput + +func (S3BucketReplicationRuleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]S3BucketReplicationRule)(nil)).Elem() +} + +func (i S3BucketReplicationRuleArray) ToS3BucketReplicationRuleArrayOutput() S3BucketReplicationRuleArrayOutput { + return i.ToS3BucketReplicationRuleArrayOutputWithContext(context.Background()) +} + +func (i S3BucketReplicationRuleArray) ToS3BucketReplicationRuleArrayOutputWithContext(ctx context.Context) S3BucketReplicationRuleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(S3BucketReplicationRuleArrayOutput) +} + +type S3BucketReplicationRuleOutput struct{ *pulumi.OutputState } + +func (S3BucketReplicationRuleOutput) ElementType() reflect.Type { + return reflect.TypeOf((*S3BucketReplicationRule)(nil)).Elem() +} + +func (o S3BucketReplicationRuleOutput) ToS3BucketReplicationRuleOutput() S3BucketReplicationRuleOutput { + return o +} + +func (o S3BucketReplicationRuleOutput) ToS3BucketReplicationRuleOutputWithContext(ctx context.Context) S3BucketReplicationRuleOutput { + return o +} + +// Rule ARN genrated by MinIO +func (o S3BucketReplicationRuleOutput) Arn() pulumi.StringPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRule) *string { return v.Arn }).(pulumi.StringPtrOutput) +} + +// Whether or not to synchronise marker deletion +func (o S3BucketReplicationRuleOutput) DeleteMarkerReplication() pulumi.BoolPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRule) *bool { return v.DeleteMarkerReplication }).(pulumi.BoolPtrOutput) +} + +// Whether or not to propagate deletion +func (o S3BucketReplicationRuleOutput) DeleteReplication() pulumi.BoolPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRule) *bool { return v.DeleteReplication }).(pulumi.BoolPtrOutput) +} + +// Whether or not this rule is enabled +func (o S3BucketReplicationRuleOutput) Enabled() pulumi.BoolPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRule) *bool { return v.Enabled }).(pulumi.BoolPtrOutput) +} + +// Whether or not to synchronise object created prior the replication configuration +func (o S3BucketReplicationRuleOutput) ExistingObjectReplication() pulumi.BoolPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRule) *bool { return v.ExistingObjectReplication }).(pulumi.BoolPtrOutput) +} + +// Rule ID generated by MinIO +func (o S3BucketReplicationRuleOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRule) *string { return v.Id }).(pulumi.StringPtrOutput) +} + +// Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication +func (o S3BucketReplicationRuleOutput) MetadataSync() pulumi.BoolPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRule) *bool { return v.MetadataSync }).(pulumi.BoolPtrOutput) +} + +// Bucket prefix object must be in to be syncronised +func (o S3BucketReplicationRuleOutput) Prefix() pulumi.StringPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRule) *string { return v.Prefix }).(pulumi.StringPtrOutput) +} + +// Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority +func (o S3BucketReplicationRuleOutput) Priority() pulumi.IntPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRule) *int { return v.Priority }).(pulumi.IntPtrOutput) +} + +// Tags which objects must have to be syncronised +func (o S3BucketReplicationRuleOutput) Tags() pulumi.MapOutput { + return o.ApplyT(func(v S3BucketReplicationRule) map[string]interface{} { return v.Tags }).(pulumi.MapOutput) +} + +// Bucket prefix +func (o S3BucketReplicationRuleOutput) Target() S3BucketReplicationRuleTargetOutput { + return o.ApplyT(func(v S3BucketReplicationRule) S3BucketReplicationRuleTarget { return v.Target }).(S3BucketReplicationRuleTargetOutput) +} + +type S3BucketReplicationRuleArrayOutput struct{ *pulumi.OutputState } + +func (S3BucketReplicationRuleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]S3BucketReplicationRule)(nil)).Elem() +} + +func (o S3BucketReplicationRuleArrayOutput) ToS3BucketReplicationRuleArrayOutput() S3BucketReplicationRuleArrayOutput { + return o +} + +func (o S3BucketReplicationRuleArrayOutput) ToS3BucketReplicationRuleArrayOutputWithContext(ctx context.Context) S3BucketReplicationRuleArrayOutput { + return o +} + +func (o S3BucketReplicationRuleArrayOutput) Index(i pulumi.IntInput) S3BucketReplicationRuleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) S3BucketReplicationRule { + return vs[0].([]S3BucketReplicationRule)[vs[1].(int)] + }).(S3BucketReplicationRuleOutput) +} + +type S3BucketReplicationRuleTarget struct { + // Access key for the replication service account in the target MinIO + AccessKey string `pulumi:"accessKey"` + // Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + BandwidthLimt *string `pulumi:"bandwidthLimt"` + // The name of the existing target bucket to replicate into + Bucket string `pulumi:"bucket"` + // Disable proxy for this target + DisableProxy *bool `pulumi:"disableProxy"` + // Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + HealthCheckPeriod *string `pulumi:"healthCheckPeriod"` + // The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + Host string `pulumi:"host"` + // Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + Path *string `pulumi:"path"` + // Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + PathStyle *string `pulumi:"pathStyle"` + // Region of the target MinIO. This will be used to generate the target ARN + Region *string `pulumi:"region"` + // Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + SecretKey *string `pulumi:"secretKey"` + Secure *bool `pulumi:"secure"` + // The storage class to use for the object on this target + StorageClass *string `pulumi:"storageClass"` + // Use synchronous replication. + Syncronous *bool `pulumi:"syncronous"` +} + +// S3BucketReplicationRuleTargetInput is an input type that accepts S3BucketReplicationRuleTargetArgs and S3BucketReplicationRuleTargetOutput values. +// You can construct a concrete instance of `S3BucketReplicationRuleTargetInput` via: +// +// S3BucketReplicationRuleTargetArgs{...} +type S3BucketReplicationRuleTargetInput interface { + pulumi.Input + + ToS3BucketReplicationRuleTargetOutput() S3BucketReplicationRuleTargetOutput + ToS3BucketReplicationRuleTargetOutputWithContext(context.Context) S3BucketReplicationRuleTargetOutput +} + +type S3BucketReplicationRuleTargetArgs struct { + // Access key for the replication service account in the target MinIO + AccessKey pulumi.StringInput `pulumi:"accessKey"` + // Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + BandwidthLimt pulumi.StringPtrInput `pulumi:"bandwidthLimt"` + // The name of the existing target bucket to replicate into + Bucket pulumi.StringInput `pulumi:"bucket"` + // Disable proxy for this target + DisableProxy pulumi.BoolPtrInput `pulumi:"disableProxy"` + // Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + HealthCheckPeriod pulumi.StringPtrInput `pulumi:"healthCheckPeriod"` + // The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + Host pulumi.StringInput `pulumi:"host"` + // Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + Path pulumi.StringPtrInput `pulumi:"path"` + // Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + PathStyle pulumi.StringPtrInput `pulumi:"pathStyle"` + // Region of the target MinIO. This will be used to generate the target ARN + Region pulumi.StringPtrInput `pulumi:"region"` + // Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + SecretKey pulumi.StringPtrInput `pulumi:"secretKey"` + Secure pulumi.BoolPtrInput `pulumi:"secure"` + // The storage class to use for the object on this target + StorageClass pulumi.StringPtrInput `pulumi:"storageClass"` + // Use synchronous replication. + Syncronous pulumi.BoolPtrInput `pulumi:"syncronous"` +} + +func (S3BucketReplicationRuleTargetArgs) ElementType() reflect.Type { + return reflect.TypeOf((*S3BucketReplicationRuleTarget)(nil)).Elem() +} + +func (i S3BucketReplicationRuleTargetArgs) ToS3BucketReplicationRuleTargetOutput() S3BucketReplicationRuleTargetOutput { + return i.ToS3BucketReplicationRuleTargetOutputWithContext(context.Background()) +} + +func (i S3BucketReplicationRuleTargetArgs) ToS3BucketReplicationRuleTargetOutputWithContext(ctx context.Context) S3BucketReplicationRuleTargetOutput { + return pulumi.ToOutputWithContext(ctx, i).(S3BucketReplicationRuleTargetOutput) +} + +type S3BucketReplicationRuleTargetOutput struct{ *pulumi.OutputState } + +func (S3BucketReplicationRuleTargetOutput) ElementType() reflect.Type { + return reflect.TypeOf((*S3BucketReplicationRuleTarget)(nil)).Elem() +} + +func (o S3BucketReplicationRuleTargetOutput) ToS3BucketReplicationRuleTargetOutput() S3BucketReplicationRuleTargetOutput { + return o +} + +func (o S3BucketReplicationRuleTargetOutput) ToS3BucketReplicationRuleTargetOutputWithContext(ctx context.Context) S3BucketReplicationRuleTargetOutput { + return o +} + +// Access key for the replication service account in the target MinIO +func (o S3BucketReplicationRuleTargetOutput) AccessKey() pulumi.StringOutput { + return o.ApplyT(func(v S3BucketReplicationRuleTarget) string { return v.AccessKey }).(pulumi.StringOutput) +} + +// Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB +func (o S3BucketReplicationRuleTargetOutput) BandwidthLimt() pulumi.StringPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRuleTarget) *string { return v.BandwidthLimt }).(pulumi.StringPtrOutput) +} + +// The name of the existing target bucket to replicate into +func (o S3BucketReplicationRuleTargetOutput) Bucket() pulumi.StringOutput { + return o.ApplyT(func(v S3BucketReplicationRuleTarget) string { return v.Bucket }).(pulumi.StringOutput) +} + +// Disable proxy for this target +func (o S3BucketReplicationRuleTargetOutput) DisableProxy() pulumi.BoolPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRuleTarget) *bool { return v.DisableProxy }).(pulumi.BoolPtrOutput) +} + +// Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` +func (o S3BucketReplicationRuleTargetOutput) HealthCheckPeriod() pulumi.StringPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRuleTarget) *string { return v.HealthCheckPeriod }).(pulumi.StringPtrOutput) +} + +// The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself +func (o S3BucketReplicationRuleTargetOutput) Host() pulumi.StringOutput { + return o.ApplyT(func(v S3BucketReplicationRuleTarget) string { return v.Host }).(pulumi.StringOutput) +} + +// Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` +func (o S3BucketReplicationRuleTargetOutput) Path() pulumi.StringPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRuleTarget) *string { return v.Path }).(pulumi.StringPtrOutput) +} + +// Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` +func (o S3BucketReplicationRuleTargetOutput) PathStyle() pulumi.StringPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRuleTarget) *string { return v.PathStyle }).(pulumi.StringPtrOutput) +} + +// Region of the target MinIO. This will be used to generate the target ARN +func (o S3BucketReplicationRuleTargetOutput) Region() pulumi.StringPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRuleTarget) *string { return v.Region }).(pulumi.StringPtrOutput) +} + +// Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update +func (o S3BucketReplicationRuleTargetOutput) SecretKey() pulumi.StringPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRuleTarget) *string { return v.SecretKey }).(pulumi.StringPtrOutput) +} + +func (o S3BucketReplicationRuleTargetOutput) Secure() pulumi.BoolPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRuleTarget) *bool { return v.Secure }).(pulumi.BoolPtrOutput) +} + +// The storage class to use for the object on this target +func (o S3BucketReplicationRuleTargetOutput) StorageClass() pulumi.StringPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRuleTarget) *string { return v.StorageClass }).(pulumi.StringPtrOutput) +} + +// Use synchronous replication. +func (o S3BucketReplicationRuleTargetOutput) Syncronous() pulumi.BoolPtrOutput { + return o.ApplyT(func(v S3BucketReplicationRuleTarget) *bool { return v.Syncronous }).(pulumi.BoolPtrOutput) +} + type S3BucketVersioningVersioningConfiguration struct { ExcludeFolders *bool `pulumi:"excludeFolders"` ExcludedPrefixes []string `pulumi:"excludedPrefixes"` @@ -659,6 +1003,9 @@ func init() { pulumi.RegisterInputType(reflect.TypeOf((*IlmPolicyRuleArrayInput)(nil)).Elem(), IlmPolicyRuleArray{}) pulumi.RegisterInputType(reflect.TypeOf((*S3BucketNotificationQueueInput)(nil)).Elem(), S3BucketNotificationQueueArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*S3BucketNotificationQueueArrayInput)(nil)).Elem(), S3BucketNotificationQueueArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*S3BucketReplicationRuleInput)(nil)).Elem(), S3BucketReplicationRuleArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*S3BucketReplicationRuleArrayInput)(nil)).Elem(), S3BucketReplicationRuleArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*S3BucketReplicationRuleTargetInput)(nil)).Elem(), S3BucketReplicationRuleTargetArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*S3BucketVersioningVersioningConfigurationInput)(nil)).Elem(), S3BucketVersioningVersioningConfigurationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*S3BucketVersioningVersioningConfigurationPtrInput)(nil)).Elem(), S3BucketVersioningVersioningConfigurationArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*GetIamPolicyDocumentStatementInput)(nil)).Elem(), GetIamPolicyDocumentStatementArgs{}) @@ -669,6 +1016,9 @@ func init() { pulumi.RegisterOutputType(IlmPolicyRuleArrayOutput{}) pulumi.RegisterOutputType(S3BucketNotificationQueueOutput{}) pulumi.RegisterOutputType(S3BucketNotificationQueueArrayOutput{}) + pulumi.RegisterOutputType(S3BucketReplicationRuleOutput{}) + pulumi.RegisterOutputType(S3BucketReplicationRuleArrayOutput{}) + pulumi.RegisterOutputType(S3BucketReplicationRuleTargetOutput{}) pulumi.RegisterOutputType(S3BucketVersioningVersioningConfigurationOutput{}) pulumi.RegisterOutputType(S3BucketVersioningVersioningConfigurationPtrOutput{}) pulumi.RegisterOutputType(GetIamPolicyDocumentStatementOutput{}) diff --git a/sdk/go/minio/s3bucket.go b/sdk/go/minio/s3bucket.go index 39ac0c4..b2f0284 100644 --- a/sdk/go/minio/s3bucket.go +++ b/sdk/go/minio/s3bucket.go @@ -7,7 +7,7 @@ import ( "context" "reflect" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) @@ -18,7 +18,7 @@ import ( // // import ( // -// "github.com/pulumi/pulumi-minio/sdk/go/minio" +// "github.com/pulumi/pulumi-minio/sdk/v2/go/minio" // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" // // ) diff --git a/sdk/go/minio/s3bucketNotification.go b/sdk/go/minio/s3bucketNotification.go index 4c9dd45..670f2b4 100644 --- a/sdk/go/minio/s3bucketNotification.go +++ b/sdk/go/minio/s3bucketNotification.go @@ -8,7 +8,7 @@ import ( "reflect" "errors" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) diff --git a/sdk/go/minio/s3bucketPolicy.go b/sdk/go/minio/s3bucketPolicy.go index 1295eca..492decc 100644 --- a/sdk/go/minio/s3bucketPolicy.go +++ b/sdk/go/minio/s3bucketPolicy.go @@ -8,7 +8,7 @@ import ( "reflect" "errors" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) diff --git a/sdk/go/minio/s3bucketReplication.go b/sdk/go/minio/s3bucketReplication.go new file mode 100644 index 0000000..8103d56 --- /dev/null +++ b/sdk/go/minio/s3bucketReplication.go @@ -0,0 +1,441 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package minio + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi-minio/sdk/v2/go/minio" +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// myBucketInAS3Bucket, err := minio.NewS3Bucket(ctx, "myBucketInAS3Bucket", &minio.S3BucketArgs{ +// Bucket: pulumi.String("my-bucket"), +// }) +// if err != nil { +// return err +// } +// myBucketInBS3Bucket, err := minio.NewS3Bucket(ctx, "myBucketInBS3Bucket", &minio.S3BucketArgs{ +// Bucket: pulumi.String("my-bucket"), +// }, pulumi.Provider(minio.Deployment_b)) +// if err != nil { +// return err +// } +// myBucketInAS3BucketVersioning, err := minio.NewS3BucketVersioning(ctx, "myBucketInAS3BucketVersioning", &minio.S3BucketVersioningArgs{ +// Bucket: myBucketInAS3Bucket.Bucket, +// VersioningConfiguration: &minio.S3BucketVersioningVersioningConfigurationArgs{ +// Status: pulumi.String("Enabled"), +// }, +// }) +// if err != nil { +// return err +// } +// myBucketInBS3BucketVersioning, err := minio.NewS3BucketVersioning(ctx, "myBucketInBS3BucketVersioning", &minio.S3BucketVersioningArgs{ +// Bucket: myBucketInBS3Bucket.Bucket, +// VersioningConfiguration: &minio.S3BucketVersioningVersioningConfigurationArgs{ +// Status: pulumi.String("Enabled"), +// }, +// }, pulumi.Provider(minio.Deployment_b)) +// if err != nil { +// return err +// } +// replicationPolicy, err := minio.GetIamPolicyDocument(ctx, &minio.GetIamPolicyDocumentArgs{ +// Statements: []minio.GetIamPolicyDocumentStatement{ +// { +// Sid: pulumi.StringRef("ReadBuckets"), +// Effect: pulumi.StringRef("Allow"), +// Resources: []string{ +// "arn:aws:s3:::*", +// }, +// Actions: []string{ +// "s3:ListBucket", +// }, +// }, +// { +// Sid: pulumi.StringRef("EnableReplicationOnBucket"), +// Effect: pulumi.StringRef("Allow"), +// Resources: []string{ +// "arn:aws:s3:::my-bucket", +// }, +// Actions: []string{ +// "s3:GetReplicationConfiguration", +// "s3:ListBucket", +// "s3:ListBucketMultipartUploads", +// "s3:GetBucketLocation", +// "s3:GetBucketVersioning", +// "s3:GetBucketObjectLockConfiguration", +// "s3:GetEncryptionConfiguration", +// }, +// }, +// { +// Sid: pulumi.StringRef("EnableReplicatingDataIntoBucket"), +// Effect: pulumi.StringRef("Allow"), +// Resources: []string{ +// "arn:aws:s3:::my-bucket/*", +// }, +// Actions: []string{ +// "s3:GetReplicationConfiguration", +// "s3:ReplicateTags", +// "s3:AbortMultipartUpload", +// "s3:GetObject", +// "s3:GetObjectVersion", +// "s3:GetObjectVersionTagging", +// "s3:PutObject", +// "s3:PutObjectRetention", +// "s3:PutBucketObjectLockConfiguration", +// "s3:PutObjectLegalHold", +// "s3:DeleteObject", +// "s3:ReplicateObject", +// "s3:ReplicateDelete", +// }, +// }, +// }, +// }, nil) +// if err != nil { +// return err +// } +// replicationInBIamPolicy, err := minio.NewIamPolicy(ctx, "replicationInBIamPolicy", &minio.IamPolicyArgs{ +// Policy: *pulumi.String(replicationPolicy.Json), +// }, pulumi.Provider(minio.Deployment_b)) +// if err != nil { +// return err +// } +// replicationInBIamUser, err := minio.NewIamUser(ctx, "replicationInBIamUser", &minio.IamUserArgs{ +// ForceDestroy: pulumi.Bool(true), +// }, pulumi.Provider(minio.Deployment_b)) +// if err != nil { +// return err +// } +// replicationInBIamUserPolicyAttachment, err := minio.NewIamUserPolicyAttachment(ctx, "replicationInBIamUserPolicyAttachment", &minio.IamUserPolicyAttachmentArgs{ +// UserName: replicationInBIamUser.Name, +// PolicyName: replicationInBIamPolicy.ID(), +// }, pulumi.Provider(minio.Deployment_b)) +// if err != nil { +// return err +// } +// replicationInBIamServiceAccount, err := minio.NewIamServiceAccount(ctx, "replicationInBIamServiceAccount", &minio.IamServiceAccountArgs{ +// TargetUser: replicationInBIamUser.Name, +// }, pulumi.Provider(minio.Deployment_b), pulumi.DependsOn([]pulumi.Resource{ +// replicationInBIamUserPolicyAttachment, +// })) +// if err != nil { +// return err +// } +// _, err = minio.NewS3BucketReplication(ctx, "replicationInBS3BucketReplication", &minio.S3BucketReplicationArgs{ +// Bucket: myBucketInAS3Bucket.Bucket, +// Rules: minio.S3BucketReplicationRuleArray{ +// &minio.S3BucketReplicationRuleArgs{ +// DeleteReplication: pulumi.Bool(true), +// DeleteMarkerReplication: pulumi.Bool(true), +// ExistingObjectReplication: pulumi.Bool(true), +// MetadataSync: pulumi.Bool(true), +// Target: &minio.S3BucketReplicationRuleTargetArgs{ +// Bucket: myBucketInBS3Bucket.Bucket, +// Secure: pulumi.Bool(false), +// Host: pulumi.Any(_var.Minio_server_b), +// BandwidthLimt: pulumi.String("100M"), +// AccessKey: replicationInBIamServiceAccount.AccessKey, +// SecretKey: replicationInBIamServiceAccount.SecretKey, +// }, +// }, +// }, +// }, pulumi.DependsOn([]pulumi.Resource{ +// myBucketInAS3BucketVersioning, +// myBucketInBS3BucketVersioning, +// })) +// if err != nil { +// return err +// } +// replicationInAIamPolicy, err := minio.NewIamPolicy(ctx, "replicationInAIamPolicy", &minio.IamPolicyArgs{ +// Policy: *pulumi.String(replicationPolicy.Json), +// }) +// if err != nil { +// return err +// } +// replicationInAIamUser, err := minio.NewIamUser(ctx, "replicationInAIamUser", &minio.IamUserArgs{ +// ForceDestroy: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// _, err = minio.NewIamUserPolicyAttachment(ctx, "replicationInAIamUserPolicyAttachment", &minio.IamUserPolicyAttachmentArgs{ +// UserName: replicationInAIamUser.Name, +// PolicyName: replicationInAIamPolicy.ID(), +// }) +// if err != nil { +// return err +// } +// replicationInAIamServiceAccount, err := minio.NewIamServiceAccount(ctx, "replicationInAIamServiceAccount", &minio.IamServiceAccountArgs{ +// TargetUser: replicationInAIamUser.Name, +// }, pulumi.DependsOn([]pulumi.Resource{ +// replicationInBIamUserPolicyAttachment, +// })) +// if err != nil { +// return err +// } +// _, err = minio.NewS3BucketReplication(ctx, "replicationInAS3BucketReplication", &minio.S3BucketReplicationArgs{ +// Bucket: myBucketInBS3Bucket.Bucket, +// Rules: minio.S3BucketReplicationRuleArray{ +// &minio.S3BucketReplicationRuleArgs{ +// DeleteReplication: pulumi.Bool(true), +// DeleteMarkerReplication: pulumi.Bool(true), +// ExistingObjectReplication: pulumi.Bool(true), +// MetadataSync: pulumi.Bool(true), +// Target: &minio.S3BucketReplicationRuleTargetArgs{ +// Bucket: myBucketInAS3Bucket.Bucket, +// Host: pulumi.Any(_var.Minio_server_a), +// Secure: pulumi.Bool(false), +// BandwidthLimt: pulumi.String("100M"), +// AccessKey: replicationInAIamServiceAccount.AccessKey, +// SecretKey: replicationInAIamServiceAccount.SecretKey, +// }, +// }, +// }, +// }, pulumi.Provider(minio.Deployment_b), pulumi.DependsOn([]pulumi.Resource{ +// myBucketInAS3BucketVersioning, +// myBucketInBS3BucketVersioning, +// })) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +type S3BucketReplication struct { + pulumi.CustomResourceState + + // The name of the existing target bucket to replicate into + Bucket pulumi.StringOutput `pulumi:"bucket"` + // Rule definitions + Rules S3BucketReplicationRuleArrayOutput `pulumi:"rules"` +} + +// NewS3BucketReplication registers a new resource with the given unique name, arguments, and options. +func NewS3BucketReplication(ctx *pulumi.Context, + name string, args *S3BucketReplicationArgs, opts ...pulumi.ResourceOption) (*S3BucketReplication, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Bucket == nil { + return nil, errors.New("invalid value for required argument 'Bucket'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource S3BucketReplication + err := ctx.RegisterResource("minio:index/s3BucketReplication:S3BucketReplication", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetS3BucketReplication gets an existing S3BucketReplication resource's state with the given name, ID, and optional +// state properties that are used to uniquely qualify the lookup (nil if not required). +func GetS3BucketReplication(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *S3BucketReplicationState, opts ...pulumi.ResourceOption) (*S3BucketReplication, error) { + var resource S3BucketReplication + err := ctx.ReadResource("minio:index/s3BucketReplication:S3BucketReplication", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering S3BucketReplication resources. +type s3bucketReplicationState struct { + // The name of the existing target bucket to replicate into + Bucket *string `pulumi:"bucket"` + // Rule definitions + Rules []S3BucketReplicationRule `pulumi:"rules"` +} + +type S3BucketReplicationState struct { + // The name of the existing target bucket to replicate into + Bucket pulumi.StringPtrInput + // Rule definitions + Rules S3BucketReplicationRuleArrayInput +} + +func (S3BucketReplicationState) ElementType() reflect.Type { + return reflect.TypeOf((*s3bucketReplicationState)(nil)).Elem() +} + +type s3bucketReplicationArgs struct { + // The name of the existing target bucket to replicate into + Bucket string `pulumi:"bucket"` + // Rule definitions + Rules []S3BucketReplicationRule `pulumi:"rules"` +} + +// The set of arguments for constructing a S3BucketReplication resource. +type S3BucketReplicationArgs struct { + // The name of the existing target bucket to replicate into + Bucket pulumi.StringInput + // Rule definitions + Rules S3BucketReplicationRuleArrayInput +} + +func (S3BucketReplicationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*s3bucketReplicationArgs)(nil)).Elem() +} + +type S3BucketReplicationInput interface { + pulumi.Input + + ToS3BucketReplicationOutput() S3BucketReplicationOutput + ToS3BucketReplicationOutputWithContext(ctx context.Context) S3BucketReplicationOutput +} + +func (*S3BucketReplication) ElementType() reflect.Type { + return reflect.TypeOf((**S3BucketReplication)(nil)).Elem() +} + +func (i *S3BucketReplication) ToS3BucketReplicationOutput() S3BucketReplicationOutput { + return i.ToS3BucketReplicationOutputWithContext(context.Background()) +} + +func (i *S3BucketReplication) ToS3BucketReplicationOutputWithContext(ctx context.Context) S3BucketReplicationOutput { + return pulumi.ToOutputWithContext(ctx, i).(S3BucketReplicationOutput) +} + +// S3BucketReplicationArrayInput is an input type that accepts S3BucketReplicationArray and S3BucketReplicationArrayOutput values. +// You can construct a concrete instance of `S3BucketReplicationArrayInput` via: +// +// S3BucketReplicationArray{ S3BucketReplicationArgs{...} } +type S3BucketReplicationArrayInput interface { + pulumi.Input + + ToS3BucketReplicationArrayOutput() S3BucketReplicationArrayOutput + ToS3BucketReplicationArrayOutputWithContext(context.Context) S3BucketReplicationArrayOutput +} + +type S3BucketReplicationArray []S3BucketReplicationInput + +func (S3BucketReplicationArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*S3BucketReplication)(nil)).Elem() +} + +func (i S3BucketReplicationArray) ToS3BucketReplicationArrayOutput() S3BucketReplicationArrayOutput { + return i.ToS3BucketReplicationArrayOutputWithContext(context.Background()) +} + +func (i S3BucketReplicationArray) ToS3BucketReplicationArrayOutputWithContext(ctx context.Context) S3BucketReplicationArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(S3BucketReplicationArrayOutput) +} + +// S3BucketReplicationMapInput is an input type that accepts S3BucketReplicationMap and S3BucketReplicationMapOutput values. +// You can construct a concrete instance of `S3BucketReplicationMapInput` via: +// +// S3BucketReplicationMap{ "key": S3BucketReplicationArgs{...} } +type S3BucketReplicationMapInput interface { + pulumi.Input + + ToS3BucketReplicationMapOutput() S3BucketReplicationMapOutput + ToS3BucketReplicationMapOutputWithContext(context.Context) S3BucketReplicationMapOutput +} + +type S3BucketReplicationMap map[string]S3BucketReplicationInput + +func (S3BucketReplicationMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*S3BucketReplication)(nil)).Elem() +} + +func (i S3BucketReplicationMap) ToS3BucketReplicationMapOutput() S3BucketReplicationMapOutput { + return i.ToS3BucketReplicationMapOutputWithContext(context.Background()) +} + +func (i S3BucketReplicationMap) ToS3BucketReplicationMapOutputWithContext(ctx context.Context) S3BucketReplicationMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(S3BucketReplicationMapOutput) +} + +type S3BucketReplicationOutput struct{ *pulumi.OutputState } + +func (S3BucketReplicationOutput) ElementType() reflect.Type { + return reflect.TypeOf((**S3BucketReplication)(nil)).Elem() +} + +func (o S3BucketReplicationOutput) ToS3BucketReplicationOutput() S3BucketReplicationOutput { + return o +} + +func (o S3BucketReplicationOutput) ToS3BucketReplicationOutputWithContext(ctx context.Context) S3BucketReplicationOutput { + return o +} + +// The name of the existing target bucket to replicate into +func (o S3BucketReplicationOutput) Bucket() pulumi.StringOutput { + return o.ApplyT(func(v *S3BucketReplication) pulumi.StringOutput { return v.Bucket }).(pulumi.StringOutput) +} + +// Rule definitions +func (o S3BucketReplicationOutput) Rules() S3BucketReplicationRuleArrayOutput { + return o.ApplyT(func(v *S3BucketReplication) S3BucketReplicationRuleArrayOutput { return v.Rules }).(S3BucketReplicationRuleArrayOutput) +} + +type S3BucketReplicationArrayOutput struct{ *pulumi.OutputState } + +func (S3BucketReplicationArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*S3BucketReplication)(nil)).Elem() +} + +func (o S3BucketReplicationArrayOutput) ToS3BucketReplicationArrayOutput() S3BucketReplicationArrayOutput { + return o +} + +func (o S3BucketReplicationArrayOutput) ToS3BucketReplicationArrayOutputWithContext(ctx context.Context) S3BucketReplicationArrayOutput { + return o +} + +func (o S3BucketReplicationArrayOutput) Index(i pulumi.IntInput) S3BucketReplicationOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *S3BucketReplication { + return vs[0].([]*S3BucketReplication)[vs[1].(int)] + }).(S3BucketReplicationOutput) +} + +type S3BucketReplicationMapOutput struct{ *pulumi.OutputState } + +func (S3BucketReplicationMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*S3BucketReplication)(nil)).Elem() +} + +func (o S3BucketReplicationMapOutput) ToS3BucketReplicationMapOutput() S3BucketReplicationMapOutput { + return o +} + +func (o S3BucketReplicationMapOutput) ToS3BucketReplicationMapOutputWithContext(ctx context.Context) S3BucketReplicationMapOutput { + return o +} + +func (o S3BucketReplicationMapOutput) MapIndex(k pulumi.StringInput) S3BucketReplicationOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *S3BucketReplication { + return vs[0].(map[string]*S3BucketReplication)[vs[1].(string)] + }).(S3BucketReplicationOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*S3BucketReplicationInput)(nil)).Elem(), &S3BucketReplication{}) + pulumi.RegisterInputType(reflect.TypeOf((*S3BucketReplicationArrayInput)(nil)).Elem(), S3BucketReplicationArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*S3BucketReplicationMapInput)(nil)).Elem(), S3BucketReplicationMap{}) + pulumi.RegisterOutputType(S3BucketReplicationOutput{}) + pulumi.RegisterOutputType(S3BucketReplicationArrayOutput{}) + pulumi.RegisterOutputType(S3BucketReplicationMapOutput{}) +} diff --git a/sdk/go/minio/s3bucketServerSideEncryption.go b/sdk/go/minio/s3bucketServerSideEncryption.go index 3a5833b..3312ef9 100644 --- a/sdk/go/minio/s3bucketServerSideEncryption.go +++ b/sdk/go/minio/s3bucketServerSideEncryption.go @@ -8,7 +8,7 @@ import ( "reflect" "errors" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) diff --git a/sdk/go/minio/s3bucketVersioning.go b/sdk/go/minio/s3bucketVersioning.go index 67f64d4..bdf417b 100644 --- a/sdk/go/minio/s3bucketVersioning.go +++ b/sdk/go/minio/s3bucketVersioning.go @@ -8,7 +8,7 @@ import ( "reflect" "errors" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) diff --git a/sdk/go/minio/s3object.go b/sdk/go/minio/s3object.go index d1118b0..442f09b 100644 --- a/sdk/go/minio/s3object.go +++ b/sdk/go/minio/s3object.go @@ -8,7 +8,7 @@ import ( "reflect" "errors" - "github.com/pulumi/pulumi-minio/sdk/go/minio/internal" + "github.com/pulumi/pulumi-minio/sdk/v2/go/minio/internal" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" ) @@ -19,7 +19,7 @@ import ( // // import ( // -// "github.com/pulumi/pulumi-minio/sdk/go/minio" +// "github.com/pulumi/pulumi-minio/sdk/v2/go/minio" // "github.com/pulumi/pulumi/sdk/v3/go/pulumi" // // ) diff --git a/sdk/java/src/main/java/com/pulumi/minio/S3BucketReplication.java b/sdk/java/src/main/java/com/pulumi/minio/S3BucketReplication.java new file mode 100644 index 0000000..f03470e --- /dev/null +++ b/sdk/java/src/main/java/com/pulumi/minio/S3BucketReplication.java @@ -0,0 +1,302 @@ +// *** WARNING: this file was generated by pulumi-java-gen. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +package com.pulumi.minio; + +import com.pulumi.core.Output; +import com.pulumi.core.annotations.Export; +import com.pulumi.core.annotations.ResourceType; +import com.pulumi.core.internal.Codegen; +import com.pulumi.minio.S3BucketReplicationArgs; +import com.pulumi.minio.Utilities; +import com.pulumi.minio.inputs.S3BucketReplicationState; +import com.pulumi.minio.outputs.S3BucketReplicationRule; +import java.lang.String; +import java.util.List; +import java.util.Optional; +import javax.annotation.Nullable; + +/** + * ## Example Usage + * ```java + * package generated_program; + * + * import com.pulumi.Context; + * import com.pulumi.Pulumi; + * import com.pulumi.core.Output; + * import com.pulumi.minio.S3Bucket; + * import com.pulumi.minio.S3BucketArgs; + * import com.pulumi.minio.S3BucketVersioning; + * import com.pulumi.minio.S3BucketVersioningArgs; + * import com.pulumi.minio.inputs.S3BucketVersioningVersioningConfigurationArgs; + * import com.pulumi.minio.MinioFunctions; + * import com.pulumi.minio.inputs.GetIamPolicyDocumentArgs; + * import com.pulumi.minio.IamPolicy; + * import com.pulumi.minio.IamPolicyArgs; + * import com.pulumi.minio.IamUser; + * import com.pulumi.minio.IamUserArgs; + * import com.pulumi.minio.IamUserPolicyAttachment; + * import com.pulumi.minio.IamUserPolicyAttachmentArgs; + * import com.pulumi.minio.IamServiceAccount; + * import com.pulumi.minio.IamServiceAccountArgs; + * import com.pulumi.minio.S3BucketReplication; + * import com.pulumi.minio.S3BucketReplicationArgs; + * import com.pulumi.minio.inputs.S3BucketReplicationRuleArgs; + * import com.pulumi.minio.inputs.S3BucketReplicationRuleTargetArgs; + * 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 myBucketInAS3Bucket = new S3Bucket("myBucketInAS3Bucket", S3BucketArgs.builder() + * .bucket("my-bucket") + * .build()); + * + * var myBucketInBS3Bucket = new S3Bucket("myBucketInBS3Bucket", S3BucketArgs.builder() + * .bucket("my-bucket") + * .build(), CustomResourceOptions.builder() + * .provider(minio.deployment_b()) + * .build()); + * + * var myBucketInAS3BucketVersioning = new S3BucketVersioning("myBucketInAS3BucketVersioning", S3BucketVersioningArgs.builder() + * .bucket(myBucketInAS3Bucket.bucket()) + * .versioningConfiguration(S3BucketVersioningVersioningConfigurationArgs.builder() + * .status("Enabled") + * .build()) + * .build()); + * + * var myBucketInBS3BucketVersioning = new S3BucketVersioning("myBucketInBS3BucketVersioning", S3BucketVersioningArgs.builder() + * .bucket(myBucketInBS3Bucket.bucket()) + * .versioningConfiguration(S3BucketVersioningVersioningConfigurationArgs.builder() + * .status("Enabled") + * .build()) + * .build(), CustomResourceOptions.builder() + * .provider(minio.deployment_b()) + * .build()); + * + * final var replicationPolicy = MinioFunctions.getIamPolicyDocument(GetIamPolicyDocumentArgs.builder() + * .statements( + * GetIamPolicyDocumentStatementArgs.builder() + * .sid("ReadBuckets") + * .effect("Allow") + * .resources("arn:aws:s3:::*") + * .actions("s3:ListBucket") + * .build(), + * GetIamPolicyDocumentStatementArgs.builder() + * .sid("EnableReplicationOnBucket") + * .effect("Allow") + * .resources("arn:aws:s3:::my-bucket") + * .actions( + * "s3:GetReplicationConfiguration", + * "s3:ListBucket", + * "s3:ListBucketMultipartUploads", + * "s3:GetBucketLocation", + * "s3:GetBucketVersioning", + * "s3:GetBucketObjectLockConfiguration", + * "s3:GetEncryptionConfiguration") + * .build(), + * GetIamPolicyDocumentStatementArgs.builder() + * .sid("EnableReplicatingDataIntoBucket") + * .effect("Allow") + * .resources("arn:aws:s3:::my-bucket/*") + * .actions( + * "s3:GetReplicationConfiguration", + * "s3:ReplicateTags", + * "s3:AbortMultipartUpload", + * "s3:GetObject", + * "s3:GetObjectVersion", + * "s3:GetObjectVersionTagging", + * "s3:PutObject", + * "s3:PutObjectRetention", + * "s3:PutBucketObjectLockConfiguration", + * "s3:PutObjectLegalHold", + * "s3:DeleteObject", + * "s3:ReplicateObject", + * "s3:ReplicateDelete") + * .build()) + * .build()); + * + * var replicationInBIamPolicy = new IamPolicy("replicationInBIamPolicy", IamPolicyArgs.builder() + * .policy(replicationPolicy.applyValue(getIamPolicyDocumentResult -> getIamPolicyDocumentResult.json())) + * .build(), CustomResourceOptions.builder() + * .provider(minio.deployment_b()) + * .build()); + * + * var replicationInBIamUser = new IamUser("replicationInBIamUser", IamUserArgs.builder() + * .forceDestroy(true) + * .build(), CustomResourceOptions.builder() + * .provider(minio.deployment_b()) + * .build()); + * + * var replicationInBIamUserPolicyAttachment = new IamUserPolicyAttachment("replicationInBIamUserPolicyAttachment", IamUserPolicyAttachmentArgs.builder() + * .userName(replicationInBIamUser.name()) + * .policyName(replicationInBIamPolicy.id()) + * .build(), CustomResourceOptions.builder() + * .provider(minio.deployment_b()) + * .build()); + * + * var replicationInBIamServiceAccount = new IamServiceAccount("replicationInBIamServiceAccount", IamServiceAccountArgs.builder() + * .targetUser(replicationInBIamUser.name()) + * .build(), CustomResourceOptions.builder() + * .provider(minio.deployment_b()) + * .dependsOn(replicationInBIamUserPolicyAttachment) + * .build()); + * + * var replicationInBS3BucketReplication = new S3BucketReplication("replicationInBS3BucketReplication", S3BucketReplicationArgs.builder() + * .bucket(myBucketInAS3Bucket.bucket()) + * .rules(S3BucketReplicationRuleArgs.builder() + * .deleteReplication(true) + * .deleteMarkerReplication(true) + * .existingObjectReplication(true) + * .metadataSync(true) + * .target(S3BucketReplicationRuleTargetArgs.builder() + * .bucket(myBucketInBS3Bucket.bucket()) + * .secure(false) + * .host(var_.minio_server_b()) + * .bandwidthLimt("100M") + * .accessKey(replicationInBIamServiceAccount.accessKey()) + * .secretKey(replicationInBIamServiceAccount.secretKey()) + * .build()) + * .build()) + * .build(), CustomResourceOptions.builder() + * .dependsOn( + * myBucketInAS3BucketVersioning, + * myBucketInBS3BucketVersioning) + * .build()); + * + * var replicationInAIamPolicy = new IamPolicy("replicationInAIamPolicy", IamPolicyArgs.builder() + * .policy(replicationPolicy.applyValue(getIamPolicyDocumentResult -> getIamPolicyDocumentResult.json())) + * .build()); + * + * var replicationInAIamUser = new IamUser("replicationInAIamUser", IamUserArgs.builder() + * .forceDestroy(true) + * .build()); + * + * var replicationInAIamUserPolicyAttachment = new IamUserPolicyAttachment("replicationInAIamUserPolicyAttachment", IamUserPolicyAttachmentArgs.builder() + * .userName(replicationInAIamUser.name()) + * .policyName(replicationInAIamPolicy.id()) + * .build()); + * + * var replicationInAIamServiceAccount = new IamServiceAccount("replicationInAIamServiceAccount", IamServiceAccountArgs.builder() + * .targetUser(replicationInAIamUser.name()) + * .build(), CustomResourceOptions.builder() + * .dependsOn(replicationInBIamUserPolicyAttachment) + * .build()); + * + * var replicationInAS3BucketReplication = new S3BucketReplication("replicationInAS3BucketReplication", S3BucketReplicationArgs.builder() + * .bucket(myBucketInBS3Bucket.bucket()) + * .rules(S3BucketReplicationRuleArgs.builder() + * .deleteReplication(true) + * .deleteMarkerReplication(true) + * .existingObjectReplication(true) + * .metadataSync(true) + * .target(S3BucketReplicationRuleTargetArgs.builder() + * .bucket(myBucketInAS3Bucket.bucket()) + * .host(var_.minio_server_a()) + * .secure(false) + * .bandwidthLimt("100M") + * .accessKey(replicationInAIamServiceAccount.accessKey()) + * .secretKey(replicationInAIamServiceAccount.secretKey()) + * .build()) + * .build()) + * .build(), CustomResourceOptions.builder() + * .provider(minio.deployment_b()) + * .dependsOn( + * myBucketInAS3BucketVersioning, + * myBucketInBS3BucketVersioning) + * .build()); + * + * } + * } + * ``` + * + */ +@ResourceType(type="minio:index/s3BucketReplication:S3BucketReplication") +public class S3BucketReplication extends com.pulumi.resources.CustomResource { + /** + * The name of the existing target bucket to replicate into + * + */ + @Export(name="bucket", refs={String.class}, tree="[0]") + private Output bucket; + + /** + * @return The name of the existing target bucket to replicate into + * + */ + public Output bucket() { + return this.bucket; + } + /** + * Rule definitions + * + */ + @Export(name="rules", refs={List.class,S3BucketReplicationRule.class}, tree="[0,1]") + private Output> rules; + + /** + * @return Rule definitions + * + */ + public Output>> rules() { + return Codegen.optional(this.rules); + } + + /** + * + * @param name The _unique_ name of the resulting resource. + */ + public S3BucketReplication(String name) { + this(name, S3BucketReplicationArgs.Empty); + } + /** + * + * @param name The _unique_ name of the resulting resource. + * @param args The arguments to use to populate this resource's properties. + */ + public S3BucketReplication(String name, S3BucketReplicationArgs args) { + this(name, args, null); + } + /** + * + * @param name The _unique_ name of the resulting resource. + * @param args The arguments to use to populate this resource's properties. + * @param options A bag of options that control this resource's behavior. + */ + public S3BucketReplication(String name, S3BucketReplicationArgs args, @Nullable com.pulumi.resources.CustomResourceOptions options) { + super("minio:index/s3BucketReplication:S3BucketReplication", name, args == null ? S3BucketReplicationArgs.Empty : args, makeResourceOptions(options, Codegen.empty())); + } + + private S3BucketReplication(String name, Output id, @Nullable S3BucketReplicationState state, @Nullable com.pulumi.resources.CustomResourceOptions options) { + super("minio:index/s3BucketReplication:S3BucketReplication", name, state, makeResourceOptions(options, id)); + } + + private static com.pulumi.resources.CustomResourceOptions makeResourceOptions(@Nullable com.pulumi.resources.CustomResourceOptions options, @Nullable Output id) { + var defaultOptions = com.pulumi.resources.CustomResourceOptions.builder() + .version(Utilities.getVersion()) + .build(); + return com.pulumi.resources.CustomResourceOptions.merge(defaultOptions, options, id); + } + + /** + * Get an existing Host resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param state + * @param options Optional settings to control the behavior of the CustomResource. + */ + public static S3BucketReplication get(String name, Output id, @Nullable S3BucketReplicationState state, @Nullable com.pulumi.resources.CustomResourceOptions options) { + return new S3BucketReplication(name, id, state, options); + } +} diff --git a/sdk/java/src/main/java/com/pulumi/minio/S3BucketReplicationArgs.java b/sdk/java/src/main/java/com/pulumi/minio/S3BucketReplicationArgs.java new file mode 100644 index 0000000..32fb427 --- /dev/null +++ b/sdk/java/src/main/java/com/pulumi/minio/S3BucketReplicationArgs.java @@ -0,0 +1,136 @@ +// *** WARNING: this file was generated by pulumi-java-gen. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +package com.pulumi.minio; + +import com.pulumi.core.Output; +import com.pulumi.core.annotations.Import; +import com.pulumi.exceptions.MissingRequiredPropertyException; +import com.pulumi.minio.inputs.S3BucketReplicationRuleArgs; +import java.lang.String; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +import javax.annotation.Nullable; + + +public final class S3BucketReplicationArgs extends com.pulumi.resources.ResourceArgs { + + public static final S3BucketReplicationArgs Empty = new S3BucketReplicationArgs(); + + /** + * The name of the existing target bucket to replicate into + * + */ + @Import(name="bucket", required=true) + private Output bucket; + + /** + * @return The name of the existing target bucket to replicate into + * + */ + public Output bucket() { + return this.bucket; + } + + /** + * Rule definitions + * + */ + @Import(name="rules") + private @Nullable Output> rules; + + /** + * @return Rule definitions + * + */ + public Optional>> rules() { + return Optional.ofNullable(this.rules); + } + + private S3BucketReplicationArgs() {} + + private S3BucketReplicationArgs(S3BucketReplicationArgs $) { + this.bucket = $.bucket; + this.rules = $.rules; + } + + public static Builder builder() { + return new Builder(); + } + public static Builder builder(S3BucketReplicationArgs defaults) { + return new Builder(defaults); + } + + public static final class Builder { + private S3BucketReplicationArgs $; + + public Builder() { + $ = new S3BucketReplicationArgs(); + } + + public Builder(S3BucketReplicationArgs defaults) { + $ = new S3BucketReplicationArgs(Objects.requireNonNull(defaults)); + } + + /** + * @param bucket The name of the existing target bucket to replicate into + * + * @return builder + * + */ + public Builder bucket(Output bucket) { + $.bucket = bucket; + return this; + } + + /** + * @param bucket The name of the existing target bucket to replicate into + * + * @return builder + * + */ + public Builder bucket(String bucket) { + return bucket(Output.of(bucket)); + } + + /** + * @param rules Rule definitions + * + * @return builder + * + */ + public Builder rules(@Nullable Output> rules) { + $.rules = rules; + return this; + } + + /** + * @param rules Rule definitions + * + * @return builder + * + */ + public Builder rules(List rules) { + return rules(Output.of(rules)); + } + + /** + * @param rules Rule definitions + * + * @return builder + * + */ + public Builder rules(S3BucketReplicationRuleArgs... rules) { + return rules(List.of(rules)); + } + + public S3BucketReplicationArgs build() { + if ($.bucket == null) { + throw new MissingRequiredPropertyException("S3BucketReplicationArgs", "bucket"); + } + return $; + } + } + +} diff --git a/sdk/java/src/main/java/com/pulumi/minio/inputs/S3BucketReplicationRuleArgs.java b/sdk/java/src/main/java/com/pulumi/minio/inputs/S3BucketReplicationRuleArgs.java new file mode 100644 index 0000000..5d8e221 --- /dev/null +++ b/sdk/java/src/main/java/com/pulumi/minio/inputs/S3BucketReplicationRuleArgs.java @@ -0,0 +1,462 @@ +// *** WARNING: this file was generated by pulumi-java-gen. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +package com.pulumi.minio.inputs; + +import com.pulumi.core.Output; +import com.pulumi.core.annotations.Import; +import com.pulumi.exceptions.MissingRequiredPropertyException; +import com.pulumi.minio.inputs.S3BucketReplicationRuleTargetArgs; +import java.lang.Boolean; +import java.lang.Integer; +import java.lang.Object; +import java.lang.String; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import javax.annotation.Nullable; + + +public final class S3BucketReplicationRuleArgs extends com.pulumi.resources.ResourceArgs { + + public static final S3BucketReplicationRuleArgs Empty = new S3BucketReplicationRuleArgs(); + + /** + * Rule ARN genrated by MinIO + * + */ + @Import(name="arn") + private @Nullable Output arn; + + /** + * @return Rule ARN genrated by MinIO + * + */ + public Optional> arn() { + return Optional.ofNullable(this.arn); + } + + /** + * Whether or not to synchronise marker deletion + * + */ + @Import(name="deleteMarkerReplication") + private @Nullable Output deleteMarkerReplication; + + /** + * @return Whether or not to synchronise marker deletion + * + */ + public Optional> deleteMarkerReplication() { + return Optional.ofNullable(this.deleteMarkerReplication); + } + + /** + * Whether or not to propagate deletion + * + */ + @Import(name="deleteReplication") + private @Nullable Output deleteReplication; + + /** + * @return Whether or not to propagate deletion + * + */ + public Optional> deleteReplication() { + return Optional.ofNullable(this.deleteReplication); + } + + /** + * Whether or not this rule is enabled + * + */ + @Import(name="enabled") + private @Nullable Output enabled; + + /** + * @return Whether or not this rule is enabled + * + */ + public Optional> enabled() { + return Optional.ofNullable(this.enabled); + } + + /** + * Whether or not to synchronise object created prior the replication configuration + * + */ + @Import(name="existingObjectReplication") + private @Nullable Output existingObjectReplication; + + /** + * @return Whether or not to synchronise object created prior the replication configuration + * + */ + public Optional> existingObjectReplication() { + return Optional.ofNullable(this.existingObjectReplication); + } + + /** + * Rule ID generated by MinIO + * + */ + @Import(name="id") + private @Nullable Output id; + + /** + * @return Rule ID generated by MinIO + * + */ + public Optional> id() { + return Optional.ofNullable(this.id); + } + + /** + * Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + * + */ + @Import(name="metadataSync") + private @Nullable Output metadataSync; + + /** + * @return Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + * + */ + public Optional> metadataSync() { + return Optional.ofNullable(this.metadataSync); + } + + /** + * Bucket prefix object must be in to be syncronised + * + */ + @Import(name="prefix") + private @Nullable Output prefix; + + /** + * @return Bucket prefix object must be in to be syncronised + * + */ + public Optional> prefix() { + return Optional.ofNullable(this.prefix); + } + + /** + * Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + * + */ + @Import(name="priority") + private @Nullable Output priority; + + /** + * @return Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + * + */ + public Optional> priority() { + return Optional.ofNullable(this.priority); + } + + /** + * Tags which objects must have to be syncronised + * + */ + @Import(name="tags") + private @Nullable Output> tags; + + /** + * @return Tags which objects must have to be syncronised + * + */ + public Optional>> tags() { + return Optional.ofNullable(this.tags); + } + + /** + * Bucket prefix + * + */ + @Import(name="target", required=true) + private Output target; + + /** + * @return Bucket prefix + * + */ + public Output target() { + return this.target; + } + + private S3BucketReplicationRuleArgs() {} + + private S3BucketReplicationRuleArgs(S3BucketReplicationRuleArgs $) { + this.arn = $.arn; + this.deleteMarkerReplication = $.deleteMarkerReplication; + this.deleteReplication = $.deleteReplication; + this.enabled = $.enabled; + this.existingObjectReplication = $.existingObjectReplication; + this.id = $.id; + this.metadataSync = $.metadataSync; + this.prefix = $.prefix; + this.priority = $.priority; + this.tags = $.tags; + this.target = $.target; + } + + public static Builder builder() { + return new Builder(); + } + public static Builder builder(S3BucketReplicationRuleArgs defaults) { + return new Builder(defaults); + } + + public static final class Builder { + private S3BucketReplicationRuleArgs $; + + public Builder() { + $ = new S3BucketReplicationRuleArgs(); + } + + public Builder(S3BucketReplicationRuleArgs defaults) { + $ = new S3BucketReplicationRuleArgs(Objects.requireNonNull(defaults)); + } + + /** + * @param arn Rule ARN genrated by MinIO + * + * @return builder + * + */ + public Builder arn(@Nullable Output arn) { + $.arn = arn; + return this; + } + + /** + * @param arn Rule ARN genrated by MinIO + * + * @return builder + * + */ + public Builder arn(String arn) { + return arn(Output.of(arn)); + } + + /** + * @param deleteMarkerReplication Whether or not to synchronise marker deletion + * + * @return builder + * + */ + public Builder deleteMarkerReplication(@Nullable Output deleteMarkerReplication) { + $.deleteMarkerReplication = deleteMarkerReplication; + return this; + } + + /** + * @param deleteMarkerReplication Whether or not to synchronise marker deletion + * + * @return builder + * + */ + public Builder deleteMarkerReplication(Boolean deleteMarkerReplication) { + return deleteMarkerReplication(Output.of(deleteMarkerReplication)); + } + + /** + * @param deleteReplication Whether or not to propagate deletion + * + * @return builder + * + */ + public Builder deleteReplication(@Nullable Output deleteReplication) { + $.deleteReplication = deleteReplication; + return this; + } + + /** + * @param deleteReplication Whether or not to propagate deletion + * + * @return builder + * + */ + public Builder deleteReplication(Boolean deleteReplication) { + return deleteReplication(Output.of(deleteReplication)); + } + + /** + * @param enabled Whether or not this rule is enabled + * + * @return builder + * + */ + public Builder enabled(@Nullable Output enabled) { + $.enabled = enabled; + return this; + } + + /** + * @param enabled Whether or not this rule is enabled + * + * @return builder + * + */ + public Builder enabled(Boolean enabled) { + return enabled(Output.of(enabled)); + } + + /** + * @param existingObjectReplication Whether or not to synchronise object created prior the replication configuration + * + * @return builder + * + */ + public Builder existingObjectReplication(@Nullable Output existingObjectReplication) { + $.existingObjectReplication = existingObjectReplication; + return this; + } + + /** + * @param existingObjectReplication Whether or not to synchronise object created prior the replication configuration + * + * @return builder + * + */ + public Builder existingObjectReplication(Boolean existingObjectReplication) { + return existingObjectReplication(Output.of(existingObjectReplication)); + } + + /** + * @param id Rule ID generated by MinIO + * + * @return builder + * + */ + public Builder id(@Nullable Output id) { + $.id = id; + return this; + } + + /** + * @param id Rule ID generated by MinIO + * + * @return builder + * + */ + public Builder id(String id) { + return id(Output.of(id)); + } + + /** + * @param metadataSync Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + * + * @return builder + * + */ + public Builder metadataSync(@Nullable Output metadataSync) { + $.metadataSync = metadataSync; + return this; + } + + /** + * @param metadataSync Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + * + * @return builder + * + */ + public Builder metadataSync(Boolean metadataSync) { + return metadataSync(Output.of(metadataSync)); + } + + /** + * @param prefix Bucket prefix object must be in to be syncronised + * + * @return builder + * + */ + public Builder prefix(@Nullable Output prefix) { + $.prefix = prefix; + return this; + } + + /** + * @param prefix Bucket prefix object must be in to be syncronised + * + * @return builder + * + */ + public Builder prefix(String prefix) { + return prefix(Output.of(prefix)); + } + + /** + * @param priority Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + * + * @return builder + * + */ + public Builder priority(@Nullable Output priority) { + $.priority = priority; + return this; + } + + /** + * @param priority Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + * + * @return builder + * + */ + public Builder priority(Integer priority) { + return priority(Output.of(priority)); + } + + /** + * @param tags Tags which objects must have to be syncronised + * + * @return builder + * + */ + public Builder tags(@Nullable Output> tags) { + $.tags = tags; + return this; + } + + /** + * @param tags Tags which objects must have to be syncronised + * + * @return builder + * + */ + public Builder tags(Map tags) { + return tags(Output.of(tags)); + } + + /** + * @param target Bucket prefix + * + * @return builder + * + */ + public Builder target(Output target) { + $.target = target; + return this; + } + + /** + * @param target Bucket prefix + * + * @return builder + * + */ + public Builder target(S3BucketReplicationRuleTargetArgs target) { + return target(Output.of(target)); + } + + public S3BucketReplicationRuleArgs build() { + if ($.target == null) { + throw new MissingRequiredPropertyException("S3BucketReplicationRuleArgs", "target"); + } + return $; + } + } + +} diff --git a/sdk/java/src/main/java/com/pulumi/minio/inputs/S3BucketReplicationRuleTargetArgs.java b/sdk/java/src/main/java/com/pulumi/minio/inputs/S3BucketReplicationRuleTargetArgs.java new file mode 100644 index 0000000..3745571 --- /dev/null +++ b/sdk/java/src/main/java/com/pulumi/minio/inputs/S3BucketReplicationRuleTargetArgs.java @@ -0,0 +1,518 @@ +// *** WARNING: this file was generated by pulumi-java-gen. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +package com.pulumi.minio.inputs; + +import com.pulumi.core.Output; +import com.pulumi.core.annotations.Import; +import com.pulumi.exceptions.MissingRequiredPropertyException; +import java.lang.Boolean; +import java.lang.String; +import java.util.Objects; +import java.util.Optional; +import javax.annotation.Nullable; + + +public final class S3BucketReplicationRuleTargetArgs extends com.pulumi.resources.ResourceArgs { + + public static final S3BucketReplicationRuleTargetArgs Empty = new S3BucketReplicationRuleTargetArgs(); + + /** + * Access key for the replication service account in the target MinIO + * + */ + @Import(name="accessKey", required=true) + private Output accessKey; + + /** + * @return Access key for the replication service account in the target MinIO + * + */ + public Output accessKey() { + return this.accessKey; + } + + /** + * Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + * + */ + @Import(name="bandwidthLimt") + private @Nullable Output bandwidthLimt; + + /** + * @return Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + * + */ + public Optional> bandwidthLimt() { + return Optional.ofNullable(this.bandwidthLimt); + } + + /** + * The name of the existing target bucket to replicate into + * + */ + @Import(name="bucket", required=true) + private Output bucket; + + /** + * @return The name of the existing target bucket to replicate into + * + */ + public Output bucket() { + return this.bucket; + } + + /** + * Disable proxy for this target + * + */ + @Import(name="disableProxy") + private @Nullable Output disableProxy; + + /** + * @return Disable proxy for this target + * + */ + public Optional> disableProxy() { + return Optional.ofNullable(this.disableProxy); + } + + /** + * Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + * + */ + @Import(name="healthCheckPeriod") + private @Nullable Output healthCheckPeriod; + + /** + * @return Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + * + */ + public Optional> healthCheckPeriod() { + return Optional.ofNullable(this.healthCheckPeriod); + } + + /** + * The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + * + */ + @Import(name="host", required=true) + private Output host; + + /** + * @return The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + * + */ + public Output host() { + return this.host; + } + + /** + * Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + * + */ + @Import(name="path") + private @Nullable Output path; + + /** + * @return Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + * + */ + public Optional> path() { + return Optional.ofNullable(this.path); + } + + /** + * Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + * + */ + @Import(name="pathStyle") + private @Nullable Output pathStyle; + + /** + * @return Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + * + */ + public Optional> pathStyle() { + return Optional.ofNullable(this.pathStyle); + } + + /** + * Region of the target MinIO. This will be used to generate the target ARN + * + */ + @Import(name="region") + private @Nullable Output region; + + /** + * @return Region of the target MinIO. This will be used to generate the target ARN + * + */ + public Optional> region() { + return Optional.ofNullable(this.region); + } + + /** + * Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + * + */ + @Import(name="secretKey") + private @Nullable Output secretKey; + + /** + * @return Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + * + */ + public Optional> secretKey() { + return Optional.ofNullable(this.secretKey); + } + + @Import(name="secure") + private @Nullable Output secure; + + public Optional> secure() { + return Optional.ofNullable(this.secure); + } + + /** + * The storage class to use for the object on this target + * + */ + @Import(name="storageClass") + private @Nullable Output storageClass; + + /** + * @return The storage class to use for the object on this target + * + */ + public Optional> storageClass() { + return Optional.ofNullable(this.storageClass); + } + + /** + * Use synchronous replication. + * + */ + @Import(name="syncronous") + private @Nullable Output syncronous; + + /** + * @return Use synchronous replication. + * + */ + public Optional> syncronous() { + return Optional.ofNullable(this.syncronous); + } + + private S3BucketReplicationRuleTargetArgs() {} + + private S3BucketReplicationRuleTargetArgs(S3BucketReplicationRuleTargetArgs $) { + this.accessKey = $.accessKey; + this.bandwidthLimt = $.bandwidthLimt; + this.bucket = $.bucket; + this.disableProxy = $.disableProxy; + this.healthCheckPeriod = $.healthCheckPeriod; + this.host = $.host; + this.path = $.path; + this.pathStyle = $.pathStyle; + this.region = $.region; + this.secretKey = $.secretKey; + this.secure = $.secure; + this.storageClass = $.storageClass; + this.syncronous = $.syncronous; + } + + public static Builder builder() { + return new Builder(); + } + public static Builder builder(S3BucketReplicationRuleTargetArgs defaults) { + return new Builder(defaults); + } + + public static final class Builder { + private S3BucketReplicationRuleTargetArgs $; + + public Builder() { + $ = new S3BucketReplicationRuleTargetArgs(); + } + + public Builder(S3BucketReplicationRuleTargetArgs defaults) { + $ = new S3BucketReplicationRuleTargetArgs(Objects.requireNonNull(defaults)); + } + + /** + * @param accessKey Access key for the replication service account in the target MinIO + * + * @return builder + * + */ + public Builder accessKey(Output accessKey) { + $.accessKey = accessKey; + return this; + } + + /** + * @param accessKey Access key for the replication service account in the target MinIO + * + * @return builder + * + */ + public Builder accessKey(String accessKey) { + return accessKey(Output.of(accessKey)); + } + + /** + * @param bandwidthLimt Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + * + * @return builder + * + */ + public Builder bandwidthLimt(@Nullable Output bandwidthLimt) { + $.bandwidthLimt = bandwidthLimt; + return this; + } + + /** + * @param bandwidthLimt Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + * + * @return builder + * + */ + public Builder bandwidthLimt(String bandwidthLimt) { + return bandwidthLimt(Output.of(bandwidthLimt)); + } + + /** + * @param bucket The name of the existing target bucket to replicate into + * + * @return builder + * + */ + public Builder bucket(Output bucket) { + $.bucket = bucket; + return this; + } + + /** + * @param bucket The name of the existing target bucket to replicate into + * + * @return builder + * + */ + public Builder bucket(String bucket) { + return bucket(Output.of(bucket)); + } + + /** + * @param disableProxy Disable proxy for this target + * + * @return builder + * + */ + public Builder disableProxy(@Nullable Output disableProxy) { + $.disableProxy = disableProxy; + return this; + } + + /** + * @param disableProxy Disable proxy for this target + * + * @return builder + * + */ + public Builder disableProxy(Boolean disableProxy) { + return disableProxy(Output.of(disableProxy)); + } + + /** + * @param healthCheckPeriod Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + * + * @return builder + * + */ + public Builder healthCheckPeriod(@Nullable Output healthCheckPeriod) { + $.healthCheckPeriod = healthCheckPeriod; + return this; + } + + /** + * @param healthCheckPeriod Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + * + * @return builder + * + */ + public Builder healthCheckPeriod(String healthCheckPeriod) { + return healthCheckPeriod(Output.of(healthCheckPeriod)); + } + + /** + * @param host The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + * + * @return builder + * + */ + public Builder host(Output host) { + $.host = host; + return this; + } + + /** + * @param host The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + * + * @return builder + * + */ + public Builder host(String host) { + return host(Output.of(host)); + } + + /** + * @param path Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + * + * @return builder + * + */ + public Builder path(@Nullable Output path) { + $.path = path; + return this; + } + + /** + * @param path Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + * + * @return builder + * + */ + public Builder path(String path) { + return path(Output.of(path)); + } + + /** + * @param pathStyle Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + * + * @return builder + * + */ + public Builder pathStyle(@Nullable Output pathStyle) { + $.pathStyle = pathStyle; + return this; + } + + /** + * @param pathStyle Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + * + * @return builder + * + */ + public Builder pathStyle(String pathStyle) { + return pathStyle(Output.of(pathStyle)); + } + + /** + * @param region Region of the target MinIO. This will be used to generate the target ARN + * + * @return builder + * + */ + public Builder region(@Nullable Output region) { + $.region = region; + return this; + } + + /** + * @param region Region of the target MinIO. This will be used to generate the target ARN + * + * @return builder + * + */ + public Builder region(String region) { + return region(Output.of(region)); + } + + /** + * @param secretKey Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + * + * @return builder + * + */ + public Builder secretKey(@Nullable Output secretKey) { + $.secretKey = secretKey; + return this; + } + + /** + * @param secretKey Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + * + * @return builder + * + */ + public Builder secretKey(String secretKey) { + return secretKey(Output.of(secretKey)); + } + + public Builder secure(@Nullable Output secure) { + $.secure = secure; + return this; + } + + public Builder secure(Boolean secure) { + return secure(Output.of(secure)); + } + + /** + * @param storageClass The storage class to use for the object on this target + * + * @return builder + * + */ + public Builder storageClass(@Nullable Output storageClass) { + $.storageClass = storageClass; + return this; + } + + /** + * @param storageClass The storage class to use for the object on this target + * + * @return builder + * + */ + public Builder storageClass(String storageClass) { + return storageClass(Output.of(storageClass)); + } + + /** + * @param syncronous Use synchronous replication. + * + * @return builder + * + */ + public Builder syncronous(@Nullable Output syncronous) { + $.syncronous = syncronous; + return this; + } + + /** + * @param syncronous Use synchronous replication. + * + * @return builder + * + */ + public Builder syncronous(Boolean syncronous) { + return syncronous(Output.of(syncronous)); + } + + public S3BucketReplicationRuleTargetArgs build() { + if ($.accessKey == null) { + throw new MissingRequiredPropertyException("S3BucketReplicationRuleTargetArgs", "accessKey"); + } + if ($.bucket == null) { + throw new MissingRequiredPropertyException("S3BucketReplicationRuleTargetArgs", "bucket"); + } + if ($.host == null) { + throw new MissingRequiredPropertyException("S3BucketReplicationRuleTargetArgs", "host"); + } + return $; + } + } + +} diff --git a/sdk/java/src/main/java/com/pulumi/minio/inputs/S3BucketReplicationState.java b/sdk/java/src/main/java/com/pulumi/minio/inputs/S3BucketReplicationState.java new file mode 100644 index 0000000..ce55330 --- /dev/null +++ b/sdk/java/src/main/java/com/pulumi/minio/inputs/S3BucketReplicationState.java @@ -0,0 +1,132 @@ +// *** WARNING: this file was generated by pulumi-java-gen. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +package com.pulumi.minio.inputs; + +import com.pulumi.core.Output; +import com.pulumi.core.annotations.Import; +import com.pulumi.minio.inputs.S3BucketReplicationRuleArgs; +import java.lang.String; +import java.util.List; +import java.util.Objects; +import java.util.Optional; +import javax.annotation.Nullable; + + +public final class S3BucketReplicationState extends com.pulumi.resources.ResourceArgs { + + public static final S3BucketReplicationState Empty = new S3BucketReplicationState(); + + /** + * The name of the existing target bucket to replicate into + * + */ + @Import(name="bucket") + private @Nullable Output bucket; + + /** + * @return The name of the existing target bucket to replicate into + * + */ + public Optional> bucket() { + return Optional.ofNullable(this.bucket); + } + + /** + * Rule definitions + * + */ + @Import(name="rules") + private @Nullable Output> rules; + + /** + * @return Rule definitions + * + */ + public Optional>> rules() { + return Optional.ofNullable(this.rules); + } + + private S3BucketReplicationState() {} + + private S3BucketReplicationState(S3BucketReplicationState $) { + this.bucket = $.bucket; + this.rules = $.rules; + } + + public static Builder builder() { + return new Builder(); + } + public static Builder builder(S3BucketReplicationState defaults) { + return new Builder(defaults); + } + + public static final class Builder { + private S3BucketReplicationState $; + + public Builder() { + $ = new S3BucketReplicationState(); + } + + public Builder(S3BucketReplicationState defaults) { + $ = new S3BucketReplicationState(Objects.requireNonNull(defaults)); + } + + /** + * @param bucket The name of the existing target bucket to replicate into + * + * @return builder + * + */ + public Builder bucket(@Nullable Output bucket) { + $.bucket = bucket; + return this; + } + + /** + * @param bucket The name of the existing target bucket to replicate into + * + * @return builder + * + */ + public Builder bucket(String bucket) { + return bucket(Output.of(bucket)); + } + + /** + * @param rules Rule definitions + * + * @return builder + * + */ + public Builder rules(@Nullable Output> rules) { + $.rules = rules; + return this; + } + + /** + * @param rules Rule definitions + * + * @return builder + * + */ + public Builder rules(List rules) { + return rules(Output.of(rules)); + } + + /** + * @param rules Rule definitions + * + * @return builder + * + */ + public Builder rules(S3BucketReplicationRuleArgs... rules) { + return rules(List.of(rules)); + } + + public S3BucketReplicationState build() { + return $; + } + } + +} diff --git a/sdk/java/src/main/java/com/pulumi/minio/outputs/S3BucketReplicationRule.java b/sdk/java/src/main/java/com/pulumi/minio/outputs/S3BucketReplicationRule.java new file mode 100644 index 0000000..e936f25 --- /dev/null +++ b/sdk/java/src/main/java/com/pulumi/minio/outputs/S3BucketReplicationRule.java @@ -0,0 +1,275 @@ +// *** WARNING: this file was generated by pulumi-java-gen. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +package com.pulumi.minio.outputs; + +import com.pulumi.core.annotations.CustomType; +import com.pulumi.exceptions.MissingRequiredPropertyException; +import com.pulumi.minio.outputs.S3BucketReplicationRuleTarget; +import java.lang.Boolean; +import java.lang.Integer; +import java.lang.Object; +import java.lang.String; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import javax.annotation.Nullable; + +@CustomType +public final class S3BucketReplicationRule { + /** + * @return Rule ARN genrated by MinIO + * + */ + private @Nullable String arn; + /** + * @return Whether or not to synchronise marker deletion + * + */ + private @Nullable Boolean deleteMarkerReplication; + /** + * @return Whether or not to propagate deletion + * + */ + private @Nullable Boolean deleteReplication; + /** + * @return Whether or not this rule is enabled + * + */ + private @Nullable Boolean enabled; + /** + * @return Whether or not to synchronise object created prior the replication configuration + * + */ + private @Nullable Boolean existingObjectReplication; + /** + * @return Rule ID generated by MinIO + * + */ + private @Nullable String id; + /** + * @return Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + * + */ + private @Nullable Boolean metadataSync; + /** + * @return Bucket prefix object must be in to be syncronised + * + */ + private @Nullable String prefix; + /** + * @return Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + * + */ + private @Nullable Integer priority; + /** + * @return Tags which objects must have to be syncronised + * + */ + private @Nullable Map tags; + /** + * @return Bucket prefix + * + */ + private S3BucketReplicationRuleTarget target; + + private S3BucketReplicationRule() {} + /** + * @return Rule ARN genrated by MinIO + * + */ + public Optional arn() { + return Optional.ofNullable(this.arn); + } + /** + * @return Whether or not to synchronise marker deletion + * + */ + public Optional deleteMarkerReplication() { + return Optional.ofNullable(this.deleteMarkerReplication); + } + /** + * @return Whether or not to propagate deletion + * + */ + public Optional deleteReplication() { + return Optional.ofNullable(this.deleteReplication); + } + /** + * @return Whether or not this rule is enabled + * + */ + public Optional enabled() { + return Optional.ofNullable(this.enabled); + } + /** + * @return Whether or not to synchronise object created prior the replication configuration + * + */ + public Optional existingObjectReplication() { + return Optional.ofNullable(this.existingObjectReplication); + } + /** + * @return Rule ID generated by MinIO + * + */ + public Optional id() { + return Optional.ofNullable(this.id); + } + /** + * @return Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + * + */ + public Optional metadataSync() { + return Optional.ofNullable(this.metadataSync); + } + /** + * @return Bucket prefix object must be in to be syncronised + * + */ + public Optional prefix() { + return Optional.ofNullable(this.prefix); + } + /** + * @return Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + * + */ + public Optional priority() { + return Optional.ofNullable(this.priority); + } + /** + * @return Tags which objects must have to be syncronised + * + */ + public Map tags() { + return this.tags == null ? Map.of() : this.tags; + } + /** + * @return Bucket prefix + * + */ + public S3BucketReplicationRuleTarget target() { + return this.target; + } + + public static Builder builder() { + return new Builder(); + } + + public static Builder builder(S3BucketReplicationRule defaults) { + return new Builder(defaults); + } + @CustomType.Builder + public static final class Builder { + private @Nullable String arn; + private @Nullable Boolean deleteMarkerReplication; + private @Nullable Boolean deleteReplication; + private @Nullable Boolean enabled; + private @Nullable Boolean existingObjectReplication; + private @Nullable String id; + private @Nullable Boolean metadataSync; + private @Nullable String prefix; + private @Nullable Integer priority; + private @Nullable Map tags; + private S3BucketReplicationRuleTarget target; + public Builder() {} + public Builder(S3BucketReplicationRule defaults) { + Objects.requireNonNull(defaults); + this.arn = defaults.arn; + this.deleteMarkerReplication = defaults.deleteMarkerReplication; + this.deleteReplication = defaults.deleteReplication; + this.enabled = defaults.enabled; + this.existingObjectReplication = defaults.existingObjectReplication; + this.id = defaults.id; + this.metadataSync = defaults.metadataSync; + this.prefix = defaults.prefix; + this.priority = defaults.priority; + this.tags = defaults.tags; + this.target = defaults.target; + } + + @CustomType.Setter + public Builder arn(@Nullable String arn) { + + this.arn = arn; + return this; + } + @CustomType.Setter + public Builder deleteMarkerReplication(@Nullable Boolean deleteMarkerReplication) { + + this.deleteMarkerReplication = deleteMarkerReplication; + return this; + } + @CustomType.Setter + public Builder deleteReplication(@Nullable Boolean deleteReplication) { + + this.deleteReplication = deleteReplication; + return this; + } + @CustomType.Setter + public Builder enabled(@Nullable Boolean enabled) { + + this.enabled = enabled; + return this; + } + @CustomType.Setter + public Builder existingObjectReplication(@Nullable Boolean existingObjectReplication) { + + this.existingObjectReplication = existingObjectReplication; + return this; + } + @CustomType.Setter + public Builder id(@Nullable String id) { + + this.id = id; + return this; + } + @CustomType.Setter + public Builder metadataSync(@Nullable Boolean metadataSync) { + + this.metadataSync = metadataSync; + return this; + } + @CustomType.Setter + public Builder prefix(@Nullable String prefix) { + + this.prefix = prefix; + return this; + } + @CustomType.Setter + public Builder priority(@Nullable Integer priority) { + + this.priority = priority; + return this; + } + @CustomType.Setter + public Builder tags(@Nullable Map tags) { + + this.tags = tags; + return this; + } + @CustomType.Setter + public Builder target(S3BucketReplicationRuleTarget target) { + if (target == null) { + throw new MissingRequiredPropertyException("S3BucketReplicationRule", "target"); + } + this.target = target; + return this; + } + public S3BucketReplicationRule build() { + final var _resultValue = new S3BucketReplicationRule(); + _resultValue.arn = arn; + _resultValue.deleteMarkerReplication = deleteMarkerReplication; + _resultValue.deleteReplication = deleteReplication; + _resultValue.enabled = enabled; + _resultValue.existingObjectReplication = existingObjectReplication; + _resultValue.id = id; + _resultValue.metadataSync = metadataSync; + _resultValue.prefix = prefix; + _resultValue.priority = priority; + _resultValue.tags = tags; + _resultValue.target = target; + return _resultValue; + } + } +} diff --git a/sdk/java/src/main/java/com/pulumi/minio/outputs/S3BucketReplicationRuleTarget.java b/sdk/java/src/main/java/com/pulumi/minio/outputs/S3BucketReplicationRuleTarget.java new file mode 100644 index 0000000..7ab572e --- /dev/null +++ b/sdk/java/src/main/java/com/pulumi/minio/outputs/S3BucketReplicationRuleTarget.java @@ -0,0 +1,309 @@ +// *** WARNING: this file was generated by pulumi-java-gen. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +package com.pulumi.minio.outputs; + +import com.pulumi.core.annotations.CustomType; +import com.pulumi.exceptions.MissingRequiredPropertyException; +import java.lang.Boolean; +import java.lang.String; +import java.util.Objects; +import java.util.Optional; +import javax.annotation.Nullable; + +@CustomType +public final class S3BucketReplicationRuleTarget { + /** + * @return Access key for the replication service account in the target MinIO + * + */ + private String accessKey; + /** + * @return Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + * + */ + private @Nullable String bandwidthLimt; + /** + * @return The name of the existing target bucket to replicate into + * + */ + private String bucket; + /** + * @return Disable proxy for this target + * + */ + private @Nullable Boolean disableProxy; + /** + * @return Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + * + */ + private @Nullable String healthCheckPeriod; + /** + * @return The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + * + */ + private String host; + /** + * @return Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + * + */ + private @Nullable String path; + /** + * @return Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + * + */ + private @Nullable String pathStyle; + /** + * @return Region of the target MinIO. This will be used to generate the target ARN + * + */ + private @Nullable String region; + /** + * @return Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + * + */ + private @Nullable String secretKey; + private @Nullable Boolean secure; + /** + * @return The storage class to use for the object on this target + * + */ + private @Nullable String storageClass; + /** + * @return Use synchronous replication. + * + */ + private @Nullable Boolean syncronous; + + private S3BucketReplicationRuleTarget() {} + /** + * @return Access key for the replication service account in the target MinIO + * + */ + public String accessKey() { + return this.accessKey; + } + /** + * @return Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + * + */ + public Optional bandwidthLimt() { + return Optional.ofNullable(this.bandwidthLimt); + } + /** + * @return The name of the existing target bucket to replicate into + * + */ + public String bucket() { + return this.bucket; + } + /** + * @return Disable proxy for this target + * + */ + public Optional disableProxy() { + return Optional.ofNullable(this.disableProxy); + } + /** + * @return Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + * + */ + public Optional healthCheckPeriod() { + return Optional.ofNullable(this.healthCheckPeriod); + } + /** + * @return The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + * + */ + public String host() { + return this.host; + } + /** + * @return Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + * + */ + public Optional path() { + return Optional.ofNullable(this.path); + } + /** + * @return Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + * + */ + public Optional pathStyle() { + return Optional.ofNullable(this.pathStyle); + } + /** + * @return Region of the target MinIO. This will be used to generate the target ARN + * + */ + public Optional region() { + return Optional.ofNullable(this.region); + } + /** + * @return Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + * + */ + public Optional secretKey() { + return Optional.ofNullable(this.secretKey); + } + public Optional secure() { + return Optional.ofNullable(this.secure); + } + /** + * @return The storage class to use for the object on this target + * + */ + public Optional storageClass() { + return Optional.ofNullable(this.storageClass); + } + /** + * @return Use synchronous replication. + * + */ + public Optional syncronous() { + return Optional.ofNullable(this.syncronous); + } + + public static Builder builder() { + return new Builder(); + } + + public static Builder builder(S3BucketReplicationRuleTarget defaults) { + return new Builder(defaults); + } + @CustomType.Builder + public static final class Builder { + private String accessKey; + private @Nullable String bandwidthLimt; + private String bucket; + private @Nullable Boolean disableProxy; + private @Nullable String healthCheckPeriod; + private String host; + private @Nullable String path; + private @Nullable String pathStyle; + private @Nullable String region; + private @Nullable String secretKey; + private @Nullable Boolean secure; + private @Nullable String storageClass; + private @Nullable Boolean syncronous; + public Builder() {} + public Builder(S3BucketReplicationRuleTarget defaults) { + Objects.requireNonNull(defaults); + this.accessKey = defaults.accessKey; + this.bandwidthLimt = defaults.bandwidthLimt; + this.bucket = defaults.bucket; + this.disableProxy = defaults.disableProxy; + this.healthCheckPeriod = defaults.healthCheckPeriod; + this.host = defaults.host; + this.path = defaults.path; + this.pathStyle = defaults.pathStyle; + this.region = defaults.region; + this.secretKey = defaults.secretKey; + this.secure = defaults.secure; + this.storageClass = defaults.storageClass; + this.syncronous = defaults.syncronous; + } + + @CustomType.Setter + public Builder accessKey(String accessKey) { + if (accessKey == null) { + throw new MissingRequiredPropertyException("S3BucketReplicationRuleTarget", "accessKey"); + } + this.accessKey = accessKey; + return this; + } + @CustomType.Setter + public Builder bandwidthLimt(@Nullable String bandwidthLimt) { + + this.bandwidthLimt = bandwidthLimt; + return this; + } + @CustomType.Setter + public Builder bucket(String bucket) { + if (bucket == null) { + throw new MissingRequiredPropertyException("S3BucketReplicationRuleTarget", "bucket"); + } + this.bucket = bucket; + return this; + } + @CustomType.Setter + public Builder disableProxy(@Nullable Boolean disableProxy) { + + this.disableProxy = disableProxy; + return this; + } + @CustomType.Setter + public Builder healthCheckPeriod(@Nullable String healthCheckPeriod) { + + this.healthCheckPeriod = healthCheckPeriod; + return this; + } + @CustomType.Setter + public Builder host(String host) { + if (host == null) { + throw new MissingRequiredPropertyException("S3BucketReplicationRuleTarget", "host"); + } + this.host = host; + return this; + } + @CustomType.Setter + public Builder path(@Nullable String path) { + + this.path = path; + return this; + } + @CustomType.Setter + public Builder pathStyle(@Nullable String pathStyle) { + + this.pathStyle = pathStyle; + return this; + } + @CustomType.Setter + public Builder region(@Nullable String region) { + + this.region = region; + return this; + } + @CustomType.Setter + public Builder secretKey(@Nullable String secretKey) { + + this.secretKey = secretKey; + return this; + } + @CustomType.Setter + public Builder secure(@Nullable Boolean secure) { + + this.secure = secure; + return this; + } + @CustomType.Setter + public Builder storageClass(@Nullable String storageClass) { + + this.storageClass = storageClass; + return this; + } + @CustomType.Setter + public Builder syncronous(@Nullable Boolean syncronous) { + + this.syncronous = syncronous; + return this; + } + public S3BucketReplicationRuleTarget build() { + final var _resultValue = new S3BucketReplicationRuleTarget(); + _resultValue.accessKey = accessKey; + _resultValue.bandwidthLimt = bandwidthLimt; + _resultValue.bucket = bucket; + _resultValue.disableProxy = disableProxy; + _resultValue.healthCheckPeriod = healthCheckPeriod; + _resultValue.host = host; + _resultValue.path = path; + _resultValue.pathStyle = pathStyle; + _resultValue.region = region; + _resultValue.secretKey = secretKey; + _resultValue.secure = secure; + _resultValue.storageClass = storageClass; + _resultValue.syncronous = syncronous; + return _resultValue; + } + } +} diff --git a/sdk/nodejs/index.ts b/sdk/nodejs/index.ts index 9ecc457..4e4b470 100644 --- a/sdk/nodejs/index.ts +++ b/sdk/nodejs/index.ts @@ -85,6 +85,11 @@ export type S3BucketPolicy = import("./s3bucketPolicy").S3BucketPolicy; export const S3BucketPolicy: typeof import("./s3bucketPolicy").S3BucketPolicy = null as any; utilities.lazyLoad(exports, ["S3BucketPolicy"], () => require("./s3bucketPolicy")); +export { S3BucketReplicationArgs, S3BucketReplicationState } from "./s3bucketReplication"; +export type S3BucketReplication = import("./s3bucketReplication").S3BucketReplication; +export const S3BucketReplication: typeof import("./s3bucketReplication").S3BucketReplication = null as any; +utilities.lazyLoad(exports, ["S3BucketReplication"], () => require("./s3bucketReplication")); + export { S3BucketServerSideEncryptionArgs, S3BucketServerSideEncryptionState } from "./s3bucketServerSideEncryption"; export type S3BucketServerSideEncryption = import("./s3bucketServerSideEncryption").S3BucketServerSideEncryption; export const S3BucketServerSideEncryption: typeof import("./s3bucketServerSideEncryption").S3BucketServerSideEncryption = null as any; @@ -142,6 +147,8 @@ const _module = { return new S3BucketNotification(name, undefined, { urn }) case "minio:index/s3BucketPolicy:S3BucketPolicy": return new S3BucketPolicy(name, undefined, { urn }) + case "minio:index/s3BucketReplication:S3BucketReplication": + return new S3BucketReplication(name, undefined, { urn }) case "minio:index/s3BucketServerSideEncryption:S3BucketServerSideEncryption": return new S3BucketServerSideEncryption(name, undefined, { urn }) case "minio:index/s3BucketVersioning:S3BucketVersioning": @@ -167,6 +174,7 @@ pulumi.runtime.registerResourceModule("minio", "index/kmsKey", _module) pulumi.runtime.registerResourceModule("minio", "index/s3Bucket", _module) pulumi.runtime.registerResourceModule("minio", "index/s3BucketNotification", _module) pulumi.runtime.registerResourceModule("minio", "index/s3BucketPolicy", _module) +pulumi.runtime.registerResourceModule("minio", "index/s3BucketReplication", _module) pulumi.runtime.registerResourceModule("minio", "index/s3BucketServerSideEncryption", _module) pulumi.runtime.registerResourceModule("minio", "index/s3BucketVersioning", _module) pulumi.runtime.registerResourceModule("minio", "index/s3Object", _module) diff --git a/sdk/nodejs/s3bucketReplication.ts b/sdk/nodejs/s3bucketReplication.ts new file mode 100644 index 0000000..4a19136 --- /dev/null +++ b/sdk/nodejs/s3bucketReplication.ts @@ -0,0 +1,243 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as inputs from "./types/input"; +import * as outputs from "./types/output"; +import * as utilities from "./utilities"; + +/** + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as minio from "@pulumi/minio"; + * + * const myBucketInAS3Bucket = new minio.S3Bucket("myBucketInAS3Bucket", {bucket: "my-bucket"}); + * const myBucketInBS3Bucket = new minio.S3Bucket("myBucketInBS3Bucket", {bucket: "my-bucket"}, { + * provider: minio.deployment_b, + * }); + * const myBucketInAS3BucketVersioning = new minio.S3BucketVersioning("myBucketInAS3BucketVersioning", { + * bucket: myBucketInAS3Bucket.bucket, + * versioningConfiguration: { + * status: "Enabled", + * }, + * }); + * const myBucketInBS3BucketVersioning = new minio.S3BucketVersioning("myBucketInBS3BucketVersioning", { + * bucket: myBucketInBS3Bucket.bucket, + * versioningConfiguration: { + * status: "Enabled", + * }, + * }, { + * provider: minio.deployment_b, + * }); + * const replicationPolicy = minio.getIamPolicyDocument({ + * statements: [ + * { + * sid: "ReadBuckets", + * effect: "Allow", + * resources: ["arn:aws:s3:::*"], + * actions: ["s3:ListBucket"], + * }, + * { + * sid: "EnableReplicationOnBucket", + * effect: "Allow", + * resources: ["arn:aws:s3:::my-bucket"], + * actions: [ + * "s3:GetReplicationConfiguration", + * "s3:ListBucket", + * "s3:ListBucketMultipartUploads", + * "s3:GetBucketLocation", + * "s3:GetBucketVersioning", + * "s3:GetBucketObjectLockConfiguration", + * "s3:GetEncryptionConfiguration", + * ], + * }, + * { + * sid: "EnableReplicatingDataIntoBucket", + * effect: "Allow", + * resources: ["arn:aws:s3:::my-bucket/*"], + * actions: [ + * "s3:GetReplicationConfiguration", + * "s3:ReplicateTags", + * "s3:AbortMultipartUpload", + * "s3:GetObject", + * "s3:GetObjectVersion", + * "s3:GetObjectVersionTagging", + * "s3:PutObject", + * "s3:PutObjectRetention", + * "s3:PutBucketObjectLockConfiguration", + * "s3:PutObjectLegalHold", + * "s3:DeleteObject", + * "s3:ReplicateObject", + * "s3:ReplicateDelete", + * ], + * }, + * ], + * }); + * // One-Way replication (A -> B) + * const replicationInBIamPolicy = new minio.IamPolicy("replicationInBIamPolicy", {policy: replicationPolicy.then(replicationPolicy => replicationPolicy.json)}, { + * provider: minio.deployment_b, + * }); + * const replicationInBIamUser = new minio.IamUser("replicationInBIamUser", {forceDestroy: true}, { + * provider: minio.deployment_b, + * }); + * const replicationInBIamUserPolicyAttachment = new minio.IamUserPolicyAttachment("replicationInBIamUserPolicyAttachment", { + * userName: replicationInBIamUser.name, + * policyName: replicationInBIamPolicy.id, + * }, { + * provider: minio.deployment_b, + * }); + * const replicationInBIamServiceAccount = new minio.IamServiceAccount("replicationInBIamServiceAccount", {targetUser: replicationInBIamUser.name}, { + * provider: minio.deployment_b, + * dependsOn: [replicationInBIamUserPolicyAttachment], + * }); + * const replicationInBS3BucketReplication = new minio.S3BucketReplication("replicationInBS3BucketReplication", { + * bucket: myBucketInAS3Bucket.bucket, + * rules: [{ + * deleteReplication: true, + * deleteMarkerReplication: true, + * existingObjectReplication: true, + * metadataSync: true, + * target: { + * bucket: myBucketInBS3Bucket.bucket, + * secure: false, + * host: _var.minio_server_b, + * bandwidthLimt: "100M", + * accessKey: replicationInBIamServiceAccount.accessKey, + * secretKey: replicationInBIamServiceAccount.secretKey, + * }, + * }], + * }, { + * dependsOn: [ + * myBucketInAS3BucketVersioning, + * myBucketInBS3BucketVersioning, + * ], + * }); + * // Two-Way replication (A <-> B) + * const replicationInAIamPolicy = new minio.IamPolicy("replicationInAIamPolicy", {policy: replicationPolicy.then(replicationPolicy => replicationPolicy.json)}); + * const replicationInAIamUser = new minio.IamUser("replicationInAIamUser", {forceDestroy: true}); + * const replicationInAIamUserPolicyAttachment = new minio.IamUserPolicyAttachment("replicationInAIamUserPolicyAttachment", { + * userName: replicationInAIamUser.name, + * policyName: replicationInAIamPolicy.id, + * }); + * const replicationInAIamServiceAccount = new minio.IamServiceAccount("replicationInAIamServiceAccount", {targetUser: replicationInAIamUser.name}, { + * dependsOn: [replicationInBIamUserPolicyAttachment], + * }); + * const replicationInAS3BucketReplication = new minio.S3BucketReplication("replicationInAS3BucketReplication", { + * bucket: myBucketInBS3Bucket.bucket, + * rules: [{ + * deleteReplication: true, + * deleteMarkerReplication: true, + * existingObjectReplication: true, + * metadataSync: true, + * target: { + * bucket: myBucketInAS3Bucket.bucket, + * host: _var.minio_server_a, + * secure: false, + * bandwidthLimt: "100M", + * accessKey: replicationInAIamServiceAccount.accessKey, + * secretKey: replicationInAIamServiceAccount.secretKey, + * }, + * }], + * }, { + * provider: minio.deployment_b, + * dependsOn: [ + * myBucketInAS3BucketVersioning, + * myBucketInBS3BucketVersioning, + * ], + * }); + * ``` + */ +export class S3BucketReplication extends pulumi.CustomResource { + /** + * Get an existing S3BucketReplication resource's state with the given name, ID, and optional extra + * properties used to qualify the lookup. + * + * @param name The _unique_ name of the resulting resource. + * @param id The _unique_ provider ID of the resource to lookup. + * @param state Any extra arguments used during the lookup. + * @param opts Optional settings to control the behavior of the CustomResource. + */ + public static get(name: string, id: pulumi.Input, state?: S3BucketReplicationState, opts?: pulumi.CustomResourceOptions): S3BucketReplication { + return new S3BucketReplication(name, state, { ...opts, id: id }); + } + + /** @internal */ + public static readonly __pulumiType = 'minio:index/s3BucketReplication:S3BucketReplication'; + + /** + * Returns true if the given object is an instance of S3BucketReplication. This is designed to work even + * when multiple copies of the Pulumi SDK have been loaded into the same process. + */ + public static isInstance(obj: any): obj is S3BucketReplication { + if (obj === undefined || obj === null) { + return false; + } + return obj['__pulumiType'] === S3BucketReplication.__pulumiType; + } + + /** + * The name of the existing target bucket to replicate into + */ + public readonly bucket!: pulumi.Output; + /** + * Rule definitions + */ + public readonly rules!: pulumi.Output; + + /** + * Create a S3BucketReplication resource with the given unique name, arguments, and options. + * + * @param name The _unique_ name of the resource. + * @param args The arguments to use to populate this resource's properties. + * @param opts A bag of options that control this resource's behavior. + */ + constructor(name: string, args: S3BucketReplicationArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, argsOrState?: S3BucketReplicationArgs | S3BucketReplicationState, opts?: pulumi.CustomResourceOptions) { + let resourceInputs: pulumi.Inputs = {}; + opts = opts || {}; + if (opts.id) { + const state = argsOrState as S3BucketReplicationState | undefined; + resourceInputs["bucket"] = state ? state.bucket : undefined; + resourceInputs["rules"] = state ? state.rules : undefined; + } else { + const args = argsOrState as S3BucketReplicationArgs | undefined; + if ((!args || args.bucket === undefined) && !opts.urn) { + throw new Error("Missing required property 'bucket'"); + } + resourceInputs["bucket"] = args ? args.bucket : undefined; + resourceInputs["rules"] = args ? args.rules : undefined; + } + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); + super(S3BucketReplication.__pulumiType, name, resourceInputs, opts); + } +} + +/** + * Input properties used for looking up and filtering S3BucketReplication resources. + */ +export interface S3BucketReplicationState { + /** + * The name of the existing target bucket to replicate into + */ + bucket?: pulumi.Input; + /** + * Rule definitions + */ + rules?: pulumi.Input[]>; +} + +/** + * The set of arguments for constructing a S3BucketReplication resource. + */ +export interface S3BucketReplicationArgs { + /** + * The name of the existing target bucket to replicate into + */ + bucket: pulumi.Input; + /** + * Rule definitions + */ + rules?: pulumi.Input[]>; +} diff --git a/sdk/nodejs/tsconfig.json b/sdk/nodejs/tsconfig.json index efad822..0203bff 100644 --- a/sdk/nodejs/tsconfig.json +++ b/sdk/nodejs/tsconfig.json @@ -32,6 +32,7 @@ "s3bucket.ts", "s3bucketNotification.ts", "s3bucketPolicy.ts", + "s3bucketReplication.ts", "s3bucketServerSideEncryption.ts", "s3bucketVersioning.ts", "s3object.ts", diff --git a/sdk/nodejs/types/input.ts b/sdk/nodejs/types/input.ts index 8cab178..2c89b26 100644 --- a/sdk/nodejs/types/input.ts +++ b/sdk/nodejs/types/input.ts @@ -58,6 +58,105 @@ export interface S3BucketNotificationQueue { queueArn: pulumi.Input; } +export interface S3BucketReplicationRule { + /** + * Rule ARN genrated by MinIO + */ + arn?: pulumi.Input; + /** + * Whether or not to synchronise marker deletion + */ + deleteMarkerReplication?: pulumi.Input; + /** + * Whether or not to propagate deletion + */ + deleteReplication?: pulumi.Input; + /** + * Whether or not this rule is enabled + */ + enabled?: pulumi.Input; + /** + * Whether or not to synchronise object created prior the replication configuration + */ + existingObjectReplication?: pulumi.Input; + /** + * Rule ID generated by MinIO + */ + id?: pulumi.Input; + /** + * Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + */ + metadataSync?: pulumi.Input; + /** + * Bucket prefix object must be in to be syncronised + */ + prefix?: pulumi.Input; + /** + * Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + */ + priority?: pulumi.Input; + /** + * Tags which objects must have to be syncronised + */ + tags?: pulumi.Input<{[key: string]: any}>; + /** + * Bucket prefix + */ + target: pulumi.Input; +} + +export interface S3BucketReplicationRuleTarget { + /** + * Access key for the replication service account in the target MinIO + */ + accessKey: pulumi.Input; + /** + * Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + */ + bandwidthLimt?: pulumi.Input; + /** + * The name of the existing target bucket to replicate into + */ + bucket: pulumi.Input; + /** + * Disable proxy for this target + */ + disableProxy?: pulumi.Input; + /** + * Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + */ + healthCheckPeriod?: pulumi.Input; + /** + * The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + */ + host: pulumi.Input; + /** + * Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + */ + path?: pulumi.Input; + /** + * Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + */ + pathStyle?: pulumi.Input; + /** + * Region of the target MinIO. This will be used to generate the target ARN + */ + region?: pulumi.Input; + /** + * Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + */ + secretKey?: pulumi.Input; + secure?: pulumi.Input; + /** + * The storage class to use for the object on this target + */ + storageClass?: pulumi.Input; + /** + * Use synchronous replication. + */ + syncronous?: pulumi.Input; +} + export interface S3BucketVersioningVersioningConfiguration { excludeFolders?: pulumi.Input; excludedPrefixes?: pulumi.Input[]>; diff --git a/sdk/nodejs/types/output.ts b/sdk/nodejs/types/output.ts index 92a494d..d50cde5 100644 --- a/sdk/nodejs/types/output.ts +++ b/sdk/nodejs/types/output.ts @@ -43,6 +43,105 @@ export interface S3BucketNotificationQueue { queueArn: string; } +export interface S3BucketReplicationRule { + /** + * Rule ARN genrated by MinIO + */ + arn: string; + /** + * Whether or not to synchronise marker deletion + */ + deleteMarkerReplication?: boolean; + /** + * Whether or not to propagate deletion + */ + deleteReplication?: boolean; + /** + * Whether or not this rule is enabled + */ + enabled?: boolean; + /** + * Whether or not to synchronise object created prior the replication configuration + */ + existingObjectReplication?: boolean; + /** + * Rule ID generated by MinIO + */ + id: string; + /** + * Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + */ + metadataSync?: boolean; + /** + * Bucket prefix object must be in to be syncronised + */ + prefix?: string; + /** + * Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + */ + priority?: number; + /** + * Tags which objects must have to be syncronised + */ + tags?: {[key: string]: any}; + /** + * Bucket prefix + */ + target: outputs.S3BucketReplicationRuleTarget; +} + +export interface S3BucketReplicationRuleTarget { + /** + * Access key for the replication service account in the target MinIO + */ + accessKey: string; + /** + * Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + */ + bandwidthLimt?: string; + /** + * The name of the existing target bucket to replicate into + */ + bucket: string; + /** + * Disable proxy for this target + */ + disableProxy?: boolean; + /** + * Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + */ + healthCheckPeriod?: string; + /** + * The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + */ + host: string; + /** + * Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + */ + path?: string; + /** + * Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + */ + pathStyle?: string; + /** + * Region of the target MinIO. This will be used to generate the target ARN + */ + region?: string; + /** + * Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + */ + secretKey?: string; + secure?: boolean; + /** + * The storage class to use for the object on this target + */ + storageClass?: string; + /** + * Use synchronous replication. + */ + syncronous?: boolean; +} + export interface S3BucketVersioningVersioningConfiguration { excludeFolders?: boolean; excludedPrefixes?: string[]; diff --git a/sdk/python/README.md b/sdk/python/README.md index a89d887..d32b13c 100644 --- a/sdk/python/README.md +++ b/sdk/python/README.md @@ -34,7 +34,7 @@ To use from Python, install using `pip`: To use from Go, use `go get` to grab the latest version of the library - $ go get github.com/pulumi/pulumi-minio/sdk + $ go get github.com/pulumi/pulumi-minio/sdk/v2 ### .NET diff --git a/sdk/python/pulumi_minio/__init__.py b/sdk/python/pulumi_minio/__init__.py index 7852ffd..74e1677 100644 --- a/sdk/python/pulumi_minio/__init__.py +++ b/sdk/python/pulumi_minio/__init__.py @@ -21,6 +21,7 @@ from .s3_bucket import * from .s3_bucket_notification import * from .s3_bucket_policy import * +from .s3_bucket_replication import * from .s3_bucket_server_side_encryption import * from .s3_bucket_versioning import * from .s3_object import * @@ -149,6 +150,14 @@ "minio:index/s3BucketPolicy:S3BucketPolicy": "S3BucketPolicy" } }, + { + "pkg": "minio", + "mod": "index/s3BucketReplication", + "fqn": "pulumi_minio", + "classes": { + "minio:index/s3BucketReplication:S3BucketReplication": "S3BucketReplication" + } + }, { "pkg": "minio", "mod": "index/s3BucketServerSideEncryption", diff --git a/sdk/python/pulumi_minio/_inputs.py b/sdk/python/pulumi_minio/_inputs.py index e8aaac2..9cb47cf 100644 --- a/sdk/python/pulumi_minio/_inputs.py +++ b/sdk/python/pulumi_minio/_inputs.py @@ -12,6 +12,8 @@ __all__ = [ 'IlmPolicyRuleArgs', 'S3BucketNotificationQueueArgs', + 'S3BucketReplicationRuleArgs', + 'S3BucketReplicationRuleTargetArgs', 'S3BucketVersioningVersioningConfigurationArgs', 'GetIamPolicyDocumentStatementArgs', 'GetIamPolicyDocumentStatementConditionArgs', @@ -168,6 +170,396 @@ def id(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "id", value) +@pulumi.input_type +class S3BucketReplicationRuleArgs: + def __init__(__self__, *, + target: pulumi.Input['S3BucketReplicationRuleTargetArgs'], + arn: Optional[pulumi.Input[str]] = None, + delete_marker_replication: Optional[pulumi.Input[bool]] = None, + delete_replication: Optional[pulumi.Input[bool]] = None, + enabled: Optional[pulumi.Input[bool]] = None, + existing_object_replication: Optional[pulumi.Input[bool]] = None, + id: Optional[pulumi.Input[str]] = None, + metadata_sync: Optional[pulumi.Input[bool]] = None, + prefix: Optional[pulumi.Input[str]] = None, + priority: Optional[pulumi.Input[int]] = None, + tags: Optional[pulumi.Input[Mapping[str, Any]]] = None): + """ + :param pulumi.Input['S3BucketReplicationRuleTargetArgs'] target: Bucket prefix + :param pulumi.Input[str] arn: Rule ARN genrated by MinIO + :param pulumi.Input[bool] delete_marker_replication: Whether or not to synchronise marker deletion + :param pulumi.Input[bool] delete_replication: Whether or not to propagate deletion + :param pulumi.Input[bool] enabled: Whether or not this rule is enabled + :param pulumi.Input[bool] existing_object_replication: Whether or not to synchronise object created prior the replication configuration + :param pulumi.Input[str] id: Rule ID generated by MinIO + :param pulumi.Input[bool] metadata_sync: Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + :param pulumi.Input[str] prefix: Bucket prefix object must be in to be syncronised + :param pulumi.Input[int] priority: Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + :param pulumi.Input[Mapping[str, Any]] tags: Tags which objects must have to be syncronised + """ + pulumi.set(__self__, "target", target) + if arn is not None: + pulumi.set(__self__, "arn", arn) + if delete_marker_replication is not None: + pulumi.set(__self__, "delete_marker_replication", delete_marker_replication) + if delete_replication is not None: + pulumi.set(__self__, "delete_replication", delete_replication) + if enabled is not None: + pulumi.set(__self__, "enabled", enabled) + if existing_object_replication is not None: + pulumi.set(__self__, "existing_object_replication", existing_object_replication) + if id is not None: + pulumi.set(__self__, "id", id) + if metadata_sync is not None: + pulumi.set(__self__, "metadata_sync", metadata_sync) + if prefix is not None: + pulumi.set(__self__, "prefix", prefix) + if priority is not None: + pulumi.set(__self__, "priority", priority) + if tags is not None: + pulumi.set(__self__, "tags", tags) + + @property + @pulumi.getter + def target(self) -> pulumi.Input['S3BucketReplicationRuleTargetArgs']: + """ + Bucket prefix + """ + return pulumi.get(self, "target") + + @target.setter + def target(self, value: pulumi.Input['S3BucketReplicationRuleTargetArgs']): + pulumi.set(self, "target", value) + + @property + @pulumi.getter + def arn(self) -> Optional[pulumi.Input[str]]: + """ + Rule ARN genrated by MinIO + """ + return pulumi.get(self, "arn") + + @arn.setter + def arn(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "arn", value) + + @property + @pulumi.getter(name="deleteMarkerReplication") + def delete_marker_replication(self) -> Optional[pulumi.Input[bool]]: + """ + Whether or not to synchronise marker deletion + """ + return pulumi.get(self, "delete_marker_replication") + + @delete_marker_replication.setter + def delete_marker_replication(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "delete_marker_replication", value) + + @property + @pulumi.getter(name="deleteReplication") + def delete_replication(self) -> Optional[pulumi.Input[bool]]: + """ + Whether or not to propagate deletion + """ + return pulumi.get(self, "delete_replication") + + @delete_replication.setter + def delete_replication(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "delete_replication", value) + + @property + @pulumi.getter + def enabled(self) -> Optional[pulumi.Input[bool]]: + """ + Whether or not this rule is enabled + """ + return pulumi.get(self, "enabled") + + @enabled.setter + def enabled(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "enabled", value) + + @property + @pulumi.getter(name="existingObjectReplication") + def existing_object_replication(self) -> Optional[pulumi.Input[bool]]: + """ + Whether or not to synchronise object created prior the replication configuration + """ + return pulumi.get(self, "existing_object_replication") + + @existing_object_replication.setter + def existing_object_replication(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "existing_object_replication", value) + + @property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[str]]: + """ + Rule ID generated by MinIO + """ + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "id", value) + + @property + @pulumi.getter(name="metadataSync") + def metadata_sync(self) -> Optional[pulumi.Input[bool]]: + """ + Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + """ + return pulumi.get(self, "metadata_sync") + + @metadata_sync.setter + def metadata_sync(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "metadata_sync", value) + + @property + @pulumi.getter + def prefix(self) -> Optional[pulumi.Input[str]]: + """ + Bucket prefix object must be in to be syncronised + """ + return pulumi.get(self, "prefix") + + @prefix.setter + def prefix(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "prefix", value) + + @property + @pulumi.getter + def priority(self) -> Optional[pulumi.Input[int]]: + """ + Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + """ + return pulumi.get(self, "priority") + + @priority.setter + def priority(self, value: Optional[pulumi.Input[int]]): + pulumi.set(self, "priority", value) + + @property + @pulumi.getter + def tags(self) -> Optional[pulumi.Input[Mapping[str, Any]]]: + """ + Tags which objects must have to be syncronised + """ + return pulumi.get(self, "tags") + + @tags.setter + def tags(self, value: Optional[pulumi.Input[Mapping[str, Any]]]): + pulumi.set(self, "tags", value) + + +@pulumi.input_type +class S3BucketReplicationRuleTargetArgs: + def __init__(__self__, *, + access_key: pulumi.Input[str], + bucket: pulumi.Input[str], + host: pulumi.Input[str], + bandwidth_limt: Optional[pulumi.Input[str]] = None, + disable_proxy: Optional[pulumi.Input[bool]] = None, + health_check_period: Optional[pulumi.Input[str]] = None, + path: Optional[pulumi.Input[str]] = None, + path_style: Optional[pulumi.Input[str]] = None, + region: Optional[pulumi.Input[str]] = None, + secret_key: Optional[pulumi.Input[str]] = None, + secure: Optional[pulumi.Input[bool]] = None, + storage_class: Optional[pulumi.Input[str]] = None, + syncronous: Optional[pulumi.Input[bool]] = None): + """ + :param pulumi.Input[str] access_key: Access key for the replication service account in the target MinIO + :param pulumi.Input[str] bucket: The name of the existing target bucket to replicate into + :param pulumi.Input[str] host: The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + :param pulumi.Input[str] bandwidth_limt: Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + :param pulumi.Input[bool] disable_proxy: Disable proxy for this target + :param pulumi.Input[str] health_check_period: Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + :param pulumi.Input[str] path: Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + :param pulumi.Input[str] path_style: Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + :param pulumi.Input[str] region: Region of the target MinIO. This will be used to generate the target ARN + :param pulumi.Input[str] secret_key: Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + :param pulumi.Input[str] storage_class: The storage class to use for the object on this target + :param pulumi.Input[bool] syncronous: Use synchronous replication. + """ + pulumi.set(__self__, "access_key", access_key) + pulumi.set(__self__, "bucket", bucket) + pulumi.set(__self__, "host", host) + if bandwidth_limt is not None: + pulumi.set(__self__, "bandwidth_limt", bandwidth_limt) + if disable_proxy is not None: + pulumi.set(__self__, "disable_proxy", disable_proxy) + if health_check_period is not None: + pulumi.set(__self__, "health_check_period", health_check_period) + if path is not None: + pulumi.set(__self__, "path", path) + if path_style is not None: + pulumi.set(__self__, "path_style", path_style) + if region is not None: + pulumi.set(__self__, "region", region) + if secret_key is not None: + pulumi.set(__self__, "secret_key", secret_key) + if secure is not None: + pulumi.set(__self__, "secure", secure) + if storage_class is not None: + pulumi.set(__self__, "storage_class", storage_class) + if syncronous is not None: + pulumi.set(__self__, "syncronous", syncronous) + + @property + @pulumi.getter(name="accessKey") + def access_key(self) -> pulumi.Input[str]: + """ + Access key for the replication service account in the target MinIO + """ + return pulumi.get(self, "access_key") + + @access_key.setter + def access_key(self, value: pulumi.Input[str]): + pulumi.set(self, "access_key", value) + + @property + @pulumi.getter + def bucket(self) -> pulumi.Input[str]: + """ + The name of the existing target bucket to replicate into + """ + return pulumi.get(self, "bucket") + + @bucket.setter + def bucket(self, value: pulumi.Input[str]): + pulumi.set(self, "bucket", value) + + @property + @pulumi.getter + def host(self) -> pulumi.Input[str]: + """ + The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + """ + return pulumi.get(self, "host") + + @host.setter + def host(self, value: pulumi.Input[str]): + pulumi.set(self, "host", value) + + @property + @pulumi.getter(name="bandwidthLimt") + def bandwidth_limt(self) -> Optional[pulumi.Input[str]]: + """ + Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + """ + return pulumi.get(self, "bandwidth_limt") + + @bandwidth_limt.setter + def bandwidth_limt(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bandwidth_limt", value) + + @property + @pulumi.getter(name="disableProxy") + def disable_proxy(self) -> Optional[pulumi.Input[bool]]: + """ + Disable proxy for this target + """ + return pulumi.get(self, "disable_proxy") + + @disable_proxy.setter + def disable_proxy(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "disable_proxy", value) + + @property + @pulumi.getter(name="healthCheckPeriod") + def health_check_period(self) -> Optional[pulumi.Input[str]]: + """ + Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + """ + return pulumi.get(self, "health_check_period") + + @health_check_period.setter + def health_check_period(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "health_check_period", value) + + @property + @pulumi.getter + def path(self) -> Optional[pulumi.Input[str]]: + """ + Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + """ + return pulumi.get(self, "path") + + @path.setter + def path(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "path", value) + + @property + @pulumi.getter(name="pathStyle") + def path_style(self) -> Optional[pulumi.Input[str]]: + """ + Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + """ + return pulumi.get(self, "path_style") + + @path_style.setter + def path_style(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "path_style", value) + + @property + @pulumi.getter + def region(self) -> Optional[pulumi.Input[str]]: + """ + Region of the target MinIO. This will be used to generate the target ARN + """ + return pulumi.get(self, "region") + + @region.setter + def region(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "region", value) + + @property + @pulumi.getter(name="secretKey") + def secret_key(self) -> Optional[pulumi.Input[str]]: + """ + Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + """ + return pulumi.get(self, "secret_key") + + @secret_key.setter + def secret_key(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "secret_key", value) + + @property + @pulumi.getter + def secure(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "secure") + + @secure.setter + def secure(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "secure", value) + + @property + @pulumi.getter(name="storageClass") + def storage_class(self) -> Optional[pulumi.Input[str]]: + """ + The storage class to use for the object on this target + """ + return pulumi.get(self, "storage_class") + + @storage_class.setter + def storage_class(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "storage_class", value) + + @property + @pulumi.getter + def syncronous(self) -> Optional[pulumi.Input[bool]]: + """ + Use synchronous replication. + """ + return pulumi.get(self, "syncronous") + + @syncronous.setter + def syncronous(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "syncronous", value) + + @pulumi.input_type class S3BucketVersioningVersioningConfigurationArgs: def __init__(__self__, *, diff --git a/sdk/python/pulumi_minio/outputs.py b/sdk/python/pulumi_minio/outputs.py index 621652a..593cec4 100644 --- a/sdk/python/pulumi_minio/outputs.py +++ b/sdk/python/pulumi_minio/outputs.py @@ -13,6 +13,8 @@ __all__ = [ 'IlmPolicyRule', 'S3BucketNotificationQueue', + 'S3BucketReplicationRule', + 'S3BucketReplicationRuleTarget', 'S3BucketVersioningVersioningConfiguration', 'GetIamPolicyDocumentStatementResult', 'GetIamPolicyDocumentStatementConditionResult', @@ -163,6 +165,352 @@ def id(self) -> Optional[str]: return pulumi.get(self, "id") +@pulumi.output_type +class S3BucketReplicationRule(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "deleteMarkerReplication": + suggest = "delete_marker_replication" + elif key == "deleteReplication": + suggest = "delete_replication" + elif key == "existingObjectReplication": + suggest = "existing_object_replication" + elif key == "metadataSync": + suggest = "metadata_sync" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in S3BucketReplicationRule. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + S3BucketReplicationRule.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + S3BucketReplicationRule.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + target: 'outputs.S3BucketReplicationRuleTarget', + arn: Optional[str] = None, + delete_marker_replication: Optional[bool] = None, + delete_replication: Optional[bool] = None, + enabled: Optional[bool] = None, + existing_object_replication: Optional[bool] = None, + id: Optional[str] = None, + metadata_sync: Optional[bool] = None, + prefix: Optional[str] = None, + priority: Optional[int] = None, + tags: Optional[Mapping[str, Any]] = None): + """ + :param 'S3BucketReplicationRuleTargetArgs' target: Bucket prefix + :param str arn: Rule ARN genrated by MinIO + :param bool delete_marker_replication: Whether or not to synchronise marker deletion + :param bool delete_replication: Whether or not to propagate deletion + :param bool enabled: Whether or not this rule is enabled + :param bool existing_object_replication: Whether or not to synchronise object created prior the replication configuration + :param str id: Rule ID generated by MinIO + :param bool metadata_sync: Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + :param str prefix: Bucket prefix object must be in to be syncronised + :param int priority: Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + :param Mapping[str, Any] tags: Tags which objects must have to be syncronised + """ + pulumi.set(__self__, "target", target) + if arn is not None: + pulumi.set(__self__, "arn", arn) + if delete_marker_replication is not None: + pulumi.set(__self__, "delete_marker_replication", delete_marker_replication) + if delete_replication is not None: + pulumi.set(__self__, "delete_replication", delete_replication) + if enabled is not None: + pulumi.set(__self__, "enabled", enabled) + if existing_object_replication is not None: + pulumi.set(__self__, "existing_object_replication", existing_object_replication) + if id is not None: + pulumi.set(__self__, "id", id) + if metadata_sync is not None: + pulumi.set(__self__, "metadata_sync", metadata_sync) + if prefix is not None: + pulumi.set(__self__, "prefix", prefix) + if priority is not None: + pulumi.set(__self__, "priority", priority) + if tags is not None: + pulumi.set(__self__, "tags", tags) + + @property + @pulumi.getter + def target(self) -> 'outputs.S3BucketReplicationRuleTarget': + """ + Bucket prefix + """ + return pulumi.get(self, "target") + + @property + @pulumi.getter + def arn(self) -> Optional[str]: + """ + Rule ARN genrated by MinIO + """ + return pulumi.get(self, "arn") + + @property + @pulumi.getter(name="deleteMarkerReplication") + def delete_marker_replication(self) -> Optional[bool]: + """ + Whether or not to synchronise marker deletion + """ + return pulumi.get(self, "delete_marker_replication") + + @property + @pulumi.getter(name="deleteReplication") + def delete_replication(self) -> Optional[bool]: + """ + Whether or not to propagate deletion + """ + return pulumi.get(self, "delete_replication") + + @property + @pulumi.getter + def enabled(self) -> Optional[bool]: + """ + Whether or not this rule is enabled + """ + return pulumi.get(self, "enabled") + + @property + @pulumi.getter(name="existingObjectReplication") + def existing_object_replication(self) -> Optional[bool]: + """ + Whether or not to synchronise object created prior the replication configuration + """ + return pulumi.get(self, "existing_object_replication") + + @property + @pulumi.getter + def id(self) -> Optional[str]: + """ + Rule ID generated by MinIO + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="metadataSync") + def metadata_sync(self) -> Optional[bool]: + """ + Whether or not to synchonise buckets and objects metadata (such as locks). This must be enabled to achieve a two-way replication + """ + return pulumi.get(self, "metadata_sync") + + @property + @pulumi.getter + def prefix(self) -> Optional[str]: + """ + Bucket prefix object must be in to be syncronised + """ + return pulumi.get(self, "prefix") + + @property + @pulumi.getter + def priority(self) -> Optional[int]: + """ + Rule priority. If omitted, the inverted index will be used as priority. This means that the first rule definition will have the higher priority + """ + return pulumi.get(self, "priority") + + @property + @pulumi.getter + def tags(self) -> Optional[Mapping[str, Any]]: + """ + Tags which objects must have to be syncronised + """ + return pulumi.get(self, "tags") + + +@pulumi.output_type +class S3BucketReplicationRuleTarget(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "accessKey": + suggest = "access_key" + elif key == "bandwidthLimt": + suggest = "bandwidth_limt" + elif key == "disableProxy": + suggest = "disable_proxy" + elif key == "healthCheckPeriod": + suggest = "health_check_period" + elif key == "pathStyle": + suggest = "path_style" + elif key == "secretKey": + suggest = "secret_key" + elif key == "storageClass": + suggest = "storage_class" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in S3BucketReplicationRuleTarget. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + S3BucketReplicationRuleTarget.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + S3BucketReplicationRuleTarget.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + access_key: str, + bucket: str, + host: str, + bandwidth_limt: Optional[str] = None, + disable_proxy: Optional[bool] = None, + health_check_period: Optional[str] = None, + path: Optional[str] = None, + path_style: Optional[str] = None, + region: Optional[str] = None, + secret_key: Optional[str] = None, + secure: Optional[bool] = None, + storage_class: Optional[str] = None, + syncronous: Optional[bool] = None): + """ + :param str access_key: Access key for the replication service account in the target MinIO + :param str bucket: The name of the existing target bucket to replicate into + :param str host: The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + :param str bandwidth_limt: Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + :param bool disable_proxy: Disable proxy for this target + :param str health_check_period: Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + :param str path: Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + :param str path_style: Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + :param str region: Region of the target MinIO. This will be used to generate the target ARN + :param str secret_key: Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + :param str storage_class: The storage class to use for the object on this target + :param bool syncronous: Use synchronous replication. + """ + pulumi.set(__self__, "access_key", access_key) + pulumi.set(__self__, "bucket", bucket) + pulumi.set(__self__, "host", host) + if bandwidth_limt is not None: + pulumi.set(__self__, "bandwidth_limt", bandwidth_limt) + if disable_proxy is not None: + pulumi.set(__self__, "disable_proxy", disable_proxy) + if health_check_period is not None: + pulumi.set(__self__, "health_check_period", health_check_period) + if path is not None: + pulumi.set(__self__, "path", path) + if path_style is not None: + pulumi.set(__self__, "path_style", path_style) + if region is not None: + pulumi.set(__self__, "region", region) + if secret_key is not None: + pulumi.set(__self__, "secret_key", secret_key) + if secure is not None: + pulumi.set(__self__, "secure", secure) + if storage_class is not None: + pulumi.set(__self__, "storage_class", storage_class) + if syncronous is not None: + pulumi.set(__self__, "syncronous", syncronous) + + @property + @pulumi.getter(name="accessKey") + def access_key(self) -> str: + """ + Access key for the replication service account in the target MinIO + """ + return pulumi.get(self, "access_key") + + @property + @pulumi.getter + def bucket(self) -> str: + """ + The name of the existing target bucket to replicate into + """ + return pulumi.get(self, "bucket") + + @property + @pulumi.getter + def host(self) -> str: + """ + The target host (pair IP/port or domain port). If port is omitted, HTTPS port (or HTTP if unsecure) will be used. This host must be reachable by the MinIO instance itself + """ + return pulumi.get(self, "host") + + @property + @pulumi.getter(name="bandwidthLimt") + def bandwidth_limt(self) -> Optional[str]: + """ + Maximum bandwidth in byte per second that MinIO can used when syncronysing this target. Minimum is 100MB + """ + return pulumi.get(self, "bandwidth_limt") + + @property + @pulumi.getter(name="disableProxy") + def disable_proxy(self) -> Optional[bool]: + """ + Disable proxy for this target + """ + return pulumi.get(self, "disable_proxy") + + @property + @pulumi.getter(name="healthCheckPeriod") + def health_check_period(self) -> Optional[str]: + """ + Period where the health of this target will be checked. This must be a valid duration, such as `5s` or `2m` + """ + return pulumi.get(self, "health_check_period") + + @property + @pulumi.getter + def path(self) -> Optional[str]: + """ + Path of the Minio endpoint. This is usefull if MinIO API isn't served on at the root, e.g for `example.com/minio/`, the path would be `/minio/` + """ + return pulumi.get(self, "path") + + @property + @pulumi.getter(name="pathStyle") + def path_style(self) -> Optional[str]: + """ + Whether to use path-style or virtual-hosted-syle request to this target (https://docs.aws.amazon.com/AmazonS3/latest/userguide/VirtualHosting.html#path-style-access). `auto` allows MinIO to chose automatically the appropriate option (Recommened)` + """ + return pulumi.get(self, "path_style") + + @property + @pulumi.getter + def region(self) -> Optional[str]: + """ + Region of the target MinIO. This will be used to generate the target ARN + """ + return pulumi.get(self, "region") + + @property + @pulumi.getter(name="secretKey") + def secret_key(self) -> Optional[str]: + """ + Secret key for the replication service account in the target MinIO. This is optional so it can be imported but prevent secret update + """ + return pulumi.get(self, "secret_key") + + @property + @pulumi.getter + def secure(self) -> Optional[bool]: + return pulumi.get(self, "secure") + + @property + @pulumi.getter(name="storageClass") + def storage_class(self) -> Optional[str]: + """ + The storage class to use for the object on this target + """ + return pulumi.get(self, "storage_class") + + @property + @pulumi.getter + def syncronous(self) -> Optional[bool]: + """ + Use synchronous replication. + """ + return pulumi.get(self, "syncronous") + + @pulumi.output_type class S3BucketVersioningVersioningConfiguration(dict): @staticmethod diff --git a/sdk/python/pulumi_minio/s3_bucket_replication.py b/sdk/python/pulumi_minio/s3_bucket_replication.py new file mode 100644 index 0000000..13a1374 --- /dev/null +++ b/sdk/python/pulumi_minio/s3_bucket_replication.py @@ -0,0 +1,441 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['S3BucketReplicationArgs', 'S3BucketReplication'] + +@pulumi.input_type +class S3BucketReplicationArgs: + def __init__(__self__, *, + bucket: pulumi.Input[str], + rules: Optional[pulumi.Input[Sequence[pulumi.Input['S3BucketReplicationRuleArgs']]]] = None): + """ + The set of arguments for constructing a S3BucketReplication resource. + :param pulumi.Input[str] bucket: The name of the existing target bucket to replicate into + :param pulumi.Input[Sequence[pulumi.Input['S3BucketReplicationRuleArgs']]] rules: Rule definitions + """ + pulumi.set(__self__, "bucket", bucket) + if rules is not None: + pulumi.set(__self__, "rules", rules) + + @property + @pulumi.getter + def bucket(self) -> pulumi.Input[str]: + """ + The name of the existing target bucket to replicate into + """ + return pulumi.get(self, "bucket") + + @bucket.setter + def bucket(self, value: pulumi.Input[str]): + pulumi.set(self, "bucket", value) + + @property + @pulumi.getter + def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['S3BucketReplicationRuleArgs']]]]: + """ + Rule definitions + """ + return pulumi.get(self, "rules") + + @rules.setter + def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['S3BucketReplicationRuleArgs']]]]): + pulumi.set(self, "rules", value) + + +@pulumi.input_type +class _S3BucketReplicationState: + def __init__(__self__, *, + bucket: Optional[pulumi.Input[str]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input['S3BucketReplicationRuleArgs']]]] = None): + """ + Input properties used for looking up and filtering S3BucketReplication resources. + :param pulumi.Input[str] bucket: The name of the existing target bucket to replicate into + :param pulumi.Input[Sequence[pulumi.Input['S3BucketReplicationRuleArgs']]] rules: Rule definitions + """ + if bucket is not None: + pulumi.set(__self__, "bucket", bucket) + if rules is not None: + pulumi.set(__self__, "rules", rules) + + @property + @pulumi.getter + def bucket(self) -> Optional[pulumi.Input[str]]: + """ + The name of the existing target bucket to replicate into + """ + return pulumi.get(self, "bucket") + + @bucket.setter + def bucket(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bucket", value) + + @property + @pulumi.getter + def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['S3BucketReplicationRuleArgs']]]]: + """ + Rule definitions + """ + return pulumi.get(self, "rules") + + @rules.setter + def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['S3BucketReplicationRuleArgs']]]]): + pulumi.set(self, "rules", value) + + +class S3BucketReplication(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + bucket: Optional[pulumi.Input[str]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['S3BucketReplicationRuleArgs']]]]] = None, + __props__=None): + """ + ## Example Usage + + ```python + import pulumi + import pulumi_minio as minio + + my_bucket_in_as3_bucket = minio.S3Bucket("myBucketInAS3Bucket", bucket="my-bucket") + my_bucket_in_bs3_bucket = minio.S3Bucket("myBucketInBS3Bucket", bucket="my-bucket", + opts=pulumi.ResourceOptions(provider=minio["deployment_b"])) + my_bucket_in_as3_bucket_versioning = minio.S3BucketVersioning("myBucketInAS3BucketVersioning", + bucket=my_bucket_in_as3_bucket.bucket, + versioning_configuration=minio.S3BucketVersioningVersioningConfigurationArgs( + status="Enabled", + )) + my_bucket_in_bs3_bucket_versioning = minio.S3BucketVersioning("myBucketInBS3BucketVersioning", + bucket=my_bucket_in_bs3_bucket.bucket, + versioning_configuration=minio.S3BucketVersioningVersioningConfigurationArgs( + status="Enabled", + ), + opts=pulumi.ResourceOptions(provider=minio["deployment_b"])) + replication_policy = minio.get_iam_policy_document(statements=[ + minio.GetIamPolicyDocumentStatementArgs( + sid="ReadBuckets", + effect="Allow", + resources=["arn:aws:s3:::*"], + actions=["s3:ListBucket"], + ), + minio.GetIamPolicyDocumentStatementArgs( + sid="EnableReplicationOnBucket", + effect="Allow", + resources=["arn:aws:s3:::my-bucket"], + actions=[ + "s3:GetReplicationConfiguration", + "s3:ListBucket", + "s3:ListBucketMultipartUploads", + "s3:GetBucketLocation", + "s3:GetBucketVersioning", + "s3:GetBucketObjectLockConfiguration", + "s3:GetEncryptionConfiguration", + ], + ), + minio.GetIamPolicyDocumentStatementArgs( + sid="EnableReplicatingDataIntoBucket", + effect="Allow", + resources=["arn:aws:s3:::my-bucket/*"], + actions=[ + "s3:GetReplicationConfiguration", + "s3:ReplicateTags", + "s3:AbortMultipartUpload", + "s3:GetObject", + "s3:GetObjectVersion", + "s3:GetObjectVersionTagging", + "s3:PutObject", + "s3:PutObjectRetention", + "s3:PutBucketObjectLockConfiguration", + "s3:PutObjectLegalHold", + "s3:DeleteObject", + "s3:ReplicateObject", + "s3:ReplicateDelete", + ], + ), + ]) + # One-Way replication (A -> B) + replication_in_b_iam_policy = minio.IamPolicy("replicationInBIamPolicy", policy=replication_policy.json, + opts=pulumi.ResourceOptions(provider=minio["deployment_b"])) + replication_in_b_iam_user = minio.IamUser("replicationInBIamUser", force_destroy=True, + opts=pulumi.ResourceOptions(provider=minio["deployment_b"])) + replication_in_b_iam_user_policy_attachment = minio.IamUserPolicyAttachment("replicationInBIamUserPolicyAttachment", + user_name=replication_in_b_iam_user.name, + policy_name=replication_in_b_iam_policy.id, + opts=pulumi.ResourceOptions(provider=minio["deployment_b"])) + replication_in_b_iam_service_account = minio.IamServiceAccount("replicationInBIamServiceAccount", target_user=replication_in_b_iam_user.name, + opts=pulumi.ResourceOptions(provider=minio["deployment_b"], + depends_on=[replication_in_b_iam_user_policy_attachment])) + replication_in_bs3_bucket_replication = minio.S3BucketReplication("replicationInBS3BucketReplication", + bucket=my_bucket_in_as3_bucket.bucket, + rules=[minio.S3BucketReplicationRuleArgs( + delete_replication=True, + delete_marker_replication=True, + existing_object_replication=True, + metadata_sync=True, + target=minio.S3BucketReplicationRuleTargetArgs( + bucket=my_bucket_in_bs3_bucket.bucket, + secure=False, + host=var["minio_server_b"], + bandwidth_limt="100M", + access_key=replication_in_b_iam_service_account.access_key, + secret_key=replication_in_b_iam_service_account.secret_key, + ), + )], + opts=pulumi.ResourceOptions(depends_on=[ + my_bucket_in_as3_bucket_versioning, + my_bucket_in_bs3_bucket_versioning, + ])) + # Two-Way replication (A <-> B) + replication_in_a_iam_policy = minio.IamPolicy("replicationInAIamPolicy", policy=replication_policy.json) + replication_in_a_iam_user = minio.IamUser("replicationInAIamUser", force_destroy=True) + replication_in_a_iam_user_policy_attachment = minio.IamUserPolicyAttachment("replicationInAIamUserPolicyAttachment", + user_name=replication_in_a_iam_user.name, + policy_name=replication_in_a_iam_policy.id) + replication_in_a_iam_service_account = minio.IamServiceAccount("replicationInAIamServiceAccount", target_user=replication_in_a_iam_user.name, + opts=pulumi.ResourceOptions(depends_on=[replication_in_b_iam_user_policy_attachment])) + replication_in_as3_bucket_replication = minio.S3BucketReplication("replicationInAS3BucketReplication", + bucket=my_bucket_in_bs3_bucket.bucket, + rules=[minio.S3BucketReplicationRuleArgs( + delete_replication=True, + delete_marker_replication=True, + existing_object_replication=True, + metadata_sync=True, + target=minio.S3BucketReplicationRuleTargetArgs( + bucket=my_bucket_in_as3_bucket.bucket, + host=var["minio_server_a"], + secure=False, + bandwidth_limt="100M", + access_key=replication_in_a_iam_service_account.access_key, + secret_key=replication_in_a_iam_service_account.secret_key, + ), + )], + opts=pulumi.ResourceOptions(provider=minio["deployment_b"], + depends_on=[ + my_bucket_in_as3_bucket_versioning, + my_bucket_in_bs3_bucket_versioning, + ])) + ``` + + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] bucket: The name of the existing target bucket to replicate into + :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['S3BucketReplicationRuleArgs']]]] rules: Rule definitions + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: S3BucketReplicationArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + ## Example Usage + + ```python + import pulumi + import pulumi_minio as minio + + my_bucket_in_as3_bucket = minio.S3Bucket("myBucketInAS3Bucket", bucket="my-bucket") + my_bucket_in_bs3_bucket = minio.S3Bucket("myBucketInBS3Bucket", bucket="my-bucket", + opts=pulumi.ResourceOptions(provider=minio["deployment_b"])) + my_bucket_in_as3_bucket_versioning = minio.S3BucketVersioning("myBucketInAS3BucketVersioning", + bucket=my_bucket_in_as3_bucket.bucket, + versioning_configuration=minio.S3BucketVersioningVersioningConfigurationArgs( + status="Enabled", + )) + my_bucket_in_bs3_bucket_versioning = minio.S3BucketVersioning("myBucketInBS3BucketVersioning", + bucket=my_bucket_in_bs3_bucket.bucket, + versioning_configuration=minio.S3BucketVersioningVersioningConfigurationArgs( + status="Enabled", + ), + opts=pulumi.ResourceOptions(provider=minio["deployment_b"])) + replication_policy = minio.get_iam_policy_document(statements=[ + minio.GetIamPolicyDocumentStatementArgs( + sid="ReadBuckets", + effect="Allow", + resources=["arn:aws:s3:::*"], + actions=["s3:ListBucket"], + ), + minio.GetIamPolicyDocumentStatementArgs( + sid="EnableReplicationOnBucket", + effect="Allow", + resources=["arn:aws:s3:::my-bucket"], + actions=[ + "s3:GetReplicationConfiguration", + "s3:ListBucket", + "s3:ListBucketMultipartUploads", + "s3:GetBucketLocation", + "s3:GetBucketVersioning", + "s3:GetBucketObjectLockConfiguration", + "s3:GetEncryptionConfiguration", + ], + ), + minio.GetIamPolicyDocumentStatementArgs( + sid="EnableReplicatingDataIntoBucket", + effect="Allow", + resources=["arn:aws:s3:::my-bucket/*"], + actions=[ + "s3:GetReplicationConfiguration", + "s3:ReplicateTags", + "s3:AbortMultipartUpload", + "s3:GetObject", + "s3:GetObjectVersion", + "s3:GetObjectVersionTagging", + "s3:PutObject", + "s3:PutObjectRetention", + "s3:PutBucketObjectLockConfiguration", + "s3:PutObjectLegalHold", + "s3:DeleteObject", + "s3:ReplicateObject", + "s3:ReplicateDelete", + ], + ), + ]) + # One-Way replication (A -> B) + replication_in_b_iam_policy = minio.IamPolicy("replicationInBIamPolicy", policy=replication_policy.json, + opts=pulumi.ResourceOptions(provider=minio["deployment_b"])) + replication_in_b_iam_user = minio.IamUser("replicationInBIamUser", force_destroy=True, + opts=pulumi.ResourceOptions(provider=minio["deployment_b"])) + replication_in_b_iam_user_policy_attachment = minio.IamUserPolicyAttachment("replicationInBIamUserPolicyAttachment", + user_name=replication_in_b_iam_user.name, + policy_name=replication_in_b_iam_policy.id, + opts=pulumi.ResourceOptions(provider=minio["deployment_b"])) + replication_in_b_iam_service_account = minio.IamServiceAccount("replicationInBIamServiceAccount", target_user=replication_in_b_iam_user.name, + opts=pulumi.ResourceOptions(provider=minio["deployment_b"], + depends_on=[replication_in_b_iam_user_policy_attachment])) + replication_in_bs3_bucket_replication = minio.S3BucketReplication("replicationInBS3BucketReplication", + bucket=my_bucket_in_as3_bucket.bucket, + rules=[minio.S3BucketReplicationRuleArgs( + delete_replication=True, + delete_marker_replication=True, + existing_object_replication=True, + metadata_sync=True, + target=minio.S3BucketReplicationRuleTargetArgs( + bucket=my_bucket_in_bs3_bucket.bucket, + secure=False, + host=var["minio_server_b"], + bandwidth_limt="100M", + access_key=replication_in_b_iam_service_account.access_key, + secret_key=replication_in_b_iam_service_account.secret_key, + ), + )], + opts=pulumi.ResourceOptions(depends_on=[ + my_bucket_in_as3_bucket_versioning, + my_bucket_in_bs3_bucket_versioning, + ])) + # Two-Way replication (A <-> B) + replication_in_a_iam_policy = minio.IamPolicy("replicationInAIamPolicy", policy=replication_policy.json) + replication_in_a_iam_user = minio.IamUser("replicationInAIamUser", force_destroy=True) + replication_in_a_iam_user_policy_attachment = minio.IamUserPolicyAttachment("replicationInAIamUserPolicyAttachment", + user_name=replication_in_a_iam_user.name, + policy_name=replication_in_a_iam_policy.id) + replication_in_a_iam_service_account = minio.IamServiceAccount("replicationInAIamServiceAccount", target_user=replication_in_a_iam_user.name, + opts=pulumi.ResourceOptions(depends_on=[replication_in_b_iam_user_policy_attachment])) + replication_in_as3_bucket_replication = minio.S3BucketReplication("replicationInAS3BucketReplication", + bucket=my_bucket_in_bs3_bucket.bucket, + rules=[minio.S3BucketReplicationRuleArgs( + delete_replication=True, + delete_marker_replication=True, + existing_object_replication=True, + metadata_sync=True, + target=minio.S3BucketReplicationRuleTargetArgs( + bucket=my_bucket_in_as3_bucket.bucket, + host=var["minio_server_a"], + secure=False, + bandwidth_limt="100M", + access_key=replication_in_a_iam_service_account.access_key, + secret_key=replication_in_a_iam_service_account.secret_key, + ), + )], + opts=pulumi.ResourceOptions(provider=minio["deployment_b"], + depends_on=[ + my_bucket_in_as3_bucket_versioning, + my_bucket_in_bs3_bucket_versioning, + ])) + ``` + + :param str resource_name: The name of the resource. + :param S3BucketReplicationArgs args: The arguments to use to populate this resource's properties. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + def __init__(__self__, resource_name: str, *args, **kwargs): + resource_args, opts = _utilities.get_resource_args_opts(S3BucketReplicationArgs, pulumi.ResourceOptions, *args, **kwargs) + if resource_args is not None: + __self__._internal_init(resource_name, opts, **resource_args.__dict__) + else: + __self__._internal_init(resource_name, *args, **kwargs) + + def _internal_init(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + bucket: Optional[pulumi.Input[str]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['S3BucketReplicationRuleArgs']]]]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = S3BucketReplicationArgs.__new__(S3BucketReplicationArgs) + + if bucket is None and not opts.urn: + raise TypeError("Missing required property 'bucket'") + __props__.__dict__["bucket"] = bucket + __props__.__dict__["rules"] = rules + super(S3BucketReplication, __self__).__init__( + 'minio:index/s3BucketReplication:S3BucketReplication', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + bucket: Optional[pulumi.Input[str]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['S3BucketReplicationRuleArgs']]]]] = None) -> 'S3BucketReplication': + """ + Get an existing S3BucketReplication resource's state with the given name, id, and optional extra + properties used to qualify the lookup. + + :param str resource_name: The unique name of the resulting resource. + :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. + :param pulumi.ResourceOptions opts: Options for the resource. + :param pulumi.Input[str] bucket: The name of the existing target bucket to replicate into + :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['S3BucketReplicationRuleArgs']]]] rules: Rule definitions + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _S3BucketReplicationState.__new__(_S3BucketReplicationState) + + __props__.__dict__["bucket"] = bucket + __props__.__dict__["rules"] = rules + return S3BucketReplication(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def bucket(self) -> pulumi.Output[str]: + """ + The name of the existing target bucket to replicate into + """ + return pulumi.get(self, "bucket") + + @property + @pulumi.getter + def rules(self) -> pulumi.Output[Optional[Sequence['outputs.S3BucketReplicationRule']]]: + """ + Rule definitions + """ + return pulumi.get(self, "rules") +