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.

# Steigern Sie die Effizienz mithilfe von Lambda-Schichten mit AWS SAM
<a name="serverless-sam-cli-layers"></a>

Mithilfe von AWS SAM können Sie Ebenen in Ihre serverlosen Anwendungen einbeziehen. AWS Lambda Ebenen ermöglichen es Ihnen, Code aus einer Lambda-Funktion in eine Lambda-Schicht zu extrahieren, die dann für mehrere Lambda-Funktionen verwendet werden kann. Auf diese Weise können Sie die Größe Ihrer Bereitstellungspakete reduzieren, die Logik der Kernfunktionen von Abhängigkeiten trennen und Abhängigkeiten für mehrere Funktionen gemeinsam nutzen. Weitere Informationen zu Layern finden Sie unter [Lambda-Schichten](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) im *AWS Lambda Developer Guide*.

Dieses Thema enthält Informationen zu folgenden Themen:
+ Ebenen in Ihre Anwendung einbeziehen
+ Wie werden Ebenen lokal zwischengespeichert

Informationen zum Erstellen von benutzerdefinierten Layern finden Sie unter[Aufbau von Lambda-Schichten in AWS SAM](building-layers.md).

## Ebenen in Ihre Anwendung einbeziehen
<a name="including-layers"></a>

Verwenden Sie die `Layers` Eigenschaft des [AWS::Serverless::Function](sam-resource-function.md) Ressourcentyps, um Ebenen in Ihre Anwendung aufzunehmen.

Im Folgenden finden Sie eine AWS SAM Beispielvorlage mit einer Lambda-Funktion, die eine Ebene enthält:

```
ServerlessFunction:
  Type: AWS::Serverless::Function
  Properties:
    CodeUri: .
    Handler: my_handler
    Runtime: Python3.7
    Layers:
        - <LayerVersion ARN>
```

## Wie werden Ebenen lokal zwischengespeichert
<a name="local-testing-with-layers"></a>

Wenn Sie Ihre Funktion mit einem der `sam local` Befehle aufrufen, wird das Layer-Paket Ihrer Funktion heruntergeladen und auf Ihrem lokalen Host zwischengespeichert.

Die folgende Tabelle zeigt die Standard-Cache-Verzeichnisspeicherorte für verschiedene Betriebssysteme.


****  

| BS | Speicherort | 
| --- | --- | 
| Windows 7 | C:\$1Users\$1<user>\$1AppData\$1Roaming\$1AWS SAM | 
| Windows 8 | C:\$1Users\$1<user>\$1AppData\$1Roaming\$1AWS SAM | 
| Windows 10 | C:\$1Users\$1<user>\$1AppData\$1Roaming\$1AWS SAM | 
| macOS | \$1/.aws-sam/layers-pkg | 
| Unix | \$1/.aws-sam/layers-pkg | 

Nachdem das Paket zwischengespeichert wurde, werden die Ebenen auf ein Docker-Image AWS SAMCLI überlagert, das zum Aufrufen Ihrer Funktion verwendet wird. Das AWS SAMCLI generiert die Namen der Bilder, die es erstellt, sowie der Bilder, LayerVersions die im Cache gespeichert sind. Weitere Informationen zum Schema finden Sie in den folgenden Abschnitten.

Um die überlagerten Ebenen zu untersuchen, führen Sie den folgenden Befehl aus, um eine Bash-Sitzung in dem Bild zu starten, das Sie untersuchen möchten:

```
docker run -it --entrypoint=/bin/bash samcli/lambda:<Tag following the schema outlined in Docker Image Tag Schema> -i
```

**Layer-Caching: Namensschema für Verzeichnisse**

Bei gegebener LayerVersionArn Angabe, die in Ihrer Vorlage definiert ist, AWS SAMCLI extrahiert das die LayerName und Version aus dem ARN. Es erstellt ein Verzeichnis, in dem der Layer-Inhalt abgelegt wird`LayerName-Version-<first 10 characters of sha256 of ARN>`.

Beispiel:

```
ARN = arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
Directory name = myLayer-1-926eeb5ff1
```

**Tag-Schema für Docker Images**

Um den eindeutigen Layer-Hash zu berechnen, kombinieren Sie alle eindeutigen Layer-Namen mit dem Trennzeichen '-', nehmen Sie den SHA256 Hash und dann die ersten 10 Zeichen.

Beispiel:

```
ServerlessFunction:
  Type: AWS::Serverless::Function
  Properties:
    CodeUri: .
    Handler: my_handler
    Runtime: Python3.7
    Layers:
        - arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1
        - arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1
```

Eindeutige Namen werden genauso berechnet wie das Namensschema für das Layer-Caching-Verzeichnis:

```
arn:aws:lambda:us-west-2:111111111111:layer:myLayer:1 = myLayer-1-926eeb5ff1
arn:aws:lambda:us-west-2:111111111111:layer:mySecondLayer:1 = mySecondLayer-1-6bc1022bdf
```

Um den eindeutigen Layer-Hash zu berechnen, kombinieren Sie alle eindeutigen Layer-Namen mit dem Trennzeichen '-', nehmen Sie den SHA256-Hash und dann die ersten 25 Zeichen:

```
myLayer-1-926eeb5ff1-mySecondLayer-1-6bc1022bdf = 2dd7ac5ffb30d515926aef
```

Kombinieren Sie dann diesen Wert mit der Laufzeit und Architektur der Funktion mit dem Trennzeichen '-':

```
python3.7-x86_64-2dd7ac5ffb30d515926aefffd
```