• 关于
• 安装与配置
  • 运行初始设置/设置
• 基本用法
  • 初始部署
  • 更新
    • Docker 工作流程
  • 回滚
  • 调度
    • 高级调度
      • 多重表达
      • 残疾人活动
  • 取消部署
  • 包裹
    • Zappa 如何制作包装
  • 模板
  • 地位
  • 尾矿原木
  • 远程函数调用
  • Django 管理命令
  • SSL认证
    • 使用 AWS Certificate Manager 部署到域
    • 使用 Let's Encrypt 证书部署到域（DNS 身份验证）
    • 使用 Let's Encrypt 证书部署到域（HTTP 身份验证）
    • 使用您自己的 SSL 证书部署到域
• 响应 AWS 事件而执行
• 异步任务执行
  • 捕获异常
  • 任务来源
  • 直接调用
  • 远程调用
  • 限制
  • 在VPC中运行任务
  • 回应
• 高级设置
  • YAML 设置
• 高级用法
  • 保持服务器温暖
    • 提供静态文件/二进制上传服务
  • 启用 CORS
  • 大型项目
  • 启用 Bash 完成
  • 在 API Gateway 上启用安全端点
    • API密钥
    • 身份管理政策
    • API 网关 Lambda 授权者
    • Cognito 用户池授权者
    • API网关资源策略
  • 设置环境变量
    • 本地环境变量
    • 远程AWS环境变量
    • 远程环境变量
    • 远程环境变量（通过 S3 文件）
  • API网关上下文变量
  • 捕获未处理的异常
  • 使用自定义 AWS IAM 角色和策略
    • 用于部署的自定义 AWS IAM 角色和策略
    • 用于执行的自定义 AWS IAM 角色和策略
  • AWS X射线
  • 全球可用的无服务器架构
  • 提高 AWS 服务限制
  • 死信队列
  • 唯一的包裹ID
  • 应用程序负载均衡器事件源
  • 端点配置
    • 私有 API 网关配置示例
  • 冷启动（实验性）
• 扎帕指南
• 扎帕在媒体上
• 使用 Zappa 的网站
• 相关项目
• 黑客
• 贡献
  • 使用本地存储库

匆忙？单击查看（现在有点过时）来自 Serverless SF 的幻灯片！

Zappa使得在 AWS Lambda + API Gateway 上构建和部署无服务器、事件驱动的 Python 应用程序（包括但不限于 WSGI Web 应用程序）变得非常容易。将其视为 Python 应用程序的“无服务器”网络托管。这意味着无限扩展、零停机、零维护- 并且成本仅为当前部署的一小部分！

如果您有一个 Python Web 应用程序（包括 Django 和 Flask 应用程序），则非常简单：

$ pip install zappa
$ zappa init
$ zappa deploy

  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copy js-clipboard-copy-icon">
<path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path>

现在您无需服务器了！哇！

“无服务器”是什么意思？

好吧，所以仍然有一个服务器 - 但它只有40 毫秒的生命周期！在这种情况下，无服务器意味着“没有任何永久性基础设施”。

对于传统的 HTTP 服务器，服务器全天候 (24/7) 在线，一一处理传入的请求。如果传入请求的队列变得太大，某些请求将超时。借助 Zappa， Amazon API Gateway 为每个请求提供了自己的虚拟 HTTP“服务器”。AWS 自动处理水平扩展，因此任何请求都不会超时。然后，每个请求都会从 AWS Lambda 中的内存缓存调用您的应用程序，并通过 Python 的 WSGI 接口返回响应。当你的应用程序返回后，“服务器”就死掉了。

更好的是，使用 Zappa，您只需为您使用的服务器时间的毫秒数付费，因此它比 Linode 或 Heroku 等 VPS/PaaS 主机便宜很多数量级- 而且在大多数情况下，它是完全免费的。另外，无需担心负载平衡或保持服务器再次在线。

它非常适合使用 Flask 和 Bottle 等框架部署无服务器微服务，以及使用 Django 托管更大的 Web 应用程序和 CMS。或者，您可以使用任何您喜欢的 WSGI 兼容应用程序！您可能不需要更改现有的应用程序即可使用它，并且您不会被限制使用它。

Zappa 还允许您构建混合事件驱动的应用程序，每年可以扩展到数万亿个事件，而无需您付出额外的努力！您还可以获得免费的 SSL 证书、全局应用程序部署、API 访问管理、自动安全策略生成、预编译 C 扩展、自动保温、超大 Lambda 包以及许多其他独家功能！

最后，Zappa非常易于使用。您可以使用开箱即用的单个命令来部署您的应用程序！

惊人的！

在开始之前，请确保您运行的是 Python 3.8/3.9/3.10/3.11/3.12，并且拥有有效的 AWS 账户并且AWS 凭证文件已正确安装。

Zappa可以通过 pip 轻松安装，如下所示：

$ pip install zappa

  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copy js-clipboard-copy-icon">
<path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path>

请注意，Zappa必须安装到您项目的虚拟环境中。虚拟环境名称不应与 Zappa 项目名称相同，否则可能会导致错误。

（如果您使用pyenv并且喜欢使用pyenv-virtualenv管理 virtualenv ，您只需调用pyenv local [your_venv_name]它就可以了。Conda用户应该在此处发表评论。）

接下来，您需要定义本地和服务器端设置。

Zappa可以使用以下命令自动为您设置部署设置init：

$ zappa init

  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copy js-clipboard-copy-icon">
<path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path>

这将自动检测您的应用程序类型（Flask/Django - Pyramid 用户请参阅此处）并帮助您定义部署配置设置。完成初始化后，您的项目目录中将有一个名为zappa_settings.json的文件，用于定义基本部署设置。对于大多数 WSGI 应用程序来说，它可能看起来像这样：

