Strategi backoff untuk pemanggilan yang gagal Menerapkan tanggapan batch sebagian

Menangani kesalahan untuk sumber peristiwa SQS di Lambda

Untuk menangani kesalahan yang terkait dengan sumber peristiwa SQS, Lambda secara otomatis menggunakan strategi coba lagi dengan strategi backoff. Anda juga dapat menyesuaikan perilaku penanganan kesalahan dengan mengonfigurasi pemetaan sumber peristiwa SQS Anda untuk mengembalikan respons batch sebagian.

Strategi backoff untuk pemanggilan yang gagal

Ketika pemanggilan gagal, Lambda mencoba lagi pemanggilan sambil menerapkan strategi backoff. Strategi backoff sedikit berbeda tergantung pada apakah Lambda mengalami kegagalan karena kesalahan dalam kode fungsi Anda, atau karena pelambatan.

Jika kode fungsi Anda menyebabkan kesalahan, Lambda akan berhenti memproses dan mencoba kembali pemanggilan. Sementara itu, Lambda secara bertahap mundur, mengurangi jumlah konkurensi yang dialokasikan ke pemetaan sumber peristiwa Amazon SQS Anda. Setelah batas waktu visibilitas antrian Anda habis, pesan akan muncul kembali dalam antrian.
Jika pemanggilan gagal karena pelambatan, Lambda secara bertahap menghentikan percobaan ulang dengan mengurangi jumlah konkurensi yang dialokasikan ke pemetaan sumber peristiwa Amazon SQS Anda. Lambda terus mencoba lagi pesan hingga stempel waktu pesan melebihi batas waktu visibilitas antrian Anda, di mana Lambda menghapus pesan.

Menerapkan tanggapan batch sebagian

Saat fungsi Lambda Anda mengalami kesalahan saat memproses batch, semua pesan dalam kumpulan tersebut akan terlihat lagi dalam antrian secara default, termasuk pesan yang berhasil diproses Lambda. Akibatnya, fungsi Anda dapat memproses pesan yang sama beberapa kali.

Untuk menghindari pemrosesan ulang pesan yang berhasil diproses dalam kumpulan yang gagal, Anda dapat mengonfigurasi pemetaan sumber peristiwa agar hanya pesan yang gagal terlihat lagi. Ini disebut respon batch paral. Untuk mengaktifkan respons batch sebagian, tentukan ReportBatchItemFailures FunctionResponseTypestindakan saat mengonfigurasi pemetaan sumber peristiwa Anda. Ini memungkinkan fungsi Anda mengembalikan sebagian keberhasilan, yang dapat membantu mengurangi jumlah percobaan ulang yang tidak perlu pada catatan.

catatan

Utilitas Prosesor Batch dari Powertools untuk AWS Lambda menangani semua logika respons batch paral secara otomatis. Utilitas ini menyederhanakan penerapan pola pemrosesan batch dan mengurangi kode khusus yang diperlukan untuk menangani kegagalan item batch dengan benar. Ini tersedia untuk Python, Java, TypeScript, dan .NET.

Saat ReportBatchItemFailures diaktifkan, Lambda tidak mengurangi polling pesan saat pemanggilan fungsi gagal. Jika Anda mengharapkan beberapa pesan gagal—dan Anda tidak ingin kegagalan tersebut memengaruhi laju pemrosesan pesan—gunakan. ReportBatchItemFailures

catatan

Ingatlah hal berikut saat menggunakan respons batch sebagian:

Jika fungsi Anda melempar pengecualian, seluruh batch dianggap gagal total.
Jika Anda menggunakan fitur ini dengan antrian FIFO, fungsi Anda harus berhenti memproses pesan setelah kegagalan pertama dan mengembalikan semua pesan yang gagal dan belum diproses. batchItemFailures Ini membantu menjaga urutan pesan dalam antrian Anda.

Untuk mengaktifkan pelaporan batch sebagian

Tinjau Praktik terbaik untuk menerapkan respons batch sebagian.
Jalankan perintah berikut ReportBatchItemFailures untuk mengaktifkan fungsi Anda. Untuk mengambil UUID pemetaan sumber acara Anda, jalankan perintah. list-event-source-mappings AWS CLI
```
aws lambda update-event-source-mapping \
--uuid "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE" \
--function-response-types "ReportBatchItemFailures"
```

