GitHubじゃ!Pythonじゃ!

GitHubからPython関係の優良リポジトリを探したかったのじゃー、でも英語は出来ないから日本語で読むのじゃー、英語社会世知辛いのじゃー

Miserlou

Zappa – サーバーレスPython

投稿日:

サーバーレスPython https://blog.zappa.io/

Zappa – Serverless Python

急いで? クリックすると、Serverless SFのスライドが表示されます。

Zappaを使用すると、AWS Lambda + API Gateway上で、サーバーレスのイベントドリブンのPythonアプリケーション(WSGI Webアプリケーションを含むがこれに限定されない)を構築および展開するのが非常に簡単になります。 あなたのPythonアプリケーションのための “サーバレス” Webホスティングと考えてください。 これは、 無制限のスケーリング停止時間 ゼロ、メンテナンスゼロ 、現在の展開コストのほんの一部であることを意味します。

Python Webアプリケーション(DjangoやFlaskアプリケーションを含む)があれば簡単です:

$ pip install zappa
$ zappa init
$ zappa deploy

今はサーバーレスです! うわー!

「サーバレス」とはどういう意味ですか?

さて、サーバーはまだありますが、ライフサイクルは40ミリ秒です。 この場合のサーバーレスの設定は、 「永続的なインフラストラクチャなし」を意味します。

従来のHTTPサーバーでは、サーバーは24時間365日稼働し、到着時に要求を1つずつ処理します。着信要求のキューが大きくなりすぎると、要求の一部がタイムアウトします。 Zappaでは、 各リクエストに Amazon API Gatewayによって独自の仮想HTTP「サーバー」が与えられます。 AWSは自動的に水平スケーリングを処理するので、要求がタイムアウトすることはありません。 各リクエストは、AWS Lambdaのメモリキャッシュからアプリケーションを呼び出し、PythonのWSGIインターフェイス経由で応答を返します。 あなたのアプリが返ってきたら、 “サーバー”は消滅します。

さらに良いことに、Zappaを使用すると、使用するサーバー時間が1ミリ秒単位で済むので、LinodeやHerokuなどのVPS / PaaSホストよりも数桁も安く購入できます。ほとんどの場合、完全に無料です。 さらに、負荷分散やサーバーのオンライン化を心配する必要もありません。

FlaskやBottleのようなフレームワークを持つサーバーレスのマイクロサービスを展開したり、Djangoで大規模なWebアプリケーションやCMSをホスティングするのに最適です。 または、好きなWSGI互換のアプリを使うことができます。 おそらく、既存のアプリケーションを使用するために変更する必要はなく 、そのアプリケーションを使用することに固執していません。

Zappaを使用すると、1年に 兆ものイベントに拡張できるハイブリッドイベント駆動型アプリケーションを構築することもできます。 また、 無料のSSL証明書グローバルアプリのデプロイメントAPIアクセス管理自動セキュリティポリシーの生成プリコンパイルされたCエクステンションオートキープウォーム特大のラムダパッケージなど、 にも多数の特長があります

そして最後に、Zappaは使いやすいスーパーです。 単一のコマンドを使用してアプリケーションをそのまま使用することができます。

驚くばかり!

インストールと設定

始める前に、Python 2.7またはPython 3.6を実行していて、有効なAWSアカウントがあり、 AWS認証情報ファイルが正しくインストールされていることを確認してください。

Zappaはpipのように簡単にインストールできます:

$ pip install zappa

Zappa プロジェクトの仮想環境にインストールする必要あり ます 仮想環境名はZappaプロジェクト名と同じであってはなりません。エラーが発生する可能性があります。

