github.com/pulumi/pulumi-aws/sdk/v6@v6.32.0/go/aws/elasticsearch/domainPolicy.go (about)

     1  // Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
     2  // *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***
     3  
     4  package elasticsearch
     5  
     6  import (
     7  	"context"
     8  	"reflect"
     9  
    10  	"errors"
    11  	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/internal"
    12  	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    13  )
    14  
    15  // Allows setting policy to an Elasticsearch domain while referencing domain attributes (e.g., ARN)
    16  //
    17  // ## Example Usage
    18  //
    19  // <!--Start PulumiCodeChooser -->
    20  // ```go
    21  // package main
    22  //
    23  // import (
    24  //
    25  //	"fmt"
    26  //
    27  //	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/elasticsearch"
    28  //	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/iam"
    29  //	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    30  //
    31  // )
    32  //
    33  //	func main() {
    34  //		pulumi.Run(func(ctx *pulumi.Context) error {
    35  //			example, err := elasticsearch.NewDomain(ctx, "example", &elasticsearch.DomainArgs{
    36  //				DomainName:           pulumi.String("tf-test"),
    37  //				ElasticsearchVersion: pulumi.String("2.3"),
    38  //			})
    39  //			if err != nil {
    40  //				return err
    41  //			}
    42  //			_, err = elasticsearch.NewDomainPolicy(ctx, "main", &elasticsearch.DomainPolicyArgs{
    43  //				DomainName: example.DomainName,
    44  //				AccessPolicies: example.Arn.ApplyT(func(arn string) (string, error) {
    45  //					return fmt.Sprintf(`{
    46  //	    "Version": "2012-10-17",
    47  //	    "Statement": [
    48  //	        {
    49  //	            "Action": "es:*",
    50  //	            "Principal": "*",
    51  //	            "Effect": "Allow",
    52  //	            "Condition": {
    53  //	                "IpAddress": {"aws:SourceIp": "127.0.0.1/32"}
    54  //	            },
    55  //	            "Resource": "%v/*"
    56  //	        }
    57  //	    ]
    58  //	}
    59  //
    60  // `, arn), nil
    61  //
    62  //				}).(pulumi.StringOutput),
    63  //			})
    64  //			if err != nil {
    65  //				return err
    66  //			}
    67  //			return nil
    68  //		})
    69  //	}
    70  //
    71  // ```
    72  // <!--End PulumiCodeChooser -->
    73  type DomainPolicy struct {
    74  	pulumi.CustomResourceState
    75  
    76  	// IAM policy document specifying the access policies for the domain
    77  	AccessPolicies pulumi.StringOutput `pulumi:"accessPolicies"`
    78  	// Name of the domain.
    79  	DomainName pulumi.StringOutput `pulumi:"domainName"`
    80  }
    81  
    82  // NewDomainPolicy registers a new resource with the given unique name, arguments, and options.
    83  func NewDomainPolicy(ctx *pulumi.Context,
    84  	name string, args *DomainPolicyArgs, opts ...pulumi.ResourceOption) (*DomainPolicy, error) {
    85  	if args == nil {
    86  		return nil, errors.New("missing one or more required arguments")
    87  	}
    88  
    89  	if args.AccessPolicies == nil {
    90  		return nil, errors.New("invalid value for required argument 'AccessPolicies'")
    91  	}
    92  	if args.DomainName == nil {
    93  		return nil, errors.New("invalid value for required argument 'DomainName'")
    94  	}
    95  	opts = internal.PkgResourceDefaultOpts(opts)
    96  	var resource DomainPolicy
    97  	err := ctx.RegisterResource("aws:elasticsearch/domainPolicy:DomainPolicy", name, args, &resource, opts...)
    98  	if err != nil {
    99  		return nil, err
   100  	}
   101  	return &resource, nil
   102  }
   103  
   104  // GetDomainPolicy gets an existing DomainPolicy resource's state with the given name, ID, and optional
   105  // state properties that are used to uniquely qualify the lookup (nil if not required).
   106  func GetDomainPolicy(ctx *pulumi.Context,
   107  	name string, id pulumi.IDInput, state *DomainPolicyState, opts ...pulumi.ResourceOption) (*DomainPolicy, error) {
   108  	var resource DomainPolicy
   109  	err := ctx.ReadResource("aws:elasticsearch/domainPolicy:DomainPolicy", name, id, state, &resource, opts...)
   110  	if err != nil {
   111  		return nil, err
   112  	}
   113  	return &resource, nil
   114  }
   115  
   116  // Input properties used for looking up and filtering DomainPolicy resources.
   117  type domainPolicyState struct {
   118  	// IAM policy document specifying the access policies for the domain
   119  	AccessPolicies interface{} `pulumi:"accessPolicies"`
   120  	// Name of the domain.
   121  	DomainName *string `pulumi:"domainName"`
   122  }
   123  
   124  type DomainPolicyState struct {
   125  	// IAM policy document specifying the access policies for the domain
   126  	AccessPolicies pulumi.Input
   127  	// Name of the domain.
   128  	DomainName pulumi.StringPtrInput
   129  }
   130  
   131  func (DomainPolicyState) ElementType() reflect.Type {
   132  	return reflect.TypeOf((*domainPolicyState)(nil)).Elem()
   133  }
   134  
   135  type domainPolicyArgs struct {
   136  	// IAM policy document specifying the access policies for the domain
   137  	AccessPolicies interface{} `pulumi:"accessPolicies"`
   138  	// Name of the domain.
   139  	DomainName string `pulumi:"domainName"`
   140  }
   141  
   142  // The set of arguments for constructing a DomainPolicy resource.
   143  type DomainPolicyArgs struct {
   144  	// IAM policy document specifying the access policies for the domain
   145  	AccessPolicies pulumi.Input
   146  	// Name of the domain.
   147  	DomainName pulumi.StringInput
   148  }
   149  
   150  func (DomainPolicyArgs) ElementType() reflect.Type {
   151  	return reflect.TypeOf((*domainPolicyArgs)(nil)).Elem()
   152  }
   153  
   154  type DomainPolicyInput interface {
   155  	pulumi.Input
   156  
   157  	ToDomainPolicyOutput() DomainPolicyOutput
   158  	ToDomainPolicyOutputWithContext(ctx context.Context) DomainPolicyOutput
   159  }
   160  
   161  func (*DomainPolicy) ElementType() reflect.Type {
   162  	return reflect.TypeOf((**DomainPolicy)(nil)).Elem()
   163  }
   164  
   165  func (i *DomainPolicy) ToDomainPolicyOutput() DomainPolicyOutput {
   166  	return i.ToDomainPolicyOutputWithContext(context.Background())
   167  }
   168  
   169  func (i *DomainPolicy) ToDomainPolicyOutputWithContext(ctx context.Context) DomainPolicyOutput {
   170  	return pulumi.ToOutputWithContext(ctx, i).(DomainPolicyOutput)
   171  }
   172  
   173  // DomainPolicyArrayInput is an input type that accepts DomainPolicyArray and DomainPolicyArrayOutput values.
   174  // You can construct a concrete instance of `DomainPolicyArrayInput` via:
   175  //
   176  //	DomainPolicyArray{ DomainPolicyArgs{...} }
   177  type DomainPolicyArrayInput interface {
   178  	pulumi.Input
   179  
   180  	ToDomainPolicyArrayOutput() DomainPolicyArrayOutput
   181  	ToDomainPolicyArrayOutputWithContext(context.Context) DomainPolicyArrayOutput
   182  }
   183  
   184  type DomainPolicyArray []DomainPolicyInput
   185  
   186  func (DomainPolicyArray) ElementType() reflect.Type {
   187  	return reflect.TypeOf((*[]*DomainPolicy)(nil)).Elem()
   188  }
   189  
   190  func (i DomainPolicyArray) ToDomainPolicyArrayOutput() DomainPolicyArrayOutput {
   191  	return i.ToDomainPolicyArrayOutputWithContext(context.Background())
   192  }
   193  
   194  func (i DomainPolicyArray) ToDomainPolicyArrayOutputWithContext(ctx context.Context) DomainPolicyArrayOutput {
   195  	return pulumi.ToOutputWithContext(ctx, i).(DomainPolicyArrayOutput)
   196  }
   197  
   198  // DomainPolicyMapInput is an input type that accepts DomainPolicyMap and DomainPolicyMapOutput values.
   199  // You can construct a concrete instance of `DomainPolicyMapInput` via:
   200  //
   201  //	DomainPolicyMap{ "key": DomainPolicyArgs{...} }
   202  type DomainPolicyMapInput interface {
   203  	pulumi.Input
   204  
   205  	ToDomainPolicyMapOutput() DomainPolicyMapOutput
   206  	ToDomainPolicyMapOutputWithContext(context.Context) DomainPolicyMapOutput
   207  }
   208  
   209  type DomainPolicyMap map[string]DomainPolicyInput
   210  
   211  func (DomainPolicyMap) ElementType() reflect.Type {
   212  	return reflect.TypeOf((*map[string]*DomainPolicy)(nil)).Elem()
   213  }
   214  
   215  func (i DomainPolicyMap) ToDomainPolicyMapOutput() DomainPolicyMapOutput {
   216  	return i.ToDomainPolicyMapOutputWithContext(context.Background())
   217  }
   218  
   219  func (i DomainPolicyMap) ToDomainPolicyMapOutputWithContext(ctx context.Context) DomainPolicyMapOutput {
   220  	return pulumi.ToOutputWithContext(ctx, i).(DomainPolicyMapOutput)
   221  }
   222  
   223  type DomainPolicyOutput struct{ *pulumi.OutputState }
   224  
   225  func (DomainPolicyOutput) ElementType() reflect.Type {
   226  	return reflect.TypeOf((**DomainPolicy)(nil)).Elem()
   227  }
   228  
   229  func (o DomainPolicyOutput) ToDomainPolicyOutput() DomainPolicyOutput {
   230  	return o
   231  }
   232  
   233  func (o DomainPolicyOutput) ToDomainPolicyOutputWithContext(ctx context.Context) DomainPolicyOutput {
   234  	return o
   235  }
   236  
   237  // IAM policy document specifying the access policies for the domain
   238  func (o DomainPolicyOutput) AccessPolicies() pulumi.StringOutput {
   239  	return o.ApplyT(func(v *DomainPolicy) pulumi.StringOutput { return v.AccessPolicies }).(pulumi.StringOutput)
   240  }
   241  
   242  // Name of the domain.
   243  func (o DomainPolicyOutput) DomainName() pulumi.StringOutput {
   244  	return o.ApplyT(func(v *DomainPolicy) pulumi.StringOutput { return v.DomainName }).(pulumi.StringOutput)
   245  }
   246  
   247  type DomainPolicyArrayOutput struct{ *pulumi.OutputState }
   248  
   249  func (DomainPolicyArrayOutput) ElementType() reflect.Type {
   250  	return reflect.TypeOf((*[]*DomainPolicy)(nil)).Elem()
   251  }
   252  
   253  func (o DomainPolicyArrayOutput) ToDomainPolicyArrayOutput() DomainPolicyArrayOutput {
   254  	return o
   255  }
   256  
   257  func (o DomainPolicyArrayOutput) ToDomainPolicyArrayOutputWithContext(ctx context.Context) DomainPolicyArrayOutput {
   258  	return o
   259  }
   260  
   261  func (o DomainPolicyArrayOutput) Index(i pulumi.IntInput) DomainPolicyOutput {
   262  	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DomainPolicy {
   263  		return vs[0].([]*DomainPolicy)[vs[1].(int)]
   264  	}).(DomainPolicyOutput)
   265  }
   266  
   267  type DomainPolicyMapOutput struct{ *pulumi.OutputState }
   268  
   269  func (DomainPolicyMapOutput) ElementType() reflect.Type {
   270  	return reflect.TypeOf((*map[string]*DomainPolicy)(nil)).Elem()
   271  }
   272  
   273  func (o DomainPolicyMapOutput) ToDomainPolicyMapOutput() DomainPolicyMapOutput {
   274  	return o
   275  }
   276  
   277  func (o DomainPolicyMapOutput) ToDomainPolicyMapOutputWithContext(ctx context.Context) DomainPolicyMapOutput {
   278  	return o
   279  }
   280  
   281  func (o DomainPolicyMapOutput) MapIndex(k pulumi.StringInput) DomainPolicyOutput {
   282  	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DomainPolicy {
   283  		return vs[0].(map[string]*DomainPolicy)[vs[1].(string)]
   284  	}).(DomainPolicyOutput)
   285  }
   286  
   287  func init() {
   288  	pulumi.RegisterInputType(reflect.TypeOf((*DomainPolicyInput)(nil)).Elem(), &DomainPolicy{})
   289  	pulumi.RegisterInputType(reflect.TypeOf((*DomainPolicyArrayInput)(nil)).Elem(), DomainPolicyArray{})
   290  	pulumi.RegisterInputType(reflect.TypeOf((*DomainPolicyMapInput)(nil)).Elem(), DomainPolicyMap{})
   291  	pulumi.RegisterOutputType(DomainPolicyOutput{})
   292  	pulumi.RegisterOutputType(DomainPolicyArrayOutput{})
   293  	pulumi.RegisterOutputType(DomainPolicyMapOutput{})
   294  }