ObjectLambdaAccessPointPolicy class

Provides a resource to manage an S3 Object Lambda Access Point resource policy.

Example Usage

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

const example = new aws.s3.Bucket("example", {bucket: "example"});
const exampleAccessPoint = new aws.s3.AccessPoint("example", {
    bucket: example.id,
    name: "example",
});
const exampleObjectLambdaAccessPoint = new aws.s3control.ObjectLambdaAccessPoint("example", {
    configuration: {
        transformationConfigurations: [{
            contentTransformation: {
                awsLambda: {
                    functionArn: exampleAwsLambdaFunction.arn,
                },
            },
            actions: ["GetObject"],
        }],
        supportingAccessPoint: exampleAccessPoint.arn,
    },
    name: "example",
});
const exampleObjectLambdaAccessPointPolicy = new aws.s3control.ObjectLambdaAccessPointPolicy("example", {
    name: exampleObjectLambdaAccessPoint.name,
    policy: pulumi.jsonStringify({
        Version: "2008-10-17",
        Statement: [{
            Effect: "Allow",
            Action: "s3-object-lambda:GetObject",
            Principal: {
                AWS: current.accountId,
            },
            Resource: exampleObjectLambdaAccessPoint.arn,
        }],
    }),
});
import pulumi
import json
import pulumi_aws as aws

example = aws.s3.Bucket("example", bucket="example")
example_access_point = aws.s3.AccessPoint("example",
    bucket=example.id,
    name="example")
example_object_lambda_access_point = aws.s3control.ObjectLambdaAccessPoint("example",
    configuration={
        "transformation_configurations": [{
            "content_transformation": {
                "aws_lambda": {
                    "function_arn": example_aws_lambda_function["arn"],
                },
            },
            "actions": ["GetObject"],
        }],
        "supporting_access_point": example_access_point.arn,
    },
    name="example")
