# Control de la exclusividad con Lambda SnapStart
<a name="snapstart-uniqueness"></a>

Cuando las invocaciones escalar verticalmente en una función de SnapStart, Lambda utiliza una instantánea exclusiva inicializada para reanudar varios entornos de ejecución. Si el código de inicialización genera contenido único que se incluye en la instantánea, es posible que el contenido no lo sea cuando se reutilice en los entornos de ejecución. Para mantener la exclusividad al utilizar SnapStart, debe generar contenido único después de la inicialización. Esto incluye ID y secretos únicos y entropía que se utiliza para generar pseudoaleatoriedad.

Sugerimos las siguientes prácticas recomendadas para ayudarlo a mantener la exclusividad en su código: Para las funciones de Java, Lambda también proporciona una [herramienta de escaneo de SnapStart](#snapstart-scanning) de código abierto para ayudar a comprobar si el código asume que es exclusivo. Si genera datos exclusivos durante la fase de inicialización, puede utilizar un [enlace de tiempo de ejecución](snapstart-runtime-hooks.md) para restaurar la exclusividad. Con los enlaces de tiempo de ejecución, puede ejecutar un código específico inmediatamente antes de que Lambda tome una instantánea o inmediatamente después de que Lambda reanude una función a partir de una instantánea.

## Evite guardar el estado que depende de la exclusividad durante la inicialización.
<a name="snapstart-caching-unique"></a>

Durante la [fase de inicialización](lambda-runtime-environment.md#runtimes-lifecycle-ib) de la función, evite almacenar en caché datos destinados a ser exclusivos, por ejemplo, generar un ID exclusivo para el registro o configurar valores de inicialización para funciones de asignación al azar. En su lugar, recomendamos que genere datos exclusivos o establezca valores de inicialización para funciones de asignación al azar dentro de su controlador de funciones, o que utilice un [enlace de tiempo de ejecución.](snapstart-runtime-hooks.md)

En el ejemplo siguiente, se muestra cómo generar un UUID en el controlador de funciones.

------
#### [ Java ]

**Example — Generar un ID exclusivo en el controlador de funciones**  

```
import java.util.UUID;
  public class Handler implements RequestHandler<String, String> {
    private static UUID uniqueSandboxId = null;
    @Override
    public String handleRequest(String event, Context context) {
      if (uniqueSandboxId == null)
        uniqueSandboxId = UUID.randomUUID();
      System.out.println("Unique Sandbox Id: " + uniqueSandboxId);
      return "Hello, World!";
    }
  }
```

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

**Example — Generar un ID exclusivo en el controlador de funciones**  

```
import json
import random
import time

unique_number = None

def lambda_handler(event, context):
    seed = int(time.time() * 1000) 
    random.seed(seed)
    global unique_number
    if not unique_number:
        unique_number = random.randint(1, 10000)
        
    print("Unique number: ", unique_number)
    
    return "Hello, World!"
```

------
#### [ .NET ]

**Example — Generar un ID exclusivo en el controlador de funciones**  

```
namespace Example;
public class SnapstartExample
{
    private Guid _myExecutionEnvironmentGuid;
    public SnapstartExample()
    {
        // This GUID is set for non-restore use cases, such as testing or if SnapStart is turned off
        _myExecutionEnvironmentGuid = new Guid();
        // Register the method which will run after each restore. You may need to update Amazon.Lambda.Core to see this
        Amazon.Lambda.Core.SnapshotRestore.RegisterAfterRestore(MyAfterRestore);
    }

    private ValueTask MyAfterRestore()
    {
        // After restoring this snapshot to a new execution environment, update the GUID
        _myExecutionEnvironmentGuid = new Guid();
        return ValueTask.CompletedTask;
    }

    public string Handler()
    {
        return $"Hello World! My Execution Environment GUID is {_myExecutionEnvironmentGuid}";
    }
}
```

------

## Utilice generadores de números pseudoaleatorios criptográficamente seguros (CSPRNG)
<a name="snapstart-csprng"></a>

Si su aplicación depende de la aleatoriedad, le recomendamos que utilice generadores de números pseudoaleatorios criptográficamente seguros. Además de OpenSSL 1.0.2, los tiempos de ejecución administrados por Lambda también incluyen los siguientes CSPRNG integrados:
+ **Java:** `java.security.SecureRandom`
+ **Python:** `random.SystemRandom`
+ **.NET:** `System.Security.Cryptography.RandomNumberGenerator`

Software que siempre obtiene números aleatorios de `/dev/random` o `/dev/urandom` también mantiene la aleatoriedad con SnapStart.

Las bibliotecas de criptografía de AWS mantienen automáticamente la aleatoriedad con SnapStart a partir de las versiones mínimas especificadas en la siguiente tabla. Si utiliza estas bibliotecas con las funciones de Lambda, asegúrese de usar las siguientes versiones mínimas o posteriores:


****  

| Library | Versión mínima compatible (x86) | Versión mínima compatible (ARM) | 
| --- | --- | --- | 
| AWS libcrypto (AWS-LC) |  1.16.0  |  1.30.0  | 
| AWS libcrypto FIPS |  2.0.13  | 2.0.13 | 

Si empaqueta las bibliotecas criptográficas anteriores con sus funciones de Lambda como dependencias transitivas a través de las siguientes bibliotecas, asegúrese de utilizar las siguientes versiones mínimas o posteriores:


****  

| Library | Versión mínima compatible (x86) | Versión mínima compatible (ARM) | 
| --- | --- | --- | 
| AWS SDK for Java 2.x |  2.23.20  |  2.26.12  | 
| AWS Common Runtime for Java |  0.29.8  |  0.29.25  | 
| Amazon Corretto Crypto Provider |  2.4.1  | 2.4.1 | 
| Amazon Corretto Crypto Provider, FIPS |  2.4.1  | 2.4.1 | 

En los siguientes ejemplos, se demuestra cómo utilizar los CSPRNG para garantizar secuencias numéricas exclusivas incluso cuando la función se restaura a partir de una instantánea.

------
#### [ Java ]

**Example — java.security.Secure Random**  

```
import java.security.SecureRandom;
  public class Handler implements RequestHandler<String, String> {
    private static SecureRandom rng = new SecureRandom();
    @Override
    public String handleRequest(String event, Context context) {
      for (int i = 0; i < 10; i++) {
        System.out.println(rng.next());
      }
      return "Hello, World!";
    }
  }
```

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

**Example – random.SystemRandom**  

```
import json
import random

secure_rng = random.SystemRandom()

def lambda_handler(event, context):
    random_numbers = [secure_rng.random() for _ in range(10)]
    
    for number in random_numbers:
        print(number)
    
    return "Hello, World!"
```

------
#### [ .NET ]

**Example – RandomNumberGenerator**  

```
using Amazon.Lambda.Core;
using System.Security.Cryptography;
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]

namespace DotnetSecureRandom;

public class Function
{
    public string FunctionHandler()
    {
        using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
        {
            byte[] randomUnsignedInteger32Bytes = new byte[4];
            for (int i = 0; i < 10; i++)
            {
                rng.GetBytes(randomUnsignedInteger32Bytes);
                int randomInt32 = BitConverter.ToInt32(randomUnsignedInteger32Bytes, 0);
                Console.WriteLine("{0:G}", randomInt32);
            }
        }
        return "Hello World!";
    }
}
```

------

## Herramienta de escaneo de SnapStart (solo Java)
<a name="snapstart-scanning"></a>

Lambda proporciona una herramienta de escaneo para Java que lo ayuda a verificar el código que asume exclusividad. La herramienta de escaneo SnapStart es un complemento de [SpotBugs](https://spotbugs.github.io/) de código abierto que ejecuta un análisis estático en función de un conjunto de reglas. La herramienta de escaneo ayuda a identificar posibles implementaciones de código que podrían romper las suposiciones con respecto a la exclusividad. Para obtener instrucciones de instalación y una lista de las comprobaciones que realiza la herramienta de escaneo, consulte el repositorio [aws-lambda-snapstart-java-rules](https://github.com/aws/aws-lambda-snapstart-java-rules) en GitHub.

Para obtener más información sobre cómo gestionar la exclusividad con SnapStart, consulte [Inicio más rápido con AWS Lambda SnapStart](https://aws.amazon.com/blogs/compute/starting-up-faster-with-aws-lambda-snapstart/) en el blog de computación de AWS.