What is the method to incorporate requirementstxt in a Pulumi Lambda build in TypeScript

Question

Pulumi · Accepted Answer

To incorporate a `requirements.txt` file in a Pulumi Lambda build using TypeScript, you would generally follow these steps:

1. **Define your `requirements.txt` file:** This file should list all the Python dependencies your Lambda function requires.
2. **Use `@pulumi/aws` Lambda resource with inline code or asset/archive:** Pulumi allows you to define Lambda functions either using inline source code or by pointing to code stored in S3 as an asset or archive.
3. **Package your Lambda code along with `requirements.txt`:** Before deployment, use a tool to package your Python code and its dependencies into a zip file.
4. **Deploy your Lambda with Pulumi:** Set the `code` property of the Lambda function to point to the packaged asset.

Below is a sample Pulumi program that demonstrates these steps:

```typescript
import * as pulumi from '@pulumi/pulumi';
import * as aws from '@pulumi/aws';
import * as fs from 'fs';
import * as path from 'path';
import { PythonPackageArchive } from './PythonPackageArchive';

// Directory where the Lambda function's source code is located
const lambdaSourceDir = './lambda';

// Generate a zip archive of the Lambda source code and dependencies.
const lambdaArchive = new PythonPackageArchive('myLambdaPackage', {
    sourceDirectory: lambdaSourceDir,
});

// Create a new Lambda function and provide the packaged zip archive as the code.
const lambdaFunction = new aws.lambda.Function('myLambdaFunction', {
    runtime: aws.lambda.Python3d6Runtime,
    code: lambdaArchive.asset,
    handler: 'index.handler', // Assuming your handler is defined in index.py and called "handler".
    role: lambdaRole.arn, // IAM role with necessary permissions that the Lambda will assume
});

// Exports the name and ARN of the Lambda function
export const lambdaName = lambdaFunction.name;
export const lambdaARN = lambdaFunction.arn;
```

Next is the implementation of the `PythonPackageArchive` component, which packages the Python lambda code and requirements:

```typescript
import * as pulumi from '@pulumi/pulumi';
import * as path from 'path';
import * as child_process from 'child_process';
import * as pulumi_asset from '@pulumi/pulumi/asset';

export class PythonPackageArchive extends pulumi.ComponentResource {
    public readonly asset: pulumi.asset.AssetArchive;

constructor(name: string, args: { sourceDirectory: string }, opts?: pulumi.ComponentResourceOptions) {
        super('my:components:PythonPackageArchive', name, {}, opts);

const { sourceDirectory } = args;
        const requirementsPath = path.join(sourceDirectory, 'requirements.txt');

// Create an asset archive for the Lambda deployment package.
        this.asset = new pulumi.asset.AssetArchive({
            '.': new pulumi.asset.FileArchive(
                // Running the packaging script and returning the path to the created zip file.
                PythonPackageArchive.runPackagingScript(sourceDirectory, requirementsPath)
            ),
        });

// Make sure to register the component outputs.
        this.registerOutputs({
            asset: this.asset,
        });
    }

private static runPackagingScript(sourceDirectory: string, requirementsPath: string): string {
        // Check if the requirements.txt file exists and construct the output path.
        if (!fs.existsSync(requirementsPath)) {
            throw new Error(`requirements.txt not found at ${requirementsPath}`);
        }

const outputPath = `/tmp/lambda_package-${path.basename(sourceDirectory)}.zip`;

// Run the packaging script. This will install the dependencies and create a zip file.
        const result = child_process.spawnSync(
            'bash',
            ['-c', `
                set -e
                cd "${sourceDirectory}"
                pip install --target . -r requirements.txt
                zip -r "${outputPath}" .
            `],
            {
                stdio: 'inherit'
            }
        );

if (result.error || result.status !== 0) {
            throw new Error('Failed to package Lambda function');
        }

// Return the path to the packaged zip file.
        return outputPath;
    }
}
```

**Explanation:**
- The `PythonPackageArchive` class is a custom Pulumi `ComponentResource` designed to create a zip archive of Python source code, including all dependencies listed in `requirements.txt`.
- The `runPackagingScript` method checks for the existence of `requirements.txt`, performs installation of the dependencies into the Python source directory, and creates a zip archive.
- The `aws.lambda.Function` resource is instantiated with the archive from `PythonPackageArchive` as its deployment package, `code`.
- The `handler` property of the Lambda is set to the name of the Python file and function within that file which serves as the entry point for the Lambda execution.

**Note:** The Python dependency installation and packaging are performed by a child process that invokes `pip` and `zip` commands. This requires that you have Python and `pip` installed in your system where you run Pulumi. This example assumes the packaging process takes place on a UNIX-like system with common utilities like `bash` and `zip`. The actual Python function code (e.g., `index.py` and `requirements.txt`) needs to live in the specified `sourceDirectory`.

Ensure you create a suitable IAM role and attach the necessary policies for the Lambda to execute correctly, which is referenced in `lambdaRole.arn` in the example.