Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Caricamento di dati in streaming da Amazon S3
Puoi usare Lambda per inviare dati al tuo dominio di OpenSearch servizio da Amazon S3. I nuovi dati che arrivano in un bucket S3 attivano una notifica eventi per Lambda, che quindi esegue il codice personalizzato per eseguire l'indicizzazione.
Questo metodo per lo streaming dei dati è estremamente flessibile. Puoi [indicizzare i metadati degli oggetti](https://aws.amazon.com/blogs/database/indexing-metadata-in-amazon-elasticsearch-service-using-aws-lambda-and-python/) oppure, se l'oggetto è un testo normale, analizzare e indicizzare alcuni elementi del corpo dell'oggetto. Questa sezione include alcuni semplici codici Python di esempio in cui sono utilizzate espressioni regolari per analizzare un file di log e indicizzare le corrispondenze.
## Prerequisiti
Prima di procedere, devi disporre delle risorse indicate di seguito.
****
| Prerequisito | Description |
| --- | --- |
| Bucket Amazon S3 | Per ulteriori informazioni, consulta [Creazione del primo bucket S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html) nella Guida per l'utente di Amazon Simple Storage Service. Il bucket deve risiedere nella stessa regione del dominio di servizio. OpenSearch |
| OpenSearch Dominio di servizio | La destinazione dei dati dopo che la funzione Lambda li ha elaborati. Per ulteriori informazioni, consultare [Creazione OpenSearch di domini di servizio](createupdatedomains.md#createdomains). |
## Creazione il pacchetto di implementazione Lambda
I pacchetti di distribuzione sono file ZIP o JAR che includono codice ed eventuali dipendenze. In questa sezione è incluso codice di esempio Python. Per altri linguaggi di programmazione, consultare [Pacchetti di implementazione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) nella *Guida per gli sviluppatori di AWS Lambda *.
1. Crea una directory. In questo esempio utilizziamo il nome `s3-to-opensearch`.
1. Creare un file nella directory denominata `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)
```
Modifica le variabili per `region` e `host`.
1. [Installare pip](https://pip.pypa.io/en/stable/installation/), se non è già stato fatto, quindi installare le dipendenze in una nuova directory `package`:
```
cd s3-to-opensearch
pip install --target ./package requests
pip install --target ./package requests_aws4auth
```
In tutti gli ambienti di esecuzione Lambda è installato [Boto3](https://aws.amazon.com/sdk-for-python/), perciò non è necessario includerlo nel pacchetto di implementazione.
1. Crea un pacchetto con il codice dell'applicazione e le dipendenze:
```
cd package
zip -r ../lambda.zip .
cd ..
zip -g lambda.zip sample.py
```
## Creazione della funzione Lambda
Dopo aver creato il pacchetto di implementazione, è possibile creare la funzione Lambda. Quando si crea una funzione, scegliere nome, runtime (ad esempio, Python 3.8) e ruolo IAM. Il ruolo IAM definisce le autorizzazioni per la tua funzione. Per istruzioni dettagliate, consultare [Creazione di una funzione Lambda con la console](https://docs.aws.amazon.com/lambda/latest/dg/get-started-create-function.html) nella *Guida per gli sviluppatori di AWS Lambda *.
Questo esempio presuppone l'utilizzo della console. Scegli Python 3.9 e un ruolo con autorizzazioni di lettura S3 e autorizzazioni di scrittura del OpenSearch servizio, come mostrato nella schermata seguente:
![\[Configurazione di esempio per una funzione Lambda\]](http://docs.aws.amazon.com/it_it/opensearch-service/latest/developerguide/images/lambda-function.png)
Una volta creata la funzione, devi aggiungere un trigger. In questo esempio, vogliamo che il codice venga eseguito ogni volta che un file di log arriva in un bucket S3:
1. Scegliere **Aggiungi trigger** e selezionare **S3**.
1. Scegli il bucket.
1. Per **Event type (Tipo di evento)**, seleziona **PUT**.
1. In **Prefix (Prefisso)**, digita `logs/`.
1. Per **Suffisso**, digitare `.log`.
1. Confermare l'avviso di chiamata ricorsiva e scegliere **Aggiungi**.
Puoi infine caricare il pacchetto di implementazione:
1. Scegliere **Carica da** e **File .zip**, quindi seguire i prompt su schermo per caricare il pacchetto di implementazione.
1. Al termine del caricamento, modificare il campo **Impostazioni runtime** e cambiare il **gestore** in `sample.handler`. Questa impostazione indica a Lambda il file (`sample.py`) e il metodo (`handler`) da eseguire dopo un trigger.
A questo punto, hai un set completo di risorse: un bucket per i file di registro, una funzione che viene eseguita ogni volta che viene aggiunto un file di registro al bucket, codice che esegue l'analisi e l'indicizzazione e un dominio di servizio per la ricerca e la visualizzazione. OpenSearch
## Test della funzione Lambda
Una volta creata la funzione, è possibile eseguirne il test caricando un file nel bucket Amazon S3. Crea un file denominato `sample.log` utilizzando le righe di log di esempio indicate di seguito:
```
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"
```
Carica il file nella cartella `logs` del bucket S3. Per le istruzioni, consulta [Caricamento di un oggetto nel bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/PuttingAnObjectInABucket.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
Utilizza quindi la console di OpenSearch servizio o le OpenSearch dashboard per verificare che l'indice contenga due documenti. `lambda-s3-index` Puoi anche effettuare una richiesta di ricerca standard:
```
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"
}
}
]
}
}
```