Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Implementa la tua applicazione e le tue risorse con AWS SAM
La distribuzione dell'applicazione fornisce e configura le AWS risorse nel AWS cloud, facendo funzionare l'applicazione nel cloud. AWS SAM utilizza [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/)come meccanismo di implementazione sottostante. AWS SAM utilizza gli elementi di compilazione creati durante l'esecuzione del **sam build** comando come input standard per la distribuzione dell'applicazione serverless.
Con AWS SAM, puoi distribuire l'applicazione serverless manualmente oppure puoi automatizzare le distribuzioni. Per automatizzare le implementazioni, si utilizzano AWS SAM pipeline con un sistema di integrazione e distribuzione continua (CI/CD) di propria scelta. La pipeline di distribuzione è una sequenza automatizzata di passaggi eseguiti per rilasciare una nuova versione dell'applicazione serverless.
Gli argomenti di questa sezione forniscono indicazioni sulle distribuzioni automatiche e manuali. Per distribuire l'applicazione manualmente, si utilizzano i comandi. AWS SAMCLI Per automatizzare le distribuzioni, consulta gli argomenti di questa sezione. Forniscono in particolare contenuti approfonditi sull'automazione delle implementazioni utilizzando pipeline e un sistema. CI/CD Ciò include la generazione di una pipeline di avvio, la configurazione dell'automazione, la risoluzione dei problemi di implementazione, l'utilizzo dell'autenticazione utente OpenID Connect (OIDC) e il caricamento di file locali al momento dell'implementazione.
**Topics**
+ [
# Introduzione alla distribuzione con AWS SAM
](using-sam-cli-deploy.md)
+ [
# Opzioni per la distribuzione dell'applicazione con AWS SAM
](deploying-options.md)
+ [
# Utilizzo CI/CD di sistemi e pipeline con cui implementare AWS SAM
](deploying-cicd-overview.md)
+ [
# Introduzione all'uso sam sync della sincronizzazione con Cloud AWS
](using-sam-cli-sync.md)
# Introduzione alla distribuzione con AWS SAM
Utilizzate il AWS Serverless Application Model comando Command Line Interface (AWS SAMCLI) `sam deploy` per distribuire l'applicazione serverless su. Cloud AWS
+ Per un'introduzione a AWS SAMCLI, vedere. [Che cos'è il? AWS SAMCLI](what-is-sam-overview.md#what-is-sam-cli)
+ Per un elenco delle opzioni di `sam deploy` comando, vedere[sam deploy](sam-cli-command-reference-sam-deploy.md).
+ Per un esempio di utilizzo `sam deploy` durante un tipico flusso di lavoro di sviluppo, vedi[Passo 3: Distribuisci la tua applicazione su Cloud AWS](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-deploy).
**Topics**
+ [
## Prerequisiti
](#using-sam-cli-deploy-prerequisites)
+ [
## Distribuzione di applicazioni utilizzando sam deploy
](#using-sam-cli-deploy-deploying)
+ [
## Best practice
](#using-sam-cli-deploy-best)
+ [
## Opzioni per sam deploy
](#using-sam-cli-deploy-options)
+ [
## Risoluzione dei problemi
](#using-sam-cli-deploy-troubleshooting)
+ [
## Esempi
](#using-sam-cli-deploy-examples)
+ [
## Ulteriori informazioni
](#using-sam-cli-deploy-learn)
## Prerequisiti
Per utilizzarlo`sam deploy`, AWS SAMCLI installate il completando quanto segue:
+ [AWS SAM prerequisiti](prerequisites.md).
+ [Installa il AWS SAMCLI](install-sam-cli.md).
Prima dell'uso`sam deploy`, si consiglia una conoscenza di base di quanto segue:
+ [Configurazione del AWS SAMCLI](using-sam-cli-configure.md).
+ [Crea la tua candidatura in AWS SAM](using-sam-cli-init.md).
+ [Introduzione alla costruzione con AWS SAM](using-sam-cli-build.md).
## Distribuzione di applicazioni utilizzando sam deploy
Quando distribuisci un'applicazione serverless per la prima volta, utilizza l'opzione. `--guided` Ti AWS SAMCLI guiderà attraverso un flusso interattivo per configurare le impostazioni di distribuzione dell'applicazione.
**Per distribuire un'applicazione utilizzando il flusso interattivo**
1. Vai alla directory principale del tuo progetto. Questa è la stessa posizione del AWS SAM modello.
```
$ cd sam-app
```
1. Esegui il comando seguente:
```
$ sam deploy --guided
```
1. Durante il flusso interattivo, AWS SAMCLI ti vengono richieste le opzioni per configurare le impostazioni di distribuzione dell'applicazione.
Le parentesi (`[ ]`) indicano i valori predefiniti. Lascia vuota la risposta per selezionare il valore predefinito. I valori predefiniti sono ottenuti dai seguenti file di configurazione:
+ `~/.aws/config`— Le impostazioni generali AWS dell'account.
+ `~/.aws/credentials`— Le credenziali AWS del tuo account.
+ `/samconfig.toml`— Il file di configurazione del tuo progetto.
Fornisci valori rispondendo alle istruzioni AWS SAMCLI. Ad esempio, è possibile immettere valori `y` per **sì**, `n` per **no** o come stringa.
AWS SAMCLIScrive le risposte nel `samconfig.toml` file del progetto. Per le distribuzioni successive, è possibile utilizzare `sam deploy` to deploy utilizzando questi valori configurati. Per riconfigurare questi valori, `sam deploy --guided` riutilizza o modifica direttamente i file di configurazione.
Di seguito è riportato un esempio di output:
```
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. Successivamente, AWS SAMCLI distribuisce l'applicazione su. Cloud AWS Durante la distribuzione, lo stato di avanzamento viene visualizzato nel prompt dei comandi. Di seguito sono riportate le fasi principali della distribuzione:
+ Per le applicazioni con AWS Lambda funzioni impacchettate come archivio di file.zip, il AWS SAMCLI pacchetto viene compresso e caricato in un bucket Amazon Simple Storage Service (Amazon S3). Se necessario, creerà un nuovo bucket AWS SAMCLI.
+ Per le applicazioni con funzioni Lambda, il pacchetto viene caricato come immagine contenitore, AWS SAMCLI carica l'immagine su Amazon Elastic Container Registry (Amazon ECR) Elastic Container Registry (Amazon ECR). Se necessario, AWS SAMCLI creeranno un nuovo repository.
+ AWS SAMCLICrea un set di AWS CloudFormation modifiche e distribuisce l'applicazione CloudFormation come stack.
+ AWS SAMCLImodifica il AWS SAM modello distribuito con il nuovo `CodeUri` valore per le funzioni Lambda.
Di seguito è riportato un esempio dell'output di distribuzione: AWS SAMCLI
```
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. Per visualizzare l'applicazione distribuita, procedi come segue:
1. Apri la CloudFormation console direttamente con l'URL [https://console.aws.amazon.com/cloudformazione.](https://console.aws.amazon.com/cloudformation/)
1. **Seleziona Stacks.**
1. Identifica lo stack in base al nome dell'applicazione e selezionalo.
### Verifica le modifiche prima della distribuzione
È possibile configurare il file AWS SAMCLI per visualizzare il set di CloudFormation modifiche e chiedere conferma prima della distribuzione.
**Per confermare le modifiche prima della distribuzione**
1. Durante`sam deploy --guided`, inserisci **Y** per confermare le modifiche prima della distribuzione.
```
#Shows you resources changes to be deployed and require a 'Y' to initiate deploy
Confirm changes before deploy [Y/n]: Y
```
In alternativa, puoi modificare il tuo `samconfig.toml` file con quanto segue:
```
[default.deploy]
[default.deploy.parameters]
confirm_changeset = true
```
1. Durante la distribuzione, ti AWS SAMCLI chiederà di confermare le modifiche prima della distribuzione. Di seguito è riportato un esempio:
```
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
```
### Specificare parametri aggiuntivi durante la distribuzione
È possibile specificare valori di parametro aggiuntivi da configurare durante la distribuzione. È possibile farlo modificando il AWS SAM modello e configurando il valore del parametro durante la distribuzione.
**Per specificare parametri aggiuntivi**
1. Modifica la `Parameters` sezione del AWS SAM modello. Di seguito è riportato un esempio:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Globals:
...
Parameters:
DomainName:
Type: String
Default: example
Description: Domain name
```
1. Esegui `sam deploy --guided`. Di seguito è riportato un esempio di output:
```
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
```
### Configura la firma del codice per le tue funzioni Lambda
Puoi configurare la firma del codice per le tue funzioni Lambda al momento dell'implementazione. Puoi farlo modificando il AWS SAM modello e configurando la firma del codice durante la distribuzione.
**Per configurare la firma del codice**
1. `CodeSigningConfigArn`Specificalo nel tuo AWS SAM modello. Di seguito è riportato un esempio:
```
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. Esegui `sam deploy --guided`. Ti AWS SAMCLI chiederà di configurare la firma del codice. Di seguito è riportato un esempio di output:
```
#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 practice
+ Quando si utilizza`sam deploy`, AWS SAMCLI distribuisce gli artefatti di compilazione dell'applicazione che si trovano nella directory. `.aws-sam` Quando apporti modifiche ai file originali dell'applicazione, esegui `sam build` per aggiornare la `.aws-sam` directory prima della distribuzione.
+ Quando distribuisci un'applicazione per la prima volta, utilizzala per configurare `sam deploy --guided` le impostazioni di distribuzione. Per le distribuzioni successive, puoi utilizzarlo per eseguire la distribuzione con `sam deploy` le impostazioni configurate.
## Opzioni per sam deploy
Di seguito sono riportate le opzioni comunemente utilizzate per`sam deploy`. Per un elenco di tutte le opzioni, vedere[sam deploy](sam-cli-command-reference-sam-deploy.md).
### Usa il flusso interattivo guidato per distribuire la tua applicazione
Utilizza l'`--guided`opzione per configurare le impostazioni di distribuzione dell'applicazione tramite un flusso interattivo. Di seguito è riportato un esempio:
```
$ sam deploy --guided
```
Le impostazioni di distribuzione dell'applicazione vengono salvate nel `samconfig.toml` file del progetto. Per ulteriori informazioni, consulta [Configura le impostazioni del progetto](using-sam-cli-configure.md#using-sam-cli-configure-project).
## Risoluzione dei problemi
Per risolvere il problema AWS SAMCLI, consulta. [AWS SAMCLIrisoluzione dei problemi](sam-cli-troubleshooting.md)
## Esempi
### Implementa un'applicazione Hello World che contiene una funzione Lambda impacchettata come archivio di file.zip
Per un esempio, vedi [Passo 3: Distribuisci la tua applicazione su Cloud AWS](serverless-getting-started-hello-world.md#serverless-getting-started-hello-world-deploy) il tutorial dell'applicazione Hello World.
### Implementa un'applicazione Hello World che contiene una funzione Lambda impacchettata come immagine contenitore
Innanzitutto, creiamo la nostra applicazione `sam init` Hello World. Durante il flusso interattivo, scegliamo il `Python3.9` runtime e il tipo di `Image` pacchetto.
```
$ 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
...
```
Successivamente, andiamo `cd` alla directory principale del nostro progetto ed eseguiamo`sam build`. AWS SAMCLICostruisce la nostra funzione Lambda localmente utilizzando. Docker
```
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
```
Successivamente, `sam deploy --guided` eseguiamo la distribuzione della nostra applicazione. Ci AWS SAMCLI guida nella configurazione delle nostre impostazioni di distribuzione. Quindi, AWS SAMCLI distribuisce la nostra applicazione su. Cloud AWS
```
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
```
## Ulteriori informazioni
Per ulteriori informazioni sull'utilizzo del AWS SAMCLI `sam deploy` comando, consulta quanto segue:
+ **[Il AWS SAM seminario completo: Modulo 3 - Distribuzione manuale](https://s12d.com/sam-ws-en-manual-deploy)**: scopri come creare, impacchettare e distribuire un'applicazione serverless utilizzando. AWS SAMCLI
# Opzioni per la distribuzione dell'applicazione con AWS SAM
Con AWS SAM, puoi distribuire l'applicazione manualmente e automatizzare le distribuzioni. Usa il per distribuire manualmente AWS SAMCLI la tua applicazione. Per automatizzare l'implementazione, utilizzate le pipeline e un sistema di integrazione e distribuzione continua (CI/CD). Gli argomenti di questa sezione forniscono informazioni su entrambi gli approcci.
**Topics**
+ [
## Come utilizzare il comando AWS SAMCLI per la distribuzione manuale
](#serverless-sam-cli-using-package-and-deploy)
+ [
## Implementa con CI/CD sistemi e pipeline
](#serverless-deploying-ci-cd)
+ [
## Implementazioni graduali
](#serverless-deploying-gradual)
+ [
## Risoluzione dei problemi di distribuzione utilizzando il AWS SAMCLI
](#serverless-deploying-troubleshooting)
+ [
## Ulteriori informazioni
](#serverless-sam-cli-using-invoke-learn)
## Come utilizzare il comando AWS SAMCLI per la distribuzione manuale
Dopo aver sviluppato e testato l'applicazione serverless a livello locale, è possibile distribuire l'applicazione utilizzando il comando. **[sam deploy](sam-cli-command-reference-sam-deploy.md)**
Per AWS SAM guidarvi nella distribuzione con istruzioni, specificate il flag. **--guided** Quando specifichi questo flag, il **sam deploy** comando comprime gli elementi dell'applicazione, li carica su Amazon Simple Storage Service (Amazon S3) (per gli archivi di file.zip) o su Amazon Elastic Container Registry (Amazon ECR) (per le immagini dei contenitori). Il comando distribuisce quindi l'applicazione nel cloud. AWS
**Esempio**:
```
# Deploy an application using prompts:
sam deploy --guided
```
## Implementa con CI/CD sistemi e pipeline
AWS SAM ti aiuta ad automatizzare l'implementazione utilizzando pipeline e un sistema di integrazione e distribuzione continua (CI/CD). AWS SAM può essere utilizzato per creare pipeline e CI/CD semplificare le attività per le applicazioni serverless. Più CI/CD sistemi supportano la AWS SAM creazione di immagini di container e forniscono AWS SAM anche una serie di modelli di pipeline predefiniti per più CI/CD sistemi che racchiudono AWS le migliori pratiche di implementazione.
Per ulteriori informazioni, consulta [Utilizzo CI/CD di sistemi e pipeline con cui implementare AWS SAM](deploying-cicd-overview.md).
## Implementazioni graduali
Se si desidera distribuire l' AWS SAM applicazione gradualmente anziché tutto in una volta, è possibile specificare le configurazioni di distribuzione appropriate. AWS CodeDeploy *Per ulteriori informazioni, consulta [Lavorare con le configurazioni di distribuzione CodeDeploy nella Guida](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-configurations.html) per l'AWS CodeDeploy utente.*
Per informazioni sulla configurazione AWS SAM dell'applicazione per una distribuzione graduale, consulta. [Implementazione graduale di applicazioni serverless con AWS SAM](automating-updates-to-serverless-apps.md)
## Risoluzione dei problemi di distribuzione utilizzando il AWS SAMCLI
### AWS SAMCLIerrore: «Vincoli di sicurezza non soddisfatti»
Durante l'esecuzione**sam deploy --guided**, ti viene posta la domanda. `HelloWorldFunction may not have authorization defined, Is this okay? [y/N]` Se rispondi a questa richiesta con **N** (la risposta predefinita), viene visualizzato il seguente errore:
```
Error: Security Constraints Not Satisfied
```
Il messaggio ti informa che l'applicazione che stai per distribuire potrebbe avere un'API Amazon API Gateway configurata senza autorizzazione. Rispondendo **N** a questa richiesta, stai dicendo che non va bene.
Per risolvere questo problema, sono disponibili le seguenti opzioni:
+ Configura la tua applicazione con autorizzazione. Per informazioni sulla configurazione dell'autorizzazione, vedere[Controlla l'accesso alle API con il tuo AWS SAM modello](serverless-controlling-access-to-apis.md).
+ Rispondi a questa domanda indicando che sei d'accordo con la distribuzione di un'applicazione con un'API API Gateway configurata senza autorizzazione. **Y**
## Ulteriori informazioni
*Per esempi pratici di implementazione di applicazioni serverless, consulta quanto segue tratto da The Complete Workshop: AWS SAM *
+ [Modulo 3 - Distribuzione manuale](https://s12d.com/sam-ws-en-manual-deploy): scopri come creare, impacchettare e distribuire un'applicazione serverless utilizzando il. AWS SAMCLI
+ [Modulo 4 - CI/CD](https://s12d.com/sam-ws-en-cicd-deploy): scopri come automatizzare le fasi di creazione, pacchetto e distribuzione creando una pipeline di *integrazione e distribuzione continue* (CI/CD).
# Utilizzo CI/CD di sistemi e pipeline con cui implementare AWS SAM
AWS SAM aiuta le organizzazioni a creare pipeline per i propri CI/CD sistemi preferiti, in modo che possano trarne i vantaggi CI/CD con il minimo sforzo, ad esempio accelerando la frequenza di implementazione, accorciando i tempi di esecuzione delle modifiche e riducendo gli errori di implementazione.
AWS SAM semplifica le CI/CD attività per le applicazioni serverless con l'aiuto della creazione di immagini di container. Le immagini AWS SAM fornite includono gli AWS SAMCLI strumenti di compilazione per una serie di runtime supportati AWS Lambda . Ciò semplifica la creazione e il pacchetto di applicazioni serverless utilizzando. AWS SAMCLI Queste immagini riducono inoltre la necessità per i team di creare e gestire le proprie immagini per CI/CD i sistemi. Per ulteriori informazioni sulla AWS SAM creazione di immagini dei container, consulta[Archivi di immagini per AWS SAM](serverless-image-repositories.md).
Più CI/CD sistemi supportano la AWS SAM creazione di immagini dei container. CI/CD Il sistema da utilizzare dipende da diversi fattori. Questi includono se l'applicazione utilizza un singolo runtime o più runtime o se si desidera creare l'applicazione all'interno di un'immagine del contenitore o direttamente su una macchina host, una macchina virtuale (VM) o un host bare metal.
AWS SAM fornisce inoltre una serie di modelli di pipeline predefiniti per più CI/CD sistemi che AWS incapsulano le migliori pratiche di implementazione. Questi modelli di pipeline predefiniti utilizzano formati di configurazione delle JSON/YAML pipeline standard e le best practice integrate aiutano a eseguire distribuzioni con più account e più regioni e a verificare che le pipeline non possano apportare modifiche involontarie all'infrastruttura.
Sono disponibili due opzioni principali AWS SAM da utilizzare per distribuire le applicazioni serverless: 1) modificare la configurazione della pipeline esistente per utilizzare AWS SAMCLI i comandi o 2) generare una configurazione di pipeline di esempio CI/CD da utilizzare come punto di partenza per la propria applicazione.
**Topics**
+ [
## Cos'è una pipeline?
](#deploying-whatis-pipeline)
+ [
# Come AWS SAM vengono caricati i file locali al momento della distribuzione
](deploy-upload-local-files.md)
+ [
# Genera una CI/CD pipeline iniziale con AWS SAM
](serverless-generating-example-ci-cd.md)
+ [
# Come personalizzare le pipeline di avviamento con AWS SAM
](serverless-customizing-starter-pipelines.md)
+ [
# Automatizza l'implementazione della tua AWS SAM applicazione
](serverless-deploying-modify-pipeline.md)
+ [
# Come utilizzare l'autenticazione OIDC con le pipeline AWS SAM
](deploying-with-oidc.md)
## Cos'è una pipeline?
Una pipeline è una sequenza automatizzata di passaggi eseguiti per rilasciare una nuova versione di un'applicazione. [Con AWS SAM, puoi utilizzare molti CI/CD sistemi comuni per distribuire le tue applicazioni, tra cui [Jenkins [AWS CodePipeline](https://aws.amazon.com/codepipeline)](https://www.jenkins.io/), [GitLab CI/CD](https://docs.gitlab.com/ee/ci/) e Actions. GitHub](https://github.com/features/actions)
I modelli di pipeline includono le migliori pratiche AWS di implementazione per facilitare le distribuzioni con più account e più regioni. AWS ambienti come sviluppo e produzione in genere esistono in account diversi. AWS Ciò consente ai team di sviluppo di configurare pipeline di implementazione sicure, senza apportare modifiche involontarie all'infrastruttura.
Puoi anche fornire modelli di pipeline personalizzati per aiutare a standardizzare le pipeline tra i team di sviluppo.
# Come AWS SAM vengono caricati i file locali al momento della distribuzione
Quando si distribuisce l'applicazione su Cloud AWS, è AWS CloudFormation necessario che i file locali vengano prima caricati su un AWS servizio accessibile, come Amazon Simple Storage Service (Amazon S3) Simple Storage Service (Amazon S3). Ciò include i file locali a cui fa riferimento il AWS SAM modello. Per soddisfare questo requisito, AWS SAMCLI esegue le seguenti operazioni quando si utilizza il `sam package` comando `sam deploy` or:
1. Carica automaticamente i file locali su un AWS servizio accessibile.
1. Aggiorna automaticamente il modello dell'applicazione in modo che faccia riferimento al nuovo percorso del file.
**Topics**
+ [
## Demo: usa il codice della funzione AWS SAMCLI Lambda per caricare il codice della funzione Lambda
](#deploy-upload-local-files-demo)
+ [
## Casi di utilizzo supportati
](#deploy-upload-local-files-use)
+ [
## Ulteriori informazioni
](#deploy-upload-local-files-learn)
## Demo: usa il codice della funzione AWS SAMCLI Lambda per caricare il codice della funzione Lambda
In questa demo, inizializziamo l'applicazione Hello World di esempio utilizzando un tipo di pacchetto.zip per la nostra funzione Lambda. Utilizziamo il AWS SAMCLI per caricare automaticamente il nostro codice della funzione Lambda su Amazon S3 e fare riferimento al suo nuovo percorso nel nostro modello di applicazione.
Innanzitutto, `sam init` eseguiamo l'inizializzazione della nostra applicazione Hello World.
```
$ 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
...
```
Il nostro codice di funzione Lambda è organizzato nella `hello_world` sottodirectory del nostro progetto.
```
demo
├── README.md
├── hello_world
│ ├── __init__.py
│ ├── app.py
│ └── requirements.txt
├── template.yaml
└── tests
```
All'interno AWS SAM del nostro modello, facciamo riferimento al percorso locale del nostro codice di funzione Lambda utilizzando la `CodeUri` proprietà.
```
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
...
```
Successivamente, `sam build` eseguiamo la creazione della nostra applicazione e ci prepariamo per la distribuzione.
```
$ 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
...
```
Successivamente, corriamo `sam deploy --guided` per distribuire la nostra applicazione.
```
$ 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
```
Durante la distribuzione, carica AWS SAMCLI automaticamente il nostro codice della funzione Lambda su Amazon S3 e aggiorna il nostro modello. Il nostro modello modificato nella CloudFormation console riflette il percorso del bucket Amazon S3.
```
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
...
```
## Casi di utilizzo supportati
AWS SAMCLIPossono facilitare automaticamente questo processo per diversi tipi di file, tipi di CloudFormation risorse e CloudFormation macro.
### Tipi di file
I file e Docker le immagini delle applicazioni sono supportati.
### CloudFormation tipi di risorse
Di seguito è riportato un elenco dei tipi di risorse supportati e delle relative proprietà:
| Risorsa | Properties |
| --- | --- |
| 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 macro
I file a cui si fa riferimento utilizzando la macro di `AWS::Include` trasformazione sono supportati.
## Ulteriori informazioni
Per ulteriori informazioni sulla `AWS::Include` trasformazione, consulta la sezione [ AWS::Include Transform](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html) nella *Guida AWS CloudFormation per l'utente*.
Per vedere un esempio di utilizzo della `AWS::Include` trasformazione in un AWS SAM modello, consulta il pattern [API Gateway HTTP API to SQS](https://serverlessland.com/patterns/apigw-sqs) su *Serverless Land*.
# Genera una CI/CD pipeline iniziale con AWS SAM
Quando sei pronto per automatizzare l'implementazione, puoi utilizzare uno dei modelli di pipeline AWS SAM di avvio disponibili per generare una pipeline di distribuzione per il CI/CD sistema che scegli di utilizzare. La pipeline di distribuzione è ciò che configuri e utilizzi per automatizzare la distribuzione della tua applicazione serverless. Un modello di pipeline iniziale è preconfigurato per aiutarti a configurare rapidamente la pipeline di distribuzione per la tua applicazione serverless.
Con un modello di pipeline iniziale, puoi generare pipeline in pochi minuti utilizzando il comando. [sam pipeline init](sam-cli-command-reference-sam-pipeline-init.md)
I modelli di pipeline starter utilizzano la JSON/YAML sintassi familiare del CI/CD sistema e incorporano best practice come la gestione degli artefatti su più account e aree e l'utilizzo della quantità minima di autorizzazioni richieste per distribuire l'applicazione. [https://github.com/features/actions](https://github.com/features/actions)
Ecco le attività di alto livello da eseguire per generare una configurazione di pipeline iniziale:
1. **Crea risorse infrastrutturali**: la tua pipeline richiede determinate AWS risorse, ad esempio l'utente e i ruoli IAM con le autorizzazioni necessarie, un bucket Amazon S3 e, facoltativamente, un repository Amazon ECR.
1. **Connetti il tuo repository Git al tuo CI/CD sistema**: il tuo CI/CD sistema deve sapere quale repository Git attiverà l'esecuzione della pipeline. Nota che questo passaggio potrebbe non essere necessario, a seconda della combinazione di repository Git e CI/CD sistema che stai utilizzando.
1. **Genera la configurazione della pipeline**: questo passaggio genera una configurazione iniziale della pipeline che include due fasi di distribuzione.
1. Esegui **il commit della configurazione della pipeline nel tuo repository Git**: questo passaggio è necessario per garantire che il CI/CD sistema sia a conoscenza della configurazione della pipeline e verrà eseguito quando verranno eseguite le modifiche.
Dopo aver generato la configurazione della pipeline di partenza e averla salvata nel tuo repository Git, ogni volta che qualcuno esegue una modifica al codice in quel repository, la pipeline verrà attivata per essere eseguita automaticamente.
L'ordine di questi passaggi e i dettagli di ogni passaggio variano in base al sistema CI/CD in uso:
+ Se si utilizza AWS CodePipeline, vedere. [Generazione di una pipeline di avviamento per AWS CodePipeline AWS SAM](serverless-generating-example-ci-cd-codepipeline.md)
+ Se utilizzi Jenkins, GitLab CI/CD, GitHub Actions o Bitbucket Pipelines, vedi. [AWS SAM Da utilizzare per generare pipeline di avvio per Jenkins, GitLab CI/CD, Actions, Bitbucket Pipelines GitHub](serverless-generating-example-ci-cd-others.md)
# Generazione di una pipeline di avviamento per AWS CodePipeline AWS SAM
Per generare una configurazione di pipeline di avviamento per AWS CodePipeline, eseguite le seguenti attività in questo ordine:
1. Creare risorse infrastrutturali
1. Genera la configurazione della pipeline
1. Esegui il commit della configurazione della pipeline su Git
1. Connect il tuo repository Git con il tuo sistema CI/CD
**Nota**
La procedura seguente utilizza due AWS SAMCLI comandi, `sam pipeline bootstrap` e. `sam pipeline init` Il motivo per cui esistono due comandi è quello di gestire il caso d'uso in cui gli amministratori (ovvero gli utenti che necessitano dell'autorizzazione per configurare le AWS risorse dell'infrastruttura come gli utenti e i ruoli IAM) dispongono di maggiori autorizzazioni rispetto agli sviluppatori (ovvero gli utenti che necessitano solo dell'autorizzazione per configurare le singole pipeline, ma non le risorse di infrastruttura AWS richieste).
## Fase 1: Creare risorse infrastrutturali
Le pipeline che utilizzano AWS SAM richiedono determinate AWS risorse, come un utente IAM e ruoli con le autorizzazioni necessarie, un bucket Amazon S3 e, facoltativamente, un repository Amazon ECR. È necessario disporre di un set di risorse infrastrutturali per ogni fase di implementazione della pipeline.
È possibile eseguire il comando seguente per facilitare questa configurazione:
```
sam pipeline bootstrap
```
**Nota**
Esegui il comando precedente per ogni fase di distribuzione della pipeline.
## Fase 2: Generare la configurazione della pipeline
Per generare la configurazione della pipeline, esegui il comando seguente:
```
sam pipeline init
```
## Passaggio 3: Esegui il commit della configurazione della pipeline nell'archivio Git
Questo passaggio è necessario per garantire che il CI/CD sistema sia a conoscenza della configurazione della pipeline e venga eseguito quando vengono apportate le modifiche.
## Passaggio 4: Connect il repository Git al sistema CI/CD
Perché ora AWS CodePipeline puoi creare la connessione eseguendo il seguente comando:
```
sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --region
```
Se utilizzi GitHub o Bitbucket, dopo aver eseguito il **sam deploy** comando in precedenza, completa la connessione seguendo la procedura riportata in **Per completare una connessione disponibile nell'argomento Aggiornare una connessione** [in sospeso](https://docs.aws.amazon.com/dtconsole/latest/userguide/connections-update.html) nella guida per l'utente della *console Developer Tools*. Inoltre, memorizza una copia del file `CodeStarConnectionArn` dall'output del **sam deploy** comando, poiché ti servirà se desideri utilizzarlo AWS CodePipeline con un altro ramo di. `main`
## Configurazione di altre filiali
Per impostazione predefinita, AWS CodePipeline utilizza il `main` ramo con AWS SAM. Se si desidera utilizzare un ramo diverso da`main`, è necessario eseguire nuovamente il **sam deploy** comando. Nota che, a seconda del repository Git che stai utilizzando, potresti dover fornire anche: `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="
```
## Ulteriori informazioni
*Per un esempio pratico di configurazione di una CI/CD pipeline, vedi [CI/CD](https://catalog.workshops.aws/complete-aws-sam/en-US/module-4-cicd) with in The Complete Workshop. AWS CodePipeline AWS SAM *
# AWS SAM Da utilizzare per generare pipeline di avvio per Jenkins, GitLab CI/CD, Actions, Bitbucket Pipelines GitHub
Per generare una configurazione di pipeline iniziale per Jenkins, GitLab CI/CD, Actions o Bitbucket Pipelines, esegui le seguenti attività in questo ordine GitHub :
1. Crea risorse infrastrutturali
1. Connect il tuo repository Git con il tuo sistema CI/CD
1. Crea oggetti credenziali
1. Genera la configurazione della pipeline
1. Esegui il commit della configurazione della pipeline nel repository Git
**Nota**
La procedura seguente utilizza due AWS SAMCLI comandi, e. `sam pipeline bootstrap` `sam pipeline init` Il motivo per cui esistono due comandi è quello di gestire il caso d'uso in cui gli amministratori (ovvero gli utenti che necessitano dell'autorizzazione per configurare le AWS risorse dell'infrastruttura come gli utenti e i ruoli IAM) dispongono di maggiori autorizzazioni rispetto agli sviluppatori (ovvero gli utenti che necessitano solo dell'autorizzazione per configurare le singole pipeline, ma non le risorse di infrastruttura AWS richieste).
## Fase 1: Creare risorse infrastrutturali
Le pipeline che utilizzano AWS SAM richiedono determinate AWS risorse, come un utente IAM e ruoli con le autorizzazioni necessarie, un bucket Amazon S3 e, facoltativamente, un repository Amazon ECR. È necessario disporre di un set di risorse infrastrutturali per ogni fase di implementazione della pipeline.
È possibile eseguire il comando seguente per facilitare questa configurazione:
```
sam pipeline bootstrap
```
**Nota**
Esegui il comando precedente per ogni fase di distribuzione della pipeline.
È necessario acquisire le AWS credenziali (ID chiave e chiave segreta) per gli utenti della pipeline per ogni fase di distribuzione della pipeline, poiché sono necessarie per i passaggi successivi.
## Passaggio 2: Connect il repository Git al sistema CI/CD
La connessione del repository Git al CI/CD sistema è necessaria in modo che il CI/CD sistema possa accedere al codice sorgente dell'applicazione per le build e le distribuzioni.
**Nota**
Puoi saltare questo passaggio se utilizzi una delle seguenti combinazioni, poiché la connessione viene eseguita automaticamente:
GitHub Azioni con repository GitHub
GitLab CI/CD con repository GitLab
Bitbucket Pipelines con un repository Bitbucket
Per connettere il tuo repository Git al tuo CI/CD sistema, esegui una delle seguenti operazioni:
+ Se usi Jenkins, consulta la [documentazione di Jenkins](https://www.jenkins.io/doc/book/pipeline/multibranch/) per «Aggiungere una sorgente filiale».
+ Se utilizzi GitLab CI/CD e un repository Git diverso da quello GitLab, consulta la [GitLabdocumentazione](https://docs.gitlab.com/ee/ci/ci_cd_for_external_repos/) per «connettere un repository esterno».
## Fase 3: Creare oggetti di credenziali
Ogni CI/CD sistema ha il proprio modo di gestire le credenziali necessarie al CI/CD sistema per accedere al tuo repository Git.
Per creare gli oggetti di credenziali necessari, esegui una delle seguenti operazioni:
+ Se utilizzi Jenkins, crea un'unica «credenziale» che memorizzi sia l'ID della chiave che la chiave segreta. **Segui le istruzioni nel AWS SAM blog [Building a Jenkins Pipeline with](https://aws.amazon.com/blogs/compute/building-a-jenkins-pipeline-with-aws-sam/), nella sezione Configure Jenkins.** Avrai bisogno del «Credential ID» per il passaggio successivo.
+ Se utilizzi GitLab CI/CD, crea due «variabili protette», una per ogni ID chiave e chiave segreta. Segui le istruzioni nella [GitLab documentazione](https://docs.gitlab.com/ee/ci/variables/): per il passaggio successivo avrai bisogno di due «chiavi variabili».
+ Se utilizzi GitHub Actions, crea due «segreti crittografati», uno per ciascuna chiave e chiave segreta. Segui le istruzioni nella [GitHubdocumentazione](https://docs.github.com/en/actions/reference/encrypted-secrets): per il passaggio successivo ti serviranno due «nomi segreti».
+ Se utilizzi Bitbucket Pipelines, crea due «variabili sicure», una per ogni ID chiave e chiave segreta. Segui le istruzioni in [Variabili e segreti](https://support.atlassian.com/bitbucket-cloud/docs/variables-and-secrets): per il passaggio successivo ti serviranno due «nomi segreti».
## Fase 4: Generazione della configurazione della pipeline
Per generare la configurazione della pipeline, esegui il comando seguente. Dovrai inserire l'oggetto credenziale che hai creato nel passaggio precedente:
```
sam pipeline init
```
## Passaggio 5: Esegui il commit della configurazione della pipeline nell'archivio Git
Questo passaggio è necessario per garantire che il CI/CD sistema sia a conoscenza della configurazione della pipeline e venga eseguito una volta apportate le modifiche.
## Ulteriori informazioni
*Per un esempio pratico di configurazione di una CI/CD pipeline utilizzandoGitHub Actions, vedi [CI/CD with GitHub](https://s12d.com/sam-ws-en-gh) in The Complete Workshop. AWS SAM *
# Come personalizzare le pipeline di avviamento con AWS SAM
In qualità di CI/CD amministratore, potresti voler personalizzare un modello di pipeline iniziale e i relativi prompt guidati, che gli sviluppatori della tua organizzazione possono utilizzare per creare configurazioni di pipeline.
AWS SAMCLIUtilizza i modelli Cookiecutter per la creazione di modelli iniziali. [Per dettagli sui modelli di stampini per biscotti, Cookiecutter.](https://cookiecutter.readthedocs.io/en/latest/README.html)
È inoltre possibile personalizzare i prompt che AWS SAMCLI vengono visualizzati agli utenti durante la creazione di configurazioni di pipeline utilizzando il comando. `sam pipeline init` Per personalizzare i prompt degli utenti, effettuate le seguenti operazioni:
1. **Crea un `questions.json` file**: il `questions.json` file deve trovarsi nella radice del repository del progetto. Questa è la stessa directory del file. `cookiecutter.json` Per visualizzare lo schema del `questions.json` file, consulta [questions.json.schema](https://github.com/aws/aws-sam-cli/blob/2b831b29f76ac9c4e0cbcbd68b37f8f664e136d8/samcli/lib/pipeline/init/questions.json.schema). [Per visualizzare un file di esempio`questions.json`, vedi questions.json.](https://github.com/aws/aws-sam-cli-pipeline-init-templates/blob/main/Jenkins/two-stage-pipeline-template/questions.json)
1. **Mappa le chiavi delle domande con i nomi cookiecutter**: ogni oggetto nel `questions.json` file necessita di una chiave che corrisponda a un nome nel modello cookiecutter. Questa corrispondenza di tasti consente di mappare le risposte richieste dall'utente AWS SAMCLI al modello di cookie cutter. Per vedere esempi di questa corrispondenza di tasti, consultate la [File di esempio](#serverless-customizing-starter-pipelines-example-files) sezione più avanti in questo argomento.
1. **Crea un `metadata.json` file**: dichiara il numero di fasi che la pipeline avrà nel `metadata.json` file. Il numero di fasi indica al `sam pipeline init` comando per quante fasi richiedere informazioni o, nel caso dell'`--bootstrap`opzione, per quante fasi creare risorse di infrastruttura. [Per visualizzare un `metadata.json` file di esempio che dichiara una pipeline con due fasi, vedete metadata.json.](https://github.com/aws/aws-sam-cli-pipeline-init-templates/blob/main/Jenkins/two-stage-pipeline-template/metadata.json)
## Progetti di esempio
Ecco alcuni progetti di esempio, ciascuno dei quali include un modello Cookiecutter, un `questions.json` file e un file: `metadata.json`
+ [Esempio Jenkins: modello di pipeline Jenkins a due fasi](https://github.com/aws/aws-sam-cli-pipeline-init-templates/tree/main/Jenkins/two-stage-pipeline-template)
+ CodePipeline [esempio: modello di pipeline a due fasi CodePipeline ](https://github.com/aws/aws-sam-cli-pipeline-init-templates/tree/main/AWS-CodePipeline/two-stage-pipeline-template)
## File di esempio
Il seguente set di file mostra come le domande nel `questions.json` file sono associate alle voci nel file modello Cookiecutter. Nota che questi esempi sono frammenti di file, non file completi. Per vedere esempi di file completi, consultate la [Progetti di esempio](#serverless-customizing-starter-pipelines-example-projects) sezione precedente di questo argomento.
Esempio **`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"
}, {
...
```
Esempio **`cookiecutter.json`**:
```
{
"outputDir": "aws-sam-pipeline",
"pipeline_user_jenkins_credential_id": "",
"sam_template": "",
...
```
Esempio **`Jenkinsfile`**:
```
pipeline {
agent any
environment {
PIPELINE_USER_CREDENTIAL_ID = '{{cookiecutter.pipeline_user_jenkins_credential_id}}'
SAM_TEMPLATE = '{{cookiecutter.sam_template}}'
...
```
# Automatizza l'implementazione della tua AWS SAM applicazione
Inoltre AWS SAM, il modo in cui automatizzi la distribuzione dell' AWS SAM applicazione varia a seconda del CI/CD sistema che stai utilizzando. Per questo motivo, gli esempi in questa sezione mostrano come configurare vari CI/CD sistemi per automatizzare la creazione di applicazioni serverless in un'immagine del contenitore di AWS SAM compilazione. Queste immagini dei container di compilazione semplificano la creazione e il pacchetto di applicazioni serverless utilizzando. AWS SAMCLI
Le procedure utilizzate dalla CI/CD pipeline esistente per la distribuzione di applicazioni serverless AWS SAM sono leggermente diverse a seconda del CI/CD sistema in uso.
I seguenti argomenti forniscono esempi per configurare il CI/CD sistema per creare applicazioni serverless all'interno di un'immagine del contenitore di compilazione: AWS SAM
**Topics**
+ [
# Utilizzo AWS CodePipeline per la distribuzione con AWS SAM
](deploying-using-codepipeline.md)
+ [
# Utilizzo di Bitbucket Pipelines per la distribuzione con AWS SAM
](deploying-using-bitbucket.md)
+ [
# Utilizzo di Jenkins per la distribuzione con AWS SAM
](deploying-using-jenkins.md)
+ [
# Utilizzo di GitLab CI/CD per la distribuzione con AWS SAM
](deploying-using-gitlab.md)
+ [
# Utilizzo GitHub delle azioni con cui eseguire la distribuzione AWS SAM
](deploying-using-github.md)
# Utilizzo AWS CodePipeline per la distribuzione con AWS SAM
Per configurare la [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)pipeline in modo da automatizzare la creazione e la distribuzione dell' AWS SAM applicazione, il CloudFormation modello e il `buildspec.yml` file devono contenere righe che eseguano le seguenti operazioni:
1. Fai riferimento a un'immagine del contenitore di compilazione con il runtime necessario tra le immagini disponibili. L'esempio seguente utilizza l'immagine del contenitore di `public.ecr.aws/sam/build-nodejs20.x` compilazione.
1. Configura le fasi della pipeline per eseguire i comandi CLI ( AWS SAM Command Line Interface) necessari. L'esempio seguente esegue due AWS SAMCLI comandi: **sam build** e **sam deploy** (con le opzioni necessarie).
L'esempio presuppone che abbiate dichiarato tutte le funzioni e i livelli nel file AWS SAM modello con`runtime: nodejs20.x`.
**CloudFormation frammento di modello:**
```
CodeBuildProject:
Type: AWS::CodeBuild::Project
Properties:
Environment:
ComputeType: BUILD_GENERAL1_SMALL
Image: public.ecr.aws/sam/build-nodejs20.x
Type: LINUX_CONTAINER
...
```
**`buildspec.yml`frammento:**
```
version: 0.2
phases:
build:
commands:
- sam build
- sam deploy --no-confirm-changeset --no-fail-on-empty-changeset
```
Per un elenco delle immagini dei container di build Amazon Elastic Container Registry (Amazon ECR) disponibili per diversi runtime, consulta. [Archivi di immagini per AWS SAM](serverless-image-repositories.md)
# Utilizzo di Bitbucket Pipelines per la distribuzione con AWS SAM
Per configurare [Bitbucket Pipeline](https://support.atlassian.com/bitbucket-cloud/docs/get-started-with-bitbucket-pipelines/) per automatizzare la creazione e la distribuzione dell' AWS SAM applicazione, il `bitbucket-pipelines.yml` file deve contenere righe che eseguano le seguenti operazioni:
1. Fai riferimento a un'immagine del contenitore di compilazione con il runtime necessario tra le immagini disponibili. L'esempio seguente utilizza l'immagine del contenitore di `public.ecr.aws/sam/build-nodejs20.x` compilazione.
1. Configura le fasi della pipeline per eseguire i comandi CLI ( AWS SAM Command Line Interface) necessari. L'esempio seguente esegue due AWS SAMCLI comandi: **sam build** e **sam deploy** (con le opzioni necessarie).
L'esempio presuppone che abbiate dichiarato tutte le funzioni e i livelli nel file AWS SAM modello con`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
```
Per un elenco delle immagini dei container di build Amazon Elastic Container Registry (Amazon ECR) disponibili per diversi runtime, consulta. [Archivi di immagini per AWS SAM](serverless-image-repositories.md)
# Utilizzo di Jenkins per la distribuzione con AWS SAM
Per configurare la pipeline [Jenkins](https://www.jenkins.io/) per automatizzare la compilazione e la distribuzione dell' AWS SAM applicazione, è `Jenkinsfile` necessario contenere righe che eseguano le seguenti operazioni:
1. Fai riferimento a un'immagine del contenitore di compilazione con il runtime necessario tra le immagini disponibili. L'esempio seguente utilizza l'immagine del contenitore di `public.ecr.aws/sam/build-nodejs20.x` compilazione.
1. Configura le fasi della pipeline per eseguire i comandi CLI ( AWS SAM Command Line Interface) necessari. L'esempio seguente esegue due AWS SAMCLI comandi: **sam build** e **sam deploy** (con le opzioni necessarie).
L'esempio presuppone che abbiate dichiarato tutte le funzioni e i livelli nel file AWS SAM modello con`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'
}
}
}
}
```
Per un elenco delle immagini dei container di build Amazon Elastic Container Registry (Amazon ECR) disponibili per diversi runtime, consulta. [Archivi di immagini per AWS SAM](serverless-image-repositories.md)
# Utilizzo di GitLab CI/CD per la distribuzione con AWS SAM
Per configurare la [GitLab](https://about.gitlab.com)pipeline in modo da automatizzare la creazione e la distribuzione dell' AWS SAM applicazione, il `gitlab-ci.yml` file deve contenere righe che eseguano le seguenti operazioni:
1. Fai riferimento a un'immagine del contenitore di compilazione con il runtime necessario tra le immagini disponibili. L'esempio seguente utilizza l'immagine del contenitore di `public.ecr.aws/sam/build-nodejs20.x` compilazione.
1. Configura le fasi della pipeline per eseguire i comandi CLI ( AWS SAM Command Line Interface) necessari. L'esempio seguente esegue due AWS SAMCLI comandi: **sam build** e **sam deploy** (con le opzioni necessarie).
L'esempio presuppone che abbiate dichiarato tutte le funzioni e i livelli nel file AWS SAM modello con`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
```
Per un elenco delle immagini dei container di build Amazon Elastic Container Registry (Amazon ECR) disponibili per diversi runtime, consulta. [Archivi di immagini per AWS SAM](serverless-image-repositories.md)
# Utilizzo GitHub delle azioni con cui eseguire la distribuzione AWS SAM
Per configurare la [GitHub](https://github.com/)pipeline in modo da automatizzare la creazione e la distribuzione dell' AWS SAM applicazione, è necessario innanzitutto installare l'interfaccia a riga di AWS SAM comando (CLI) sull'host. Puoi utilizzare [GitHub Actions](https://github.com/features/actions) nel tuo GitHub flusso di lavoro per facilitare questa configurazione.
Il seguente GitHub flusso di lavoro di esempio configura un host Ubuntu utilizzando una serie di GitHub azioni, quindi esegue AWS SAMCLI i comandi per creare e distribuire un' AWS SAM applicazione:
```
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
```
Per un elenco delle immagini dei container di build Amazon Elastic Container Registry (Amazon ECR) disponibili per diversi runtime, consulta. [Archivi di immagini per AWS SAM](serverless-image-repositories.md)
# Come utilizzare l'autenticazione OIDC con le pipeline AWS SAM
AWS Serverless Application Model (AWS SAM) supporta l'autenticazione utente OpenID Connect (OIDC) per Bitbucket, GitHub Actions e l'integrazione GitLab continua e la distribuzione continua (account CI/CD) platforms. With this support, you can use authorized CI/CD utente) da una di queste piattaforme per gestire le pipeline di applicazioni serverless. Altrimenti, dovresti creare e gestire più utenti AWS Identity and Access Management (IAM) per controllare l'accesso alle pipeline. AWS SAM
## Configura OIDC con pipeline AWS SAM
Durante il processo `sam pipeline bootstrap` di configurazione, procedi come segue per configurare OIDC con la tua pipeline. AWS SAM
1. **Quando viene richiesto di scegliere un provider di identità, seleziona OIDC.**
1. Quindi, seleziona un provider OIDC supportato.
1. Inserisci l'URL del provider OIDC, iniziando con. **https://**
**Nota**
AWS SAM fa riferimento a questo URL quando genera il tipo di `AWS::IAM::OIDCProvider` risorsa.
1. Quindi, segui le istruzioni e inserisci le informazioni sulla CI/CD piattaforma necessarie per accedere alla piattaforma selezionata. Questi dettagli variano in base alla piattaforma e possono includere:
+ ID cliente OIDC.
+ Nome del repository di codici o identificatore univoco universale (UUID).
+ Nome del gruppo o dell'organizzazione associato al repository.
+ GitHub organizzazione a cui appartiene il repository di codice.
+ GitHub nome del repository.
+ Filiale da cui verranno effettuate le distribuzioni.
1. AWS SAM visualizza un riepilogo della configurazione OIDC inserita. Immettete il numero di un'impostazione per modificarla oppure premete Enter per continuare.
1. Quando viene richiesto di confermare la creazione delle risorse necessarie per supportare la connessione OIDC inserita, premi Y per continuare.
AWS SAM genera una `AWS::IAM::OIDCProvider` AWS CloudFormation risorsa con la configurazione fornita che assume il ruolo di esecuzione della pipeline. Per ulteriori informazioni su questo tipo di CloudFormation risorse, consulta [AWS: :IAM:: OIDCProvider](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-oidcprovider.html) nella *Guida per l'AWS CloudFormation utente*.
**Nota**
Se la risorsa del provider di identità (IdP) esiste già nel tuo Account AWS, vi AWS SAM fa riferimento invece di creare una nuova risorsa.
## Esempio
Di seguito è riportato un esempio di configurazione di OIDC con 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]:
```
## Ulteriori informazioni
Per ulteriori informazioni sull'utilizzo di OIDC con AWS SAM pipeline, vedere. [sam pipeline bootstrap](sam-cli-command-reference-sam-pipeline-bootstrap.md)
# Introduzione all'uso sam sync della sincronizzazione con Cloud AWS
Il AWS Serverless Application Model comando Command Line Interface (AWS SAMCLI) `sam sync` fornisce opzioni per sincronizzare rapidamente le modifiche dell'applicazione locale con. Cloud AWS`sam sync`Utilizzatelo quando sviluppate le vostre applicazioni per:
1. Rileva e sincronizza automaticamente le modifiche locali su Cloud AWS.
1. Personalizza le modifiche locali sincronizzate con. Cloud AWS
1. Prepara la tua applicazione nel cloud per il test e la convalida.
Con`sam sync`, puoi creare un flusso di lavoro di sviluppo rapido che riduce il tempo necessario per sincronizzare le modifiche locali nel cloud per test e convalida.
**Nota**
Il `sam sync` comando è consigliato per gli ambienti di sviluppo. Per gli ambienti di produzione, si consiglia di utilizzare `sam deploy` o configurare una pipeline di *integrazione e distribuzione continue (CI/CD*). Per ulteriori informazioni, consulta [Implementa la tua applicazione e le tue risorse con AWS SAM](serverless-deploying.md).
Il `sam sync` comando fa parte di. AWS SAM Accelerate *AWS SAM Accelerate*fornisce strumenti che è possibile utilizzare per velocizzare l'esperienza di sviluppo e test di applicazioni serverless in. Cloud AWS
**Topics**
+ [
## Rileva e sincronizza automaticamente le modifiche locali al Cloud AWS
](#using-sam-cli-sync-auto)
+ [
## Personalizza le modifiche locali da sincronizzare con Cloud AWS
](#using-sam-cli-sync-customize)
+ [
## Prepara la tua applicazione nel cloud per il test e la convalida
](#using-sam-cli-sync-test)
+ [
## Opzioni per il comando sam sync
](#using-sam-cli-sync-options)
+ [
## Risoluzione dei problemi
](#using-sam-cli-sync-troubleshooting)
+ [
## Esempi
](#using-sam-cli-sync-examples)
+ [
## Ulteriori informazioni
](#using-sam-cli-sync-learn)
## Rileva e sincronizza automaticamente le modifiche locali al Cloud AWS
Esegui `sam sync` con l'`--watch`opzione per iniziare a sincronizzare l' Cloud AWS applicazione con. Questa operazione esegue le seguenti operazioni:
1. **Crea la tua applicazione**: questo processo è simile all'utilizzo del `sam build` comando.
1. **Distribuisci l'applicazione**: AWS SAMCLI distribuisce l'applicazione AWS CloudFormation utilizzando le impostazioni predefinite. Vengono utilizzati i seguenti valori predefiniti:
1. AWS credenziali e impostazioni di configurazione generali presenti nella cartella `.aws` utente.
1. impostazioni di distribuzione dell'applicazione disponibili nel `samconfig.toml` file dell'applicazione.
Se non riesci a trovare i valori predefiniti, ti AWS SAMCLI informerà e chiuderà il processo di sincronizzazione.
1. **Controlla le modifiche locali**: AWS SAMCLI rimane in esecuzione e controlla le modifiche locali all'applicazione. Questo è ciò che offre l'`--watch`opzione.
Questa opzione può essere attivata per impostazione predefinita. Per i valori predefiniti, consultate il `samconfig.toml` file dell'applicazione. Di seguito è riportato un esempio del file .
```
...
[default.sync]
[default.sync.parameters]
watch = true
...
```
1. **Sincronizza le modifiche locali** con Cloud AWS: quando apporti modifiche locali, AWS SAMCLI rileva e sincronizza tali modifiche Cloud AWS tramite il metodo più rapido disponibile. A seconda del tipo di modifica, può verificarsi quanto segue:
1. Se la risorsa aggiornata supporta il AWS servizio APIs, la AWS SAMCLI utilizzeranno per distribuire le modifiche. Ciò si traduce in una sincronizzazione rapida per aggiornare la risorsa in. Cloud AWS
1. Se la risorsa aggiornata non supporta il AWS servizio APIs, AWS SAMCLI eseguirà una CloudFormation distribuzione. Questo aggiorna l'intera applicazione in Cloud AWS. Sebbene non sia altrettanto rapido, evita di dover avviare manualmente una distribuzione.
Poiché il `sam sync` comando aggiorna automaticamente l'applicazione in Cloud AWS, è consigliato solo per gli ambienti di sviluppo. Quando esegui`sam sync`, ti verrà chiesto di confermare:
```
**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
```
## Personalizza le modifiche locali da sincronizzare con Cloud AWS
Fornisci opzioni per personalizzare le modifiche locali sincronizzate con. Cloud AWS Ciò può velocizzare il tempo necessario per visualizzare le modifiche locali nel cloud per i test e la convalida.
Ad esempio, offri la `--code` possibilità di sincronizzare solo le modifiche al codice, come il codice di AWS Lambda funzione. Durante lo sviluppo, se ti concentri specificamente sul codice Lambda, le modifiche verranno trasferite rapidamente nel cloud per il test e la convalida. Di seguito è riportato un esempio:
```
$ sam sync --code --watch
```
Per sincronizzare solo le modifiche al codice per una funzione o un layer Lambda specifico, utilizzate l'`--resource-id`opzione. Di seguito è riportato un esempio:
```
$ sam sync --code --resource-id HelloWorldFunction --resource-id HelloWorldLayer
```
## Prepara la tua applicazione nel cloud per il test e la convalida
Il `sam sync` comando trova automaticamente il metodo più rapido disponibile per aggiornare l'applicazione in. Cloud AWS Ciò può velocizzare i flussi di lavoro di sviluppo e test sul cloud. Utilizzando il AWS servizio APIs, puoi sviluppare, sincronizzare e testare rapidamente le risorse supportate. Per un esempio pratico, consulta il [Modulo 6 - AWS SAM Accelerare](https://s12d.com/sam-ws-en-accelerate) in *The* Complete Workshop. AWS SAM
## Opzioni per il comando sam sync
Di seguito sono riportate alcune delle opzioni principali che è possibile utilizzare per modificare il `sam sync` comando. Per un elenco di tutte le opzioni, vedere[sam sync](sam-cli-command-reference-sam-sync.md).
### Eseguire una distribuzione una tantum CloudFormation
Usa l'`--no-watch`opzione per disattivare la sincronizzazione automatica. Di seguito è riportato un esempio:
```
$ sam sync --no-watch
```
AWS SAMCLIEseguirà una distribuzione una tantum. CloudFormation Questo comando raggruppa le azioni eseguite dai `sam deploy` comandi `sam build` and.
### Salta la distribuzione iniziale CloudFormation
È possibile personalizzare se è necessaria una CloudFormation distribuzione ogni volta che `sam sync` viene eseguita.
+ Provvedere `--no-skip-deploy-sync` a richiedere una CloudFormation distribuzione ogni volta `sam sync` che viene eseguita. Ciò garantisce la sincronizzazione dell'infrastruttura locale con CloudFormation, prevenendo eventuali deviazioni. L'utilizzo di questa opzione aggiunge ulteriore tempo al flusso di lavoro di sviluppo e test.
+ Fornisci `--skip-deploy-sync` per rendere facoltativa CloudFormation la distribuzione. AWS SAMCLIConfronterà il AWS SAM modello locale con il CloudFormation modello distribuito e salterà la CloudFormation distribuzione iniziale se non viene rilevata una modifica. Saltare la CloudFormation distribuzione può farti risparmiare tempo durante la sincronizzazione delle modifiche locali con. Cloud AWS
Se non viene rilevata alcuna modifica, AWS SAMCLI eseguirà comunque una CloudFormation distribuzione nei seguenti scenari:
+ Se sono trascorsi almeno 7 giorni dall'ultima CloudFormation distribuzione.
+ Se viene rilevato un gran numero di modifiche al codice della funzione Lambda, la CloudFormation distribuzione è il metodo più rapido per aggiornare l'applicazione.
Di seguito è riportato un esempio:
```
$ sam sync --skip-deploy-sync
```
### Sincronizza una risorsa da uno stack annidato
**Per sincronizzare una risorsa da uno stack annidato**
1. Fornisci lo stack principale utilizzando. `--stack-name`
1. Identifica la risorsa nello stack annidato utilizzando il seguente formato:. `nestedStackId/resourceId`
1. Fornisci la risorsa nello stack nidificato utilizzando. `--resource-id`
Di seguito è riportato un esempio:
```
$ sam sync --code --stack-name sam-app --resource-id myNestedStack/HelloWorldFunction
```
Per ulteriori informazioni sulla creazione di applicazioni annidate, vedere. [Riutilizza codice e risorse utilizzando applicazioni annidate in AWS SAM](serverless-sam-template-nested-applications.md)
### Specificare uno CloudFormation stack specifico da aggiornare
Per specificare uno CloudFormation stack specifico da aggiornare, fornisci l'`--stack-name`opzione. Di seguito è riportato un esempio:
```
$ sam sync --stack-name dev-sam-app
```
### Accelera i tempi di compilazione creando il tuo progetto nella cartella dei sorgenti
Per i runtime e i metodi di compilazione supportati, puoi utilizzare l'`--build-in-source`opzione per creare il tuo progetto direttamente nella cartella di origine. Per impostazione predefinita, AWS SAM CLI le build si trovano in una directory temporanea, che prevede la copia del codice sorgente e dei file di progetto. Con`--build-in-source`, AWS SAM CLI le build vengono create direttamente nella cartella di origine, il che accelera il processo di compilazione eliminando la necessità di copiare i file in una directory temporanea.
Per un elenco dei runtime e dei metodi di compilazione supportati, consulta. ` --build-in-source`
### Specificate i file e le cartelle che non avvieranno una sincronizzazione
Utilizzate l'`--watch-exclude`opzione per specificare qualsiasi file o cartella che non avvierà una sincronizzazione una volta aggiornato. Per ulteriori informazioni su questa opzione, consulta `--watch-exclude`.
Di seguito è riportato un esempio che esclude il `package-lock.json` file associato alla nostra `HelloWorldFunction` funzione:
```
$ sam sync --watch --watch-exclude HelloWorldFunction=package-lock.json
```
Quando viene eseguito questo comando, AWS SAM CLI avvierà il processo di sincronizzazione. Questo include gli output seguenti:
+ Esegui `sam build` per creare le tue funzioni e preparare l'applicazione per la distribuzione.
+ Esegui `sam deploy` per distribuire la tua applicazione.
+ Controlla le modifiche alla tua applicazione.
Quando modifichiamo il `package-lock.json` file, AWS SAM CLI non avvieranno una sincronizzazione. Quando un altro file viene aggiornato, AWS SAM CLI avvierà una sincronizzazione, che includerà il `package-lock.json` file.
Di seguito è riportato un esempio di specificazione di una funzione Lambda di uno stack secondario:
```
$ sam sync --watch --watch-exclude ChildStackA/MyFunction=database.sqlite3
```
## Risoluzione dei problemi
Per risolvere il problema, vedere. AWS SAMCLI [AWS SAMCLIrisoluzione dei problemi](sam-cli-troubleshooting.md)
## Esempi
### Utilizzo di sam sync per aggiornare l'applicazione Hello World
In questo esempio, iniziamo inizializzando l'applicazione Hello World di esempio. Per ulteriori informazioni su questa applicazione, consulta. [Tutorial: Implementa un'applicazione Hello World con AWS SAM](serverless-getting-started-hello-world.md)
L'esecuzione `sam sync` avvia il processo di creazione e distribuzione.
```
$ 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.
```
Una volta completata la distribuzione, modifichiamo il `HelloWorldFunction` codice. AWS SAMCLIRileva questa modifica e sincronizza la nostra applicazione con. Cloud AWS Poiché AWS Lambda supporta il AWS servizio APIs, viene eseguita una sincronizzazione rapida.
```
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.
```
Successivamente, modifichiamo il nostro endpoint API nel AWS SAM modello dell'applicazione. Passiamo `/hello` a. `/helloworld`
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
...
Resources:
HelloWorldFunction:
...
Properties:
...
Events:
HelloWorld:
Type: Api
Properties:
Path: /helloworld
Method: get
```
Poiché la risorsa Amazon API Gateway non supporta l'API del AWS servizio, esegue AWS SAMCLI automaticamente una CloudFormation distribuzione. Di seguito è riportato un esempio di output:
```
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.
```
## Ulteriori informazioni
Per una descrizione di tutte le `sam sync` opzioni, consulta[sam sync](sam-cli-command-reference-sam-sync.md).