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

# Recuperare dati sulle funzioni Lambda che utilizzano un runtime obsoleto
<a name="runtimes-list-deprecated"></a>

Quando un runtime Lambda sta per diventare obsoleto, Lambda ti avvisa tramite e-mail e fornisce notifiche al termine. Health Dashboard Trusted Advisor Queste e-mail e notifiche elencano le versioni \$1LATEST delle funzioni che utilizzano il runtime. Per elencare tutte le versioni delle funzioni che utilizzano un determinato runtime, puoi usare il () o uno dei AWS Command Line Interface .AWS CLI AWS SDKs

Se disponi di un gran numero di funzioni che utilizzano un runtime destinato a diventare obsoleto, puoi anche usare AWS CLI or AWS SDKs per aiutarti a dare priorità agli aggiornamenti delle funzioni richiamate più comunemente.

Fate riferimento alle seguenti sezioni per imparare a utilizzare AWS CLI e AWS SDKs raccogliere dati sulle funzioni che utilizzano un particolare runtime.

## Elenco delle versioni delle funzioni che utilizzano un determinato runtime
<a name="runtimes-list-deprecated-versions"></a>

Per utilizzare AWS CLI per elencare tutte le versioni delle funzioni che utilizzano un determinato runtime, esegui il comando seguente. Sostituiscilo `RUNTIME_IDENTIFIER` con il nome del runtime che è diventato obsoleto e scegli il tuo. Regione AWS Per elencare solo le versioni della funzione \$1LATEST, ometti `--function-version ALL` dal comando.

```
aws lambda list-functions --function-version ALL --region us-east-1 --output text --query "Functions[?Runtime=='RUNTIME_IDENTIFIER'].FunctionArn" 
```

**Suggerimento**  
Il comando di esempio elenca le funzioni nella `us-east-1` regione per una determinata regione. Account AWS Dovrai ripetere questo comando per ogni regione in cui il tuo account ha funzioni e per ognuna delle tue. Account AWS

Puoi anche elencare le funzioni che utilizzano un particolare runtime utilizzando uno dei AWS SDKs. Il codice di esempio seguente utilizza V3 AWS SDK per JavaScript e the AWS SDK per Python (Boto3) per restituire un elenco della funzione ARNs per le funzioni che utilizzano un determinato runtime. Il codice di esempio restituisce anche il gruppo di CloudWatch log per ciascuna delle funzioni elencate. È possibile utilizzare questo gruppo di log per trovare la data dell'ultima invocazione per la funzione. Per ulteriori informazioni, consulta la sezione [Identificazione delle funzioni richiamate più di frequente e più di recente](#runtimes-list-deprecated-statistics) seguente.

------
#### [ Node.js ]

**Example JavaScript codice per elencare le funzioni utilizzando un particolare runtime**  

```
import { LambdaClient, ListFunctionsCommand } from "@aws-sdk/client-lambda";
const lambdaClient = new LambdaClient();

const command = new ListFunctionsCommand({
    FunctionVersion: "ALL",
    MaxItems: 50
});
const response = await lambdaClient.send(command);

for (const f of response.Functions){
    if (f.Runtime == '<your_runtime>'){ // Use the runtime id, e.g. 'nodejs24.x' or 'python3.14'
        console.log(f.FunctionArn);
        // get the CloudWatch log group of the function to
        // use later for finding the last invocation date
        console.log(f.LoggingConfig.LogGroup);
    }   
}
// If your account has more functions than the specified
// MaxItems, use the returned pagination token in the 
// next request with the 'Marker' parameter
if ('NextMarker' in response){
    let paginationToken = response.NextMarker;
  }
```

------
#### [ Python ]

**Example Codice Python per elencare le funzioni utilizzando un particolare runtime**  

```
import boto3
from botocore.exceptions import ClientError

def list_lambda_functions(target_runtime):

    lambda_client = boto3.client('lambda')
    
    response = lambda_client.list_functions(
        FunctionVersion='ALL',
        MaxItems=50
    )
    if not response['Functions']:
            print("No Lambda functions found")
    else: 
        for function in response['Functions']:   
            if function['PackageType']=='Zip' and function['Runtime'] == target_runtime: 
                print(function['FunctionArn'])
                # Print the CloudWatch log group of the function
                # to use later for finding last invocation date
                print(function['LoggingConfig']['LogGroup'])

    if 'NextMarker' in response:
       pagination_token = response['NextMarker']

if __name__ == "__main__":
    # Replace python3.12 with the appropriate runtime ID for your Lambda functions
    list_lambda_functions('python3.12')
```

------