{
    // The name of your stage
    "dev": {
        // The name of your S3 bucket
        "s3_bucket": "lambda",
    <span class="pl-c">// The modular python path to your WSGI application function.</span>
    <span class="pl-c">// In Flask and Bottle, this is your 'app' object.</span>
    <span class="pl-c">// Flask (your_module.py):</span>
    <span class="pl-c">// app = Flask()</span>
    <span class="pl-c">// Bottle (your_module.py):</span>
    <span class="pl-c">// app = bottle.default_app()</span>
    <span class="pl-s">"app_function"</span>: <span class="pl-s">"your_module.app"</span>
<span class="pl-kos">}</span>

}

  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copy js-clipboard-copy-icon">
<path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path>

或者对于姜戈：

{
    "dev": { // The name of your stage
       "s3_bucket": "lambda", // The name of your S3 bucket
       "django_settings": "your_project.settings" // The python path to your Django settings.
    }
}

  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copy js-clipboard-copy-icon">
<path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path>

注：如果您是第一次使用 Zappa 部署 Django 应用程序，您可能需要阅读 Edgar Roman 的Django Zappa 指南。

您可以根据需要定义任意多个阶段 - 我们建议有开发、登台和生产阶段。

现在，您已准备好部署！

配置完设置后，您可以使用单个命令打包应用程序并将其部署到名为“生产”的阶段：

$ zappa deploy production
Deploying..
Your application is now live at: https://7k6anj0k99.execute-api.us-east-1.amazonaws.com/production

现在您的应用程序已上线！多么酷啊？！

为了解释发生了什么，当您调用 时deploy，Zappa 会自动将您的应用程序和本地虚拟环境打包到 Lambda 兼容的存档中，将任何依赖项替换为与 lambda 兼容的轮子版本，设置函数处理程序和必要的 WSGI 中间件，上传将存档保存到 S3，创建和管理必要的 Amazon IAM 策略和角色，将其注册为新的 Lambda 函数，创建新的 API 网关资源，为其创建 WSGI 兼容的路由，将其链接到新的 Lambda 函数，最后删除S3 存储桶中的存档。便利！

请注意，为执行 Lambda 创建的默认 IAM 角色和策略应用一组自由的权限。这些很可能不适合重要应用程序的生产部署。有关更多详细信息，请参阅用于执行的自定义 AWS IAM 角色和策略部分 。

如果您的应用程序已经部署，您只需要上传新的Python代码，而不需要触及底层路由，您可以简单地：

$ zappa update production
Updating..
Your application is now live at: https://7k6anj0k99.execute-api.us-east-1.amazonaws.com/production

这会创建一个新存档，将其上传到 S3 并更新 Lambda 函数以使用新代码，但不会触及 API 网关路由。

在0.53.0版本中中，添加了使用 Docker 部署和更新 Lambda 函数的支持。

--docker-image-uri您可以使用zappa 命令的选项来deploy指定ECR 映像update。Zappa 期望构建镜像并将其推送到 Amazon ECR 存储库。

部署示例：

$ zappa deploy --docker-image-uri {AWS ACCOUNT ID}.dkr.ecr.{REGION}.amazonaws.com/{REPOSITORY NAME}:latest

  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copy js-clipboard-copy-icon">
<path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path>

更新示例：

$ zappa update --docker-image-uri {AWS ACCOUNT ID}.dkr.ecr.{REGION}.amazonaws.com/{REPOSITORY NAME}:latest

  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copy js-clipboard-copy-icon">
<path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path>

参考博文了解有关如何利用此功能以及何时需要的更多详细信息。

如果您为 Lambda 运行时使用自定义 Docker 映像（例如，如果您想要使用 Lambda 开箱即用尚不支持的较新版本的 Python）并且您想绕过 Python 版本检查，则可以设置一个环境变量来执行此操作：

$ export ZAPPA_RUNNING_IN_DOCKER=True

  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copy js-clipboard-copy-icon">
<path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path>

您还可以将其添加到您的 Dockerfile 中，如下所示：

ENV ZAPPA_RUNNING_IN_DOCKER=True

  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copy js-clipboard-copy-icon">
<path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path>

您还可以rollback通过提供要返回的修订数量来将部署的代码恢复到先前版本。例如，要回滚到 3 个版本之前部署的版本：

$ zappa rollback production -n 3

  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copy js-clipboard-copy-icon">
<path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path>

Zappa 可用于轻松安排定期发生的功能。这提供了比 Celery 更好、免维护的替代品！这些函数将与您一起打包和部署，app_function并自动从处理程序中调用。只需在zappa_settings.json文件中列出您的函数和表达式，以使用cron 或rate 语法来安排它们：

{
    "production": {
       ...
       "events": [{
           "function": "your_module.your_function", // The function to execute
           "expression": "rate(1 minute)" // When to execute it (in cron or rate format)
       }],
       ...
    }
}

进而：

$ zappa schedule production

现在你的函数将每分钟执行一次！

如果你想取消这些，你可以简单地使用unschedule命令：

$ zappa unschedule production

现在您的预定活动规则已被删除。

请参阅示例了解更多详细信息。

有时，一个函数需要多个表达式来描述其调度。要设置多个表达式，只需在zappa_settings.json文件中列出您的函数以及使用cron 或rate 语法来调度它们的表达式列表：

{
    "production": {
       ...
       "events": [{
           "function": "your_module.your_function", // The function to execute
           "expressions": ["cron(0 20-23 ? * SUN-THU *)", "cron(0 0-8 ? * MON-FRI *)"] // When to execute it (in cron or rate format)
       }],
       ...
    }
}