(もしあなたがpyenvを使い、 pyenv- virtualenvでvirtualenvを管理しているのであれば、 pyenv local [your_venv_name]を呼ぶだけで準備が整いました。

次に、ローカル側とサーバー側の設定を定義する必要があります。

初期設定/設定の実行

Zappaは自動的にinitコマンドを使ってデプロイ設定をあなたのために設定することができます:

$ zappa init

これにより、アプリケーションタイプ(Flask / Django – Pyramidユーザー)が自動的に検出され、デプロイメント設定を定義するのに役立ちます。 初期化が完了すると、プロジェクトディレクトリにzappa_settings.jsonというファイルが作成され、基本的なデプロイメント設定が定義されます。 ほとんどのWSGIアプリケーションでは、おそらく次のようになります。

{
    // The name of your stage
    "dev": {
        // The name of your S3 bucket
        "s3_bucket": "lmbda",

        // The modular python path to your WSGI application function.
        // In Flask and Bottle, this is your 'app' object.
        // Flask (your_module.py):
        // app = Flask()
        // Bottle (your_module.py):
        // app = bottle.default_app()
        "app_function": "your_module.app"
    }
}

またはDjangoの場合:

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

Psst:Zappaで初めてDjangoアプリケーションをデプロイする場合は、Edgar RomanのDjango Zappa Guideを読んでみてください。

あなたは好きなだけ多くのステージを定義することができます。 開発者ステージングプロダクションをお勧めします。

今すぐ、展開する準備が整いました!

基本的な使用法

初期展開

設定が構成されたら、次のコマンドを使用して、アプリケーションをパッケージ化して「プロダクション」と呼ばれるステージにデプロイできます。

$ 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ポリシーとロールの作成と管理、新しいラムダ関数としての登録、新しいAPIゲートウェイリソースの作成、WSGI互換ルートの作成、新しいラムダ関数へのリンク、最後にあなたの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にアップロードされ、ラムダ関数が新しいコードを使用するように更新されますが、APIゲートウェイのルートには触れません。

ロールバック

また、リビジョン数を指定することで、配布されたコードを以前のバージョンにrollbackすることもできます。 たとえば、3つ前のバージョンで展開されたバージョンにロールバックするには、次のようにします。

$ zappa rollback production -n 3

スケジューリング

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タイムゾーンから発生する問題に対処するために使用できます。

関数の重複したトリガーを防ぐために、重複する式は警告を投げず、チェックする必要があることに注意してください。

配備の解除

以前に公開したAPIゲートウェイとラムダ機能を削除する必要がある場合は、次の操作を簡単に行うことができます。

$ zappa undeploy production

実行する前に確認を求められます。

APIゲートウェイサービスのCloudWatchログを有効にしていて、それらのログを保持したくない場合は、– --remove-logs引数を指定して、APIゲートウェイとLambda関数のログをパージできます。

$ zappa undeploy production --remove-logs

パッケージ

実際にアップロードしてラムダ関数として登録せずにアプリケーションパッケージをビルドする場合は、 packageコマンドを使用できます:

$ zappa package production

callbacks設定でzipコールバックがある場合は、これも呼び出されます。

{
    "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がパッケージを作る方法

Zappaは、アクティブな仮想環境をAWS Lambda上でスムーズに動作するパッケージに自動的にパッケージ化します。

このプロセスでは、AWS Lambda互換バージョンとのローカル依存関係を置き換えます。 依存関係は次の順序で含まれます。

  • ローカルキャッシュからのラムダ互換のmanylinuxホイール
  • PyPIからのラムダ互換のmanylinuxホイール
  • ラムダパッケージからのラムダ固有のバージョン
  • アクティブな仮想環境からのパッケージ
  • ローカルプロジェクトディレクトリのパッケージ

また、不要な特定のファイルをスキップし、.pycファイルが利用可能であれば、.pyファイルを無視します。

また、Zappaは自動的に正しい実行権限を設定し、パッケージ設定を構成し、一意かつ監査可能なパッケージマニフェストファイルを作成します。

最終的なパッケージファイルサイズをさらに減らすには、次のようにします。

テンプレート

packageと同様に、API Gateway CloudFormationテンプレートのみが必要な場合は、 templateコマンドを使用します。

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

この場合、独自のLambda ARNとRole ARNを作成する必要があります。作成されていない可能性があります。

JSON出力を--jsonで直接--json 、–outputで出力ファイルを指定することができ--output

状態

デプロイメントとイベントのスケジュールの状態を確認する必要がある場合は、単にstatusコマンドを使用してください。

$ zappa status production

テーリングログ

tail管理コマンドを呼び出すことで、配備のログを見ることができます。

$ zappa tail production

デフォルトでは、すべてのログ項目が表示されます。 HTTPやその他のイベントに加えて、 stdoutまたはstderr printされたものはすべてログに表示されます。

--http引数を使用してHTTPリクエストをフィルタリングできます。これはApache Common Log Formatになります。

$ 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ログのフィルタ構文を使用することに注意してください。

リモート関数呼び出し

invokeコマンドを使用すると、アプリケーション内の任意の関数をいつでも直接実行できます。

たとえば、 “my_app.py”というファイルに基本アプリケーションがあり、その中に “my_function”という関数を呼び出すとします。 アプリケーションがデプロイされたら、いつでもその関数を呼び出すことができます:

$ zappa invoke production 'my_app.my_function'

リモート印刷ステートメントと返された値は、ローカルコンソールに出力されます。 ニフティ!

また、解釈可能なPython 2.7やPython 3.6の文字列を--rawを使って直接呼び出すこともできます。

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

Django管理コマンド

便宜上、ZappaはmanageコマンドでリモートのDjango ‘manage.py’コマンドを呼び出すこともできます。 例えば、基本的なDjangoの状態チェックを実行するには:

$ zappa manage production showmigrations admin

明らかに、これは設定が適切に定義されたDjangoプロジェクトでのみ機能します。

独自の引数を持つコマンドの場合は、次のようにコマンドを文字列として渡すこともできます。

$ zappa manage production "shell --version"

createsuperuserなどの直接ユーザー入力を必要とするコマンドは、 createsuperuser zappa invoke <env> --rawを使用するコマンド置き換える必要があります。

(実行に30秒以上かかるコマンドがタイムアウトする可能性があるので注意してください。

SSL証明書

Zappaは、カスタムSSL証明書、証明書の暗号化、 AWS Certificate Manager (ACM)証明書を使用して、カスタムドメイン名とサブドメインに展開できます。

現在、AWS証明書マネージャーの証明書は、無料で自己更新し、必要最小限の作業しか必要としないため、これらの証明書を使用するのが最も簡単です。

以下に説明するように設定すると、これらのメソッドはすべて同じコマンドを使用します。

$ zappa certify 

CI / CDシステムから配備する場合は、次のものを使用できます。

$ zappa certify --yes

確認のプロンプトをスキップします。

AWS Certificate Managerを使用したドメインへの配備

Amazonは、 AWS Certificate Manager (ACM)と呼ばれるLet’s Encryptに代わる独自の無料の方法を提供しています。 Zappaでこのサービスを使用するには:

  1. AWS Certificate Managerコンソールでドメインを確認します。
  2. コンソールで、N. Virginia(us-east-1)領域を選択し、ドメインまたはサブドメイン( sub.yourdomain.tld )の証明書を要求するか、ワイルドカードドメイン( *.yourdomain.tld )を要求します。
  3. その証明書のARN全体をコピーし、Zappa設定certificate_arnます。
  4. domain設定で目的のドメインを設定します。
  5. $ zappa certify呼び出して、その証明書を使用してAPIゲートウェイ配布を作成して関連付けます。

証明書を暗号化してドメインに展開する(DNS認証)

自動ルート53ベースのDNS認証を使用して、自由に暗号化しようとする証明書を持つドメインでZappaを使用する場合は、 この便利なガイドに従うことができます。

「証明書を暗号化しよう」(HTTP Auth)を使用してドメインに展開する

無料のドメインでZappaを使用する場合は、HTTP認証を使用して証明書を暗号化してくださいこのガイドに従うことができます。

ただし、Route 53ベースのDNS認証を使用する方がはるかに簡単です$ zappa certifyつの$ zappa certifyコマンドでLet’s Encrypt証明書を使用できます。

独自のSSL証明書を使用してドメインに展開する

  1. まず、カスタムドメインを作成し、SSL証明書/キー/バンドルを入手します。
  2. Zappa設定のdomain設定をJSONに設定していることを確認してください。これにより、カスタムドメインとAPI呼び出しURLの間のベースパスマッピングの問題が回避され、URIにステージ名が追加されます
  3. Zappa設定のSSL証明書/キー/バンドルへのパスをcertificatecertificate_key 、およびcertificate_chain設定にそれぞれ追加します。JSON
  4. AWS Route53 Hostedゾーンではなく、独自のDNSプロバイダを使用する予定の場合は、 route53_enabledfalse設定します。
  5. Zappaを使用してアプリをデプロイまたは更新する
  6. $ zappa certify実行して証明書をアップロードし、カスタムゲートウェイ名をAPIゲートウェイに登録します。

AWSイベントに応答して実行する

同様に、S3アップロード、DynamoDBエントリ、Kinesisストリーム、SNSメッセージなど、AWSエコシステムで発生するイベントに応じて関数を実行させることができます。

zappa_settings.jsonファイルで、実行するイベントソースと関数を定義します。 たとえば、これはあなたのmy-bucket S3バケット内の新しいオブジェクトに応じてyour_module.process_upload_functionを実行します。 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
                  ]
               }
            }],
       ...
    }
}

