As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Usando um pipeline OpenSearch de ingestão com AWS Lambda
<a name="configure-client-lambda"></a>

Use o [AWS Lambda processador](https://opensearch.org/docs/latest/data-prepper/pipelines/configuration/processors/aws-lambda/) para enriquecer dados de qualquer fonte ou destino suportado pela OpenSearch ingestão usando código personalizado. Com o processador do Lambda, você pode aplicar suas próprias transformações ou enriquecimentos de dados e depois retornar os eventos processados ao pipeline para processamento adicional. Esse processador permite o processamento de dados personalizado e oferece total controle sobre como os dados são manipulados antes de passar pelo pipeline.

**nota**  
O limite de tamanho da carga útil para um único evento processado pelo processador do Lambda é de 5 MB. Além disso, o processador do Lambda só é compatível com respostas no formato de matriz JSON.

## Pré-requisitos
<a name="configure-clients-lambda-prereqs"></a>

Antes de criar um pipeline com um processador do Lambda, crie os seguintes recursos:
+ Uma AWS Lambda função que enriquece e transforma seus dados de origem. Para obter instruções, consulte [Criar sua primeira função do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html).
+ Um domínio OpenSearch de serviço ou coleção OpenSearch sem servidor que será o coletor do pipeline. Para obter mais informações, consulte [Criação OpenSearch de domínios de serviço](createupdatedomains.md#createdomains) e [Criação de coleções](serverless-create.md).
+ Um perfil de pipeline que inclui permissões para gravar no coletor do domínio ou da coleção. Para saber mais, consulte [Perfis do pipeline](pipeline-security-overview.md#pipeline-security-sink).

  O perfil do pipeline também precisa de uma política de permissões anexada que permita invocar a função do Lambda especificada na configuração do pipeline. Por exemplo: 

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Sid": "allowinvokeFunction",
              "Effect": "Allow",
              "Action": [
                  "lambda:invokeFunction",
                  "lambda:InvokeAsync",
                  "lambda:ListFunctions"
              ],
              "Resource": "arn:aws:lambda:{{us-east-1}}:{{111122223333}}:function:{{function-name}}"
              
          }
      ]
  }
  ```

------

## Criar um pipeline
<a name="configure-clients-security-lake-pipeline-role"></a>

Para usar AWS Lambda como processador, configure um pipeline OpenSearch de ingestão e especifique `aws_lambda` como processador. Você também pode usar o esquema de **enriquecimento personalizado do AWS Lambda ** para criar o pipeline. Para obter mais informações, consulte [Trabalhar com esquemas](pipeline-blueprint.md).

O exemplo de pipeline a seguir recebe dados de uma fonte HTTP, os enriquece usando um processador de data e o AWS Lambda processador e ingere os dados processados em um domínio. OpenSearch 

```
version: "2"
lambda-processor-pipeline:
  source:
    http:
      path: "/${pipelineName}/logs"
  processor:
      - date:
        destination: "@timestamp"
        from_time_received: true
    - aws_lambda:
        function_name: "my-lambda-function"

        tags_on_failure: ["lambda_failure"]
        batch:
            key_name: "events"
        aws:
          region: {{region}}
  sink:
    - opensearch:
        hosts: [ "https://search-{{mydomain}}.{{us-east-1}}es.amazonaws.com" ]
        index: "table-index"
        aws:
          region: "{{region}}"
          serverless: false
```

A AWS Lambda função de exemplo a seguir transforma os dados recebidos adicionando um novo par de valores-chave (`"transformed": "true"`) a cada elemento na matriz de eventos fornecida e, em seguida, envia de volta a versão modificada.

```
import json

def lambda_handler(event, context):
    input_array = event.get('events', [])
    output = []
    for input in input_array:
        input["transformed"] = "true";
        output.append(input)

    return output
```

## Agrupamento em lotes
<a name="configure-clients-lambda-batching"></a>

Os pipelines enviam eventos em lote para o processador do Lambda e ajustam dinamicamente o tamanho do lote para garantir que fique abaixo do limite de 5 MB.

A seguinte imagem é um exemplo de lote do pipeline:

```
batch:
    key_name: "events"

input_arrary = event.get('events', [])
```

**nota**  
Ao criar um pipeline, certifique-se de que a opção `key_name` na configuração do processador do Lambda corresponda à chave de evento no manipulador do Lambda.

## Filtragem condicional
<a name="configure-clients-lambda-conditional-filtering"></a>

A filtragem condicional permite controlar quando seu AWS Lambda processador invoca a função Lambda com base em condições específicas nos dados do evento. Isso será especialmente útil quando você deseja processar seletivamente certos tipos de evento enquanto ignora outros.

O seguinte exemplo de configuração usa filtragem condicional:

```
processors:
  - aws_lambda:
      function_name: "my-lambda-function"
      aws:
        region: "region"
      lambda_when: "/sourceIp == 10.10.10.10"
```