# Recuperar dados sobre as funções do Lambda que usam um runtime obsoleto
<a name="runtimes-list-deprecated"></a>

Quando um runtime do Lambda está se prestes a ser descontinuado, o Lambda alerta você por e-mail e fornece notificações no Health Dashboard e no Trusted Advisor. Esses e-mails e notificações listam as versões \$1LATEST das funções que usam o runtime. Para listar todas as versões da função que usam um determinado runtime, você pode usar a AWS Command Line Interface (AWS CLI) ou um dos AWS SDKs.

Se tiver muitas funções que usam um runtime que está prestes a ser descontinuado, você também poderá usar a AWS CLI ou os AWS SKLs para ajudar a priorizar as atualizações das funções mais invocadas.

Consulte as seções a seguir para saber como usar a AWS CLI e os AWS SDKs para coletar dados sobre as funções que usam um determinado runtime.

## Listar as versões da função que usam um determinado runtime
<a name="runtimes-list-deprecated-versions"></a>

Para usar a AWS CLI para listar todas as versões da função que usam um determinado runtime, execute o comando a seguir. Substitua `RUNTIME_IDENTIFIER` pelo nome do runtime que está sendo descontinuado e escolha sua própria Região da AWS. Para listar somente as versões da função \$1LATEST, omita `--function-version ALL` do comando.

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

**dica**  
O exemplo de comando lista as funções na região `us-east-1` para uma determinada Conta da AWS. Você precisará repetir esse comando para cada região na qual sua conta tiver funções e para cada uma das suas Contas da AWS.

Você também pode listar funções que usam um determinado runtime usando um dos AWS SDKs. O exemplo de código a seguir usa o AWS SDK para JavaScript V3 e o AWS SDK para Python (Boto3) para retornar uma lista dos ARNs de função para as funções que usam um determinado runtime. O código de exemplo também retorna o grupo de logs do CloudWatch para cada uma das funções listadas. Você pode usar esse grupo de logs para encontrar a data da última invocação da função. Consulte a seção [Identificar as funções invocadas com maior frequência e as invocadas mais recentemente](#runtimes-list-deprecated-statistics) a seguir para obter mais informações.

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

**Example Código JavaScript para listar as funções que usam um determinado 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 Código Python para listar as funções que usam um determinado 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')
```

------

Para saber mais sobre como usar um AWS SDK para listar suas funções usando a ação [ListFunctions](https://docs.aws.amazon.com/lambda/latest/api/API_ListFunctions.html), consulte a [documentação do SDK](https://aws.amazon.com/developer/tools/) para sua linguagem de programação preferida.

Você também pode usar o recurso Consultas avançadas do AWS Config para listar todas as suas funções que usam um runtime afetado. Essa consulta retorna apenas as versões da função \$1LATEST, mas você pode agregar consultas para listar funções em todas as regiões e em várias Contas da AWS com um único comando. Para saber mais, consulte [Querying the Current Configuration State of AWS Auto Scaling Resources](https://docs.aws.amazon.com/config/latest/developerguide/querying-AWS-resources.html) no *AWS Config Developer Guide*.

## Identificar as funções invocadas com maior frequência e as invocadas mais recentemente
<a name="runtimes-list-deprecated-statistics"></a>

Se a sua Conta da AWS contém funções que usam um runtime que está prestes a ser descontinuado, você deve priorizar a atualização de funções que são invocadas com frequência ou que foram invocadas recentemente.

Se você tiver apenas algumas funções, poderá usar o console do CloudWatch Logs para coletar essas informações examinando os fluxos de logs das funções. Consulte [Visualizar dados de log enviados para o CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData) para obter mais informações.

Para ver o número de invocações recentes da função, você também pode usar as informações de métricas do CloudWatch mostradas no console do Lambda. Para visualizar essas informações, faça o seguinte:

1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda.

1. Selecione a função cujas estatísticas de invocação você deseja ver.

1. Escolha a guia **Monitor** (Monitorar).

1. Defina o período para o qual deseja visualizar estatísticas usando o seletor de intervalo de datas. As invocações recentes são exibidas no painel **Invocações**.

Para contas com mais funções, pode ser mais eficiente coletar esses dados programaticamente usando a AWS CLI ou um dos AWS SDKs com as ações de API [DescribeLogStreams](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeLogStreams.html) e [GetMetricStatistics](https://docs.aws.amazon.com/AmazonCloudWatch/latest/APIReference/API_GetMetricStatistics.html).

Os exemplos a seguir fornecem trechos de código usando o AWS SDK para JavaScript V3 e o AWS SDK para Python (Boto3) para identificar a data da última invocação de uma determinada função e especificar o número de invocações de uma determinada função nos últimos 14 dias.

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

**Example Código JavaScript para encontrar a hora da última invocação de uma função**  

```
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 Código Python para encontrar a hora da última invocação de uma função**  

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

------

**dica**  
Você pode encontrar o nome do grupo de logs da função usando a operação de API [ListFunctions](https://docs.aws.amazon.com/lambda/latest/api/API_ListFunctions.html). Veja o código em [Listar as versões da função que usam um determinado runtime](#runtimes-list-deprecated-versions) para ter um exemplo de como fazer isso.

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

**Example Código JavaScript para encontrar o número de invocações nos últimos 14 dias**  

```
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 Código Python para encontrar o número de invocações nos últimos 14 dias**  

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

------