Dari Docker ke Lambda: Perjalanan Pentadbir AWS ke dalam Aplikasi Python

Daripada Skrip Python kepada AWS Tanpa Pelayan: Perjalanan Portfolio Pelaburan Saya

Saya bermula dengan skrip Python mudah untuk automasi AWS, secara beransur-ansur berkembang menjadi projek yang lebih kompleks. Tiga bulan yang lalu, saya hampir tidak memahami metaclass; kini, saya telah membina pengurus portfolio pelaburan sepenuhnya.

Perjalanan Saya

Bertahun-tahun menggunakan Python untuk automasi AWS (termasuk skrip "does-everything" yang terkenal itu) membawa saya membina aplikasi yang betul. Dengan memanfaatkan skrip lepas saya, Stack Overflow dan bantuan AI Claude, akhirnya saya memahami prinsip pembangunan perisian.

Tangkapan skrin apl (data benih, bukan pelaburan sebenar).

Bosan dengan kemas kini hamparan Excel manual untuk portfolio pelaburan saya, saya mengautomasikan proses tersebut. Aplikasi Python ini menguruskan portfolio, menjejaki transaksi, memproses dividen, dan juga mengemas kini harga secara automatik. Pada mulanya, ia berjalan dengan indah dalam Docker pada pelayan rumah saya (Flask backend, React frontend, pangkalan data SQLite).

Teka-teki "Hobi Menjadi Pekerjaan"

Menjalankan ini pada pelayan rumah saya berasa tidak cekap. Sebagai seorang profesional AWS, mengurus bekas pada perkakasan saya kelihatan berlawanan dengan intuitif. Penyelesaiannya kelihatan jelas: ECS. Saya sudah mempunyai docker-compose fail:

<code>services:
  backend:
    build: ./backend
    container_name: investment-portfolio-backend
    environment:
      - DB_DIR=/data/db
      - LOG_DIR=/data/logs
      - DOMAIN=${DOMAIN:-localhost}
    volumes:
      - /path/to/your/data:/data
    networks:
      - app-network

  frontend:
    build:
      context: ./frontend
      args:
        - DOMAIN=${DOMAIN:-localhost}
        - USE_HTTPS=${USE_HTTPS:-false}
    container_name: investment-portfolio-frontend
    environment:
      - DOMAIN=${DOMAIN:-localhost}
      - USE_HTTPS=${USE_HTTPS:-false}
    ports:
      - "80:80"
    depends_on:
      - backend
    networks:
      - app-network</code>

Walau bagaimanapun, perspektif arkitek AWS (dan kalkulator harga) mencadangkan pendekatan tanpa pelayan:

• Kemas kini harga harian dan akses yang jarang dicadangkan untuk mengelakkan bekas 24/7.
• Fail bahagian hadapan statik sesuai untuk pengehosan tapak web S3.
• API Gateway dan Lambda akan mengendalikan panggilan API.
• Tanpa Pelayan Aurora sesuai dengan data hubungan.
• DynamoDB boleh menyimpan sejarah harga (walaupun saya tidak mencapai tahap ini).

Ini membawa saya ke lubang arnab tanpa pelayan. Saya mempunyai pengalaman tanpa pelayan sebelum ini – projek penjejakan suhu dengan isteri saya, menggunakan data KNMI dan menjana jadual berkod warna untuk projek kerajinan.

<code>| Date       | Min.Temp | Min.Kleur   | Max.Temp | Max.Kleur   |
----------------------------------------------------------------
| 2023-03-01 |   -4.1°C | darkblue   |    7.1°C | lightblue  |
| 2023-03-02 |    1.3°C | blue       |    6.8°C | lightblue  |
...</code>

Projek ini dijalankan secara tempatan atau melalui Lambda/API Gateway, mengambil parameter tarikh. Menskalakan ini kepada aplikasi Flask penuh dengan SQLAlchemy, kerja latar belakang dan perhubungan yang kompleks terbukti mencabar.

Pesona Tanpa Pelayan

Aplikasi kontena saya berfungsi dengan baik, tetapi daya tarikan perkhidmatan tanpa pelayan adalah kuat. Potensi untuk penskalaan automatik dan penyingkiran pengurusan kontena sangat menarik.

