Erstellen, debuggen und bereitstellen Ihren Code als wiederverwendbare AWS -Lambda -Ebenen

AWS Lambda -Schichten sind eine gute Möglichkeit, Code mit Ihren verschiedenen Lambdas wiederzuverwenden. Ich habe viele Tutorials zum Erstellen von Ebenen für vorhandene PIP -Pakete gesehen, aber nicht so viele, die erklären, wie man ihn mit Ihrem eigenen Code macht, und Sie können es zusammen mit Ihrem Lambda debuggen. In meinem Szenario können Sie Ihre Ebene und mehrere Lambdas mit dieser Ebene haben und den Code des Lambdas und die Ebene entlang der AWS -Umgebung debuggen. Ich gehe davon aus, dass Sie bereits eine Lambda -Funktion mit seiner template.yml erstellt haben. Wenn nicht, überprüfen Sie den folgenden Artikel, wie Sie eine Lambda https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html erstellen. Nach dem Erstellen können Sie es als ZIP -Datei herunterladen und den Code und die Vorlage von dort extrahieren.

Vorbereitung Ihrer Schicht

Zunächst müssen wir die Ordnerstruktur für die Ebene einrichten. Ich erstelle gerne einen Ordner namens Ebenen und erstelle für jede Ebene einen eigenen Ordner. AWS Lambda benötigt eine bestimmte Ordnerstruktur für die Ebenen, wobei der Code jeder Ebene in einem Python/ Ordner liegt. Weitere Informationen finden Sie im folgenden Link. https://docs.aws.amazon.com/lambda/latest/dg/packaging-layers.html

Unsere Schicht wird als Layer_utils bezeichnet. Wir setzen dann einen Ordner Layer_utils in den Python -Ordner und in der Dateien erstellen wir die Dateien Request_handler.py und Processor.py mit dem Code. Wir brauchen auch eine init .py leere Datei, die für Python erforderlich ist, um dies als Paket zu erkennen. So sollte die Baumstruktur aussehen

layers/
└── layer_utils/
    └── python/
        ├── layer_utils/
        │   ├── __init__.py
        │   └── request_handler.py
        │   └── processor.py

Die Request_Handler.py erhält eine Anfrage mit einer URL und ruft den Prozessor an, der die Bibliotheksanforderungen verwendet, um die Daten zu erhalten und diese zurückzugeben.

./ Ebenen/layer_utils/python/layer_utils/prozessor.py

import requests

def process_data(url):
    """
    Fetches data from a URL.

    Args:
        url (str): The URL to fetch data from.

    Returns:
        str: The fetched content or an error message.
    """
    try:
        response = requests.get(url)
        response.raise_for_status()  # Raise an error for bad status codes
        return response.text[:200]  # Return the first 200 characters of the response
    except requests.RequestException as e:
        return f"Error fetching data: {str(e)}"

./ Ebenen/layer_utils/python/layer_utils/request_handler.py

from layer_utils.processor import process_data

def handle_request(request):
    """
    Handles an incoming request and processes it.

    Args:
        request (dict): The input request data.

    Returns:
        dict: The processed result.
    """
    # Example: Extract 'url' from the request and process it
    if "url" not in request:
        return {"error": "Missing 'data' in request"}

    data = request["url"]
    processed_result = process_data(data)
    return {"result": processed_result}

Hier ist es wichtig zu beachten, wie wir die Prozessorfunktionen importieren, indem wir von Layer_utils.Processor Import Process_Data aufrufen, anstatt nur aus dem Prozessor importieren prozess_data. Wenn Sie den absoluten Pfad verwenden, können Sie später Fehler importieren.

Verpacken Sie Ihre Schicht

Okay, jetzt haben wir unseren Ebenencode erstellt. Aber wir sind noch nicht damit fertig. Wir müssen jetzt ein bearbeitbares Paket mit PIP erstellen, damit dies von unserem Lambda -Code verwendet werden kann. Wir werden dem Pep 660 -Stil dazu folgen. Wir müssen zwei Dateien erstellen: Anforderungen.txt und pYProject.toml. Der erste enthält alle externen Bibliotheken, die wir für diese Schicht benötigen, in diesem Fall Anfrage. Die zweite ist die Datei, die wir mithilfe von PIP ein bearbeitbares Paket erstellen müssen und sicherstellen, dass alle Abhängigkeiten installiert sind. Dies ermöglicht das Bearbeiten des Ebenencode

So sollte der Baum aussehen

└── layer_utils
    └── python
        ├── layer_utils
        │   ├── __init__.py
        │   ├── processor.py
        │   └── request_handler.py
        ├── pyproject.toml
        └── requirements.txt

Das PYProject.toml wird von PIP verwendet, um das Paket mit unserer Ebene zu erstellen.

