

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à.

# Strumentazione del codice Node.js in AWS Lambda
<a name="nodejs-tracing"></a>

Lambda si integra con AWS X-Ray per aiutarti a tracciare, eseguire il debug e ottimizzare le applicazioni Lambda. Puoi utilizzare X-Ray per tracciare una richiesta mentre attraversa le risorse nell'applicazione, che possono includere funzioni Lambda e altri servizi AWS .

Per inviare dati di tracciamento a X-Ray, è possibile utilizzare una delle due librerie SDK:
+ [AWS Distro for OpenTelemetry (ADOT)](https://aws.amazon.com/otel): una distribuzione sicura, pronta per la produzione e supportata dell'SDK (). AWS OpenTelemetry OTel
+ [SDK AWS X-Ray per Node.js](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-nodejs.html): un SDK per generare e inviare i dati di traccia su X-Ray.

Ciascuno di essi SDKs offre modi per inviare i dati di telemetria al servizio X-Ray. Puoi quindi utilizzare X-Ray per visualizzare, filtrare e analizzare le metriche delle prestazioni dell'applicazione per identificare i problemi e le opportunità di ottimizzazione.

**Importante**  
X-Ray e Powertools per AWS Lambda SDKs fanno parte di una soluzione di strumentazione strettamente integrata offerta da. AWS I livelli Lambda ADOT fanno parte di uno standard di settore per la strumentazione di tracciamento che in generale raccoglie più dati, ma potrebbero non essere adatti a tutti i casi d'uso. È possibile implementare il end-to-end tracciamento in X-Ray utilizzando entrambe le soluzioni. Per saperne di più sulla scelta tra di esse, consulta [Scelta tra AWS Distro for Open Telemetry](https://docs.aws.amazon.com/xray/latest/devguide/xray-instrumenting-your-app.html#xray-instrumenting-choosing) e X-Ray. SDKs

**Topics**
+ [

## Utilizzo di ADOT per strumentare le funzioni Node.js
](#nodejs-adot)
+ [

## Utilizzo dell'SDK X-Ray per strumentare le funzioni Node.js
](#nodejs-xray-sdk)
+ [

## Attivazione del tracciamento con la console Lambda
](#nodejs-tracing-console)
+ [

## Attivazione del tracciamento con l'API Lambda
](#nodejs-tracing-api)
+ [

## Attivazione del tracciamento con CloudFormation
](#nodejs-tracing-cloudformation)
+ [

## Interpretazione di una traccia X-Ray
](#nodejs-tracing-interpretation)
+ [

## Memorizzazione delle dipendenze di runtime in un livello (SDK X-Ray)
](#nodejs-tracing-layers)

## Utilizzo di ADOT per strumentare le funzioni Node.js
<a name="nodejs-adot"></a>

ADOT fornisce layer [Lambda](chapter-layers.md) completamente gestiti che racchiudono tutto il necessario per raccogliere dati di telemetria utilizzando l'SDK. OTel Usando questo livello, è possibile strumentare le funzioni Lambda senza dover modificare alcun codice funzione. Puoi anche configurare il tuo layer per eseguire l'inizializzazione personalizzata di. OTel Per ulteriori informazioni, consulta la sezione relativa alla [configurazione personalizzata per ADOT Collector su Lambda](https://aws-otel.github.io/docs/getting-started/lambda#custom-configuration-for-the-adot-collector-on-lambda) nella documentazione di ADOT.

Per i runtime Node.js, puoi aggiungere il **livello Lambda gestito da AWS per ADOT Javascript** per strumentare automaticamente le tue funzioni. Per istruzioni dettagliate su come aggiungere questo layer, consulta [AWS Distro for OpenTelemetry Lambda JavaScript Support](https://aws-otel.github.io/docs/getting-started/lambda/lambda-js) nella documentazione ADOT.

## Utilizzo dell'SDK X-Ray per strumentare le funzioni Node.js
<a name="nodejs-xray-sdk"></a>

Per registrare i dettagli sulle chiamate effettuate dalla funzione Lambda ad altre risorse nell'applicazione, è anche possibile utilizzare il SDK AWS X-Ray per Node.js. Per ottenere l'SDK, aggiungere il pacchetto `aws-xray-sdk-core` alle dipendenze dell'applicazione.

**Example [blank-nodejs/package.json](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/package.json)**  

```
{
  "name": "blank-nodejs",
  "version": "1.0.0",
  "private": true,
  "devDependencies": {
    "jest": "29.7.0"
  },
  "dependencies": {
    "@aws-sdk/client-lambda": "3.345.0",
    "aws-xray-sdk-core": "3.5.3"
  },
  "scripts": {
    "test": "jest"
  }
}
```

Per strumentare i client AWS SDK nella versione [AWS SDK per JavaScript v3](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/welcome.html), avvolgete l'istanza del client con il metodo. `captureAWSv3Client`

**Example [blank- nodejs/function/index .js](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/function/index.js) — Tracciamento di un client SDK AWS**  

```
const AWSXRay = require('aws-xray-sdk-core');
const { LambdaClient, GetAccountSettingsCommand } = require('@aws-sdk/client-lambda');

// Create client outside of handler to reuse
const lambda = AWSXRay.captureAWSv3Client(new LambdaClient());

// Handler
exports.handler = async function(event, context) {
    event.Records.forEach(record => {
  ...
```

Il runtime Lambda imposta alcune variabili di ambiente per configurare l'SDK X-Ray. Ad esempio, Lambda imposta `AWS_XRAY_CONTEXT_MISSING` su `LOG_ERROR` per evitare di generare errori di runtime dall'SDK X-Ray. Per impostare una strategia mancante di contesto personalizzato, sovrascrivi la variabile di ambiente nella configurazione della funzione in modo da non avere alcun valore, quindi puoi impostare la strategia mancante di contesto a livello di programmazione.

**Example Esempio di codice di inizializzazione**  

```
const AWSXRay = require('aws-xray-sdk-core');

// Configure the context missing strategy to do nothing
AWSXRay.setContextMissingStrategy(() => {});
```

Per ulteriori informazioni, consulta [Utilizzo delle variabili di ambiente Lambda](configuration-envvars.md).

Dopo aver aggiunto le dipendenze corrette e aver apportato le modifiche necessarie al codice, attivare il tracciamento nella configurazione della funzione tramite la console Lambda o l'API.

## Attivazione del tracciamento con la console Lambda
<a name="nodejs-tracing-console"></a>

Per attivare il tracciamento attivo sulla funzione Lambda con la console, attenersi alla seguente procedura:

**Per attivare il tracciamento attivo**

1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.

1. Scegliere una funzione.

1. Scegliere **Configuration** (Configurazione) e quindi **Monitoring and operations tools** (Strumenti di monitoraggio e operazioni).

1. In **Strumenti di monitoraggio aggiuntivi** scegli **Modifica**.

1. In **CloudWatch Application Signals e AWS X-Ray**, scegli **Enable** for **Lambda service trace**.

1. Scegli **Save** (Salva).

## Attivazione del tracciamento con l'API Lambda
<a name="nodejs-tracing-api"></a>

Configura il tracciamento sulla tua funzione Lambda con AWS o SDK, utilizza AWS CLI le seguenti operazioni API:
+ [UpdateFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionConfiguration.html)
+ [GetFunctionConfiguration](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConfiguration.html)
+ [CreateFunction](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html)

**Il AWS CLI comando di esempio seguente abilita il tracciamento attivo su una funzione denominata my-function.**

```
aws lambda update-function-configuration --function-name my-function \
--tracing-config Mode=Active
```

La modalità di tracciamento fa parte della configurazione specifica della versione quando si pubblica una versione della funzione. Non è possibile modificare la modalità di tracciamento in una versione pubblicata.

## Attivazione del tracciamento con CloudFormation
<a name="nodejs-tracing-cloudformation"></a>

Per attivare il tracciamento su una `AWS::Lambda::Function` risorsa in un CloudFormation modello, utilizzate la proprietà. `TracingConfig`

**Example [function-inline.yml](https://github.com/awsdocs/aws-lambda-developer-guide/blob/master/templates/function-inline.yml) – Configurazione del tracciamento**  

```
Resources:
  function:
    Type: [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
    Properties:
      TracingConfig:
        Mode: Active
      ...
```

Per una `AWS::Serverless::Function` risorsa AWS Serverless Application Model (AWS SAM), utilizzate la `Tracing` proprietà.

**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml) – Configurazione del tracciamento**  

```
Resources:
  function:
    Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
    Properties:
      Tracing: Active
      ...
```

## Interpretazione di una traccia X-Ray
<a name="nodejs-tracing-interpretation"></a>

La funzione ha bisogno dell'autorizzazione per caricare i dati di traccia su X-Ray. Quando si attiva il tracciamento nella console Lambda, Lambda aggiunge le autorizzazioni necessarie al [ruolo di esecuzione](lambda-intro-execution-role.md) della funzione. Altrimenti, aggiungete la [AWSXRayDaemonWriteAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AWSXRayDaemonWriteAccess)politica al ruolo di esecuzione.

Dopo aver configurato il tracciamento attivo, è possibile osservare richieste specifiche tramite l'applicazione. Il [grafico dei servizi X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html#xray-concepts-servicegraph) mostra informazioni sull'applicazione e tutti i suoi componenti. Il seguente esempio mostra un'applicazione con due funzioni. La funzione principale elabora gli eventi e talvolta restituisce errori. La seconda funzione in alto elabora gli errori che compaiono nel gruppo di log della prima e utilizza l' AWS SDK per chiamare X-Ray, Amazon Simple Storage Service (Amazon S3) e Amazon Logs. CloudWatch 

![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/sample-errorprocessor-servicemap.png)


X-Ray non traccia tutte le richieste nell'applicazione. X-Ray applica un algoritmo di campionamento per garantire che il tracciamento avvenga in modo efficiente, continuando allo stesso tempo a fornire un campione rappresentativo di tutte le richieste. La frequenza di campionamento è di una richiesta al secondo e del 5% delle altre richieste. Non è possibile configurare la frequenza di campionamento di X-Ray per le funzioni.

In X-Ray, una *traccia* registra informazioni su una richiesta elaborata da uno o più *servizi*. Lambda registra 2 segmenti per traccia, che creano due nodi sul grafico del servizio. L'immagine seguente evidenzia questi due nodi:

![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/xray-servicemap-function.png)


Il primo nodo a sinistra rappresenta il servizio Lambda che riceve la richiesta di chiamata. Il secondo nodo rappresenta la specifica funzione Lambda. L'esempio seguente mostra una traccia con questi 2 segmenti. Entrambi sono nominati **my-function**, ma uno ha l'origine `AWS::Lambda` e l'altro ha l'origine `AWS::Lambda::Function`. Se il segmento `AWS::Lambda` mostra un errore, il servizio Lambda ha avuto un problema. Se il `AWS::Lambda::Function` segmento mostra un errore, la funzione ha avuto un problema.

![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/V2_sandbox_images/my-function-2-v1.png)


Questo esempio espande il segmento `AWS::Lambda::Function` per visualizzare i relativi tre sottosegmenti.

**Nota**  
AWS sta attualmente implementando modifiche al servizio Lambda. A causa di queste modifiche, potresti notare piccole differenze tra la struttura e il contenuto dei messaggi di log di sistema e dei segmenti di traccia emessi da diverse funzioni Lambda nel tuo Account AWS.  
La traccia di esempio mostrata qui illustra il segmento di funzione vecchio stile. Le differenze tra i segmenti vecchio e nuovo stile sono descritte nei paragrafi seguenti.  
Queste modifiche verranno implementate nelle prossime settimane e tutte le funzioni, Regioni AWS ad eccezione della Cina e delle GovCloud regioni, passeranno all'utilizzo dei messaggi di registro e dei segmenti di traccia di nuovo formato.

Il segmento di funzioni vecchio stile contiene i seguenti sottosegmenti:
+ **Inizializzazione** – Rappresenta il tempo trascorso a caricare la funzione e ad eseguire il [codice di inizializzazione](foundation-progmodel.md). Questo sottosegmento viene visualizzato solo per il primo evento che viene elaborato da ogni istanza della funzione.
+ **Chiamata**: rappresenta il tempo impiegato per eseguire il codice del gestore.
+ **Overhead**: rappresenta il tempo impiegato dal runtime Lambda per prepararsi a gestire l'evento successivo.

Il segmento di funzione di nuovo stile non contiene un sottosegmento `Invocation`. I sottosegmenti dei clienti sono invece collegati direttamente al segmento di funzioni. Per ulteriori informazioni sulla struttura dei segmenti di funzioni vecchio e nuovo stile, consulta [Informazioni sui monitoraggi di X-Ray](services-xray.md#services-xray-traces).

È inoltre possibile strumentare i client HTTP, registrare query SQL e creare segmenti secondari personalizzati con annotazioni e metadati. Per ulteriori informazioni, consulta [SDK AWS X-Ray per Node.js](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-nodejs.html) nella *Guida per gli sviluppatori di AWS X-Ray *.

**Prezzi**  
Puoi utilizzare il tracciamento X-Ray gratuitamente ogni mese fino a un determinato limite come parte del AWS piano gratuito. Oltre la soglia, X-Ray addebita lo storage di traccia e il recupero. Per ulteriori informazioni, consultare [Prezzi di AWS X-Ray](https://aws.amazon.com/xray/pricing/).

## Memorizzazione delle dipendenze di runtime in un livello (SDK X-Ray)
<a name="nodejs-tracing-layers"></a>

Se utilizzate X-Ray SDK per strumentare i client AWS SDK del codice della funzione, il pacchetto di distribuzione può diventare piuttosto grande. Per evitare di caricare dipendenze di runtime ogni volta che si aggiorna il codice della funzione, includere l'SDK X-Ray in un [livello Lambda](chapter-layers.md).

L'esempio seguente mostra una risorsa `AWS::Serverless::LayerVersion` che memorizza SDK AWS X-Ray per Node.js.

**Example [template.yml](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs/template.yml) – Livello delle dipendenze**  

```
Resources:
  function:
    Type: [AWS::Serverless::Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html)
    Properties:
      CodeUri: function/.
      Tracing: Active
      Layers:
        - !Ref libs
      ...
  libs:
    Type: [AWS::Serverless::LayerVersion](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-layerversion.html)
    Properties:
      LayerName: blank-nodejs-lib
      Description: Dependencies for the blank sample app.
      ContentUri: lib/.
      CompatibleRuntimes:
        - nodejs24.x
```

Con questa configurazione, si aggiorna il livello della libreria solo se si modificano le dipendenze di runtime. Poiché il pacchetto di implementazione della funzione contiene solo il codice, questo può contribuire a ridurre i tempi di caricamento.

La creazione di un layer per le dipendenze richiede modifiche alla compilazione per generare l'archivio dei layer prima della distribuzione. Per un esempio funzionante, vedere l'applicazione di esempio [blank-nodejs](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/blank-nodejs) .