getFunctions function

Future<GetFunctionsResult> getFunctions(
  1. GetFunctionsArgs args, {
  2. InvokeOptions? options,
})

Provides a list of AWS Lambda Functions in the current region. Use this data source to discover existing Lambda functions for inventory, monitoring, or bulk operations.

Example Usage

List All Functions

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

const all = aws.lambda.getFunctions({});
export const functionCount = all.then(all => all.functionNames).length;
export const allFunctionNames = all.then(all => all.functionNames);

import pulumi
import pulumi_aws as aws

all = aws.lambda_.get_functions()
pulumi.export("functionCount", len(all.function_names))
pulumi.export("allFunctionNames", all.function_names)

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

return await Deployment.RunAsync(() =>
{
    var all = Aws.Lambda.GetFunctions.Invoke();

    return new Dictionary<string, object?>
    {
        ["functionCount"] = all.Apply(getFunctionsResult => getFunctionsResult.FunctionNames).Length(),
        ["allFunctionNames"] = all.Apply(getFunctionsResult => getFunctionsResult.FunctionNames),
    };
});

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 {
		all, err := lambda.GetFunctions(ctx, &lambda.GetFunctionsArgs{}, nil)
		if err != nil {
			return err
		}
		ctx.Export("functionCount", len(all.FunctionNames))
		ctx.Export("allFunctionNames", all.FunctionNames)
		return nil
	})
}

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

data "aws_lambda_getfunctions" "all" {
}

output "functionCount" {
  value = length(data.aws_lambda_getfunctions.all.function_names)
}
output "allFunctionNames" {
  value = data.aws_lambda_getfunctions.all.function_names
}

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.GetFunctionsArgs;
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 all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
            .build());

        ctx.export("functionCount", all.functionNames().size());
        ctx.export("allFunctionNames", all.functionNames());
    }
}

variables:
  all:
    fn::invoke:
      function: aws:lambda:getFunctions
      arguments: {}
outputs:
  functionCount:
    fn::length: ${all.functionNames}
  allFunctionNames: ${all.functionNames}

Use Function List for Bulk Operations

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

// Get all Lambda functions
const all = aws.lambda.getFunctions({});
// Create CloudWatch alarms for all functions
const lambdaErrors: aws.cloudwatch.MetricAlarm[] = [];
all.then(all => all.functionNames).length.apply(rangeBody => {
    for (let range = 0; range < rangeBody; range++) {
        lambdaErrors.push(new aws.cloudwatch.MetricAlarm(`lambda_errors-${range}`, {
            name: all.then(all => `${all.functionNames[range]}-errors`),
            comparisonOperator: "GreaterThanThreshold",
            evaluationPeriods: 2,
            metricName: "Errors",
            namespace: "AWS/Lambda",
            period: 300,
            statistic: "Sum",
            threshold: 5,
            alarmDescription: "This metric monitors lambda errors",
            dimensions: {
                FunctionName: all.then(all => all.functionNames[range]),
            },
            tags: {
                Environment: "monitoring",
                Purpose: "lambda-error-tracking",
            },
        }));
    }
});

import pulumi
from typing import Any
import pulumi_aws as aws

# Get all Lambda functions
all = aws.lambda_.get_functions()
# Create CloudWatch alarms for all functions
lambda_errors: list[aws.cloudwatch.MetricAlarm] = []
def create_lambda_errors(range_body):
    for lambda_errors_range in [{"value": i} for i in range(0, range_body)]:
        lambda_errors.append(aws.cloudwatch.MetricAlarm(f"lambda_errors-{lambda_errors_range['value']}",
            name=f"{all.function_names[lambda_errors_range['value']]}-errors",
            comparison_operator="GreaterThanThreshold",
            evaluation_periods=2,
            metric_name="Errors",
            namespace="AWS/Lambda",
            period=300,
            statistic="Sum",
            threshold=float(5),
            alarm_description="This metric monitors lambda errors",
            dimensions={
                "FunctionName": all.function_names[lambda_errors_range["value"]],
            },
            tags={
                "Environment": "monitoring",
                "Purpose": "lambda-error-tracking",
            }))

(len(all.function_names)).apply(create_lambda_errors)

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

return await Deployment.RunAsync(() =>
{
    // Get all Lambda functions
    var all = Aws.Lambda.GetFunctions.Invoke();

    // Create CloudWatch alarms for all functions
    var lambdaErrors = new List<Aws.CloudWatch.MetricAlarm>();
    all.Apply(getFunctionsResult => getFunctionsResult.FunctionNames).Length().Apply(rangeBody =>
    {
        for (var rangeIndex = 0; rangeIndex < rangeBody; rangeIndex++)
        {
            var range = new { Value = rangeIndex };
            lambdaErrors.Add(new Aws.CloudWatch.MetricAlarm($"lambda_errors-{range.Value}", new()
            {
                Name = $"{all.Apply(getFunctionsResult => getFunctionsResult.FunctionNames)[range.Value]}-errors",
                ComparisonOperator = "GreaterThanThreshold",
                EvaluationPeriods = 2,
                MetricName = "Errors",
                Namespace = "AWS/Lambda",
                Period = 300,
                Statistic = "Sum",
                Threshold = 5,
                AlarmDescription = "This metric monitors lambda errors",
                Dimensions =
                {
                    { "FunctionName", all.Apply(getFunctionsResult => getFunctionsResult.FunctionNames)[range.Value] },
                },
                Tags =
                {
                    { "Environment", "monitoring" },
                    { "Purpose", "lambda-error-tracking" },
                },
            }));
        }
        return 0;
    });
});

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
	"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 all Lambda functions
		all, err := lambda.GetFunctions(ctx, &lambda.GetFunctionsArgs{}, nil)
		if err != nil {
			return err
		}
		// Create CloudWatch alarms for all functions
		var lambdaErrors []*cloudwatch.MetricAlarm
		for index := 0; index < int(len(all.FunctionNames)); index++ {
			key0 := index
			val0 := index
			__res, err := cloudwatch.NewMetricAlarm(ctx, fmt.Sprintf("lambda_errors-%v", key0), &cloudwatch.MetricAlarmArgs{
				Name:               pulumi.Sprintf("%v-errors", all.FunctionNames[val0]),
				ComparisonOperator: pulumi.String("GreaterThanThreshold"),
				EvaluationPeriods:  pulumi.Int(2),
				MetricName:         pulumi.String("Errors"),
				Namespace:          pulumi.String("AWS/Lambda"),
				Period:             pulumi.Int(300),
				Statistic:          pulumi.String("Sum"),
				Threshold:          pulumi.Float64(5),
				AlarmDescription:   pulumi.String("This metric monitors lambda errors"),
				Dimensions: pulumi.StringMap{
					"FunctionName": pulumi.String(all.FunctionNames[val0]),
				},
				Tags: pulumi.StringMap{
					"Environment": pulumi.String("monitoring"),
					"Purpose":     pulumi.String("lambda-error-tracking"),
				},
			})
			if err != nil {
				return err
			}
			lambdaErrors = append(lambdaErrors, __res)
		}
		return nil
	})
}

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

data "aws_lambda_getfunctions" "all" {
}

# Create CloudWatch alarms for all functions
resource "aws_cloudwatch_metricalarm" "lambda_errors" {
  count               = length(data.aws_lambda_getfunctions.all.function_names)
  name                ="${data.aws_lambda_getfunctions.all.function_names[count.index]}-errors"
  comparison_operator = "GreaterThanThreshold"
  evaluation_periods  = "2"
  metric_name         = "Errors"
  namespace           = "AWS/Lambda"
  period              = "300"
  statistic           = "Sum"
  threshold           = "5"
  alarm_description   = "This metric monitors lambda errors"
  dimensions = {
    "FunctionName" = data.aws_lambda_getfunctions.all.function_names[count.index]
  }
  tags = {
    "Environment" = "monitoring"
    "Purpose"     = "lambda-error-tracking"
  }
}
# Get all Lambda functions

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.GetFunctionsArgs;
import com.pulumi.aws.cloudwatch.MetricAlarm;
import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
import com.pulumi.codegen.internal.KeyedValue;
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 all Lambda functions
        final var all = LambdaFunctions.getFunctions(GetFunctionsArgs.builder()
            .build());

        // Create CloudWatch alarms for all functions
        for (var i = 0; i < all.functionNames().size(); i++) {
            new MetricAlarm("lambdaErrors-" + i, MetricAlarmArgs.builder()
                .name(String.format("%s-errors", all.functionNames()[range.value()]))
                .comparisonOperator("GreaterThanThreshold")
                .evaluationPeriods(2)
                .metricName("Errors")
                .namespace("AWS/Lambda")
                .period(300)
                .statistic("Sum")
                .threshold(5.0)
                .alarmDescription("This metric monitors lambda errors")
                .dimensions(Map.of("FunctionName", all.functionNames()[range.value()]))
                .tags(Map.ofEntries(
                    Map.entry("Environment", "monitoring"),
                    Map.entry("Purpose", "lambda-error-tracking")
                ))
                .build());


}
    }
}

Filter Functions by Name Pattern

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

function can_(
    fn: () => any
): boolean {
    try {
        const result = fn();
        if (result === undefined) {
            return false;
        }
        return true;
    } catch (e) {
        return false;
    }
}


export = async () => {
    // Get all functions
    const all = await aws.lambda.getFunctions({});
    const apiFunctions = .filter(name =>
can_(() => (await await std.regex({
        pattern: "^api-",
        string: name,
    })).result)).map(name => (name));
    const workerFunctions = .filter(name =>
can_(() => (await await std.regex({
        pattern: "^worker-",
        string: name,
    })).result)).map(name => (name));
    return {
        apiFunctions: apiFunctions,
        workerFunctions: workerFunctions,
    };
}

import pulumi
import pulumi_aws as aws
import pulumi_std as std

def can_(fn):
    try:
        _result = fn()
        return True
    except:
        return False


# Get all functions
all = aws.lambda_.get_functions()
api_functions = [name for name in all.function_names if can_(lambda: std.regex(pattern="^api-",
    string=name).result)]
worker_functions = [name for name in all.function_names if can_(lambda: std.regex(pattern="^worker-",
    string=name).result)]
pulumi.export("apiFunctions", api_functions)
pulumi.export("workerFunctions", worker_functions)

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

data "aws_lambda_getfunctions" "all" {
}

# Get all functions
locals {
  apiFunctions = [for name in data.aws_lambda_getfunctions.all.function_names : name if can(regex("^api-", name))]
}
locals {
  workerFunctions = [for name in data.aws_lambda_getfunctions.all.function_names : name if can(regex("^worker-", name))]
}
output "apiFunctions" {
  value = local.apiFunctions
}
output "workerFunctions" {
  value = local.workerFunctions
}

Create Function Inventory

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

export = async () => {
    const all = await aws.lambda.getFunctions({});
    // Get detailed information for each function
    const details = .map(__index => (await aws.lambda.getFunction({
        functionName: all.functionNames[__index],
    })));
    const functionInventory = .map(([i, name]) => ({
        name: name,
        arn: all.functionArns[i],
        runtime: details.apply(details => details[i].runtime),
        memorySize: details.apply(details => details[i].memorySize),
        timeout: details.apply(details => details[i].timeout),
        handler: details.apply(details => details[i].handler),
    }));
    return {
        functionInventory: functionInventory,
    };
}

import pulumi
import pulumi_aws as aws

all = aws.lambda_.get_functions()
# Get detailed information for each function
details = [aws.lambda_.get_function(function_name=all.function_names[__index]) for __index in len(all.function_names).apply(lambda length: range(length))]
function_inventory = [{
    "name": name,
    "arn": all.function_arns[i],
    "runtime": details.apply(lambda details: details[i].runtime),
    "memorySize": details.apply(lambda details: details[i].memory_size),
    "timeout": details.apply(lambda details: details[i].timeout),
    "handler": details.apply(lambda details: details[i].handler),
} for i, name in enumerate(all.function_names)]
pulumi.export("functionInventory", function_inventory)

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

return await Deployment.RunAsync(() =>
{
    var all = Aws.Lambda.GetFunctions.Invoke();

    // Get detailed information for each function
    var details = ;

    var functionInventory = Output.Tuple(all, details).Apply(values =>
    {
        var all = values.Item1;
        var details = values.Item2;
        return .Select(name =>
        {
            return
            {
                { "name", name },
                { "arn", all.Apply(getFunctionsResult => getFunctionsResult.FunctionArns)[i] },
                { "runtime", details[i].Runtime },
                { "memorySize", details[i].MemorySize },
                { "timeout", details[i].Timeout },
                { "handler", details[i].Handler },
            };
        }).ToList();
    });

    return new Dictionary<string, object?>
    {
        ["functionInventory"] = functionInventory,
    };
});

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

data "aws_lambda_getfunctions" "all" {
}
data "aws_lambda_getfunction" "invoke_1" {
  for_each      = toset(range(length(data.aws_lambda_getfunctions.all.function_names)))
  function_name = data.aws_lambda_getfunctions.all.function_names[each.value]
}

# Get detailed information for each function
locals {
  details = [for __index in range(length(data.aws_lambda_getfunctions.all.function_names)) : data.aws_lambda_getfunction.invoke_1[__index]]
}
locals {
  functionInventory = [for i, name in data.aws_lambda_getfunctions.all.function_names : {
    "name"       = name
    "arn"        = data.aws_lambda_getfunctions.all.function_arns[i]
    "runtime"    = local.details[i].runtime
    "memorySize" = local.details[i].memory_size
    "timeout"    = local.details[i].timeout
    "handler"    = local.details[i].handler
  } ]
}
output "functionInventory" {
  value = local.functionInventory
}

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

Implementation

Future<GetFunctionsResult> getFunctions(
  GetFunctionsArgs args, {
  pulumi.InvokeOptions? options,
}) async {
  final deployment = pulumi.Deployment.instance;
  final result = await deployment.invoke<Map<String, dynamic>>(
    'aws:lambda/getFunctions:getFunctions',
    args.toMap(),
    options: pulumi.toDeploymentInvokeOptions(options),
  );
  return GetFunctionsResult.fromMap(result);
}