./ Ebenen/layer_utils/python/pyproject.toml

layers/
└── layer_utils/
    └── python/
        ├── layer_utils/
        │   ├── __init__.py
        │   └── request_handler.py
        │   └── processor.py

In dieser Datei ist das Setuptools -Paket zum Erstellen des Pakets erforderlich und das Radpaket wird zum Verpacken des Codes in ein verteilbares Format verwendet.

Die Anforderungen.txt gibt alle externen Module an, die unsere Ebenen benötigen. In unserem Fall benötigen wir nur das Anfragemodul, aber Sie könnten so viele nach Bedarf hinzufügen.

./ Ebenen/layer_utils/python/required.txt

import requests

def process_data(url):
    """
    Fetches data from a URL.

    Args:
        url (str): The URL to fetch data from.

    Returns:
        str: The fetched content or an error message.
    """
    try:
        response = requests.get(url)
        response.raise_for_status()  # Raise an error for bad status codes
        return response.text[:200]  # Return the first 200 characters of the response
    except requests.RequestException as e:
        return f"Error fetching data: {str(e)}"

Ich denke, es ist wichtig, im Auge zu behalten, welche Version Ihres Pakets Sie verwenden, da Ihre externen Pakete importiert werden, indem Sie Ihre AWS Lambda Layer -Ressource direkt von AWS aufrufen. Wenn Sie direkt in Ihrem System debuggen, indem Sie Ihre Lambda direkt aus Ihrer Python-Umgebung ausführen, anstatt Sam Local Invoke oder SAM Local Start-API zu verwenden, müssen Sie sicherstellen Pakete in Ihrer Ebene. Ich werde nicht erklären, wie man die externen Ebenen erstellt, da es dafür viele gute Tutorials gibt (zum Beispiel diese https://www.keyq.cloud/en/blog/creating-an-aws-lambda-layer-for- Python-Requests-Module
).

Einrichten der virtuellen Umgebung

Lassen Sie uns nun eine virtuelle Umgebung erstellen. Dies ist nicht notwendig, wird jedoch empfohlen, da es Abhängigkeiten isoliert und sicherstellt, dass die Python -Umgebung mit derjenigen übereinstimmt, die Lambda verwenden wird. In der Konsole auf Ihrem Projekt DIR geben Sie dazu
in der Konsole

from layer_utils.processor import process_data

def handle_request(request):
    """
    Handles an incoming request and processes it.

    Args:
        request (dict): The input request data.

    Returns:
        dict: The processed result.
    """
    # Example: Extract 'url' from the request and process it
    if "url" not in request:
        return {"error": "Missing 'data' in request"}

    data = request["url"]
    processed_result = process_data(data)
    return {"result": processed_result}

Der erste lässt Python das Venv -Modul mit -m -Venv ausführen und eine virtuelle Umgebung namens Venv erstellen.

Die zweite aktiviert die virtuelle Umgebung, indem die integrierte Befehlsquelle aufgerufen wird, die das Aktivierungsskript der virtuellen Umgebung ausführt. Wenn Sie Visual Studio -Code verwenden, können Sie auf die virtuelle Umgebung wechseln. Sag ja.

Danach sollten Sie in Ihrer Hülle so etwas sehen.

└── layer_utils
    └── python
        ├── layer_utils
        │   ├── __init__.py
        │   ├── processor.py
        │   └── request_handler.py
        ├── pyproject.toml
        └── requirements.txt

Das (Venv) am Anfang zeigt an, dass Sie sich in der virtuellen Umgebung befinden.

Manchmal mag ich es, die Python -Datei direkt anstatt mit den SAM -Tools auszuführen (weil sie schneller ist). Dazu werde ich alle externen Pakete in meiner virtuellen Umgebung installieren, damit ich sie lokal für die Entwicklung und Debuggierung verwenden kann.

[project]
name = "layer_utils"
version = "0.1.0"

[build-system]
requires = ["setuptools", "wheel"]
build-backend = "setuptools.build_meta"

Dies ist nur erforderlich, um ohne die SAM -Tools lokal und direkt zu debuggen, sodass Sie diesen Schritt überspringen können, wenn Sie dies nicht vorhaben.

Wir müssen jetzt die Ebene verpacken, damit unsere Lambda die Ebene als Python -Paket finden kann.

requests==2.32.2

Das -E -Flag gibt an, dass dies ein bearbeitbares Paket ist. Der Pfad zeigt auf die Datei PYProject.toml. Ausführen Dies erstellt eine neue Ordner layer_utils.egg-info. Nichts zu tun, lass es einfach.

Debuggen

Ok, lass uns jetzt sehen, wie wir das debuggen würden. Dies ist meine Ordnerstruktur mit den Schichten und den Lambdas.

