getFunction function

Provides details about an AWS Lambda Function. Use this data source to obtain information about an existing Lambda function for use in other resources or as a reference for function configurations.

> Note: This data source returns information about the latest version or alias specified by the qualifier. If no qualifier is provided, it returns information about the most recent published version, or $LATEST if no published version exists.

Example Usage

Basic Usage

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

const example = aws.lambda.getFunction({
    functionName: "my-lambda-function",
});
export const functionArn = example.then(example => example.arn);

import pulumi
import pulumi_aws as aws

example = aws.lambda_.get_function(function_name="my-lambda-function")
pulumi.export("functionArn", example.arn)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = Aws.Lambda.GetFunction.Invoke(new()
    {
        FunctionName = "my-lambda-function",
    });

    return new Dictionary<string, object?>
    {
        ["functionArn"] = example.Apply(getFunctionResult => getFunctionResult.Arn),
    };
});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lambda"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := lambda.LookupFunction(ctx, &lambda.LookupFunctionArgs{
			FunctionName: "my-lambda-function",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("functionArn", example.Arn)
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_lambda_getfunction" "example" {
  function_name = "my-lambda-function"
}

output "functionArn" {
  value = data.aws_lambda_getfunction.example.arn
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lambda.LambdaFunctions;
import com.pulumi.aws.lambda.inputs.GetFunctionArgs;
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) {
        final var example = LambdaFunctions.getFunction(GetFunctionArgs.builder()
            .functionName("my-lambda-function")
            .build());

        ctx.export("functionArn", example.arn());
    }
}

variables:
  example:
    fn::invoke:
      function: aws:lambda:getFunction
      arguments:
        functionName: my-lambda-function
outputs:
  functionArn: ${example.arn}

Using Function Alias

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

const example = aws.lambda.getFunction({
    functionName: "api-handler",
    qualifier: "production",
});
// Use in API Gateway integration
const exampleIntegration = new aws.apigateway.Integration("example", {
    restApi: exampleAwsApiGatewayRestApi.id,
    resourceId: exampleAwsApiGatewayResource.id,
    httpMethod: exampleAwsApiGatewayMethod.httpMethod,
    integrationHttpMethod: "POST",
    type: "AWS_PROXY",
    uri: example.then(example => example.invokeArn),
});

import pulumi
import pulumi_aws as aws

example = aws.lambda_.get_function(function_name="api-handler",
    qualifier="production")
# Use in API Gateway integration
example_integration = aws.apigateway.Integration("example",
    rest_api=example_aws_api_gateway_rest_api["id"],
    resource_id=example_aws_api_gateway_resource["id"],
    http_method=example_aws_api_gateway_method["httpMethod"],
    integration_http_method="POST",
    type="AWS_PROXY",
    uri=example.invoke_arn)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = Aws.Lambda.GetFunction.Invoke(new()
    {
        FunctionName = "api-handler",
        Qualifier = "production",
    });

    // Use in API Gateway integration
    var exampleIntegration = new Aws.ApiGateway.Integration("example", new()
    {
        RestApi = exampleAwsApiGatewayRestApi.Id,
        ResourceId = exampleAwsApiGatewayResource.Id,
        HttpMethod = exampleAwsApiGatewayMethod.HttpMethod,
        IntegrationHttpMethod = "POST",
        Type = "AWS_PROXY",
        Uri = example.Apply(getFunctionResult => getFunctionResult.InvokeArn),
    });

});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/apigateway"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lambda"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := lambda.LookupFunction(ctx, &lambda.LookupFunctionArgs{
			FunctionName: "api-handler",
			Qualifier:    pulumi.StringRef("production"),
		}, nil)
		if err != nil {
			return err
		}
		// Use in API Gateway integration
		_, err = apigateway.NewIntegration(ctx, "example", &apigateway.IntegrationArgs{
			RestApi:               pulumi.Any(exampleAwsApiGatewayRestApi.Id),
			ResourceId:            pulumi.Any(exampleAwsApiGatewayResource.Id),
			HttpMethod:            pulumi.Any(exampleAwsApiGatewayMethod.HttpMethod),
			IntegrationHttpMethod: pulumi.String("POST"),
			Type:                  pulumi.String("AWS_PROXY"),
			Uri:                   pulumi.String(example.InvokeArn),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_lambda_getfunction" "example" {
  function_name = "api-handler"
  qualifier     = "production"
}

# Use in API Gateway integration
resource "aws_apigateway_integration" "example" {
  rest_api                = exampleAwsApiGatewayRestApi.id
  resource_id             = exampleAwsApiGatewayResource.id
  http_method             = exampleAwsApiGatewayMethod.httpMethod
  integration_http_method = "POST"
  type                    = "AWS_PROXY"
  uri                     = data.aws_lambda_getfunction.example.invoke_arn
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lambda.LambdaFunctions;
import com.pulumi.aws.lambda.inputs.GetFunctionArgs;
import com.pulumi.aws.apigateway.Integration;
import com.pulumi.aws.apigateway.IntegrationArgs;
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) {
        final var example = LambdaFunctions.getFunction(GetFunctionArgs.builder()
            .functionName("api-handler")
            .qualifier("production")
            .build());

        // Use in API Gateway integration
        var exampleIntegration = new Integration("exampleIntegration", IntegrationArgs.builder()
            .restApi(exampleAwsApiGatewayRestApi.id())
            .resourceId(exampleAwsApiGatewayResource.id())
            .httpMethod(exampleAwsApiGatewayMethod.httpMethod())
            .integrationHttpMethod("POST")
            .type("AWS_PROXY")
            .uri(example.invokeArn())
            .build());

    }
}

