Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Récupération de données sur les fonctions Lambda qui utilisent un environnement d’exécution obsolète
Lorsqu'un environnement d'exécution Lambda est sur le point de devenir obsolète, Lambda vous avertit par e-mail et vous envoie des notifications dans le et. Tableau de bord Health Trusted Advisor Ces e-mails et notifications répertorient les versions \$1LATEST des fonctions utilisant l’environnement d’exécution. Pour répertorier toutes les versions de vos fonctions qui utilisent un environnement d'exécution particulier, vous pouvez utiliser le AWS Command Line Interface (AWS CLI) ou l'un des AWS SDKs.
Si un grand nombre de fonctions utilisent un environnement d'exécution destiné à être obsolète, vous pouvez également utiliser le AWS CLI ou pour vous aider AWS SDKs à prioriser les mises à jour de vos fonctions les plus fréquemment invoquées.
Reportez-vous aux sections suivantes pour savoir comment utiliser AWS CLI et AWS SDKs pour collecter des données sur les fonctions qui utilisent un environnement d'exécution particulier.
## Liste des versions de fonctions qui utilisent un environnement d’exécution particulier
Pour utiliser le AWS CLI pour répertorier toutes les versions de vos fonctions qui utilisent un environnement d'exécution particulier, exécutez la commande suivante. `RUNTIME_IDENTIFIER`Remplacez-le par le nom du moteur d'exécution qui est obsolète et choisissez le vôtre. Région AWS Pour répertorier uniquement les versions de fonction \$1LATEST, omettez `--function-version ALL` dans la commande.
```
aws lambda list-functions --function-version ALL --region us-east-1 --output text --query "Functions[?Runtime=='RUNTIME_IDENTIFIER'].FunctionArn"
```
**Astuce**
L'exemple de commande répertorie les fonctions d'une `us-east-1` région en particulier. Compte AWS Vous devrez répéter cette commande pour chaque région dans laquelle votre compte possède des fonctions et pour chacune de vos Comptes AWS.
Vous pouvez également répertorier les fonctions qui utilisent un environnement d'exécution particulier à l'aide de l'un des AWS SDKs. L'exemple de code suivant utilise le V3 AWS SDK pour JavaScript et le AWS SDK pour Python (Boto3) pour renvoyer une liste des fonctions ARNs utilisant un environnement d'exécution particulier. L'exemple de code renvoie également le groupe de CloudWatch journaux pour chacune des fonctions répertoriées. Vous pouvez utiliser ce groupe de journaux pour trouver la date de la dernière invocation de la fonction. Consultez la section [Identification des fonctions les plus fréquemment et les plus récemment invoquées](#runtimes-list-deprecated-statistics) suivante pour plus d’informations.
------
#### [ Node.js ]
**Example JavaScript code pour répertorier les fonctions utilisant un environnement d'exécution particulier**
```
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 == ''){ // 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 Code Python pour répertorier les fonctions utilisant un environnement d’exécution particulier**
```
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')
```
------
Pour en savoir plus sur l'utilisation d'un AWS SDK pour répertorier vos fonctions à l'aide de l'[ListFunctions](https://docs.aws.amazon.com/lambda/latest/api/API_ListFunctions.html)action, consultez la [documentation du SDK correspondant](https://aws.amazon.com/developer/tools/) à votre langage de programmation préféré.
Vous pouvez également utiliser la fonctionnalité de requêtes AWS Config avancées pour répertorier toutes les fonctions qui utilisent un environnement d'exécution affecté. Cette requête renvoie uniquement les versions \$1LATEST de la fonction, mais vous pouvez agréger les requêtes pour répertorier les fonctions dans toutes les régions et plusieurs Comptes AWS avec une seule commande. Pour en savoir plus, consultez la section [Interrogation de l'état de configuration actuel des AWS Auto Scaling ressources](https://docs.aws.amazon.com/config/latest/developerguide/querying-AWS-resources.html) dans le *guide du AWS Config développeur*.
## Identification des fonctions les plus fréquemment et les plus récemment invoquées
Si vous utilisez Compte AWS des fonctions qui utilisent un environnement d'exécution destiné à être obsolète, vous souhaiterez peut-être donner la priorité à la mise à jour des fonctions fréquemment invoquées ou des fonctions qui ont été invoquées récemment.
Si vous ne disposez que de quelques fonctions, vous pouvez utiliser la console CloudWatch Logs pour recueillir ces informations en consultant les flux de journaux de vos fonctions. Voir [Afficher les données de journal envoyées à CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData) pour plus d'informations.
Pour connaître le nombre d'appels de fonctions récents, vous pouvez également utiliser les informations de CloudWatch métriques affichées dans la console Lambda. Pour afficher ces informations, procédez comme suit :
1. Ouvrez la [page Functions](https://console.aws.amazon.com/lambda/home#/functions) (Fonctions) de la console Lambda.
1. Sélectionnez la fonction dont vous souhaitez consulter les statistiques d’invocation.
1. Choisissez l’onglet **Surveiller**.
1. Définissez la période pendant laquelle vous souhaitez consulter les statistiques à l’aide du sélecteur de plage de dates. Les invocations récentes sont affichées dans le volet **Invocations**.
Pour les comptes dotés d'un plus grand nombre de fonctions, il peut être plus efficace de collecter ces données par programmation en utilisant l'une AWS CLI ou l'une des AWS SDKs actions d'[GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)API [DescribeLogStreams](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeLogStreams.html)et.
Les exemples suivants fournissent des extraits de code utilisant la V3 AWS SDK pour JavaScript et le AWS SDK pour Python (Boto3) pour identifier la date du dernier appel pour une fonction particulière et pour déterminer le nombre d'appels pour une fonction particulière au cours des 14 derniers jours.
------
#### [ Node.js ]
**Example JavaScript code pour trouver l'heure du dernier appel d'une fonction**
```
import { CloudWatchLogsClient, DescribeLogStreamsCommand } from "@aws-sdk/client-cloudwatch-logs";
const cloudWatchLogsClient = new CloudWatchLogsClient();
const command = new DescribeLogStreamsCommand({
logGroupName: '',
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 Code Python pour trouver l’heure de la dernière invocation d’une fonction**
```
import boto3
from datetime import datetime
cloudwatch_logs_client = boto3.client('logs')
response = cloudwatch_logs_client.describe_log_streams(
logGroupName='',
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')
```
------
**Astuce**
Vous pouvez trouver le nom du groupe de journaux de votre fonction à l'aide de l'opération [ListFunctions](https://docs.aws.amazon.com/lambda/latest/api/API_ListFunctions.html)API. Consultez le code dans [Liste des versions de fonctions qui utilisent un environnement d’exécution particulier](#runtimes-list-deprecated-versions) pour obtenir un exemple montrant la façon de procéder.
------
#### [ Node.js ]
**Example JavaScript code pour trouver le nombre d'invocations au cours des 14 derniers jours**
```
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: ''
}]
});
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 Code Python pour trouver le nombre d’invocations au cours des 14 derniers jours**
```
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': ''
},
],
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}')
```
------