Installation des dépendances Python sur AWS Lambda à l'aide d'EFS

Lorsqu'ils travaillent avec AWS Lambda, l'un des défis courants auxquels les développeurs sont confrontés est la gestion de grandes dépendances Python. Les bibliothèques comme Pandas, Shapely et GeoPandas, essentielles pour des tâches telles que l'analyse géospatiale, dépassent souvent la limite de 250 Mo de couche décompressée de Lambda. Une solution pratique ? Stockez vos dépendances sur un EFS (Elastic File System) et montez-le sur votre fonction Lambda.

Dans cet article, nous expliquerons le processus de configuration, y compris les conditions préalables, les principaux avantages et la mise en œuvre étape par étape.

Prérequis

Cet article est destiné aux utilisateurs ayant une expérience AWS avancée. Cela suppose une solide compréhension des services AWS tels que Lambda, EFS, VPC et les groupes de sécurité, ainsi qu'une familiarité avec la gestion de l'infrastructure et le déploiement de solutions évolutives dans le cloud.
Avant de plonger dans la configuration, assurez-vous d'avoir les éléments suivants :

1. Fonction AWS Lambda : une fonction Lambda déployée que vous configurerez avec EFS.
2. EFS File System : un système de fichiers élastique créé dans la même région AWS.
3. Point d'accès EFS : un point d'accès EFS créé dans la même région AWS, avec le chemin du répertoire racine vers /data. Assurez-vous de définir les autorisations POSIX et les autorisations de création de répertoire de manière appropriée comme suit, 1101 et 1001, groupe secondaire. ID 1002 et autorisations 0755.
4. VPC et mise en réseau : assurez-vous que la fonction Lambda se trouve dans le même VPC que l'EFS, avec des sous-réseaux et des groupes de sécurité correctement configurés.
5. Autorisations IAM : votre fonction Lambda a besoin d'autorisations pour accéder à l'EFS. Attachez la stratégie appropriée (par exemple, elasticfilesystem:ClientMount, elasticfilesystem:ClientWrite).

Code du gestionnaire pour l'installation des packages

Le gestionnaire installe les dépendances Python directement sur un stockage Amazon EFS monté sur une fonction AWS Lambda. Cette approche contourne les limitations de taille des couches Lambda, ce qui la rend adaptée aux dépendances lourdes telles que les pandas, les géopandas et Shapely, souvent nécessaires au traitement des données géospatiales. Il garantit que les bibliothèques requises sont disponibles dans le répertoire /mnt/data pour que Lambda puisse les utiliser pendant l'exécution :

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}"}

Étapes pour tester

Lors de l'appel de votre fonction Lambda, transmettez la charge utile JSON suivante :

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

Vérifier l'installation du package

Accédez à votre point de montage EFS (par exemple, /mnt/data/lib/) à l'aide d'une session SSH ou d'AWS CLI.
Vérifiez les packages installés dans le répertoire site-packages/.
ou utilisez simplement un pour voir un package installé

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}"}

Enfin utiliser les dépendances installées dans Lambda

Mettez à jour le gestionnaire de votre fonction Lambda pour inclure les dépendances installées sur EFS, la clé ici est de monter le chemin des dépendances dans efs sur un PYTHONPATH du gestionnaire lambda :

Remarque importante

Toutes les fonctions Lambda qui souhaitent utiliser les dépendances installées doivent attacher l'EFS au Lambda. Sans cette pièce jointe, Lambda ne pourra pas accéder aux dépendances requises stockées sur EFS.

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

Avantages clés

Bien que l'installation de dépendances Python directement dans EFS ne soit pas une pratique courante, elle offre certains avantages dans les scénarios où les limitations par défaut de Lambda, telles que la taille de la couche décompressée de 250 Mo, deviennent restrictives. Cette approche est particulièrement bénéfique pour les applications nécessitant des calculs géospatiaux avec des bibliothèques lourdes comme Pandas, Shapely et GeoPandas, qui dépassent souvent la limite de taille de couche.

Avantages de l'utilisation d'EFS pour les dépendances :

• Contourner les limites de taille des couches Lambda : installez et utilisez des bibliothèques sans vous soucier des contraintes d'empaquetage.
• Activer le traitement géospatial à grande échelle : gérez des calculs spatiaux complexes dans un environnement sans serveur.
• Rationalisez la gestion des dépendances  : ajoutez ou mettez à jour des bibliothèques de manière dynamique sans redéployer votre fonction Lambda.

Cette solution est idéale pour les tâches avancées de traitement de données, telles que l'analyse géospatiale, permet également une mise à l'échelle facile du stockage selon les besoins, tout en conservant la flexibilité d'une architecture sans serveur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!