layers/
└── layer_utils/
    └── python/
        ├── layer_utils/
        │   ├── __init__.py
        │   └── request_handler.py
        │   └── processor.py

Dies ist der Code meines Lambda

import requests

def process_data(url):
    """
    Fetches data from a URL.

    Args:
        url (str): The URL to fetch data from.

    Returns:
        str: The fetched content or an error message.
    """
    try:
        response = requests.get(url)
        response.raise_for_status()  # Raise an error for bad status codes
        return response.text[:200]  # Return the first 200 characters of the response
    except requests.RequestException as e:
        return f"Error fetching data: {str(e)}"

Sie können die Datei ausführen und sollten ein gültiges Ergebnis ohne Fehler erhalten.

Wenn Sie Visual Studio -Code mit Pylance verwenden, können Sie feststellen, dass der Import der Ebene auch dann nicht auflöst, wenn der Code funktioniert hat.

Um dies zu lösen, können Sie die Einstellungen für Ihren Arbeitsbereich bearbeiten. Kontrollieren Sie/Befehlsschicht P, geben Sie Einstellungen ein: Öffnen Sie die Arbeitsbereicheinstellungen (JSON) und fügen Sie Folgendes in den Klammern hinzu (fügen Sie einfach den Pfad hinzu)
hinzugefügt)

from layer_utils.processor import process_data

def handle_request(request):
    """
    Handles an incoming request and processes it.

    Args:
        request (dict): The input request data.

    Returns:
        dict: The processed result.
    """
    # Example: Extract 'url' from the request and process it
    if "url" not in request:
        return {"error": "Missing 'data' in request"}

    data = request["url"]
    processed_result = process_data(data)
    return {"result": processed_result}

Jetzt sollte Pylance diese Geldstrafe lösen.

Hinzufügen der Ebene zu Ihrem Stapel

Wir müssen jetzt die Ebene auf Ihrer Lambdas -Vorlage einrichten. Wir müssen Folgendes in den Ressourcen hinzufügen: Abschnitt (Anpassen des Inhalts gemäß Ihrem Projekt)

./ lambdas/mylambda/template.yml

└── layer_utils
    └── python
        ├── layer_utils
        │   ├── __init__.py
        │   ├── processor.py
        │   └── request_handler.py
        ├── pyproject.toml
        └── requirements.txt

Im Contenturi können Sie sehen, wie es sich auf den relativen Pfad bezieht, auf dem sich der Schichtcode befindet. Sehen Sie, wie es nicht auf den Python -Ordner hinweist, da das AWS -SAM -System dort nach dem Python -Ordner sucht. Stellen Sie sicher, dass die Laufzeit dem, das Sie in Ihrer virtuellen Umgebung und Ihrer Lamnbda verwenden, übereinstimmen.
Außerdem müssen Sie die Ebene im Abschnitt Lambda der Datei

verweisen

[project]
name = "layer_utils"
version = "0.1.0"

[build-system]
requires = ["setuptools", "wheel"]
build-backend = "setuptools.build_meta"

Beachten Sie, dass wir im Layers -Abschnitt der Vorlagendatei auch die Anfragenschicht haben, die sich bereits auf unserer AWS befindet. Dadurch wird die Ebene lokal erstellt, sodass Sam weiß, dass sie sie lesen muss. Außerdem werden diese Ebene auf AWS bereitgestellt, wenn Sie AWS -Bereitstellungen aufrufen.

Debugging mit Sam

Testen wir dies. Lass es uns zuerst bauen. Ich hatte Probleme beim Erstellen der Vorlage von einem anderen Weg als in der Vorlage, wo sich der Quellcode befindet. Um dies zu vermeiden, empfehle ich, es direkt aus dem Pfad der Vorlagendatei zu erstellen.

requests==2.32.2

Dies erstellt alle notwendigen Abhängigkeiten.

Jetzt können wir es aufrufen. Ich habe eine Ereignisdatei erstellt, um die Lambda

zu testen ./ lambdas/mylambda/event/event.json

python3.12 -m venv venv

source venv/bin/activate

Jetzt können wir die Datei zum Debuggen aufrufen. Denken Sie daran, dass Sie Docker installiert und damit ausgeführt werden müssen. Denken Sie noch einmal daran, dies von der Stelle aufzurufen, an der die Vorlagendatei ist.

(venv) usar@MacBookPro my-lambda-project

Auf diese Weise werden die Funktion auf der template.yml aufgerufen. Das Flag -D gibt an, dass der Debug -Port 5678 beträgt. Das -E -Flag gibt an, wo die Ereignisdatei an die Lambda übermittelt wird.

Bereitstellung Ihrer Lambda und der Ebene zu AWS

