Pembangunan AWS Lambda Tanpa Pelayan · Pelajaran

Membina Sistem Tanpa Pelayan yang Berdaya Tahan

Reka bentuk seni bina tanpa pelayan yang sangat tersedia dan tahan terhadap kegagalan dengan menerapkan corak seperti pemutus litar, percubaan semula dan keidempotenan merentas fungsi anda.

Pelajaran 2 daripada 411 langkah

Membina Sistem Tanpa Pelayan yang Berdaya Tahan ialah pelajaran Pembangunan AWS Lambda Tanpa Pelayan percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Pembangunan AWS Lambda Tanpa Pelayan, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Pembangunan AWS Lambda Tanpa Pelayan merangkumi sejumlah 4 pelajaran.

Membina Sistem Tanpa Pelayan yang Kukuh

Selamat datang! Dalam pelajaran ini, kita akan mendalami reka bentuk aplikasi tanpa pelayan yang sangat berdaya tahan dan tahan terhadap kegagalan. Walaupun AWS mengurus sebahagian besar infrastruktur, fungsi anda masih perlu menangani kegagalan dengan baik.

Kita akan meneroka corak seni bina utama untuk memastikan aplikasi anda kekal stabil dan berprestasi baik walaupun berlaku masalah.

Realiti Sistem Teragih

Dalam dunia tanpa pelayan, fungsi anda sering berinteraksi dengan banyak perkhidmatan lain: pangkalan data, API dan baris gilir mesej. Interaksi ini berlaku melalui rangkaian, dan rangkaian boleh menjadi tidak boleh dipercayai.

Kegagalan Sementara: Gangguan rangkaian singkat atau kelembapan perkhidmatan.
Masalah Perkhidmatan Hiliran: Perkhidmatan yang dipanggil oleh Lambda anda mungkin tidak tersedia buat sementara waktu.
Data Tidak Dijangka: Input yang tidak mengikut format boleh menyebabkan fungsi anda terhenti.

Mereka bentuk sistem dengan mengambil kira "kegagalan" ini adalah penting untuk memastikan sistem stabil.

Logik Percubaan Semula Terbina dalam Lambda

Untuk jenis penggunaan tertentu, AWS Lambda akan mencuba semula fungsi anda secara automatik jika fungsi tersebut gagal. Ini ialah mekanisme daya tahan terbina dalam yang berkuasa untuk penggunaan tak segerak.

Contohnya, jika baris gilir SQS mencetuskan Lambda anda dan fungsi anda menghasilkan ralat, Lambda (atau SQS) akan mencuba semula penggunaan tersebut beberapa kali. Ini membantu mengatasi masalah sementara tanpa sebarang perubahan kod.

Walau bagaimanapun, percubaan semula bukanlah penyelesaian untuk semua masalah; jika tidak dikendalikan dengan teliti, percubaan ini boleh menyebabkan pemprosesan pendua.

Menjadikan Operasi Idempoten

Apabila percubaan semula berlaku, fungsi anda mungkin melaksanakan operasi yang sama beberapa kali. Di sinilah keidempotenan diperlukan.

Operasi idempoten ialah operasi yang boleh digunakan beberapa kali tanpa mengubah hasil selepas penggunaan pertama.

Contoh: Menetapkan nilai (x = 5) adalah idempoten.
Bukan Contoh: Menambah nilai (x++) BUKAN idempoten kerana setiap percubaan semula akan mengubah nilai tersebut.

Bagi sistem yang berdaya tahan, banyak operasi sepatutnya diusahakan supaya bersifat idempoten.

Kunci kepada Fungsi Idempoten

Untuk menjadikan fungsi Lambda anda idempoten, anda biasanya perlu menjejaki keadaan sesuatu permintaan. Langkah ini lazimnya melibatkan:

Menjana Kunci Keidempotenan yang unik bagi setiap permintaan (contohnya, daripada ID permintaan atau ID sumber acara).
Memeriksa sama ada kunci ini telah diproses sebelum melaksanakan logik teras.
Menyimpan hasil atau status operasi yang dikaitkan dengan kunci tersebut.

