View a markdown version of this page

Einführung in das Bauen mit AWS SAM - AWS Serverless Application Model

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.

Einführung in das Bauen mit AWS SAM

Verwenden Sie das AWS Serverless Application Model Befehlszeilenschnittstelle (AWS SAM CLI) sam build Befehl zur Vorbereitung Ihrer serverlosen Anwendung auf nachfolgende Schritte in Ihrem Entwicklungsworkflow, wie z. B. lokales Testen oder Bereitstellen auf AWS Cloud. Dieser Befehl erstellt eine .aws-sam Verzeichnis, das Ihre Anwendung in einem Format und an einem Speicherort strukturiert sam local und sam deploy benötigen.

Wichtig

sam build führt die Makefile-Ziele, Paketmanager-Skripte und andere Build-Tools aus, die ein Projekt definiert. Bevor Sie ein Projekt erstellen, das Sie nicht selbst erstellt haben, überprüfen Sie dessen Build-Dateien und Abhängigkeiten.

Anmerkung

Verwenden sam build erfordert, dass Sie mit den grundlegenden Komponenten einer serverlosen Anwendung auf Ihrem Entwicklungscomputer beginnen. Dies beinhaltet eine AWS SAM Vorlage, AWS Lambda Event-Funktionscode und alle sprachspezifischen Dateien und Abhängigkeiten. Weitere Informationen hierzu finden Sie unter Erstellen Sie Ihre Bewerbung in AWS SAM.

Erstellen von Anwendungen mit Sam Build

Vor der Verwendung sam build, erwägen Sie, Folgendes zu konfigurieren:

  1. Lambda-Funktionen und -Layer — Das sam build Der Befehl kann Lambda-Funktionen und -Layer erstellen. Weitere Informationen zu Lambda-Layern finden Sie unter Aufbau von Lambda-Schichten in AWS SAM.

    Es kann auch Lambda-Webfunktionen erstellen (AWS::Serverless::WebFunction), die lokalen Code haben. Weitere Informationen hierzu finden Sie unter Erstellen und Bereitstellen von Lambda-Webfunktionen.

  2. Lambda-Laufzeit — Die Laufzeit stellt eine sprachspezifische Umgebung bereit, die Ihre Funktion in einer Ausführungsumgebung ausführt, wenn sie aufgerufen wird. Sie können native und benutzerdefinierte Laufzeiten konfigurieren.

    1. Native Laufzeit — Erstellen Sie Ihre Lambda-Funktionen in einer unterstützten Lambda-Laufzeit und erstellen Sie Ihre Funktionen, um eine native Lambda-Laufzeit in der AWS Cloud.

    2. Benutzerdefinierte Laufzeit — Erstellen Sie Ihre Lambda-Funktionen mit einer beliebigen Programmiersprache und erstellen Sie Ihre Runtime mithilfe eines benutzerdefinierten Prozesses, der in einer makefile oder ein Drittanbieter-Builder wie esbuild. Weitere Informationen hierzu finden Sie unter Erstellen von Lambda-Ereignisfunktionen mit benutzerdefinierten Laufzeiten in AWS SAM.

  3. Lambda-Pakettyp — Lambda-Funktionen können in die folgenden Lambda-Bereitstellungspakettypen gepackt werden:

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

    2. Container-Bild — Enthält das Basisbetriebssystem, die Runtime, Lambda-Erweiterungen, Ihren Anwendungscode und seine Abhängigkeiten.

Diese Anwendungseinstellungen können bei der Initialisierung einer Anwendung mithilfe von konfiguriert werden sam init.