这可用于处理因 UTC 时区在您当地时区的工作时间内跨越午夜而引起的问题。

应该注意的是，重叠表达式不会引发警告，并且应该进行检查，以防止重复触发函数。

有时应该安排某个事件，但将其禁用。例如，也许一个事件应该只在生产环境中运行，而不是在沙箱中运行。您可能仍希望将其部署到沙箱，以确保在部署到生产之前您的表达式没有问题。

在这种情况下，您可以通过在事件定义中设置enabled为来禁用它运行：false

{
    "sandbox": {
       ...
       "events": [{
           "function": "your_module.your_function", // The function to execute
           "expression": "rate(1 minute)", // When to execute it (in cron or rate format)
           "enabled": false
       }],
       ...
    }
}

如果您需要删除之前发布的 API Gateway 和 Lambda 函数，您可以简单地：

$ zappa undeploy production

在执行之前，系统会要求您进行确认。

如果您为 API Gateway 服务启用了 CloudWatch Logs 并且不想保留这些日志，则可以指定参数--remove-logs来清除 API Gateway 和 Lambda 函数的日志：

$ zappa undeploy production --remove-logs

如果您想构建应用程序包而不实际将其上传并注册为 Lambda 函数，则可以使用以下package命令：

$ zappa package production

如果您zip的设置中有回调callbacks，它也会被调用。

{
    "production": { // The name of your stage
        "callbacks": {
            "zip": "my_app.zip_callback"// After creating the package
        }
    }
}

您还可以使用以下命令指定包的输出文件名-o：

$ zappa package production -o my_awesome_package.zip

Zappa 会自动将您的活动虚拟环境打包成可在 AWS Lambda 上顺利运行的包。

在此过程中，它将用 AWS Lambda 兼容版本替换任何本地依赖项。依赖项包含在此顺序中：

• manylinux来自本地缓存的Lambda 兼容轮子
• manylinuxPyPI 的Lambda 兼容轮
• 来自活动虚拟环境的包
• 来自本地项目目录的包

它还会跳过某些不必要的文件，并忽略任何 .py 文件（如果 .pyc 文件可用）。

此外，Zappa 还将自动设置正确的执行权限、配置包设置，并创建唯一的、可审核的包清单文件。

要进一步减小最终包文件的大小，您可以：

• 设置slim_handler为True将一个小处理程序上传到 Lambda，并将包的其余部分上传到 S3。有关更多详细信息，请参阅合并的拉取请求和原始问题中的讨论。另请参阅：大型项目。
• 使用exclude或exclude_glob设置并提供要从存档中排除的模式列表。默认情况下，Zappa 将排除 Boto，因为它已经在 Lambda 执行环境中可用。

与 类似package，如果您只需要 API Gateway CloudFormation 模板，请使用以下template命令：

$ zappa template production --l your-lambda-arn -r your-role-arn

请注意，在这种情况下，您必须提供自己的 Lambda ARN 和角色 ARN，因为它们可能不是为您创建的。

您可以使用 直接获取 JSON 输出--json，并使用 指定输出文件--output。

如果您需要查看部署和事件计划的状态，只需使用该status命令即可。

$ zappa status production

您可以通过调用管理命令来查看部署的日志tail。

$ zappa tail production

默认情况下，这将显示所有日志项。除了 HTTP 和其他事件之外，任何print已编辑stdout或stderr将显示在日志中的内容。

您可以使用该参数--http来过滤 HTTP 请求，该请求将采用 Apache 通用日志格式。

$ zappa tail production --http

同样，您可以执行相反的操作，仅显示非 HTTP 事件和日志消息：

$ zappa tail production --non-http

如果您不喜欢默认的日志颜色，可以使用 关闭它们--no-color。

您还可以使用 限制尾部的长度--since，它接受一个简单的持续时间字符串：

$ zappa tail production --since 4h # 4 hours
$ zappa tail production --since 1m # 1 minute
$ zappa tail production --since 1mm # 1 month

您可以使用 过滤掉日志的内容--filter，如下所示：

$ zappa tail production --http --filter "POST" # Only show POST HTTP requests

请注意，这使用CloudWatch Logs 过滤器语法。

要尾随日志而不跟随（在显示所请求日志的末尾后立即退出），请传递--disable-keep-open：

$ zappa tail production --since 1h --disable-keep-open

您可以随时使用该invoke命令直接执行应用程序中的任何功能。

例如，假设您在名为“my_app.py”的文件中有一个基本应用程序，并且您想要调用其中名为“my_function”的函数。部署应用程序后，您可以随时通过调用以下命令来调用该函数：

$ zappa invoke production my_app.my_function

所做的任何远程打印语句以及函数返回的值都将被打印到本地控制台。漂亮！

您还可以使用 直接调用可解释的 Python 3.8/3.9/3.10/3.11/3.12 字符串--raw，如下所示：

$ zappa invoke production "print(1 + 2 + 3)" --raw

例如，如果您想superuser在 VPC 中运行的 RDS 数据库（例如 Serverless Aurora）上创建第一个数据库，它会派上用场： $ zappa invoke staging "from django.contrib.auth import get_user_model; User = get_user_model(); User .objects.create_superuser('用户名', '电子邮件', '密码')" --raw

为了方便起见，Zappa 还可以使用该命令调用远程 Django 'manage.py' 命令manage。例如，要执行基本的 Django 状态检查：

$ zappa manage production showmigrations admin

显然，这只适用于正确定义设置的 Django 项目。

对于有自己的参数的命令，您还可以将命令作为字符串传递，如下所示：

