# AWS::S3ObjectLambda Construct Library

> Version 2.277.0-alpha.0

> **Separate package**
>
> `@aws-cdk/aws-s3objectlambda-alpha` is not part of `aws-cdk-lib` — install it separately:
>
> ```sh
> npm install @aws-cdk/aws-s3objectlambda-alpha
> pip install aws-cdk.aws-s3objectlambda-alpha
> ```
>
> This module is [**experimental**](/stability) (alpha): its API may change in any release, without a major version bump.
---

![cdk-constructs: Experimental](https://img.shields.io/badge/cdk--constructs-experimental-important.svg?style=for-the-badge)

> The APIs of higher level constructs in this module are experimental and under active development.
> They are subject to non-backward compatible changes or removal in any future version. These are
> not subject to the [Semantic Versioning](https://semver.org/) model and breaking changes will be
> announced in the release notes. This means that while you may use them, you may need to update
> your source code when upgrading to a newer version of this package.

---

This construct library allows you to define S3 object lambda access points.

TypeScript:

```ts
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as s3objectlambda from '@aws-cdk/aws-s3objectlambda-alpha';
import * as cdk from 'aws-cdk-lib';

const stack = new cdk.Stack();
const bucket = new s3.Bucket(stack, 'MyBucket');
const handler = new lambda.Function(stack, 'MyFunction', {
	runtime: lambda.Runtime.NODEJS_LATEST,
	handler: 'index.handler',
	code: lambda.Code.fromAsset('lambda.zip'),
});
new s3objectlambda.AccessPoint(stack, 'MyObjectLambda', {
	bucket,
	handler,
	accessPointName: 'my-access-point',
	payload: {
		prop: "value",
	},
});
```

Python:

```python
import aws_cdk.aws_lambda as lambda_
import aws_cdk.aws_s3 as s3
import aws_cdk.aws_s3objectlambda_alpha as s3objectlambda
import aws_cdk as cdk

stack = cdk.Stack()
bucket = s3.Bucket(stack, "MyBucket")
handler = lambda_.Function(stack, "MyFunction",
    runtime=lambda_.Runtime.NODEJS_LATEST,
    handler="index.handler",
    code=lambda_.Code.from_asset("lambda.zip")
)
s3objectlambda.AccessPoint(stack, "MyObjectLambda",
    bucket=bucket,
    handler=handler,
    access_point_name="my-access-point",
    payload={
        "prop": "value"
    }
)
```

Java:

```java
import software.amazon.awscdk.services.lambda.*;
import software.amazon.awscdk.services.s3.*;
import software.amazon.awscdk.services.s3objectlambda.alpha.*;
import software.amazon.awscdk.*;

Stack stack = new Stack();
Bucket bucket = new Bucket(stack, "MyBucket");
Function handler = Function.Builder.create(stack, "MyFunction")
        .runtime(Runtime.NODEJS_LATEST)
        .handler("index.handler")
        .code(Code.fromAsset("lambda.zip"))
        .build();
AccessPoint.Builder.create(stack, "MyObjectLambda")
        .bucket(bucket)
        .handler(handler)
        .accessPointName("my-access-point")
        .payload(Map.of(
                "prop", "value"))
        .build();
```

C# / .NET:

```csharp
using Amazon.CDK.AWS.Lambda;
using Amazon.CDK.AWS.S3;
using Amazon.CDK.AWS.S3ObjectLambda.Alpha;
using Amazon.CDK;

var stack = new Stack();
var bucket = new Bucket(stack, "MyBucket");
var handler = new Function(stack, "MyFunction", new FunctionProps {
    Runtime = Runtime.NODEJS_LATEST,
    Handler = "index.handler",
    Code = Code.FromAsset("lambda.zip")
});
new AccessPoint(stack, "MyObjectLambda", new AccessPointProps {
    Bucket = bucket,
    Handler = handler,
    AccessPointName = "my-access-point",
    Payload = new Dictionary<string, object> {
        { "prop", "value" }
    }
});
```

Golang:

```go
import "github.com/aws/aws-cdk-go/awscdk"
import s3 "github.com/aws/aws-cdk-go/awscdk"
import s3objectlambda "github.com/aws/aws-cdk-go/awscdks3objectlambdaalpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"

stack := cdk.NewStack()
bucket := s3.NewBucket(stack, jsii.String("MyBucket"))
handler := lambda.NewFunction(stack, jsii.String("MyFunction"), &FunctionProps{
	Runtime: lambda.Runtime_NODEJS_LATEST(),
	Handler: jsii.String("index.handler"),
	Code: lambda.Code_FromAsset(jsii.String("lambda.zip")),
})
s3objectlambda.NewAccessPoint(stack, jsii.String("MyObjectLambda"), &AccessPointProps{
	Bucket: Bucket,
	Handler: Handler,
	AccessPointName: jsii.String("my-access-point"),
	Payload: map[string]interface{}{
		"prop": jsii.String("value"),
	},
})
```

## Handling range and part number requests

Lambdas are currently limited to only transforming `GetObject` requests. However, they can additionally support `GetObject-Range` and `GetObject-PartNumber` requests, which needs to be specified in the access point configuration:

TypeScript:

```ts
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as s3objectlambda from '@aws-cdk/aws-s3objectlambda-alpha';
import * as cdk from 'aws-cdk-lib';

const stack = new cdk.Stack();
const bucket = new s3.Bucket(stack, 'MyBucket');
const handler = new lambda.Function(stack, 'MyFunction', {
	runtime: lambda.Runtime.NODEJS_LATEST,
	handler: 'index.handler',
	code: lambda.Code.fromAsset('lambda.zip'),
});
new s3objectlambda.AccessPoint(stack, 'MyObjectLambda', {
	bucket,
	handler,
	accessPointName: 'my-access-point',
	supportsGetObjectRange: true,
	supportsGetObjectPartNumber: true,
});
```

Python:

```python
import aws_cdk.aws_lambda as lambda_
import aws_cdk.aws_s3 as s3
import aws_cdk.aws_s3objectlambda_alpha as s3objectlambda
import aws_cdk as cdk

stack = cdk.Stack()
bucket = s3.Bucket(stack, "MyBucket")
handler = lambda_.Function(stack, "MyFunction",
    runtime=lambda_.Runtime.NODEJS_LATEST,
    handler="index.handler",
    code=lambda_.Code.from_asset("lambda.zip")
)
s3objectlambda.AccessPoint(stack, "MyObjectLambda",
    bucket=bucket,
    handler=handler,
    access_point_name="my-access-point",
    supports_get_object_range=True,
    supports_get_object_part_number=True
)
```

Java:

```java
import software.amazon.awscdk.services.lambda.*;
import software.amazon.awscdk.services.s3.*;
import software.amazon.awscdk.services.s3objectlambda.alpha.*;
import software.amazon.awscdk.*;

Stack stack = new Stack();
Bucket bucket = new Bucket(stack, "MyBucket");
Function handler = Function.Builder.create(stack, "MyFunction")
        .runtime(Runtime.NODEJS_LATEST)
        .handler("index.handler")
        .code(Code.fromAsset("lambda.zip"))
        .build();
AccessPoint.Builder.create(stack, "MyObjectLambda")
        .bucket(bucket)
        .handler(handler)
        .accessPointName("my-access-point")
        .supportsGetObjectRange(true)
        .supportsGetObjectPartNumber(true)
        .build();
```

C# / .NET:

```csharp
using Amazon.CDK.AWS.Lambda;
using Amazon.CDK.AWS.S3;
using Amazon.CDK.AWS.S3ObjectLambda.Alpha;
using Amazon.CDK;

var stack = new Stack();
var bucket = new Bucket(stack, "MyBucket");
var handler = new Function(stack, "MyFunction", new FunctionProps {
    Runtime = Runtime.NODEJS_LATEST,
    Handler = "index.handler",
    Code = Code.FromAsset("lambda.zip")
});
new AccessPoint(stack, "MyObjectLambda", new AccessPointProps {
    Bucket = bucket,
    Handler = handler,
    AccessPointName = "my-access-point",
    SupportsGetObjectRange = true,
    SupportsGetObjectPartNumber = true
});
```

Golang:

```go
import "github.com/aws/aws-cdk-go/awscdk"
import s3 "github.com/aws/aws-cdk-go/awscdk"
import s3objectlambda "github.com/aws/aws-cdk-go/awscdks3objectlambdaalpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"

stack := cdk.NewStack()
bucket := s3.NewBucket(stack, jsii.String("MyBucket"))
handler := lambda.NewFunction(stack, jsii.String("MyFunction"), &FunctionProps{
	Runtime: lambda.Runtime_NODEJS_LATEST(),
	Handler: jsii.String("index.handler"),
	Code: lambda.Code_FromAsset(jsii.String("lambda.zip")),
})
s3objectlambda.NewAccessPoint(stack, jsii.String("MyObjectLambda"), &AccessPointProps{
	Bucket: Bucket,
	Handler: Handler,
	AccessPointName: jsii.String("my-access-point"),
	SupportsGetObjectRange: jsii.Boolean(true),
	SupportsGetObjectPartNumber: jsii.Boolean(true),
})
```

## Pass additional data to Lambda function

You can specify an additional object that provides supplemental data to the Lambda function used to transform objects. The data is delivered as a JSON payload to the Lambda:

TypeScript:

```ts
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as s3objectlambda from '@aws-cdk/aws-s3objectlambda-alpha';
import * as cdk from 'aws-cdk-lib';

const stack = new cdk.Stack();
const bucket = new s3.Bucket(stack, 'MyBucket');
const handler = new lambda.Function(stack, 'MyFunction', {
	runtime: lambda.Runtime.NODEJS_LATEST,
	handler: 'index.handler',
	code: lambda.Code.fromAsset('lambda.zip'),
});
new s3objectlambda.AccessPoint(stack, 'MyObjectLambda', {
	bucket,
	handler,
	accessPointName: 'my-access-point',
	payload: {
		prop: "value",
	},
});
```

Python:

```python
import aws_cdk.aws_lambda as lambda_
import aws_cdk.aws_s3 as s3
import aws_cdk.aws_s3objectlambda_alpha as s3objectlambda
import aws_cdk as cdk

stack = cdk.Stack()
bucket = s3.Bucket(stack, "MyBucket")
handler = lambda_.Function(stack, "MyFunction",
    runtime=lambda_.Runtime.NODEJS_LATEST,
    handler="index.handler",
    code=lambda_.Code.from_asset("lambda.zip")
)
s3objectlambda.AccessPoint(stack, "MyObjectLambda",
    bucket=bucket,
    handler=handler,
    access_point_name="my-access-point",
    payload={
        "prop": "value"
    }
)
```

Java:

```java
import software.amazon.awscdk.services.lambda.*;
import software.amazon.awscdk.services.s3.*;
import software.amazon.awscdk.services.s3objectlambda.alpha.*;
import software.amazon.awscdk.*;

Stack stack = new Stack();
Bucket bucket = new Bucket(stack, "MyBucket");
Function handler = Function.Builder.create(stack, "MyFunction")
        .runtime(Runtime.NODEJS_LATEST)
        .handler("index.handler")
        .code(Code.fromAsset("lambda.zip"))
        .build();
AccessPoint.Builder.create(stack, "MyObjectLambda")
        .bucket(bucket)
        .handler(handler)
        .accessPointName("my-access-point")
        .payload(Map.of(
                "prop", "value"))
        .build();
```

C# / .NET:

```csharp
using Amazon.CDK.AWS.Lambda;
using Amazon.CDK.AWS.S3;
using Amazon.CDK.AWS.S3ObjectLambda.Alpha;
using Amazon.CDK;

var stack = new Stack();
var bucket = new Bucket(stack, "MyBucket");
var handler = new Function(stack, "MyFunction", new FunctionProps {
    Runtime = Runtime.NODEJS_LATEST,
    Handler = "index.handler",
    Code = Code.FromAsset("lambda.zip")
});
new AccessPoint(stack, "MyObjectLambda", new AccessPointProps {
    Bucket = bucket,
    Handler = handler,
    AccessPointName = "my-access-point",
    Payload = new Dictionary<string, object> {
        { "prop", "value" }
    }
});
```

Golang:

```go
import "github.com/aws/aws-cdk-go/awscdk"
import s3 "github.com/aws/aws-cdk-go/awscdk"
import s3objectlambda "github.com/aws/aws-cdk-go/awscdks3objectlambdaalpha"
import cdk "github.com/aws/aws-cdk-go/awscdk"

stack := cdk.NewStack()
bucket := s3.NewBucket(stack, jsii.String("MyBucket"))
handler := lambda.NewFunction(stack, jsii.String("MyFunction"), &FunctionProps{
	Runtime: lambda.Runtime_NODEJS_LATEST(),
	Handler: jsii.String("index.handler"),
	Code: lambda.Code_FromAsset(jsii.String("lambda.zip")),
})
s3objectlambda.NewAccessPoint(stack, jsii.String("MyObjectLambda"), &AccessPointProps{
	Bucket: Bucket,
	Handler: Handler,
	AccessPointName: jsii.String("my-access-point"),
	Payload: map[string]interface{}{
		"prop": jsii.String("value"),
	},
})
```

## Accessing the S3 AccessPoint ARN

If you need access to the s3 accesspoint, you can get its ARN like so:

TypeScript:

```ts
import * as s3objectlambda from '@aws-cdk/aws-s3objectlambda-alpha';

declare const accessPoint: s3objectlambda.AccessPoint;
const s3AccessPointArn = accessPoint.s3AccessPointArn;
```

Python:

```python
import aws_cdk.aws_s3objectlambda_alpha as s3objectlambda

# access_point: s3objectlambda.AccessPoint
s3_access_point_arn = access_point.s3_access_point_arn
```

Java:

```java
import software.amazon.awscdk.services.s3objectlambda.alpha.*;

AccessPoint accessPoint;
String s3AccessPointArn = accessPoint.getS3AccessPointArn();
```

C# / .NET:

```csharp
using Amazon.CDK.AWS.S3ObjectLambda.Alpha;

AccessPoint accessPoint;
var s3AccessPointArn = accessPoint.S3AccessPointArn;
```

Golang:

```go
import s3objectlambda "github.com/aws/aws-cdk-go/awscdks3objectlambdaalpha"

var accessPoint AccessPoint
s3AccessPointArn := accessPoint.S3AccessPointArn
```

This is only supported for AccessPoints created in the stack - currently you're unable to get the S3 AccessPoint ARN for imported AccessPoints. To do that you'd have to know the S3 bucket name beforehand.

## Types

| Name | Kind | Summary |
| --- | --- | --- |
| [`AccessPoint`](/v2/docs/@aws-cdk_aws-s3objectlambda-alpha.AccessPoint) | Construct (L2) | An S3 object lambda access point for intercepting and transforming `GetObject` requests. |
| [`AccessPointAttributes`](/v2/docs/@aws-cdk_aws-s3objectlambda-alpha.AccessPointAttributes) | Struct | The access point resource attributes. |
| [`AccessPointProps`](/v2/docs/@aws-cdk_aws-s3objectlambda-alpha.AccessPointProps) | Struct | The S3 object lambda access point configuration. |
| [`IAccessPoint`](/v2/docs/@aws-cdk_aws-s3objectlambda-alpha.IAccessPoint) | Interface | The interface that represents the AccessPoint resource. |
