Comment créer une couche AWS Lambda Python ? (Exemple d'utilisation avec XGBoost)

MODIF : Comme @Marcin l'a fait remarquer, la première réponse fournie fonctionne pour les packages de moins de 262 Mo.

A. Packages Python dans la limite de taille de la couche Lambda

Vous pouvez également le faire avec AWS sam cli et Docker (voir ce lien pour installer la SAM cli), pour construire les packages à l'intérieur d'un conteneur. En gros, vous initialisez un modèle par défaut avec Python comme runtime, puis vous spécifiez les packages sous le requirements.txt dossier. Je l'ai trouvé plus facile que l'article que vous avez mentionné. Je vous laisse les étapes si vous voulez les considérer pour une utilisation future.

1. Initialiser un modèle SAM par défaut

Sous n'importe quel dossier dans lequel vous souhaitez conserver le projet, vous pouvez taper

sam init

cela suscitera une série de questions, pour une configuration rapide, nous choisirons les modèles de démarrage rapide comme suit

1 - AWS Quick Start Templates

2 - Python 3.8

Project name [sam-app]: your_project_name

1 - Hello World Example

En choisissant le Hello World Example il génère un lambda function par défaut avec un requirements.txt dossier. Maintenant, nous allons éditer avec le nom du paquet que vous voulez, dans ce cas xgboost

2. Spécifiez les packages à installer

cd your_project_name
code hello_world/requirements.txt

comme j'ai Visual Studio Code comme éditeur, cela ouvrira le fichier dessus. Maintenant, je peux spécifier le xgboost paquet

your_python_package

Voici la raison d'installer Docker. Certains packages reposaient sur C++ . Ainsi, il est recommandé de construire à l'intérieur d'un conteneur (cas sous Windows). Maintenant, déplacez-vous vers le dossier où le template.yaml fichier est localisé. Tapez ensuite

sam build -u

3. Colis zip

il y a certains fichiers que vous ne voulez pas inclure dans votre couche lambda, car nous ne voulons conserver que les bibliothèques python. Ainsi, vous pourriez supprimer les fichiers suivants

rm .aws-sam/build/HelloWorldFunction/app.py
rm .aws-sam/build/HelloWorldFunction/__init__.py
rm .aws-sam/build/HelloWorldFunction/requirements.txt

puis compressez le contenu restant du dossier.

cp -r .aws-sam/build/HelloWorldFunction/ python/
zip -r my_layer.zip python/

où nous plaçons le calque dans le python/ dossier selon le système docsOn Windows le zip la commande doit être remplacée par Compress-Archive my_layer/ my_layer.zip.

4. Chargez votre couche sur AWS

Sur AWS, allez à Lambda , puis choisissez Layers et Create Layer . Maintenant, vous pouvez télécharger votre .zip fichier comme le montre l'image ci-dessous

Notez que pour les fichiers zip de plus de 50 Mo, vous devez télécharger le .zip vers un compartiment s3 et indiquez le chemin, par exemple, https://s3:amazonaws.com//mybucket/my_layer.zip .

B. Paquets Python qui dépassent les limites de la couche Lambda

Le xgboost package à lui seul est supérieur à 300 Mo et générera l'erreur suivante

Comme @Marcin l'a gentiment souligné, l'approche précédente avec SAM cli ne fonctionnerait pas directement pour les couches Python qui dépassent la limite. Il y a un problème ouvert sur github pour spécifier une image docker personnalisée lors de l'exécution de sam build -u et une solution possible en remarquant le lambda/lambci par défaut photo.

Alors, comment pourrions-nous traverser cela?. Il existe déjà des ressources utiles que je voudrais simplement signaler.

Tout d'abord, l'article Medium que @Alex a pris comme solution qui suit ce code de dépôt.
Deuxièmement, l'approche alexeybutyrev qui fonctionne en appliquant la commande strip pour réduire la taille des bibliothèques. On peut trouver cette approche sous un dépôt github, les instructions sont fournies.

Modifier (décembre 2020)

Ce mois-ci, AWS lance la prise en charge des images de conteneurs pour AWS Lambda. Suivre l'arborescence suivante de votre projet

Project/
|-- app/
|   |-- app.py
|   |-- requirements.txt
|   |-- xgb_trained.bin
|-- Dockerfile

Vous pouvez déployer un modèle XGBoost avec l'image Docker suivante. Suivez les instructions de ce dépôt pour une explication détaillée.

# Dockerfile based on https://docs.aws.amazon.com/lambda/latest/dg/images-create.html

# Define global args
ARG FUNCTION_DIR="/function"
ARG RUNTIME_VERSION="3.6"

# Choose buster image
FROM python:${RUNTIME_VERSION}-buster as base-image

# Install aws-lambda-cpp build dependencies
RUN apt-get update && \
  apt-get install -y \
  g++ \
  make \
  cmake \
  unzip \
  libcurl4-openssl-dev \
  git


# Include global arg in this stage of the build
ARG FUNCTION_DIR
# Create function directory
RUN mkdir -p ${FUNCTION_DIR}

# Copy function code
COPY app/* ${FUNCTION_DIR}/

# Install python dependencies and runtime interface client
RUN python${RUNTIME_VERSION} -m pip install \
                   --target ${FUNCTION_DIR} \
                   --no-cache-dir \
                   awslambdaric \
                   -r ${FUNCTION_DIR}/requirements.txt

# Install xgboost from source
RUN git clone --recursive https://github.com/dmlc/xgboost
RUN cd xgboost; make -j4; cd python-package; python${RUNTIME_VERSION} setup.py install; cd;

# Multi-stage build: grab a fresh copy of the base image
FROM base-image

# Include global arg in this stage of the build
ARG FUNCTION_DIR

# Set working directory to function root directory
WORKDIR ${FUNCTION_DIR}

# Copy in the build image dependencies
COPY --from=base-image ${FUNCTION_DIR} ${FUNCTION_DIR}

ENTRYPOINT [ "/usr/local/bin/python", "-m", "awslambdaric" ]

CMD [ "app.handler" ]