$ zappa manage production "shell --version"

需要用户直接输入的命令（例如createsuperuser）应替换为使用 的命令zappa invoke <env> --raw。

有关 Django 集成的更多信息，请查看zappa-django-utils项目。

可以使用自定义 SSL 证书、Let's Encrypt 证书和AWS Certificate Manager (ACM) 证书将 Zappa 部署到自定义域名和子域。

目前，其中最容易使用的是 AWS Certificate Manager 证书，因为它们是免费的、自我更新的，并且需要的工作量最少。

如下所述配置后，所有这些方法都使用相同的命令：

$ zappa certify

从 CI/CD 系统部署时，您可以使用：

$ zappa certify --yes

跳过确认提示。

Amazon 提供了自己的 Let's Encrypt 的免费替代方案，称为AWS Certificate Manager (ACM)。要通过 Zappa 使用此服务：

1. 在 AWS Certificate Manager 控制台中验证您的域。
2. 在控制台中，选择弗吉尼亚北部 (us-east-1) 区域并为您的域或子域请求证书 ( sub.yourdomain.tld)，或请求通配符域 ( *.yourdomain.tld)。
3. 复制该证书的整个 ARN 并将其放置在 Zappa 设置中certificate_arn。
4. 在设置中设置您想要的域名domain。
5. 调用$ zappa certify以使用该证书创建并关联 API Gateway 分配。

如果您想在具有免费 Let's Encrypt 证书并使用基于 Route 53 的 DNS 身份验证的域上使用 Zappa，您可以按照此便捷指南进行操作。

如果您想在具有使用 HTTP 身份验证的免费 Let's Encrypt 证书的域上使用 Zappa，您可以按照本指南进行操作。

但是，现在使用基于 Route 53 的 DNS 身份验证要容易得多，这将允许您通过单个命令使用 Let's Encrypt 证书$ zappa certify。

1. 第一步是创建自定义域并获取您的 SSL 证书/密钥/捆绑包。
2. 确保您已domain在 Zappa 设置 JSON 中设置该设置 - 这将避免自定义域和 API 调用 URL 之间的基本路径映射出现问题，该 URL 会在 URI 中附加阶段名称
3. 将 SSL 证书/密钥/包的路径分别添加到 Zappa 设置 JSON 中的certificate、certificate_key和设置certificate_chain
4. 设置route53_enabled_false如果您计划使用自己的 DNS 提供商而不是 AWS Route53 托管区域，
5. 使用 Zappa 部署或更新您的应用程序
6. 运行$ zappa certify以上传您的证书并向您的 API 网关注册自定义域名。

同样，您可以执行函数来响应 AWS 生态系统中发生的事件，例如 S3 上传、DynamoDB 条目、Kinesis 流、SNS 消息和 SQS 队列。

在您的zappa_settings.json文件中，定义您的事件源和您希望执行的函数。例如，这将your_module.process_upload_function响应my-bucketS3 存储桶中的新对象而执行。注意process_upload_function必须接受event和context参数。

{
    "production": {
       ...
       "events": [{
            "function": "your_module.process_upload_function",
            "event_source": {
                  "arn":  "arn:aws:s3:::my-bucket",
                  "events": [
                    "s3:ObjectCreated:*" // Supported event types: http://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html#supported-notification-event-types
                  ],
                  "key_filters": [{ // optional
                    "type": "suffix",
                    "value": "yourfile.json"
                  },
                  {
                    "type": "prefix",
                    "value": "prefix/for/your/object"
                  }]
               }
            }],
       ...
    }
}

进而：

$ zappa schedule production

现在，每次新上传的内容出现在您的存储桶中时，您的函数都会执行！

要访问应用程序上下文中的密钥信息，您需要process_upload_function如下所示：

import boto3
s3_client = boto3.client('s3')
def process_upload_function(event, context):
"""
    Process a file upload.
    """
<span class="pl-c"># Get the uploaded file's information</span>
<span class="pl-s1">bucket</span> <span class="pl-c1">=</span> <span class="pl-s1">event</span>[<span class="pl-s">'Records'</span>][<span class="pl-c1">0</span>][<span class="pl-s">'s3'</span>][<span class="pl-s">'bucket'</span>][<span class="pl-s">'name'</span>] <span class="pl-c"># Will be `my-bucket`</span>
<span class="pl-s1">key</span> <span class="pl-c1">=</span> <span class="pl-s1">event</span>[<span class="pl-s">'Records'</span>][<span class="pl-c1">0</span>][<span class="pl-s">'s3'</span>][<span class="pl-s">'object'</span>][<span class="pl-s">'key'</span>] <span class="pl-c"># Will be the file path of whatever file was uploaded.</span>

<span class="pl-c"># Get the bytes from S3</span>
<span class="pl-s1">s3_client</span>.<span class="pl-en">download_file</span>(<span class="pl-s1">bucket</span>, <span class="pl-s1">key</span>, <span class="pl-s">'/tmp/'</span> <span class="pl-c1">+</span> <span class="pl-s1">key</span>) <span class="pl-c"># Download this file to writable tmp space.</span>
<span class="pl-s1">file_bytes</span> <span class="pl-c1">=</span> <span class="pl-en">open</span>(<span class="pl-s">'/tmp/'</span> <span class="pl-c1">+</span> <span class="pl-s1">key</span>).<span class="pl-en">read</span>()</pre><div class="zeroclipboard-container">
<clipboard-copy aria-label="Copy" class="ClipboardButton btn btn-invisible js-clipboard-copy m-2 p-0 tooltipped-no-delay d-flex flex-justify-center flex-items-center" data-copy-feedback="Copied!" data-tooltip-direction="w" value="import boto3