その後:

$ zappa schedule production

そして、あなたのバケツに新しいアップロードが現れるたびにあなたの関数が実行されます!

アプリケーションコンテキストでキーの情報にアクセスするには、 process_upload_functionを次のようにします。

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()

同様に、 Simple Notification Serviceイベントの場合は次のようになります。

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

必要に応じて、 SNSメッセージフィルタを追加できます

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

DynamoDBKinesisは、イベントベースではなくストリームから取得するため、わずかに異なります。

       "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
               }
           }
       ]

Lex Botのインテントトリガイベントを設定するには:

	"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

より多くのイベントソースの例がここにあります

非同期タスクの実行

またZappaでは、完全に別のAWS Lambdaインスタンスで非同期に関数をシームレスに実行できるようになりました。

たとえば、Pythonを注文するためのFlask APIがある場合は、 zappa.async.taskデコレータを使用して完全に別のLambdaインスタンスでbake関数をシームレスに呼び出すことができます。

from flask import Flask
from zappa.async 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!"

以上です! APIレスポンスはすぐにmake_pieますが、 make_pie関数は完全に異なるラムダインスタンスで実行されます。

@task装飾された関数やzappa.async.runコマンドの呼び出しがローカル開発環境のようにLambdaの外部で行われると、関数は即座にローカルで実行されます。 zappa非同期機能は、Lambda環境またはリモート呼び出しを指定する場合にのみ機能します。