Ini memastikan bahawa walaupun fungsi dicuba semula, kesan sampingan teras hanya berlaku sekali.

import hashlib
import json

# Imagine a database or cache for storing processed requests
# For simplicity, using a global dict here. A real app uses persistent storage.
processed_requests = {}

def is_idempotent(event_payload):
    # Create a unique key from the event payload
    # For a real app, use a proper hashing/unique ID strategy
    event_hash = hashlib.md5(json.dumps(event_payload, sort_keys=True).encode('utf-8')).hexdigest()

    if event_hash in processed_requests:
        print(f"Request with hash {event_hash} already processed.")
        return True
    
    processed_requests[event_hash] = "processing" # Mark as processing
    return False

def lambda_handler(event, context):
    if is_idempotent(event):
        return {
            'statusCode': 200,
            'body': json.dumps('Request already processed or is being processed.')
        }

    # Simulate actual work (e.g., writing to a database)
    print(f"Processing new request: {event}")
    
    # In a real scenario, update processed_requests[event_hash] = "completed"
    # after successful processing and store the result in persistent storage.
    
    return {
        'statusCode': 200,
        'body': json.dumps('Request processed successfully!')
    }

Mencegah Kegagalan Berantai

Corak Pemutus Litar ialah cara yang berkuasa untuk mencegah perkhidmatan yang gagal daripada menyebabkan kegagalan berantai di seluruh aplikasi anda.

Bayangkan panggilan kepada API luaran yang mula mengalami kegagalan. Percubaan semula secara berterusan hanya akan membazirkan sumber dan memperlahankan fungsi anda. Pemutus litar mengesan keadaan ini lalu "membuka" litar, dan menghentikan panggilan kepada perkhidmatan yang gagal buat sementara waktu.

Ini memberikan masa kepada perkhidmatan yang gagal untuk pulih serta mencegah aplikasi anda daripada terbeban.

Cara Pemutus Litar Berfungsi

Pemutus litar biasanya mempunyai tiga keadaan:

Tertutup: Operasi berjalan seperti biasa. Jika kegagalan melebihi ambang, keadaan berubah kepada Terbuka.
Terbuka: Semua panggilan kepada perkhidmatan yang dilindungi gagal serta-merta (atau mengembalikan pilihan sandaran). Selepas tempoh tamat masa, keadaan berubah kepada Separuh Terbuka.
Separuh Terbuka: Sebilangan terhad panggilan ujian dibenarkan. Jika panggilan ini berjaya, keadaan berubah kembali kepada Tertutup. Jika gagal, keadaan kembali kepada Terbuka.

Tingkah laku pintar ini membolehkan pemulihan kendiri.

Melaksanakan Pemutus Litar Ringkas

Pelaksanaan pemutus litar lengkap melibatkan pengurusan keadaan (kegagalan, bilangan kejayaan dan masa kegagalan terakhir). Untuk aplikasi tanpa pelayan, keadaan ini mungkin disimpan dalam cache dikongsi (seperti ElastiCache) atau pangkalan data.

Walaupun pelaksanaan dari awal dalam Lambda ringkas adalah rumit, memahami logiknya adalah penting. Pustaka tersedia untuk pelbagai bahasa bagi membantu anda, atau anda boleh menggunakan perkhidmatan AWS seperti Step Functions untuk mengatur logik percubaan semula dengan kelewatan.

import time

class CircuitBreaker:
    def __init__(self, failure_threshold=3, reset_timeout=5):
        self.state = "CLOSED"
        self.failure_count = 0
        self.last_failure_time = 0
        self.failure_threshold = failure_threshold
        self.reset_timeout = reset_timeout # seconds

    def call(self, func, *args, **kwargs):
        if self.state == "OPEN":
            if time.time() - self.last_failure_time > self.reset_timeout:
                self.state = "HALF-OPEN"
                # In a real app, log this state change
            else:
                raise Exception("Circuit is open, service unavailable.")
        
        try:
            result = func(*args, **kwargs)
            if self.state == "HALF-OPEN":
                self.state = "CLOSED"
                self.failure_count = 0
                # In a real app, log this state change
            return result
        except Exception as e:
            self.failure_count += 1
            self.last_failure_time = time.time()
            if self.failure_count >= self.failure_threshold:
                self.state = "OPEN"
                # In a real app, log this state change
            raise e