s3_client = boto3.client('s3')
def process_upload_function(event, context):
"""
Process a file upload.
"""
# Get the uploaded file's information
bucket = event['Records'][0]['s3']['bucket']['name'] # Will be `my-bucket`
key = event['Records'][0]['s3']['object']['key'] # Will be the file path of whatever file was uploaded.

# Get the bytes from S3
s3_client.download_file(bucket, key, '/tmp/' + key) # Download this file to writable tmp space.
file_bytes = open('/tmp/' + key).read()" tabindex="0" role="button">
  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copy js-clipboard-copy-icon">
<path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path>


      
    

    
  

        "events": [
            {
                "function": "your_module.your_function",
                "event_source": {
                    "arn":  "arn:aws:sns:::your-event-topic-arn",
                    "events": [
                        "sns:Publish"
                    ]
                }
            }
        ]

        "events": [
            {
                "function": "your_module.your_function",
                "event_source": {
                    "arn":  "arn:aws:sns:::your-event-topic-arn",
                    "filters": {
                        "interests": ["python", "aws", "zappa"],
                        "version": ["1.0"]
                    },
                    ...
                }
            }
        ]

       "events": [
           {
               "function": "replication.replicate_records",
               "event_source": {
                    "arn":  "arn:aws:dynamodb:us-east-1:1234554:table/YourTable/stream/2016-05-11T00:00:00.000",
                    "starting_position": "TRIM_HORIZON", // Supported values: TRIM_HORIZON, LATEST
                    "batch_size": 50, // Max: 1000
                    "enabled": true // Default is false
               }
           }
       ]

       "events": [
           {
               "function": "your_module.process_messages",
               "event_source": {
                    "arn":  "arn:aws:sqs:us-east-1:12341234:your-queue-name-arn",
                    "batch_size": 10, // Max: 10. Use 1 to trigger immediate processing
                    "enabled": true // Default is false
               }
           }
       ]

  <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copy js-clipboard-copy-icon">
<path d="M0 6.75C0 5.784.784 5 1.75 5h1.5a.75.75 0 0 1 0 1.5h-1.5a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-1.5a.75.75 0 0 1 1.5 0v1.5A1.75 1.75 0 0 1 9.25 16h-7.5A1.75 1.75 0 0 1 0 14.25Z"></path><path d="M5 1.75C5 .784 5.784 0 6.75 0h7.5C15.216 0 16 .784 16 1.75v7.5A1.75 1.75 0 0 1 14.25 11h-7.5A1.75 1.75 0 0 1 5 9.25Zm1.75-.25a.25.25 0 0 0-.25.25v7.5c0 .138.112.25.25.25h7.5a.25.25 0 0 0 .25-.25v-7.5a.25.25 0 0 0-.25-.25Z"></path>

    "bot_events": [
        {
            "function": "lexbot.handlers.book_appointment.handler",
            "event_source": {
                "arn": "arn:aws:lex:us-east-1:01234123123:intent:TestLexEventNames:$LATEST", // optional. In future it will be used to configure the intent
                "intent":"intentName", // name of the bot event configured
                "invocation_source":"DialogCodeHook", // either FulfillmentCodeHook or DialogCodeHook
            }
        }
    ]

       "events": [
            {
                "function": "your_module.your_recurring_function", // The function to execute
                "kwargs": {"key": "val", "key2": "val2"},  // Keyword arguments to pass. These are available in the event
                "expression": "rate(1 minute)" // When to execute it (in cron or rate format)
            }
       ]

def your_recurring_function(event, context):
    my_kwargs = event.get("kwargs")  # dict of kwargs given in zappa_settings file

from flask import Flask
from zappa.asynchronous import task
app = Flask(__name__)
@task
def make_pie():
""" This takes a long time! """
ingredients = get_ingredients()
pie = bake(ingredients)
deliver(pie)
@app.route('/api/order/pie')
def order_pie():
""" This returns immediately! """
make_pie()
return "Your pie is being made!"

@task
def make_pie():
    try:
        ingredients = get_ingredients()
        pie = bake(ingredients)
        deliver(pie)
    except Fault as error:
        """send an email"""
    ...
    return Response('Web services down', status=503)

@task
def make_pie():
    try:
        """code block"""
    except Fault as error:
        """send an email"""
    ...
    return {} #or return True

from zappa.asynchronous import task_sns
@task_sns

{
  "dev": {
    ..
      "async_source": "sns", // Source of async tasks. Defaults to "lambda"
      "async_resources": true, // Create the SNS topic to use. Defaults to true.
    ..
    }
}

from zappa.asynchronous import run
run(your_function, args, kwargs) # Using Lambda
run(your_function, args, kwargs, service='sns') # Using SNS

@task(remote_aws_lambda_function_name='pizza-pie-prod', remote_aws_region='us-east-1')
def make_pie():
   """ This takes a long time! """
   ingredients = get_ingredients()
   pie = bake(ingredients)
   deliver(pie)

from zappa.asynchronous import task, get_async_response
from flask import Flask, make_response, abort, url_for, redirect, request, jsonify
from time import sleep
app = Flask(name)
@app.route('/payload')
def payload():
delay = request.args.get('delay', 60)
x = longrunner(delay)
return redirect(url_for('response', response_id=x.response_id))
@app.route('/async-response/<response_id>')
def response(response_id):
response = get_async_response(response_id)
if response is None:
abort(404)
<span class="pl-k">if</span> <span class="pl-s1">response</span>[<span class="pl-s">'status'</span>] <span class="pl-c1">==</span> <span class="pl-s">'complete'</span>:
    <span class="pl-k">return</span> <span class="pl-en">jsonify</span>(<span class="pl-s1">response</span>[<span class="pl-s">'response'</span>])