example_object_lambda_access_point_policy = aws.s3control.ObjectLambdaAccessPointPolicy("example",
    name=example_object_lambda_access_point.name,
    policy=pulumi.Output.json_dumps({
        "Version": "2008-10-17",
        "Statement": [{
            "Effect": "Allow",
            "Action": "s3-object-lambda:GetObject",
            "Principal": {
                "AWS": current["accountId"],
            },
            "Resource": example_object_lambda_access_point.arn,
        }],
    }))
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.S3.Bucket("example", new()
    {
        BucketName = "example",
    });

    var exampleAccessPoint = new Aws.S3.AccessPoint("example", new()
    {
        Bucket = example.Id,
        Name = "example",
    });

    var exampleObjectLambdaAccessPoint = new Aws.S3Control.ObjectLambdaAccessPoint("example", new()
    {
        Configuration = new Aws.S3Control.Inputs.ObjectLambdaAccessPointConfigurationArgs
        {
            TransformationConfigurations = new[]
            {
                new Aws.S3Control.Inputs.ObjectLambdaAccessPointConfigurationTransformationConfigurationArgs
                {
                    ContentTransformation = new Aws.S3Control.Inputs.ObjectLambdaAccessPointConfigurationTransformationConfigurationContentTransformationArgs
                    {
                        AwsLambda = new Aws.S3Control.Inputs.ObjectLambdaAccessPointConfigurationTransformationConfigurationContentTransformationAwsLambdaArgs
                        {
                            FunctionArn = exampleAwsLambdaFunction.Arn,
                        },
                    },
                    Actions = new[]
                    {
                        "GetObject",
                    },
                },
            },
            SupportingAccessPoint = exampleAccessPoint.Arn,
        },
        Name = "example",
    });

    var exampleObjectLambdaAccessPointPolicy = new Aws.S3Control.ObjectLambdaAccessPointPolicy("example", new()
    {
        Name = exampleObjectLambdaAccessPoint.Name,
        Policy = Output.JsonSerialize(Output.Create(new Dictionary<string, object?>
        {
            ["Version"] = "2008-10-17",
            ["Statement"] = new[]
            {
                new Dictionary<string, object?>
                {
                    ["Effect"] = "Allow",
                    ["Action"] = "s3-object-lambda:GetObject",
                    ["Principal"] = new Dictionary<string, object?>
                    {
                        ["AWS"] = current.AccountId,
                    },
                    ["Resource"] = exampleObjectLambdaAccessPoint.Arn,
                },
            },
        })),
    });

});
package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/s3control"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := s3.NewBucket(ctx, "example", &s3.BucketArgs{
			Bucket: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		exampleAccessPoint, err := s3.NewAccessPoint(ctx, "example", &s3.AccessPointArgs{
			Bucket: example.ID().ToIDOutput().ToStringOutput(),
			Name:   pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		exampleObjectLambdaAccessPoint, err := s3control.NewObjectLambdaAccessPoint(ctx, "example", &s3control.ObjectLambdaAccessPointArgs{
			Configuration: &s3control.ObjectLambdaAccessPointConfigurationArgs{
				TransformationConfigurations: s3control.ObjectLambdaAccessPointConfigurationTransformationConfigurationArray{
					&s3control.ObjectLambdaAccessPointConfigurationTransformationConfigurationArgs{
						ContentTransformation: &s3control.ObjectLambdaAccessPointConfigurationTransformationConfigurationContentTransformationArgs{
							AwsLambda: &s3control.ObjectLambdaAccessPointConfigurationTransformationConfigurationContentTransformationAwsLambdaArgs{
								FunctionArn: pulumi.Any(exampleAwsLambdaFunction.Arn),
							},
						},
						Actions: pulumi.StringArray{
							pulumi.String("GetObject"),
						},
					},
				},
				SupportingAccessPoint: exampleAccessPoint.Arn,
			},
			Name: pulumi.String("example"),
		})
		if err != nil {
			return err
		}
		_, err = s3control.NewObjectLambdaAccessPointPolicy(ctx, "example", &s3control.ObjectLambdaAccessPointPolicyArgs{
			Name: exampleObjectLambdaAccessPoint.Name,
			Policy: exampleObjectLambdaAccessPoint.Arn.ApplyT(func(arn string) (pulumi.String, error) {
				var _zero pulumi.String
				tmpJSON0, err := json.Marshal(map[string]interface{}{
					"Version": "2008-10-17",
					"Statement": []map[string]interface{}{
						map[string]interface{}{
							"Effect": "Allow",
							"Action": "s3-object-lambda:GetObject",
							"Principal": map[string]interface{}{
								"AWS": current.AccountId,
							},
							"Resource": arn,
						},
					},
				})
				if err != nil {
					return _zero, err
				}
				json0 := string(tmpJSON0)
				return pulumi.String(json0), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_s3_bucket" "example" {
  bucket = "example"
}
resource "aws_s3_accesspoint" "example" {
  bucket = aws_s3_bucket.example.id
  name   = "example"
}
resource "aws_s3control_objectlambdaaccesspoint" "example" {
  configuration = {
    transformation_configurations = [{
      "contentTransformation" = {
        "awsLambda" = {
          "functionArn" = exampleAwsLambdaFunction.arn
        }
      }
      "actions" = ["GetObject"]
    }]
    supporting_access_point = aws_s3_accesspoint.example.arn
  }
  name = "example"
}
resource "aws_s3control_objectlambdaaccesspointpolicy" "example" {
  name = aws_s3control_objectlambdaaccesspoint.example.name
  policy = jsonencode({
    "Version" = "2008-10-17"
    "Statement" = [{
      "Effect" = "Allow"
      "Action" = "s3-object-lambda:GetObject"
      "Principal" = {
        "AWS" = current.accountId
      }
      "Resource" = aws_s3control_objectlambdaaccesspoint.example.arn
    }]
  })
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.s3.Bucket;
import com.pulumi.aws.s3.BucketArgs;
import com.pulumi.aws.s3.AccessPoint;
import com.pulumi.aws.s3.AccessPointArgs;
import com.pulumi.aws.s3control.ObjectLambdaAccessPoint;
import com.pulumi.aws.s3control.ObjectLambdaAccessPointArgs;
import com.pulumi.aws.s3control.inputs.ObjectLambdaAccessPointConfigurationArgs;
import com.pulumi.aws.s3control.inputs.ObjectLambdaAccessPointConfigurationTransformationConfigurationArgs;
import com.pulumi.aws.s3control.inputs.ObjectLambdaAccessPointConfigurationTransformationConfigurationContentTransformationArgs;
import com.pulumi.aws.s3control.inputs.ObjectLambdaAccessPointConfigurationTransformationConfigurationContentTransformationAwsLambdaArgs;
import com.pulumi.aws.s3control.ObjectLambdaAccessPointPolicy;
import com.pulumi.aws.s3control.ObjectLambdaAccessPointPolicyArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.ArrayList;
import java.util.Arrays;
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 example = new Bucket("example", BucketArgs.builder()
            .bucket("example")
            .build());

        var exampleAccessPoint = new AccessPoint("exampleAccessPoint", AccessPointArgs.builder()
            .bucket(example.id())
            .name("example")
            .build());

        var exampleObjectLambdaAccessPoint = new ObjectLambdaAccessPoint("exampleObjectLambdaAccessPoint", ObjectLambdaAccessPointArgs.builder()
            .configuration(ObjectLambdaAccessPointConfigurationArgs.builder()
                .transformationConfigurations(ObjectLambdaAccessPointConfigurationTransformationConfigurationArgs.builder()
                    .contentTransformation(ObjectLambdaAccessPointConfigurationTransformationConfigurationContentTransformationArgs.builder()
                        .awsLambda(ObjectLambdaAccessPointConfigurationTransformationConfigurationContentTransformationAwsLambdaArgs.builder()
                            .functionArn(exampleAwsLambdaFunction.arn())
                            .build())
                        .build())
                    .actions("GetObject")
                    .build())
                .supportingAccessPoint(exampleAccessPoint.arn())
                .build())
            .name("example")
            .build());

        var exampleObjectLambdaAccessPointPolicy = new ObjectLambdaAccessPointPolicy("exampleObjectLambdaAccessPointPolicy", ObjectLambdaAccessPointPolicyArgs.builder()
            .name(exampleObjectLambdaAccessPoint.name())
            .policy(exampleObjectLambdaAccessPoint.arn().applyValue(_arn -> serializeJson(
                jsonObject(
                    jsonProperty("Version", "2008-10-17"),
                    jsonProperty("Statement", jsonArray(jsonObject(
                        jsonProperty("Effect", "Allow"),
                        jsonProperty("Action", "s3-object-lambda:GetObject"),
                        jsonProperty("Principal", jsonObject(
                            jsonProperty("AWS", current.accountId())
                        )),
                        jsonProperty("Resource", _arn)
                    )))
                ))))
            .build());

    }
}
resources:
  example:
    type: aws:s3:Bucket
    properties:
      bucket: example
  exampleAccessPoint:
    type: aws:s3:AccessPoint
    name: example
    properties:
      bucket: ${example.id}
      name: example
  exampleObjectLambdaAccessPoint:
    type: aws:s3control:ObjectLambdaAccessPoint
    name: example
    properties:
      configuration:
        transformationConfigurations:
          - contentTransformation:
              awsLambda:
                functionArn: ${exampleAwsLambdaFunction.arn}
            actions:
              - GetObject
        supportingAccessPoint: ${exampleAccessPoint.arn}
      name: example
  exampleObjectLambdaAccessPointPolicy:
    type: aws:s3control:ObjectLambdaAccessPointPolicy
    name: example
    properties:
      name: ${exampleObjectLambdaAccessPoint.name}
      policy:
        fn::toJSON:
          Version: 2008-10-17
          Statement:
            - Effect: Allow
              Action: s3-object-lambda:GetObject
              Principal:
                AWS: ${current.accountId}
              Resource: ${exampleObjectLambdaAccessPoint.arn}

Import

Using pulumi import, import Object Lambda Access Point policies using the accountId and name, separated by a colon (:). For example:

$ pulumi import aws:s3control/objectLambdaAccessPointPolicy:ObjectLambdaAccessPointPolicy example 123456789012:example

Constructors

ObjectLambdaAccessPointPolicy(String name, {ObjectLambdaAccessPointPolicyArgs? args, CustomResourceOptions? options})
Creates a new ObjectLambdaAccessPointPolicy. name The Pulumi resource name. args Arguments used to configure this ObjectLambdaAccessPointPolicy. The set of arguments for ObjectLambdaAccessPointPolicy. options Resource options controlling this resource's behavior.
ObjectLambdaAccessPointPolicy.reference(String urn)
Creates a typed reference to an existing ObjectLambdaAccessPointPolicy resource.

Properties

accountId ↔ Output<String>
AWS account ID for the account that owns the Object Lambda Access Point. Defaults to automatically determined account ID of the AWS provider.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
hashCode → int
The hash code for this object.
no setterinherited
hasPublicAccessPolicy ↔ Output<bool>
Whether this access point currently has a policy that allows public access.
latefinal
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
name ↔ Output<String>
Name of the Object Lambda Access Point.
latefinal
policy ↔ Output<String>
Object Lambda Access Point resource policy document.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {ObjectLambdaAccessPointPolicyState? state, CustomResourceOptions? options}) → ObjectLambdaAccessPointPolicy
Gets an existing ObjectLambdaAccessPointPolicy resource's state with the given name and id.