%global _empty_manifest_terminate_build 0 Name: python-zappa Version: 0.56.1 Release: 1 Summary: Server-less Python Web Services for AWS Lambda and API Gateway License: MIT License URL: https://github.com/zappa/Zappa Source0: https://mirrors.nju.edu.cn/pypi/web/packages/cd/01/cbf06398160db1979c0497e113e524430ff1291987bc1dd13038cdb29214/zappa-0.56.1.tar.gz BuildArch: noarch Requires: python3-argcomplete Requires: python3-boto3 Requires: python3-durationpy Requires: python3-hjson Requires: python3-jmespath Requires: python3-kappa Requires: python3-pip Requires: python3-placebo Requires: python3-dateutil Requires: python3-slugify Requires: python3-pyyaml Requires: python3-requests Requires: python3-toml Requires: python3-tqdm Requires: python3-troposphere Requires: python3-werkzeug Requires: python3-wheel %description dev: app_function: your_module.your_app s3_bucket: your-code-bucket events: - function: your_module.your_function event_source: arn: arn:aws:s3:::your-event-bucket events: - s3:ObjectCreated:* ``` You can also supply a custom settings file at any time with the `-s` argument, ex: ``` $ zappa deploy dev -s my-custom-settings.yml ``` Similarly, you can supply a `zappa_settings.toml` file: ```toml [dev] app_function = "your_module.your_app" s3_bucket = "your-code-bucket" ``` ## Advanced Usage ### Keeping The Server Warm Zappa will automatically set up a regularly occurring execution of your application in order to keep the Lambda function warm. This can be disabled via the `keep_warm` setting. #### Serving Static Files / Binary Uploads Zappa is now able to serve and receive binary files, as detected by their MIME-type. However, generally Zappa is designed for running your application code, not for serving static web assets. If you plan on serving custom static assets in your web application (CSS/JavaScript/images/etc.,), you'll likely want to use a combination of AWS S3 and AWS CloudFront. Your web application framework will likely be able to handle this for you automatically. For Flask, there is [Flask-S3](https://github.com/e-dard/flask-s3), and for Django, there is [Django-Storages](https://django-storages.readthedocs.io/en/latest/). Similarly, you may want to design your application so that static binary uploads go [directly to S3](http://docs.aws.amazon.com/AWSJavaScriptSDK/guide/browser-examples.html#Uploading_a_local_file_using_the_File_API), which then triggers an event response defined in your `events` setting! That's thinking serverlessly! ### Enabling CORS The simplest way to enable CORS (Cross-Origin Resource Sharing) for your Zappa application is to set `cors` to `true` in your Zappa settings file and update, which is the equivalent of pushing the "Enable CORS" button in the AWS API Gateway console. This is disabled by default, but you may wish to enable it for APIs which are accessed from other domains, etc. You can also simply handle CORS directly in your application. Your web framework will probably have an extension to do this, such as [django-cors-headers](https://github.com/ottoyiu/django-cors-headers) or [Flask-CORS](https://github.com/corydolphin/flask-cors). Using these will make your code more portable. ### Large Projects AWS currently limits Lambda zip sizes to 50 megabytes. If your project is larger than that, set `slim_handler: true` in your `zappa_settings.json`. In this case, your fat application package will be replaced with a small handler-only package. The handler file then pulls the rest of the large project down from S3 at run time! The initial load of the large project may add to startup overhead, but the difference should be minimal on a warm lambda function. Note that this will also eat into the storage space of your application function. Note that AWS currently [limits](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) the `/tmp` directory storage to 512 MB, so your project must still be smaller than that. ### Enabling Bash Completion Bash completion can be enabled by adding the following to your .bashrc: ```bash eval "$(register-python-argcomplete zappa)" ``` `register-python-argcomplete` is provided by the argcomplete Python package. If this package was installed in a virtualenv then the command must be run there. Alternatively you can execute: activate-global-python-argcomplete --dest=- > file The file's contents should then be sourced in e.g. ~/.bashrc. ### Enabling Secure Endpoints on API Gateway #### API Key You can use the `api_key_required` setting to generate an API key to all the routes of your API Gateway. The process is as follows: 1. Deploy/redeploy (update won't work) and write down the *id* for the key that has been created 2. Go to AWS console > Amazon API Gateway and * select "API Keys" and find the key *value* (for example `key_value`) * select "Usage Plans", create a new usage plan and link the API Key and the API that Zappa has created for you 3. Send a request where you pass the key value as a header called `x-api-key` to access the restricted endpoints (for example with curl: `curl --header "x-api-key: key_value"`). Note that without the x-api-key header, you will receive a 403. #### IAM Policy You can enable IAM-based (v4 signing) authorization on an API by setting the `iam_authorization` setting to `true`. Your API will then require signed requests and access can be controlled via [IAM policy](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-iam-policy-examples.html). Unsigned requests will receive a 403 response, as will requesters who are not authorized to access the API. Enabling this will override the Authorizer configuration (see below). #### API Gateway Lambda Authorizers If you deploy an API endpoint with Zappa, you can take advantage of [API Gateway Lambda Authorizers](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) to implement a token-based authentication - all you need to do is to provide a function to create the required output, Zappa takes care of the rest. A good start for the function is the [AWS Labs blueprint example](https://github.com/awslabs/aws-apigateway-lambda-authorizer-blueprints/blob/master/blueprints/python/api-gateway-authorizer-python.py). If you are wondering for what you would use an Authorizer, here are some potential use cases: 1. Call out to OAuth provider 2. Decode a JWT token inline 3. Lookup in a self-managed DB (for example DynamoDB) Zappa can be configured to call a function inside your code to do the authorization, or to call some other existing lambda function (which lets you share the authorizer between multiple lambdas). You control the behavior by specifying either the `arn` or `function_name` values in the `authorizer` settings block. For example, to get the Cognito identity, add this to a `zappa_settings.yaml`: ```yaml context_header_mappings: user_id: authorizer.user_id ``` Which can now be accessed in Flask like this: ```python from flask import request @route('/hello') def hello_world: print(request.headers.get('user_id')) ``` #### Cognito User Pool Authorizer You can also use AWS Cognito User Pool Authorizer by adding: ```javascript { "authorizer": { "type": "COGNITO_USER_POOLS", "provider_arns": [ "arn:aws:cognito-idp:{region}:{account_id}:userpool/{user_pool_id}" ] } } ``` #### API Gateway Resource Policy You can also use API Gateway Resource Policies. Example of IP Whitelisting: ```javascript { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": "*", "Action": "execute-api:Invoke", "Resource": "execute-api:/*", "Condition": { "IpAddress": { "aws:SourceIp": [ "1.2.3.4/32" ] } } } ] } ``` ### Setting Environment Variables #### Local Environment Variables If you want to set local environment variables for a deployment stage, you can simply set them in your `zappa_settings.json`: ```javascript { "dev": { "environment_variables": { "your_key": "your_value" } }, } ``` You can then access these inside your application with: ```python import os your_value = os.environ.get('your_key') ``` If your project needs to be aware of the type of environment you're deployed to, you'll also be able to get `SERVERTYPE` (AWS Lambda), `FRAMEWORK` (Zappa), `PROJECT` (your project name) and `STAGE` (_dev_, _production_, etc.) variables at any time. #### Remote AWS Environment Variables If you want to use native AWS Lambda environment variables you can use the `aws_environment_variables` configuration setting. These are useful as you can easily change them via the AWS Lambda console or cli at runtime. They are also useful for storing sensitive credentials and to take advantage of KMS encryption of environment variables. During development, you can add your Zappa defined variables to your locally running app by, for example, using the below (for Django, to manage.py). ```python if 'SERVERTYPE' in os.environ and os.environ['SERVERTYPE'] == 'AWS Lambda': import json import os json_data = open('zappa_settings.json') env_vars = json.load(json_data)['dev']['environment_variables'] for key, val in env_vars.items(): os.environ[key] = val ``` #### Remote Environment Variables Any environment variables that you have set outside of Zappa (via AWS Lambda console or cli) will remain as they are when running `update`, unless they are also in `aws_environment_variables`, in which case the remote value will be overwritten by the one in the settings file. If you are using KMS-encrypted AWS environment variables, you can set your KMS Key ARN in the `aws_kms_key_arn` setting. Make sure that the values you set are encrypted in such case. _Note: if you rely on these as well as `environment_variables`, and you have the same key names, then those in `environment_variables` will take precedence as they are injected in the lambda handler._ #### Remote Environment Variables (via an S3 file) _S3 remote environment variables were added to Zappa before AWS introduced native environment variables for Lambda (via the console and cli). Before going down this route check if above make more sense for your usecase._ If you want to use remote environment variables to configure your application (which is especially useful for things like sensitive credentials), you can create a file and place it in an S3 bucket to which your Zappa application has access. To do this, add the `remote_env` key to zappa_settings pointing to a file containing a flat JSON object, so that each key-value pair on the object will be set as an environment variable and value whenever a new lambda instance spins up. For example, to ensure your application has access to the database credentials without storing them in your version control, you can add a file to S3 with the connection string and load it into the lambda environment using the `remote_env` configuration setting. super-secret-config.json (uploaded to my-config-bucket): ```javascript { "DB_CONNECTION_STRING": "super-secret:database" } ``` zappa_settings.json: ```javascript { "dev": { "remote_env": "s3://my-config-bucket/super-secret-config.json", }, } ``` Now in your application you can use: ```python import os db_string = os.environ.get('DB_CONNECTION_STRING') ``` ### API Gateway Context Variables If you want to map an API Gateway context variable (http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html) to an HTTP header you can set up the mapping in `zappa_settings.json`: ```javascript { "dev": { "context_header_mappings": { "HTTP_header_name": "API_Gateway_context_variable" } }, } ``` For example, if you want to expose the $context.identity.cognitoIdentityId variable as the HTTP header CognitoIdentityId, and $context.stage as APIStage, you would have: ```javascript { "dev": { "context_header_mappings": { "CognitoIdentityId": "identity.cognitoIdentityId", "APIStage": "stage" } }, } ``` ### Catching Unhandled Exceptions By default, if an _unhandled_ exception happens in your code, Zappa will just print the stacktrace into a CloudWatch log. If you wish to use an external reporting tool to take note of those exceptions, you can use the `exception_handler` configuration option. zappa_settings.json: ```javascript { "dev": { "exception_handler": "your_module.unhandled_exceptions", }, } ``` The function has to accept three arguments: exception, event, and context: your_module.py ```python def unhandled_exceptions(e, event, context): send_to_raygun(e, event) # gather data you need and send return True # Prevent invocation retry ``` You may still need a similar exception handler inside your application, this is just a way to catch exception which happen at the Zappa/WSGI layer (typically event-based invocations, misconfigured settings, bad Lambda packages, and permissions issues). By default, AWS Lambda will attempt to retry an event based (non-API Gateway, e.g. CloudWatch) invocation if an exception has been thrown. However, you can prevent this by returning True, as in example above, so Zappa that will not re-raise the uncaught exception, thus preventing AWS Lambda from retrying the current invocation. ### Using Custom AWS IAM Roles and Policies #### Custom AWS IAM Roles and Policies for Deployment You can specify which _local_ profile to use for deploying your Zappa application by defining the `profile_name` setting, which will correspond to a profile in your AWS credentials file. #### Custom AWS IAM Roles and Policies for Execution The default IAM policy created by Zappa for executing the Lambda is very permissive. It grants access to all actions for all resources for types CloudWatch, S3, Kinesis, SNS, SQS, DynamoDB, and Route53; lambda:InvokeFunction for all Lambda resources; Put to all X-Ray resources; and all Network Interface operations to all EC2 resources. While this allows most Lambdas to work correctly with no extra permissions, it is generally not an acceptable set of permissions for most continuous integration pipelines or production deployments. Instead, you will probably want to manually manage your IAM policies. To manually define the policy of your Lambda execution role, you must set *manage_roles* to false and define either the *role_name* or *role_arn* in your Zappa settings file. ```javascript { "dev": { "manage_roles": false, // Disable Zappa client managing roles. "role_name": "MyLambdaRole", // Name of your Zappa execution role. Optional, default: --ZappaExecutionRole. "role_arn": "arn:aws:iam::12345:role/app-ZappaLambdaExecutionRole", // ARN of your Zappa execution role. Optional. }, } ``` Ongoing discussion about the minimum policy requirements necessary for a Zappa deployment [can be found here](https://github.com/Miserlou/Zappa/issues/244). A more robust solution to managing these entitlements will likely be implemented soon. To add permissions to the default Zappa execution policy, use the `extra_permissions` setting: ```javascript { "dev": { "extra_permissions": [{ // Attach any extra permissions to this policy. "Effect": "Allow", "Action": ["rekognition:*"], // AWS Service ARN "Resource": "*" }] }, } ``` ### AWS X-Ray Zappa can enable [AWS X-Ray](https://aws.amazon.com/xray/) support on your function with a configuration setting: ```javascript { "dev": { "xray_tracing": true }, } ``` This will enable it on the Lambda function and allow you to instrument your code with X-Ray. For example, with Flask: ```python from aws_xray_sdk.core import xray_recorder app = Flask(__name__) xray_recorder.configure(service='my_app_name') @route('/hello') @xray_recorder.capture('hello') def hello_world: return 'Hello' ``` You may use the capture decorator to create subsegments around functions, or `xray_recorder.begin_subsegment('subsegment_name')` and `xray_recorder.end_subsegment()` within a function. The official [X-Ray documentation for Python](http://docs.aws.amazon.com/xray-sdk-for-python/latest/reference/) has more information on how to use this with your code. Note that you may create subsegments in your code but an exception will be raised if you try to create a segment, as it is [created by the lambda worker](https://github.com/aws/aws-xray-sdk-python/issues/2). This also means that if you use Flask you must not use the [XRayMiddleware the documentation suggests](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python-middleware.html). ### Globally Available Server-less Architectures