<span class="pl-en">sleep</span>(<span class="pl-c1">5</span>)

<span class="pl-k">return</span> <span class="pl-s">"Not yet ready. Redirecting."</span>, <span class="pl-c1">302</span>, {
    <span class="pl-s">'Content-Type'</span>: <span class="pl-s">'text/plain; charset=utf-8'</span>,
    <span class="pl-s">'Location'</span>: <span class="pl-en">url_for</span>(<span class="pl-s">'response'</span>, <span class="pl-s1">response_id</span><span class="pl-c1">=</span><span class="pl-s1">response_id</span>, <span class="pl-s1">backoff</span><span class="pl-c1">=</span><span class="pl-c1">5</span>),
    <span class="pl-s">'X-redirect-reason'</span>: <span class="pl-s">"Not yet ready."</span>,
}

@task(capture_response=True)
def longrunner(delay):
sleep(float(delay))
return {'MESSAGE': "It took {} seconds to generate this.".format(delay)}

if response['status'] == 'complete':
    return jsonify(response['response'])

sleep(5)

return "Not yet ready. Redirecting.", 302, {
    'Content-Type': 'text/plain; charset=utf-8',
    'Location': url_for('response', response_id=response_id, backoff=5),
    'X-redirect-reason': "Not yet ready.",
}

 {
    "dev": {
        "additional_text_mimetypes": [], // allows you to provide additional mimetypes to be handled as text when binary_support is true.
        "alb_enabled": false, // enable provisioning of application load balancing resources. If set to true, you _must_ fill out the alb_vpc_config option as well.
        "alb_vpc_config": {
            "CertificateArn": "your_acm_certificate_arn", // ACM certificate ARN for ALB
            "SubnetIds": [], // list of subnets for ALB
            "SecurityGroupIds": [] // list of security groups for ALB
        },
        "api_key_required": false, // enable securing API Gateway endpoints with x-api-key header (default False)
        "api_key": "your_api_key_id", // optional, use an existing API key. The option "api_key_required" must be true to apply
        "apigateway_enabled": true, // Set to false if you don't want to create an API Gateway resource. Default true.
        "apigateway_description": "My funky application!", // Define a custom description for the API Gateway console. Default None.
        "assume_policy": "my_assume_policy.json", // optional, IAM assume policy JSON file
        "attach_policy": "my_attach_policy.json", // optional, IAM attach policy JSON file
        "apigateway_policy": "my_apigateway_policy.json", // optional, API Gateway resource policy JSON file
        "async_source": "sns", // Source of async tasks. Defaults to "lambda"
        "async_resources": true, // Create the SNS topic and DynamoDB table to use. Defaults to true.
        "async_response_table": "your_dynamodb_table_name",  // the DynamoDB table name to use for captured async responses; defaults to None (can't capture)
        "async_response_table_read_capacity": 1,  // DynamoDB table read capacity; defaults to 1
        "async_response_table_write_capacity": 1,  // DynamoDB table write capacity; defaults to 1
        "aws_endpoint_urls": { "aws_service_name": "endpoint_url" }, // a dictionary of endpoint_urls that emulate the appropriate service.  Usually used for testing, for instance with `localstack`.
        "aws_environment_variables" : {"your_key": "your_value"}, // A dictionary of environment variables that will be available to your deployed app via AWS Lambdas native environment variables. See also "environment_variables" and "remote_env" . Default {}.
        "aws_kms_key_arn": "your_aws_kms_key_arn", // Your AWS KMS Key ARN
        "aws_region": "aws-region-name", // optional, uses region set in profile or environment variables if not set here,
        "binary_support": true, // Enable automatic MIME-type based response encoding through API Gateway. Default true.
        "callbacks": { // Call custom functions during the local Zappa deployment/update process
            "settings": "my_app.settings_callback", // After loading the settings
            "zip": "my_app.zip_callback", // After creating the package
            "post": "my_app.post_callback", // After command has executed
        },
        "cache_cluster_enabled": false, // Use APIGW cache cluster (default False)
        "cache_cluster_size": 0.5, // APIGW Cache Cluster size (default 0.5)
        "cache_cluster_ttl": 300, // APIGW Cache Cluster time-to-live (default 300)
        "cache_cluster_encrypted": false, // Whether or not APIGW Cache Cluster encrypts data (default False)
        "certificate": "my_cert.crt", // SSL certificate file location. Used to manually certify a custom domain
        "certificate_key": "my_key.key", // SSL key file location. Used to manually certify a custom domain
        "certificate_chain": "my_cert_chain.pem", // SSL certificate chain file location. Used to manually certify a custom domain
        "certificate_arn": "arn:aws:acm:us-east-1:1234512345:certificate/aaaa-bbb-cccc-dddd", // ACM certificate ARN (needs to be in us-east-1 region).
        "cloudwatch_log_level": "OFF", // Enables/configures a level of logging for the given staging. Available options: "OFF", "INFO", "ERROR", default "OFF".
        "cloudwatch_data_trace": false, // Logs all data about received events. Default false.
        "cloudwatch_metrics_enabled": false, // Additional metrics for the API Gateway. Default false.
        "cognito": { // for Cognito event triggers
            "user_pool": "user-pool-id", // User pool ID from AWS Cognito
            "triggers": [{
                "source": "PreSignUp_SignUp", // triggerSource from http://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html#cognito-user-pools-lambda-trigger-syntax-pre-signup
                "function": "my_app.pre_signup_function"
            }]
        },
        "context_header_mappings": { "HTTP_header_name": "API_Gateway_context_variable" }, // A dictionary mapping HTTP header names to API Gateway context variables
        "cors": false, // Enable Cross-Origin Resource Sharing. Default false. If true, simulates the "Enable CORS" button on the API Gateway console. Can also be a dictionary specifying lists of "allowed_headers", "allowed_methods", and string of "allowed_origin"
        "dead_letter_arn": "arn:aws:<sns/sqs>:::my-topic/queue", // Optional Dead Letter configuration for when Lambda async invoke fails thrice
        "debug": true, // Print Zappa configuration errors tracebacks in the 500. Default true.
        "delete_local_zip": true, // Delete the local zip archive after code updates. Default true.
        "delete_s3_zip": true, // Delete the s3 zip archive. Default true.
        "django_settings": "your_project.production_settings", // The modular path to your Django project's settings. For Django projects only.
        "domain": "yourapp.yourdomain.com", // Required if you're using a domain
        "base_path": "your-base-path", // Optional base path for API gateway custom domain base path mapping. Default None. Not supported for use with Application Load Balancer event sources.
        "environment_variables": {"your_key": "your_value"}, // A dictionary of environment variables that will be available to your deployed app. See also "remote_env" and "aws_environment_variables". Default {}.
        "events": [
            {   // Recurring events
                "function": "your_module.your_recurring_function", // The function to execute (Pattern: [._A-Za-z0-9]+).
                "expression": "rate(1 minute)" // When to execute it (in cron or rate format)
            },
            {   // AWS Reactive events
                "function": "your_module.your_reactive_function", // The function to execute (Pattern: [._A-Za-z0-9]+).
                "event_source": {
                    "arn":  "arn:aws:s3:::my-bucket", // The ARN of this event source
                    "events": [
                        "s3:ObjectCreated:*" // The specific event to execute in response to.
                    ]
                }
            }
        ],
        "endpoint_configuration": ["EDGE", "REGIONAL", "PRIVATE"],  // Specify APIGateway endpoint None (default) or list `EDGE`, `REGION`, `PRIVATE`
        "exception_handler": "your_module.report_exception", // function that will be invoked in case Zappa sees an unhandled exception raised from your code
        "exclude": ["file.gz", "tests"], // A list of filename patterns to exclude from the archive (see `fnmatch` module for patterns).
        "exclude_glob": ["*.gz", "*.rar", "tests/**/*"], // A list of glob patterns to exclude from the archive. To exclude boto3 and botocore (available in an older version on Lambda), add "boto3*" and "botocore*".
        "extends": "stage_name", // Duplicate and extend another stage's settings. For example, `dev-asia` could extend from `dev-common` with a different `s3_bucket` value.
        "extra_permissions": [{ // Attach any extra permissions to this policy. Default None
            "Effect": "Allow",
            "Action": ["rekognition:*"], // AWS Service ARN
            "Resource": "*"
        }],
        "iam_authorization": false, // optional, use IAM to require request signing. Default false. Note that enabling this will override the authorizer configuration.
        "include": ["your_special_library_to_load_at_handler_init"], // load special libraries into PYTHONPATH at handler init that certain modules cannot find on path
        "authorizer": {
            "function": "your_module.your_auth_function", // Local function to run for token validation. For more information about the function see below.
            "arn": "arn:aws:lambda:<region>:<account_id>:function:<function_name>", // Existing Lambda function to run for token validation.
            "result_ttl": 300, // Optional. Default 300. The time-to-live (TTL) period, in seconds, that specifies how long API Gateway caches authorizer results. Currently, the maximum TTL value is 3600 seconds.
            "token_header": "Authorization", // Optional. Default 'Authorization'. The name of a custom authorization header containing the token that clients submit as part of their requests.
            "validation_expression": "^Bearer \\w+$", // Optional. A validation expression for the incoming token, specify a regular expression.
        },
        "keep_warm": true, // Create CloudWatch events to keep the server warm. Default true. To remove, set to false and then `unschedule`.
        "keep_warm_expression": "rate(4 minutes)", // How often to execute the keep-warm, in cron and rate format. Default 4 minutes.
        "lambda_description": "Your Description", // However you want to describe your project for the AWS console. Default "Zappa Deployment".
        "lambda_handler": "your_custom_handler", // The name of Lambda handler. Default: handler.lambda_handler
        "layers": ["arn:aws:lambda:<region>:<account_id>:layer:<layer_name>:<layer_version>"], // optional lambda layers
        "lambda_concurrency": 10, // Sets the maximum number of simultaneous executions for a function, and reserves capacity for that concurrency level. Default is None.
        "lets_encrypt_key": "s3://your-bucket/account.key", // Let's Encrypt account key path. Can either be an S3 path or a local file path.
        "log_level": "DEBUG", // Set the Zappa log level. Can be one of CRITICAL, ERROR, WARNING, INFO and DEBUG. Default: DEBUG
        "manage_roles": true, // Have Zappa automatically create and define IAM execution roles and policies. Default true. If false, you must define your own IAM Role and role_name setting.
        "memory_size": 512, // Lambda function memory in MB. Default 512.
        "ephemeral_storage": { "Size": 512 }, // Lambda function ephemeral_storage size in MB, Default 512, Max 10240
        "num_retained_versions":null, // Indicates the number of old versions to retain for the lambda. If absent, keeps all the versions of the function.
        "payload_compression": true, // Whether or not to enable API gateway payload compression (default: true)
        "payload_minimum_compression_size": 0, // The threshold size (in bytes) below which payload compression will not be applied (default: 0)
        "prebuild_script": "your_module.your_function", // Function to execute before uploading code
        "profile_name": "your-profile-name", // AWS profile credentials to use. Default 'default'. Removing this setting will use the AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables instead.
        "project_name": "MyProject", // The name of the project as it appears on AWS. Defaults to a slugified `pwd`.
        "remote_env": "s3://my-project-config-files/filename.json", // optional file in s3 bucket containing a flat json object which will be used to set custom environment variables.
        "role_name": "MyLambdaRole", // Name of Zappa execution role. Default <project_name>-<env>-ZappaExecutionRole. To use a different, pre-existing policy, you must also set manage_roles to false.
        "role_arn": "arn:aws:iam::12345:role/app-ZappaLambdaExecutionRole", // ARN of Zappa execution role. Default to None. To use a different, pre-existing policy, you must also set manage_roles to false. This overrides role_name. Use with temporary credentials via GetFederationToken.
        "route53_enabled": true, // Have Zappa update your Route53 Hosted Zones when certifying with a custom domain. Default true.
        "runtime": "python3.12", // Python runtime to use on Lambda. Can be one of: "python3.8", "python3.9", "python3.10", "python3.11", or "python3.12". Defaults to whatever the current Python being used is.
        "s3_bucket": "dev-bucket", // Zappa zip bucket,
        "slim_handler": false, // Useful if project >50M. Set true to just upload a small handler to Lambda and load actual project from S3 at runtime. Default false.
        "settings_file": "~/Projects/MyApp/settings/dev_settings.py", // Server side settings file location,
        "tags": { // Attach additional tags to AWS Resources
            "Key": "Value",  // Example Key and value
            "Key2": "Value2",
            },
        "timeout_seconds": 30, // Maximum lifespan for the Lambda function (default 30, max 900.)
        "touch": true, // GET the production URL upon initial deployment (default True)
        "touch_path": "/", // The endpoint path to GET when checking the initial deployment (default "/")
        "use_precompiled_packages": true, // If possible, use C-extension packages which have been pre-compiled for AWS Lambda. Default true.
        "vpc_config": { // Optional Virtual Private Cloud (VPC) configuration for Lambda function
            "SubnetIds": [ "subnet-12345678" ], // Note: not all availability zones support Lambda!
            "SecurityGroupIds": [ "sg-12345678" ]
        },
        "xray_tracing": false // Optional, enable AWS X-Ray tracing on your lambda function.
    }
}