Per ulteriori informazioni sull'utilizzo di un AWS SDK per elencare le funzioni utilizzando l'[ListFunctions](https://docs.aws.amazon.com/lambda/latest/api/API_ListFunctions.html)azione, consulta la [documentazione SDK relativa](https://aws.amazon.com/developer/tools/) al linguaggio di programmazione preferito.

Puoi anche utilizzare la funzionalità Interrogazioni AWS Config avanzate per elencare tutte le funzioni che utilizzano un runtime interessato. Questa query restituisce solo le versioni della funzione \$1LATEST, ma è possibile aggregare le query per elencare le funzioni in tutte le regioni e più regioni Account AWS con un solo comando. *Per ulteriori informazioni, consulta [Interrogazione dello stato di configurazione corrente delle AWS Auto Scaling risorse](https://docs.aws.amazon.com/config/latest/developerguide/querying-AWS-resources.html) nella Guida per gli sviluppatori.AWS Config *

## Identificazione delle funzioni richiamate più di frequente e più di recente
<a name="runtimes-list-deprecated-statistics"></a>

Se il tuo Account AWS file contiene funzioni che utilizzano un runtime che sta per essere obsoleto, potresti voler dare priorità all'aggiornamento delle funzioni che vengono richiamate di frequente o delle funzioni che sono state richiamate di recente.

Se disponi solo di poche funzioni, puoi utilizzare la console CloudWatch Logs per raccogliere queste informazioni esaminando i flussi di registro delle tue funzioni. Per ulteriori informazioni, consulta [Visualizzare i dati di registro inviati ai CloudWatch registri.](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData)

Per vedere il numero di chiamate di funzioni recenti, puoi anche utilizzare le informazioni sulle CloudWatch metriche mostrate nella console Lambda. Per visualizzare queste informazioni, completa le seguenti operazioni:

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

1. Seleziona la funzione per la quale desideri visualizzare le statistiche sull'invocazione.

1. Selezionare la scheda **Monitor (Monitora)**.

1. Imposta il periodo di tempo per cui desideri visualizzare le statistiche utilizzando il selettore dell'intervallo di date. Le invocazioni recenti vengono visualizzate nel riquadro **Invocazioni**.

Per gli account con un numero maggiore di funzioni, può essere più efficiente raccogliere questi dati a livello di codice utilizzando AWS CLI o una delle azioni using the e API. AWS SDKs [DescribeLogStreams[GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeLogStreams.html)

Gli esempi seguenti forniscono frammenti di codice che utilizzano V3 AWS SDK per JavaScript e AWS SDK per Python (Boto3) per identificare la data dell'ultima chiamata per una particolare funzione e per determinare il numero di chiamate per una particolare funzione negli ultimi 14 giorni.

------
#### [ Node.js ]

**Example JavaScript codice per trovare l'ora dell'ultima chiamata per una funzione**  

```
import { CloudWatchLogsClient, DescribeLogStreamsCommand } from "@aws-sdk/client-cloudwatch-logs";
const cloudWatchLogsClient = new CloudWatchLogsClient();
const command = new DescribeLogStreamsCommand({
    logGroupName: '<your_log_group_name>',
    orderBy: 'LastEventTime',
    descending: true,
    limit: 1
});
try {
    const response = await cloudWatchLogsClient.send(command);
    const lastEventTimestamp = response.logStreams.length > 0 ? 
        response.logStreams[0].lastEventTimestamp : null;
    // Convert the UNIX timestamp to a human-readable format for display
    const date = new Date(lastEventTimestamp).toLocaleDateString();
    const time = new Date(lastEventTimestamp).toLocaleTimeString();
    console.log(`${date} ${time}`);
    
} catch (e){
    console.error('Log group not found.')
}
```

------
#### [ Python ]

**Example Codice Python per trovare l'ora dell'ultima invocazione per una funzione**  

```
import boto3
from datetime import datetime

cloudwatch_logs_client  = boto3.client('logs')

response = cloudwatch_logs_client.describe_log_streams(
    logGroupName='<your_log_group_name>',
    orderBy='LastEventTime',
    descending=True,
    limit=1
)

try:
    if len(response['logStreams']) > 0:
        last_event_timestamp = response['logStreams'][0]['lastEventTimestamp']
        print(datetime.fromtimestamp(last_event_timestamp/1000)) # Convert timestamp from ms to seconds
    else:
        last_event_timestamp = None
except:
    print('Log group not found')
```

------

**Suggerimento**  
Puoi trovare il nome del gruppo di log della tua funzione utilizzando l'operazione [ListFunctions](https://docs.aws.amazon.com/lambda/latest/api/API_ListFunctions.html)API. Per un esempio su come eseguire questa operazione, consulta [Elenco delle versioni delle funzioni che utilizzano un determinato runtime](#runtimes-list-deprecated-versions).

------
#### [ Node.js ]

**Example JavaScript codice per trovare il numero di chiamate negli ultimi 14 giorni**  

```
import { CloudWatchClient, GetMetricStatisticsCommand } from "@aws-sdk/client-cloudwatch";
const cloudWatchClient = new CloudWatchClient();
const command = new GetMetricStatisticsCommand({
    Namespace: 'AWS/Lambda',
    MetricName: 'Invocations',
    StartTime: new Date(Date.now()-86400*1000*14), // 14 days ago
    EndTime: new Date(Date.now()),
    Period: 86400 * 14, // 14 days.
    Statistics: ['Sum'],
    Dimensions: [{
        Name: 'FunctionName',
        Value: '<your_function_name>'
    }]
});
const response = await cloudWatchClient.send(command);
const invokesInLast14Days = response.Datapoints.length > 0 ? 
    response.Datapoints[0].Sum : 0;

console.log('Number of invocations: ' + invokesInLast14Days);
```

------
#### [ Python ]

**Example Codice Python per trovare il numero di invocazioni negli ultimi 14 giorni**  

```
import boto3
from datetime import datetime, timedelta

cloudwatch_client = boto3.client('cloudwatch')

response = cloudwatch_client.get_metric_statistics(
    Namespace='AWS/Lambda',
    MetricName='Invocations',
    Dimensions=[
        {
            'Name': 'FunctionName',
            'Value': '<your_function_name>'
        },
    ],
    StartTime=datetime.now() - timedelta(days=14),
    EndTime=datetime.now(),
    Period=86400 * 14, # 14 days
    Statistics=[
        'Sum'
    ]
)

if len(response['Datapoints']) > 0:
    invokes_in_last_14_days = int(response['Datapoints'][0]['Sum'])
else:
    invokes_in_last_14_days = 0

print(f'Number of invocations: {invokes_in_last_14_days}')
```

------