SAM build - construit-il également des couches?

Réponse rapide - Non , SAM ne construit actuellement pas les couches que vous définissez dans un fichier SAM template.yaml .

Il ne construira que les fonctions que vous définissez .

Cependant (curieusement) il empaqueter (téléchargement à S3) et Deploy (configuration dans AWS, assign de sorte qu'il peut ARN être utilisé , etc.) toutes les couches que vous définissez.

Il y a une demande de fonctionnalité sur les problèmes github SAM pour implémenter la création de couches avec SAM.

Cela peut en fait être piraté dès maintenant pour que SAM crée également vos couches , en créant une fonction factice dans votre fichier de modèle SAM, ainsi qu'une entrée de couche, et en ayant le point d'entrée ContentUri de la couche vers la construction .aws-sam répertoire qui est créé pour la fonction.

Voir mon message ici à ce sujet.

Cette approche semble en fait fonctionner assez bien pour tordre SAM en ce moment pour créer vos couches pour vous.

Je ne sais pas si quelque chose a changé récemment, mais je peux le faire sans problème. Mon fichier de modèle et ma structure sont très similaires à l'OP sauf que j'ai mis tout mon code commun dans ...

/dependencies/python/lib/python3.7/site-packages/

Je n'ai pas inclus de fichier requirements.txt dans ce répertoire ... juste le fichier __init__.py et divers fichiers .py que je dois importer dans mes fonctions.

SAM trouve ensuite le code et construit la couche. Vous n'avez même pas besoin de compresser le contenu du répertoire comme certains tutoriels vous disent de le faire.

La meilleure partie est Layers: peut être placé dans la section Globals: du fichier modèle afin que le calque soit disponible pour toutes vos fonctions!

Globals:
  Function:
    Handler: main.lambda_handler
    Timeout: 10
    Runtime: python3.7
    Layers: 
        - !Ref HelperFunctions

Resources:
  HelperFunctions:
    Type: AWS::Serverless::LayerVersion
    Properties:
      LayerName: MyHelperFunctions
      Description: My Lambda Layer with Helper Functions for accessing RDS, Logging, and other utilities.
      ContentUri: dependencies/
      CompatibleRuntimes:
        - python3.6
        - python3.7
      LicenseInfo: MIT
      RetentionPolicy: Delete

Je l'ai fait fonctionner avec le script suivant. Testé avec Ubuntu 18 et CodeBuild

Il installe les exigences de la couche dans .aws-sam/build/layername/python/ . Ensuite, vous pouvez exécuter sam package et sam deploy comme d'habitude

build-layers.py :

---  # build spec for AWS CodeBuild

version: 0.2

phases:
  install:
    runtime-versions:
      python: 3.8
    commands:
      - pip install aws-sam-cli
  build:
    commands:
      - cd lambda/layers
      - python build-layers.py
      - sam package --s3-bucket foo --s3-prefix sam/lambda/layers | sam deploy --capabilities CAPABILITY_IAM -t /dev/stdin --stack-name LAYERS

template.yaml :

lambda
  layers
    pandas
      requirements.txt (content = pandas)
    sqlparse
      requirements.txt (content = sqlparse)
  template.yaml
  build-layers.py

alors appelez d'abord python build-layers.py , puis sam package puis sam deploy

mes répertoires ressemblent à ceci:

Transform: AWS::Serverless-2016-10-31

Resources:
  pandas:
    Type: AWS::Serverless::LayerVersion
    Properties:
      LayerName: pandas
      ContentUri: pandas
      CompatibleRuntimes:
        - python3.6
        - python3.7
        - python3.8
  sqlparse:
    Type: AWS::Serverless::LayerVersion
    Properties:
      LayerName: sqlparse
      ContentUri: sqlparse
      CompatibleRuntimes:
        - python3.6
        - python3.7
        - python3.8

buildspec.yml :

import yaml
import subprocess
import sys
import shutil

SAM_BUILD_PATH = ".aws-sam/build"

with open("template.yaml", "r") as f:
    template = yaml.safe_load(f)

for key, resource in template["Resources"].items():
    if resource["Type"] not in ["AWS::Serverless::LayerVersion", "AWS::Lambda::LayerVersion"]:
        continue
    properties = resource["Properties"]
    content_uri = properties["ContentUri"]
    layer_name = properties["LayerName"]
    requirements_path = f"{content_uri}/requirements.txt"

    subprocess.check_call([sys.executable, "-m", "pip", "install", "-r", requirements_path, "-t", f"{SAM_BUILD_PATH}/{layer_name}/python"])

shutil.copyfile("template.yaml", f"{SAM_BUILD_PATH}/template.yaml")

Depuis la version v0.50.0 de SAM Cli , il construit des couches dans le cadre de sam build .

Le document de conception pourrait être un bon point de départ pour comprendre son fonctionnement.

En gros, vous devez définir un BuildMethod personnalisé avec le runtime cible de votre lambda:

MyLayer:
Type: AWS::Serverless::LayerVersion
Properties:
  ContentUri: my_layer
  CompatibleRuntimes:
    - python3.8
Metadata:
  BuildMethod: python3.8 (or nodejs8.10 etc..)

Attention : pour un langage compilé comme Java, il a un problème où il essaie de construire des couches avant les fonctions. On s'attend à ce qu'il soit corrigé dans la prochaine version ( PR ouvert déjà ).

L'équipe AWS a dû rendre les choses plus faciles, par rapport à ces réponses plus anciennes. À partir de la documentation actuelle, tout ce que vous faites est de répertorier une couche en tant que propriété dans votre modèle (novembre 2020):

ServerlessFunction:
  Type: AWS::Serverless::Function
  Properties:
    CodeUri: .
    Handler: my_handler
    Runtime: Python3.7
    Layers:
        - arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
        - arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1

https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-layers.html