---
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:*

[dev]
  app_function = "your_module.your_app"
  s3_bucket = "your-code-bucket"

  eval "$(register-python-argcomplete zappa)"

  context_header_mappings:
    user_id: authorizer.user_id

from flask import request
@route('/hello')
def hello_world:
print(request.headers.get('user_id'))

{
    "authorizer": {
        "type": "COGNITO_USER_POOLS",
        "provider_arns": [
            "arn:aws:cognito-idp:{region}:{account_id}:userpool/{user_pool_id}"
        ]
    }
}

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": "*",
            "Action": "execute-api:Invoke",
            "Resource": "execute-api:/*",
            "Condition": {
                "IpAddress": {
                    "aws:SourceIp": [
                        "1.2.3.4/32"
                    ]
                }
            }
        }
    ]
}

{
    "dev": {
        ...
        "environment_variables": {
            "your_key": "your_value"
        }
    },
    ...
}

import os
your_value = os.environ.get('your_key')

import json
import os
if os.environ.get('AWS_LAMBDA_FUNCTION_NAME') is None: # Ensures app is NOT running on Lambda
json_data = open('zappa_settings.json')
env_vars = json.load(json_data)['dev']['environment_variables']
os.environ.update(env_vars)

{
    "DB_CONNECTION_STRING": "super-secret:database"
}

{
    "dev": {
        ...
        "remote_env": "s3://my-config-bucket/super-secret-config.json",
    },
    ...
}

import os
db_string = os.environ.get('DB_CONNECTION_STRING')

{
    "dev": {
        ...
        "context_header_mappings": {
            "HTTP_header_name": "API_Gateway_context_variable"
        }
    },
    ...
}

{
    "dev": {
        ...
        "context_header_mappings": {
            "CognitoIdentityId": "identity.cognitoIdentityId",
            "APIStage": "stage"
        }
    },
    ...
}

{
    "dev": {
        ...
        "exception_handler": "your_module.unhandled_exceptions",
    },
    ...
}

def unhandled_exceptions(e, event, context):
    send_to_raygun(e, event)  # gather data you need and send
    return True # Prevent invocation retry

{
    "dev": {
        ...
        "manage_roles": false, // Disable Zappa client managing roles.
        "role_name": "MyLambdaRole", // Name of your Zappa execution role. Optional, default: <project_name>-<env>-ZappaExecutionRole.
        "role_arn": "arn:aws:iam::12345:role/app-ZappaLambdaExecutionRole", // ARN of your Zappa execution role. Optional.
        ...
    },
    ...
}

{
    "dev": {
        ...
        "extra_permissions": [{ // Attach any extra permissions to this policy.
            "Effect": "Allow",
            "Action": ["rekognition:*"], // AWS Service ARN
            "Resource": "*"
        }]
    },
    ...
}

{
    "dev": {
        ...
        "xray_tracing": true
    },
    ...
}

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'

{
  "build_platform": "darwin",
  "build_user": "frank",
  "build_time": "1509732511",
  "uuid": "9c2df9e6-30f4-4c0a-ac4d-4ecb51831a74"
}

{
    "dev": {
        ...
        "endpoint_configuration": ["PRIVATE"],
        "apigateway_policy": "apigateway_resource_policy.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:/*"
        }
    ]
}