

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.

# Erstellen Sie Ihre Bewerbung in AWS SAM
<a name="using-sam-cli-init"></a>

Nachdem Sie die Lektüre „[Erste Schritte](serverless-getting-started.md)“ abgeschlossen haben[Wie benutzt man AWS Serverless Application Model (AWS SAM)](chapter-using-sam.md), sind Sie bereit, ein AWS SAM Projekt in Ihrer Entwicklerumgebung zu erstellen. Ihr AWS SAM Projekt dient als Ausgangspunkt für das Schreiben Ihrer serverlosen Anwendung. Eine Liste der AWS SAMCLI `sam init` Befehlsoptionen finden Sie unter[sam init](sam-cli-command-reference-sam-init.md).

Der AWS Serverless Application Model Befehl Command Line Interface (AWS SAMCLI) bietet Optionen zur Initialisierung einer neuen serverlosen Anwendung, die aus `sam init` folgenden Komponenten besteht:
+ Eine AWS SAM Vorlage zur Definition Ihres Infrastrukturcodes.
+ Eine Ordnerstruktur, die Ihre Anwendung organisiert.
+ Konfiguration für Ihre AWS Lambda Funktionen.

Informationen zum Erstellen eines AWS SAM Projekts finden Sie in den Themen in diesen Abschnitten.

**Anmerkung**  
`sam init`enthält Projektvorlagen für dauerhafte Funktionen in unterstützten Laufzeiten (TypeScript, Python, Java). Diese Vorlagen bieten Startcode und Konfiguration für die Erstellung von statusbehafteten serverlosen Anwendungen.