タスクソース

デフォルトでは、この機能は直接AWSラムダ呼び出しを使用します。 代わりに、 task_snsデコレータを使用すると、AWS Simple Notification Serviceをタスクイベントソースとして使用できます。

from zappa.async import task_sns
@task_sns

SNSを使用するには、 zappa_settings次の設定を行う必要があります。

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

これにより、 zappa scheduleコマンドを呼び出すときにコードが使用するSNSトピックが自動的に作成され、登録されます。

SNSを使用すると、呼び出しを追跡する必要がある場合に備えて、メッセージIDも返されます。

直接呼び出し

また、 zappa.async.runに関数を渡すことで、デコレータなしでこの機能を使用することもできます。

from zappa.async import run

run(your_function, args, kwargs) # Using Lambda
run(your_function, args, kwargs, service='sns') # Using SNS

リモート呼び出し

デフォルトでは、Zappaはラムダの現在の関数名と現在のAWS領域を使用します。 別の関数名/地域を持つラムダを呼び出す場合や、ラムダの外側からラムダを呼び出す場合は、 remote_aws_region引数とremote_aws_region引数を指定して、アプリケーションが使用する関数と領域を知るようにする必要があります。 例えば、ピッツァ作成アプリケーションの一部がEC2インスタンス上に存在しなければならないが、独自のLambdaインスタンスでmake_pie()関数を呼び出すことを望む場合、次のようにします。

