Buat, debug, dan gunakan kod anda sebagai lapisan AWS Lambda yang boleh diguna semula

Lapisan Lambda AWS adalah cara yang baik untuk dapat menggunakan semula kod dengan lambdas yang berbeza. Saya telah melihat banyak tutorial tentang cara membuat lapisan untuk pakej PIP yang sedia ada, tetapi tidak banyak yang menjelaskan bagaimana untuk melakukannya dengan kod anda sendiri dan membolehkan anda menyahpepijatnya bersama -sama dengan lambda anda. Dalam senario saya, anda boleh mempunyai lapisan anda dan beberapa lambdas menggunakan lapisan ini, dan debug kod lambdas dan lapisan di sepanjang simulasi persekitaran AWS. Saya akan menganggap anda sudah mempunyai fungsi lambda yang dibuat dengan template.yml. Jika tidak, periksa artikel berikut mengenai cara membuat lambda https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html. Selepas menciptanya, anda boleh memuat turunnya sebagai fail zip dan mengeluarkan kod dan template.yml dari sana.

Menyediakan lapisan anda

Pertama, kita perlu menyediakan struktur folder untuk lapisan. Saya suka membuat folder yang dipanggil Lapisan, dan untuk setiap lapisan membuat folder sendiri. AWS Lambda memerlukan struktur folder tertentu untuk lapisan, di mana kod setiap lapisan berada dalam python/ folder. Lihat pautan berikut untuk maklumat lanjut mengenai perkara ini. https://docs.aws.amazon.com/lambda/latest/dg/packaging-layers.html

Lapisan kami akan dipanggil Layer_utils. Kami meletakkan kemudian folder layer_utils di dalam folder python dan di dalam kami membuat fail request_handler.py dan pemproses.py dengan kod. Kami juga memerlukan fail kosong . Ini adalah bagaimana struktur pokok sepatutnya kelihatan seperti

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

request_handler.py akan menerima permintaan dengan URL, dan memanggil pemproses yang akan menggunakan permintaan perpustakaan untuk mendapatkan data dan mengembalikannya.

3

3
di sini, adalah penting untuk diperhatikan bagaimana kami mengimport fungsi pemproses, dengan memanggil dari Layer_utils.Processor Import Process_data, bukannya dari Processor Import Process_Data sahaja. Menggunakan jalan mutlak membantu mengelakkan kesilapan import kemudian.

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

Membungkus lapisan anda

baiklah, kini kami mempunyai kod lapisan kami yang dibuat. Tetapi kita belum selesai dengannya. Kita perlu membuat pakej yang boleh diedit dengan PIP supaya ini boleh digunakan oleh kod Lambda kami. Kami akan mengikuti gaya PEP 660 untuk berbuat demikian. Kita perlu membuat dua fail: keperluan.txt dan pyproject.toml. Yang pertama akan memasukkan semua perpustakaan luaran yang kita perlukan untuk lapisan ini, dalam permintaan ini. Yang kedua ialah fail yang kita perlukan untuk membuat pakej yang boleh diedit menggunakan PIP dan memastikan semua kebergantungan dipasang. Ini membolehkan mengedit kod lapisan tanpa perlu mengemas semula ia sentiasa (yang kita perlukan untuk debug).
ini adalah bagaimana pokok itu kelihatan seperti

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}

pyproject.toml akan digunakan oleh PIP untuk membuat pakej dengan lapisan kami.

3

Dalam fail ini, pakej setuptools diperlukan untuk membuat pakej dan pakej roda digunakan untuk membungkus kod ke dalam format yang boleh diedarkan.

Keperluan.txt Menunjukkan semua modul luaran yang diperlukan oleh lapisan kami. Dalam kes kami, kami hanya memerlukan modul permintaan, tetapi anda boleh menambah sebanyak yang diperlukan.

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

3