Global Zappa Slides

Click to see slides from ServerlessConf London!

During the `init` process, you will be given the option to deploy your application "globally." This will allow you to deploy your application to all available AWS regions simultaneously in order to provide a consistent global speed, increased redundancy, data isolation, and legal compliance. You can also choose to deploy only to "primary" locations, the AWS regions with `-1` in their names. To learn more about these capabilities, see [these slides](https://htmlpreview.github.io/?https://github.com/Miserlou/Talks/blob/master/serverless-london/global.html#0) from ServerlessConf London. ### Raising AWS Service Limits Out of the box, AWS sets a limit of [1000 concurrent executions](http://docs.aws.amazon.com/lambda/latest/dg/limits.html) for your functions. If you start to breach these limits, you may start to see errors like `ClientError: An error occurred (LimitExceededException) when calling the PutTargets.."` or something similar. To avoid this, you can file a [service ticket](https://console.aws.amazon.com/support/home#/) with Amazon to raise your limits up to the many tens of thousands of concurrent executions which you may need. This is a fairly common practice with Amazon, designed to prevent you from accidentally creating extremely expensive bug reports. So, before raising your service limits, make sure that you don't have any rogue scripts which could accidentally create tens of thousands of parallel executions that you don't want to pay for. ### Dead Letter Queues If you want to utilise [AWS Lambda's Dead Letter Queue feature](http://docs.aws.amazon.com/lambda/latest/dg/dlq.html) simply add the key `dead_letter_arn`, with the value being the complete ARN to the corresponding SNS topic or SQS queue in your `zappa_settings.json`. You must have already created the corresponding SNS/SQS topic/queue, and the Lambda function execution role must have been provisioned with read/publish/sendMessage access to the DLQ resource. ### Unique Package ID For monitoring of different deployments, a unique UUID for each package is available in `package_info.json` in the root directory of your application's package. You can use this information or a hash of this file for such things as tracking errors across different deployments, monitoring status of deployments and other such things on services such as Sentry and New Relic. The package will contain: ```json { "build_platform": "darwin", "build_user": "frank", "build_time": "1509732511", "uuid": "9c2df9e6-30f4-4c0a-ac4d-4ecb51831a74" } ``` ### Application Load Balancer Event Source Zappa can be used to handle events triggered by Application Load Balancers (ALB). This can be useful in a few circumstances: - Since API Gateway has a hard limit of 30 seconds before timing out, you can use an ALB for longer running requests. - API Gateway is billed per-request; therefore, costs can become excessive with high throughput services. ALBs pricing model makes much more sense financially if you're expecting a lot of traffic to your Lambda. - ALBs can be placed within a VPC, which may make more sense for private endpoints than using API Gateway's private model (using AWS PrivateLink). Like API Gateway, Zappa can automatically provision ALB resources for you. You'll need to add the following to your `zappa_settings`: ``` "alb_enabled": true, "alb_vpc_config": { "CertificateArn": "arn:aws:acm:us-east-1:[your-account-id]:certificate/[certificate-id]", "SubnetIds": [ // Here, you'll want to provide a list of subnets for your ALB, eg. 'subnet-02a58266' ], "SecurityGroupIds": [ // And here, a list of security group IDs, eg. 'sg-fbacb791' ] } ``` More information on using ALB as an event source for Lambda can be found [here](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/lambda-functions.html). *An important note*: right now, Zappa will provision ONE lambda to ONE load balancer, which means using `base_path` along with ALB configuration is currently unsupported. ### Endpoint Configuration API Gateway can be configured to be only accessible in a VPC. To enable this; [configure your VPC to support](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html) then set the `endpoint_configuration` to `PRIVATE` and set up Resource Policy on the API Gateway. A note about this; if you're using a private endpoint, Zappa won't be able to tell if the API is returning a successful status code upon deploy or update, so you'll have to check it manually to ensure your setup is working properly. For full list of options for endpoint configuration refer to [API Gateway EndpointConfiguration documentation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-restapi-endpointconfiguration.html) #### Example Private API Gateway configuration zappa_settings.json: ```json { "dev": { "endpoint_configuration": ["PRIVATE"], "apigateway_policy": "apigateway_resource_policy.json", }, } ``` apigateway_resource_policy.json: ```json { "Version": "2012-10-17", "Statement": [ { "Effect": "Deny", "Principal": "*", "Action": "execute-api:Invoke", "Resource": "execute-api:/*", "Condition": { "StringNotEquals": { "aws:sourceVpc": "{{vpcID}}" // UPDATE ME } } }, { "Effect": "Allow", "Principal": "*", "Action": "execute-api:Invoke", "Resource": "execute-api:/*" } ] } ``` ### Cold Starts (Experimental) Lambda may provide additional resources than provisioned during cold start initialization. Set `INSTANTIATE_LAMBDA_HANDLER_ON_IMPORT=True` to instantiate the lambda handler on import. This is an experimental feature - if startup time is critical, look into using Provisioned Concurrency. ## Zappa Guides * [Django-Zappa tutorial (screencast)](https://www.youtube.com/watch?v=plUrbPN0xc8&feature=youtu.be). * [Using Django-Zappa, Part 1](https://serverlesscode.com/post/zappa-wsgi-for-python/). * [Using Django-Zappa, Part 2: VPCs](https://serverlesscode.com/post/zappa-wsgi-for-python-pt-2/). * [Building Serverless Microservices with Zappa and Flask](https://gun.io/blog/serverless-microservices-with-zappa-and-flask/) * [Zappa で Hello World するまで (Japanese)](http://qiita.com/satoshi_iwashita/items/505492193317819772c7) * [How to Deploy Zappa with CloudFront, RDS and VPC](https://jinwright.net/how-deploy-serverless-wsgi-app-using-zappa/) * [Secure 'Serverless' File Uploads with AWS Lambda, S3, and Zappa](http://blog.stratospark.com/secure-serverless-file-uploads-with-aws-lambda-s3-zappa.html) * [Deploy a Serverless WSGI App using Zappa, CloudFront, RDS, and VPC](https://docs.google.com/presentation/d/1aYeOMgQl4V_fFgT5VNoycdXtob1v6xVUWlyxoTEiTw0/edit#slide=id.p) * [AWS: Deploy Alexa Ask Skills with Flask-Ask and Zappa](https://developer.amazon.com/blogs/post/8e8ad73a-99e9-4c0f-a7b3-60f92287b0bf/New-Alexa-Tutorial-Deploy-Flask-Ask-Skills-to-AWS-Lambda-with-Zappa) * [Guide to using Django with Zappa](https://edgarroman.github.io/zappa-django-guide/) * [Zappa and LambCI](https://seancoates.com/blogs/zappa-and-lambci/) * [Building A Serverless Image Processing SaaS using Zappa](https://medium.com/99serverless/building-a-serverless-image-processing-saas-9ef68b594076) * [Serverless Slack Slash Commands with Python and Zappa](https://renzo.lucioni.xyz/serverless-slash-commands-with-python/) * [Bringing Tokusatsu to AWS using Python, Flask, Zappa and Contentful](https://www.contentful.com/blog/2018/03/07/bringing-tokusatsu-to-aws-using-python-flask-zappa-and-contentful/) * [AWS Summit 2018 Seoul - Zappa와 함께하는 Serverless Microservice](https://www.slideshare.net/YunSeopSong/zappa-serverless-microservice-94410308/) * [Book - Building Serverless Python Web Services with Zappa](https://github.com/PacktPublishing/Building-Serverless-Python-Web-Services-with-Zappa) * [Vider sa flask dans une lambda](http://free_zed.gitlab.io/articles/2019/11/vider-sa-flask-dans-une-lambda/)[French] * _Your guide here?_ ## Zappa in the Press * _[Zappa Serves Python, Minus the Servers](http://www.infoworld.com/article/3031665/application-development/zappa-serves-python-web-apps-minus-the-servers.html)_ * _[Zappa lyfter serverlösa applikationer med Python](http://computersweden.idg.se/2.2683/1.649895/zappa-lyfter-python)_ * _[Interview: Rich Jones on Zappa](https://serverlesscode.com/post/rich-jones-interview-django-zappa/)_ * [Top 10 Python Libraries of 2016](https://tryolabs.com/blog/2016/12/20/top-10-python-libraries-of-2016/) ## Sites Using Zappa * [Mailchimp Signup Utility](https://github.com/sasha42/Mailchimp-utility) - A microservice for adding people to a mailing list via API. * [Zappa Slack Inviter](https://github.com/Miserlou/zappa-slack-inviter) - A tiny, server-less service for inviting new users to your Slack channel. * [Serverless Image Host](https://github.com/Miserlou/serverless-imagehost) - A thumbnailing service with Flask, Zappa and Pillow. * [Zappa BitTorrent Tracker](https://github.com/Miserlou/zappa-bittorrent-tracker) - An experimental server-less BitTorrent tracker. Work in progress. * [JankyGlance](https://github.com/Miserlou/JankyGlance) - A server-less Yahoo! Pipes replacement. * [LambdaMailer](https://github.com/tryolabs/lambda-mailer) - A server-less endpoint for processing a contact form. * [Voter Registration Microservice](https://topics.arlingtonva.us/2016/11/voter-registration-search-microservice/) - Official backup to to the Virginia Department of Elections portal. * [FreePoll Online](https://www.freepoll.online) - A simple and awesome say for groups to make decisions. * [PasteOfCode](https://paste.ofcode.org/) - A Zappa-powered paste bin. * And many more, including banks, governments, startups, enterprises and schools! Are you using Zappa? Let us know and we'll list your site here! ## Related Projects * [Mackenzie](http://github.com/Miserlou/Mackenzie) - AWS Lambda Infection Toolkit * [NoDB](https://github.com/Miserlou/NoDB) - A simple, server-less, Pythonic object store based on S3. * [zappa-cms](http://github.com/Miserlou/zappa-cms) - A tiny server-less CMS for busy hackers. Work in progress. * [zappa-django-utils](https://github.com/Miserlou/zappa-django-utils) - Utility commands to help Django deployments. * [flask-ask](https://github.com/johnwheeler/flask-ask) - A framework for building Amazon Alexa applications. Uses Zappa for deployments. * [zappa-file-widget](https://github.com/anush0247/zappa-file-widget) - A Django plugin for supporting binary file uploads in Django on Zappa. * [zops](https://github.com/bjinwright/zops) - Utilities for teams and continuous integrations using Zappa. * [cookiecutter-mobile-backend](https://github.com/narfman0/cookiecutter-mobile-backend/) - A `cookiecutter` Django project with Zappa and S3 uploads support. * [zappa-examples](https://github.com/narfman0/zappa-examples/) - Flask, Django, image uploads, and more! * [zappa-hug-example](https://github.com/mcrowson/zappa-hug-example) - Example of a Hug application using Zappa. * [Zappa Docker Image](https://github.com/danielwhatmuff/zappa) - A Docker image for running Zappa locally, based on Lambda Docker. * [zappa-dashing](https://github.com/nikos/zappa-dashing) - Monitor your AWS environment (health/metrics) with Zappa and CloudWatch. * [s3env](https://github.com/cameronmaske/s3env) - Manipulate a remote Zappa environment variable key/value JSON object file in an S3 bucket through the CLI. * [zappa_resize_image_on_fly](https://github.com/wobeng/zappa_resize_image_on_fly) - Resize images on the fly using Flask, Zappa, Pillow, and OpenCV-python. * [zappa-ffmpeg](https://github.com/ubergarm/zappa-ffmpeg) - Run ffmpeg inside a lambda for serverless transformations. * [gdrive-lambda](https://github.com/richiverse/gdrive-lambda) - pass json data to a csv file for end users who use Gdrive across the organization. * [travis-build-repeat](https://github.com/bcongdon/travis-build-repeat) - Repeat TravisCI builds to avoid stale test results. * [wunderskill-alexa-skill](https://github.com/mcrowson/wunderlist-alexa-skill) - An Alexa skill for adding to a Wunderlist. * [xrayvision](https://github.com/mathom/xrayvision) - Utilities and wrappers for using AWS X-Ray with Zappa. * [terraform-aws-zappa](https://github.com/dpetzold/terraform-aws-zappa) - Terraform modules for creating a VPC, RDS instance, ElastiCache Redis and CloudFront Distribution for use with Zappa. * [zappa-sentry](https://github.com/jneves/zappa-sentry) - Integration with Zappa and Sentry * [IOpipe](https://github.com/iopipe/iopipe-python#zappa) - Monitor, profile and analyze your Zappa apps. ## Hacks Zappa goes quite far beyond what Lambda and API Gateway were ever intended to handle. As a result, there are quite a few hacks in here that allow it to work. Some of those include, but aren't limited to.. * Using VTL to map body, headers, method, params and query strings into JSON, and then turning that into valid WSGI. * Attaching response codes to response bodies, Base64 encoding the whole thing, using that as a regex to route the response code, decoding the body in VTL, and mapping the response body to that. * Packing and _Base58_ encoding multiple cookies into a single cookie because we can only map one kind. * Forcing the case permutations of "Set-Cookie" in order to return multiple headers at the same time. * Turning cookie-setting 301/302 responses into 200 responses with HTML redirects, because we have no way to set headers on redirects. ## Contributing This project is still young, so there is still plenty to be done. Contributions are more than welcome! Please file tickets for discussion before submitting patches. Pull requests should target `master` and should leave Zappa in a "shippable" state if merged. If you are adding a non-trivial amount of new code, please include a functioning test in your PR. For AWS calls, we use the `placebo` library, which you can learn to use [in their README](https://github.com/garnaat/placebo#usage-as-a-decorator). The test suite will be run by [Travis CI](https://travis-ci.org/zappa/Zappa) once you open a pull request. Please include the GitHub issue or pull request URL that has discussion related to your changes as a comment in the code ([example](https://github.com/zappa/Zappa/blob/fae2925431b820eaedf088a632022e4120a29f89/zappa/zappa.py#L241-L243)). This greatly helps for project maintainability, as it allows us to trace back use cases and explain decision making. Similarly, please make sure that you meet all of the requirements listed in the [pull request template](https://raw.githubusercontent.com/zappa/Zappa/master/.github/PULL_REQUEST_TEMPLATE.md). Please feel free to work on any open ticket, especially any ticket marked with the "help-wanted" label. If you get stuck or want to discuss an issue further, please join [our Slack channel](https://zappateam.slack.com/), where you'll find a community of smart and interesting people working dilligently on hard problems. [Zappa Slack Auto Invite](https://slackautoinviter.herokuapp.com) Zappa does not intend to conform to PEP8, isolate your commits so that changes to functionality with changes made by your linter. #### Using a Local Repo To use the git HEAD, you *probably can't* use `pip install -e `. Instead, you should clone the repo to your machine and then `pip install /path/to/zappa/repo` or `ln -s /path/to/zappa/repo/zappa zappa` in your local project. ## Patrons If you or your company uses **Zappa**, please consider giving what you can to support the ongoing development of the project! You can become a patron by **[visiting our Patreon page](https://patreon.com/zappa)**. Zappa is currently supported by these awesome individuals and companies: * Nathan Lawrence * LaunchLab * Sean Paley * Theo Chitayat * George Sibble * Joe Weiss * Nik Bora * Zerong Toby Wang * Gareth E * Matt Jackson * Sean Coates * Alexander Loschilov * Korey Peters * Joe Weiss * Kimmo Parvianen-Jalanko * Patrick Agin * Roberto Martinez * Charles Dimino * Doug Beney * Dan "The Man" Gayle * Juancito * Will Childs-Klein * Efi Merdler Kravitz * **Philippe Trounev** Thank you very, very much! ## Support / Development / Training / Consulting Do you need help with.. * Porting existing Flask and Django applications to Zappa? * Building new applications and services that scale infinitely? * Reducing your operations and hosting costs? * Adding new custom features into Zappa? * Training your team to use AWS and other server-less paradigms? Good news! We're currently available for remote and on-site consulting for small, large and enterprise teams. Please contact with your needs and let's work together!

Made by Gun.io

%package -n python3-zappa Summary: Server-less Python Web Services for AWS Lambda and API Gateway Provides: python-zappa BuildRequires: python3-devel BuildRequires: python3-setuptools BuildRequires: python3-pip %description -n python3-zappa dev: app_function: your_module.your_app s3_bucket: your-code-bucket events: - function: your_module.your_function event_source: arn: arn:aws:s3:::your-event-bucket events: - s3:ObjectCreated:* ``` You can also supply a custom settings file at any time with the `-s` argument, ex: ``` $ zappa deploy dev -s my-custom-settings.yml ``` Similarly, you can supply a `zappa_settings.toml` file: ```toml [dev] app_function = "your_module.your_app" s3_bucket = "your-code-bucket" ``` ## Advanced Usage ### Keeping The Server Warm Zappa will automatically set up a regularly occurring execution of your application in order to keep the Lambda function warm. This can be disabled via the `keep_warm` setting. #### Serving Static Files / Binary Uploads Zappa is now able to serve and receive binary files, as detected by their MIME-type. However, generally Zappa is designed for running your application code, not for serving static web assets. If you plan on serving custom static assets in your web application (CSS/JavaScript/images/etc.,), you'll likely want to use a combination of AWS S3 and AWS CloudFront. Your web application framework will likely be able to handle this for you automatically. For Flask, there is [Flask-S3](https://github.com/e-dard/flask-s3), and for Django, there is [Django-Storages](https://django-storages.readthedocs.io/en/latest/). Similarly, you may want to design your application so that static binary uploads go [directly to S3](http://docs.aws.amazon.com/AWSJavaScriptSDK/guide/browser-examples.html#Uploading_a_local_file_using_the_File_API), which then triggers an event response defined in your `events` setting! That's thinking serverlessly! ### Enabling CORS The simplest way to enable CORS (Cross-Origin Resource Sharing) for your Zappa application is to set `cors` to `true` in your Zappa settings file and update, which is the equivalent of pushing the "Enable CORS" button in the AWS API Gateway console. This is disabled by default, but you may wish to enable it for APIs which are accessed from other domains, etc. You can also simply handle CORS directly in your application. Your web framework will probably have an extension to do this, such as [django-cors-headers](https://github.com/ottoyiu/django-cors-headers) or [Flask-CORS](https://github.com/corydolphin/flask-cors). Using these will make your code more portable. ### Large Projects AWS currently limits Lambda zip sizes to 50 megabytes. If your project is larger than that, set `slim_handler: true` in your `zappa_settings.json`. In this case, your fat application package will be replaced with a small handler-only package. The handler file then pulls the rest of the large project down from S3 at run time! The initial load of the large project may add to startup overhead, but the difference should be minimal on a warm lambda function. Note that this will also eat into the storage space of your application function. Note that AWS currently [limits](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) the `/tmp` directory storage to 512 MB, so your project must still be smaller than that. ### Enabling Bash Completion Bash completion can be enabled by adding the following to your .bashrc: ```bash eval "$(register-python-argcomplete zappa)" ``` `register-python-argcomplete` is provided by the argcomplete Python package. If this package was installed in a virtualenv then the command must be run there. Alternatively you can execute: activate-global-python-argcomplete --dest=- > file The file's contents should then be sourced in e.g. ~/.bashrc. ### Enabling Secure Endpoints on API Gateway #### API Key You can use the `api_key_required` setting to generate an API key to all the routes of your API Gateway. The process is as follows: 1. Deploy/redeploy (update won't work) and write down the *id* for the key that has been created 2. Go to AWS console > Amazon API Gateway and * select "API Keys" and find the key *value* (for example `key_value`) * select "Usage Plans", create a new usage plan and link the API Key and the API that Zappa has created for you 3. Send a request where you pass the key value as a header called `x-api-key` to access the restricted endpoints (for example with curl: `curl --header "x-api-key: key_value"`). Note that without the x-api-key header, you will receive a 403. #### IAM Policy You can enable IAM-based (v4 signing) authorization on an API by setting the `iam_authorization` setting to `true`. Your API will then require signed requests and access can be controlled via [IAM policy](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-iam-policy-examples.html). Unsigned requests will receive a 403 response, as will requesters who are not authorized to access the API. Enabling this will override the Authorizer configuration (see below). #### API Gateway Lambda Authorizers If you deploy an API endpoint with Zappa, you can take advantage of [API Gateway Lambda Authorizers](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) to implement a token-based authentication - all you need to do is to provide a function to create the required output, Zappa takes care of the rest. A good start for the function is the [AWS Labs blueprint example](https://github.com/awslabs/aws-apigateway-lambda-authorizer-blueprints/blob/master/blueprints/python/api-gateway-authorizer-python.py). If you are wondering for what you would use an Authorizer, here are some potential use cases: 1. Call out to OAuth provider 2. Decode a JWT token inline 3. Lookup in a self-managed DB (for example DynamoDB) Zappa can be configured to call a function inside your code to do the authorization, or to call some other existing lambda function (which lets you share the authorizer between multiple lambdas). You control the behavior by specifying either the `arn` or `function_name` values in the `authorizer` settings block. For example, to get the Cognito identity, add this to a `zappa_settings.yaml`: ```yaml context_header_mappings: user_id: authorizer.user_id ``` Which can now be accessed in Flask like this: ```python from flask import request @route('/hello') def hello_world: print(request.headers.get('user_id')) ``` #### Cognito User Pool Authorizer You can also use AWS Cognito User Pool Authorizer by adding: ```javascript { "authorizer": { "type": "COGNITO_USER_POOLS", "provider_arns": [ "arn:aws:cognito-idp:{region}:{account_id}:userpool/{user_pool_id}" ] } } ``` #### API Gateway Resource Policy You can also use API Gateway Resource Policies. Example of IP Whitelisting: ```javascript { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": "*", "Action": "execute-api:Invoke", "Resource": "execute-api:/*", "Condition": { "IpAddress": { "aws:SourceIp": [ "1.2.3.4/32" ] } } } ] } ``` ### Setting Environment Variables #### Local Environment Variables If you want to set local environment variables for a deployment stage, you can simply set them in your `zappa_settings.json`: ```javascript { "dev": { "environment_variables": { "your_key": "your_value" } }, } ``` You can then access these inside your application with: ```python import os your_value = os.environ.get('your_key') ``` If your project needs to be aware of the type of environment you're deployed to, you'll also be able to get `SERVERTYPE` (AWS Lambda), `FRAMEWORK` (Zappa), `PROJECT` (your project name) and `STAGE` (_dev_, _production_, etc.) variables at any time. #### Remote AWS Environment Variables If you want to use native AWS Lambda environment variables you can use the `aws_environment_variables` configuration setting. These are useful as you can easily change them via the AWS Lambda console or cli at runtime. They are also useful for storing sensitive credentials and to take advantage of KMS encryption of environment variables. During development, you can add your Zappa defined variables to your locally running app by, for example, using the below (for Django, to manage.py). ```python if 'SERVERTYPE' in os.environ and os.environ['SERVERTYPE'] == 'AWS Lambda': import json import os json_data = open('zappa_settings.json') env_vars = json.load(json_data)['dev']['environment_variables'] for key, val in env_vars.items(): os.environ[key] = val ``` #### Remote Environment Variables Any environment variables that you have set outside of Zappa (via AWS Lambda console or cli) will remain as they are when running `update`, unless they are also in `aws_environment_variables`, in which case the remote value will be overwritten by the one in the settings file. If you are using KMS-encrypted AWS environment variables, you can set your KMS Key ARN in the `aws_kms_key_arn` setting. Make sure that the values you set are encrypted in such case. _Note: if you rely on these as well as `environment_variables`, and you have the same key names, then those in `environment_variables` will take precedence as they are injected in the lambda handler._ #### Remote Environment Variables (via an S3 file) _S3 remote environment variables were added to Zappa before AWS introduced native environment variables for Lambda (via the console and cli). Before going down this route check if above make more sense for your usecase._ If you want to use remote environment variables to configure your application (which is especially useful for things like sensitive credentials), you can create a file and place it in an S3 bucket to which your Zappa application has access. To do this, add the `remote_env` key to zappa_settings pointing to a file containing a flat JSON object, so that each key-value pair on the object will be set as an environment variable and value whenever a new lambda instance spins up. For example, to ensure your application has access to the database credentials without storing them in your version control, you can add a file to S3 with the connection string and load it into the lambda environment using the `remote_env` configuration setting. super-secret-config.json (uploaded to my-config-bucket): ```javascript { "DB_CONNECTION_STRING": "super-secret:database" } ``` zappa_settings.json: ```javascript { "dev": { "remote_env": "s3://my-config-bucket/super-secret-config.json", }, } ``` Now in your application you can use: ```python import os db_string = os.environ.get('DB_CONNECTION_STRING') ``` ### API Gateway Context Variables If you want to map an API Gateway context variable (http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html) to an HTTP header you can set up the mapping in `zappa_settings.json`: ```javascript { "dev": { "context_header_mappings": { "HTTP_header_name": "API_Gateway_context_variable" } }, } ``` For example, if you want to expose the $context.identity.cognitoIdentityId variable as the HTTP header CognitoIdentityId, and $context.stage as APIStage, you would have: ```javascript { "dev": { "context_header_mappings": { "CognitoIdentityId": "identity.cognitoIdentityId", "APIStage": "stage" } }, } ``` ### Catching Unhandled Exceptions By default, if an _unhandled_ exception happens in your code, Zappa will just print the stacktrace into a CloudWatch log. If you wish to use an external reporting tool to take note of those exceptions, you can use the `exception_handler` configuration option. zappa_settings.json: ```javascript { "dev": { "exception_handler": "your_module.unhandled_exceptions", }, } ``` The function has to accept three arguments: exception, event, and context: your_module.py ```python def unhandled_exceptions(e, event, context): send_to_raygun(e, event) # gather data you need and send return True # Prevent invocation retry ``` You may still need a similar exception handler inside your application, this is just a way to catch exception which happen at the Zappa/WSGI layer (typically event-based invocations, misconfigured settings, bad Lambda packages, and permissions issues). By default, AWS Lambda will attempt to retry an event based (non-API Gateway, e.g. CloudWatch) invocation if an exception has been thrown. However, you can prevent this by returning True, as in example above, so Zappa that will not re-raise the uncaught exception, thus preventing AWS Lambda from retrying the current invocation. ### Using Custom AWS IAM Roles and Policies #### Custom AWS IAM Roles and Policies for Deployment You can specify which _local_ profile to use for deploying your Zappa application by defining the `profile_name` setting, which will correspond to a profile in your AWS credentials file. #### Custom AWS IAM Roles and Policies for Execution The default IAM policy created by Zappa for executing the Lambda is very permissive. It grants access to all actions for all resources for types CloudWatch, S3, Kinesis, SNS, SQS, DynamoDB, and Route53; lambda:InvokeFunction for all Lambda resources; Put to all X-Ray resources; and all Network Interface operations to all EC2 resources. While this allows most Lambdas to work correctly with no extra permissions, it is generally not an acceptable set of permissions for most continuous integration pipelines or production deployments. Instead, you will probably want to manually manage your IAM policies. To manually define the policy of your Lambda execution role, you must set *manage_roles* to false and define either the *role_name* or *role_arn* in your Zappa settings file. ```javascript { "dev": { "manage_roles": false, // Disable Zappa client managing roles. "role_name": "MyLambdaRole", // Name of your Zappa execution role. Optional, default: --ZappaExecutionRole. "role_arn": "arn:aws:iam::12345:role/app-ZappaLambdaExecutionRole", // ARN of your Zappa execution role. Optional. }, } ``` Ongoing discussion about the minimum policy requirements necessary for a Zappa deployment [can be found here](https://github.com/Miserlou/Zappa/issues/244). A more robust solution to managing these entitlements will likely be implemented soon. To add permissions to the default Zappa execution policy, use the `extra_permissions` setting: ```javascript { "dev": { "extra_permissions": [{ // Attach any extra permissions to this policy. "Effect": "Allow", "Action": ["rekognition:*"], // AWS Service ARN "Resource": "*" }] }, } ``` ### AWS X-Ray Zappa can enable [AWS X-Ray](https://aws.amazon.com/xray/) support on your function with a configuration setting: ```javascript { "dev": { "xray_tracing": true }, } ``` This will enable it on the Lambda function and allow you to instrument your code with X-Ray. For example, with Flask: ```python from aws_xray_sdk.core import xray_recorder app = Flask(__name__) xray_recorder.configure(service='my_app_name') @route('/hello') @xray_recorder.capture('hello') def hello_world: return 'Hello' ``` You may use the capture decorator to create subsegments around functions, or `xray_recorder.begin_subsegment('subsegment_name')` and `xray_recorder.end_subsegment()` within a function. The official [X-Ray documentation for Python](http://docs.aws.amazon.com/xray-sdk-for-python/latest/reference/) has more information on how to use this with your code. Note that you may create subsegments in your code but an exception will be raised if you try to create a segment, as it is [created by the lambda worker](https://github.com/aws/aws-xray-sdk-python/issues/2). This also means that if you use Flask you must not use the [XRayMiddleware the documentation suggests](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python-middleware.html). ### Globally Available Server-less Architectures

Global Zappa Slides

Click to see slides from ServerlessConf London!

During the `init` process, you will be given the option to deploy your application "globally." This will allow you to deploy your application to all available AWS regions simultaneously in order to provide a consistent global speed, increased redundancy, data isolation, and legal compliance. You can also choose to deploy only to "primary" locations, the AWS regions with `-1` in their names. To learn more about these capabilities, see [these slides](https://htmlpreview.github.io/?https://github.com/Miserlou/Talks/blob/master/serverless-london/global.html#0) from ServerlessConf London. ### Raising AWS Service Limits Out of the box, AWS sets a limit of [1000 concurrent executions](http://docs.aws.amazon.com/lambda/latest/dg/limits.html) for your functions. If you start to breach these limits, you may start to see errors like `ClientError: An error occurred (LimitExceededException) when calling the PutTargets.."` or something similar. To avoid this, you can file a [service ticket](https://console.aws.amazon.com/support/home#/) with Amazon to raise your limits up to the many tens of thousands of concurrent executions which you may need. This is a fairly common practice with Amazon, designed to prevent you from accidentally creating extremely expensive bug reports. So, before raising your service limits, make sure that you don't have any rogue scripts which could accidentally create tens of thousands of parallel executions that you don't want to pay for. ### Dead Letter Queues If you want to utilise [AWS Lambda's Dead Letter Queue feature](http://docs.aws.amazon.com/lambda/latest/dg/dlq.html) simply add the key `dead_letter_arn`, with the value being the complete ARN to the corresponding SNS topic or SQS queue in your `zappa_settings.json`. You must have already created the corresponding SNS/SQS topic/queue, and the Lambda function execution role must have been provisioned with read/publish/sendMessage access to the DLQ resource. ### Unique Package ID For monitoring of different deployments, a unique UUID for each package is available in `package_info.json` in the root directory of your application's package. You can use this information or a hash of this file for such things as tracking errors across different deployments, monitoring status of deployments and other such things on services such as Sentry and New Relic. The package will contain: ```json { "build_platform": "darwin", "build_user": "frank", "build_time": "1509732511", "uuid": "9c2df9e6-30f4-4c0a-ac4d-4ecb51831a74" } ``` ### Application Load Balancer Event Source Zappa can be used to handle events triggered by Application Load Balancers (ALB). This can be useful in a few circumstances: - Since API Gateway has a hard limit of 30 seconds before timing out, you can use an ALB for longer running requests. - API Gateway is billed per-request; therefore, costs can become excessive with high throughput services. ALBs pricing model makes much more sense financially if you're expecting a lot of traffic to your Lambda. - ALBs can be placed within a VPC, which may make more sense for private endpoints than using API Gateway's private model (using AWS PrivateLink). Like API Gateway, Zappa can automatically provision ALB resources for you. You'll need to add the following to your `zappa_settings`: ``` "alb_enabled": true, "alb_vpc_config": { "CertificateArn": "arn:aws:acm:us-east-1:[your-account-id]:certificate/[certificate-id]", "SubnetIds": [ // Here, you'll want to provide a list of subnets for your ALB, eg. 'subnet-02a58266' ], "SecurityGroupIds": [ // And here, a list of security group IDs, eg. 'sg-fbacb791' ] } ``` More information on using ALB as an event source for Lambda can be found [here](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/lambda-functions.html). *An important note*: right now, Zappa will provision ONE lambda to ONE load balancer, which means using `base_path` along with ALB configuration is currently unsupported. ### Endpoint Configuration API Gateway can be configured to be only accessible in a VPC. To enable this; [configure your VPC to support](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html) then set the `endpoint_configuration` to `PRIVATE` and set up Resource Policy on the API Gateway. A note about this; if you're using a private endpoint, Zappa won't be able to tell if the API is returning a successful status code upon deploy or update, so you'll have to check it manually to ensure your setup is working properly. For full list of options for endpoint configuration refer to [API Gateway EndpointConfiguration documentation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-restapi-endpointconfiguration.html) #### Example Private API Gateway configuration zappa_settings.json: ```json { "dev": { "endpoint_configuration": ["PRIVATE"], "apigateway_policy": "apigateway_resource_policy.json", }, } ``` apigateway_resource_policy.json: ```json { "Version": "2012-10-17", "Statement": [ { "Effect": "Deny", "Principal": "*", "Action": "execute-api:Invoke", "Resource": "execute-api:/*", "Condition": { "StringNotEquals": { "aws:sourceVpc": "{{vpcID}}" // UPDATE ME } } }, { "Effect": "Allow", "Principal": "*", "Action": "execute-api:Invoke", "Resource": "execute-api:/*" } ] } ``` ### Cold Starts (Experimental) Lambda may provide additional resources than provisioned during cold start initialization. Set `INSTANTIATE_LAMBDA_HANDLER_ON_IMPORT=True` to instantiate the lambda handler on import. This is an experimental feature - if startup time is critical, look into using Provisioned Concurrency. ## Zappa Guides * [Django-Zappa tutorial (screencast)](https://www.youtube.com/watch?v=plUrbPN0xc8&feature=youtu.be). * [Using Django-Zappa, Part 1](https://serverlesscode.com/post/zappa-wsgi-for-python/). * [Using Django-Zappa, Part 2: VPCs](https://serverlesscode.com/post/zappa-wsgi-for-python-pt-2/). * [Building Serverless Microservices with Zappa and Flask](https://gun.io/blog/serverless-microservices-with-zappa-and-flask/) * [Zappa で Hello World するまで (Japanese)](http://qiita.com/satoshi_iwashita/items/505492193317819772c7) * [How to Deploy Zappa with CloudFront, RDS and VPC](https://jinwright.net/how-deploy-serverless-wsgi-app-using-zappa/) * [Secure 'Serverless' File Uploads with AWS Lambda, S3, and Zappa](http://blog.stratospark.com/secure-serverless-file-uploads-with-aws-lambda-s3-zappa.html) * [Deploy a Serverless WSGI App using Zappa, CloudFront, RDS, and VPC](https://docs.google.com/presentation/d/1aYeOMgQl4V_fFgT5VNoycdXtob1v6xVUWlyxoTEiTw0/edit#slide=id.p) * [AWS: Deploy Alexa Ask Skills with Flask-Ask and Zappa](https://developer.amazon.com/blogs/post/8e8ad73a-99e9-4c0f-a7b3-60f92287b0bf/New-Alexa-Tutorial-Deploy-Flask-Ask-Skills-to-AWS-Lambda-with-Zappa) * [Guide to using Django with Zappa](https://edgarroman.github.io/zappa-django-guide/) * [Zappa and LambCI](https://seancoates.com/blogs/zappa-and-lambci/) * [Building A Serverless Image Processing SaaS using Zappa](https://medium.com/99serverless/building-a-serverless-image-processing-saas-9ef68b594076) * [Serverless Slack Slash Commands with Python and Zappa](https://renzo.lucioni.xyz/serverless-slash-commands-with-python/) * [Bringing Tokusatsu to AWS using Python, Flask, Zappa and Contentful](https://www.contentful.com/blog/2018/03/07/bringing-tokusatsu-to-aws-using-python-flask-zappa-and-contentful/) * [AWS Summit 2018 Seoul - Zappa와 함께하는 Serverless Microservice](https://www.slideshare.net/YunSeopSong/zappa-serverless-microservice-94410308/) * [Book - Building Serverless Python Web Services with Zappa](https://github.com/PacktPublishing/Building-Serverless-Python-Web-Services-with-Zappa) * [Vider sa flask dans une lambda](http://free_zed.gitlab.io/articles/2019/11/vider-sa-flask-dans-une-lambda/)[French] * _Your guide here?_ ## Zappa in the Press * _[Zappa Serves Python, Minus the Servers](http://www.infoworld.com/article/3031665/application-development/zappa-serves-python-web-apps-minus-the-servers.html)_ * _[Zappa lyfter serverlösa applikationer med Python](http://computersweden.idg.se/2.2683/1.649895/zappa-lyfter-python)_ * _[Interview: Rich Jones on Zappa](https://serverlesscode.com/post/rich-jones-interview-django-zappa/)_ * [Top 10 Python Libraries of 2016](https://tryolabs.com/blog/2016/12/20/top-10-python-libraries-of-2016/) ## Sites Using Zappa * [Mailchimp Signup Utility](https://github.com/sasha42/Mailchimp-utility) - A microservice for adding people to a mailing list via API. * [Zappa Slack Inviter](https://github.com/Miserlou/zappa-slack-inviter) - A tiny, server-less service for inviting new users to your Slack channel. * [Serverless Image Host](https://github.com/Miserlou/serverless-imagehost) - A thumbnailing service with Flask, Zappa and Pillow. * [Zappa BitTorrent Tracker](https://github.com/Miserlou/zappa-bittorrent-tracker) - An experimental server-less BitTorrent tracker. Work in progress. * [JankyGlance](https://github.com/Miserlou/JankyGlance) - A server-less Yahoo! Pipes replacement. * [LambdaMailer](https://github.com/tryolabs/lambda-mailer) - A server-less endpoint for processing a contact form. * [Voter Registration Microservice](https://topics.arlingtonva.us/2016/11/voter-registration-search-microservice/) - Official backup to to the Virginia Department of Elections portal. * [FreePoll Online](https://www.freepoll.online) - A simple and awesome say for groups to make decisions. * [PasteOfCode](https://paste.ofcode.org/) - A Zappa-powered paste bin. * And many more, including banks, governments, startups, enterprises and schools! Are you using Zappa? Let us know and we'll list your site here! ## Related Projects * [Mackenzie](http://github.com/Miserlou/Mackenzie) - AWS Lambda Infection Toolkit * [NoDB](https://github.com/Miserlou/NoDB) - A simple, server-less, Pythonic object store based on S3. * [zappa-cms](http://github.com/Miserlou/zappa-cms) - A tiny server-less CMS for busy hackers. Work in progress. * [zappa-django-utils](https://github.com/Miserlou/zappa-django-utils) - Utility commands to help Django deployments. * [flask-ask](https://github.com/johnwheeler/flask-ask) - A framework for building Amazon Alexa applications. Uses Zappa for deployments. * [zappa-file-widget](https://github.com/anush0247/zappa-file-widget) - A Django plugin for supporting binary file uploads in Django on Zappa. * [zops](https://github.com/bjinwright/zops) - Utilities for teams and continuous integrations using Zappa. * [cookiecutter-mobile-backend](https://github.com/narfman0/cookiecutter-mobile-backend/) - A `cookiecutter` Django project with Zappa and S3 uploads support. * [zappa-examples](https://github.com/narfman0/zappa-examples/) - Flask, Django, image uploads, and more! * [zappa-hug-example](https://github.com/mcrowson/zappa-hug-example) - Example of a Hug application using Zappa. * [Zappa Docker Image](https://github.com/danielwhatmuff/zappa) - A Docker image for running Zappa locally, based on Lambda Docker. * [zappa-dashing](https://github.com/nikos/zappa-dashing) - Monitor your AWS environment (health/metrics) with Zappa and CloudWatch. * [s3env](https://github.com/cameronmaske/s3env) - Manipulate a remote Zappa environment variable key/value JSON object file in an S3 bucket through the CLI. * [zappa_resize_image_on_fly](https://github.com/wobeng/zappa_resize_image_on_fly) - Resize images on the fly using Flask, Zappa, Pillow, and OpenCV-python. * [zappa-ffmpeg](https://github.com/ubergarm/zappa-ffmpeg) - Run ffmpeg inside a lambda for serverless transformations. * [gdrive-lambda](https://github.com/richiverse/gdrive-lambda) - pass json data to a csv file for end users who use Gdrive across the organization. * [travis-build-repeat](https://github.com/bcongdon/travis-build-repeat) - Repeat TravisCI builds to avoid stale test results. * [wunderskill-alexa-skill](https://github.com/mcrowson/wunderlist-alexa-skill) - An Alexa skill for adding to a Wunderlist. * [xrayvision](https://github.com/mathom/xrayvision) - Utilities and wrappers for using AWS X-Ray with Zappa. * [terraform-aws-zappa](https://github.com/dpetzold/terraform-aws-zappa) - Terraform modules for creating a VPC, RDS instance, ElastiCache Redis and CloudFront Distribution for use with Zappa. * [zappa-sentry](https://github.com/jneves/zappa-sentry) - Integration with Zappa and Sentry * [IOpipe](https://github.com/iopipe/iopipe-python#zappa) - Monitor, profile and analyze your Zappa apps. ## Hacks Zappa goes quite far beyond what Lambda and API Gateway were ever intended to handle. As a result, there are quite a few hacks in here that allow it to work. Some of those include, but aren't limited to.. * Using VTL to map body, headers, method, params and query strings into JSON, and then turning that into valid WSGI. * Attaching response codes to response bodies, Base64 encoding the whole thing, using that as a regex to route the response code, decoding the body in VTL, and mapping the response body to that. * Packing and _Base58_ encoding multiple cookies into a single cookie because we can only map one kind. * Forcing the case permutations of "Set-Cookie" in order to return multiple headers at the same time. * Turning cookie-setting 301/302 responses into 200 responses with HTML redirects, because we have no way to set headers on redirects. ## Contributing This project is still young, so there is still plenty to be done. Contributions are more than welcome! Please file tickets for discussion before submitting patches. Pull requests should target `master` and should leave Zappa in a "shippable" state if merged. If you are adding a non-trivial amount of new code, please include a functioning test in your PR. For AWS calls, we use the `placebo` library, which you can learn to use [in their README](https://github.com/garnaat/placebo#usage-as-a-decorator). The test suite will be run by [Travis CI](https://travis-ci.org/zappa/Zappa) once you open a pull request. Please include the GitHub issue or pull request URL that has discussion related to your changes as a comment in the code ([example](https://github.com/zappa/Zappa/blob/fae2925431b820eaedf088a632022e4120a29f89/zappa/zappa.py#L241-L243)). This greatly helps for project maintainability, as it allows us to trace back use cases and explain decision making. Similarly, please make sure that you meet all of the requirements listed in the [pull request template](https://raw.githubusercontent.com/zappa/Zappa/master/.github/PULL_REQUEST_TEMPLATE.md). Please feel free to work on any open ticket, especially any ticket marked with the "help-wanted" label. If you get stuck or want to discuss an issue further, please join [our Slack channel](https://zappateam.slack.com/), where you'll find a community of smart and interesting people working dilligently on hard problems. [Zappa Slack Auto Invite](https://slackautoinviter.herokuapp.com) Zappa does not intend to conform to PEP8, isolate your commits so that changes to functionality with changes made by your linter. #### Using a Local Repo To use the git HEAD, you *probably can't* use `pip install -e `. Instead, you should clone the repo to your machine and then `pip install /path/to/zappa/repo` or `ln -s /path/to/zappa/repo/zappa zappa` in your local project. ## Patrons If you or your company uses **Zappa**, please consider giving what you can to support the ongoing development of the project! You can become a patron by **[visiting our Patreon page](https://patreon.com/zappa)**. Zappa is currently supported by these awesome individuals and companies: * Nathan Lawrence * LaunchLab * Sean Paley * Theo Chitayat * George Sibble * Joe Weiss * Nik Bora * Zerong Toby Wang * Gareth E * Matt Jackson * Sean Coates * Alexander Loschilov * Korey Peters * Joe Weiss * Kimmo Parvianen-Jalanko * Patrick Agin * Roberto Martinez * Charles Dimino * Doug Beney * Dan "The Man" Gayle * Juancito * Will Childs-Klein * Efi Merdler Kravitz * **Philippe Trounev** Thank you very, very much! ## Support / Development / Training / Consulting Do you need help with.. * Porting existing Flask and Django applications to Zappa? * Building new applications and services that scale infinitely? * Reducing your operations and hosting costs? * Adding new custom features into Zappa? * Training your team to use AWS and other server-less paradigms? Good news! We're currently available for remote and on-site consulting for small, large and enterprise teams. Please contact with your needs and let's work together!

Made by Gun.io

%package help Summary: Development documents and examples for zappa Provides: python3-zappa-doc %description help dev: app_function: your_module.your_app s3_bucket: your-code-bucket events: - function: your_module.your_function event_source: arn: arn:aws:s3:::your-event-bucket events: - s3:ObjectCreated:* ``` You can also supply a custom settings file at any time with the `-s` argument, ex: ``` $ zappa deploy dev -s my-custom-settings.yml ``` Similarly, you can supply a `zappa_settings.toml` file: ```toml [dev] app_function = "your_module.your_app" s3_bucket = "your-code-bucket" ``` ## Advanced Usage ### Keeping The Server Warm Zappa will automatically set up a regularly occurring execution of your application in order to keep the Lambda function warm. This can be disabled via the `keep_warm` setting. #### Serving Static Files / Binary Uploads Zappa is now able to serve and receive binary files, as detected by their MIME-type. However, generally Zappa is designed for running your application code, not for serving static web assets. If you plan on serving custom static assets in your web application (CSS/JavaScript/images/etc.,), you'll likely want to use a combination of AWS S3 and AWS CloudFront. Your web application framework will likely be able to handle this for you automatically. For Flask, there is [Flask-S3](https://github.com/e-dard/flask-s3), and for Django, there is [Django-Storages](https://django-storages.readthedocs.io/en/latest/). Similarly, you may want to design your application so that static binary uploads go [directly to S3](http://docs.aws.amazon.com/AWSJavaScriptSDK/guide/browser-examples.html#Uploading_a_local_file_using_the_File_API), which then triggers an event response defined in your `events` setting! That's thinking serverlessly! ### Enabling CORS The simplest way to enable CORS (Cross-Origin Resource Sharing) for your Zappa application is to set `cors` to `true` in your Zappa settings file and update, which is the equivalent of pushing the "Enable CORS" button in the AWS API Gateway console. This is disabled by default, but you may wish to enable it for APIs which are accessed from other domains, etc. You can also simply handle CORS directly in your application. Your web framework will probably have an extension to do this, such as [django-cors-headers](https://github.com/ottoyiu/django-cors-headers) or [Flask-CORS](https://github.com/corydolphin/flask-cors). Using these will make your code more portable. ### Large Projects AWS currently limits Lambda zip sizes to 50 megabytes. If your project is larger than that, set `slim_handler: true` in your `zappa_settings.json`. In this case, your fat application package will be replaced with a small handler-only package. The handler file then pulls the rest of the large project down from S3 at run time! The initial load of the large project may add to startup overhead, but the difference should be minimal on a warm lambda function. Note that this will also eat into the storage space of your application function. Note that AWS currently [limits](https://docs.aws.amazon.com/lambda/latest/dg/limits.html) the `/tmp` directory storage to 512 MB, so your project must still be smaller than that. ### Enabling Bash Completion Bash completion can be enabled by adding the following to your .bashrc: ```bash eval "$(register-python-argcomplete zappa)" ``` `register-python-argcomplete` is provided by the argcomplete Python package. If this package was installed in a virtualenv then the command must be run there. Alternatively you can execute: activate-global-python-argcomplete --dest=- > file The file's contents should then be sourced in e.g. ~/.bashrc. ### Enabling Secure Endpoints on API Gateway #### API Key You can use the `api_key_required` setting to generate an API key to all the routes of your API Gateway. The process is as follows: 1. Deploy/redeploy (update won't work) and write down the *id* for the key that has been created 2. Go to AWS console > Amazon API Gateway and * select "API Keys" and find the key *value* (for example `key_value`) * select "Usage Plans", create a new usage plan and link the API Key and the API that Zappa has created for you 3. Send a request where you pass the key value as a header called `x-api-key` to access the restricted endpoints (for example with curl: `curl --header "x-api-key: key_value"`). Note that without the x-api-key header, you will receive a 403. #### IAM Policy You can enable IAM-based (v4 signing) authorization on an API by setting the `iam_authorization` setting to `true`. Your API will then require signed requests and access can be controlled via [IAM policy](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-iam-policy-examples.html). Unsigned requests will receive a 403 response, as will requesters who are not authorized to access the API. Enabling this will override the Authorizer configuration (see below). #### API Gateway Lambda Authorizers If you deploy an API endpoint with Zappa, you can take advantage of [API Gateway Lambda Authorizers](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) to implement a token-based authentication - all you need to do is to provide a function to create the required output, Zappa takes care of the rest. A good start for the function is the [AWS Labs blueprint example](https://github.com/awslabs/aws-apigateway-lambda-authorizer-blueprints/blob/master/blueprints/python/api-gateway-authorizer-python.py). If you are wondering for what you would use an Authorizer, here are some potential use cases: 1. Call out to OAuth provider 2. Decode a JWT token inline 3. Lookup in a self-managed DB (for example DynamoDB) Zappa can be configured to call a function inside your code to do the authorization, or to call some other existing lambda function (which lets you share the authorizer between multiple lambdas). You control the behavior by specifying either the `arn` or `function_name` values in the `authorizer` settings block. For example, to get the Cognito identity, add this to a `zappa_settings.yaml`: ```yaml context_header_mappings: user_id: authorizer.user_id ``` Which can now be accessed in Flask like this: ```python from flask import request @route('/hello') def hello_world: print(request.headers.get('user_id')) ``` #### Cognito User Pool Authorizer You can also use AWS Cognito User Pool Authorizer by adding: ```javascript { "authorizer": { "type": "COGNITO_USER_POOLS", "provider_arns": [ "arn:aws:cognito-idp:{region}:{account_id}:userpool/{user_pool_id}" ] } } ``` #### API Gateway Resource Policy You can also use API Gateway Resource Policies. Example of IP Whitelisting: ```javascript { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": "*", "Action": "execute-api:Invoke", "Resource": "execute-api:/*", "Condition": { "IpAddress": { "aws:SourceIp": [ "1.2.3.4/32" ] } } } ] } ``` ### Setting Environment Variables #### Local Environment Variables If you want to set local environment variables for a deployment stage, you can simply set them in your `zappa_settings.json`: ```javascript { "dev": { "environment_variables": { "your_key": "your_value" } }, } ``` You can then access these inside your application with: ```python import os your_value = os.environ.get('your_key') ``` If your project needs to be aware of the type of environment you're deployed to, you'll also be able to get `SERVERTYPE` (AWS Lambda), `FRAMEWORK` (Zappa), `PROJECT` (your project name) and `STAGE` (_dev_, _production_, etc.) variables at any time. #### Remote AWS Environment Variables If you want to use native AWS Lambda environment variables you can use the `aws_environment_variables` configuration setting. These are useful as you can easily change them via the AWS Lambda console or cli at runtime. They are also useful for storing sensitive credentials and to take advantage of KMS encryption of environment variables. During development, you can add your Zappa defined variables to your locally running app by, for example, using the below (for Django, to manage.py). ```python if 'SERVERTYPE' in os.environ and os.environ['SERVERTYPE'] == 'AWS Lambda': import json import os json_data = open('zappa_settings.json') env_vars = json.load(json_data)['dev']['environment_variables'] for key, val in env_vars.items(): os.environ[key] = val ``` #### Remote Environment Variables Any environment variables that you have set outside of Zappa (via AWS Lambda console or cli) will remain as they are when running `update`, unless they are also in `aws_environment_variables`, in which case the remote value will be overwritten by the one in the settings file. If you are using KMS-encrypted AWS environment variables, you can set your KMS Key ARN in the `aws_kms_key_arn` setting. Make sure that the values you set are encrypted in such case. _Note: if you rely on these as well as `environment_variables`, and you have the same key names, then those in `environment_variables` will take precedence as they are injected in the lambda handler._ #### Remote Environment Variables (via an S3 file) _S3 remote environment variables were added to Zappa before AWS introduced native environment variables for Lambda (via the console and cli). Before going down this route check if above make more sense for your usecase._ If you want to use remote environment variables to configure your application (which is especially useful for things like sensitive credentials), you can create a file and place it in an S3 bucket to which your Zappa application has access. To do this, add the `remote_env` key to zappa_settings pointing to a file containing a flat JSON object, so that each key-value pair on the object will be set as an environment variable and value whenever a new lambda instance spins up. For example, to ensure your application has access to the database credentials without storing them in your version control, you can add a file to S3 with the connection string and load it into the lambda environment using the `remote_env` configuration setting. super-secret-config.json (uploaded to my-config-bucket): ```javascript { "DB_CONNECTION_STRING": "super-secret:database" } ``` zappa_settings.json: ```javascript { "dev": { "remote_env": "s3://my-config-bucket/super-secret-config.json", }, } ``` Now in your application you can use: ```python import os db_string = os.environ.get('DB_CONNECTION_STRING') ``` ### API Gateway Context Variables If you want to map an API Gateway context variable (http://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-mapping-template-reference.html) to an HTTP header you can set up the mapping in `zappa_settings.json`: ```javascript { "dev": { "context_header_mappings": { "HTTP_header_name": "API_Gateway_context_variable" } }, } ``` For example, if you want to expose the $context.identity.cognitoIdentityId variable as the HTTP header CognitoIdentityId, and $context.stage as APIStage, you would have: ```javascript { "dev": { "context_header_mappings": { "CognitoIdentityId": "identity.cognitoIdentityId", "APIStage": "stage" } }, } ``` ### Catching Unhandled Exceptions By default, if an _unhandled_ exception happens in your code, Zappa will just print the stacktrace into a CloudWatch log. If you wish to use an external reporting tool to take note of those exceptions, you can use the `exception_handler` configuration option. zappa_settings.json: ```javascript { "dev": { "exception_handler": "your_module.unhandled_exceptions", }, } ``` The function has to accept three arguments: exception, event, and context: your_module.py ```python def unhandled_exceptions(e, event, context): send_to_raygun(e, event) # gather data you need and send return True # Prevent invocation retry ``` You may still need a similar exception handler inside your application, this is just a way to catch exception which happen at the Zappa/WSGI layer (typically event-based invocations, misconfigured settings, bad Lambda packages, and permissions issues). By default, AWS Lambda will attempt to retry an event based (non-API Gateway, e.g. CloudWatch) invocation if an exception has been thrown. However, you can prevent this by returning True, as in example above, so Zappa that will not re-raise the uncaught exception, thus preventing AWS Lambda from retrying the current invocation. ### Using Custom AWS IAM Roles and Policies #### Custom AWS IAM Roles and Policies for Deployment You can specify which _local_ profile to use for deploying your Zappa application by defining the `profile_name` setting, which will correspond to a profile in your AWS credentials file. #### Custom AWS IAM Roles and Policies for Execution The default IAM policy created by Zappa for executing the Lambda is very permissive. It grants access to all actions for all resources for types CloudWatch, S3, Kinesis, SNS, SQS, DynamoDB, and Route53; lambda:InvokeFunction for all Lambda resources; Put to all X-Ray resources; and all Network Interface operations to all EC2 resources. While this allows most Lambdas to work correctly with no extra permissions, it is generally not an acceptable set of permissions for most continuous integration pipelines or production deployments. Instead, you will probably want to manually manage your IAM policies. To manually define the policy of your Lambda execution role, you must set *manage_roles* to false and define either the *role_name* or *role_arn* in your Zappa settings file. ```javascript { "dev": { "manage_roles": false, // Disable Zappa client managing roles. "role_name": "MyLambdaRole", // Name of your Zappa execution role. Optional, default: --ZappaExecutionRole. "role_arn": "arn:aws:iam::12345:role/app-ZappaLambdaExecutionRole", // ARN of your Zappa execution role. Optional. }, } ``` Ongoing discussion about the minimum policy requirements necessary for a Zappa deployment [can be found here](https://github.com/Miserlou/Zappa/issues/244). A more robust solution to managing these entitlements will likely be implemented soon. To add permissions to the default Zappa execution policy, use the `extra_permissions` setting: ```javascript { "dev": { "extra_permissions": [{ // Attach any extra permissions to this policy. "Effect": "Allow", "Action": ["rekognition:*"], // AWS Service ARN "Resource": "*" }] }, } ``` ### AWS X-Ray Zappa can enable [AWS X-Ray](https://aws.amazon.com/xray/) support on your function with a configuration setting: ```javascript { "dev": { "xray_tracing": true }, } ``` This will enable it on the Lambda function and allow you to instrument your code with X-Ray. For example, with Flask: ```python from aws_xray_sdk.core import xray_recorder app = Flask(__name__) xray_recorder.configure(service='my_app_name') @route('/hello') @xray_recorder.capture('hello') def hello_world: return 'Hello' ``` You may use the capture decorator to create subsegments around functions, or `xray_recorder.begin_subsegment('subsegment_name')` and `xray_recorder.end_subsegment()` within a function. The official [X-Ray documentation for Python](http://docs.aws.amazon.com/xray-sdk-for-python/latest/reference/) has more information on how to use this with your code. Note that you may create subsegments in your code but an exception will be raised if you try to create a segment, as it is [created by the lambda worker](https://github.com/aws/aws-xray-sdk-python/issues/2). This also means that if you use Flask you must not use the [XRayMiddleware the documentation suggests](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python-middleware.html). ### Globally Available Server-less Architectures

Global Zappa Slides

Click to see slides from ServerlessConf London!

During the `init` process, you will be given the option to deploy your application "globally." This will allow you to deploy your application to all available AWS regions simultaneously in order to provide a consistent global speed, increased redundancy, data isolation, and legal compliance. You can also choose to deploy only to "primary" locations, the AWS regions with `-1` in their names. To learn more about these capabilities, see [these slides](https://htmlpreview.github.io/?https://github.com/Miserlou/Talks/blob/master/serverless-london/global.html#0) from ServerlessConf London. ### Raising AWS Service Limits Out of the box, AWS sets a limit of [1000 concurrent executions](http://docs.aws.amazon.com/lambda/latest/dg/limits.html) for your functions. If you start to breach these limits, you may start to see errors like `ClientError: An error occurred (LimitExceededException) when calling the PutTargets.."` or something similar. To avoid this, you can file a [service ticket](https://console.aws.amazon.com/support/home#/) with Amazon to raise your limits up to the many tens of thousands of concurrent executions which you may need. This is a fairly common practice with Amazon, designed to prevent you from accidentally creating extremely expensive bug reports. So, before raising your service limits, make sure that you don't have any rogue scripts which could accidentally create tens of thousands of parallel executions that you don't want to pay for. ### Dead Letter Queues If you want to utilise [AWS Lambda's Dead Letter Queue feature](http://docs.aws.amazon.com/lambda/latest/dg/dlq.html) simply add the key `dead_letter_arn`, with the value being the complete ARN to the corresponding SNS topic or SQS queue in your `zappa_settings.json`. You must have already created the corresponding SNS/SQS topic/queue, and the Lambda function execution role must have been provisioned with read/publish/sendMessage access to the DLQ resource. ### Unique Package ID For monitoring of different deployments, a unique UUID for each package is available in `package_info.json` in the root directory of your application's package. You can use this information or a hash of this file for such things as tracking errors across different deployments, monitoring status of deployments and other such things on services such as Sentry and New Relic. The package will contain: ```json { "build_platform": "darwin", "build_user": "frank", "build_time": "1509732511", "uuid": "9c2df9e6-30f4-4c0a-ac4d-4ecb51831a74" } ``` ### Application Load Balancer Event Source Zappa can be used to handle events triggered by Application Load Balancers (ALB). This can be useful in a few circumstances: - Since API Gateway has a hard limit of 30 seconds before timing out, you can use an ALB for longer running requests. - API Gateway is billed per-request; therefore, costs can become excessive with high throughput services. ALBs pricing model makes much more sense financially if you're expecting a lot of traffic to your Lambda. - ALBs can be placed within a VPC, which may make more sense for private endpoints than using API Gateway's private model (using AWS PrivateLink). Like API Gateway, Zappa can automatically provision ALB resources for you. You'll need to add the following to your `zappa_settings`: ``` "alb_enabled": true, "alb_vpc_config": { "CertificateArn": "arn:aws:acm:us-east-1:[your-account-id]:certificate/[certificate-id]", "SubnetIds": [ // Here, you'll want to provide a list of subnets for your ALB, eg. 'subnet-02a58266' ], "SecurityGroupIds": [ // And here, a list of security group IDs, eg. 'sg-fbacb791' ] } ``` More information on using ALB as an event source for Lambda can be found [here](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/lambda-functions.html). *An important note*: right now, Zappa will provision ONE lambda to ONE load balancer, which means using `base_path` along with ALB configuration is currently unsupported. ### Endpoint Configuration API Gateway can be configured to be only accessible in a VPC. To enable this; [configure your VPC to support](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-apis.html) then set the `endpoint_configuration` to `PRIVATE` and set up Resource Policy on the API Gateway. A note about this; if you're using a private endpoint, Zappa won't be able to tell if the API is returning a successful status code upon deploy or update, so you'll have to check it manually to ensure your setup is working properly. For full list of options for endpoint configuration refer to [API Gateway EndpointConfiguration documentation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-apigateway-restapi-endpointconfiguration.html) #### Example Private API Gateway configuration zappa_settings.json: ```json { "dev": { "endpoint_configuration": ["PRIVATE"], "apigateway_policy": "apigateway_resource_policy.json", }, } ``` apigateway_resource_policy.json: ```json { "Version": "2012-10-17", "Statement": [ { "Effect": "Deny", "Principal": "*", "Action": "execute-api:Invoke", "Resource": "execute-api:/*", "Condition": { "StringNotEquals": { "aws:sourceVpc": "{{vpcID}}" // UPDATE ME } } }, { "Effect": "Allow", "Principal": "*", "Action": "execute-api:Invoke", "Resource": "execute-api:/*" } ] } ``` ### Cold Starts (Experimental) Lambda may provide additional resources than provisioned during cold start initialization. Set `INSTANTIATE_LAMBDA_HANDLER_ON_IMPORT=True` to instantiate the lambda handler on import. This is an experimental feature - if startup time is critical, look into using Provisioned Concurrency. ## Zappa Guides * [Django-Zappa tutorial (screencast)](https://www.youtube.com/watch?v=plUrbPN0xc8&feature=youtu.be). * [Using Django-Zappa, Part 1](https://serverlesscode.com/post/zappa-wsgi-for-python/). * [Using Django-Zappa, Part 2: VPCs](https://serverlesscode.com/post/zappa-wsgi-for-python-pt-2/). * [Building Serverless Microservices with Zappa and Flask](https://gun.io/blog/serverless-microservices-with-zappa-and-flask/) * [Zappa で Hello World するまで (Japanese)](http://qiita.com/satoshi_iwashita/items/505492193317819772c7) * [How to Deploy Zappa with CloudFront, RDS and VPC](https://jinwright.net/how-deploy-serverless-wsgi-app-using-zappa/) * [Secure 'Serverless' File Uploads with AWS Lambda, S3, and Zappa](http://blog.stratospark.com/secure-serverless-file-uploads-with-aws-lambda-s3-zappa.html) * [Deploy a Serverless WSGI App using Zappa, CloudFront, RDS, and VPC](https://docs.google.com/presentation/d/1aYeOMgQl4V_fFgT5VNoycdXtob1v6xVUWlyxoTEiTw0/edit#slide=id.p) * [AWS: Deploy Alexa Ask Skills with Flask-Ask and Zappa](https://developer.amazon.com/blogs/post/8e8ad73a-99e9-4c0f-a7b3-60f92287b0bf/New-Alexa-Tutorial-Deploy-Flask-Ask-Skills-to-AWS-Lambda-with-Zappa) * [Guide to using Django with Zappa](https://edgarroman.github.io/zappa-django-guide/) * [Zappa and LambCI](https://seancoates.com/blogs/zappa-and-lambci/) * [Building A Serverless Image Processing SaaS using Zappa](https://medium.com/99serverless/building-a-serverless-image-processing-saas-9ef68b594076) * [Serverless Slack Slash Commands with Python and Zappa](https://renzo.lucioni.xyz/serverless-slash-commands-with-python/) * [Bringing Tokusatsu to AWS using Python, Flask, Zappa and Contentful](https://www.contentful.com/blog/2018/03/07/bringing-tokusatsu-to-aws-using-python-flask-zappa-and-contentful/) * [AWS Summit 2018 Seoul - Zappa와 함께하는 Serverless Microservice](https://www.slideshare.net/YunSeopSong/zappa-serverless-microservice-94410308/) * [Book - Building Serverless Python Web Services with Zappa](https://github.com/PacktPublishing/Building-Serverless-Python-Web-Services-with-Zappa) * [Vider sa flask dans une lambda](http://free_zed.gitlab.io/articles/2019/11/vider-sa-flask-dans-une-lambda/)[French] * _Your guide here?_ ## Zappa in the Press * _[Zappa Serves Python, Minus the Servers](http://www.infoworld.com/article/3031665/application-development/zappa-serves-python-web-apps-minus-the-servers.html)_ * _[Zappa lyfter serverlösa applikationer med Python](http://computersweden.idg.se/2.2683/1.649895/zappa-lyfter-python)_ * _[Interview: Rich Jones on Zappa](https://serverlesscode.com/post/rich-jones-interview-django-zappa/)_ * [Top 10 Python Libraries of 2016](https://tryolabs.com/blog/2016/12/20/top-10-python-libraries-of-2016/) ## Sites Using Zappa * [Mailchimp Signup Utility](https://github.com/sasha42/Mailchimp-utility) - A microservice for adding people to a mailing list via API. * [Zappa Slack Inviter](https://github.com/Miserlou/zappa-slack-inviter) - A tiny, server-less service for inviting new users to your Slack channel. * [Serverless Image Host](https://github.com/Miserlou/serverless-imagehost) - A thumbnailing service with Flask, Zappa and Pillow. * [Zappa BitTorrent Tracker](https://github.com/Miserlou/zappa-bittorrent-tracker) - An experimental server-less BitTorrent tracker. Work in progress. * [JankyGlance](https://github.com/Miserlou/JankyGlance) - A server-less Yahoo! Pipes replacement. * [LambdaMailer](https://github.com/tryolabs/lambda-mailer) - A server-less endpoint for processing a contact form. * [Voter Registration Microservice](https://topics.arlingtonva.us/2016/11/voter-registration-search-microservice/) - Official backup to to the Virginia Department of Elections portal. * [FreePoll Online](https://www.freepoll.online) - A simple and awesome say for groups to make decisions. * [PasteOfCode](https://paste.ofcode.org/) - A Zappa-powered paste bin. * And many more, including banks, governments, startups, enterprises and schools! Are you using Zappa? Let us know and we'll list your site here! ## Related Projects * [Mackenzie](http://github.com/Miserlou/Mackenzie) - AWS Lambda Infection Toolkit * [NoDB](https://github.com/Miserlou/NoDB) - A simple, server-less, Pythonic object store based on S3. * [zappa-cms](http://github.com/Miserlou/zappa-cms) - A tiny server-less CMS for busy hackers. Work in progress. * [zappa-django-utils](https://github.com/Miserlou/zappa-django-utils) - Utility commands to help Django deployments. * [flask-ask](https://github.com/johnwheeler/flask-ask) - A framework for building Amazon Alexa applications. Uses Zappa for deployments. * [zappa-file-widget](https://github.com/anush0247/zappa-file-widget) - A Django plugin for supporting binary file uploads in Django on Zappa. * [zops](https://github.com/bjinwright/zops) - Utilities for teams and continuous integrations using Zappa. * [cookiecutter-mobile-backend](https://github.com/narfman0/cookiecutter-mobile-backend/) - A `cookiecutter` Django project with Zappa and S3 uploads support. * [zappa-examples](https://github.com/narfman0/zappa-examples/) - Flask, Django, image uploads, and more! * [zappa-hug-example](https://github.com/mcrowson/zappa-hug-example) - Example of a Hug application using Zappa. * [Zappa Docker Image](https://github.com/danielwhatmuff/zappa) - A Docker image for running Zappa locally, based on Lambda Docker. * [zappa-dashing](https://github.com/nikos/zappa-dashing) - Monitor your AWS environment (health/metrics) with Zappa and CloudWatch. * [s3env](https://github.com/cameronmaske/s3env) - Manipulate a remote Zappa environment variable key/value JSON object file in an S3 bucket through the CLI. * [zappa_resize_image_on_fly](https://github.com/wobeng/zappa_resize_image_on_fly) - Resize images on the fly using Flask, Zappa, Pillow, and OpenCV-python. * [zappa-ffmpeg](https://github.com/ubergarm/zappa-ffmpeg) - Run ffmpeg inside a lambda for serverless transformations. * [gdrive-lambda](https://github.com/richiverse/gdrive-lambda) - pass json data to a csv file for end users who use Gdrive across the organization. * [travis-build-repeat](https://github.com/bcongdon/travis-build-repeat) - Repeat TravisCI builds to avoid stale test results. * [wunderskill-alexa-skill](https://github.com/mcrowson/wunderlist-alexa-skill) - An Alexa skill for adding to a Wunderlist. * [xrayvision](https://github.com/mathom/xrayvision) - Utilities and wrappers for using AWS X-Ray with Zappa. * [terraform-aws-zappa](https://github.com/dpetzold/terraform-aws-zappa) - Terraform modules for creating a VPC, RDS instance, ElastiCache Redis and CloudFront Distribution for use with Zappa. * [zappa-sentry](https://github.com/jneves/zappa-sentry) - Integration with Zappa and Sentry * [IOpipe](https://github.com/iopipe/iopipe-python#zappa) - Monitor, profile and analyze your Zappa apps. ## Hacks Zappa goes quite far beyond what Lambda and API Gateway were ever intended to handle. As a result, there are quite a few hacks in here that allow it to work. Some of those include, but aren't limited to.. * Using VTL to map body, headers, method, params and query strings into JSON, and then turning that into valid WSGI. * Attaching response codes to response bodies, Base64 encoding the whole thing, using that as a regex to route the response code, decoding the body in VTL, and mapping the response body to that. * Packing and _Base58_ encoding multiple cookies into a single cookie because we can only map one kind. * Forcing the case permutations of "Set-Cookie" in order to return multiple headers at the same time. * Turning cookie-setting 301/302 responses into 200 responses with HTML redirects, because we have no way to set headers on redirects. ## Contributing This project is still young, so there is still plenty to be done. Contributions are more than welcome! Please file tickets for discussion before submitting patches. Pull requests should target `master` and should leave Zappa in a "shippable" state if merged. If you are adding a non-trivial amount of new code, please include a functioning test in your PR. For AWS calls, we use the `placebo` library, which you can learn to use [in their README](https://github.com/garnaat/placebo#usage-as-a-decorator). The test suite will be run by [Travis CI](https://travis-ci.org/zappa/Zappa) once you open a pull request. Please include the GitHub issue or pull request URL that has discussion related to your changes as a comment in the code ([example](https://github.com/zappa/Zappa/blob/fae2925431b820eaedf088a632022e4120a29f89/zappa/zappa.py#L241-L243)). This greatly helps for project maintainability, as it allows us to trace back use cases and explain decision making. Similarly, please make sure that you meet all of the requirements listed in the [pull request template](https://raw.githubusercontent.com/zappa/Zappa/master/.github/PULL_REQUEST_TEMPLATE.md). Please feel free to work on any open ticket, especially any ticket marked with the "help-wanted" label. If you get stuck or want to discuss an issue further, please join [our Slack channel](https://zappateam.slack.com/), where you'll find a community of smart and interesting people working dilligently on hard problems. [Zappa Slack Auto Invite](https://slackautoinviter.herokuapp.com) Zappa does not intend to conform to PEP8, isolate your commits so that changes to functionality with changes made by your linter. #### Using a Local Repo To use the git HEAD, you *probably can't* use `pip install -e `. Instead, you should clone the repo to your machine and then `pip install /path/to/zappa/repo` or `ln -s /path/to/zappa/repo/zappa zappa` in your local project. ## Patrons If you or your company uses **Zappa**, please consider giving what you can to support the ongoing development of the project! You can become a patron by **[visiting our Patreon page](https://patreon.com/zappa)**. Zappa is currently supported by these awesome individuals and companies: * Nathan Lawrence * LaunchLab * Sean Paley * Theo Chitayat * George Sibble * Joe Weiss * Nik Bora * Zerong Toby Wang * Gareth E * Matt Jackson * Sean Coates * Alexander Loschilov * Korey Peters * Joe Weiss * Kimmo Parvianen-Jalanko * Patrick Agin * Roberto Martinez * Charles Dimino * Doug Beney * Dan "The Man" Gayle * Juancito * Will Childs-Klein * Efi Merdler Kravitz * **Philippe Trounev** Thank you very, very much! ## Support / Development / Training / Consulting Do you need help with.. * Porting existing Flask and Django applications to Zappa? * Building new applications and services that scale infinitely? * Reducing your operations and hosting costs? * Adding new custom features into Zappa? * Training your team to use AWS and other server-less paradigms? Good news! We're currently available for remote and on-site consulting for small, large and enterprise teams. Please contact with your needs and let's work together!

Made by Gun.io

%prep %autosetup -n zappa-0.56.1 %build %py3_build %install %py3_install install -d -m755 %{buildroot}/%{_pkgdocdir} if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi pushd %{buildroot} if [ -d usr/lib ]; then find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/lib64 ]; then find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/bin ]; then find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/sbin ]; then find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst fi touch doclist.lst if [ -d usr/share/man ]; then find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst fi popd mv %{buildroot}/filelist.lst . mv %{buildroot}/doclist.lst . %files -n python3-zappa -f filelist.lst %dir %{python3_sitelib}/* %files help -f doclist.lst %{_docdir}/* %changelog * Sun Apr 23 2023 Python_Bot - 0.56.1-1 - Package Spec generated