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.

# Umgang mit Einzigartigkeit mit Lambda SnapStart
<a name="snapstart-uniqueness"></a>

Wenn Aufrufe für eine SnapStart Funktion skaliert werden, verwendet Lambda einen einzigen initialisierten Snapshot, um mehrere Ausführungsumgebungen wieder aufzunehmen. Wenn Ihr Initialisierungscode eindeutigen Inhalt generiert, der im Snapshot enthalten ist, ist der Inhalt möglicherweise nicht eindeutig, wenn er in Ausführungsumgebungen wiederverwendet wird. Um die Einzigartigkeit bei der Verwendung zu wahren SnapStart, müssen Sie nach der Initialisierung eindeutige Inhalte generieren. Dazu gehören einzigartige IDs, einzigartige Geheimnisse und Entropie, die verwendet wird, um Pseudozufälligkeit zu erzeugen.

Im Folgenden finden Sie einige bewährte Methoden für die Aufrechterhaltung der Eindeutigkeit Ihres Codes. Für Java-Funktionen bietet Lambda auch ein [SnapStart Open-Source-Scan-Tool](#snapstart-scanning), mit dessen Hilfe nach Code gesucht werden kann, der Eindeutigkeit voraussetzt. Wenn Sie während der Initialisierungsphase eindeutige Daten generieren, können Sie eine [Laufzeit-Hook](snapstart-runtime-hooks.md) verwenden, um die Eindeutigkeit wiederherzustellen. Mit Laufzeit-Hooks können Sie bestimmten Code ausführen, unmittelbar bevor Lambda einen Snapshot aufnimmt oder unmittelbar nachdem Lambda eine Funktion aus einem Snapshot fortsetzt.

## Vermeiden des Speicherns eines Zustands, der von der Eindeutigkeit während der Initialisierung abhängt
<a name="snapstart-caching-unique"></a>

Vermeiden Sie während der [Initialisierungsphase](lambda-runtime-environment.md#runtimes-lifecycle-ib) Ihrer Funktion das Zwischenspeichern von Daten, die eindeutig sein sollen, z. B. das Generieren einer eindeutigen ID für die Protokollierung oder das Setzen von Seeds für Zufallsfunktionen. Stattdessen empfehlen wir Ihnen, eindeutige Daten zu generieren oder Seeds für Zufallsfunktionen in Ihrem Funktionshandler festzulegen – oder einen [Laufzeit-Hook](snapstart-runtime-hooks.md) zu verwenden.

Die folgenden Beispiele zeigen, wie eine UUID im Funktionshandler erzeugt werden kann.

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

**Example – Generierung einer eindeutigen ID im Funktionshandler**  

```
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 – Generierung einer eindeutigen ID im Funktionshandler**  

```
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 – Generierung einer eindeutigen ID im Funktionshandler**  

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

------

## Verwenden Sie kryptografisch sichere Pseudozufallszahlengeneratoren () CSPRNGs
<a name="snapstart-csprng"></a>

Wenn Ihre Anwendung von Zufälligkeit abhängt, empfehlen wir Ihnen, kryptografisch sichere Zufallszahlengeneratoren () zu verwenden. CSPRNGs Zusätzlich zu OpenSSL 1.0.2 enthalten die von Lambda verwalteten Laufzeiten auch die folgenden integrierten Funktionen: CSPRNGs
+ **Java:** `java.security.SecureRandom`
+ **Python:** `random.SystemRandom`
+ **.NET:** `System.Security.Cryptography.RandomNumberGenerator`

Software, die immer Zufallszahlen von erhält `/dev/random` oder `/dev/urandom` auch deren Zufälligkeit beibehält. SnapStart

AWS Kryptografie-Bibliotheken behalten automatisch die Zufälligkeit bei, SnapStart beginnend mit den in der folgenden Tabelle angegebenen Mindestversionen. Wenn Sie diese Bibliotheken mit Ihren Lambda-Funktionen verwenden, stellen Sie sicher, dass Sie die folgenden Mindestversionen oder neuere Versionen verwenden:


****  

| Bibliothek | Unterstützte Mindestversion (x86) | Unterstützte Mindestversion (ARM) | 
| --- | --- | --- | 
| AWS libcrypto (-LC)AWS |  1.16.0  |  1.30.0  | 
| AWS libcrypto FIPS |  2.0.13  | 2.0.13 | 

Wenn Sie die vorangehenden kryptografischen Bibliotheken mit Ihren Lambda-Funktionen als transitive Abhängigkeiten über die folgenden Bibliotheken paketieren, stellen Sie sicher, dass Sie die folgenden Mindestversionen oder neuere Versionen verwenden:


****  

| Bibliothek | Unterstützte Mindestversion (x86) | Unterstützte Mindestversion (ARM) | 
| --- | --- | --- | 
| AWS SDK for Java 2.x |  2.23.20  |  2,26,12  | 
| AWS Allgemeine Runtime für Java |  0.29.8  |  0,29,25  | 
| Kryptoanbieter Amazon Corretto |  2.4.1  | 2.4.1 | 
| Amazon Corretto Kryptoanbieter FIPS |  2.4.1  | 2.4.1 | 

Die folgenden Beispiele zeigen, wie eindeutige Zahlenfolgen garantiert werden können CSPRNGs , auch wenn die Funktion aus einem Snapshot wiederhergestellt wird.

------
#### [ 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 — zufällig. 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 Scan-Tool (nur Java)
<a name="snapstart-scanning"></a>

Lambda bietet ein Scan-Tool für Java an, um nach Code zu suchen, der Eindeutigkeit voraussetzt. Das SnapStart Scan-Tool ist ein [SpotBugs](https://spotbugs.github.io/)Open-Source-Plugin, das eine statische Analyse anhand einer Reihe von Regeln durchführt. Das Scan-Tool hilft dabei, potenzielle Codeimplementierungen zu identifizieren, die Annahmen bezüglich der Eindeutigkeit widerlegen könnten. Installationsanweisungen und eine Liste der Prüfungen, die das Scan-Tool durchführt, finden Sie im Repository [aws-lambda-snapstart-java-rules](https://github.com/aws/aws-lambda-snapstart-java-rules) unter. GitHub

Weitere Informationen zum Umgang mit SnapStart Einzigartigkeit finden Sie unter [Schneller starten mit AWS Lambda SnapStart](https://aws.amazon.com/blogs/compute/starting-up-faster-with-aws-lambda-snapstart/) im AWS Compute-Blog.