

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.

# Erste Schritte mit Terraform Support für AWS SAMCLI
<a name="gs-terraform-support"></a>

Dieses Thema behandelt die ersten Schritte mit der Verwendung der AWS Serverless Application Model Befehlszeilenschnittstelle (AWS SAMCLI) mitTerraform.

Um Feedback zu geben und Funktionsanfragen einzureichen, erstellen Sie ein [GitHubProblem](https://github.com/aws/aws-sam-cli/issues/new?labels=area%2Fterraform).

**Topics**
+ [AWS SAMCLITerraformVoraussetzungen](#gs-terraform-support-prerequisites)
+ [Verwenden von AWS SAMCLI Befehlen mit Terraform](#gs-terraform-support-using)
+ [Für Terraform Projekte eingerichtet](#gs-terraform-support-projects)
+ [Einrichtung für Terraform Cloud](#gs-terraform-support-cloud)

## AWS SAMCLITerraformVoraussetzungen
<a name="gs-terraform-support-prerequisites"></a>

Erfüllen Sie alle Voraussetzungen, um AWS SAMCLI mit der Verwendung von in Ihren Terraform Projekten zu beginnen.

1. 

**Installieren oder aktualisieren Sie das AWS SAMCLI**

   Um zu überprüfen, ob Sie das AWS SAMCLI installiert haben, führen Sie Folgendes aus:

   ```
   $ sam --version
   ```

   Wenn das bereits installiert AWS SAMCLI ist, wird in der Ausgabe eine Version angezeigt. Informationen zum Upgrade auf die neueste Version finden Sie unter[Aktualisierung des AWS SAMCLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade).

   Anweisungen zur Installation von AWS SAMCLI mit allen erforderlichen Komponenten finden Sie unter[Installieren Sie das AWS SAMCLI](install-sam-cli.md).

1. 

**Installieren Terraform**

   Führen Sie den folgenden Befehl aus, um zu überprüfen, ob Sie Terraform installiert haben:

   ```
   $ terraform -version
   ```

   Informationen zur Installation Terraform finden [Sie unter Installieren Terraform](https://developer.hashicorp.com/terraform/downloads) in der *TerraformRegistrierung*.

1. 

**DockerFür lokale Tests installieren**

   Das AWS SAMCLI ist Docker für lokale Tests erforderlich. Informationen zur Installation Docker finden Sie unter[Installation von Docker zur Verwendung mit dem AWS SAMCLI](install-docker.md).

## Verwenden von AWS SAMCLI Befehlen mit Terraform
<a name="gs-terraform-support-using"></a>

Wenn Sie einen unterstützten AWS SAMCLI Befehl ausführen, verwenden Sie die `--hook-name` Option und geben Sie den `terraform` Wert an. Im Folgenden wird ein Beispiel gezeigt:

```
$ sam local invoke --hook-name terraform
```

Sie können diese Option in Ihrer AWS SAMCLI Konfigurationsdatei wie folgt konfigurieren:

```
hook_name = "terraform"
```

## Für Terraform Projekte eingerichtet
<a name="gs-terraform-support-projects"></a>

Führen Sie die Schritte in diesem Thema aus, um das AWS SAMCLI mit Terraform Projekten zu verwenden.

Es ist kein zusätzliches Setup erforderlich, wenn Sie Ihre AWS Lambda Artefakte außerhalb Ihres Terraform Projekts erstellen. Informationen [Verwenden von AWS SAMCLI with Terraform für lokales Debuggen und Testen](using-samcli-terraform.md) zur Verwendung von finden Sie unter AWS SAMCLI.

Wenn Sie Ihre Lambda-Artefakte in Ihren Terraform Projekten erstellen, müssen Sie wie folgt vorgehen:

1. Installieren Sie Python 3.8 oder neuer

1. Installieren Sie das Make Tool.

1. Definieren Sie die Build-Logik Ihrer Lambda-Artefakte in Ihrem Terraform Projekt.

1. Definieren Sie eine `sam metadata` Ressource, die AWS SAMCLI Sie über Ihre Build-Logik informieren soll.

1. Verwenden Sie den AWS SAMCLI `sam build` Befehl, um Ihre Lambda-Artefakte zu erstellen.

### Installieren Sie Python 3.8 oder neuer
<a name="gs-terraform-support-projects-python"></a>

Python3.8 oder neuer ist für die Verwendung mit dem erforderlich AWS SAMCLI. Wenn Sie die `sam build` Creates ausführen, AWS SAMCLI `makefiles` die Python Befehle zum Erstellen Ihrer Lambda-Artefakte enthalten.

Installationsanweisungen finden Sie unter [Python herunterladen im Python's](https://wiki.python.org/moin/BeginnersGuide/Download) *Beginners Guide*.

Stellen Sie sicher, dass Python 3.8 oder neuer zu Ihrem Computerpfad hinzugefügt wurde, indem Sie Folgendes ausführen:

```
$ python --version
```

Die Ausgabe sollte eine Version von Python 3.8 oder neuer anzeigen.

### Installieren Sie das Make Tool
<a name="gs-terraform-support-projects-make"></a>

GNU[Make](https://www.gnu.org/software/make/)ist ein Tool, das die Generierung von ausführbaren Dateien und anderen Nicht-Quelldateien für Ihr Projekt steuert. Die AWS SAMCLI Kreationen`makefiles`, die auf dieses Tool angewiesen sind, um Ihre Lambda-Artefakte zu erstellen.

Wenn Sie es nicht auf Ihrem lokalen Computer Make installiert haben, installieren Sie es, bevor Sie fortfahren.

Für Windows können Sie die Installation mit [Chocolatey durchführen](https://chocolatey.org/). Anweisungen finden Sie unter [Verwenden von Chocolatey](https://www.technewstoday.com/install-and-use-make-in-windows/#using-chocolatey) unter *So installieren und verwenden Sie „*Make“ in Windows

### Definieren Sie die Build-Logik für Lambda-Artefakte
<a name="gs-terraform-support-projects-logic"></a>

Verwenden Sie den `null_resource` Terraform Ressourcentyp, um Ihre Lambda-Build-Logik zu definieren. Im Folgenden finden Sie ein Beispiel, das ein benutzerdefiniertes Build-Skript verwendet, um eine Lambda-Funktion zu erstellen.

```
resource "null_resource" "build_lambda_function" {
    triggers = {
        build_number = "${timestamp()}" 
    }

    provisioner "local-exec" {
        command =  substr(pathexpand("~"), 0, 1) == "/"? "./py_build.sh \"${local.lambda_src_path}\" \"${local.building_path}\" \"${local.lambda_code_filename}\" Function" : "powershell.exe -File .\\PyBuild.ps1 ${local.lambda_src_path} ${local.building_path} ${local.lambda_code_filename} Function"
    }
}
```

### Definieren Sie eine Ressource sam metadata
<a name="gs-terraform-support-projects-metadata"></a>

Die `sam metadata` Ressource ist ein `null_resource` Terraform Ressourcentyp, der sie AWS SAMCLI mit den Informationen versorgt, die sie zum Auffinden Ihrer Lambda-Artefakte benötigt. Für jede Lambda-Funktion oder Schicht in Ihrem Projekt ist eine eindeutige `sam metadata` Ressource erforderlich. *Weitere Informationen zu diesem Ressourcentyp finden Sie unter [null\$1resource](https://registry.terraform.io/providers/hashicorp/null/latest/docs/resources/resource) in der Registrierung. Terraform*

**Um eine Ressource zu definieren sam metadata**

1. Geben Sie Ihrer Ressource einen Namen, der mit beginnt`sam_metadata_`, um die Ressource als sam metadata Ressource zu identifizieren.

1. Definieren Sie Ihre Lambda-Artefakteigenschaften innerhalb des `triggers` Blocks Ihrer Ressource.

1. Geben Sie mit dem `depends_on` Argument Ihre an`null_resource`, die Ihre Lambda-Build-Logik enthält.

   Im Folgenden finden Sie eine Beispielvorlage:

   ```
   resource "null_resource" "sam_metadata_..." {
     triggers = {
       resource_name = resource_name
       resource_type = resource_type
       original_source_code = original_source_code
       built_output_path = built_output_path
     }
     depends_on = [
       null_resource.build_lambda_function # ref to your build logic
     ]
   }
   ```

   Im Folgenden finden Sie eine `sam metadata` Beispielressource:

   ```
   resource "null_resource" "sam_metadata_aws_lambda_function_publish_book_review" {
       triggers = {
           resource_name = "aws_lambda_function.publish_book_review"
           resource_type = "ZIP_LAMBDA_FUNCTION"
           original_source_code = "${local.lambda_src_path}"
           built_output_path = "${local.building_path}/${local.lambda_code_filename}"
       }
       depends_on = [
           null_resource.build_lambda_function
       ]
   }
   ```

Der Inhalt Ihrer `sam metadata` Ressource variiert je nach Lambda-Ressourcentyp (Funktion oder Layer) und Verpackungstyp (ZIP oder Bild). Weitere Informationen und Beispiele finden Sie unter[Sam-Metadatenressource](terraform-sam-metadata.md).

Wenn Sie eine `sam metadata` Ressource konfigurieren und einen unterstützten AWS SAMCLI Befehl verwenden, generiert er die Metadatendatei, bevor der AWS SAMCLI Befehl ausgeführt AWS SAMCLI wird. Sobald Sie diese Datei generiert haben, können Sie die `--skip-prepare-infra` Option mit future AWS SAMCLI Befehlen verwenden, um den Metadaten-Generierungsprozess zu überspringen und Zeit zu sparen. Diese Option sollte nur verwendet werden, wenn Sie keine Änderungen an der Infrastruktur vorgenommen haben, z. B. neue Lambda-Funktionen oder neue API-Endpunkte erstellt haben.

### Verwenden Sie die AWS SAMCLI, um Ihre Lambda-Artefakte zu erstellen
<a name="gs-terraform-support-projects-build"></a>

Verwenden Sie den AWS SAMCLI `sam build` Befehl, um Ihre Lambda-Artefakte zu erstellen. Wenn Sie das ausführen`sam build`, AWS SAMCLI macht der Folgendes:

1. Sucht in Ihrem Terraform Projekt nach `sam metadata` Ressourcen, um mehr über Ihre Lambda-Ressourcen zu erfahren und diese zu finden.

1. Initiiert Ihre Lambda-Build-Logik, um Ihre Lambda-Artefakte zu erstellen.

1. Erstellt ein `.aws-sam` Verzeichnis, das Ihr Terraform Projekt für die Verwendung mit den Befehlen organisiert. AWS SAMCLI `sam local`

**Um mit Sam Build zu bauen**

1. Führen Sie in dem Verzeichnis, das Ihr Terraform Root-Modul enthält, Folgendes aus:

   ```
   $ sam build --hook-name terraform
   ```

1. Führen Sie den folgenden Befehl aus, um eine bestimmte Lambda-Funktion oder -Layer zu erstellen

   ```
   $ sam build --hook-name terraform lambda-resource-id
   ```

   Die Lambda-Ressourcen-ID kann der Name der Lambda-Funktion oder die vollständige Terraform Ressourcenadresse sein, z. B. `aws_lambda_function.list_books` oder. `module.list_book_function.aws_lambda_function.this[0]`

Wenn sich Ihr Funktionsquellcode oder andere Terraform Konfigurationsdateien außerhalb des Verzeichnisses befinden, das Ihr Terraform Stammmodul enthält, müssen Sie den Speicherort angeben. Verwenden Sie die `--terraform-project-root-path` Option, um den absoluten oder relativen Pfad zum Verzeichnis der obersten Ebene anzugeben, das diese Dateien enthält. Im Folgenden wird ein Beispiel gezeigt:

```
$ sam build --hook-name terraform --terraform-project-root-path ~/projects/terraform/demo
```

#### Mithilfe eines Containers erstellen
<a name="gs-terraform-support-projects-build-container"></a>

Wenn Sie den AWS SAMCLI `sam build` Befehl ausführen, können Sie den so konfigurieren, AWS SAMCLI dass Ihre Anwendung mithilfe eines lokalen Docker Containers erstellt wird.

**Anmerkung**  
Sie müssen es Docker installiert und konfiguriert haben. Detaillierte Anweisungen finden Sie unter [Installation von Docker zur Verwendung mit dem AWS SAMCLI](install-docker.md).

**Um mit einem Container zu bauen**

1. Erstellen Sie eine`Dockerfile`, die die Make Tools TerraformPython, und enthält. Sie sollten auch Ihre Lambda-Funktionslaufzeit angeben.

   Das Folgende ist ein Beispiel: `Dockerfile`

   ```
   FROM public.ecr.aws/amazonlinux/amazonlinux:2
   
   RUN yum -y update \
       && yum install -y unzip tar gzip bzip2-devel ed gcc gcc-c++ gcc-gfortran \
       less libcurl-devel openssl openssl-devel readline-devel xz-devel \
       zlib-devel glibc-static libcxx libcxx-devel llvm-toolset-7 zlib-static \
       && rm -rf /var/cache/yum
   
   RUN yum -y install make \
       && yum -y install zip
   
   RUN yum install -y yum-utils \
       && yum-config-manager --add-repo https://rpm.releases.hashicorp.com/AmazonLinux/hashicorp.repo \
       && yum -y install terraform \
       && terraform --version
   
   # AWS Lambda Builders
   RUN amazon-linux-extras enable python3.8
   RUN yum clean metadata && yum -y install python3.8
   RUN curl -L get-pip.io | python3.8
   RUN pip3 install aws-lambda-builders
   RUN ln -s /usr/bin/python3.8 /usr/bin/python3
   RUN python3 --version
   
   VOLUME /project
   WORKDIR /project
   
   ENTRYPOINT ["sh"]
   ```

1. Verwenden Sie [https://docs.docker.com/engine/reference/commandline/build/](https://docs.docker.com/engine/reference/commandline/build/), um Ihr Docker Image zu erstellen.

   Im Folgenden wird ein Beispiel gezeigt:

   ```
   $ docker build --tag terraform-build:v1 <path-to-directory-containing-Dockerfile>
   ```

1. Führen Sie den AWS SAMCLI `sam build` Befehl mit den `--build-image` Optionen `--use-container` und aus.

   Im Folgenden wird ein Beispiel gezeigt:

   ```
   $ sam build --use-container --build-image terraform-build:v1
   ```

### Nächste Schritte
<a name="gs-terraform-support-projects-next"></a>

Informationen zur ersten Verwendung von AWS SAMCLI mit Ihren Terraform Projekten finden Sie unter[Verwenden von AWS SAMCLI with Terraform für lokales Debuggen und Testen](using-samcli-terraform.md).

## Einrichtung für Terraform Cloud
<a name="gs-terraform-support-cloud"></a>

Wir empfehlen, die Version Terraform v1.6.0 oder eine neuere Version zu verwenden. Wenn Sie eine ältere Version verwenden, müssen Sie lokal eine Terraform Plandatei generieren. Die lokale Plandatei enthält die AWS SAM CLI Informationen, die sie benötigt, um lokale Tests und Debuggings durchzuführen.

**Um eine lokale Plandatei zu generieren**
**Anmerkung**  
Diese Schritte sind in Terraform v1.6.0 oder neuer Version nicht erforderlich. Informationen zum Einstieg in die Verwendung von AWS SAM CLI with Terraform Cloud finden Sie unter[Verwenden mit AWS SAMCLI Terraform](using-samcli-terraform.md).

1. **Ein API-Token konfigurieren** — Die Art des Tokens hängt von Ihrer Zugriffsebene ab. Weitere Informationen finden Sie in der *Terraform CloudDokumentation* unter [API-Token](https://developer.hashicorp.com/terraform/cloud-docs/users-teams-organizations/api-tokens).

1. **Legen Sie die Umgebungsvariable Ihres API-Tokens** fest — Im Folgenden finden Sie ein Beispiel aus der Befehlszeile:

   ```
   $ export TOKEN="<api-token-value>"
   ```

1. **Ermitteln Sie Ihre Run-ID** — Suchen Sie in der Terraform Cloud Konsole die Run-ID für den Terraform Run, den Sie mit dem verwenden möchten AWS SAMCLI.

   Die Run-ID befindet sich im Breadcrumb-Pfad Ihres Laufs.  
![\[Der Breadcrumb-Pfad, in dem Terraform Cloud die Run-ID angezeigt wird.\]](http://docs.aws.amazon.com/de_de/serverless-application-model/latest/developerguide/images/terraform-01.png)

1. **Die Plandatei abrufen — Rufen** Sie mithilfe Ihres API-Tokens Ihre lokale Plandatei ab. Im Folgenden finden Sie ein Beispiel aus der Befehlszeile:

   ```
   curl \
      --header "Authorization: Bearer $TOKEN" \
      --header "Content-Type: application/vnd.api+json" \
      --location \
      https://app.terraform.io/api/v2/runs/<run ID>/plan/json-output \
      > custom_plan.json
   ```

Sie sind jetzt bereit, AWS SAMCLI with zu verwendenTerraform Cloud. Wenn Sie einen unterstützten AWS SAMCLI Befehl verwenden, verwenden Sie die `--terraform-plan-file` Option, um den Namen und den Pfad Ihrer lokalen Plandatei anzugeben. Im Folgenden wird ein Beispiel gezeigt:

```
$ sam local invoke --hook-name terraform --terraform-plan-file custom-plan.json
```

Im Folgenden finden Sie ein Beispiel für die Verwendung des `sam local start-api` Befehls:

```
$ sam local start-api --hook-name terraform --terraform-plan-file custom-plan.json
```

*Eine Beispielanwendung, die Sie mit diesen Beispielen verwenden können, finden Sie unter [api\$1gateway\$1v2\$1tf\$1cloud](https://github.com/aws-samples/aws-sam-terraform-examples/tree/main/ga/api_gateway_v2_tf_cloud) im aws-samples Repository. GitHub*

### Nächste Schritte
<a name="gs-terraform-support-cloud-next"></a>

Informationen zum Einstieg in die Verwendung von AWS SAMCLI with Terraform Cloud finden Sie unter[Verwenden von AWS SAMCLI with Terraform für lokales Debuggen und Testen](using-samcli-terraform.md).