Lassen Sie uns dies nun abschließen, indem Sie den Code für AWS bereitstellen.

layers/
└── layer_utils/
    └── python/
        ├── layer_utils/
        │   ├── __init__.py
        │   └── request_handler.py
        │   └── processor.py

Das -gesteuerte Flag kann zum ersten Mal verwendet werden, wenn Sie Ihr Lambda noch nicht bereitgestellt haben, da es Ihnen dabei hilft. Danach können Sie zur AWS -Konsole gehen und Ihre Ebene finden. Sie können die Ebene jetzt mit anderen Lambdas verwenden, indem Sie den ARN der Ebene verwenden.

Einrichten von VSCODE zum Debuggen

Wenn Sie VSCODE zum Debuggen, Einstellen von Haltepunkten usw. verwenden möchten, müssen wir einige zusätzliche Schritte ausführen.

Wir müssen eine Debug -Konfiguration hinzufügen. Dabei steuern Sie/Befehlsverschiebung P und geben Sie Debug: Konfiguration hinzufügen .... Dadurch wird die Datei launch.json geöffnet. Sie müssen die Konfiguration dort hinzufügen.

./

Wir verwenden Debugpy, die sich an den Sam Local Invoke befinden, und hier richten wir den Port 5678 ein, den wir beim Aufrufen mit der Flagge gesehen haben. Stellen Sie sicher, dass sich der Lokalroot auf das Verzeichnis verweist, in dem sich Ihr Lambda -Code befindet. Wenn Sie mehr Konfigurationen haben, fügen Sie den Teil in die Konfiguration der Liste hinzu.

import requests

def process_data(url):
    """
    Fetches data from a URL.

    Args:
        url (str): The URL to fetch data from.

    Returns:
        str: The fetched content or an error message.
    """
    try:
        response = requests.get(url)
        response.raise_for_status()  # Raise an error for bad status codes
        return response.text[:200]  # Return the first 200 characters of the response
    except requests.RequestException as e:
        return f"Error fetching data: {str(e)}"

Wir brauchen die Debugpy -Bibliothek, um Debugug zu debuggen. Fügen wir es zuerst den Anforderungen hinzu.txt Ihres Lambda

./ Lambdas/Mylambda/Anforderungen.txt

Lassen Sie es uns nun mit PIP

from layer_utils.processor import process_data

def handle_request(request):
    """
    Handles an incoming request and processes it.

    Args:
        request (dict): The input request data.

    Returns:
        dict: The processed result.
    """
    # Example: Extract 'url' from the request and process it
    if "url" not in request:
        return {"error": "Missing 'data' in request"}

    data = request["url"]
    processed_result = process_data(data)
    return {"result": processed_result}

installieren

oder Sie können es auch über die Anforderungen installieren.txt -Datei

└── layer_utils
    └── python
        ├── layer_utils
        │   ├── __init__.py
        │   ├── processor.py
        │   └── request_handler.py
        ├── pyproject.toml
        └── requirements.txt

Wir müssen eine Umgebungsdatei erstellen, in der wir eine Umgebungsvariable AWS_SAM_LOCAL definieren können, die unsere Ebene angibt, dass sie lokal ausgeführt wird. Wir erstellen eine Datei .Env in unserem Workspace -Ordner.

[project]
name = "layer_utils"
version = "0.1.0"

[build-system]
requires = ["setuptools", "wheel"]
build-backend = "setuptools.build_meta"

./ .v

Hier definieren wir die AWS_SAM_LOCAL, sodass die Lambda weiß, dass dies lokal über AWS Sam ausgeführt wird.

requests==2.32.2

Wir müssen auch unserer Python -Umgebung mitteilen, dass sie die Umgebungsvariablen aus der Umgebungsdatei verwenden muss. So sollte es aussehen

./

Und schließlich müssen wir unseren Lambda -Code ändern, damit er beim lokalen Ausführen an den Debugger anhängen muss. Zu Beginn unserer Datei werden wir das folgende Code -Stück
hinzufügen

python3.12 -m venv venv

source venv/bin/activate

./ lambdas/mylambda/src/lambda_function.py

Jetzt rufen wir die Funktion auf (wieder aus dem Pfad, wo sich die Funktion befindet):

(venv) usar@MacBookPro my-lambda-project

Wenn die Konsole zeigt, dass Debugger angehängt wird ... drücken

pip3 install -r ./layers/layer_utils/python/requirements.txt

Und jetzt sind Sie bereit, Ihre lokalen Schichten und Lambdas zu debuggen!

Das obige ist der detaillierte Inhalt vonErstellen, debuggen und bereitstellen Ihren Code als wiederverwendbare AWS -Lambda -Ebenen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!