

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-Ereignisfunktionen ab, die eine veraltete Laufzeit verwenden

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 $LATEST-Versionen von Funktionen aufgelistet, die die Laufzeit verwenden. Um alle Versionen Ihrer Event Function aufzulisten, die eine bestimmte Laufzeit verwenden, können Sie das AWS Command Line Interface (AWS CLI) oder eines der SDKs verwenden. AWS 

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 auch die AWS SDKs AWS CLI oder verwenden, um Aktualisierungen Ihrer am häufigsten aufgerufenen Funktionen zu priorisieren.

In den folgenden Abschnitten erfahren Sie, wie Sie mithilfe der AWS SDKs AWS CLI und Daten über Ereignisfunktionen sammeln, 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 AWS CLI Befehl aus, um alle Versionen Ihrer Lambda-Ereignisfunktionen aufzulisten, die eine bestimmte Laufzeit verwenden. Dieser Befehl gibt keine Lambda Web Functions zurück. `RUNTIME_IDENTIFIER`Ersetzen Sie es durch den Namen der Laufzeit, die veraltet ist, und wählen Sie Ihren eigenen aus. AWS-Region Um nur die $LATEST-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

Mit einem der AWS SDKs können Sie auch Ereignisfunktionen auflisten, die eine bestimmte Laufzeit verwenden. Der folgende Beispielcode verwendet die V3 AWS SDK für JavaScript und die AWS SDK für Python (Boto3) , um eine Liste der Funktions-ARNs für Funktionen, die eine bestimmte Laufzeit verwenden, zurückzugeben. 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 alle Ihre Lambda-Ereignisfunktionen aufzulisten, die eine betroffene Laufzeit verwenden. AWS Config gibt keine Lambda Web Functions zurück. Diese Abfrage gibt nur die Versionen der Funktion $LATEST 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 Ihr System 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 Event Functions](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 mithilfe der API-Aktionen AWS CLI oder eines der AWS SDKs programmgesteuert 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}')
```

------