Um eine Anwendung zu erstellen
  1. cd bis zur Wurzel Ihres Projekts. Das ist derselbe Ort wie dein AWS SAM Vorlage.

    $ cd sam-app
  2. Führen Sie Folgendes aus:

    sam-app $ sam build <arguments> <options>
    Anmerkung

    Eine häufig verwendete Option ist --use-container. Weitere Informationen hierzu finden Sie unter Erstellen einer Lambda-Event-Funktion in einem bereitgestellten Container.

    Das Folgende ist ein Beispiel für AWS SAM CLI Ausgang:

    sam-app $ sam build Starting Build use cache Manifest file is changed (new hash: 3298f1304...d4d421) or dependency folder (.aws-sam/deps/4d3dfad6-a267-47a6-a6cd-e07d6fae318c) is missing for (HelloWorldFunction), downloading dependencies and copying/building source Building codeuri: /Users/.../sam-app/hello_world runtime: python3.12 metadata: {} architecture: x86_64 functions: HelloWorldFunction Running PythonPipBuilder:CleanUp Running PythonPipBuilder:ResolveDependencies Running PythonPipBuilder:CopySource Running PythonPipBuilder:CopySource Build Succeeded Built Artifacts : .aws-sam/build Built Template : .aws-sam/build/template.yaml Commands you can use next ========================= [*] Validate SAM template: sam validate [*] Invoke Function: sam local invoke [*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch [*] Deploy: sam deploy --guided
  3. Die AWS SAM CLI erstellt eine .aws-sam Verzeichnis erstellen. Im Folgenden wird ein Beispiel gezeigt:

    .aws-sam
    ├── build
    │   ├── HelloWorldFunction
    │   │   ├── __init__.py
    │   │   ├── app.py
    │   │   └── requirements.txt
    │   └── template.yaml
    └── build.toml

Je nachdem, wie Ihre Anwendung konfiguriert ist, AWS SAM CLI macht Folgendes:

  1. Lädt, installiert und organisiert Abhängigkeiten in der .aws-sam/build Verzeichnis.

  2. Bereitet Ihren Lambda-Code vor. Dies kann das Kompilieren Ihres Codes, das Erstellen ausführbarer Binärdateien und das Erstellen von Container-Images beinhalten.

  3. Kopiert Build-Artefakte in den .aws-sam Verzeichnis. Das Format variiert je nach Art Ihres Anwendungspakets.

    1. Bei ZIP-Pakettypen sind die Artefakte noch nicht gezippt, sodass sie für lokale Tests verwendet werden können. Die AWS SAM CLI komprimiert Ihre Anwendung bei der Verwendung sam deploy.

    2. Für Container-Image-Pakettypen wird ein Container-Image lokal erstellt und im .aws-sam/build.toml datei.

  4. Kopiert die AWS SAM Vorlage rüber in die .aws-sam Verzeichnis und ändert es bei Bedarf mit neuen Dateipfaden.

Im Folgenden sind die Hauptkomponenten aufgeführt, aus denen Ihre Build-Artefakte in der .aws-sam Verzeichnis:

  • Das Build-Verzeichnis — Enthält Ihre Lambda-Funktionen und -Layer, die unabhängig voneinander strukturiert sind. Dies führt zu einer einzigartigen Struktur für jede Funktion oder Ebene in .aws-sam/build Verzeichnis.

  • Das AWS SAM Muster — Geändert mit aktualisierten Werten auf der Grundlage von Änderungen während des Erstellungsprozesses.

  • Die build.toml-Datei — Eine Konfigurationsdatei, die Build-Einstellungen enthält, die von AWS SAM CLI.

Lokales Testen und Bereitstellen

Bei der Durchführung lokaler Tests mit sam local oder Einsatz mit sam deploy, der AWS SAM CLI macht Folgendes:

  1. Es prüft zunächst, ob ein .aws-sam Verzeichnis existiert und ob ein AWS SAM Die Vorlage befindet sich in diesem Verzeichnis. Wenn diese Bedingungen erfüllt sind, wird AWS SAM CLI betrachtet dies als das Stammverzeichnis Ihrer Anwendung.

  2. Wenn diese Bedingungen nicht erfüllt sind, wird AWS SAM CLI berücksichtigt den ursprünglichen Standort Ihres AWS SAM Vorlage als Stammverzeichnis Ihrer Anwendung.

Wenn bei der Entwicklung Änderungen an Ihren ursprünglichen Anwendungsdateien vorgenommen werden, führen Sie Folgendes aus sam build um das zu aktualisieren .aws-sam Verzeichnis vor dem lokalen Testen.

Bewährte Methoden

  • Bearbeiten Sie keinen Code unter dem .aws-sam/build Verzeichnis. Aktualisieren Sie stattdessen Ihren ursprünglichen Quellcode in Ihrem Projektordner und führen Sie ihn aus sam build um das zu aktualisieren .aws-sam/build Verzeichnis.

  • Wenn Sie Ihre Originaldateien ändern, führen Sie Folgendes aus sam build um das zu aktualisieren .aws-sam/build Verzeichnis.

  • Vielleicht möchtest du das AWS SAM CLI um auf das ursprüngliche Stammverzeichnis Ihres Projekts zu verweisen, anstatt auf .aws-sam Verzeichnis, z. B. beim Entwickeln und Testen mit sam local. Löschen Sie die .aws-sam Verzeichnis oder AWS SAM Vorlage in der .aws-sam Verzeichnis, in dem das gespeichert werden soll AWS SAM CLI erkennen Sie Ihr ursprüngliches Projektverzeichnis als das Root-Projektverzeichnis. Wenn Sie fertig sind, führen Sie es aus sam build erneut, um das zu erstellen .aws-sam Verzeichnis.

  • Wenn du rennst sam build, der .aws-sam/build Verzeichnis wird jedes Mal überschrieben. Das .aws-sam Das Verzeichnis tut es nicht. Wenn Sie Dateien wie Protokolle speichern möchten, speichern Sie sie in .aws-sam um zu verhindern, dass sie überschrieben werden.

Optionen für Sam Build

Aufbau einer einzelnen Ressource

Geben Sie die logische ID der Ressource an, um nur diese Ressource zu erstellen. Im Folgenden wird ein Beispiel gezeigt:

$ sam build HelloWorldFunction

Um eine Ressource aus einer verschachtelten Anwendung oder eines Stapels zu erstellen, geben Sie die logische Anwendungs- oder Stack-ID zusammen mit der logischen ID der Ressource im folgenden Format an <stack-logical-id>/<resource-logical-id> :

$ sam build MyNestedStack/MyFunction

Erstellen einer Lambda-Event-Funktion in einem bereitgestellten Container

Die --use-container Die Option lädt ein Container-Image herunter und verwendet es, um Ihre Lambda-Funktionen zu erstellen. Der lokale Container wird dann in Ihrem referenziert .aws-sam/build.toml datei.

Diese Option erfordert Docker muss installiert werden. Detaillierte Anweisungen finden Sie unter Installieren von Docker.

Das Folgende ist ein Beispiel für diesen Befehl:

$ sam build --use-container

Sie können das Container-Image angeben, das mit dem verwendet werden soll --build-image Option. Im Folgenden wird ein Beispiel gezeigt:

$ sam build --use-container --build-image amazon/aws-sam-cli-build-image-nodejs20.x

Um das Container-Image anzugeben, das für eine einzelne Funktion verwendet werden soll, geben Sie die logische ID der Funktion an. Im Folgenden wird ein Beispiel gezeigt:

$ sam build --use-container --build-image Function1=amazon/aws-sam-cli-build-image-python3.12

Erstellen von Container-Images mit BuildKit

Beim Erstellen von Lambda-Funktionen mit dem Image Pakettyp, den Sie verwenden können BuildKit als Build-Engine, indem Sie den übergeben --use-buildkit Option. BuildKit bietet im Vergleich zur Vorgängerversion eine verbesserte Build-Leistung, besseres Caching und eine verbesserte Build-Ausgabe Docker Engine erstellen.

Diese Option erfordert entweder Docker oder Finch CLIs installiert und in deinem PATH.

Du kannst kombinieren --use-buildkit mit anderen Build-Optionen. Im Folgenden wird ein Beispiel gezeigt:

$ sam build --use-buildkit --parallel
Anmerkung

Das --use-buildkit Die Flagge ist nur für Container-Image-Builds vorgesehen. Es hat keine Auswirkung auf Zip-Funktionen, mit denen gebaut wird --use-container.

Übergeben Sie Umgebungsvariablen an den Build-Container

Benutze das --container-env-var um Umgebungsvariablen an den Build-Container zu übergeben. Im Folgenden wird ein Beispiel gezeigt:

$ sam build --use-container --container-env-var Function1.GITHUB_TOKEN=<token1> --container-env-var GLOBAL_ENV_VAR=<global-token>

Um Umgebungsvariablen aus einer Datei zu übergeben, verwenden Sie den --container-env-var-file Option. Im Folgenden wird ein Beispiel gezeigt:

$ sam build --use-container --container-env-var-file <env.json>

Beispiel für env.json datei:

{ "MyFunction1": { "GITHUB_TOKEN": "TOKEN1" }, "MyFunction2": { "GITHUB_TOKEN": "TOKEN2" } }

Beschleunigen Sie die Erstellung von Anwendungen, die mehrere Funktionen enthalten

Wenn du rennst sam build bei einer Anwendung mit mehreren Funktionen AWS SAM CLI erstellt jede Funktion einzeln. Um den Build-Prozess zu beschleunigen, verwenden Sie den --parallel Option. Dadurch werden alle Ihre Funktionen und Ebenen gleichzeitig erstellt.

Das Folgende ist ein Beispiel für diesen Befehl:

$ sam build —-parallel

Beschleunigen Sie die Build-Zeiten, indem Sie Ihr Projekt im Quellordner erstellen

Für unterstützte Laufzeiten und Build-Methoden können Sie das verwenden --build-in-source Option, um Ihr Projekt direkt im Quellordner zu erstellen. Standardmäßig ist der AWS SAM CLI erstellt in einem temporären Verzeichnis, was das Kopieren von Quellcode und Projektdateien beinhaltet. Mit --build-in-source, der AWS SAM CLI erstellt direkt in Ihrem Quellordner, wodurch der Build-Prozess beschleunigt wird, da keine Dateien mehr in ein temporäres Verzeichnis kopiert werden müssen.

Eine Liste der unterstützten Laufzeiten und Build-Methoden finden Sie unter --build-in-source.

Fehlerbehebung

Um Fehler zu beheben AWS SAM CLI, siehe AWS SAM CLI Fehlerbehebung.

Beispiele

Erstellen einer Anwendung, die eine native Runtime- und den Pakettyp „.zip“ verwendet

Dieses Beispiel finden Sie unter Tutorial: Stellen Sie eine Hello World-Anwendung bereit mit AWS SAM.

Erstellen einer Anwendung, die einen nativen Runtime- und Image-Pakettyp verwendet

Zuerst rennen wir sam init um eine neue Anwendung zu initialisieren. Während des interaktiven Ablaufs wählen wir die Image Pakettyp. Im Folgenden wird ein Beispiel gezeigt:

$ sam init ... 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: 1 Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER Which runtime would you like to use? ... 10 - java8 11 - nodejs20.x 12 - nodejs18.x 13 - nodejs16.x ... Runtime: 12 What package type would you like to use? 1 - Zip 2 - Image Package type: 2 Based on your selections, the only dependency manager available is npm. We will proceed copying the template using npm. Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER Would you like to enable monitoring using CloudWatch Application Insights? For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER Project name [sam-app]: ENTER Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment) ----------------------- Generating application: ----------------------- Name: sam-app Base Image: amazon/nodejs18.x-base Architectures: x86_64 Dependency Manager: npm Output Directory: . Configuration file: sam-app/samconfig.toml Next steps can be found in the README file at sam-app/README.md ...