resources:
  # Use in API Gateway integration
  exampleIntegration:
    type: aws:apigateway:Integration
    name: example
    properties:
      restApi: ${exampleAwsApiGatewayRestApi.id}
      resourceId: ${exampleAwsApiGatewayResource.id}
      httpMethod: ${exampleAwsApiGatewayMethod.httpMethod}
      integrationHttpMethod: POST
      type: AWS_PROXY
      uri: ${example.invokeArn}
variables:
  example:
    fn::invoke:
      function: aws:lambda:getFunction
      arguments:
        functionName: api-handler
        qualifier: production

Function Configuration Reference

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

function singleOrNone<T>(elements: pulumi.Input<T>[]): pulumi.Input<T> | undefined {
    if (elements.length > 1) {
        throw new Error("singleOrNone expected input list to have a single element");
    }
    return elements[0];
}

// Get existing function details
const reference = aws.lambda.getFunction({
    functionName: "existing-function",
});
// Create new function with similar configuration
const example = new aws.lambda.Function("example", {
    vpcConfig: {
        subnetIds: reference.then(reference => reference.vpcConfig?.subnetIds),
        securityGroupIds: reference.then(reference => reference.vpcConfig?.securityGroupIds),
    },
    environment: {
        variables: reference.then(reference => reference.environment?.variables),
    },
    durableConfig: singleOrNone(reference.then(reference => .map(entry => ({
        executionTimeout: entry.executionTimeout,
        retentionPeriod: entry.retentionPeriod,
    })))),
    code: new pulumi.asset.FileArchive("new-function.zip"),
    name: "new-function",
    role: reference.then(reference => reference.role),
    handler: reference.then(reference => reference.handler),
    runtime: aws.lambda.Runtime[reference.then(reference => reference.runtime)],
    memorySize: reference.then(reference => reference.memorySize),
    timeout: reference.then(reference => reference.timeout),
    architectures: reference.then(reference => reference.architectures),
});

import pulumi
import pulumi_aws as aws

def single_or_none(elements):
    if len(elements) > 1:
        raise Exception("single_or_none expected input list to have a single element")
    return elements[0] if elements else None


# Get existing function details
reference = aws.lambda_.get_function(function_name="existing-function")
# Create new function with similar configuration
example = aws.lambda_.Function("example",
    vpc_config={
        "subnet_ids": reference.vpc_config.subnet_ids,
        "security_group_ids": reference.vpc_config.security_group_ids,
    },
    environment={
        "variables": reference.environment.variables,
    },
    durable_config=single_or_none([{
        "executionTimeout": entry.execution_timeout,
        "retentionPeriod": entry.retention_period,
    } for entry in reference.durable_configs]),
    code=pulumi.FileArchive("new-function.zip"),
    name="new-function",
    role=reference.role,
    handler=reference.handler,
    runtime=aws.lambda_.Runtime(reference.runtime),
    memory_size=reference.memory_size,
    timeout=reference.timeout,
    architectures=reference.architectures)

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    // Get existing function details
    var reference = Aws.Lambda.GetFunction.Invoke(new()
    {
        FunctionName = "existing-function",
    });

    // Create new function with similar configuration
    var example = new Aws.Lambda.Function("example", new()
    {
        VpcConfig = new Aws.Lambda.Inputs.FunctionVpcConfigArgs
        {
            SubnetIds = reference.Apply(getFunctionResult => getFunctionResult.VpcConfig?.SubnetIds),
            SecurityGroupIds = reference.Apply(getFunctionResult => getFunctionResult.VpcConfig?.SecurityGroupIds),
        },
        Environment = new Aws.Lambda.Inputs.FunctionEnvironmentArgs
        {
            Variables = reference.Apply(getFunctionResult => getFunctionResult.Environment?.Variables),
        },
        DurableConfig = Enumerable.SingleOrDefault(.Select(entry =>
        {
            return
            {
                { "executionTimeout", entry.ExecutionTimeout },
                { "retentionPeriod", entry.RetentionPeriod },
            };
        }).ToList()),
        Code = new FileArchive("new-function.zip"),
        Name = "new-function",
        Role = reference.Apply(getFunctionResult => getFunctionResult.Role),
        Handler = reference.Apply(getFunctionResult => getFunctionResult.Handler),
        Runtime = reference.Apply(getFunctionResult => getFunctionResult.Runtime).Apply(System.Enum.Parse<Aws.Lambda.Runtime>),
        MemorySize = reference.Apply(getFunctionResult => getFunctionResult.MemorySize),
        Timeout = reference.Apply(getFunctionResult => getFunctionResult.Timeout),
        Architectures = reference.Apply(getFunctionResult => getFunctionResult.Architectures),
    });

});

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_lambda_getfunction" "reference" {
  function_name = "existing-function"
}

# Create new function with similar configuration
resource "aws_lambda_function" "example" {
  vpc_config = {
    subnet_ids         = data.aws_lambda_getfunction.reference.vpc_config.subnet_ids
    security_group_ids = data.aws_lambda_getfunction.reference.vpc_config.security_group_ids
  }
  environment = {
    variables = data.aws_lambda_getfunction.reference.environment.variables
  }
  durable_config = one([for entry in data.aws_lambda_getfunction.reference.durable_configs : {
    "executionTimeout" = entry.executionTimeout
    "retentionPeriod"  = entry.retentionPeriod
  } ])
  code          = fileArchive("new-function.zip")
  name          = "new-function"
  role          = data.aws_lambda_getfunction.reference.role
  handler       = data.aws_lambda_getfunction.reference.handler
  runtime       = data.aws_lambda_getfunction.reference.runtime
  memory_size   = data.aws_lambda_getfunction.reference.memory_size
  timeout       = data.aws_lambda_getfunction.reference.timeout
  architectures = data.aws_lambda_getfunction.reference.architectures
}
# Get existing function details

Function Version Management

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

// Get details about specific version
const version = aws.lambda.getFunction({
    functionName: "my-function",
    qualifier: "3",
});
// Get details about latest version
const latest = aws.lambda.getFunction({
    functionName: "my-function",
    qualifier: "$LATEST",
});
export const versionComparison = {
    specificVersion: version.then(version => version.version),
    latestVersion: latest.then(latest => latest.version),
    codeDifference: Promise.all([version, latest]).then(([version, latest]) => version.codeSha256 != latest.codeSha256),
};

import pulumi
import pulumi_aws as aws

# Get details about specific version
version = aws.lambda_.get_function(function_name="my-function",
    qualifier="3")
# Get details about latest version
latest = aws.lambda_.get_function(function_name="my-function",
    qualifier="$LATEST")
pulumi.export("versionComparison", {
    "specificVersion": version.version,
    "latestVersion": latest.version,
    "codeDifference": version.code_sha256 != latest.code_sha256,
})

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    // Get details about specific version
    var version = Aws.Lambda.GetFunction.Invoke(new()
    {
        FunctionName = "my-function",
        Qualifier = "3",
    });

    // Get details about latest version
    var latest = Aws.Lambda.GetFunction.Invoke(new()
    {
        FunctionName = "my-function",
        Qualifier = "$LATEST",
    });

    return new Dictionary<string, object?>
    {
        ["versionComparison"] =
        {
            { "specificVersion", version.Apply(getFunctionResult => getFunctionResult.Version) },
            { "latestVersion", latest.Apply(getFunctionResult => getFunctionResult.Version) },
            { "codeDifference", Output.Tuple(version, latest).Apply(values =>
            {
                var version = values.Item1;
                var latest = values.Item2;
                return version.Apply(getFunctionResult => getFunctionResult.CodeSha256) != latest.Apply(getFunctionResult => getFunctionResult.CodeSha256);
            }) },
        },
    };
});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lambda"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Get details about specific version
		version, err := lambda.LookupFunction(ctx, &lambda.LookupFunctionArgs{
			FunctionName: "my-function",
			Qualifier:    pulumi.StringRef("3"),
		}, nil)
		if err != nil {
			return err
		}
		// Get details about latest version
		latest, err := lambda.LookupFunction(ctx, &lambda.LookupFunctionArgs{
			FunctionName: "my-function",
			Qualifier:    pulumi.StringRef("$LATEST"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("versionComparison", pulumi.Map{
			"specificVersion": version.Version,
			"latestVersion":   latest.Version,
			"codeDifference":  pulumi.Bool(version.CodeSha256 != latest.CodeSha256),
		})
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_lambda_getfunction" "version" {
  function_name = "my-function"
  qualifier     = "3"
}
data "aws_lambda_getfunction" "latest" {
  function_name = "my-function"
  qualifier     = "$LATEST"
}

# Get details about specific version
# Get details about latest version
# Compare versions
output "versionComparison" {
  value = {
    "specificVersion" = data.aws_lambda_getfunction.version.version
    "latestVersion"   = data.aws_lambda_getfunction.latest.version
    "codeDifference"  = data.aws_lambda_getfunction.version.code_sha256 != data.aws_lambda_getfunction.latest.code_sha256
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lambda.LambdaFunctions;
import com.pulumi.aws.lambda.inputs.GetFunctionArgs;
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) {
        // Get details about specific version
        final var version = LambdaFunctions.getFunction(GetFunctionArgs.builder()
            .functionName("my-function")
            .qualifier("3")
            .build());

        // Get details about latest version
        final var latest = LambdaFunctions.getFunction(GetFunctionArgs.builder()
            .functionName("my-function")
            .qualifier("$LATEST")
            .build());

        ctx.export("versionComparison", Map.ofEntries(
            Map.entry("specificVersion", version.version()),
            Map.entry("latestVersion", latest.version()),
            Map.entry("codeDifference", version.codeSha256() != latest.codeSha256())
        ));
    }
}

Accessing Durable Configuration

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

const durableFunction = aws.lambda.getFunction({
    functionName: "my-durable-function",
});
export const durableSettings = {
    hasDurableConfig: durableFunction.then(durableFunction => durableFunction.durableConfigs).length.apply(length => length > 0),
    executionTimeout: pulumi.all([durableFunction.then(durableFunction => durableFunction.durableConfigs).length, durableFunction]).apply(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.executionTimeout : null),
    retentionPeriod: pulumi.all([durableFunction.then(durableFunction => durableFunction.durableConfigs).length, durableFunction]).apply(([length, durableFunction]) => length > 0 ? durableFunction.durableConfigs?.[0]?.retentionPeriod : null),
};

import pulumi
import pulumi_aws as aws

durable_function = aws.lambda_.get_function(function_name="my-durable-function")
pulumi.export("durableSettings", {
    "hasDurableConfig": len(durable_function.durable_configs).apply(lambda length: length > 0),
    "executionTimeout": len(durable_function.durable_configs).apply(lambda length: durable_function.durable_configs[0].execution_timeout if length > 0 else None),
    "retentionPeriod": len(durable_function.durable_configs).apply(lambda length: durable_function.durable_configs[0].retention_period if length > 0 else None),
})

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var durableFunction = Aws.Lambda.GetFunction.Invoke(new()
    {
        FunctionName = "my-durable-function",
    });

    return new Dictionary<string, object?>
    {
        ["durableSettings"] =
        {
            { "hasDurableConfig", durableFunction.Apply(getFunctionResult => getFunctionResult.DurableConfigs).Length().Apply(length => length > 0) },
            { "executionTimeout", Output.Tuple(durableFunction.Apply(getFunctionResult => getFunctionResult.DurableConfigs).Length(), durableFunction).Apply(values =>
            {
                var length = values.Item1;
                var durableFunction = values.Item2;
                return length > 0 ? durableFunction.Apply(getFunctionResult => getFunctionResult.DurableConfigs[0]?.ExecutionTimeout) : null;
            }) },
            { "retentionPeriod", Output.Tuple(durableFunction.Apply(getFunctionResult => getFunctionResult.DurableConfigs).Length(), durableFunction).Apply(values =>
            {
                var length = values.Item1;
                var durableFunction = values.Item2;
                return length > 0 ? durableFunction.Apply(getFunctionResult => getFunctionResult.DurableConfigs[0]?.RetentionPeriod) : null;
            }) },
        },
    };
});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/lambda"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		durableFunction, err := lambda.LookupFunction(ctx, &lambda.LookupFunctionArgs{
			FunctionName: "my-durable-function",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("durableSettings", pulumi.Map{
			"hasDurableConfig": len(durableFunction.DurableConfigs).ApplyT(func(length int) (bool, error) {
				return length > 0, nil
			}).(pulumi.BoolOutput),
			"executionTimeout": len(durableFunction.DurableConfigs).ApplyT(func(length int) (*int, error) {
				var tmp0 *int
				if length > 0 {
					tmp0 = durableFunction.DurableConfigs[0].ExecutionTimeout
				} else {
					tmp0 = nil
				}
				return &tmp0, nil
			}).(pulumi.IntPtrOutput),
			"retentionPeriod": len(durableFunction.DurableConfigs).ApplyT(func(length int) (*int, error) {
				var tmp1 *int
				if length > 0 {
					tmp1 = durableFunction.DurableConfigs[0].RetentionPeriod
				} else {
					tmp1 = nil
				}
				return &tmp1, nil
			}).(pulumi.IntPtrOutput),
		})
		return nil
	})
}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_lambda_getfunction" "durableFunction" {
  function_name = "my-durable-function"
}

# Output durable configuration details
output "durableSettings" {
  value = {
    "hasDurableConfig" = length(data.aws_lambda_getfunction.durableFunction.durable_configs) > 0
    "executionTimeout" = length(data.aws_lambda_getfunction.durableFunction.durable_configs) > 0 ? data.aws_lambda_getfunction.durableFunction.durable_configs[0].execution_timeout : null
    "retentionPeriod"  = length(data.aws_lambda_getfunction.durableFunction.durable_configs) > 0 ? data.aws_lambda_getfunction.durableFunction.durable_configs[0].retention_period : null
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lambda.LambdaFunctions;
import com.pulumi.aws.lambda.inputs.GetFunctionArgs;
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) {
        final var durableFunction = LambdaFunctions.getFunction(GetFunctionArgs.builder()
            .functionName("my-durable-function")
            .build());

        ctx.export("durableSettings", Map.ofEntries(
            Map.entry("hasDurableConfig", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0)),
            Map.entry("executionTimeout", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0 ? durableFunction.durableConfigs()[0].executionTimeout() : null)),
            Map.entry("retentionPeriod", durableFunction.durableConfigs().size().applyValue(_length -> _length > 0 ? durableFunction.durableConfigs()[0].retentionPeriod() : null))
        ));
    }
}

args Arguments passed to this invoke. Arguments for getFunction. options Invoke options controlling this call.