**Topics**
+ [

## Initialisieren Sie eine neue serverlose Anwendung
](#using-sam-cli-init-new)
+ [

## Optionen für Sam Init
](#using-sam-cli-init-options)
+ [

## Fehlerbehebung
](#using-sam-cli-init-troubleshooting)
+ [

## Beispiele
](#using-sam-cli-init-examples)
+ [

## Weitere Informationen
](#using-sam-cli-init-learn)
+ [

## Nächste Schritte
](#w2aac18c11c39)

## Initialisieren Sie eine neue serverlose Anwendung
<a name="using-sam-cli-init-new"></a>

**Um eine neue serverlose Anwendung mit dem zu initialisieren AWS SAMCLI**

1. `cd`in ein Startverzeichnis.

1. Führen Sie in der Befehlszeile Folgendes aus:

   ```
   $ sam init
   ```

1. Der AWS SAMCLI führt Sie durch einen interaktiven Ablauf zur Erstellung einer neuen serverlosen Anwendung.
**Anmerkung**  
Wie unter beschrieben[Tutorial: Stellen Sie eine Hello World-Anwendung bereit mit AWS SAM](serverless-getting-started-hello-world.md), initialisiert dieser Befehl Ihre serverlose Anwendung und erstellt Ihr Projektverzeichnis. Dieses Verzeichnis wird mehrere Dateien und Ordner enthalten. Die wichtigste Datei ist`template.yaml`. Das ist deine AWS SAM Vorlage. Ihre Version von Python muss mit der Version von Python übereinstimmen, die in der `template.yaml` Datei aufgeführt ist, die der **sam init** Befehl erstellt hat.

### Wählen Sie eine Startvorlage
<a name="using-sam-cli-init-new-template"></a>

Eine *Vorlage* besteht aus den folgenden Komponenten:

1. Eine AWS SAM Vorlage für Ihren Infrastrukturcode.

1. Ein Startprojektverzeichnis, das Ihre Projektdateien organisiert. Dies kann beispielsweise Folgendes beinhalten:

   1. Eine Struktur für Ihren Lambda-Funktionscode und seine Abhängigkeiten.

   1. Ein `events` Ordner, der Testereignisse für lokale Tests enthält.

   1. Ein `tests` Ordner zur Unterstützung von Komponententests.

   1. Eine `samconfig.toml` Datei zur Konfiguration der Projekteinstellungen.

   1. Eine `ReadMe` Datei und andere grundlegende Startprojektdateien.

   Im Folgenden finden Sie ein Beispiel für ein Startprojektverzeichnis:

   ```
   sam-app
   ├── README.md
   ├── __init__.py
   ├── events
   │   └── event.json
   ├── hello_world
   │   ├── __init__.py
   │   ├── app.py
   │   └── requirements.txt
   ├── samconfig.toml
   ├── template.yaml
   └── tests
       ├── __init__.py
       ├── integration
       │   ├── __init__.py
       │   └── test_api_gateway.py
       ├── requirements.txt
       └── unit
           ├── __init__.py
           └── test_handler.py
   ```

Sie können aus einer Liste verfügbarer *AWS Schnellstartvorlagen* auswählen oder Ihren eigenen *Speicherort für benutzerdefinierte Vorlagen* angeben.

**Um eine AWS Schnellstart-Vorlage auszuwählen**

1. Wenn Sie dazu aufgefordert werden, wählen Sie **AWS Schnellstartvorlagen** aus.

1. Wählen Sie zunächst eine AWS Schnellstart-Vorlage aus. Im Folgenden wird ein Beispiel gezeigt:

   ```
   Which template source would you like to use?
       1 - AWS Quick Start Templates
       2 - Custom Template Location
   Choice: 1
   
   Choose an AWS Quick Start application template
       1 - Hello World Example
       2 - Multi-step workflow
       3 - Serverless API
       4 - Scheduled task
       5 - Standalone function
       6 - Data processing
       7 - Hello World Example With Powertools
       8 - Infrastructure event management
       9 - Serverless Connector Hello World Example
       10 - Multi-step workflow with Connectors
       11 - Lambda EFS example
       12 - DynamoDB Example
       13 - Machine Learning
   Template: 4
   ```

**Um Ihren eigenen Speicherort für benutzerdefinierte Vorlagen auszuwählen**

1. Wenn Sie dazu aufgefordert werden, wählen Sie den **Speicherort für benutzerdefinierte Vorlagen** aus.

   ```
   Which template source would you like to use?
       1 - AWS Quick Start Templates
       2 - Custom Template Location
   Choice: 2
   ```

1. Sie AWS SAMCLI werden aufgefordert, einen Speicherort für die Vorlage anzugeben.

   ```
   Template location (git, mercurial, http(s), zip, path):
   ```

   Geben Sie einen der folgenden Speicherorte für Ihr ZIP-Vorlagenarchiv an:
   + **GitHubRepository** — Der Pfad zur .zip-Datei in Ihrem GitHub Repository. Die Datei muss sich im Stammverzeichnis Ihres Repositorys befinden.
   + **MercurialRepository** — Der Pfad zur .zip-Datei in Ihrem Mercurial Repository. Die Datei muss sich im Stammverzeichnis Ihres Repositorys befinden.
   + **.zip-Pfad** — Ein HTTPS-Pfad oder ein lokaler Pfad zu Ihrer .zip-Datei.

1. Dadurch AWS SAMCLI wird Ihre serverlose Anwendung mithilfe Ihrer benutzerdefinierten Vorlage initialisiert.

### Wählen Sie eine Laufzeit
<a name="using-sam-cli-init-new-runtime"></a>

Wenn Sie eine *AWS Schnellstartvorlage* auswählen, werden Sie AWS SAMCLI aufgefordert, eine Laufzeit für Ihre Lambda-Funktionen auszuwählen. Die von der angezeigte Liste der Optionen entspricht den AWS SAMCLI Laufzeiten, die von Lambda nativ unterstützt werden.
+ Die [Laufzeit](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-runtime) stellt eine sprachspezifische Umgebung bereit, die in der Ausführungsumgebung ausgeführt wird.
+ Bei der Bereitstellung auf dem AWS Cloud ruft der Lambda-Service Ihre Funktion in einer [Ausführungsumgebung](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtime-environment.html) auf.

Sie können jede andere Programmiersprache mit einer benutzerdefinierten Laufzeit verwenden. Dazu müssen Sie Ihre Startanwendungsstruktur manuell erstellen. Anschließend können Sie Ihre Anwendung `sam init` schnell initialisieren, indem Sie einen benutzerdefinierten Speicherort für Vorlagen konfigurieren.

Aus Ihrer Auswahl AWS SAMCLI erstellt der das Startverzeichnis für Ihren Lambda-Funktionscode und die Abhängigkeiten.

Wenn Lambda mehrere Abhängigkeitsmanager für Ihre Laufzeit unterstützt, werden Sie aufgefordert, Ihren bevorzugten Abhängigkeitsmanager auszuwählen.

### Wählen Sie einen Pakettyp
<a name="using-sam-cli-init-new-package"></a>

Wenn Sie eine *AWS Schnellstartvorlage* und eine *Runtime* auswählen, werden Sie AWS SAMCLI aufgefordert, einen *Pakettyp* auszuwählen. Der Pakettyp bestimmt, wie Ihre Lambda-Funktionen für die Verwendung mit dem Lambda-Service bereitgestellt werden. Die beiden unterstützten Pakettypen sind:

1. **Container-Image** — Enthält das Basisbetriebssystem, die Laufzeit, Lambda-Erweiterungen, Ihren Anwendungscode und dessen Abhängigkeiten.

1. **ZIP-Dateiarchiv** — Enthält Ihren Anwendungscode und seine Abhängigkeiten.

Weitere Informationen zu Bereitstellungspakettypen finden Sie unter [Lambda-Bereitstellungspakete](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-package.html) im *AWS Lambda Entwicklerhandbuch*.

Im Folgenden finden Sie ein Beispiel für die Verzeichnisstruktur einer Anwendung mit einer Lambda-Funktion, die als Container-Image verpackt ist. Das AWS SAMCLI lädt das Bild herunter und erstellt `Dockerfile` im Verzeichnis der Funktion ein, um das Bild zu spezifizieren.

```
sam-app
├── README.md
├── __init__.py
├── events
│   └── event.json
├── hello_world
│   ├── Dockerfile
│   ├── __init__.py
│   ├── app.py
│   └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
    ├── __init__.py
    └── unit
        ├── __init__.py
        └── test_handler.py
```

Im Folgenden finden Sie ein Beispiel für die Verzeichnisstruktur einer Anwendung mit einer Funktion, die als ZIP-Dateiarchiv verpackt ist.

```
sam-app
├── README.md
├── __init__.py
├── events
│   └── event.json
├── hello_world
│   ├── __init__.py
│   ├── app.py
│   └── requirements.txt
├── samconfig.toml
├── template.yaml
└── tests
    ├── __init__.py
    ├── integration
    │   ├── __init__.py
    │   └── test_api_gateway.py
    ├── requirements.txt
    └── unit
        ├── __init__.py
        └── test_handler.py
```

### Konfigurieren Sie die Ablaufverfolgung AWS X-Ray
<a name="using-sam-cli-init-new-tracing"></a>

Sie können wählen, ob Sie die AWS X-Ray Ablaufverfolgung aktivieren möchten. Weitere Informationen finden Sie unter [Was ist AWS X-Ray?](https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html) im *AWS X-Ray Entwicklerhandbuch*.

Wenn Sie es aktivieren, AWS SAMCLI konfiguriert das Ihre AWS SAM Vorlage. Im Folgenden wird ein Beispiel gezeigt:

```
Globals:
  Function:
    ...
    Tracing: Active
  Api:
    TracingEnabled: True
```

### Konfigurieren Sie die Überwachung mit Amazon CloudWatch Application Insights
<a name="using-sam-cli-init-new-insights"></a>

Sie können wählen, ob Sie die Überwachung mit Amazon CloudWatch Application Insights aktivieren möchten. Weitere Informationen finden Sie unter [Amazon CloudWatch Application Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html) im * CloudWatch Amazon-Benutzerhandbuch*.

Wenn Sie aktivieren, AWS SAMCLI konfiguriert der Ihre AWS SAM Vorlage. Im Folgenden wird ein Beispiel gezeigt:

```
Resources:
  ApplicationResourceGroup:
    Type: AWS::ResourceGroups::Group
    Properties:
      Name:
        Fn::Join:
        - ''
        - - ApplicationInsights-SAM-
          - Ref: AWS::StackName
      ResourceQuery:
        Type: CLOUDFORMATION_STACK_1_0
  ApplicationInsightsMonitoring:
    Type: AWS::ApplicationInsights::Application
    Properties:
      ResourceGroupName:
        Fn::Join:
        - ''
        - - ApplicationInsights-SAM-
          - Ref: AWS::StackName
      AutoConfigurationEnabled: 'true'
    DependsOn: ApplicationResourceGroup
```

### Benennen Sie Ihre Anwendung
<a name="using-sam-cli-init-new-name"></a>

Geben Sie einen Namen für Ihre Anwendung ein. Der AWS SAMCLI erstellt unter diesem Namen einen Ordner auf oberster Ebene für Ihre Anwendung.

## Optionen für Sam Init
<a name="using-sam-cli-init-options"></a>

Im Folgenden sind einige der wichtigsten Optionen aufgeführt, die Sie mit dem `sam init` Befehl verwenden können. Eine Liste aller Optionen finden Sie unter[sam init](sam-cli-command-reference-sam-init.md).

### Initialisieren Sie eine Anwendung mithilfe eines benutzerdefinierten Vorlagenspeicherorts
<a name="using-sam-cli-init-options-location"></a>

Verwenden Sie die `--location` Option und geben Sie einen unterstützten Speicherort für benutzerdefinierte Vorlagen an. Im Folgenden wird ein Beispiel gezeigt:

```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```

### Initialisieren Sie eine Anwendung ohne den interaktiven Ablauf
<a name="using-sam-cli-init-options-no-interactive"></a>

Verwenden Sie die `--no-interactive` Option und geben Sie Ihre Konfigurationsoptionen in der Befehlszeile an, um den interaktiven Ablauf zu überspringen. Im Folgenden wird ein Beispiel gezeigt:

```
$ sam init --no-interactive --runtime go1.x --name go-demo --dependency-manager mod --app-template hello-world
```

## Fehlerbehebung
<a name="using-sam-cli-init-troubleshooting"></a>

Informationen zur Behebung von Problemen finden Sie unter[AWS SAMCLIProblembehandlung](sam-cli-troubleshooting.md). AWS SAMCLI

## Beispiele
<a name="using-sam-cli-init-examples"></a>

### Initialisieren Sie eine neue serverlose Anwendung mithilfe der Hello World AWS Starter-Vorlage
<a name="using-sam-cli-init-examples-helloworld"></a>

Dieses Beispiel finden Sie [Schritt 1: Initialisieren Sie die Hello World-Beispielanwendung](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-init) im *Tutorial: Bereitstellen einer Hello World-Anwendung*.

### Initialisieren Sie eine neue serverlose Anwendung mit einem benutzerdefinierten Speicherort für Vorlagen
<a name="using-sam-cli-init-examples-custom"></a>

Im Folgenden finden Sie Beispiele für die Bereitstellung eines GitHub Speicherorts für Ihre benutzerdefinierte Vorlage:

```
$ sam init --location gh:aws-samples/cookiecutter-aws-sam-python
$ sam init --location git+sh://git@github.com/aws-samples/cookiecutter-aws-sam-python.git
$ sam init --location hg+ssh://hg@bitbucket.org/repo/template-name
```

Im Folgenden finden Sie ein Beispiel für einen lokalen Dateipfad:

```
$ sam init --location /path/to/template.zip
```

Im Folgenden finden Sie ein Beispiel für einen Pfad, der über HTTPS erreichbar ist:

```
$ sam init --location https://github.com/aws-samples/sessions-with-aws-sam/raw/master/starter-templates/web-app.zip
```

## Weitere Informationen
<a name="using-sam-cli-init-learn"></a>

Weitere Informationen zur Verwendung des `sam init` Befehls finden Sie in den folgenden Abschnitten:
+ **[Lernen AWS SAM: sam init](https://www.youtube.com/watch?v=9m3R-leD5Xo)** — Reihe Serverless Land „Lernen AWS SAM“ amYouTube.
+ **[Strukturierung serverloser Anwendungen für die Verwendung mit den AWS SAMCLI (Sessions with SAM S2E7)](https://www.youtube.com/watch?v=k9IRdgze9fQ)** — Sessions mit der Serie On. AWS SAM YouTube

## Nächste Schritte
<a name="w2aac18c11c39"></a>

Nachdem Sie Ihr AWS SAM Projekt erstellt haben, können Sie mit der Erstellung Ihrer Anwendung beginnen. [Definieren Sie Ihre Infrastruktur mit AWS SAM](serverless-authoring.md)Ausführliche Anweisungen zu den Aufgaben, die Sie dazu erledigen müssen, finden Sie unter.