Jadi, saya mereka bina semula aplikasi saya untuk persekitaran tanpa pelayan. Projek asal mengambil masa dua bulan; ini akan menjadi mudah... atau begitulah yang saya fikirkan.

Keputusan Pangkalan Data

Keterbatasan SQLite dengan Lambda menyebabkan saya mempertimbangkan PostgreSQL Aurora Serverless, mengekalkan keserasian dengan pengetahuan SQLAlchemy saya. Saya mencipta dwi-pengendali:

<code>services:
  backend:
    build: ./backend
    container_name: investment-portfolio-backend
    environment:
      - DB_DIR=/data/db
      - LOG_DIR=/data/logs
      - DOMAIN=${DOMAIN:-localhost}
    volumes:
      - /path/to/your/data:/data
    networks:
      - app-network

  frontend:
    build:
      context: ./frontend
      args:
        - DOMAIN=${DOMAIN:-localhost}
        - USE_HTTPS=${USE_HTTPS:-false}
    container_name: investment-portfolio-frontend
    environment:
      - DOMAIN=${DOMAIN:-localhost}
      - USE_HTTPS=${USE_HTTPS:-false}
    ports:
      - "80:80"
    depends_on:
      - backend
    networks:
      - app-network</code>

Keluk Pembelajaran Lambda

Menukar aplikasi Flask saya kepada fungsi Lambda adalah lebih kompleks daripada yang dijangkakan. Percubaan awal saya kekok:

<code>| Date       | Min.Temp | Min.Kleur   | Max.Temp | Max.Kleur   |
----------------------------------------------------------------
| 2023-03-01 |   -4.1°C | darkblue   |    7.1°C | lightblue  |
| 2023-03-02 |    1.3°C | blue       |    6.8°C | lightblue  |
...</code>

Untuk meningkatkan kebolehselenggaraan, saya mencipta penghias:

<code>@contextmanager
def db_session():
    # ... (code for environment-aware database session management) ...</code>

Struktur fungsi Lambda yang dipertingkatkan ini:

<code># ... (initial, inefficient Lambda handler code) ...</code>

Walau bagaimanapun, ini memecahkan laluan Flask asal. Penghias baharu mendayakan dwi fungsi:

<code>def lambda_response(func):
    # ... (decorator for cleaner Lambda responses) ...</code>

Fungsi sokongan memastikan tindak balas yang konsisten:

<code>@lambda_response
def get_portfolios(event, context):
    # ... (simplified Lambda function) ...</code>

Ini dibenarkan menggunakan laluan yang sama untuk Flask dan Lambda:

<code>def dual_handler(route_path, methods=None):
    # ... (decorator for both Flask routes and Lambda handlers) ...</code>

Kesederhanaan Depan

Halaman hadapan adalah mudah. Pengehosan laman web statik S3 dan CloudFront menyediakan penggunaan mudah. Skrip mudah memuat naik bahagian hadapan ke S3 dan membatalkan cache CloudFront:

<code>def create_lambda_response(flask_response):
    # ... (function to convert Flask response to Lambda response format) ...

def create_flask_request(event):
    # ... (function to convert Lambda event to Flask request) ...</code>

Hasilnya

Selepas berminggu-minggu bekerja, permohonan saya tanpa pelayan. Walaupun saya tidak akan menyimpannya dalam talian kerana kebimbangan keselamatan, saya belajar pelajaran berharga:

1. Keupayaan Python melangkaui skrip.
2. Tier Percuma AWS tidak ternilai untuk pembangunan.
3. Log CloudWatch adalah penting untuk nyahpepijat.
4. Cara "betul" tidak selalunya cara AWS.

Adakah saya akan mengulangi ini? Mungkin tidak. Tetapi perjalanan itu memberi ganjaran, mengajar saya tentang Python dan pembangunan dwi-tindanan. Pengurus portfolio pelaburan saya kini berjalan dengan selamat pada rangkaian peribadi saya.

Atas ialah kandungan terperinci Dari Docker ke Lambda: Perjalanan Pentadbir AWS ke dalam Aplikasi Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!