Perbarui kode fungsi Anda untuk menangkap semua pengecualian dan mengembalikan pesan yang gagal dalam respons batchItemFailures JSON. batchItemFailuresRespons harus menyertakan daftar pesan IDs, sebagai nilai itemIdentifier JSON.

Misalnya, Anda memiliki sekumpulan lima pesan, dengan pesan IDs id1,,id2, id3id4, danid5. Fungsi Anda berhasil memprosesid1,id3, danid5. Untuk membuat pesan id2 dan id4 terlihat lagi dalam antrian Anda, fungsi Anda harus mengembalikan respons berikut:


{ 
  "batchItemFailures": [ 
        {
            "itemIdentifier": "id2"
        },
        {
            "itemIdentifier": "id4"
        }
    ]
}

Berikut adalah beberapa contoh kode fungsi yang mengembalikan daftar pesan gagal IDs dalam batch:

.NET

SDK untuk .NET

catatan

Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori contoh Nirserver.

Melaporkan kegagalan item batch SQS dengan Lambda menggunakan.NET.


// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
using Amazon.Lambda.Core;
using Amazon.Lambda.SQSEvents;

// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace sqsSample;

public class Function
{
    public async Task<SQSBatchResponse> FunctionHandler(SQSEvent evnt, ILambdaContext context)
    {
        List<SQSBatchResponse.BatchItemFailure> batchItemFailures = new List<SQSBatchResponse.BatchItemFailure>();
        foreach(var message in evnt.Records)
        {
            try
            {
                //process your message
                await ProcessMessageAsync(message, context);
            }
            catch (System.Exception)
            {
                //Add failed message identifier to the batchItemFailures list
                batchItemFailures.Add(new SQSBatchResponse.BatchItemFailure{ItemIdentifier=message.MessageId}); 
            }
        }
        return new SQSBatchResponse(batchItemFailures);
    }

    private async Task ProcessMessageAsync(SQSEvent.SQSMessage message, ILambdaContext context)
    {
        if (String.IsNullOrEmpty(message.Body))
        {
            throw new Exception("No Body in SQS Message.");
        }
        context.Logger.LogInformation($"Processed message {message.Body}");
        // TODO: Do interesting work based on the new message
        await Task.CompletedTask;
    }
}

Go

SDK untuk Go V2

catatan

Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori contoh Nirserver.

Melaporkan kegagalan item batch SQS dengan Lambda menggunakan Go.


// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
package main

import (
	"context"
	"fmt"
	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-lambda-go/lambda"
)

func handler(ctx context.Context, sqsEvent events.SQSEvent) (map[string]interface{}, error) {
	batchItemFailures := []map[string]interface{}{}

	for _, message := range sqsEvent.Records {
		if len(message.Body) > 0 {
			// Your message processing condition here
			fmt.Printf("Successfully processed message: %s\n", message.Body)
		} else {
			// Message processing failed
			fmt.Printf("Failed to process message %s\n", message.MessageId)
			batchItemFailures = append(batchItemFailures, map[string]interface{}{"itemIdentifier": message.MessageId})
		}
	}

	sqsBatchResponse := map[string]interface{}{
		"batchItemFailures": batchItemFailures,
	}
	return sqsBatchResponse, nil
}

func main() {
	lambda.Start(handler)
}

Java

SDK untuk Java 2.x

catatan

Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori contoh Nirserver.

Melaporkan kegagalan item batch SQS dengan Lambda menggunakan Java.


// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.SQSEvent;
import com.amazonaws.services.lambda.runtime.events.SQSBatchResponse;
 
import java.util.ArrayList;
import java.util.List;
 
public class ProcessSQSMessageBatch implements RequestHandler<SQSEvent, SQSBatchResponse> {
    @Override
    public SQSBatchResponse handleRequest(SQSEvent sqsEvent, Context context) {
         List<SQSBatchResponse.BatchItemFailure> batchItemFailures = new ArrayList<SQSBatchResponse.BatchItemFailure>();

         for (SQSEvent.SQSMessage message : sqsEvent.getRecords()) {
             try {
                 //process your message
             } catch (Exception e) {
                 //Add failed message identifier to the batchItemFailures list
                 batchItemFailures.add(new SQSBatchResponse.BatchItemFailure(message.getMessageId()));
             }
         }
         return new SQSBatchResponse(batchItemFailures);
     }
}

JavaScript

SDK untuk JavaScript (v3)

catatan

Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori contoh Nirserver.

Melaporkan kegagalan item batch SQS dengan penggunaan JavaScript Lambda.


