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.
# Stellen Sie Ihre Anwendung und Ressourcen bereit mit AWS SAM
Durch die Bereitstellung Ihrer Anwendung werden Ihre AWS Ressourcen in der AWS Cloud bereitgestellt und konfiguriert, sodass Ihre Anwendung in der Cloud ausgeführt wird. AWS SAM verwendet [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/)als zugrunde liegenden Bereitstellungsmechanismus. AWS SAM verwendet die Build-Artefakte, die Sie bei der Ausführung des **sam build** Befehls erstellen, als Standardeingaben für die Bereitstellung Ihrer serverlosen Anwendung.
Mit AWS SAM können Sie Ihre serverlose Anwendung manuell bereitstellen oder Bereitstellungen automatisieren. Um Bereitstellungen zu automatisieren, verwenden Sie AWS SAM Pipelines mit einem CI/CD-System (Continuous Integration and Continuous Deployment) Ihrer Wahl. Ihre Bereitstellungspipeline besteht aus einer automatisierten Abfolge von Schritten, die ausgeführt werden, um eine neue Version Ihrer serverlosen Anwendung zu veröffentlichen.
Die Themen in diesem Abschnitt enthalten Anleitungen sowohl zu automatisierten als auch zu manuellen Bereitstellungen. Um Ihre Anwendung manuell bereitzustellen, verwenden Sie AWS SAMCLI Befehle. Informationen zur Automatisierung von Bereitstellungen finden Sie in den Themen in diesem Abschnitt. Sie bieten insbesondere ausführliche Inhalte zur Automatisierung von Bereitstellungen mithilfe von Pipelines und einem System. CI/CD Dazu gehören die Generierung einer Starter-Pipeline, die Einrichtung der Automatisierung, die Fehlerbehebung bei Bereitstellungen, die Verwendung der OpenID Connect (OIDC) -Benutzerauthentifizierung und das Hochladen lokaler Dateien bei der Bereitstellung.
**Topics**
+ [
# Einführung in die Bereitstellung mit AWS SAM
](using-sam-cli-deploy.md)
+ [
# Optionen für die Bereitstellung Ihrer Anwendung mit AWS SAM
](deploying-options.md)
+ [
# Verwendung von CI/CD Systemen und Pipelines für die Bereitstellung mit AWS SAM
](deploying-cicd-overview.md)
+ [
# Einführung in die Verwendung von sam sync to sync to AWS Cloud
](using-sam-cli-sync.md)
# Einführung in die Bereitstellung mit AWS SAM
Verwenden Sie den AWS Serverless Application Model Befehl Command Line Interface (AWS SAMCLI)`sam deploy`, um Ihre serverlose Anwendung auf dem bereitzustellen. AWS Cloud
+ Eine Einführung in das finden Sie AWS SAMCLI unter[Was ist das? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli).
+ Eine Liste der `sam deploy` Befehlsoptionen finden Sie unter[sam deploy](sam-cli-command-reference-sam-deploy.md).
+ Ein Beispiel für die Verwendung `sam deploy` während eines typischen Entwicklungsworkflows finden Sie unter[Schritt 3: Stellen Sie Ihre Anwendung auf dem bereit AWS Cloud](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-deploy).
**Topics**
+ [
## Voraussetzungen
](#using-sam-cli-deploy-prerequisites)
+ [
## Bereitstellen von Anwendungen mit Sam Deploy
](#using-sam-cli-deploy-deploying)
+ [
## Best Practices
](#using-sam-cli-deploy-best)
+ [
## Optionen für Sam Deploy
](#using-sam-cli-deploy-options)
+ [
## Fehlerbehebung
](#using-sam-cli-deploy-troubleshooting)
+ [
## Beispiele
](#using-sam-cli-deploy-examples)
+ [
## Weitere Informationen
](#using-sam-cli-deploy-learn)
## Voraussetzungen
Um das zu verwenden`sam deploy`, installieren Sie das, AWS SAMCLI indem Sie wie folgt vorgehen:
+ [AWS SAM Voraussetzungen](prerequisites.md).
+ [Installieren Sie das AWS SAMCLI](install-sam-cli.md).
Vor der Verwendung empfehlen wir`sam deploy`, sich mit folgenden Grundkenntnissen vertraut zu machen:
+ [Konfiguration der AWS SAMCLI](using-sam-cli-configure.md).
+ [Erstellen Sie Ihre Bewerbung in AWS SAM](using-sam-cli-init.md).
+ [Einführung in das Bauen mit AWS SAM](using-sam-cli-build.md).
## Bereitstellen von Anwendungen mit Sam Deploy
Wenn Sie eine serverlose Anwendung zum ersten Mal bereitstellen, verwenden Sie die `--guided` Option. Sie AWS SAMCLI führt Sie durch einen interaktiven Ablauf zur Konfiguration der Bereitstellungseinstellungen Ihrer Anwendung.
**Um eine Anwendung mithilfe des interaktiven Ablaufs bereitzustellen**
1. Gehen Sie zum Stammverzeichnis Ihres Projekts. Dies ist derselbe Speicherort wie Ihre AWS SAM Vorlage.
```
$ cd sam-app
```
1. Führen Sie den folgenden Befehl aus:
```
$ sam deploy --guided
```
1. Während des interaktiven Ablaufs werden Sie AWS SAMCLI aufgefordert, Optionen zur Konfiguration der Bereitstellungseinstellungen Ihrer Anwendung anzugeben.
Klammern (`[ ]`) stehen für Standardwerte. Lassen Sie Ihre Antwort leer, um den Standardwert auszuwählen. Standardwerte werden aus den folgenden Konfigurationsdateien abgerufen:
+ `~/.aws/config`— Ihre allgemeinen AWS Kontoeinstellungen.
+ `~/.aws/credentials`— Ihre AWS Kontoanmeldeinformationen.
+ `/samconfig.toml`— Die Konfigurationsdatei Ihres Projekts.
Geben Sie Werte an, indem Sie die AWS SAMCLI Eingabeaufforderungen beantworten. Sie können beispielsweise Werte `y` für **Ja**, `n` für **Nein** oder Zeichenfolgen eingeben.
Der AWS SAMCLI schreibt Ihre Antworten in die `samconfig.toml` Datei Ihres Projekts. Für nachfolgende Bereitstellungen können Sie die Bereitstellung mithilfe dieser konfigurierten Werte verwenden. `sam deploy` Um diese Werte neu zu konfigurieren, verwenden Sie Ihre `sam deploy --guided` Konfigurationsdateien erneut oder ändern Sie sie direkt.
Im Folgenden finden Sie ein Beispiel für eine Ausgabe:
```
sam-app $ sam deploy --guided
Configuring SAM deploy
======================
Looking for config file [samconfig.toml] : Found
Reading default arguments : Success
Setting default arguments for 'sam deploy'
=========================================
Stack Name [sam-app]: ENTER
AWS Region [us-west-2]: ENTER
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: ENTER
#SAM needs permission to be able to create roles to connect to the resources in your template
Allow SAM CLI IAM role creation [Y/n]: ENTER
#Preserves the state of previously provisioned resources when an operation fails
Disable rollback [y/N]: ENTER
HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y
Save arguments to configuration file [Y/n]: ENTER
SAM configuration file [samconfig.toml]: ENTER
SAM configuration environment [default]: ENTER
```
1. Als Nächstes AWS SAMCLI stellt der Ihre Anwendung auf dem AWS Cloud bereit. Während der Bereitstellung wird der Fortschritt in Ihrer Befehlszeile angezeigt. Im Folgenden sind die wichtigsten Phasen der Bereitstellung aufgeführt:
+ Bei Anwendungen mit AWS Lambda Funktionen, die als ZIP-Dateiarchiv verpackt sind, wird das Paket AWS SAMCLI komprimiert und in einen Amazon Simple Storage Service (Amazon S3) -Bucket hochgeladen. Falls erforderlich, AWS SAMCLI wird ein neuer Bucket erstellt.
+ Bei Anwendungen mit einem Lambda-Funktionspaket als Container-Image wird das Image in Amazon Elastic Container Registry (Amazon ECR) AWS SAMCLI hochgeladen. Falls erforderlich, AWS SAMCLI wird ein neues Repository erstellt.
+ Das AWS SAMCLI erstellt einen AWS CloudFormation Änderungssatz und stellt Ihre Anwendung CloudFormation als Stack bereit.
+ Das AWS SAMCLI ändert Ihre bereitgestellte AWS SAM Vorlage mit dem neuen `CodeUri` Wert für Ihre Lambda-Funktionen.
Im Folgenden finden Sie ein Beispiel für die AWS SAMCLI Bereitstellungsausgabe:
```
Looking for resources needed for deployment:
Managed S3 bucket: aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
A different default S3 bucket can be set in samconfig.toml and auto resolution of buckets turned off by setting resolve_s3=False
Parameter "stack_name=sam-app" in [default.deploy.parameters] is defined as a global parameter [default.global.parameters].
This parameter will be only saved under [default.global.parameters] in /Users/.../sam-app/samconfig.toml.
Saved arguments to config file
Running 'sam deploy' for future deployments will use the parameters saved above.
The above parameters can be changed by modifying samconfig.toml
Learn more about samconfig.toml syntax at
https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-config.html
Uploading to sam-app-zip/da3c598813f1c2151579b73ad788cac8 262144 / 619839 (42.29%)Uploading to sam-app-zip/da3c598813f1c2151579b73ad788cac8 524288 / 619839 (84.58%)Uploading to sam-app-zip/da3c598813f1c2151579b73ad788cac8 619839 / 619839 (100.00%)
Deploying with following values
===============================
Stack name : sam-app
Region : us-west-2
Confirm changeset : True
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_IAM"]
Parameter overrides : {}
Signing Profiles : {}
Initiating deployment
=====================
Uploading to sam-app-zip/be84c20f868068e4dc4a2c11966edf2d.template 1212 / 1212 (100.00%)
Waiting for changeset to be created..
CloudFormation stack changeset
-------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
-------------------------------------------------------------------------------------------------
+ Add HelloWorldFunctionHell AWS::Lambda::Permissio N/A
oWorldPermissionProd n
+ Add HelloWorldFunctionRole AWS::IAM::Role N/A
+ Add HelloWorldFunction AWS::Lambda::Function N/A
+ Add ServerlessRestApiDeplo AWS::ApiGateway::Deplo N/A
yment47fc2d5f9d yment
+ Add ServerlessRestApiProdS AWS::ApiGateway::Stage N/A
tage
+ Add ServerlessRestApi AWS::ApiGateway::RestA N/A
pi
-------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1680559234/d9f58a77-98bc-41cd-b9f4-433a5a450d7a
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y
2023-04-03 12:00:50 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 5.0 seconds)
-------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
-------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation
Initiated
CREATE_COMPLETE AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction Resource creation
Initiated
CREATE_COMPLETE AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::ApiGateway::RestA ServerlessRestApi -
pi
CREATE_IN_PROGRESS AWS::ApiGateway::RestA ServerlessRestApi Resource creation
pi Initiated
CREATE_COMPLETE AWS::ApiGateway::RestA ServerlessRestApi -
pi
CREATE_IN_PROGRESS AWS::Lambda::Permissio HelloWorldFunctionHell -
n oWorldPermissionProd
CREATE_IN_PROGRESS AWS::ApiGateway::Deplo ServerlessRestApiDeplo -
yment yment47fc2d5f9d
CREATE_IN_PROGRESS AWS::Lambda::Permissio HelloWorldFunctionHell Resource creation
n oWorldPermissionProd Initiated
CREATE_IN_PROGRESS AWS::ApiGateway::Deplo ServerlessRestApiDeplo Resource creation
yment yment47fc2d5f9d Initiated
CREATE_COMPLETE AWS::ApiGateway::Deplo ServerlessRestApiDeplo -
yment yment47fc2d5f9d
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdS -
tage
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdS Resource creation
tage Initiated
CREATE_COMPLETE AWS::ApiGateway::Stage ServerlessRestApiProdS -
tage
CREATE_COMPLETE AWS::Lambda::Permissio HelloWorldFunctionHell -
n oWorldPermissionProd
CREATE_COMPLETE AWS::CloudFormation::S sam-app-zip -
tack
-------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
-------------------------------------------------------------------------------------------------
Outputs
-------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/sam-app-zip-
HelloWorldFunctionRole-11ZOGSCG28H0M
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://njzfhdmls0.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:sam-app-
HelloWorldFunction-XPqNX4TBu7qn
-------------------------------------------------------------------------------------------------
Successfully created/updated stack - sam-app-zip in us-west-2
```
1. Gehen Sie wie folgt vor, um Ihre bereitgestellte Anwendung anzuzeigen:
1. Öffnen Sie die CloudFormation Konsole direkt mit der URL [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. **Wählen Sie Stacks aus.**
1. Identifizieren Sie Ihren Stack anhand des Anwendungsnamens und wählen Sie ihn aus.
### Überprüfen Sie die Änderungen vor der Bereitstellung
Sie können den so konfigurieren AWS SAMCLI, dass Ihr CloudFormation Änderungssatz angezeigt wird und Sie vor der Bereitstellung um Bestätigung gebeten werden.
**Um Änderungen vor der Bereitstellung zu bestätigen**
1. Geben Sie `sam deploy --guided` währenddessen ein, **Y** um die Änderungen vor der Bereitstellung zu bestätigen.
```
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: Y
```
Alternativ können Sie Ihre `samconfig.toml` Datei wie folgt ändern:
```
[default.deploy]
[default.deploy.parameters]
confirm_changeset = true
```
1. Während der Bereitstellung AWS SAMCLI werden Sie aufgefordert, die Änderungen vor der Bereitstellung zu bestätigen. Im Folgenden wird ein Beispiel gezeigt:
```
Waiting for changeset to be created..
CloudFormation stack changeset
-------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
-------------------------------------------------------------------------------------------------
+ Add HelloWorldFunctionHell AWS::Lambda::Permissio N/A
oWorldPermissionProd n
+ Add HelloWorldFunctionRole AWS::IAM::Role N/A
+ Add HelloWorldFunction AWS::Lambda::Function N/A
+ Add ServerlessRestApiDeplo AWS::ApiGateway::Deplo N/A
yment47fc2d5f9d yment
+ Add ServerlessRestApiProdS AWS::ApiGateway::Stage N/A
tage
+ Add ServerlessRestApi AWS::ApiGateway::RestA N/A
pi
-------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1680559234/d9f58a77-98bc-41cd-b9f4-433a5a450d7a
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y
```
### Geben Sie während der Bereitstellung zusätzliche Parameter an
Sie können zusätzliche Parameterwerte angeben, die bei der Bereitstellung konfiguriert werden sollen. Sie tun dies, indem Sie Ihre AWS SAM Vorlage ändern und Ihren Parameterwert während der Bereitstellung konfigurieren.
**Um zusätzliche Parameter anzugeben**
1. Ändern Sie den `Parameters` Abschnitt Ihrer AWS SAM Vorlage. Im Folgenden wird ein Beispiel gezeigt:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Globals:
...
Parameters:
DomainName:
Type: String
Default: example
Description: Domain name
```
1. Führen Sie `sam deploy --guided`. Im Folgenden finden Sie ein Beispiel für eine Ausgabe:
```
sam-app $ sam deploy --guided
Configuring SAM deploy
======================
Looking for config file [samconfig.toml] : Found
Reading default arguments : Success
Setting default arguments for 'sam deploy'
=========================================
Stack Name [sam-app-zip]: ENTER
AWS Region [us-west-2]: ENTER
Parameter DomainName [example]: ENTER
```
### Konfigurieren Sie die Codesignatur für Ihre Lambda-Funktionen
Sie können die Codesignatur für Ihre Lambda-Funktionen bei der Bereitstellung konfigurieren. Dazu ändern Sie Ihre AWS SAM Vorlage und konfigurieren die Codesignatur während der Bereitstellung.
**Um die Codesignatur zu konfigurieren**
1. Geben Sie `CodeSigningConfigArn` dies in Ihrer AWS SAM Vorlage an. Im Folgenden wird ein Beispiel gezeigt:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.7
CodeSigningConfigArn: arn:aws:lambda:us-east-1:111122223333:code-signing-config:csc-12e12345db1234567
```
1. Führen Sie `sam deploy --guided`. Sie AWS SAMCLI werden aufgefordert, die Codesignatur zu konfigurieren. Im Folgenden finden Sie ein Beispiel für eine Ausgabe:
```
#Found code signing configurations in your function definitions
Do you want to sign your code? [Y/n]: ENTER
#Please provide signing profile details for the following functions & layers
#Signing profile details for function 'HelloWorld'
Signing Profile Name:
Signing Profile Owner Account ID (optional):
#Signing profile details for layer 'MyLayer', which is used by functions {'HelloWorld'}
Signing Profile Name:
Signing Profile Owner Account ID (optional):
```
## Best Practices
+ Bei der Verwendung `sam deploy` werden die AWS SAMCLI Build-Artefakte Ihrer Anwendung bereitgestellt, die sich im `.aws-sam` Verzeichnis befinden. Wenn Sie Änderungen an den Originaldateien Ihrer Anwendung vornehmen, führen Sie vor der Bereitstellung den Befehl aus, `sam build` um das `.aws-sam` Verzeichnis zu aktualisieren.
+ Wenn Sie eine Anwendung zum ersten Mal bereitstellen, verwenden Sie diese Option, `sam deploy --guided` um die Bereitstellungseinstellungen zu konfigurieren. Für nachfolgende Bereitstellungen können Sie die Bereitstellung mit Ihren konfigurierten Einstellungen verwenden`sam deploy`.
## Optionen für Sam Deploy
Die folgenden Optionen werden häufig für verwendet`sam deploy`. Eine Liste aller Optionen finden Sie unter[sam deploy](sam-cli-command-reference-sam-deploy.md).
### Verwenden Sie den geführten interaktiven Ablauf, um Ihre Anwendung bereitzustellen
Verwenden Sie die `--guided` Option, um die Bereitstellungseinstellungen Ihrer Anwendung über einen interaktiven Ablauf zu konfigurieren. Im Folgenden wird ein Beispiel gezeigt:
```
$ sam deploy --guided
```
Die Bereitstellungseinstellungen Ihrer Anwendung werden in der `samconfig.toml` Datei Ihres Projekts gespeichert. Weitere Informationen hierzu finden Sie unter [Konfigurieren Sie die Projekteinstellungen](using-sam-cli-configure.md#using-sam-cli-configure-project).
## Fehlerbehebung
Informationen zur Fehlerbehebung bei AWS SAMCLI finden Sie unter[AWS SAMCLIProblembehandlung](sam-cli-troubleshooting.md).
## Beispiele
### Stellen Sie eine Hello World-Anwendung bereit, die eine Lambda-Funktion enthält, die als ZIP-Dateiarchiv verpackt ist
Ein Beispiel finden Sie [Schritt 3: Stellen Sie Ihre Anwendung auf dem bereit AWS Cloud](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-deploy) im Tutorial zur Hello World-Anwendung.
### Stellen Sie eine Hello World-Anwendung bereit, die eine Lambda-Funktion enthält, die als Container-Image verpackt ist
Zunächst erstellen wir `sam init` damit unsere Hello World-Anwendung. Während des interaktiven Ablaufs wählen wir die `Python3.9` Laufzeit und den `Image` Pakettyp aus.
```
$ 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
...
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER
Which runtime would you like to use?
1 - aot.dotnet7 (provided.al2)
...
15 - nodejs12.x
16 - python3.9
17 - python3.8
...
Runtime: 16
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 pip.
We will proceed copying the template using pip.
...
Project name [sam-app]: ENTER
-----------------------
Generating application:
-----------------------
Name: sam-app
Base Image: amazon/python3.9-base
Architectures: x86_64
Dependency Manager: pip
Output Directory: .
Configuration file: sam-app/samconfig.toml
Next steps can be found in the README file at sam-app/README.md
...
```
Als Nächstes `cd` gehen wir in das Stammverzeichnis unseres Projekts und führen es aus`sam build`. Das AWS SAMCLI erstellt unsere Lambda-Funktion lokal mitDocker.
```
sam-app $ sam build
Building codeuri: /Users/.../sam-app runtime: None metadata: {'Dockerfile': 'Dockerfile', 'DockerContext': '/Users/.../sam-app/hello_world', 'DockerTag': 'python3.9-v1'} architecture: x86_64 functions: HelloWorldFunction
Building image for HelloWorldFunction function
Setting DockerBuildArgs: {} for HelloWorldFunction function
Step 1/5 : FROM public.ecr.aws/lambda/python:3.9
---> 0a5e3da309aa
Step 2/5 : COPY requirements.txt ./
---> abc4e82e85f9
Step 3/5 : RUN python3.9 -m pip install -r requirements.txt -t .
---> [Warning] The requested image's platform (linux/amd64) does not match the detected host platform (linux/arm64/v8) and no specific platform was requested
---> Running in 43845e7aa22d
Collecting requests
Downloading requests-2.28.2-py3-none-any.whl (62 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 62.8/62.8 KB 829.5 kB/s eta 0:00:00
Collecting idna<4,>=2.5
Downloading idna-3.4-py3-none-any.whl (61 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 61.5/61.5 KB 2.4 MB/s eta 0:00:00
Collecting charset-normalizer<4,>=2
Downloading charset_normalizer-3.1.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (199 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 199.2/199.2 KB 2.1 MB/s eta 0:00:00
Collecting certifi>=2017.4.17
Downloading certifi-2022.12.7-py3-none-any.whl (155 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 155.3/155.3 KB 10.2 MB/s eta 0:00:00
Collecting urllib3<1.27,>=1.21.1
Downloading urllib3-1.26.15-py2.py3-none-any.whl (140 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 140.9/140.9 KB 9.1 MB/s eta 0:00:00
Installing collected packages: urllib3, idna, charset-normalizer, certifi, requests
Successfully installed certifi-2022.12.7 charset-normalizer-3.1.0 idna-3.4 requests-2.28.2 urllib3-1.26.15
Removing intermediate container 43845e7aa22d
---> cab8ace899ce
Step 4/5 : COPY app.py ./
---> 4146f3cd69f2
Step 5/5 : CMD ["app.lambda_handler"]
---> [Warning] The requested image's platform (linux/amd64) does not match the detected host platform (linux/arm64/v8) and no specific platform was requested
---> Running in f4131ddffb31
Removing intermediate container f4131ddffb31
---> d2f5180b2154
Successfully built d2f5180b2154
Successfully tagged helloworldfunction:python3.9-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
```
Als Nächstes starten wir, `sam deploy --guided` um unsere Anwendung bereitzustellen. Das AWS SAMCLI führt uns durch die Konfiguration unserer Bereitstellungseinstellungen. Anschließend AWS SAMCLI stellt der unsere Anwendung auf dem AWS Cloud bereit.
```
sam-app $ sam deploy --guided
Configuring SAM deploy
======================
Looking for config file [samconfig.toml] : Found
Reading default arguments : Success
Setting default arguments for 'sam deploy'
=========================================
Stack Name [sam-app]: ENTER
AWS Region [us-west-2]: ENTER
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: ENTER
#SAM needs permission to be able to create roles to connect to the resources in your template
Allow SAM CLI IAM role creation [Y/n]: ENTER
#Preserves the state of previously provisioned resources when an operation fails
Disable rollback [y/N]: ENTER
HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y
Save arguments to configuration file [Y/n]: ENTER
SAM configuration file [samconfig.toml]: ENTER
SAM configuration environment [default]: ENTER
Looking for resources needed for deployment:
Managed S3 bucket: aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
A different default S3 bucket can be set in samconfig.toml and auto resolution of buckets turned off by setting resolve_s3=False
Parameter "stack_name=sam-app" in [default.deploy.parameters] is defined as a global parameter [default.global.parameters].
This parameter will be only saved under [default.global.parameters] in /Users/.../sam-app/samconfig.toml.
Saved arguments to config file
Running 'sam deploy' for future deployments will use the parameters saved above.
The above parameters can be changed by modifying samconfig.toml
Learn more about samconfig.toml syntax at
https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-config.html
e95fc5e75742: Pushed
d8df51e7bdd7: Pushed
b1d0d7e0b34a: Pushed
0071317b94d8: Pushed
d98f98baf147: Pushed
2d244e0816c6: Pushed
eb2eeb1ebe42: Pushed
a5ca065a3279: Pushed
fe9e144829c9: Pushed
helloworldfunction-d2f5180b2154-python3.9-v1: digest: sha256:cceb71401b47dc3007a7a1e1f2e0baf162999e0e6841d15954745ecc0c447533 size: 2206
Deploying with following values
===============================
Stack name : sam-app
Region : us-west-2
Confirm changeset : True
Disable rollback : False
Deployment image repository :
{
"HelloWorldFunction": "012345678910.dkr.ecr.us-west-2.amazonaws.com/samapp7427b055/helloworldfunction19d43fc4repo"
}
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_IAM"]
Parameter overrides : {}
Signing Profiles : {}
Initiating deployment
=====================
HelloWorldFunction may not have authorization defined.
Uploading to sam-app/682ad27c7cf7a17c7f77a1688b0844f2.template 1328 / 1328 (100.00%)
Waiting for changeset to be created..
CloudFormation stack changeset
-------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
-------------------------------------------------------------------------------------------------
+ Add HelloWorldFunctionHell AWS::Lambda::Permissio N/A
oWorldPermissionProd n
+ Add HelloWorldFunctionRole AWS::IAM::Role N/A
+ Add HelloWorldFunction AWS::Lambda::Function N/A
+ Add ServerlessRestApiDeplo AWS::ApiGateway::Deplo N/A
yment47fc2d5f9d yment
+ Add ServerlessRestApiProdS AWS::ApiGateway::Stage N/A
tage
+ Add ServerlessRestApi AWS::ApiGateway::RestA N/A
pi
-------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1680634124/0ffd4faf-2e2b-487e-b9e0-9116e8299ac4
Previewing CloudFormation changeset before deployment
======================================================
Deploy this changeset? [y/N]: y
2023-04-04 08:49:15 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 5.0 seconds)
-------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
-------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::CloudFormation::S sam-app User Initiated
tack
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation
Initiated
CREATE_COMPLETE AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction Resource creation
Initiated
CREATE_COMPLETE AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::ApiGateway::RestA ServerlessRestApi -
pi
CREATE_IN_PROGRESS AWS::ApiGateway::RestA ServerlessRestApi Resource creation
pi Initiated
CREATE_COMPLETE AWS::ApiGateway::RestA ServerlessRestApi -
pi
CREATE_IN_PROGRESS AWS::Lambda::Permissio HelloWorldFunctionHell -
n oWorldPermissionProd
CREATE_IN_PROGRESS AWS::ApiGateway::Deplo ServerlessRestApiDeplo -
yment yment47fc2d5f9d
CREATE_IN_PROGRESS AWS::Lambda::Permissio HelloWorldFunctionHell Resource creation
n oWorldPermissionProd Initiated
CREATE_IN_PROGRESS AWS::ApiGateway::Deplo ServerlessRestApiDeplo Resource creation
yment yment47fc2d5f9d Initiated
CREATE_COMPLETE AWS::ApiGateway::Deplo ServerlessRestApiDeplo -
yment yment47fc2d5f9d
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdS -
tage
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdS Resource creation
tage Initiated
CREATE_COMPLETE AWS::ApiGateway::Stage ServerlessRestApiProdS -
tage
CREATE_COMPLETE AWS::Lambda::Permissio HelloWorldFunctionHell -
n oWorldPermissionProd
CREATE_COMPLETE AWS::CloudFormation::S sam-app -
tack
-------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
-------------------------------------------------------------------------------------------------
Outputs
-------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/sam-app-HelloWorldFunctionRole-JFML1JOKHJ71
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://endlwiqqod.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:sam-app-HelloWorldFunction-
kyg6Y2iNRUPg
-------------------------------------------------------------------------------------------------
Successfully created/updated stack - sam-app in us-west-2
```
## Weitere Informationen
Weitere Informationen zur Verwendung des AWS SAMCLI `sam deploy` Befehls finden Sie in den folgenden Abschnitten:
+ **[Der komplette AWS SAM Workshop: Modul 3 — Manuelles Bereitstellen](https://s12d.com/sam-ws-en-manual-deploy)** — Erfahren Sie, wie Sie eine serverlose Anwendung mit dem AWS SAMCLI erstellen, paketieren und bereitstellen.
# Optionen für die Bereitstellung Ihrer Anwendung mit AWS SAM
Mit AWS SAM können Sie Ihre Anwendung manuell bereitstellen und Bereitstellungen automatisieren. Verwenden Sie die AWS SAMCLI, um Ihre Anwendung manuell bereitzustellen. Verwenden Sie zur Automatisierung der Bereitstellung Pipelines und ein CI/CD-System (Continuous Integration and Continuous Deployment). Die Themen in diesem Abschnitt enthalten Informationen zu beiden Ansätzen.
**Topics**
+ [
## Wie benutzt man den AWS SAMCLI für die manuelle Bereitstellung
](#serverless-sam-cli-using-package-and-deploy)
+ [
## Bereitstellen mit CI/CD Systemen und Pipelines
](#serverless-deploying-ci-cd)
+ [
## Schrittweise Bereitstellungen
](#serverless-deploying-gradual)
+ [
## Problembehandlung bei Bereitstellungen mit dem AWS SAMCLI
](#serverless-deploying-troubleshooting)
+ [
## Weitere Informationen
](#serverless-sam-cli-using-invoke-learn)
## Wie benutzt man den AWS SAMCLI für die manuelle Bereitstellung
Nachdem Sie Ihre serverlose Anwendung lokal entwickelt und getestet haben, können Sie Ihre Anwendung mithilfe des **[sam deploy](sam-cli-command-reference-sam-deploy.md)** Befehls bereitstellen.
Geben Sie das AWS SAM Kennzeichen an, damit Sie mit Anweisungen durch die **--guided** Bereitstellung geführt werden. Wenn Sie dieses Flag angeben, komprimiert der **sam deploy** Befehl Ihre Anwendungsartefakte und lädt sie entweder in Amazon Simple Storage Service (Amazon S3) (für ZIP-Dateiarchive) oder in Amazon Elastic Container Registry (Amazon ECR) (für Container-Images) hoch. Der Befehl stellt dann Ihre Anwendung in der Cloud bereit. AWS
**Beispiel:**
```
# Deploy an application using prompts:
sam deploy --guided
```
## Bereitstellen mit CI/CD Systemen und Pipelines
AWS SAM unterstützt Sie bei der Automatisierung der Bereitstellung mithilfe von Pipelines und einem CI/CD-System (Continuous Integration and Continuous Deployment). AWS SAM kann verwendet werden, um Pipelines zu erstellen und CI/CD Aufgaben für serverlose Anwendungen zu vereinfachen. Mehrere CI/CD Systeme unterstützen AWS SAM Build-Container-Images und bieten AWS SAM außerdem eine Reihe von Standard-Pipeline-Vorlagen für mehrere CI/CD Systeme, in denen die bewährten Bereitstellungsmethoden zusammengefasst AWS sind.
Weitere Informationen finden Sie unter [Verwendung von CI/CD Systemen und Pipelines für die Bereitstellung mit AWS SAM](deploying-cicd-overview.md).
## Schrittweise Bereitstellungen
Wenn Sie Ihre AWS SAM Anwendung schrittweise und nicht alle auf einmal bereitstellen möchten, können Sie Bereitstellungskonfigurationen angeben, die Folgendes AWS CodeDeploy bieten: Weitere Informationen finden Sie [ CodeDeployim *AWS CodeDeploy Benutzerhandbuch* unter Arbeiten mit Bereitstellungskonfigurationen](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-configurations.html).
Informationen zur Konfiguration Ihrer AWS SAM Anwendung für die schrittweise Bereitstellung finden Sie unter[Schrittweise Bereitstellung serverloser Anwendungen mit AWS SAM](automating-updates-to-serverless-apps.md).
## Problembehandlung bei Bereitstellungen mit dem AWS SAMCLI
### AWS SAMCLIFehler: „Sicherheitseinschränkungen nicht erfüllt“
Beim Ausführen **sam deploy --guided** wird Ihnen die Frage angezeigt`HelloWorldFunction may not have authorization defined, Is this okay? [y/N]`. Wenn Sie auf diese Aufforderung mit **N** (der Standardantwort) antworten, wird der folgende Fehler angezeigt:
```
Error: Security Constraints Not Satisfied
```
Die Aufforderung informiert Sie darüber, dass für die Anwendung, die Sie bereitstellen möchten, möglicherweise eine Amazon API Gateway Gateway-API ohne Autorisierung konfiguriert ist. Wenn Sie **N** auf diese Aufforderung antworten, sagen Sie, dass dies nicht in Ordnung ist.
Um dieses Problem zu beheben, haben Sie die folgenden Optionen:
+ Konfigurieren Sie Ihre Anwendung mit Autorisierung. Informationen zur Konfiguration der Autorisierung finden Sie unter[Kontrollieren Sie den API-Zugriff mit Ihrer AWS SAM Vorlage](serverless-controlling-access-to-apis.md).
+ Beantworten Sie diese Frage mit, **Y** um anzugeben, dass Sie mit der Bereitstellung einer Anwendung einverstanden sind, für die eine API-Gateway-API ohne Autorisierung konfiguriert ist.
## Weitere Informationen
Praktische Beispiele für die Bereitstellung serverloser Anwendungen finden Sie im Folgenden in The *Complete AWS SAM Workshop*:
+ [Modul 3 — Manuelles Bereitstellen](https://s12d.com/sam-ws-en-manual-deploy) — Erfahren Sie, wie Sie eine serverlose Anwendung mithilfe von erstellen, verpacken und bereitstellen. AWS SAMCLI
+ [Modul 4 — CI/CD](https://s12d.com/sam-ws-en-cicd-deploy) — Erfahren Sie, wie Sie die Erstellungs-, Paketierungs- und Bereitstellungsphasen automatisieren können, indem Sie eine *CI/CD-Pipeline (Continuous Integration and Delivery) einrichten*.
# Verwendung von CI/CD Systemen und Pipelines für die Bereitstellung mit AWS SAM
AWS SAM unterstützt Unternehmen bei der Erstellung von Pipelines für ihre bevorzugten CI/CD Systeme, sodass sie CI/CD mit minimalem Aufwand die Vorteile nutzen können, wie z. B. die Beschleunigung der Bereitstellungshäufigkeit, die Verkürzung der Vorlaufzeit für Änderungen und die Reduzierung von Bereitstellungsfehlern.
AWS SAM vereinfacht CI/CD Aufgaben für serverlose Anwendungen mithilfe von Build-Container-Images. Die bereitgestellten Images beinhalten die Tools AWS SAMCLI und Build-Tools für eine Reihe unterstützter AWS Lambda Laufzeiten. AWS SAM Dies macht es einfacher, serverlose Anwendungen mithilfe von zu erstellen und zu paketieren. AWS SAMCLI Diese Images machen es den Teams auch leichter, ihre eigenen Images für CI/CD Systeme zu erstellen und zu verwalten. Weitere Informationen zum AWS SAM Erstellen von Container-Images finden Sie unter[Bild-Repositorys für AWS SAM](serverless-image-repositories.md).
Das AWS SAM Erstellen von Container-Images wird von mehreren CI/CD Systemen unterstützt. Welches CI/CD System Sie verwenden sollten, hängt von mehreren Faktoren ab. Dazu gehört, ob Ihre Anwendung eine einzelne Laufzeit oder mehrere Laufzeiten verwendet oder ob Sie Ihre Anwendung in einem Container-Image oder direkt auf einem Hostcomputer, entweder einer virtuellen Maschine (VM) oder einem Bare-Metal-Host, erstellen möchten.
AWS SAM bietet außerdem eine Reihe von Standard-Pipeline-Vorlagen für mehrere CI/CD Systeme, in denen die bewährten Bereitstellungsmethoden zusammengefasst AWS sind. Diese Standard-Pipeline-Vorlagen verwenden standardmäßige JSON/YAML Pipeline-Konfigurationsformate, und die integrierten Best Practices helfen bei der Durchführung von Bereitstellungen mit mehreren Konten und Regionen und stellen sicher, dass Pipelines keine unbeabsichtigten Änderungen an der Infrastruktur vornehmen können.
Sie haben zwei Hauptoptionen für die Bereitstellung Ihrer serverlosen Anwendungen: 1) Ändern Sie Ihre bestehende Pipeline-Konfiguration, sodass AWS SAMCLI Befehle verwendet werden, oder 2) Generieren Sie eine CI/CD Beispiel-Pipeline-Konfiguration, die Sie als Ausgangspunkt für Ihre eigene Anwendung verwenden können. AWS SAM
**Topics**
+ [
## Was ist eine Pipeline?
](#deploying-whatis-pipeline)
+ [
# So werden lokale Dateien bei der Bereitstellung AWS SAM hochgeladen
](deploy-upload-local-files.md)
+ [
# Generieren Sie eine CI/CD Starter-Pipeline mit AWS SAM
](serverless-generating-example-ci-cd.md)
+ [
# So passen Sie Starter-Pipelines an mit AWS SAM
](serverless-customizing-starter-pipelines.md)
+ [
# Automatisieren Sie die Bereitstellung Ihrer AWS SAM Anwendung
](serverless-deploying-modify-pipeline.md)
+ [
# So verwenden Sie die OIDC-Authentifizierung mit Pipelines AWS SAM
](deploying-with-oidc.md)
## Was ist eine Pipeline?
Eine Pipeline ist eine automatisierte Abfolge von Schritten, die ausgeführt werden, um eine neue Version einer Anwendung zu veröffentlichen. [Mit AWS SAM können Sie viele gängige CI/CD Systeme für die Bereitstellung Ihrer Anwendungen verwenden, darunter [Jenkins [AWS CodePipeline](https://aws.amazon.com/codepipeline)](https://www.jenkins.io/), [GitLab CI/CD](https://docs.gitlab.com/ee/ci/) und Actions. GitHub](https://github.com/features/actions)
Pipeline-Vorlagen enthalten bewährte AWS Bereitstellungsmethoden, die Sie bei Bereitstellungen mit mehreren Konten und Regionen unterstützen. AWS Umgebungen wie Entwicklung und Produktion existieren in der Regel in unterschiedlichen Konten. AWS Auf diese Weise können Entwicklungsteams sichere Bereitstellungspipelines konfigurieren, ohne unbeabsichtigte Änderungen an der Infrastruktur vorzunehmen.
Sie können auch Ihre eigenen benutzerdefinierten Pipeline-Vorlagen bereitstellen, um die Pipelines zwischen den Entwicklungsteams zu standardisieren.
# So werden lokale Dateien bei der Bereitstellung AWS SAM hochgeladen
Wenn Sie Ihre Anwendung auf dem bereitstellen AWS Cloud, AWS CloudFormation müssen Ihre lokalen Dateien zunächst in einen zugänglichen AWS Service wie Amazon Simple Storage Service (Amazon S3) hochgeladen werden. Dies schließt lokale Dateien ein, auf die Ihre AWS SAM Vorlage verweist. Um diese Anforderung zu erfüllen, AWS SAMCLI geht der wie folgt vor, wenn Sie den `sam package` Befehl `sam deploy` oder verwenden:
1. Lädt Ihre lokalen Dateien automatisch in einen AWS Dienst hoch, auf den zugegriffen werden kann.
1. Aktualisiert Ihre Anwendungsvorlage automatisch, sodass sie auf den neuen Dateipfad verweist.
**Topics**
+ [
## Demo: Verwenden Sie AWS SAMCLI den Lambda-Funktionscode zum Hochladen
](#deploy-upload-local-files-demo)
+ [
## Unterstützte Anwendungsfälle
](#deploy-upload-local-files-use)
+ [
## Weitere Informationen
](#deploy-upload-local-files-learn)
## Demo: Verwenden Sie AWS SAMCLI den Lambda-Funktionscode zum Hochladen
In dieser Demo initialisieren wir die Hello World-Beispielanwendung mit einem Pakettyp .zip für unsere Lambda-Funktion. Wir verwenden den AWS SAMCLI, um unseren Lambda-Funktionscode automatisch auf Amazon S3 hochzuladen und auf seinen neuen Pfad in unserer Anwendungsvorlage zu verweisen.
Zuerst starten wir, `sam init` um unsere Hello World-Anwendung zu initialisieren.
```
$ 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
...
Template: 1
Use the most popular runtime and package type? (Python and zip) [y/N]: y
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]: demo
-----------------------
Generating application:
-----------------------
Name: demo
Runtime: python3.9
Architectures: x86_64
Dependency Manager: pip
Application Template: hello-world
Output Directory: .
Configuration file: demo/samconfig.toml
...
```
Unser Lambda-Funktionscode ist im `hello_world` Unterverzeichnis unseres Projekts organisiert.
```
demo
├── README.md
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── template.yaml
└── tests
```
In unserer AWS SAM Vorlage verweisen wir mithilfe der `CodeUri` Eigenschaft auf den lokalen Pfad zu unserem Lambda-Funktionscode.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
Properties:
CodeUri: hello_world/
Handler: app.lambda_handler
Runtime: python3.9
...
```
Als Nächstes erstellen wir unsere `sam build` Anwendung und bereiten sie auf die Bereitstellung vor.
```
$ sam build
Starting Build use cache
Manifest file is changed (new hash: 3298f13049d19cffaa37ca931dd4d421) or dependency folder (.aws-sam/deps/7896875f-9bcc-4350-8adb-2c1d543627a1) is missing for (HelloWorldFunction), downloading dependencies and copying/building source
Building codeuri: /Users/.../demo/hello_world runtime: python3.9 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
...
```
Als Nächstes starten wir, `sam deploy --guided` um unsere Anwendung bereitzustellen.
```
$ sam deploy --guided
Configuring SAM deploy
======================
Looking for config file [samconfig.toml] : Found
Reading default arguments : Success
Setting default arguments for 'sam deploy'
=========================================
Stack Name [demo]: ENTER
AWS Region [us-west-2]: ENTER
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: n
#SAM needs permission to be able to create roles to connect to the resources in your template
Allow SAM CLI IAM role creation [Y/n]: ENTER
#Preserves the state of previously provisioned resources when an operation fails
Disable rollback [y/N]: ENTER
HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y
Save arguments to configuration file [Y/n]: ENTER
SAM configuration file [samconfig.toml]: ENTER
SAM configuration environment [default]: ENTER
Looking for resources needed for deployment:
...
Saved arguments to config file
Running 'sam deploy' for future deployments will use the parameters saved above.
The above parameters can be changed by modifying samconfig.toml
Learn more about samconfig.toml syntax at
https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-config.html
File with same data already exists at demo/da3c598813f1c2151579b73ad788cac8, skipping upload
Deploying with following values
===============================
Stack name : demo
Region : us-west-2
Confirm changeset : False
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_IAM"]
Parameter overrides : {}
Signing Profiles : {}
Initiating deployment
=====================
...
Waiting for changeset to be created..
CloudFormation stack changeset
-------------------------------------------------------------------------------------------------
Operation LogicalResourceId ResourceType Replacement
-------------------------------------------------------------------------------------------------
+ Add HelloWorldFunctionHell AWS::Lambda::Permissio N/A
oWorldPermissionProd n
+ Add HelloWorldFunctionRole AWS::IAM::Role N/A
...
-------------------------------------------------------------------------------------------------
Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1680906292/1164338d-72e7-4593-a372-f2b3e67f542f
2023-04-07 12:24:58 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 5.0 seconds)
-------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
-------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation
Initiated
...
-------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
-------------------------------------------------------------------------------------------------
Outputs
-------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/demo-HelloWorldFunctionRole-VQ4CU7UY7S2K
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://satnon55e9.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:demo-
HelloWorldFunction-G14inKTmSQvK
-------------------------------------------------------------------------------------------------
Successfully created/updated stack - demo in us-west-2
```
Während der Bereitstellung lädt der AWS SAMCLI automatisch unseren Lambda-Funktionscode auf Amazon S3 hoch und aktualisiert unsere Vorlage. Unsere geänderte Vorlage in der CloudFormation Konsole spiegelt den Amazon S3 S3-Bucket-Pfad wider.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: s3://aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr/demo/da3c598813f1c2151579b73ad788cac8
Handler: app.lambda_handler
...
```
## Unterstützte Anwendungsfälle
Das AWS SAMCLI kann diesen Vorgang für eine Reihe von Dateitypen, CloudFormation Ressourcentypen und CloudFormation Makros automatisch vereinfachen.
### Dateitypen
Anwendungsdateien und Docker Bilder werden unterstützt.
### CloudFormation Ressourcentypen
Im Folgenden finden Sie eine Liste der unterstützten Ressourcentypen und ihrer Eigenschaften:
| Ressource | Eigenschaften |
| --- | --- |
| AWS::ApiGateway::RestApi | BodyS3Location |
| AWS::ApiGatewayV2::Api | BodyS3Location |
| AWS::AppSync:FunctionConfiguration | `CodeS3Location` `RequestMappingTemplateS3Location` `ResponseMappingTemplateS3Location` |
| AWS::AppSync::GraphQLSchema | DefinitionS3Location |
| AWS::AppSync::Resolver | `CodeS3Location` `RequestMappingTemplateS3Location` `ResponseMappingTemplateS3Location` |
| AWS::CloudFormation::ModuleVersion | ModulePackage |
| AWS::CloudFormation::ResourceVersion | SchemaHandlerPackage |
| AWS::ECR::Repository | RepositoryName |
| AWS::ElasticBeanstalk::ApplicationVersion | SourceBundle |
| AWS::Glue::Job | Command.ScriptLocation |
| AWS::Lambda::Function | `Code` `Code.ImageUri` |
| AWS::Lambda::LayerVersion | Content |
| AWS::Serverless::Api | DefinitionUri |
| AWS::Serverless::Function | `CodeUri` `ImageUri` |
| AWS::Serverless::GraphQLApi | `SchemaUri` `Function.CodeUri` `Resolver.CodeUri` |
| AWS::Serverless::HttpApi | DefinitionUri |
| AWS::Serverless::LayerVersion | ContentUri |
| AWS::Serverless::StateMachine | DefinitionUri |
| AWS::StepFunctions::StateMachine | DefinitionS3Location |
### CloudFormation Makros
Dateien, auf die mit dem `AWS::Include` Transform-Makro verwiesen wird, werden unterstützt.
## Weitere Informationen
Weitere Informationen zur `AWS::Include` Transformation finden Sie unter [ AWS::Include Transformation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html) im *AWS CloudFormation Benutzerhandbuch*.
Ein Beispiel für die Verwendung der `AWS::Include` Transformation in einer AWS SAM Vorlage finden Sie im [API-Gateway-HTTP-API-zu-SQS-Muster](https://serverlessland.com/patterns/apigw-sqs) auf *Serverless Land*.
# Generieren Sie eine CI/CD Starter-Pipeline mit AWS SAM
Wenn Sie bereit sind, die Bereitstellung zu automatisieren, können Sie eine der AWS SAM Start-Pipeline-Vorlagen verwenden, um eine Bereitstellungspipeline für das CI/CD System zu generieren, das Sie verwenden möchten. Ihre Bereitstellungspipeline ist das, was Sie konfigurieren und verwenden, um die Bereitstellung Ihrer serverlosen Anwendung zu automatisieren. Eine Vorlage für die Starter-Pipeline ist vorkonfiguriert, damit Sie Ihre Bereitstellungspipeline für Ihre serverlose Anwendung schnell einrichten können.
Mit einer Vorlage für eine Starter-Pipeline können Sie mithilfe des Befehls Pipelines innerhalb von Minuten generieren. [sam pipeline init](sam-cli-command-reference-sam-pipeline-init.md)
Die Vorlagen für die Starter-Pipeline verwenden die vertraute JSON/YAML Syntax des CI/CD Systems und beinhalten bewährte Methoden wie die Verwaltung von Artefakten über mehrere Konten und Regionen hinweg und die Verwendung der Mindestanzahl an Berechtigungen, die für die Bereitstellung der Anwendung erforderlich sind. [Derzeit unterstützt die AWS SAM CLI die Generierung von CI/CD Starter-Pipeline-Konfigurationen für [Jenkins [AWS CodePipeline](https://aws.amazon.com/codepipeline)](https://www.jenkins.io/), [GitLab CI/CD](https://docs.gitlab.com/ee/ci/), [GitHub Actions](https://github.com/features/actions) und Bitbucket-Pipelines.](https://support.atlassian.com/bitbucket-cloud/docs/get-started-with-bitbucket-pipelines/)
Hier sind die wichtigsten Aufgaben, die Sie ausführen müssen, um eine Starter-Pipeline-Konfiguration zu generieren:
1. **Infrastrukturressourcen erstellen** — Ihre Pipeline benötigt bestimmte AWS Ressourcen, z. B. den IAM-Benutzer und Rollen mit den erforderlichen Berechtigungen, einen Amazon S3 S3-Bucket und optional ein Amazon ECR-Repository.
1. **Connect dein Git-Repository mit deinem CI/CD System** — Dein CI/CD System muss wissen, welches Git-Repository die Ausführung der Pipeline auslöst. Beachten Sie, dass dieser Schritt möglicherweise nicht erforderlich ist, je nachdem, welche Kombination aus Git-Repository und CI/CD System Sie verwenden.
1. **Generieren Sie Ihre Pipeline-Konfiguration** — In diesem Schritt wird eine Starter-Pipeline-Konfiguration generiert, die zwei Bereitstellungsphasen umfasst.
1. **Übernehmen Sie Ihre Pipeline-Konfiguration in Ihr Git-Repository** — Dieser Schritt ist notwendig, um sicherzustellen, dass Ihr CI/CD System Ihre Pipeline-Konfiguration kennt. Er wird ausgeführt, wenn die Änderungen festgeschrieben wurden.
Nachdem Sie die Starter-Pipeline-Konfiguration generiert und in Ihr Git-Repository übernommen haben, wird Ihre Pipeline automatisch ausgeführt, wenn jemand eine Codeänderung an dieses Repository festschreibt.
Die Reihenfolge dieser Schritte und die Einzelheiten der einzelnen Schritte variieren je nach CI/CD-System:
+ Wenn Sie verwenden, finden Sie weitere Informationen AWS CodePipeline unter. [Generierung der Starter-Pipeline für AWS CodePipeline in AWS SAM](serverless-generating-example-ci-cd-codepipeline.md)
+ Wenn Sie Jenkins-, GitLab CI/CD-, GitHub Actions- oder Bitbucket-Pipelines verwenden, finden Sie weitere Informationen unter. [Wird verwendet AWS SAM , um Starter-Pipelines für Jenkins, GitLab CI/CD, Actions und Bitbucket-Pipelines zu generieren GitHub](serverless-generating-example-ci-cd-others.md)
# Generierung der Starter-Pipeline für AWS CodePipeline in AWS SAM
Um eine Starter-Pipeline-Konfiguration für zu generieren AWS CodePipeline, führen Sie die folgenden Aufgaben in dieser Reihenfolge aus:
1. Infrastrukturressourcen erstellen
1. Generieren Sie die Pipeline-Konfiguration
1. Übergeben Sie Ihre Pipeline-Konfiguration auf Git
1. Connect dein Git-Repository mit deinem CI/CD System
**Anmerkung**
Das folgende Verfahren verwendet zwei AWS SAMCLI Befehle, `sam pipeline bootstrap` und`sam pipeline init`. Der Grund dafür, dass es zwei Befehle gibt, ist der Anwendungsfall, in dem Administratoren (d. h. Benutzer, die eine Berechtigung zum Einrichten von AWS Infrastrukturressourcen wie IAM-Benutzern und -Rollen benötigen) mehr Rechte haben als Entwickler (d. h. Benutzer, die lediglich die Erlaubnis benötigen, einzelne Pipelines einzurichten, aber nicht die erforderlichen AWS Infrastrukturressourcen).
## Schritt 1: Infrastrukturressourcen erstellen
Verwendete Pipelines AWS SAM benötigen bestimmte AWS Ressourcen, z. B. einen IAM-Benutzer und Rollen mit den erforderlichen Berechtigungen, einen Amazon S3 S3-Bucket und optional ein Amazon ECR-Repository. Sie benötigen für jede Bereitstellungsphase der Pipeline eine Reihe von Infrastrukturressourcen.
Sie können den folgenden Befehl ausführen, um bei dieser Einrichtung zu helfen:
```
sam pipeline bootstrap
```
**Anmerkung**
Führen Sie den vorherigen Befehl für jede Bereitstellungsphase Ihrer Pipeline aus.
## Schritt 2: Generieren Sie die Pipeline-Konfiguration
Führen Sie den folgenden Befehl aus, um die Pipeline-Konfiguration zu generieren:
```
sam pipeline init
```
## Schritt 3: Übernehmen Sie Ihre Pipeline-Konfiguration in das Git-Repository
Dieser Schritt ist notwendig, um sicherzustellen, dass Ihr CI/CD System Ihre Pipeline-Konfiguration kennt. Er wird ausgeführt, wenn die Änderungen übernommen wurden.
## Schritt 4: Connect dein Git-Repository mit deinem CI/CD System
Denn AWS CodePipeline Sie können jetzt die Verbindung herstellen, indem Sie den folgenden Befehl ausführen:
```
sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --region
```
Wenn du Bitbucket GitHub verwendest, stelle nach dem vorherigen Ausführen des **sam deploy** Befehls die Verbindung her, indem du die Schritte unter **So stellst du eine Verbindung her**, die du im Thema [Eine ausstehende Verbindung aktualisieren](https://docs.aws.amazon.com/dtconsole/latest/userguide/connections-update.html) im *Benutzerhandbuch für die Developer Tools-Konsole* findest. Speichere außerdem eine Kopie der `CodeStarConnectionArn` aus der Ausgabe des **sam deploy** Befehls, da du sie benötigst, wenn du sie AWS CodePipeline mit einem anderen Zweig als `main` verwenden möchtest.
## Konfiguration anderer Zweige
AWS CodePipeline Verwendet standardmäßig den `main` Zweig mit AWS SAM. Wenn Sie einen anderen Zweig als verwenden möchten`main`, müssen Sie den **sam deploy** Befehl erneut ausführen. Beachten Sie, dass Sie je nachdem, welches Git-Repository Sie verwenden, möglicherweise auch Folgendes angeben müssen`CodeStarConnectionArn`:
```
# For GitHub and Bitbucket
sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --parameter-overrides="FeatureGitBranch= CodeStarConnectionArn="
# For AWS CodeCommit
sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --parameter-overrides="FeatureGitBranch="
```
## Weitere Informationen
Ein praktisches Beispiel für die Einrichtung einer CI/CD Pipeline finden Sie unter [CI/CD mit AWS CodePipeline](https://catalog.workshops.aws/complete-aws-sam/en-US/module-4-cicd) in *The* Complete Workshop. AWS SAM
# Wird verwendet AWS SAM , um Starter-Pipelines für Jenkins, GitLab CI/CD, Actions und Bitbucket-Pipelines zu generieren GitHub
Um eine Starter-Pipeline-Konfiguration für Jenkins-, GitLab CI/CD-, GitHub Actions- oder Bitbucket-Pipelines zu generieren, führe die folgenden Aufgaben in dieser Reihenfolge aus:
1. Infrastrukturressourcen erstellen
1. Connect dein Git-Repository mit deinem CI/CD System
1. Erstellen Sie Objekte mit Anmeldeinformationen
1. Generieren Sie die Pipeline-Konfiguration
1. Übergeben Sie Ihre Pipeline-Konfiguration in das Git-Repository
**Anmerkung**
Das folgende Verfahren verwendet zwei AWS SAMCLI Befehle, `sam pipeline bootstrap` und`sam pipeline init`. Der Grund dafür, dass es zwei Befehle gibt, ist der Anwendungsfall, in dem Administratoren (d. h. Benutzer, die eine Berechtigung zum Einrichten von AWS Infrastrukturressourcen wie IAM-Benutzern und -Rollen benötigen) mehr Rechte haben als Entwickler (d. h. Benutzer, die lediglich die Erlaubnis benötigen, einzelne Pipelines einzurichten, aber nicht die erforderlichen AWS Infrastrukturressourcen).
## Schritt 1: Infrastrukturressourcen erstellen
Verwendete Pipelines AWS SAM benötigen bestimmte AWS Ressourcen, z. B. einen IAM-Benutzer und Rollen mit den erforderlichen Berechtigungen, einen Amazon S3 S3-Bucket und optional ein Amazon ECR-Repository. Sie benötigen für jede Bereitstellungsphase der Pipeline eine Reihe von Infrastrukturressourcen.
Sie können den folgenden Befehl ausführen, um bei dieser Einrichtung zu helfen:
```
sam pipeline bootstrap
```
**Anmerkung**
Führen Sie den vorherigen Befehl für jede Bereitstellungsphase Ihrer Pipeline aus.
Sie müssen die AWS Anmeldeinformationen (Schlüssel-ID und geheimer Schlüssel) für die Pipeline-Benutzer für jede Bereitstellungsphase Ihrer Pipeline erfassen, da sie für nachfolgende Schritte benötigt werden.
## Schritt 2: Connect dein Git-Repository mit deinem CI/CD System
Das Verbinden Ihres Git-Repositorys mit Ihrem CI/CD System ist notwendig, damit das CI/CD System auf den Quellcode Ihrer Anwendung für Builds und Deployments zugreifen kann.
**Anmerkung**
Sie können diesen Schritt überspringen, wenn Sie eine der folgenden Kombinationen verwenden, da die Verbindung automatisch für Sie hergestellt wird:
GitHub Aktionen mit dem GitHub Repository
GitLab CI/CD mit Repository GitLab
Bitbucket-Pipelines mit einem Bitbucket-Repository
Um dein Git-Repository mit deinem CI/CD System zu verbinden, führe einen der folgenden Schritte aus:
+ Wenn Sie Jenkins verwenden, lesen Sie in der [Jenkins-Dokumentation](https://www.jenkins.io/doc/book/pipeline/multibranch/) unter „Hinzufügen einer Branch-Quelle“ nach.
+ Wenn du GitLab CI/CD und ein anderes Git-Repository als verwendest GitLab, lies die [GitLabDokumentation](https://docs.gitlab.com/ee/ci/ci_cd_for_external_repos/) unter „Ein externes Repository verbinden“.
## Schritt 3: Objekte mit Anmeldeinformationen erstellen
Jedes CI/CD System hat seine eigene Methode zur Verwaltung der Anmeldeinformationen, die das CI/CD System für den Zugriff auf Ihr Git-Repository benötigt.
Gehen Sie wie folgt vor, um die erforderlichen Objekte mit Anmeldeinformationen zu erstellen:
+ Wenn Sie Jenkins verwenden, erstellen Sie ein einzelnes „Credential“, das sowohl die Schlüssel-ID als auch den geheimen Schlüssel speichert. **Folgen Sie den Anweisungen im AWS SAM Blog „[Eine Jenkins-Pipeline mit erstellen“ im Abschnitt „Jenkins](https://aws.amazon.com/blogs/compute/building-a-jenkins-pipeline-with-aws-sam/) konfigurieren“.** Für den nächsten Schritt benötigen Sie die „Credential ID“.
+ Wenn Sie GitLab CI/CD verwenden, erstellen Sie zwei „geschützte Variablen“, jeweils eine für die Schlüssel-ID und den geheimen Schlüssel. Folgen Sie den Anweisungen in der [GitLab Dokumentation](https://docs.gitlab.com/ee/ci/variables/) — für den nächsten Schritt benötigen Sie zwei „variable Schlüssel“.
+ Wenn Sie GitHub Aktionen verwenden, erstellen Sie zwei „verschlüsselte Geheimnisse“, jeweils einen für Schlüssel und geheimen Schlüssel. Folgen Sie den Anweisungen in der [GitHubDokumentation](https://docs.github.com/en/actions/reference/encrypted-secrets). Für den nächsten Schritt benötigen Sie zwei „geheime Namen“.
+ Wenn du Bitbucket-Pipelines verwendest, erstelle zwei „sichere Variablen“, jeweils eine für die Schlüssel-ID und den geheimen Schlüssel. Folge den Anweisungen in den Abschnitten [Variablen und Geheimnisse](https://support.atlassian.com/bitbucket-cloud/docs/variables-and-secrets) — für den nächsten Schritt benötigst du zwei „geheime Namen“.
## Schritt 4: Generieren Sie die Pipeline-Konfiguration
Führen Sie den folgenden Befehl aus, um die Pipeline-Konfiguration zu generieren. Sie müssen das Anmeldeinformationsobjekt eingeben, das Sie im vorherigen Schritt erstellt haben:
```
sam pipeline init
```
## Schritt 5: Übernehmen Sie Ihre Pipeline-Konfiguration in das Git-Repository
Dieser Schritt ist notwendig, um sicherzustellen, dass Ihr CI/CD System Ihre Pipeline-Konfiguration kennt. Er wird ausgeführt, wenn die Änderungen übernommen wurden.
## Weitere Informationen
Ein praktisches Beispiel für die Einrichtung einer CI/CD Pipeline mit GitHub Actions finden Sie unter [CI/CD with GitHub](https://s12d.com/sam-ws-en-gh) in *The* Complete Workshop. AWS SAM
# So passen Sie Starter-Pipelines an mit AWS SAM
Als CI/CD Administrator möchten Sie möglicherweise eine Vorlage für die Starter-Pipeline und die zugehörigen geführten Eingabeaufforderungen anpassen, sodass Entwickler in Ihrer Organisation Pipeline-Konfigurationen erstellen können.
The AWS SAMCLI verwendet Cookiecutter-Vorlagen bei der Erstellung von Starter-Vorlagen. [Einzelheiten zu Ausstechvorlagen finden Sie unter Cookiecutter.](https://cookiecutter.readthedocs.io/en/latest/README.html)
Mit dem Befehl können Sie auch die Eingabeaufforderungen anpassen, die Benutzern beim Erstellen von Pipeline-Konfigurationen AWS SAMCLI angezeigt werden. `sam pipeline init` Gehen Sie wie folgt vor, um Benutzeraufforderungen anzupassen:
1. **`questions.json`Datei erstellen — Die `questions.json` Datei** muss sich im Stammverzeichnis des Projekt-Repositorys befinden. Dies ist das gleiche Verzeichnis wie die Datei. `cookiecutter.json` Das Schema für die `questions.json` Datei finden Sie unter [questions.json.schema](https://github.com/aws/aws-sam-cli/blob/2b831b29f76ac9c4e0cbcbd68b37f8f664e136d8/samcli/lib/pipeline/init/questions.json.schema). [Eine Beispieldatei finden Sie unter questions.json. `questions.json`](https://github.com/aws/aws-sam-cli-pipeline-init-templates/blob/main/Jenkins/two-stage-pipeline-template/questions.json)
1. **Zuordnen von Frageschlüsseln zu Cookiecutter-Namen** — Jedes Objekt in der `questions.json` Datei benötigt einen Schlüssel, der einem Namen in der Cookiecutter-Vorlage entspricht. Dieser Schlüsselabgleich ist die Art und Weise, wie der AWS SAMCLI Maps-Benutzer Antworten auf die Cookie-Cutter-Vorlage eingibt. Beispiele für diese Tastenkombination finden Sie im [Beispieldateien](#serverless-customizing-starter-pipelines-example-files) Abschnitt weiter unten in diesem Thema.
1. **`metadata.json`Datei erstellen — Geben** Sie die Anzahl der Stufen an, die die Pipeline in der `metadata.json` Datei enthalten soll. Die Anzahl der Stufen gibt dem `sam pipeline init` Befehl an, für wie viele Stufen Informationen angefordert werden sollen, oder, im Fall der `--bootstrap` Option, für wie viele Stufen Infrastrukturressourcen erstellt werden sollen. [Eine `metadata.json` Beispieldatei, die eine Pipeline mit zwei Stufen deklariert, finden Sie unter metadata.json.](https://github.com/aws/aws-sam-cli-pipeline-init-templates/blob/main/Jenkins/two-stage-pipeline-template/metadata.json)
## Beispielprojekte
Hier sind Beispielprojekte, die jeweils eine Cookiecutter-Vorlage, eine `questions.json` Datei und eine `metadata.json` Datei enthalten:
+ [Jenkins-Beispiel: Zweistufige Jenkins-Pipeline-Vorlage](https://github.com/aws/aws-sam-cli-pipeline-init-templates/tree/main/Jenkins/two-stage-pipeline-template)
+ CodePipeline [Beispiel: Zweistufige Pipeline-Vorlage CodePipeline ](https://github.com/aws/aws-sam-cli-pipeline-init-templates/tree/main/AWS-CodePipeline/two-stage-pipeline-template)
## Beispieldateien
Die folgenden Dateien zeigen, wie Fragen in der `questions.json` Datei mit Einträgen in der Cookiecutter-Vorlagendatei verknüpft sind. Beachten Sie, dass es sich bei diesen Beispielen um Dateifragmente und nicht um vollständige Dateien handelt. Beispiele für vollständige Dateien finden Sie im [Beispielprojekte](#serverless-customizing-starter-pipelines-example-projects) Abschnitt weiter oben in diesem Thema.
Beispiel **`questions.json`**:
```
{
"questions": [{
"key": "intro",
"question": "\nThis template configures a pipeline that deploys a serverless application to a testing and a production stage.\n",
"kind": "info"
}, {
"key": "pipeline_user_jenkins_credential_id",
"question": "What is the Jenkins credential ID (via Jenkins plugin \"aws-credentials\") for pipeline user access key?",
"isRequired": true
}, {
"key": "sam_template",
"question": "What is the template file path?",
"default": "template.yaml"
}, {
...
```
Beispiel **`cookiecutter.json`**:
```
{
"outputDir": "aws-sam-pipeline",
"pipeline_user_jenkins_credential_id": "",
"sam_template": "",
...
```
Beispiel **`Jenkinsfile`**:
```
pipeline {
agent any
environment {
PIPELINE_USER_CREDENTIAL_ID = '{{cookiecutter.pipeline_user_jenkins_credential_id}}'
SAM_TEMPLATE = '{{cookiecutter.sam_template}}'
...
```
# Automatisieren Sie die Bereitstellung Ihrer AWS SAM Anwendung
Wie Sie die Bereitstellung Ihrer AWS SAM Anwendung automatisieren, hängt vom verwendeten CI/CD System ab. AWS SAM Aus diesem Grund zeigen Ihnen die Beispiele in diesem Abschnitt, wie Sie verschiedene CI/CD Systeme konfigurieren, um die Erstellung serverloser Anwendungen in einem AWS SAM Build-Container-Image zu automatisieren. Diese Build-Container-Images erleichtern das Erstellen und Verpacken serverloser Anwendungen mithilfe von. AWS SAMCLI
Die Verfahren für Ihre bestehende CI/CD Pipeline zur Bereitstellung serverloser Anwendungen unterscheiden AWS SAM sich geringfügig, je nachdem, welches CI/CD System Sie verwenden.
Die folgenden Themen enthalten Beispiele für die Konfiguration Ihres CI/CD Systems für die Erstellung serverloser Anwendungen in einem AWS SAM Build-Container-Image:
**Topics**
+ [
# Wird AWS CodePipeline zur Bereitstellung mit verwendet AWS SAM
](deploying-using-codepipeline.md)
+ [
# Verwenden von Bitbucket-Pipelines für die Bereitstellung mit AWS SAM
](deploying-using-bitbucket.md)
+ [
# Verwenden von Jenkins für die Bereitstellung mit AWS SAM
](deploying-using-jenkins.md)
+ [
# Verwendung von GitLab CI/CD für die Bereitstellung mit AWS SAM
](deploying-using-gitlab.md)
+ [
# Verwenden von GitHub Aktionen zur Bereitstellung mit AWS SAM
](deploying-using-github.md)
# Wird AWS CodePipeline zur Bereitstellung mit verwendet AWS SAM
Um Ihre [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)Pipeline so zu konfigurieren, dass die Erstellung und Bereitstellung Ihrer AWS SAM Anwendung automatisiert wird, müssen Ihre CloudFormation Vorlage und `buildspec.yml` Datei Zeilen enthalten, die Folgendes bewirken:
1. Verweisen Sie aus den verfügbaren Images auf ein Build-Container-Image mit der erforderlichen Laufzeit. Im folgenden Beispiel wird das `public.ecr.aws/sam/build-nodejs20.x` Build-Container-Image verwendet.
1. Konfigurieren Sie die Pipeline-Stufen, um die erforderlichen AWS SAM Befehlszeilenschnittstellenbefehle (CLI) auszuführen. Im folgenden Beispiel AWS SAMCLI werden zwei Befehle ausgeführt: **sam build** und **sam deploy** (mit den erforderlichen Optionen).
In diesem Beispiel wird vorausgesetzt, dass Sie alle Funktionen und Ebenen in Ihrer AWS SAM Vorlagendatei mit deklariert haben`runtime: nodejs20.x`.
**CloudFormation Vorlagenausschnitt:**
```
CodeBuildProject:
Type: AWS::CodeBuild::Project
Properties:
Environment:
ComputeType: BUILD_GENERAL1_SMALL
Image: public.ecr.aws/sam/build-nodejs20.x
Type: LINUX_CONTAINER
...
```
**`buildspec.yml`Schnipsel:**
```
version: 0.2
phases:
build:
commands:
- sam build
- sam deploy --no-confirm-changeset --no-fail-on-empty-changeset
```
Eine Liste der verfügbaren Build-Container-Images von Amazon Elastic Container Registry (Amazon ECR) für verschiedene Laufzeiten finden Sie unter. [Bild-Repositorys für AWS SAM](serverless-image-repositories.md)
# Verwenden von Bitbucket-Pipelines für die Bereitstellung mit AWS SAM
Um deine [Bitbucket-Pipeline](https://support.atlassian.com/bitbucket-cloud/docs/get-started-with-bitbucket-pipelines/) so zu konfigurieren, dass sie den Build und die Bereitstellung deiner AWS SAM Anwendung automatisiert, muss deine `bitbucket-pipelines.yml` Datei Zeilen enthalten, die Folgendes tun:
1. Verweise auf ein Build-Container-Image mit der erforderlichen Laufzeit aus den verfügbaren Images. Im folgenden Beispiel wird das `public.ecr.aws/sam/build-nodejs20.x` Build-Container-Image verwendet.
1. Konfigurieren Sie die Pipeline-Stufen, um die erforderlichen AWS SAM Befehlszeilenschnittstellenbefehle (CLI) auszuführen. Im folgenden Beispiel AWS SAMCLI werden zwei Befehle ausgeführt: **sam build** und **sam deploy** (mit den erforderlichen Optionen).
In diesem Beispiel wird vorausgesetzt, dass Sie alle Funktionen und Ebenen in Ihrer AWS SAM Vorlagendatei mit deklariert haben`runtime: nodejs20.x`.
```
image: public.ecr.aws/sam/build-nodejs20.x
pipelines:
branches:
main: # branch name
- step:
name: Build and Package
script:
- sam build
- sam deploy --no-confirm-changeset --no-fail-on-empty-changeset
```
Eine Liste der verfügbaren Build-Container-Images von Amazon Elastic Container Registry (Amazon ECR) für verschiedene Laufzeiten finden Sie unter. [Bild-Repositorys für AWS SAM](serverless-image-repositories.md)
# Verwenden von Jenkins für die Bereitstellung mit AWS SAM
Um Ihre [Jenkins-Pipeline](https://www.jenkins.io/) so zu konfigurieren, dass sie den Build und die Bereitstellung Ihrer AWS SAM Anwendung automatisiert, `Jenkinsfile` müssen Sie Zeilen enthalten, die Folgendes tun:
1. Verweisen Sie aus den verfügbaren Images auf ein Build-Container-Image mit der erforderlichen Laufzeit. Im folgenden Beispiel wird das `public.ecr.aws/sam/build-nodejs20.x` Build-Container-Image verwendet.
1. Konfigurieren Sie die Pipeline-Stufen, um die erforderlichen AWS SAM Befehlszeilenschnittstellenbefehle (CLI) auszuführen. Im folgenden Beispiel AWS SAMCLI werden zwei Befehle ausgeführt: **sam build** und **sam deploy** (mit den erforderlichen Optionen).
In diesem Beispiel wird vorausgesetzt, dass Sie alle Funktionen und Ebenen in Ihrer AWS SAM Vorlagendatei mit deklariert haben`runtime: nodejs20.x`.
```
pipeline {
agent { docker { image 'public.ecr.aws/sam/build-nodejs20.x' } }
stages {
stage('build') {
steps {
sh 'sam build'
sh 'sam deploy --no-confirm-changeset --no-fail-on-empty-changeset'
}
}
}
}
```
Eine Liste der verfügbaren Build-Container-Images von Amazon Elastic Container Registry (Amazon ECR) für verschiedene Laufzeiten finden Sie unter. [Bild-Repositorys für AWS SAM](serverless-image-repositories.md)
# Verwendung von GitLab CI/CD für die Bereitstellung mit AWS SAM
Um Ihre [GitLab](https://about.gitlab.com)Pipeline so zu konfigurieren, dass der Build und die Bereitstellung Ihrer AWS SAM Anwendung automatisiert werden, muss Ihre `gitlab-ci.yml` Datei Zeilen enthalten, die Folgendes tun:
1. Verweisen Sie aus den verfügbaren Images auf ein Build-Container-Image mit der erforderlichen Laufzeit. Im folgenden Beispiel wird das `public.ecr.aws/sam/build-nodejs20.x` Build-Container-Image verwendet.
1. Konfigurieren Sie die Pipeline-Stufen, um die erforderlichen AWS SAM Befehlszeilenschnittstellenbefehle (CLI) auszuführen. Im folgenden Beispiel AWS SAMCLI werden zwei Befehle ausgeführt: **sam build** und **sam deploy** (mit den erforderlichen Optionen).
In diesem Beispiel wird vorausgesetzt, dass Sie alle Funktionen und Ebenen in Ihrer AWS SAM Vorlagendatei mit deklariert haben`runtime: nodejs20.x`.
```
image: public.ecr.aws/sam/build-nodejs20.x
deploy:
script:
- sam build
- sam deploy --no-confirm-changeset --no-fail-on-empty-changeset
```
Eine Liste der verfügbaren Build-Container-Images von Amazon Elastic Container Registry (Amazon ECR) für verschiedene Laufzeiten finden Sie unter. [Bild-Repositorys für AWS SAM](serverless-image-repositories.md)
# Verwenden von GitHub Aktionen zur Bereitstellung mit AWS SAM
Um Ihre [GitHub](https://github.com/)Pipeline so zu konfigurieren, dass der Build und die Bereitstellung Ihrer AWS SAM Anwendung automatisiert werden, müssen Sie zunächst die AWS SAM Befehlszeilenschnittstelle (CLI) auf Ihrem Host installieren. Sie können [GitHub Aktionen](https://github.com/features/actions) in Ihrem GitHub Workflow verwenden, um Ihnen bei dieser Einrichtung zu helfen.
Der folgende GitHub Beispiel-Workflow richtet mithilfe einer Reihe von GitHub Aktionen einen Ubuntu-Host ein und führt dann AWS SAMCLI Befehle zum Erstellen und Bereitstellen einer AWS SAM Anwendung aus:
```
on:
push:
branches:
- main
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-python@v3
- uses: aws-actions/setup-sam@v2
- uses: aws-actions/configure-aws-credentials@v1
with:
aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
aws-region: us-east-2
- run: sam build --use-container
- run: sam deploy --no-confirm-changeset --no-fail-on-empty-changeset
```
Eine Liste der verfügbaren Build-Container-Images von Amazon Elastic Container Registry (Amazon ECR) für verschiedene Laufzeiten finden Sie unter. [Bild-Repositorys für AWS SAM](serverless-image-repositories.md)
# So verwenden Sie die OIDC-Authentifizierung mit Pipelines AWS SAM
AWS Serverless Application Model (AWS SAM) unterstützt OpenID Connect (OIDC) -Benutzerauthentifizierung für Bitbucket, GitHub Actions sowie GitLab Continuous Integration und Continuous Delivery (CI/CD) platforms. With this support, you can use authorized CI/CDBenutzerkonten von jeder dieser Plattformen) zur Verwaltung deiner serverlosen Anwendungspipelines. Andernfalls müsstest du mehrere AWS Identity and Access Management (IAM-) Benutzer erstellen und verwalten, um den Zugriff auf Pipelines zu kontrollieren. AWS SAM
## Richten Sie OIDC mit Pipeline ein AWS SAM
Gehen Sie während des `sam pipeline bootstrap` Konfigurationsprozesses wie folgt vor, um OIDC mit Ihrer Pipeline einzurichten. AWS SAM
1. **Wenn Sie aufgefordert werden, einen Identitätsanbieter auszuwählen, wählen Sie OIDC aus.**
1. Wählen Sie als Nächstes einen unterstützten OIDC-Anbieter aus.
1. Geben Sie die URL des OIDC-Anbieters ein, beginnend mit. **https://**
**Anmerkung**
AWS SAM verweist bei der Generierung des `AWS::IAM::OIDCProvider` Ressourcentyps auf diese URL.
1. Folgen Sie anschließend den Anweisungen und geben Sie die CI/CD Plattforminformationen ein, die für den Zugriff auf die ausgewählte Plattform erforderlich sind. Diese Details variieren je nach Plattform und können Folgendes beinhalten:
+ OIDC-Client-ID.
+ Name des Code-Repositorys oder UUID (Universally Unique Identifier).
+ Gruppen- oder Organisationsname, der dem Repository zugeordnet ist.
+ GitHub Organisation, zu der das Code-Repository gehört.
+ GitHub Name des Repositorys.
+ Zweig, von dem aus die Bereitstellungen erfolgen.
1. AWS SAM zeigt eine Zusammenfassung der eingegebenen OIDC-Konfiguration an. Geben Sie die Nummer für eine Einstellung ein, um sie zu bearbeiten, oder drücken Sie, Enter um fortzufahren.
1. Wenn Sie aufgefordert werden, die Erstellung der Ressourcen zu bestätigen, die zur Unterstützung der eingegebenen OIDC-Verbindung erforderlich sind, drücken Sie, Y um fortzufahren.
AWS SAM generiert eine `AWS::IAM::OIDCProvider` AWS CloudFormation Ressource mit der angegebenen Konfiguration, die die Rolle der Pipeline-Ausführung übernimmt. Weitere Informationen zu diesem CloudFormation Ressourcentyp finden Sie unter [AWS: :IAM:: OIDCProvider](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-oidcprovider.html) im *AWS CloudFormation Benutzerhandbuch*.
**Anmerkung**
Wenn die Identitätsanbieter-Ressource (IdP) bereits in Ihrer vorhanden ist AWS-Konto, AWS SAM verweist Sie darauf, anstatt eine neue Ressource zu erstellen.
## Beispiel
Im Folgenden finden Sie ein Beispiel für die Einrichtung von OIDC mit Pipeline. AWS SAM
```
Select a permissions provider:
1 - IAM (default)
2 - OpenID Connect (OIDC)
Choice (1, 2): 2
Select an OIDC provider:
1 - GitHub Actions
2 - GitLab
3 - Bitbucket
Choice (1, 2, 3): 1
Enter the URL of the OIDC provider [https://token.actions.githubusercontent.com]:
Enter the OIDC client ID (sometimes called audience) [sts.amazonaws.com]:
Enter the GitHub organization that the code repository belongs to. If there is no organization enter your username instead: my-org
Enter GitHub repository name: testing
Enter the name of the branch that deployments will occur from [main]:
[3] Reference application build resources
Enter the pipeline execution role ARN if you have previously created one, or we will create one for you []:
Enter the CloudFormation execution role ARN if you have previously created one, or we will create one for you []:
Please enter the artifact bucket ARN for your Lambda function. If you do not have a bucket, we will create one for you []:
Does your application contain any IMAGE type Lambda functions? [y/N]:
[4] Summary
Below is the summary of the answers:
1 - Account: 123456
2 - Stage configuration name: dev
3 - Region: us-east-1
4 - OIDC identity provider URL: https://token.actions.githubusercontent.com
5 - OIDC client ID: sts.amazonaws.com
6 - GitHub organization: my-org
7 - GitHub repository: testing
8 - Deployment branch: main
9 - Pipeline execution role: [to be created]
10 - CloudFormation execution role: [to be created]
11 - Artifacts bucket: [to be created]
12 - ECR image repository: [skipped]
Press enter to confirm the values above, or select an item to edit the value:
This will create the following required resources for the 'dev' configuration:
- IAM OIDC Identity Provider
- Pipeline execution role
- CloudFormation execution role
- Artifact bucket
Should we proceed with the creation? [y/N]:
```
## Weitere Informationen
Weitere Informationen zur Verwendung von OIDC mit AWS SAM Pipeline finden Sie unter. [sam pipeline bootstrap](sam-cli-command-reference-sam-pipeline-bootstrap.md)
# Einführung in die Verwendung von sam sync to sync to AWS Cloud
Der AWS Serverless Application Model Befehl Command Line Interface (AWS SAMCLI) `sam sync` bietet Optionen zum schnellen Synchronisieren von lokalen Anwendungsänderungen mit dem AWS Cloud. Verwenden Sie `sam sync` ihn bei der Entwicklung Ihrer Anwendungen für:
1. Automatische Erkennung und Synchronisation lokaler Änderungen mit dem AWS Cloud.
1. Passen Sie an, welche lokalen Änderungen mit dem AWS Cloud synchronisiert werden.
1. Bereiten Sie Ihre Anwendung in der Cloud für Tests und Validierung vor.
Mit können Sie einen schnellen Entwicklungsworkflow erstellen`sam sync`, der die Zeit verkürzt, die benötigt wird, um Ihre lokalen Änderungen zum Testen und Validieren mit der Cloud zu synchronisieren.
**Anmerkung**
Der `sam sync` Befehl wird für Entwicklungsumgebungen empfohlen. Für Produktionsumgebungen empfehlen wir, eine *CI/CD-Pipeline (Continuous Integration and Delivery)* zu verwenden `sam deploy` oder zu konfigurieren. Weitere Informationen hierzu finden Sie unter [Stellen Sie Ihre Anwendung und Ressourcen bereit mit AWS SAM](serverless-deploying.md).
Der `sam sync` Befehl ist Teil von. AWS SAM Accelerate *AWS SAM Accelerate*bietet Tools, mit denen Sie das Entwickeln und Testen serverloser Anwendungen in der AWS Cloud beschleunigen können.
**Topics**
+ [
## Erkennt automatisch lokale Änderungen und synchronisiert sie mit AWS Cloud
](#using-sam-cli-sync-auto)
+ [
## Passen Sie an, welche lokalen Änderungen mit dem synchronisiert werden AWS Cloud
](#using-sam-cli-sync-customize)
+ [
## Bereiten Sie Ihre Anwendung in der Cloud für Tests und Validierung vor
](#using-sam-cli-sync-test)
+ [
## Optionen für den Befehl sam sync
](#using-sam-cli-sync-options)
+ [
## Fehlerbehebung
](#using-sam-cli-sync-troubleshooting)
+ [
## Beispiele
](#using-sam-cli-sync-examples)
+ [
## Weitere Informationen
](#using-sam-cli-sync-learn)
## Erkennt automatisch lokale Änderungen und synchronisiert sie mit AWS Cloud
Führen Sie `sam sync` mit der `--watch` Option aus, mit der Synchronisierung Ihrer Anwendung mit dem AWS Cloud zu beginnen. Dies macht Folgendes:
1. **Erstellen Sie Ihre Anwendung** — Dieser Vorgang ähnelt der Verwendung des `sam build` Befehls.
1. **Stellen Sie Ihre Anwendung** bereit — AWS SAMCLI Der stellt Ihre Anwendung AWS CloudFormation unter Verwendung Ihrer Standardeinstellungen bereit. Die folgenden Standardwerte werden verwendet:
1. AWS Anmeldeinformationen und allgemeine Konfigurationseinstellungen befinden sich in Ihrem `.aws` Benutzerordner.
1. Die Einstellungen für die Anwendungsbereitstellung finden Sie in der `samconfig.toml` Datei Ihrer Anwendung.
Wenn keine Standardwerte gefunden werden können, werden Sie darüber informiert und der Synchronisierungsvorgang AWS SAMCLI wird beendet.
1. **Achten Sie auf lokale Änderungen** — AWS SAMCLI Der läuft weiter und sucht nach lokalen Änderungen an Ihrer Anwendung. Das bietet die `--watch` Option.
Diese Option kann standardmäßig aktiviert sein. Standardwerte finden Sie in der `samconfig.toml` Datei Ihrer Anwendung. Im Folgenden sehen Sie ein Beispiel für eine -Datei:
```
...
[default.sync]
[default.sync.parameters]
watch = true
...
```
1. **Lokale Änderungen mit dem synchronisieren AWS Cloud** — Wenn Sie lokale Änderungen vornehmen, AWS SAMCLI erkennt und synchronisiert der diese Änderungen mit der AWS Cloud schnellsten verfügbaren Methode. Je nach Art der Änderung kann Folgendes passieren:
1. Wenn Ihre aktualisierte Ressource den AWS Dienst unterstützt APIs, verwendet AWS SAMCLI sie ihn, um Ihre Änderungen bereitzustellen. Dies führt zu einer schnellen Synchronisierung, um Ihre Ressource in der zu aktualisieren AWS Cloud.
1. Wenn Ihre aktualisierte Ressource den AWS Dienst nicht unterstützt APIs, AWS SAMCLI führt sie eine CloudFormation Bereitstellung durch. Dadurch wird Ihre gesamte Anwendung in der aktualisiert AWS Cloud. Es ist zwar nicht so schnell, verhindert aber, dass Sie eine Bereitstellung manuell initiieren müssen.
Da der `sam sync` Befehl Ihre Anwendung in der automatisch aktualisiert AWS Cloud, wird er nur für Entwicklungsumgebungen empfohlen. Beim Ausführen werden Sie aufgefordert`sam sync`, Folgendes zu bestätigen:
```
**The sync command should only be used against a development stack**.
Confirm that you are synchronizing a development stack.
Enter Y to proceed with the command, or enter N to cancel:
[Y/n]: ENTER
```
## Passen Sie an, welche lokalen Änderungen mit dem synchronisiert werden AWS Cloud
Stellen Sie Optionen bereit, um anzupassen, welche lokalen Änderungen mit dem AWS Cloud synchronisiert werden. Dies kann die Zeit verkürzen, die benötigt wird, um Ihre lokalen Änderungen zum Testen und Validieren in der Cloud zu sehen.
Bieten Sie beispielsweise die `--code` Option an, nur Codeänderungen wie AWS Lambda Funktionscode zu synchronisieren. Wenn Sie sich während der Entwicklung speziell auf Lambda-Code konzentrieren, werden Ihre Änderungen schnell in die Cloud übertragen, um sie zu testen und zu validieren. Im Folgenden wird ein Beispiel gezeigt:
```
$ sam sync --code --watch
```
Verwenden Sie die `--resource-id` Option, um nur Codeänderungen für eine bestimmte Lambda-Funktion oder -Layer zu synchronisieren. Im Folgenden wird ein Beispiel gezeigt:
```
$ sam sync --code --resource-id HelloWorldFunction --resource-id HelloWorldLayer
```
## Bereiten Sie Ihre Anwendung in der Cloud für Tests und Validierung vor
Der `sam sync` Befehl findet automatisch die schnellste verfügbare Methode zum Aktualisieren Ihrer Anwendung in der AWS Cloud. Dies kann Ihre Entwicklungs- und Cloud-Test-Workflows beschleunigen. Durch die Nutzung des AWS Service APIs können Sie unterstützte Ressourcen schnell entwickeln, synchronisieren und testen. Ein praktisches Beispiel finden Sie in [Modul 6 — AWS SAM Accelerate](https://s12d.com/sam-ws-en-accelerate) in *The Complete AWS SAM Workshop*.
## Optionen für den Befehl sam sync
Im Folgenden sind einige der wichtigsten Optionen aufgeführt, mit denen Sie den `sam sync` Befehl ändern können. Eine Liste aller Optionen finden Sie unter[sam sync](sam-cli-command-reference-sam-sync.md).
### Führen Sie eine einmalige CloudFormation Bereitstellung durch
Verwenden Sie die `--no-watch` Option, um die automatische Synchronisierung zu deaktivieren. Im Folgenden wird ein Beispiel gezeigt:
```
$ sam sync --no-watch
```
Der AWS SAMCLI führt eine einmalige CloudFormation Bereitstellung durch. Dieser Befehl gruppiert die Aktionen, die mit den `sam deploy` Befehlen `sam build` und ausgeführt werden.
### Überspringen Sie die erste CloudFormation Bereitstellung
Sie können anpassen, ob bei jeder Ausführung eine CloudFormation Bereitstellung erforderlich `sam sync` ist.
+ Geben Sie `--no-skip-deploy-sync` an, dass bei jeder Ausführung eine CloudFormation Bereitstellung erforderlich `sam sync` ist. Dadurch wird sichergestellt, dass Ihre lokale Infrastruktur synchronisiert ist CloudFormation, sodass Abweichungen vermieden werden. Die Verwendung dieser Option verlängert Ihren Entwicklungs- und Test-Workflow um zusätzliche Zeit.
+ Geben Sie `--skip-deploy-sync` an, dass die CloudFormation Bereitstellung optional ist. Das vergleicht AWS SAMCLI Ihre lokale AWS SAM Vorlage mit Ihrer bereitgestellten CloudFormation Vorlage und überspringt die erste CloudFormation Bereitstellung, wenn keine Änderung festgestellt wird. Wenn Sie die CloudFormation Bereitstellung überspringen, können Sie Zeit sparen, wenn Sie lokale Änderungen mit dem synchronisieren. AWS Cloud
Wenn keine Änderung festgestellt AWS SAMCLI wird, führt der in den folgenden Szenarien dennoch eine CloudFormation Bereitstellung durch:
+ Wenn seit Ihrer letzten CloudFormation Bereitstellung 7 Tage oder mehr vergangen sind.
+ Wenn eine große Anzahl von Änderungen am Lambda-Funktionscode erkannt wird, ist die CloudFormation Bereitstellung die schnellste Methode, um Ihre Anwendung zu aktualisieren.
Im Folgenden wird ein Beispiel gezeigt:
```
$ sam sync --skip-deploy-sync
```
### Synchronisieren Sie eine Ressource aus einem verschachtelten Stack
**Um eine Ressource aus einem verschachtelten Stapel zu synchronisieren**
1. Stellen Sie den Root-Stack bereit mit`--stack-name`.
1. Identifizieren Sie die Ressource im verschachtelten Stapel im folgenden Format:`nestedStackId/resourceId`.
1. Stellen Sie die Ressource im verschachtelten Stapel bereit mit. `--resource-id`
Im Folgenden wird ein Beispiel gezeigt:
```
$ sam sync --code --stack-name sam-app --resource-id myNestedStack/HelloWorldFunction
```
Weitere Informationen zum Erstellen verschachtelter Anwendungen finden Sie unter. [Verwenden Sie Code und Ressourcen mithilfe verschachtelter Anwendungen in AWS SAM](serverless-sam-template-nested-applications.md)
### Geben Sie einen bestimmten CloudFormation Stack an, der aktualisiert werden soll
Um einen bestimmten CloudFormation Stack für die Aktualisierung anzugeben, geben Sie die `--stack-name` Option an. Im Folgenden wird ein Beispiel gezeigt:
```
$ sam sync --stack-name dev-sam-app
```
### Beschleunigen Sie die Build-Zeiten, indem Sie Ihr Projekt im Quellordner erstellen
Für unterstützte Laufzeiten und Build-Methoden können Sie die `--build-in-source` Option verwenden, um Ihr Projekt direkt im Quellordner zu erstellen. Standardmäßig werden die AWS SAM CLI Builds in einem temporären Verzeichnis gespeichert, was das Kopieren von Quellcode und Projektdateien beinhaltet. Damit befinden `--build-in-source` sich die AWS SAM CLI Builds direkt in Ihrem Quellordner, was den Build-Prozess beschleunigt, 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`.
### Geben Sie Dateien und Ordner an, die keine Synchronisierung initiieren
Verwenden Sie die `--watch-exclude` Option, um eine Datei oder einen Ordner anzugeben, die bei einer Aktualisierung keine Synchronisierung initiieren. Weitere Informationen zu dieser Option finden Sie unter `--watch-exclude`.
Im Folgenden finden Sie ein Beispiel, das die mit unserer `HelloWorldFunction` Funktion verknüpfte `package-lock.json` Datei ausschließt:
```
$ sam sync --watch --watch-exclude HelloWorldFunction=package-lock.json
```
Wenn dieser Befehl ausgeführt wird, AWS SAM CLI wird der Synchronisierungsvorgang initiiert. Diese umfasst die folgenden Funktionen:
+ Führen Sie `sam build` das Programm aus, um Ihre Funktionen zu erstellen und Ihre Anwendung für die Bereitstellung vorzubereiten.
+ Führen Sie `sam deploy` den Befehl aus, um Ihre Anwendung bereitzustellen.
+ Achten Sie auf Änderungen an Ihrer Anwendung.
Wenn wir die `package-lock.json` Datei ändern, AWS SAM CLI wird keine Synchronisierung initiiert. Wenn eine andere Datei aktualisiert wird, AWS SAM CLI wird eine Synchronisierung initiiert, die die `package-lock.json` Datei einschließt.
Das Folgende ist ein Beispiel für die Angabe einer Lambda-Funktion eines untergeordneten Stacks:
```
$ sam sync --watch --watch-exclude ChildStackA/MyFunction=database.sqlite3
```
## Fehlerbehebung
Informationen zur Fehlerbehebung bei AWS SAMCLI finden Sie unter[AWS SAMCLIProblembehandlung](sam-cli-troubleshooting.md).
## Beispiele
### Verwenden von Sam Sync zum Aktualisieren der Hello World-Anwendung
In diesem Beispiel beginnen wir mit der Initialisierung der Hello World-Beispielanwendung. Weitere Informationen zu dieser Anwendung finden Sie unter[Tutorial: Stellen Sie eine Hello World-Anwendung bereit mit AWS SAM](serverless-getting-started-hello-world.md).
Mit der Ausführung `sam sync` wird der Build- und Bereitstellungsprozess gestartet.
```
$ sam sync
The SAM CLI will use the AWS Lambda, Amazon API Gateway, and AWS StepFunctions APIs to upload your code without
performing a CloudFormation deployment. This will cause drift in your CloudFormation stack.
**The sync command should only be used against a development stack**.
Confirm that you are synchronizing a development stack.
Enter Y to proceed with the command, or enter N to cancel:
[Y/n]:
Queued infra sync. Waiting for in progress code syncs to complete...
Starting infra sync.
Manifest file is changed (new hash: 3298f13049d19cffaa37ca931dd4d421) or dependency folder (.aws-sam/deps/0663e6fe-a888-4efb-b908-e2344261e9c7) is missing for (HelloWorldFunction), downloading dependencies and copying/building source
Building codeuri: /Users/.../Demo/sync/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CleanUp
Running PythonPipBuilder:ResolveDependencies
Running PythonPipBuilder:CopySource
Build Succeeded
Successfully packaged artifacts and wrote output template to file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpx_5t4u3f.
Execute the following command to deploy the packaged template
sam deploy --template-file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpx_5t4u3f --stack-name
Deploying with following values
===============================
Stack name : sam-app
Region : us-west-2
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"]
Parameter overrides : {}
Signing Profiles : null
Initiating deployment
=====================
2023-03-17 11:17:19 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 0.5 seconds)
---------------------------------------------------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
---------------------------------------------------------------------------------------------------------------------------------------------
CREATE_IN_PROGRESS AWS::CloudFormation::Stack sam-app Transformation succeeded
CREATE_IN_PROGRESS AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt -
ack
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole -
CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation Initiated
CREATE_IN_PROGRESS AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt Resource creation Initiated
ack
CREATE_COMPLETE AWS::IAM::Role HelloWorldFunctionRole -
CREATE_COMPLETE AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt -
ack
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::Lambda::Function HelloWorldFunction Resource creation Initiated
CREATE_COMPLETE AWS::Lambda::Function HelloWorldFunction -
CREATE_IN_PROGRESS AWS::ApiGateway::RestApi ServerlessRestApi -
CREATE_IN_PROGRESS AWS::ApiGateway::RestApi ServerlessRestApi Resource creation Initiated
CREATE_COMPLETE AWS::ApiGateway::RestApi ServerlessRestApi -
CREATE_IN_PROGRESS AWS::ApiGateway::Deployment ServerlessRestApiDeployment47fc2d -
5f9d
CREATE_IN_PROGRESS AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi -
ssionProd
CREATE_IN_PROGRESS AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi Resource creation Initiated
ssionProd
CREATE_IN_PROGRESS AWS::ApiGateway::Deployment ServerlessRestApiDeployment47fc2d Resource creation Initiated
5f9d
CREATE_COMPLETE AWS::ApiGateway::Deployment ServerlessRestApiDeployment47fc2d -
5f9d
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdStage -
CREATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdStage Resource creation Initiated
CREATE_COMPLETE AWS::ApiGateway::Stage ServerlessRestApiProdStage -
CREATE_COMPLETE AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi -
ssionProd
CREATE_COMPLETE AWS::CloudFormation::Stack sam-app -
---------------------------------------------------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
----------------------------------------------------------------------------------------------------------------------------------------------
Outputs
----------------------------------------------------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/sam-app-HelloWorldFunctionRole-BUFVMO2PJIYF
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://pcrx5gdaof.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:sam-app-HelloWorldFunction-2PlN6TPTQoco
----------------------------------------------------------------------------------------------------------------------------------------------
Stack creation succeeded. Sync infra completed.
Infra sync completed.
CodeTrigger not created as CodeUri or DefinitionUri is missing for ServerlessRestApi.
```
Sobald die Bereitstellung abgeschlossen ist, ändern wir den `HelloWorldFunction` Code. Der AWS SAMCLI erkennt diese Änderung und synchronisiert unsere Anwendung mit dem AWS Cloud. Da der AWS Service AWS Lambda unterstützt wird APIs, wird eine schnelle Synchronisierung durchgeführt.
```
Syncing Lambda Function HelloWorldFunction...
Manifest is not changed for (HelloWorldFunction), running incremental build
Building codeuri: /Users/.../Demo/sync/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CopySource
Finished syncing Lambda Function HelloWorldFunction.
```
Als Nächstes ändern wir unseren API-Endpunkt in der AWS SAM Vorlage der Anwendung. Wir wechseln `/hello` zu`/helloworld`.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
...
Properties:
...
Events:
HelloWorld:
Type: Api
Properties:
Path: /helloworld
Method: get
```
Da die Amazon API Gateway Gateway-Ressource die AWS Service-API nicht unterstützt, führt sie AWS SAMCLI automatisch eine CloudFormation Bereitstellung durch. Im Folgenden finden Sie ein Beispiel für eine Ausgabe:
```
Queued infra sync. Waiting for in progress code syncs to complete...
Starting infra sync.
Manifest is not changed for (HelloWorldFunction), running incremental build
Building codeuri: /Users/.../Demo/sync/sam-app/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction
Running PythonPipBuilder:CopySource
Build Succeeded
Successfully packaged artifacts and wrote output template to file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpuabo0jb9.
Execute the following command to deploy the packaged template
sam deploy --template-file /var/folders/45/5ct135bx3fn2551_ptl5g6_80000gr/T/tmpuabo0jb9 --stack-name
Deploying with following values
===============================
Stack name : sam-app
Region : us-west-2
Disable rollback : False
Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr
Capabilities : ["CAPABILITY_NAMED_IAM", "CAPABILITY_AUTO_EXPAND"]
Parameter overrides : {}
Signing Profiles : null
Initiating deployment
=====================
2023-03-17 14:41:18 - Waiting for stack create/update to complete
CloudFormation events from stack operations (refresh every 0.5 seconds)
---------------------------------------------------------------------------------------------------------------------------------------------
ResourceStatus ResourceType LogicalResourceId ResourceStatusReason
---------------------------------------------------------------------------------------------------------------------------------------------
UPDATE_IN_PROGRESS AWS::CloudFormation::Stack sam-app Transformation succeeded
UPDATE_IN_PROGRESS AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt -
ack
UPDATE_COMPLETE AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt -
ack
UPDATE_IN_PROGRESS AWS::ApiGateway::RestApi ServerlessRestApi -
UPDATE_COMPLETE AWS::ApiGateway::RestApi ServerlessRestApi -
CREATE_IN_PROGRESS AWS::ApiGateway::Deployment ServerlessRestApiDeployment8cf30e -
d3cd
UPDATE_IN_PROGRESS AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi Requested update requires the
ssionProd creation of a new physical
resource; hence creating one.
UPDATE_IN_PROGRESS AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi Resource creation Initiated
ssionProd
CREATE_IN_PROGRESS AWS::ApiGateway::Deployment ServerlessRestApiDeployment8cf30e Resource creation Initiated
d3cd
CREATE_COMPLETE AWS::ApiGateway::Deployment ServerlessRestApiDeployment8cf30e -
d3cd
UPDATE_IN_PROGRESS AWS::ApiGateway::Stage ServerlessRestApiProdStage -
UPDATE_COMPLETE AWS::ApiGateway::Stage ServerlessRestApiProdStage -
UPDATE_COMPLETE AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi -
ssionProd
UPDATE_COMPLETE_CLEANUP_IN_PROGRE AWS::CloudFormation::Stack sam-app -
SS
DELETE_IN_PROGRESS AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi -
ssionProd
DELETE_IN_PROGRESS AWS::ApiGateway::Deployment ServerlessRestApiDeployment47fc2d -
5f9d
DELETE_COMPLETE AWS::ApiGateway::Deployment ServerlessRestApiDeployment47fc2d -
5f9d
UPDATE_COMPLETE AWS::CloudFormation::Stack AwsSamAutoDependencyLayerNestedSt -
ack
DELETE_COMPLETE AWS::Lambda::Permission HelloWorldFunctionHelloWorldPermi -
ssionProd
UPDATE_COMPLETE AWS::CloudFormation::Stack sam-app -
---------------------------------------------------------------------------------------------------------------------------------------------
CloudFormation outputs from deployed stack
----------------------------------------------------------------------------------------------------------------------------------------------
Outputs
----------------------------------------------------------------------------------------------------------------------------------------------
Key HelloWorldFunctionIamRole
Description Implicit IAM Role created for Hello World function
Value arn:aws:iam::012345678910:role/sam-app-HelloWorldFunctionRole-BUFVMO2PJIYF
Key HelloWorldApi
Description API Gateway endpoint URL for Prod stage for Hello World function
Value https://pcrx5gdaof.execute-api.us-west-2.amazonaws.com/Prod/hello/
Key HelloWorldFunction
Description Hello World Lambda Function ARN
Value arn:aws:lambda:us-west-2:012345678910:function:sam-app-HelloWorldFunction-2PlN6TPTQoco
----------------------------------------------------------------------------------------------------------------------------------------------
Stack update succeeded. Sync infra completed.
Infra sync completed.
```
## Weitere Informationen
Eine Beschreibung aller `sam sync` Optionen finden Sie unter[sam sync](sam-cli-command-reference-sam-sync.md).