Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Rufen Sie Daten über Lambda-Funktionen ab, die eine veraltete Laufzeit verwenden
<a name="runtimes-list-deprecated"></a>

Wenn sich eine Lambda-Laufzeit dem Ende nähert, werden Sie von Lambda per E-Mail benachrichtigt und im Laufe der Zeit benachrichtigt. Health Dashboard Trusted Advisor In diesen E-Mails und Benachrichtigungen werden die \$1LATEST-Versionen von Funktionen aufgelistet, die die Laufzeit verwenden. Um all Ihre Funktionsversionen aufzulisten, die eine bestimmte Laufzeit verwenden, können Sie die AWS Command Line Interface (AWS CLI) oder eine der folgenden verwenden. AWS SDKs

Wenn Sie über eine große Anzahl von Funktionen verfügen, die eine Laufzeit verwenden, die bald nicht mehr unterstützt wird, können Sie das AWS CLI oder auch verwenden, AWS SDKs um Aktualisierungen Ihrer am häufigsten aufgerufenen Funktionen zu priorisieren.

In den folgenden Abschnitten erfahren Sie, wie Sie Funktionen verwenden AWS CLI und Daten über Funktionen sammeln AWS SDKs , die eine bestimmte Laufzeit verwenden.

## Auflisten von Funktionsversionen, die eine bestimmte Laufzeit verwenden
<a name="runtimes-list-deprecated-versions"></a>

Führen Sie den folgenden Befehl aus, AWS CLI um alle Ihre Funktionsversionen aufzulisten, die eine bestimmte Laufzeit verwenden. `RUNTIME_IDENTIFIER`Ersetzen Sie ihn durch den Namen der Laufzeit, die veraltet ist, und wählen Sie Ihren eigenen aus. AWS-Region Um nur die \$1LATEST-Funktionsversionen aufzulisten, lassen Sie `--function-version ALL` im Befehl weg.

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

**Tipp**  
Der Beispielbefehl listet Funktionen in der `us-east-1` Region für eine bestimmte Region auf. AWS-Konto Sie müssen diesen Befehl für jede Region wiederholen, in der Ihr Konto Funktionen hat, und für jede Ihrer Regionen. AWS-Konten

Sie können auch Funktionen auflisten, die eine bestimmte Laufzeit verwenden, indem Sie eine der folgenden Optionen verwenden AWS SDKs. Der folgende Beispielcode verwendet V3 AWS SDK für JavaScript und die AWS SDK für Python (Boto3) , um eine Liste der Funktionen ARNs für Funktionen zurückzugeben, die eine bestimmte Laufzeit verwenden. Der Beispielcode gibt auch die CloudWatch Protokollgruppe für jede der aufgelisteten Funktionen zurück. Sie können diese Protokollgruppe verwenden, um das Datum des letzten Aufrufs der Funktion zu ermitteln. Weitere Informationen finden Sie im folgenden Abschnitt [Identifizieren der am häufigsten und zuletzt aufgerufenen Funktionen](#runtimes-list-deprecated-statistics).

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

**Example JavaScript Code zum Auflisten von Funktionen, die eine bestimmte Laufzeit verwenden**  

```
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 Python-Code zur Auflistung von Funktionen mit einer bestimmten Laufzeit**  

```
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')
```

------

Weitere Informationen zur Verwendung eines AWS SDK zum Auflisten Ihrer Funktionen mithilfe der [ListFunctions](https://docs.aws.amazon.com/lambda/latest/api/API_ListFunctions.html)Aktion finden Sie in der [SDK-Dokumentation](https://aws.amazon.com/developer/tools/) für Ihre bevorzugte Programmiersprache.

Sie können auch die Funktion AWS Config Erweiterte Abfragen verwenden, um all Ihre Funktionen aufzulisten, die eine betroffene Laufzeit verwenden. Diese Abfrage gibt nur die Versionen der Funktion \$1LATEST zurück, aber Sie können Abfragen aggregieren, um Funktionen für alle Regionen und mehrere Regionen AWS-Konten mit einem einzigen Befehl aufzulisten. Weitere Informationen finden Sie unter [Abfragen des aktuellen Konfigurationsstatus von AWS Auto Scaling Ressourcen](https://docs.aws.amazon.com/config/latest/developerguide/querying-AWS-resources.html) im *AWS Config Entwicklerhandbuch*.

## Identifizieren der am häufigsten und zuletzt aufgerufenen Funktionen
<a name="runtimes-list-deprecated-statistics"></a>

Wenn Ihre Version Funktionen AWS-Konto enthält, die eine Laufzeit verwenden, die bald veraltet sein wird, sollten Sie der Aktualisierung von Funktionen, die häufig aufgerufen werden, oder Funktionen, die kürzlich aufgerufen wurden, Priorität einräumen.

Wenn Sie nur über wenige Funktionen verfügen, können Sie die CloudWatch Logs-Konsole verwenden, um diese Informationen zu sammeln, indem Sie sich die Log-Streams Ihrer Funktionen ansehen. [Weitere Informationen finden Sie unter An Logs gesendete CloudWatch Protokolldaten](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData) anzeigen.

Um die Anzahl der letzten Funktionsaufrufen zu sehen, können Sie auch die in der Lambda-Konsole angezeigten CloudWatch Metrikinformationen verwenden. Gehen Sie wie folgt vor, um diese Informationen anzuzeigen:

1. Öffnen Sie die Seite [Funktionen](https://console.aws.amazon.com/lambda/home#/functions) der Lambda-Konsole.

1. Wählen Sie die Funktion aus, für die Sie eine Aufrufstatistik anzeigen möchten.

1. Wählen Sie den Tab **Überwachung**.

1. Legen Sie den Zeitraum fest, für den Sie die Statistiken anzeigen möchten, indem Sie den Datumsbereich auswählen. Die letzten Aufrufe werden im Bereich **Aufrufe** angezeigt.

Bei Konten mit einer größeren Anzahl von Funktionen kann es effizienter sein, diese Daten programmgesteuert mithilfe der AWS CLI oder einer der API-Aktionen „ AWS SDKs using the“ und zu sammeln. [DescribeLogStreams[GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html)](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeLogStreams.html)

Die folgenden Beispiele enthalten Codefragmente, die V3 AWS SDK für JavaScript und die verwenden, AWS SDK für Python (Boto3) um das Datum des letzten Aufrufs für eine bestimmte Funktion zu identifizieren und die Anzahl der Aufrufe für eine bestimmte Funktion in den letzten 14 Tagen zu bestimmen.

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

**Example JavaScript Code, um die Uhrzeit des letzten Aufrufs für eine Funktion zu ermitteln**  

```
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 Python-Code, um den Zeitpunkt des letzten Aufrufs für eine Funktion zu ermitteln**  

```
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')
```

------

**Tipp**  
Sie können den Namen der Protokollgruppe Ihrer Funktion mithilfe der [ListFunctions](https://docs.aws.amazon.com/lambda/latest/api/API_ListFunctions.html)API-Operation ermitteln. Der Code in [Auflisten von Funktionsversionen, die eine bestimmte Laufzeit verwenden](#runtimes-list-deprecated-versions) enthält ein Beispiel für diese Vorgehensweise.

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

**Example JavaScript Code, um die Anzahl der Aufrufe in den letzten 14 Tagen zu ermitteln**  

```
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 Python-Code, um die Anzahl der Aufrufe in den letzten 14 Tagen zu ermitteln**  

```
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}')
```

------