// Node.js 20.x Lambda runtime, AWS SDK for Javascript V3
export const handler = async (event, context) => {
    const batchItemFailures = [];
    for (const record of event.Records) {
        try {
            await processMessageAsync(record, context);
        } catch (error) {
            batchItemFailures.push({ itemIdentifier: record.messageId });
        }
    }
    return { batchItemFailures };
};

async function processMessageAsync(record, context) {
    if (record.body && record.body.includes("error")) {
        throw new Error("There is an error in the SQS Message.");
    }
    console.log(`Processed message: ${record.body}`);
}

Melaporkan kegagalan item batch SQS dengan penggunaan TypeScript Lambda.


// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
import { SQSEvent, SQSBatchResponse, Context, SQSBatchItemFailure, SQSRecord } from 'aws-lambda';

export const handler = async (event: SQSEvent, context: Context): Promise<SQSBatchResponse> => {
    const batchItemFailures: SQSBatchItemFailure[] = [];

    for (const record of event.Records) {
        try {
            await processMessageAsync(record);
        } catch (error) {
            batchItemFailures.push({ itemIdentifier: record.messageId });
        }
    }

    return {batchItemFailures: batchItemFailures};
};

async function processMessageAsync(record: SQSRecord): Promise<void> {
    if (record.body && record.body.includes("error")) {
        throw new Error('There is an error in the SQS Message.');
    }
    console.log(`Processed message ${record.body}`);
}

PHP

SDK untuk PHP

catatan

Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori contoh Nirserver.

Melaporkan kegagalan item batch SQS dengan Lambda menggunakan PHP.


// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
<?php

use Bref\Context\Context;
use Bref\Event\Sqs\SqsEvent;
use Bref\Event\Sqs\SqsHandler;
use Bref\Logger\StderrLogger;

require __DIR__ . '/vendor/autoload.php';

class Handler extends SqsHandler
{
    private StderrLogger $logger;
    public function __construct(StderrLogger $logger)
    {
        $this->logger = $logger;
    }

    /**
     * @throws JsonException
     * @throws \Bref\Event\InvalidLambdaEvent
     */
    public function handleSqs(SqsEvent $event, Context $context): void
    {
        $this->logger->info("Processing SQS records");
        $records = $event->getRecords();

        foreach ($records as $record) {
            try {
                // Assuming the SQS message is in JSON format
                $message = json_decode($record->getBody(), true);
                $this->logger->info(json_encode($message));
                // TODO: Implement your custom processing logic here
            } catch (Exception $e) {
                $this->logger->error($e->getMessage());
                // failed processing the record
                $this->markAsFailed($record);
            }
        }
        $totalRecords = count($records);
        $this->logger->info("Successfully processed $totalRecords SQS records");
    }
}

$logger = new StderrLogger();
return new Handler($logger);

Python

SDK untuk Python (Boto3)

catatan

Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori contoh Nirserver.

Melaporkan kegagalan item batch SQS dengan Lambda menggunakan Python.


# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0

def lambda_handler(event, context):
    if event:
        batch_item_failures = []
        sqs_batch_response = {}
     
        for record in event["Records"]:
            try:
                print(f"Processed message: {record['body']}")
            except Exception as e:
                batch_item_failures.append({"itemIdentifier": record['messageId']})
        
        sqs_batch_response["batchItemFailures"] = batch_item_failures
        return sqs_batch_response

Ruby

SDK untuk Ruby

catatan

Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori contoh Nirserver.

Melaporkan kegagalan item batch SQS dengan Lambda menggunakan Ruby.


# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
require 'json'

def lambda_handler(event:, context:)
  if event
    batch_item_failures = []
    sqs_batch_response = {}

    event["Records"].each do |record|
      begin
        # process message
      rescue StandardError => e
        batch_item_failures << {"itemIdentifier" => record['messageId']}
      end
    end

    sqs_batch_response["batchItemFailures"] = batch_item_failures
    return sqs_batch_response
  end
end

Rust

SDK untuk Rust

catatan

Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori contoh Nirserver.

Melaporkan kegagalan item batch SQS dengan Lambda menggunakan Rust.


// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
use aws_lambda_events::{
    event::sqs::{SqsBatchResponse, SqsEvent},
    sqs::{BatchItemFailure, SqsMessage},
};
use lambda_runtime::{run, service_fn, Error, LambdaEvent};

async fn process_record(_: &SqsMessage) -> Result<(), Error> {
    Err(Error::from("Error processing message"))
}

async fn function_handler(event: LambdaEvent<SqsEvent>) -> Result<SqsBatchResponse, Error> {
    let mut batch_item_failures = Vec::new();
    for record in event.payload.records {
        match process_record(&record).await {
            Ok(_) => (),
            Err(_) => batch_item_failures.push(BatchItemFailure {
                item_identifier: record.message_id.unwrap(),
            }),
        }
    }

    Ok(SqsBatchResponse {
        batch_item_failures,
    })
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    run(service_fn(function_handler)).await
}

Jika peristiwa gagal tidak kembali ke antrian, lihat Bagaimana cara memecahkan masalah fungsi Lambda SQS? ReportBatchItemFailures di pusat AWS pengetahuan.

Status berhasil dan gagal

Lambda memperlakukan batch sebagai sukses total jika fungsi Anda mengembalikan salah satu dari berikut ini:

Daftar batchItemFailures kosong
Daftar batchItemFailures nol
EventResponse kosong
EventResponse nol

Lambda memperlakukan batch sebagai kegagalan total jika fungsi Anda mengembalikan salah satu dari berikut ini:

Respons JSON yang tidak valid
String itemIdentifier kosong
itemIdentifier nol
itemIdentifier dengan nama kunci yang buruk
itemIdentifierNilai dengan ID pesan yang tidak ada

CloudWatch metrik

Untuk menentukan apakah fungsi Anda melaporkan kegagalan item batch dengan benar, Anda dapat memantau metrik ApproximateAgeOfOldestMessage Amazon SQS NumberOfMessagesDeleted dan Amazon di Amazon. CloudWatch

NumberOfMessagesDeletedmelacak jumlah pesan yang dihapus dari antrian Anda. Jika ini turun ke 0, ini adalah tanda bahwa respons fungsi Anda tidak mengembalikan pesan yang gagal dengan benar.
ApproximateAgeOfOldestMessagemelacak berapa lama pesan tertua telah tinggal di antrian Anda. Peningkatan tajam dalam metrik ini dapat menunjukkan bahwa fungsi Anda tidak mengembalikan pesan yang gagal dengan benar.

Menggunakan Powertools untuk prosesor AWS Lambda batch

Utilitas prosesor batch dari Powertools untuk AWS Lambda secara otomatis menangani logika respons batch paral, mengurangi kompleksitas penerapan pelaporan kegagalan batch. Berikut adalah contoh menggunakan prosesor batch:

Python

catatan

Untuk contoh lengkap dan petunjuk penyiapan, lihat dokumentasi prosesor batch.

Memproses pesan Amazon SQS dengan prosesor AWS Lambda batch.


import json
from aws_lambda_powertools import Logger
from aws_lambda_powertools.utilities.batch import BatchProcessor, EventType, process_partial_response
from aws_lambda_powertools.utilities.data_classes import SQSEvent
from aws_lambda_powertools.utilities.typing import LambdaContext

processor = BatchProcessor(event_type=EventType.SQS)
logger = Logger()

def record_handler(record):
    logger.info(record)
    # Your business logic here
    # Raise an exception to mark this record as failed
    
def lambda_handler(event, context: LambdaContext):
    return process_partial_response(
        event=event, 
        record_handler=record_handler, 
        processor=processor,
        context=context
    )

TypeScript

catatan

Untuk contoh lengkap dan petunjuk penyiapan, lihat dokumentasi prosesor batch.

Memproses pesan Amazon SQS dengan prosesor AWS Lambda batch.


import { BatchProcessor, EventType, processPartialResponse } from '@aws-lambda-powertools/batch';
import { Logger } from '@aws-lambda-powertools/logger';
import type { SQSEvent, Context } from 'aws-lambda';

const processor = new BatchProcessor(EventType.SQS);
const logger = new Logger();

const recordHandler = async (record: any): Promise<void> => {
    logger.info('Processing record', { record });
    // Your business logic here
    // Throw an error to mark this record as failed
};

export const handler = async (event: SQSEvent, context: Context) => {
    return processPartialResponse(event, recordHandler, processor, {
        context,
    });
};

Awas Javascript dinonaktifkan atau tidak tersedia di browser Anda.

Untuk menggunakan Dokumentasi AWS, Javascript harus diaktifkan. Lihat halaman Bantuan browser Anda untuk petunjuk.

Konvensi Dokumen

Perilaku penskalaan

Parameter