AWS Lambda - Unterstützung für Python 3.7

Auf der re:Invent 2018 kündigte AWS die Unterstützung von Python 3.7 für die Laufzeit von AWS Lambda an. AWS Lambda unterstützt Python 2.7 und 3.6 schon seit einiger Zeit. Python 3.7 ist eine großartige Ergänzung. Python 3.7 bietet Funktionen wie Datenklassen und die aufgeschobene Auswertung von Anmerkungen, die die Arbeit mit "Datensätzen" vereinfachen. Werfen wir einen Blick darauf!

Daten als Datensatz

Daten können auf viele Arten dargestellt werden. Wenn Daten transportiert werden, wird ein gängiges Format wie binäre Einsen und Nullen, JSON, XML, CSV verwendet. Bei der Verarbeitung von Daten unterstützt eine typisierte Darstellung der Daten die Typüberprüfung, um die Datenverarbeitungslogik zu validieren. Um Daten in einer typisierten Form zu materialisieren, unterstützt Python 3.7 Datenklassen. Wenn Datenklassen mit mashumaro kombiniert werden, einem schnellen und gut getesteten Serialisierungs-Framework, das auf Datenklassen aufsetzt, wird es sehr einfach, Daten in eine feste Form zu bringen. Lassen Sie uns sehen, wie das aussieht.

JSON-Paket

Python stellt Daten traditionell als Wörterbuch mit Schlüssel-Wert-Paaren dar, die mit dem Paket json von und nach JSON konvertiert werden können.

import json


def handler(event: dict, context) -> dict:
    return {
        'statusCode': 200,
        'body': json.dumps('Hello World')
        }

Abstrahieren der Lambda-Antwort

Mit Datenklassen kann ein Response Objekt auf hoher Ebene erstellt werden, das die Details der Antwort mit einem JSON-Wörterbuch an den API Gateway Proxy abstrahiert. In diesem Beispiel verwenden wir die neuen Python 3.7-Funktionen 'postponed evaluation' und 'data classes'. Datenklassen bieten die Funktion asdict, die die Datenklasseninstanz in ein Diktat umwandelt.

from __future__ import annotations
import json
from dataclasses import dataclass, asdict


@dataclass
class Response:
    statusCode: int = 200
    body: str = ''

    @classmethod
    def of(cls, status_code: int, body: dict) -> Response:
        return Response(status_code, json.dumps(body))

    def respond(self) -> dict:
        return asdict(self)


def handler(event: dict, context) -> dict:
    return Response.of(200, { 'msg': 'Hello World' }).respond()

Getippte Antworten

Es ist möglich, typisierte Antworten in der Verarbeitungslogik des Lambdas zurückzugeben. Das folgende Beispiel verwendet mashumaro, das eine typisierte Darstellung von Daten bietet. Im folgenden Beispiel akzeptiert die Klasse Response eine Message, die verwendet wird, wenn das Lambda antwortet.

from __future__ import annotations
import requests
from requests.auth import HTTPBasicAuth
from dataclasses import dataclass, asdict
from mashumaro import DataClassJSONMixin


@dataclass
class Response(DataClassJSONMixin):
    statusCode: int = 200
    body: str = ''

    @classmethod
    def of(cls, status_code: int, msg: Message) -> Response:
        return Response(status_code, msg.to_json())

    def respond(self) -> dict:
        return asdict(self)


@dataclass
class Message(DataClassJSONMixin):
    message: str


def say_hello(msg: Message) -> dict:
    resp = requests.post(
        'https://httpbin.org/post',
        json=msg.to_dict(),
        auth=HTTPBasicAuth('username', 'password'),
        verify=False,
        timeout=2)
    try:
        return resp.json()['json']
    except Exception as e :
        return { 'msg': f'No body in response {e} -> {resp.text}' }


def handler(event: dict, context) -> dict:
    try:
        payload: dict = say_hello(Message("Hello World"))
        payload.update({'message': f"Received from httpbin: {payload['message']}"})
        msg: Message = Message.from_dict(payload)
        return Response.of(200, msg).respond()
    except Exception as e:
        return Response.of(500, Message(str(e))).respond()

Python 3.7-Laufzeitkonfiguration

CloudFormation unterstützt die Konfiguration von Lambdas zur Verwendung von Python 3.7, indem das Feld Runtime auf python3.7 gesetzt wird.

  HelloLambda:
    Type: AWS::Lambda::Function
    Properties:
      Handler: helloworld.handler
      Runtime: python3.7
      Role: !GetAtt 'LambdaBasicExecutionRole.Arn'
      MemorySize: 128
      Timeout: 30
      Code:
        S3Bucket: !Ref S3Bucket
        S3Key: !Ref S3Key
        S3ObjectVersion: !Ref S3Version

Beispiel

Das Beispielprojekt enthält ein Beispielprojekt mit den Lambdas und der CloudFormation-Konfiguration, das die Python 3.7-Laufzeit verwendet. Das Beispiel kann durch Eingabe von make deploy bereitgestellt und mit make delete entfernt werden.

Fazit

Es ist großartig, dass Lambda Python 3.7 unterstützt. In diesem Blog haben wir uns einige der aufregenden neuen Funktionen von Python angesehen und wie wir sie in Lambda-Code anwenden können, um sichereren Code zu erstellen. Wir haben uns ein einfaches Lambda angesehen, wie Sie normalerweise Daten serialisieren könnten. Wir haben gesehen, wie wir die Antwortlogik mit den Funktionen von Python 3.7 abstrahieren können. Schließlich haben wir gesehen, wie wir einen Dienstaufruf an httpbin tätigen und darauf antworten können, und zwar auf völlig typsichere Weise.