@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)

これらのtask()パラメータが使用されなかった場合、EC2はローカルで関数を実行します。 これらの同じremote_aws_lambda_function_name引数とremote_aws_region引数は、zappa.async.run()関数でも使用できます。

制限事項

この機能の制限事項は次のとおりです。

  • 関数にはクリーンなインポートパスが必要です。つまり、クロージャ、ラムダ、メソッドはありません。
  • argskwargsはJSON kwargsなければなりません。
  • JSON直列化引数は、ラムダ(128K)イ​​ベントまたはSNS(256K)イベントのサイズ制限内でなければなりません。

このコードはすべて非ラムダ環境との下位互換性があります。単純にブロッキング方式で実行し、結果を返します。

VPCでのタスクの実行

仮想プライベートクラウド(VPC)でZappaを実行している場合は、ラムダがVPC内のサービスやパブリックインターネットと通信できるようにサブネットを設定する必要があります。 最小限の設定では、2つのサブネットが必要です。

サブネットa

  • NATを作成する
  • インターネットゲートウェイを作成する
  • ルートテーブルで、インターネットゲートウェイを0.0.0.0/0に示すルートを作成します。

サブネットb

  • ラムダ関数を配置する
  • ルートテーブルで、 subnet-aに属するNATを指すルートを0.0.0.0/0に作成します

lambdaは、高可用性のためにサブネットbと同じ方法で構成された複数のサブネットに配置できます。

このチュートリアルこのチュートリアルこのAWSのドキュメントページに役立つリソースがあります

反応

非同期タスクの応答をキャプチャすることは可能です。

ZappaはこれらのバックエンドとしてDynamoDBを使用します。

レスポンスを取得するには、 async_response_tablezappa_settings設定する必要があります。 これはDynamoDBテーブル名です。 それから、 @task@taskときは、 capture_response=True渡して@task

非同期応答にはresponse_idが割り当てられます。 これは@taskデコレータによって返されるLambdaAsyncResponse (またはSnsAsyncResponse )オブジェクトのプロパティとして返されます。

例:

from zappa.async 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)

    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.",
    }

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

高度な設定

Zappaの動作を変更するためにローカル設定で定義できるその他の設定があります。 自己責任でこれらを使用してください!

 {
    "dev": {
        "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
        "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 now 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". C
        "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
        "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
                "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
                "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.
                    ]
                }
            }
        ],
        "exception_handler": "your_module.report_exception", // function that will be invoked in case Zappa sees an unhandled exception raised from your code
        "exclude": ["*.gz", "*.rar"], // A list of regex 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": true, // 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_source": "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
        "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.
        "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": "python2.7", // Python runtime to use on Lambda. Can be one of "python2.7" or "python3.6". 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 300.)
        "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.
    }
}

YAML Settings

If you prefer YAML over JSON, you can also use a zappa_settings.yml , like so:

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

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

高度な使用法

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 , and for Django, there is Django-Storages .

Similarly, you may want to design your application so that static binary uploads go directly to S3 , 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. It may also conflict with binary_support , so you should set that to false in your settings.

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 or 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 memory space of your application function.

Enabling Bash Completion

Bash completion can be enabled by adding the following to your .bashrc:

  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 eg ~/.bashrc.

Enabling Secure Endpoints on API Gateway

APIキー

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 . 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 Authorizers

