Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Carga de datos de streaming desde Amazon S3
Puede usar Lambda para enviar datos a su dominio de OpenSearch servicio desde Amazon S3. Cuando llegan datos nuevos a un bucket de S3, activan una notificación de eventos en Lambda que, a su vez, ejecuta el código personalizado para realizar la indexación.
Este método de streaming de datos es extremadamente flexible. Es posible [indexar los metadatos del objeto](https://aws.amazon.com/blogs/database/indexing-metadata-in-amazon-elasticsearch-service-using-aws-lambda-and-python/) o, si el objeto contiene texto sin formato, analizar e indexar algunos elementos del cuerpo del objeto. En esta sección, se incluye código de muestra sencillo de Python que utiliza expresiones regulares para analizar un archivo de registros e indexar los resultados obtenidos.
## Requisitos previos
Antes de continuar, debe contar con los siguientes recursos.
****
| Requisito previo | Description (Descripción) |
| --- | --- |
| Bucket de Amazon S3 | Para más información, consulte [Crear su primer bucket de S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) en la Guía del usuario de Amazon Simple Storage Service. El bucket debe residir en la misma región que su dominio OpenSearch de servicio. |
| OpenSearch Dominio de servicio | Es el destino de los datos después de que la función de Lambda los procesa. Para más información, consulte [Creación de dominios OpenSearch de servicio](createupdatedomains.md#createdomains). |
## Crear el paquete de implementación de Lambda
Los paquetes de implementación son archivos ZIP o JAR que contienen el código y sus dependencias. En esta sección, se incluye un código de muestra de Python. Para otros lenguajes de programación, consulte [Paquetes de implementación de Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) en la *Guía para desarrolladores de AWS Lambda *.
1. Cree un directorio. En este ejemplo, utilizamos el nombre `s3-to-opensearch`.
1. Cree un archivo en el directorio denominado `sample.py`:
```
import boto3
import re
import requests
from requests_aws4auth import AWS4Auth
region = '' # e.g. us-west-1
service = 'es'
credentials = boto3.Session().get_credentials()
awsauth = AWS4Auth(credentials.access_key, credentials.secret_key, region, service, session_token=credentials.token)
host = '' # the OpenSearch Service domain, e.g. https://search-mydomain.us-west-1.es.amazonaws.com
index = 'lambda-s3-index'
datatype = '_doc'
url = host + '/' + index + '/' + datatype
headers = { "Content-Type": "application/json" }
s3 = boto3.client('s3')
# Regular expressions used to parse some simple log lines
ip_pattern = re.compile('(\d+\.\d+\.\d+\.\d+)')
time_pattern = re.compile('\[(\d+\/\w\w\w\/\d\d\d\d:\d\d:\d\d:\d\d\s-\d\d\d\d)\]')
message_pattern = re.compile('\"(.+)\"')
# Lambda execution starts here
def handler(event, context):
for record in event['Records']:
# Get the bucket name and key for the new file
bucket = record['s3']['bucket']['name']
key = record['s3']['object']['key']
# Get, read, and split the file into lines
obj = s3.get_object(Bucket=bucket, Key=key)
body = obj['Body'].read()
lines = body.splitlines()
# Match the regular expressions to each line and index the JSON
for line in lines:
line = line.decode("utf-8")
ip = ip_pattern.search(line).group(1)
timestamp = time_pattern.search(line).group(1)
message = message_pattern.search(line).group(1)
document = { "ip": ip, "timestamp": timestamp, "message": message }
r = requests.post(url, auth=awsauth, json=document, headers=headers)
```
Edite las variables para `region` y `host`.
1. [Instale pip](https://pip.pypa.io/en/stable/installation/), si todavía no lo hizo, luego instale las dependencias en un directorio `package` nuevo:
```
cd s3-to-opensearch
pip install --target ./package requests
pip install --target ./package requests_aws4auth
```
Todos los entornos de ejecución de Lambda tienen instalado [Boto3](https://aws.amazon.com/sdk-for-python/), por lo que no es necesario incluirlo en el paquete de implementación.
1. Cree el paquete con el código de la aplicación y las dependencias:
```
cd package
zip -r ../lambda.zip .
cd ..
zip -g lambda.zip sample.py
```
## Crear la función de Lambda
Después de crear el paquete de implementación, puede crear la función de Lambda. Al crear una función, elija un nombre, un tiempo de ejecución (por ejemplo, Python 3.8) y un rol de IAM. El rol de IAM define los permisos para la función. Para obtener instrucciones detalladas, consulte [Create a Lambda function with the consol](https://docs.aws.amazon.com/lambda/latest/dg/get-started-create-function.html) en la *Guía para desarrolladores de AWS Lambda *.
En este ejemplo, se supone que utiliza la consola. Elija Python 3.9 y un rol que tenga permisos de lectura en S3 y permisos de escritura en el OpenSearch servicio, como se muestra en la siguiente captura de pantalla:
![\[Ejemplo de configuración de una función de Lambda\]](http://docs.aws.amazon.com/es_es/opensearch-service/latest/developerguide/images/lambda-function.png)
Después de crear la función, debe agregar un desencadenador. En este ejemplo, queremos que el código se ejecute cada vez que llega un archivo de registros a un bucket de S3:
1. Seleccione **Agregar desencadenador** y Seleccione **S3**.
1. Seleccione el bucket.
1. Para el **Tipo de evento**, elija **PUT**.
1. Para el **Prefijo**, escriba `logs/`.
1. Para el **Sufijo**, escriba `.log`.
1. Reconozca la advertencia de invocación recursiva y elija **Agregar**.
Por último, puede cargar el paquete de implementación:
1. Seleccione **Cargar desde** y **archivo .zip**, luego siga las instrucciones para cargar el paquete de implementación.
1. Una vez finalizada la carga, edite la **Configuración de tiempo de ejecución** y cambie el **Controlador** a `sample.handler`. Esta configuración indica a Lambda el archivo (`sample.py`) y el método (`handler`) que debe ejecutar cuando se produzca un desencadenador.
En este punto, dispone de un conjunto completo de recursos: un depósito para los archivos de registro, una función que se ejecuta cada vez que se añade un archivo de registro al depósito, un código que realiza el análisis y la indexación y un dominio de OpenSearch servicio para la búsqueda y la visualización.
## Prueba de la función de Lambda
Después de crear la función, puede probarla mediante la carga de un archivo en el bucket de Amazon S3. Cree un archivo denominado `sample.log` que contenga los siguientes ejemplos de líneas de registro:
```
12.345.678.90 - [10/Oct/2000:13:55:36 -0700] "PUT /some-file.jpg"
12.345.678.91 - [10/Oct/2000:14:56:14 -0700] "GET /some-file.jpg"
```
Cargue el archivo en la carpeta `logs` del bucket de S3. Para obtener instrucciones, consulte [Carga de un objeto en el bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/PuttingAnObjectInABucket.html) en la *Guía del usuario de Amazon Simple Storage Service*.
A continuación, utilice la consola OpenSearch de servicio o los OpenSearch paneles de control para comprobar que el `lambda-s3-index` índice contiene dos documentos. También puede realizar una petición de búsqueda estándar:
```
GET https://domain-name/lambda-s3-index/_search?pretty
{
"hits" : {
"total" : 2,
"max_score" : 1.0,
"hits" : [
{
"_index" : "lambda-s3-index",
"_type" : "_doc",
"_id" : "vTYXaWIBJWV_TTkEuSDg",
"_score" : 1.0,
"_source" : {
"ip" : "12.345.678.91",
"message" : "GET /some-file.jpg",
"timestamp" : "10/Oct/2000:14:56:14 -0700"
}
},
{
"_index" : "lambda-s3-index",
"_type" : "_doc",
"_id" : "vjYmaWIBJWV_TTkEuCAB",
"_score" : 1.0,
"_source" : {
"ip" : "12.345.678.90",
"message" : "PUT /some-file.jpg",
"timestamp" : "10/Oct/2000:13:55:36 -0700"
}
}
]
}
}
```