AWS Cloud Control

import * as pulumi from "@pulumi/pulumi";
import * as awsnative from "@pulumi/aws-native";

// The ARN of the Lambda function that transforms objects.
const config = new pulumi.Config();
const functionArn = config.require("functionArn");

const myBucket = new awsnative.s3.Bucket("myBucket");

const ap = new awsnative.s3.AccessPoint("ap", {
    bucket: myBucket.id,
});

const objectLambdaAp = new awsnative.s3objectlambda.AccessPoint("objectLambdaAp", {
    objectLambdaConfiguration: {
        supportingAccessPoint: ap.arn,
        transformationConfigurations: [{
            actions: ["GetObject"],
            contentTransformation: {
                awsLambda: {
                    functionArn: functionArn,
                },
            },
        }],
    },
});

import pulumi
import pulumi_aws_native as aws_native

# The ARN of the Lambda function that transforms objects.
config = pulumi.Config()
function_arn = config.require("functionArn")

my_bucket = aws_native.s3.Bucket("myBucket")

ap = aws_native.s3.AccessPoint("ap", bucket=my_bucket.id)

object_lambda_ap = aws_native.s3objectlambda.AccessPoint("objectLambdaAp", object_lambda_configuration={
    "supporting_access_point": ap.arn,
    "transformation_configurations": [{
        "actions": ["GetObject"],
        "content_transformation": {
            "aws_lambda": {
                "function_arn": function_arn,
            },
        },
    }],
})

using Pulumi;
using AwsNative = Pulumi.AwsNative;

return await Deployment.RunAsync(() =>
{
    // The ARN of the Lambda function that transforms objects.
    var config = new Config();
    var functionArn = config.Require("functionArn");

    var myBucket = new AwsNative.S3.Bucket("myBucket");

    var ap = new AwsNative.S3.AccessPoint("ap", new()
    {
        Bucket = myBucket.Id,
    });

    var objectLambdaAp = new AwsNative.S3ObjectLambda.AccessPoint("objectLambdaAp", new()
    {
        ObjectLambdaConfiguration = new AwsNative.S3ObjectLambda.Inputs.AccessPointObjectLambdaConfigurationArgs
        {
            SupportingAccessPoint = ap.Arn,
            TransformationConfigurations =
            {
                new AwsNative.S3ObjectLambda.Inputs.AccessPointTransformationConfigurationArgs
                {
                    Actions = { "GetObject" },
                    ContentTransformation = new AwsNative.S3ObjectLambda.Inputs.AccessPointTransformationConfigurationContentTransformationPropertiesArgs
                    {
                        AwsLambda = new AwsNative.S3ObjectLambda.Inputs.AccessPointAwsLambdaArgs
                        {
                            FunctionArn = functionArn,
                        },
                    },
                },
            },
        },
    });
});

package main

import (
	"github.com/pulumi/pulumi-aws-native/sdk/go/aws/s3"
	"github.com/pulumi/pulumi-aws-native/sdk/go/aws/s3objectlambda"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// The ARN of the Lambda function that transforms objects.
		cfg := config.New(ctx, "")
		functionArn := cfg.Require("functionArn")

		myBucket, err := s3.NewBucket(ctx, "myBucket", nil)
		if err != nil {
			return err
		}

		ap, err := s3.NewAccessPoint(ctx, "ap", &s3.AccessPointArgs{
			Bucket: myBucket.ID().ToStringOutput(),
		})
		if err != nil {
			return err
		}

		_, err = s3objectlambda.NewAccessPoint(ctx, "objectLambdaAp", &s3objectlambda.AccessPointArgs{
			ObjectLambdaConfiguration: &s3objectlambda.AccessPointObjectLambdaConfigurationArgs{
				SupportingAccessPoint: ap.Arn,
				TransformationConfigurations: s3objectlambda.AccessPointTransformationConfigurationArray{
					&s3objectlambda.AccessPointTransformationConfigurationArgs{
						Actions: pulumi.StringArray{
							pulumi.String("GetObject"),
						},
						ContentTransformation: &s3objectlambda.AccessPointTransformationConfigurationContentTransformationPropertiesArgs{
							AwsLambda: &s3objectlambda.AccessPointAwsLambdaArgs{
								FunctionArn: pulumi.String(functionArn),
							},
						},
					},
				},
			},
		})
		return err
	})
}

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.awsnative.s3.AccessPoint;
import com.pulumi.awsnative.s3.AccessPointArgs;
import com.pulumi.awsnative.s3.Bucket;
import com.pulumi.awsnative.s3objectlambda.inputs.AccessPointAwsLambdaArgs;
import com.pulumi.awsnative.s3objectlambda.inputs.AccessPointObjectLambdaConfigurationArgs;
import com.pulumi.awsnative.s3objectlambda.inputs.AccessPointTransformationConfigurationArgs;
import com.pulumi.awsnative.s3objectlambda.inputs.AccessPointTransformationConfigurationContentTransformationPropertiesArgs;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        // The ARN of the Lambda function that transforms objects.
        final var functionArn = ctx.config().require("functionArn");

        var myBucket = new Bucket("myBucket");

        var ap = new AccessPoint("ap", AccessPointArgs.builder()
            .bucket(myBucket.id())
            .build());

        var objectLambdaAp = new com.pulumi.awsnative.s3objectlambda.AccessPoint("objectLambdaAp",
            com.pulumi.awsnative.s3objectlambda.AccessPointArgs.builder()
                .objectLambdaConfiguration(AccessPointObjectLambdaConfigurationArgs.builder()
                    .supportingAccessPoint(ap.arn())
                    .transformationConfigurations(AccessPointTransformationConfigurationArgs.builder()
                        .actions("GetObject")
                        .contentTransformation(AccessPointTransformationConfigurationContentTransformationPropertiesArgs.builder()
                            .awsLambda(AccessPointAwsLambdaArgs.builder()
                                .functionArn(functionArn)
                                .build())
                            .build())
                        .build())
                    .build())
                .build());
    }
}

config:
  # The ARN of the Lambda function that transforms objects.
  functionArn:
    type: string
resources:
  myBucket:
    type: aws-native:s3:Bucket
  ap:
    type: aws-native:s3:AccessPoint
    properties:
      bucket: ${myBucket}
  objectLambdaAp:
    type: aws-native:s3objectlambda:AccessPoint
    properties:
      objectLambdaConfiguration:
        supportingAccessPoint: ${ap.arn}
        transformationConfigurations:
          - actions:
              - GetObject
            contentTransformation:
              awsLambda:
                functionArn: ${functionArn}

terraform {
  required_providers {
    aws-native = {
      source = "pulumi/aws-native"
    }
  }
}

# The ARN of the Lambda function that transforms objects.
variable "function_arn" {
  type = string
}

resource "aws-native_s3_bucket" "myBucket" {
}

resource "aws-native_s3_access_point" "ap" {
  bucket = aws-native_s3_bucket.myBucket.id
}

resource "aws-native_s3objectlambda_access_point" "objectLambdaAp" {
  object_lambda_configuration = {
    supporting_access_point = aws-native_s3_access_point.ap.arn
    transformation_configurations = [{
      actions = ["GetObject"]
      content_transformation = {
        aws_lambda = {
          function_arn = var.function_arn
        }
      }
    }]
  }
}