Metadata-Version: 2.1
Name: awslambdaric
Version: 1.0.0
Summary: AWS Lambda Runtime Interface Client for Python
Home-page:  https://github.com/aws/aws-lambda-python-runtime-interface-client
Author: Amazon Web Services
License: UNKNOWN
Description: ## AWS Lambda Python Runtime Interface Client
        
        We have open-sourced a set of software packages, Runtime Interface Clients (RIC), that implement the Lambda
         [Runtime API](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html), allowing you to seamlessly extend your preferred
          base images to be Lambda compatible.
        The Lambda Runtime Interface Client is a lightweight interface that allows your runtime to receive requests from and send requests to the Lambda service.
        
        The Lambda Python Runtime Interface Client is vended through [pip](https://pypi.org/project/awslambdaric). 
        You can include this package in your preferred base image to make that base image Lambda compatible.
        
        ## Requirements
        The Python Runtime Interface Client package currently supports Python versions:
         - 3.6.x up to and including 3.9.x
        
        ## Usage
        
        ### Creating a Docker Image for Lambda with the Runtime Interface Client
        First step is to choose the base image to be used. The supported Linux OS distributions are:
        
         - Amazon Linux 2
         - Alpine
         - CentOS
         - Debian
         - Ubuntu
        
        
        Then, the Runtime Interface Client needs to be installed. We provide both wheel and source distribution.
        If the OS/pip version used does not support [manylinux2014](https://www.python.org/dev/peps/pep-0599/) wheels, you will also need to install the required build dependencies.
        Also, your Lambda function code needs to be copied into the image.
        
        ```dockerfile
        # Include global arg in this stage of the build
        ARG FUNCTION_DIR
        
        # Install aws-lambda-cpp build dependencies
        RUN apt-get update && \
          apt-get install -y \
          g++ \
          make \
          cmake \
          unzip \
          libcurl4-openssl-dev
        
        
        # Create function directory
        RUN mkdir -p ${FUNCTION_DIR}
        
        # Copy handler function
        COPY app/* ${FUNCTION_DIR}
        
        # Install the function's dependencies
        RUN pip install \
            --target ${FUNCTION_DIR} \
                awslambdaric
        ```
        
        The next step would be to set the `ENTRYPOINT` property of the Docker image to invoke the Runtime Interface Client and then set the `CMD` argument to specify the desired handler.
        
        Example Dockerfile (to keep the image light we use a multi-stage build):
        ```dockerfile
        # Define custom function directory
        ARG FUNCTION_DIR="/function"
        
        FROM python:buster as build-image
        
        # Include global arg in this stage of the build
        ARG FUNCTION_DIR
        
        # Install aws-lambda-cpp build dependencies
        RUN apt-get update && \
          apt-get install -y \
          g++ \
          make \
          cmake \
          unzip \
          libcurl4-openssl-dev
        
        
        # Create function directory
        RUN mkdir -p ${FUNCTION_DIR}
        
        # Copy handler function
        COPY app/* ${FUNCTION_DIR}
        
        # Install the function's dependencies
        RUN pip install \
            --target ${FUNCTION_DIR} \
                awslambdaric
        
        
        FROM python:buster
        
        # 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 built dependencies
        COPY --from=build-image ${FUNCTION_DIR} ${FUNCTION_DIR}
        
        ENTRYPOINT [ "/usr/local/bin/python", "-m", "awslambdaric" ]
        CMD [ "app.handler" ]
        ```
        
        Example Python handler `app.py`:
        ```python
        def handler(event, context):
            return "Hello World!"
        ```
        
        ### Local Testing
        
        To make it easy to locally test Lambda functions packaged as container images we open-sourced a lightweight web-server, Lambda Runtime Interface Emulator (RIE), which allows your function packaged as a container image to accept HTTP requests. You can install the [AWS Lambda Runtime Interface Emulator](https://github.com/aws/aws-lambda-runtime-interface-emulator) on your local machine to test your function. Then when you run the image function, you set the entrypoint to be the emulator. 
        
        *To install the emulator and test your Lambda function*
        
        1) From your project directory, run the following command to download the RIE from GitHub and install it on your local machine. 
        
        ```shell script
        mkdir -p ~/.aws-lambda-rie && \
            curl -Lo ~/.aws-lambda-rie/aws-lambda-rie https://github.com/aws/aws-lambda-runtime-interface-emulator/releases/latest/download/aws-lambda-rie && \
            chmod +x ~/.aws-lambda-rie/aws-lambda-rie
        ```
        2) Run your Lambda image function using the docker run command. 
        
        ```shell script
        docker run -d -v ~/.aws-lambda-rie:/aws-lambda -p 9000:8080 \
            --entrypoint /aws-lambda/aws-lambda-rie \
            myfunction:latest \
                /usr/local/bin/python -m awslambdaric app.handler
        ```
        
        This runs the image as a container and starts up an endpoint locally at `http://localhost:9000/2015-03-31/functions/function/invocations`. 
        
        3) Post an event to the following endpoint using a curl command: 
        
        ```shell script
        curl -XPOST "http://localhost:9000/2015-03-31/functions/function/invocations" -d '{}'.
        ```
        
        This command invokes the function running in the container image and returns a response.
        
        *Alternately, you can also include RIE as a part of your base image. See the AWS documentation on how to [Build RIE into your base image](https://docs.aws.amazon.com/lambda/latest/dg/images-test.html#images-test-alternative).*
        
        
        ## Development
        
        ### Building the package
        Clone this repository and run:
        
        ```shell script
        make init
        make build
        ```
        
        ### Running tests
        
        Make sure the project is built:
        ```shell script
        make init build
        ```
        Then,
        * to run unit tests: `make test`
        * to run integration tests: `make test-integ`
        * to run smoke tests: `make test-smoke`
        
        ## Security
        
        If you discover a potential security issue in this project we ask that you notify AWS/Amazon Security via our [vulnerability reporting page](http://aws.amazon.com/security/vulnerability-reporting/). Please do **not** create a public github issue.
        
        ## License
        
        This project is licensed under the Apache-2.0 License.
        
Platform: UNKNOWN
Classifier: Intended Audience :: Developers
Classifier: Natural Language :: English
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.6
Description-Content-Type: text/markdown