Had Masa Mencegah Proses Tergantung

Satu lagi corak daya tahan yang penting ialah menggunakan had masa untuk panggilan luaran. Jika fungsi Lambda anda memanggil perkhidmatan lain (contohnya, pangkalan data atau API HTTP), panggilan tersebut mungkin tergantung selama-lamanya jika perkhidmatan itu tidak memberikan respons.

Menetapkan had masa memastikan fungsi anda tidak menunggu selama-lamanya, membebaskan sumber dan membolehkan logik percubaan semula bermula dengan lebih cepat. AWS Lambda sendiri mempunyai had masa yang boleh dikonfigurasikan, tetapi anda juga harus menetapkan had masa dalam kod anda untuk permintaan luaran tertentu.

Cabaran Reka Bentuk Berdaya Tahan

Pertimbangkan fungsi Lambda yang memproses pesanan masuk. Jika fungsi tersebut gagal selepas berjaya menolak bayaran tetapi sebelum mengemas kini status pesanan dalam pangkalan data, kemudian fungsi itu dicuba semula, apakah masalah yang mungkin berlaku jika penolakan bayaran BUKAN idempoten?

Jawab dalam pelajaran interaktif

Ringkasan: Membina Sistem untuk Menangani Kegagalan

Kita telah membincangkan corak penting untuk membina aplikasi tanpa pelayan yang berdaya tahan:

Percubaan Semula: Mekanisme terbina dalam Lambda untuk menangani ralat sementara.
Keidempotenan: Memastikan operasi boleh dicuba semula dengan selamat tanpa kesan sampingan yang tidak diingini (contohnya, caj pendua).
Pemutus Litar: Mencegah kegagalan berantai dengan menghentikan panggilan kepada perkhidmatan yang gagal secara bijak.
Had Masa: Melindungi daripada perkhidmatan luaran yang tidak memberikan respons.

Dengan menerapkan prinsip ini, anda boleh mencipta sistem tanpa pelayan yang menangani kegagalan yang tidak dapat dielakkan dengan baik.

Percuma untuk bermula

Pelajari Pembangunan AWS Lambda Tanpa Pelayan dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 12
Pelajaran: 48

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Membina Sistem Tanpa Pelayan yang Berdaya Tahan” percuma?

Ya — teks penuh “Membina Sistem Tanpa Pelayan yang Berdaya Tahan” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Pembangunan AWS Lambda Tanpa Pelayan, tingkat taraf kepada CoddyKit PRO. Kursus Pembangunan AWS Lambda Tanpa Pelayan merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Membina Sistem Tanpa Pelayan yang Berdaya Tahan”?

Reka bentuk seni bina tanpa pelayan yang sangat tersedia dan tahan terhadap kegagalan dengan menerapkan corak seperti pemutus litar, percubaan semula dan keidempotenan merentas fungsi anda. Anda berlatih Pembangunan AWS Lambda Tanpa Pelayan menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Pembangunan AWS Lambda Tanpa Pelayan?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Pembangunan AWS Lambda Tanpa Pelayan di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Membina Sistem Tanpa Pelayan yang Berdaya Tahan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Pembangunan AWS Lambda Tanpa Pelayan ini?

Ya. Setiap pelajaran Pembangunan AWS Lambda Tanpa Pelayan menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Pengedaran Canary dan Biru/Hijau
Membina Sistem Tanpa Pelayan yang Berdaya Tahan
Corak Seni Bina Tanpa Pelayan
Pengoptimuman Kos dalam Seni Bina Tanpa Pelayan

← Kembali ke Pembangunan AWS Lambda Tanpa Pelayan