aws-cdk-lib.aws_greengrass.CfnFunctionDefinitionVersion.FunctionConfigurationProperty

FunctionConfigurationProperty Struct

The group-specific configuration settings for a Lambda function.

These settings configure the function's behavior in the Greengrass group. For more information, see Controlling Execution of Greengrass Lambda Functions by Using Group-Specific Configuration in the Developer Guide .

In an CloudFormation template, FunctionConfiguration is a property of the Function property type.

Source

Generated code

Type last changed

v2.93.0 · 23 Aug 2023

Example

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import { aws_greengrass as greengrass } from 'aws-cdk-lib';

declare const variables: any;
const functionConfigurationProperty: greengrass.CfnFunctionDefinitionVersion.FunctionConfigurationProperty = {
  encodingType: 'encodingType',
  environment: {
    accessSysfs: false,
    execution: {
      isolationMode: 'isolationMode',
      runAs: {
        gid: 123,
        uid: 123,
      },
    },
    resourceAccessPolicies: [{
      resourceId: 'resourceId',

      // the properties below are optional
      permission: 'permission',
    }],
    variables: variables,
  },
  execArgs: 'execArgs',
  executable: 'executable',
  memorySize: 123,
  pinned: false,
  timeout: 123,
};

# The code below shows an example of how to instantiate this type.
# The values are placeholders you should change.
from aws_cdk import aws_greengrass as greengrass

# variables: Any

function_configuration_property = greengrass.CfnFunctionDefinitionVersion.FunctionConfigurationProperty(
    encoding_type="encodingType",
    environment=greengrass.CfnFunctionDefinitionVersion.EnvironmentProperty(
        access_sysfs=False,
        execution=greengrass.CfnFunctionDefinitionVersion.ExecutionProperty(
            isolation_mode="isolationMode",
            run_as=greengrass.CfnFunctionDefinitionVersion.RunAsProperty(
                gid=123,
                uid=123
            )
        ),
        resource_access_policies=[greengrass.CfnFunctionDefinitionVersion.ResourceAccessPolicyProperty(
            resource_id="resourceId",

            # the properties below are optional
            permission="permission"
        )],
        variables=variables
    ),
    exec_args="execArgs",
    executable="executable",
    memory_size=123,
    pinned=False,
    timeout=123
)

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import software.amazon.awscdk.services.greengrass.*;

Object variables;

FunctionConfigurationProperty functionConfigurationProperty = FunctionConfigurationProperty.builder()
        .encodingType("encodingType")
        .environment(EnvironmentProperty.builder()
                .accessSysfs(false)
                .execution(ExecutionProperty.builder()
                        .isolationMode("isolationMode")
                        .runAs(RunAsProperty.builder()
                                .gid(123)
                                .uid(123)
                                .build())
                        .build())
                .resourceAccessPolicies(List.of(ResourceAccessPolicyProperty.builder()
                        .resourceId("resourceId")

                        // the properties below are optional
                        .permission("permission")
                        .build()))
                .variables(variables)
                .build())
        .execArgs("execArgs")
        .executable("executable")
        .memorySize(123)
        .pinned(false)
        .timeout(123)
        .build();

// Install: dotnet add package Amazon.CDK.Lib
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
using Amazon.CDK.AWS.Greengrass;

var variables;

var functionConfigurationProperty = new FunctionConfigurationProperty {
    EncodingType = "encodingType",
    Environment = new EnvironmentProperty {
        AccessSysfs = false,
        Execution = new ExecutionProperty {
            IsolationMode = "isolationMode",
            RunAs = new RunAsProperty {
                Gid = 123,
                Uid = 123
            }
        },
        ResourceAccessPolicies = new [] { new ResourceAccessPolicyProperty {
            ResourceId = "resourceId",

            // the properties below are optional
            Permission = "permission"
        } },
        Variables = variables
    },
    ExecArgs = "execArgs",
    Executable = "executable",
    MemorySize = 123,
    Pinned = false,
    Timeout = 123
};

// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var variables interface{}

functionConfigurationProperty := &FunctionConfigurationProperty{
	EncodingType: jsii.String("encodingType"),
	Environment: &EnvironmentProperty{
		AccessSysfs: jsii.Boolean(false),
		Execution: &ExecutionProperty{
			IsolationMode: jsii.String("isolationMode"),
			RunAs: &RunAsProperty{
				Gid: jsii.Number(123),
				Uid: jsii.Number(123),
			},
		},
		ResourceAccessPolicies: []interface{}{
			&ResourceAccessPolicyProperty{
				ResourceId: jsii.String("resourceId"),

				// the properties below are optional
				Permission: jsii.String("permission"),
			},
		},
		Variables: variables,
	},
	ExecArgs: jsii.String("execArgs"),
	Executable: jsii.String("executable"),
	MemorySize: jsii.Number(123),
	Pinned: jsii.Boolean(false),
	Timeout: jsii.Number(123),
}

Properties

encodingType?optionalstringencoding_type?optionalstrencodingType?optionalStringEncodingType?optionalstringEncodingType?optional*string#

The expected encoding type of the input payload for the function.

Valid values are json (default) and binary .

environment?optionalIResolvable | CfnFunctionDefinitionVersion.EnvironmentPropertyenvironment?optionaltyping.Union[IResolvable, EnvironmentProperty]environment?optionalIResolvableEnvironment?optionalIResolvableEnvironment?optionalinterface{}#

The environment configuration of the function.

execArgs?optionalstringexec_args?optionalstrexecArgs?optionalStringExecArgs?optionalstringExecArgs?optional*string#

The execution arguments.

executable?optionalstringexecutable?optionalstrexecutable?optionalStringExecutable?optionalstringExecutable?optional*string#

The name of the function executable.

memorySize?optionalnumbermemory_size?optionalint | floatmemorySize?optionalNumberMemorySize?optionaldoubleMemorySize?optional*float64#

The memory size (in KB) required by the function.

This property applies only to Lambda functions that run in a Greengrass container.

pinned?optionalboolean | IResolvablepinned?optionaltyping.Union[bool, IResolvable]pinned?optionalBooleanPinned?optionalboolPinned?optionalinterface{}#

Indicates whether the function is pinned (or *long-lived* ).

Pinned functions start when the core starts and process all requests in the same container. The default value is false.

timeout?optionalnumbertimeout?optionalint | floattimeout?optionalNumberTimeout?optionaldoubleTimeout?optional*float64#

The allowed execution time (in seconds) after which the function should terminate.

For pinned functions, this timeout applies for each request.