Saya fikir penting untuk menjejaki versi pakej anda yang anda gunakan, kerana pakej luaran anda akan diimport dengan menghubungi sumber lapisan AWS Lambda secara langsung dari AWS. Sekiranya anda menyahpepijat secara langsung pada sistem anda dengan menjalankan lambda anda secara langsung dari persekitaran python anda dan bukannya menggunakan Sam Local Invoke atau Sam Local Start-API, anda perlu memastikan bahawa pakej tempatan anda dipasang dengan PIP akan sama seperti yang anda gunakan pakej di lapisan anda. Saya tidak akan menerangkan cara membuat lapisan luaran kerana terdapat banyak tutorial yang baik untuk itu (contohnya, ini https://www.keyq.cloud/en/blog/creating-an-aws-lambda-layer-for- Python-Requests-Module

).

Menetapkan persekitaran maya
Sekarang mari kita buat persekitaran maya. Ini tidak perlu, tetapi disyorkan, kerana ia mengasingkan kebergantungan dan memastikan persekitaran python selaras dengan yang akan digunakan oleh Lambda. Untuk melakukan ini, dalam konsol di dir projek anda, input

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

Yang pertama membuat python menjalankan modul Venv dengan -m venv dan mewujudkan persekitaran maya yang dipanggil Venv.

yang kedua mengaktifkan persekitaran maya dengan memanggil sumber arahan terbina dalam yang menjalankan skrip pengaktifan persekitaran maya. Jika anda menggunakan kod Visual Studio, ia mungkin mendorong anda untuk beralih ke persekitaran maya. Katakan ya.

selepas ini, anda harus melihat dalam shell anda seperti ini.

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}

(venv) pada mulanya menunjukkan anda berada di persekitaran maya.

Kadang -kadang saya suka debug menjalankan fail python secara langsung dan bukannya dengan alat SAM (kerana ia lebih cepat). Untuk melakukan ini, saya akan memasang semua pakej luaran pada persekitaran maya saya supaya saya dapat menggunakannya secara tempatan untuk pembangunan dan debugging.

Ini hanya perlu untuk debug secara tempatan dan secara langsung tanpa alat SAM, jadi anda boleh melangkau langkah ini jika anda tidak merancang untuk melakukan ini.

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

sekarang kita perlu membungkus lapisan, jadi lambda kami dapat mencari lapisan sebagai pakej python.

Bendera -e -bendera menunjukkan bahawa ini adalah pakej yang boleh diedit. Laluan menunjuk ke mana fail pyproject.toml adalah. Running Ini akan membuat folder baru Layer_utils.egg-Info. Tiada apa -apa yang boleh dilakukan di sana, tinggalkannya.

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

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

Debugging

OK, mari kita lihat bagaimana kita akan debug ini. Ini adalah struktur folder saya dengan lapisan dan lambdas.

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

ini adalah kod lambda saya

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

anda boleh menjalankan fail dan anda harus mendapatkan hasil yang sah tanpa kesilapan.

Jika anda menggunakan kod Visual Studio dengan Pylance, anda mungkin melihat bahawa import lapisan tidak menyelesaikan walaupun kod tersebut telah berfungsi.

Untuk menyelesaikannya, anda boleh mengedit tetapan.json ruang kerja anda. Do Control/Command Shift P, Masukkan Keutamaan: Tetapan Ruang Kerja Terbuka (JSON) dan tambahkan yang berikut di dalam kurungan (jika anda mempunyai lebih banyak extrapaths, tambahkan jalan)

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}

sekarang Pylance harus menyelesaikannya dengan baik.

Menambah lapisan ke timbunan anda

kita perlu sekarang untuk menubuhkan lapisan pada template.yml lambdas anda. Kami perlu menambah perkara berikut di dalam sumber: seksyen (menyesuaikan kandungan mengikut projek anda)

3

Di Contenturi, anda dapat melihat bagaimana ia merujuk kepada laluan relatif di mana kod lapisan itu. Lihat bagaimana ia tidak menunjuk pada folder Python, kerana sistem AWS Sam akan mencari folder Python di sana. Pastikan runtime sepadan dengan yang anda gunakan dalam persekitaran maya anda dan lamnbda anda. Juga, anda perlu merujuk lapisan pada bahagian lambda fail

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

Perhatikan bahawa dalam bahagian lapisan fail templat kami juga mempunyai lapisan permintaan yang sudah ada di AWS kami. Ini akan mewujudkan lapisan tempatan, jadi Sam akan tahu ia perlu membacanya. Ia juga akan menggunakan lapisan ini pada AWS setiap kali anda memanggil AWS Deploy.

Debugging dengan Sam

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

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

mari kita uji ini. Mari kita bina terlebih dahulu. Saya mempunyai masalah dengan membina template dari jalan yang berbeza dari mana ia berada kerana dalam templat terdapat tanda -tanda di mana kod sumbernya. Untuk mengelakkan ini, saya cadangkan untuk membinanya terus dari laluan fail templat.

Ini akan membina semua kebergantungan yang diperlukan.

Sekarang kita boleh memanggilnya. Saya membuat fail acara untuk menguji lambda

3

requests==2.32.2

Sekarang kita boleh menggunakan fail untuk debugging. Ingat bahawa anda memerlukan Docker dipasang dan berjalan untuk ini. Sekali lagi, ingatlah untuk memohon ini dari tempat di mana fail templat.

Ini akan memohon fungsi pada template.yml. Bendera -d bendera menunjukkan bahawa port debug ialah 5678.

Menggunakan Lambda dan Lapisan anda ke AWS

mari kita selesaikan ini dengan menggunakan kod ke AWS.

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

Bendera yang boleh digunakan boleh digunakan pada kali pertama jika anda belum menggunakan Lambda anda, kerana ia akan membantu anda dalam proses. Selepas melakukan ini, anda boleh pergi ke konsol AWS dan mencari lapisan anda. Anda kini boleh menggunakan lapisan dengan lambdas lain dengan menggunakan ARN lapisan.

Menyediakan VSCode ke Debug

Jika anda mahu menggunakan vscode untuk debug, menetapkan titik putus, dan lain -lain, kita perlu melakukan beberapa langkah tambahan.

kita perlu menambah konfigurasi debug. Untuk melakukan ini, lakukan Control/Command Shift P dan Taip Debug: Tambah Konfigurasi .... Ini akan membuka fail launch.json. Anda perlu menambah konfigurasi di sana.

./. Vscode/launch.json

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

Kami menggunakan Debugpy yang akan melekat pada Sam Local Invoke, dan di sini kami menyediakan port 5678 yang kami lihat ketika menggunakan bendera -d. Pastikan LocalRoot menunjuk ke direktori di mana kod Lambda anda. Jika anda mempunyai lebih banyak konfigurasi, tambahkan bahagian di dalam konfigurasi ke senarai.

Kami akan memerlukan perpustakaan debugpy untuk debug. Mari kita tambahkan terlebih dahulu ke keperluan.txt Lambda anda

3

sekarang mari kita pasang dengan 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}

atau anda juga boleh memasangnya melalui fail keperluan.txt

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

kita perlu membuat fail persekitaran di mana kita boleh menentukan pembolehubah persekitaran AWS_SAM_LOCAL yang akan memberitahu lapisan kita bahawa ia berjalan secara tempatan. Kami membuat fail .Env pada folder Workspace kami.

./. Env

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

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

di sini kita menentukan AWS_SAM_LOCAL supaya lambda akan tahu bahawa berjalan secara tempatan melalui AWS Sam.
kita juga perlu memberitahu persekitaran python kita bahawa ia perlu menggunakan pembolehubah persekitaran dari fail persekitaran. Ini adalah bagaimana ia kelihatan seperti

requests==2.32.2

./. Vscode/settings.json

dan akhirnya kita perlu mengubah suai kod Lambda kami supaya ia perlu melampirkan ke debugger ketika menjalankannya secara tempatan. Pada permulaan fail kami, kami akan menambah sekeping kod berikut
./ Lambdas/Mylambda/Src/Lambda_Function.py

python3.12 -m venv venv

source venv/bin/activate

Sekarang, kami memanggil fungsi (sekali lagi, dari jalan di mana fungsi itu):

Apabila konsol menunjukkan menunggu debugger untuk melampirkan ..., tekan F5 atau pilih debugger python: debug menggunakan launch.json

(venv) usar@MacBookPro my-lambda-project

dan sekarang anda sudah bersedia untuk debug lapisan tempatan dan lambdas anda!

Atas ialah kandungan terperinci Buat, debug, dan gunakan kod anda sebagai lapisan AWS Lambda yang boleh diguna semula. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!