If you deploy an API endpoint with Zappa, you can take advantage of API Gateway Authorizers 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 .

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 :

  context_header_mappings:
    user_id: authorizer.user_id

Which can now be accessed in Flask like this:

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:

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

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 :

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

You can then access these inside your application with:

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).

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. 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):

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

zappa_settings.json:

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

Now in your application you can use:

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 :

{
    "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:

{
    "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:

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

The function has to accept three arguments: exception, event, and context:

your_module.py

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, eg 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 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.

Using 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.

{
    "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.
        ...
    },
    ...
}

Ongoing discussion about the minimum policy requirements necessary for a Zappa deployment can be found here . 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:

{
    "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 support on your function with a configuration setting:

{
    "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:

from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.ext.flask.middleware import XRayMiddleware

app = Flask(__name__)

xray_recorder.configure(service='my_app_name')
XRayMiddleware(app, xray_recorder)

The official X-Ray documentation for Python has more information on how to use this with your code.

Globally Available Server-less Architectures

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 from ServerlessConf London.

Raising AWS Service Limits

Out of the box, AWS sets a limit of 1000 concurrent executions 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 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.

Using Zappa With Docker

If Docker is part of your team’s CI, testing, or deployments, you may want to check out this handy guide on using Zappa with Docker.

デッドレターキュー

If you want to utilise AWS Lambda’s Dead Letter Queue feature 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:

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

Zappa Guides

Zappa in the Press

Sites Using Zappa

Are you using Zappa? Let us know and we’ll list your site here!

関連プロジェクト

  • lambda-packages – Precompiled C-extension packages for AWS Lambda. Used automatically by Zappa.
  • Mackenzie – AWS Lambda Infection Toolkit
  • NoDB – A simple, server-less, Pythonic object store based on S3.
  • zappa-cms – A tiny server-less CMS for busy hackers. 作業中です。
  • zappa-django-utils – Utility commands to help Django deployments.
  • flask-ask – A framework for building Amazon Alexa applications. Uses Zappa for deployments.
  • zappa-file-widget – A Django plugin for supporting binary file uploads in Django on Zappa.
  • zops – Utilities for teams and continuous integrations using Zappa.
  • cookiecutter-mobile-backend – A cookiecutter Django project with Zappa and S3 uploads support.
  • zappa-examples – Flask, Django, image uploads, and more!
  • zappa-hug-example – Example of a Hug application using Zappa.
  • Zappa Docker Image – A Docker image for running Zappa locally, based on Lambda Docker.
  • zappa-dashing – Monitor your AWS environment (health/metrics) with Zappa and CloudWatch.
  • s3env – Manipulate a remote Zappa environment variable key/value JSON object file in an S3 bucket through the CLI.
  • zappa_resize_image_on_fly – Resize images on the fly using Flask, Zappa, Pillow, and OpenCV-python.
  • zappa-ffmpeg – Run ffmpeg inside a lambda for serverless transformations.
  • gdrive-lambda – pass json data to a csv file for end users who use Gdrive across the organization.
  • travis-build-repeat – Repeat TravisCI builds to avoid stale test results.
  • wunderskill-alexa-skill – An Alexa skill for adding to a Wunderlist.
  • xrayvision – Utilities and wrappers for using AWS X-Ray with Zappa.
  • zappa-sentry – Integration with Zappa and Sentry

ハック

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.

貢献する

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 . The test suite will be run by Travis CI 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 ). 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 .

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 , where you’ll find a community of smart and interesting people working dilligently on hard problems.

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.

パトロン

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 .

Zappa is currently supported by these awesome individuals and companies:

  • ネイサンローレンス
  • LaunchLab
  • Sean Paley
  • Theo Chitayat
  • George Sibble
  • Joe Weiss

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?

良いニュース! We’re currently available for remote and on-site consulting for small, large and enterprise teams. Please contact miserlou@gmail.com with your needs and let’s work together!







-Miserlou
-, , , , , , , , , ,

執筆者: