Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menangani kesalahan untuk sumber peristiwa SQS di Lambda
<a name="services-sqs-errorhandling"></a>

Untuk menangani kesalahan yang terkait dengan sumber peristiwa SQS, Lambda secara otomatis menggunakan strategi coba ulang dengan strategi backoff. Anda juga dapat menyesuaikan perilaku penanganan kesalahan dengan mengonfigurasi pemetaan sumber peristiwa SQS untuk mengembalikan respons [Menerapkan tanggapan batch parsional](#services-sqs-batchfailurereporting) batch parsional.

## Strategi Backoff untuk pemanggilan yang gagal
<a name="services-sqs-backoff-strategy"></a>

Ketika pemanggilan gagal, Lambda mencoba untuk 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 berhenti memproses dan mencoba lagi 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 muncul kembali dalam antrian. 
+ Jika pemanggilan gagal karena pelambatan ****, Lambda secara bertahap membatalkan percobaan ulang dengan mengurangi jumlah konkurensi yang dialokasikan ke pemetaan sumber peristiwa Amazon SQS Anda. Lambda terus mencoba lagi pesan sampai stempel waktu pesan melebihi batas waktu visibilitas antrian Anda, di mana Lambda menjatuhkan pesan.

## Menerapkan tanggapan batch parsional
<a name="services-sqs-batchfailurereporting"></a>

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

Untuk menghindari pemrosesan ulang pesan yang berhasil diproses dalam batch yang gagal, Anda dapat mengonfigurasi pemetaan sumber peristiwa agar hanya pesan yang gagal terlihat lagi. Ini disebut respons batch parsional. Untuk mengaktifkan respons batch parsional, tentukan `ReportBatchItemFailures` [ FunctionResponseTypes ](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateEventSourceMapping.html#lambda-UpdateEventSourceMapping-request-FunctionResponseTypes) tindakan saat mengonfigurasi pemetaan sumber peristiwa Anda. Dengan pengaturan ini, fungsi Anda dapat mengembalikan sebagian keberhasilan, yang dapat membantu mengurangi jumlah percobaan ulang yang tidak perlu pada catatan.

**catatan**  
Utilitas [ Batch Processor ](https://docs.aws.amazon.com/powertools/python/latest/utilities/batch/) dari Powertools untuk AWS Lambda menangani semua logika respons batch parsional 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 pol [ ling pesan ](#services-sqs-backoff-strategy) saat pemanggilan fungsi gagal. Jika Anda mengharapkan beberapa pesan gagal — dan Anda tidak ingin kegagalan tersebut memengaruhi kecepatan pemrosesan pesan — gunakan. `ReportBatchItemFailures`

**catatan**  
Ingatlah hal berikut saat menggunakan respons batch parsional:  
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 tidak diproses. `batchItemFailures` Ini membantu menjaga urutan pesan dalam antrian Anda.

**Untuk mengaktifkan pelaporan batch parsional**

1. Tinjau Prakti [ k terbaik untuk menerapkan tanggapan batch parsional](https://docs.aws.amazon.com/prescriptive-guidance/latest/lambda-event-filtering-partial-batch-responses-for-sqs/best-practices-partial-batch-responses.html).

1. Jalankan perintah berikut `ReportBatchItemFailures` untuk mengaktifkan fungsi Anda. Untuk mengambil UUID pemetaan sumber acara Anda, jalankan perintah [ list-event- ](https://docs.aws.amazon.com/cli/latest/reference/lambda/list-event-source-mappings.html) AWS CLI source-mappings.

   ```
   aws lambda update-event-source-mapping \
   --uuid {{"a1b2c3d4-5678-90ab-cdef-11111EXAMPLE"}} \
   --function-response-types "ReportBatchItemFailures"
   ```

1. Perbarui kode fungsi Anda untuk menangkap semua pengecualian dan mengembalikan pesan yang gagal dalam respons `batchItemFailures` JSON. Resp `batchItemFailures` ons harus menyertakan daftar ID pesan, sebagai nilai `itemIdentifier` JSON.

   Misalnya, Anda memiliki kumpulan lima pesan, dengan ID pesan`id1`,, `id2``id3`,`id4`, dan`id5`. Fungsi Anda berhasil memproses`id1`,`id3`, dan`id5`. 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 ID pesan gagal dalam batch:

------
#### [ .NET ]

**SDK untuk .NET**  
 Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-sqs-report-batch-item-failures). 
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**  
 Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-sqs-report-batch-item-failures). 
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**  
 Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-sqs-report-batch-item-failures). 
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)**  
 Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-sqs-report-batch-item-failures). 
Melaporkan kegagalan item batch SQS dengan menggunakan Lambda. JavaScript  

   ```
   // 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 menggunakan Lambda. TypeScript  

   ```
   // 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**  
 Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-sqs-report-batch-item-failures). 
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)**  
 Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-sqs-report-batch-item-failures). 
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**  
 Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/integration-sqs-to-lambda-with-batch-item-handling). 
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 for Rust**  
 Ada lebih banyak tentang GitHub. Temukan contoh lengkapnya dan pelajari cara mengatur dan menjalankannya di repositori [contoh Nirserver](https://github.com/aws-samples/serverless-snippets/tree/main/lambda-function-sqs-report-batch-item-failures). 
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 yang gagal tidak kembali ke antrian, lihat [ Bagaimana cara memecahkan masalah fungsi Lambda SQS? ReportBatchItemFailures ](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-sqs-report-batch-item-failures/)di Pusat Peng AWS etahuan.

### Status berhasil dan gagal
<a name="sqs-batchfailurereporting-conditions"></a>

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
+ `itemIdentifier`Nilai dengan ID pesan yang tidak ada

### CloudWatch metrik
<a name="sqs-batchfailurereporting-metrics"></a>

Untuk menentukan apakah fungsi Anda melaporkan kegagalan item batch dengan benar, Anda dapat memantau metrik `NumberOfMessagesDeleted` dan `ApproximateAgeOfOldestMessage` Amazon SQS di Amazon CloudWatch.
+ `NumberOfMessagesDeleted`melacak 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.
+ `ApproximateAgeOfOldestMessage`melacak berapa lama pesan tertua tetap berada di antrian Anda. Peningkatan tajam dalam metrik ini dapat menunjukkan bahwa fungsi Anda tidak mengembalikan pesan yang gagal dengan benar.

### Menggunakan Powertools untuk AWS Lambda prosesor batch
<a name="services-sqs-batchfailurereporting-powertools"></a>

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

**Python**  
Untuk contoh lengkap dan petunjuk penyiapan, lihat dokumentasi prosesor [ batch](https://docs.aws.amazon.com/powertools/python/latest/utilities/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**  
Untuk contoh lengkap dan petunjuk penyiapan, lihat dokumentasi prosesor [ batch](https://docs.aws.amazon.com/powertools/typescript/latest/features/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,
    });
};
```