CFN-CR-PythonLambdaLayer.yaml

---
AWSTemplateFormatVersion: '2010-09-09'
Description: >-
  This stack will create a Lambda Function which then backs CFN CR,
  so new Lambdas can use Layers build based on a given requirements,
  or raw python to support extra functions
Metadata:
  Author: KissT
  Project: CFN-CR-PythonLambdaLayer
  SourceCode: https://github.com/kisst/CFN-CR-PythonLambdaLayer

Resources:
  LambdaLambdaExecutionRole:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - lambda.amazonaws.com
            Action:
              - 'sts:AssumeRole'
      Path: /
      Policies:
        - PolicyName: AllowLogs
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - logs:CreateLogGroup
                  - logs:CreateLogStream
                  - logs:PutLogEvents
                Resource: 'arn:aws:logs:*:*:*'
        - PolicyName: AllowLambda
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - lambda:AddLayerVersionPermission
                  - lambda:GetLayerVersion
                  - lambda:GetLayerVersionPolicy
                  - lambda:ListLayerVersions
                  - lambda:PublishLayerVersion
                Resource: '*'

  LambdaLayerBuilderFuntion:
    Type: 'AWS::Lambda::Function'
    Properties:
      Description: 'Build a lambda layer with given requirements'
      Code:
        ZipFile: |
          from __future__ import print_function
          import subprocess
          import sys
          import os
          import zipfile
          import importlib
          import base64
          try:
              import cfnresponse
              CFN_CALL = True
          except ImportError:
              CFN_CALL = False

          PKG_DIR = "/tmp/packages/python/lib/python3.7/site-packages"
          PKG_ROOT = "/tmp/packages"

          def lambda_handler(event, context):
              request_type = event['RequestType']
              resource_properties = event['ResourceProperties']

              name = resource_properties['Name']
              region = resource_properties['Region']

              if request_type in ('Create', 'Update'):
                  pass
              else:
                  exit_gracefully("Nothing to do here", event, context)

              job_to_do = False
              try:
                  install_with_pip(resource_properties['requirements'])
                  job_to_do = True
              except KeyError:
                  pass

              try:
                  dump_text_to_file(
                      resource_properties['filename'],
                      resource_properties['filecontent'],
                      PKG_DIR
                  )
                  job_to_do = True
              except KeyError:
                  pass

              if job_to_do:
                  zipit(PKG_ROOT, "/tmp/layer")
                  layer_arn = publish_layer(name, region)
                  if CFN_CALL:
                      data = {"Arn": layer_arn}
                      physical_id = layer_arn
                      cfnresponse.send(event, context, cfnresponse.SUCCESS, data, physical_id)
              else:
                  exit_gracefully('Exit! No requirements or filename/filecontent', event, context)

          def exit_gracefully(message, event, context):
              print(message)
              if CFN_CALL:
                  cfnresponse.send(event, context, cfnresponse.SUCCESS, {}, '')
              sys.exit # pylint: disable=W0104

          def dump_text_to_file(filename, text, dirpath):
              abs_dirpath = os.path.abspath(f"{dirpath}/lambdalayer")
              try:
                  os.makedirs(abs_dirpath)
              except FileExistsError:
                  pass
              abs_initpath = os.path.abspath(os.path.join(abs_dirpath, '__init__.py'))
              with open(abs_initpath, mode='a'):
                  os.utime(abs_initpath, None)
              abs_filepath = os.path.abspath(os.path.join(abs_dirpath, filename))
              with open(abs_filepath, mode='w', encoding='utf-8') as file_var:
                  file_var.write(base64.b64decode(text).decode('utf-8'))

          def zipit(src, dst):
              zipf = zipfile.ZipFile("%s.zip" % (dst), "w", zipfile.ZIP_DEFLATED)
              abs_src = os.path.abspath(src)
              for dirname, _, files in os.walk(src):
                  for filename in files:
                      absname = os.path.abspath(os.path.join(dirname, filename))
                      arcname = absname[len(abs_src) + 1:]
                      zipf.write(absname, arcname)
              zipf.close()

          def install_with_pip(packages):
              print(" -- Installing pip packages")
              logfile = open("/tmp/pip-install.log", "wb")
              for package in packages:
                  print(" ---- Installing {}".format(package))
                  subprocess.check_call([
                      sys.executable, '-m', 'pip', 'install',
                      '--upgrade', '-t', PKG_DIR, package], stdout=logfile)

          def publish_layer(name, region):
              logfile = open("/tmp/pip-install.log", "wb")
              subprocess.check_call([
                  sys.executable, '-m', 'pip', 'install',
                  '--upgrade', '-t', '/tmp/upload', 'boto3'], stdout=logfile)

              sys.path.insert(0, '/tmp/upload')
              import botocore
              importlib.reload(botocore)
              import boto3

              client = boto3.client('lambda', region_name=region)
              response = client.publish_layer_version(
                  LayerName=name,
                  Description='Build with CFN Custom Resource',
                  Content={'ZipFile': file_get_content('/tmp/layer.zip')},
                  CompatibleRuntimes=['python3.7'])
              return response['LayerVersionArn']

          def file_get_content(filename):
              with open(filename, 'rb') as filevar:
                  return filevar.read()
      Handler: index.lambda_handler
      Runtime: python3.7
      Timeout: 900
      Role: !GetAtt LambdaLambdaExecutionRole.Arn


Outputs:
  CRLambdaLayerARN:
    Description: The ARN of the Lambda which can build the layers
    Value: !GetAtt LambdaLayerBuilderFuntion.Arn
    Export:
      Name: !Sub "cfn:lambdalayer:${AWS::Region}:arn"