Das AWS SAM CLI initialisiert eine Anwendung und erstellt das folgende Projektverzeichnis:

sam-app
├── README.md
├── events
│   └── event.json
├── hello-world
│   ├── Dockerfile
│   ├── app.mjs
│   ├── package.json
│   └── tests
│       └── unit
│           └── test-handler.mjs
├── samconfig.toml
└── template.yaml

Als nächstes laufen wir sam build um unsere Anwendung zu erstellen:

sam-app $ sam build Building codeuri: /Users/.../build-demo/sam-app runtime: None metadata: {'DockerTag': 'nodejs18.x-v1', 'DockerContext': '/Users/.../build-demo/sam-app/hello-world', 'Dockerfile': 'Dockerfile'} architecture: arm64 functions: HelloWorldFunction Building image for HelloWorldFunction function Setting DockerBuildArgs: {} for HelloWorldFunction function Step 1/4 : FROM public.ecr.aws/lambda/nodejs:18 ---> f5b68038c080 Step 2/4 : COPY app.mjs package*.json ./ ---> Using cache ---> 834e565aae80 Step 3/4 : RUN npm install ---> Using cache ---> 31c2209dd7b5 Step 4/4 : CMD ["app.lambdaHandler"] ---> Using cache ---> 2ce2a438e89d Successfully built 2ce2a438e89d Successfully tagged helloworldfunction:nodejs18.x-v1 Build Succeeded Built Artifacts : .aws-sam/build Built Template : .aws-sam/build/template.yaml Commands you can use next ========================= [*] Validate SAM template: sam validate [*] Invoke Function: sam local invoke [*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch [*] Deploy: sam deploy --guided

Erstellen einer Anwendung, die eine kompilierte Programmiersprache enthält

In diesem Beispiel erstellen wir eine Anwendung, die eine Lambda-Funktion enthält, mithilfe der Go Laufzeit.

Zuerst initialisieren wir eine neue Anwendung mit sam init und konfigurieren Sie unsere Anwendung zur Verwendung Go:

$ sam init ... 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 ... Template: 1 Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER Which runtime would you like to use? ... 4 - dotnetcore3.1 5 - go1.x 6 - go (provided.al2) ... Runtime: 5 What package type would you like to use? 1 - Zip 2 - Image Package type: 1 Based on your selections, the only dependency manager available is mod. We will proceed copying the template using mod. Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER Would you like to enable monitoring using CloudWatch Application Insights? For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER Project name [sam-app]: ENTER Cloning from https://github.com/aws/aws-sam-cli-app-templates (process may take a moment) ----------------------- Generating application: ----------------------- Name: sam-app Runtime: go1.x Architectures: x86_64 Dependency Manager: mod Application Template: hello-world Output Directory: . Configuration file: sam-app/samconfig.toml Next steps can be found in the README file at sam-app-go/README.md ...

Das AWS SAM CLI initialisiert die Anwendung. Das Folgende ist ein Beispiel für die Verzeichnisstruktur der Anwendung:

sam-app
├── Makefile
├── README.md
├── events
│   └── event.json
├── hello-world
│   ├── go.mod
│   ├── go.sum
│   ├── main.go
│   └── main_test.go
├── samconfig.toml
└── template.yaml

Wir verweisen auf README.md Datei für die Anforderungen dieser Anwendung.

...
## Requirements
* AWS CLI already configured with Administrator permission
* [Docker installed](https://www.docker.com/community-edition)
* [Golang](https://golang.org)
* SAM CLI - [Install the SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)
...

Als nächstes rennen wir sam local invoke um unsere Funktion zu testen. Dieser Befehl ist fehlerhaft seit Go ist nicht auf unserem lokalen Computer installiert:

sam-app $ sam local invoke Invoking hello-world (go1.x) Local image was not found. Removing rapid images for repo public.ecr.aws/sam/emulation-go1.x Building image................................................................................................................................................................................................................................................. Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64. Mounting /Users/.../Playground/build/sam-app/hello-world as /var/task:ro,delegated inside runtime container START RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 Version: $LATEST fork/exec /var/task/hello-world: no such file or directory: PathError null END RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 REPORT RequestId: c6c5eddf-042b-4e1e-ba66-745f7c86dd31 Init Duration: 0.88 ms Duration: 175.75 ms Billed Duration: 176 ms Memory Size: 128 MB Max Memory Used: 128 MB {"errorMessage":"fork/exec /var/task/hello-world: no such file or directory","errorType":"PathError"}%

Als nächstes rennen wir sam build um unsere Anwendung zu erstellen. Seitdem ist ein Fehler aufgetreten Go ist nicht auf unserem lokalen Computer installiert:

sam-app $ sam build Starting Build use cache Cache is invalid, running build and copying resources for following functions (HelloWorldFunction) Building codeuri: /Users/.../Playground/build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction Build Failed Error: GoModulesBuilder:Resolver - Path resolution for runtime: go1.x of binary: go was not successful

Wir könnten zwar unseren lokalen Computer so konfigurieren, dass er unsere Funktion richtig erstellt, aber wir verwenden stattdessen den --use-container Option mit sam build. Das AWS SAM CLI lädt ein Container-Image herunter und erstellt unsere Funktion mit dem nativen GoModulesBuilderund kopiert die resultierende Binärdatei in unsere .aws-sam/build/HelloWorldFunction Verzeichnis.

sam-app $ sam build --use-container Starting Build use cache Starting Build inside a container Cache is invalid, running build and copying resources for following functions (HelloWorldFunction) Building codeuri: /Users/.../build/sam-app/hello-world runtime: go1.x metadata: {} architecture: x86_64 functions: HelloWorldFunction Fetching public.ecr.aws/sam/build-go1.x:latest-x86_64 Docker container image..................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................... Mounting /Users/.../build/sam-app/hello-world as /tmp/samcli/source:ro,delegated inside runtime container Running GoModulesBuilder:Build Build Succeeded Built Artifacts : .aws-sam/build Built Template : .aws-sam/build/template.yaml Commands you can use next ========================= [*] Validate SAM template: sam validate [*] Invoke Function: sam local invoke [*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch [*] Deploy: sam deploy --guided

Das Folgende ist ein Beispiel für .aws-sam Verzeichnis:

.aws-sam
├── build
│   ├── HelloWorldFunction
│   │   └── hello-world
│   └── template.yaml
├── build.toml
├── cache
│   └── c860d011-4147-4010-addb-2eaa289f4d95
│       └── hello-world
└── deps

Als nächstes rennen wir sam local invoke. Unsere Funktion wurde erfolgreich aufgerufen:

sam-app $ sam local invoke Invoking hello-world (go1.x) Local image is up-to-date Using local image: public.ecr.aws/lambda/go:1-rapid-x86_64. Mounting /Users/.../Playground/build/sam-app/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated inside runtime container START RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 Version: $LATEST END RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 REPORT RequestId: cfc8ffa8-29f2-49d4-b461-45e8c7c80479 Init Duration: 1.20 ms Duration: 1782.46 ms Billed Duration: 1783 ms Memory Size: 128 MB Max Memory Used: 128 MB {"statusCode":200,"headers":null,"multiValueHeaders":null,"body":"Hello, 72.21.198.67\n"}%

Weitere Informationen

Um mehr über die Verwendung von zu erfahren sam build Den Befehl finden Sie im Folgenden: