When working with AWS Lambda, one of the common challenges developers face is managing large Python dependencies. Libraries like Pandas, Shapely, and GeoPandas, essential for tasks like geospatial analysis, often exceed Lambda's 250 MB unzipped layer limit. A practical solution? Store your dependencies on an EFS (Elastic File System) and mount it to your Lambda function.

In this post, we’ll walk through the process of setting this up, including the prerequisites, key benefits, and step-by-step implementation.

Prerequisites

This post is intended for users with advanced AWS experience. It assumes a solid understanding of AWS services such as Lambda, EFS, VPC, and security groups, as well as familiarity with managing infrastructure and deploying scalable solutions in the cloud.
Before we dive into the setup, ensure you have the following:

1. AWS Lambda Function: A deployed Lambda function you’ll configure with EFS.
2. EFS File System: An Elastic File System created in the same AWS region.
3. EFS access point: An EFS access point created in the same AWS region, with the root directory path to /data , Ensure you set the POSIX permissions and directory creation permissions appropriately as follows, 1101 and 1001, Secondary Group ID 1002 and Permissions 0755.
4. VPC and Networking: Ensure the Lambda function is in the same VPC as the EFS, with subnets and security groups properly configured.
5. IAM Permissions: Your Lambda function needs permissions to access the EFS. Attach the appropriate policy (e.g., elasticfilesystem:ClientMount, elasticfilesystem:ClientWrite).

Handler Code for Installing Packages

The handler installs Python dependencies directly on an Amazon EFS storage mounted to an AWS Lambda function. This approach bypasses the size limitations of Lambda layers, making it suitable for heavy dependencies like pandas, geopandas, and shapely, often required for geospatial data processing. It ensures the required libraries are available in the /mnt/data directory for Lambda to use during execution:

import os
import subprocess

PACKAGE_DIR = "/mnt/data/lib/{}/site-packages/"

def get_python_version_tag():
    """Generates a Python version tag like 'python3.11'."""
    return f"python{os.sys.version_info.major}.{os.sys.version_info.minor}"

def install_package(package):
    """Installs a Python package into the EFS-mounted directory."""
    target_dir = PACKAGE_DIR.format(get_python_version_tag())
    os.makedirs(target_dir, exist_ok=True)
    try:
        subprocess.run(
            [
                "pip",
                "install",
                package,
                "--target",
                target_dir,
                "--upgrade",
                "--no-cache-dir",
            ],
            check=True,
        )
        print(f"Package {package} installed successfully!")
    except subprocess.CalledProcessError as e:
        print(f"Failed to install package {package}: {e}")

def handler(event, context):
    """AWS Lambda Handler for installing packages."""
    try:
        # List of packages to install from the event input
        packages = event.get("packages", [])
        for package in packages:
            install_package(package)
        #optional for see packages installed
        #os.system(f"ls -la {PACKAGE_DIR.format(get_python_version_tag())}")
        return {"statusCode": 200, "body": "Packages installed successfully!"}
    except Exception as e:
        print(f"Error: {e}")
        return {"statusCode": 500, "body": f"An error occurred: {e}"}

Steps to Test

When invoking your Lambda function, pass the following JSON payload:

{
    "packages": ["requests", "pandas"]
}

Verify Package Installation

Navigate to your EFS mount point (e.g., /mnt/data/lib/) using an SSH session or AWS CLI.
Check the installed packages under the site-packages/ directory.
or simple use a for see a packages installed

os.system(f"ls -la {PACKAGE_DIR.format(get_python_version_tag())}")

Finally Use the Installed Dependencies in Lambda

Update your Lambda function’s handler to include the dependencies installed on EFS, the key here is mount the path of dependencies in efs to a PYTHONPATH of lambda handler:

Important Note

All Lambda functions that wish to use the installed dependencies must attach the EFS to the Lambda. Without this attachment, the Lambda will not be able to access the required dependencies stored on EFS.

import sys
sys.path.append("/mnt/data/lib/python3.11/site-packages/")  # Adjust Python version as needed
# Dependencies are now available!!!
import pandas as pd  

def lambda_handler(event, context):
    return {"message": "Dependencies loaded successfully!"}

Key Benefits

While installing Python dependencies directly in EFS is not a common practice, it offers certain advantages in scenarios where Lambda's default limitations, such as the 250 MB unzipped layer size, become restrictive. This approach is particularly beneficial for applications requiring geospatial computations with heavy libraries like Pandas, Shapely, and GeoPandas, which often exceed the layer size limit.

Benefits of Using EFS for Dependencies:

• Bypass Lambda Layer Size Limits: Install and use libraries without worrying about packaging constraints.
• Enable Large-Scale Geospatial Processing: Handle complex spatial computations in a serverless environment.
• Streamline Dependency Management: Add or update libraries dynamically without redeploying your Lambda function.

This solution is ideal for advanced data processing tasks, such as geospatial analysis,also allows for the easy scaling of storage as required, while maintaining the flexibility of a serverless architecture.