Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Gestire l'unicità con Lambda SnapStart
<a name="snapstart-uniqueness"></a>

Quando le chiamate aumentano su una SnapStart funzione, Lambda utilizza una singola istantanea inizializzata per riprendere più ambienti di esecuzione. Se il codice di inizializzazione genera contenuti unici inclusi nello snapshot, il contenuto potrebbe non essere più unico quando viene riutilizzato in più ambienti di esecuzione. Per mantenere l'unicità durante l'utilizzo SnapStart, è necessario generare contenuti unici dopo l'inizializzazione. Ciò include segreti unici IDs e unici e l'entropia utilizzata per generare pseudocasualità.

Di seguito sono riportate le best practice che consentono di mantenere l'unicità nel codice. Per le funzioni Java, Lambda fornisce anche [uno strumento di SnapStart scansione](#snapstart-scanning) open source per aiutare a verificare la presenza di codice che presuppone l'unicità. Se durante la fase di inizializzazione vengono generati dati univoci, è possibile utilizzare un [hook di runtime](snapstart-runtime-hooks.md) per ripristinare l'unicità. Con gli hook di runtime, puoi eseguire codice specifico immediatamente prima che Lambda esegua uno snapshot o subito dopo che Lambda riprende una funzione da uno snapshot.

## Evitare lo stato di salvataggio che dipende dall'unicità durante l'inizializzazione
<a name="snapstart-caching-unique"></a>

Durante la [fase di inizializzazione](lambda-runtime-environment.md#runtimes-lifecycle-ib) della funzione, evita di memorizzare nella cache dati destinati a essere univoci, ad esempio la generazione di un ID univoco per la registrazione o l'impostazione di seed per funzioni casuali. Ti consigliamo invece di generare dati univoci o impostare seed per le funzioni casuali all'interno dell'handler delle funzioni o di utilizzare un [hook di runtime](snapstart-runtime-hooks.md).

I seguenti esempi mostrano come generare un UUID nell'handler delle funzioni.

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

**Example : generazione di un ID univoco nel gestore delle funzioni**  

```
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 : generazione di un ID univoco nel gestore delle funzioni**  

```
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 : generazione di un ID univoco nel gestore delle funzioni**  

```
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}";
    }
}
```

------

## Utilizza generatori di numeri pseudocasuali crittograficamente sicuri () CSPRNGs
<a name="snapstart-csprng"></a>

Se la tua applicazione dipende dalla casualità, ti consigliamo di utilizzare generatori di numeri casuali crittograficamente sicuri (). CSPRNGs Oltre a OpenSSL 1.0.2, i runtime gestiti da Lambda includono anche le seguenti funzionalità integrate: CSPRNGs
+ **Java:** `java.security.SecureRandom`
+ **Python:** `random.SystemRandom`
+ **.NET:** `System.Security.Cryptography.RandomNumberGenerator`

Software che ottiene sempre numeri casuali da `/dev/random` o `/dev/urandom` con cui mantiene la casualità. SnapStart

AWS Le librerie di crittografia mantengono automaticamente la casualità a SnapStart partire dalle versioni minime specificate nella tabella seguente. Se usi queste librerie con le tue funzioni Lambda, assicurati di utilizzare le seguenti versioni minime o versioni successive:


****  

| Libreria | Versione minima supportata (x86) | Versione minima supportata (ARM) | 
| --- | --- | --- | 
| AWS libcrypto (-LC)AWS |  1.16.0  |  1.30.0  | 
| AWS libcrypto FIPS |  2.0.13  | 2.0.13 | 

Se impacchetti le librerie di crittografia precedenti con le funzioni Lambda come dipendenze transitive tramite le seguenti librerie, assicurati di utilizzare le seguenti versioni minime o versioni successive:


****  

| Libreria | Versione minima supportata (x86) | Versione minima supportata (ARM) | 
| --- | --- | --- | 
| AWS SDK for Java 2.x |  2.23.20  |  2,26,12  | 
| AWS Common Runtime per Java |  0.29.8  |  0,29,25  | 
| Fornitore di servizi di crittografia Amazon Corretto |  2.4.1  | 2.4.1 | 
| FIPS Fornitore di servizi di crittografia Amazon Corretto |  2.4.1  | 2.4.1 | 

Gli esempi seguenti mostrano come CSPRNGs garantire sequenze numeriche univoche anche quando la funzione viene ripristinata da un'istantanea.

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

**Example — java.security. SecureRandom**  

```
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 — casuale. 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!";
    }
}
```

------

## SnapStart strumento di scansione (solo Java)
<a name="snapstart-scanning"></a>

Lambda fornisce uno strumento di scansione che aiuta a verificare la presenza di codice che presuppone l'unicità. Lo strumento di SnapStart scansione è un [SpotBugs](https://spotbugs.github.io/)plug-in open source che esegue un'analisi statica rispetto a una serie di regole. Lo strumento di scansione consente di identificare potenziali implementazioni di codice che potrebbero infrangere i presupposti sull'unicità. Per le istruzioni di installazione e un elenco dei controlli eseguiti dallo strumento di scansione, consultate il repository [aws-lambda-snapstart-java-rules su](https://github.com/aws/aws-lambda-snapstart-java-rules). GitHub

Per saperne di più sulla gestione dell'unicità con SnapStart, consulta Starting [up faster with AWS Lambda SnapStart](https://aws.amazon.com/blogs/compute/starting-up-faster-with-aws-lambda-snapstart/) sul blog di Compute AWS .