Amazon non CodeCatalyst è più aperta a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [Come migrare da CodeCatalyst](migration.md).
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à.
# Implementazione di uno stack CloudFormation
Questa sezione descrive come distribuire uno AWS CloudFormation stack utilizzando un flusso di lavoro. CodeCatalyst A tale scopo, è necessario aggiungere l'azione **Deploy CloudFormation stack** al flusso di lavoro. L'azione distribuisce una CloudFormation pila di risorse in AWS base a un modello fornito dall'utente. Il modello può essere un:
+ CloudFormation modello: per ulteriori informazioni, consulta [Lavorare con CloudFormation i modelli](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html).
+ AWS SAM modello — Per ulteriori informazioni, vedere la [specifica AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html).
**Nota**
Per utilizzare un AWS SAM modello, dovete prima impacchettare l' AWS SAM applicazione utilizzando l'`[sam package](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html)`operazione. Per un tutorial che mostra come eseguire automaticamente questa confezione come parte di un CodeCatalyst flusso di lavoro Amazon, consulta[Tutorial: Implementazione di un'applicazione serverless](deploy-tut-lambda.md).
Se lo stack esiste già, l'azione esegue l' CloudFormation `[CreateChangeSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateChangeSet.html)`operazione e quindi l'`[ExecuteChangeSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ExecuteChangeSet.html)`operazione. L'azione attende quindi che le modifiche vengano distribuite e si contrassegna come riuscita o non riuscita, a seconda dei risultati.
Utilizza l'azione **Deploy CloudFormation stack** se disponi già di un AWS SAM modello CloudFormation or che contiene risorse che desideri distribuire, oppure prevedi di generarne uno automaticamente come parte di un'azione di [creazione](build-add-action.md) del flusso di lavoro utilizzando strumenti come e. AWS SAM [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html)
**Non ci sono restrizioni sul modello che puoi utilizzare, qualunque cosa tu possa creare CloudFormation o utilizzare con l'azione AWS SAM Deploy stack. CloudFormation **
**Suggerimento**
**Per un tutorial che mostra come distribuire un'applicazione serverless utilizzando l'azione Deploy stack, consulta. CloudFormation ** [Tutorial: Implementazione di un'applicazione serverless](deploy-tut-lambda.md)
**Topics**
+ [Immagine di runtime utilizzata dall'azione 'Deploy stack' CloudFormation](#deploy-action-cfn-runtime)
+ [Tutorial: Implementazione di un'applicazione serverless](deploy-tut-lambda.md)
+ [Aggiungere l'azione «Deploy stack» CloudFormation](deploy-action-cfn-adding.md)
+ [Configurazione dei rollback](deploy-consumption-enable-alarms.md)
+ [Variabili 'Deploy CloudFormation stack'](deploy-action-cfn-variables.md)
+ [Azione 'Implementa CloudFormation stack' YAML](deploy-action-ref-cfn.md)
## Immagine di runtime utilizzata dall'azione 'Deploy stack' CloudFormation
[L'azione **Deploy CloudFormation stack** viene eseguita su un'immagine di novembre 2022.](build-images.md#build.previous-image) Per ulteriori informazioni, consulta [Immagini attive](build-images.md#build-curated-images).
# Tutorial: Implementazione di un'applicazione serverless
In questo tutorial, imparerai come creare, testare e distribuire un'applicazione serverless come stack utilizzando un flusso di lavoro. CloudFormation
L'applicazione in questo tutorial è una semplice applicazione web che emette un messaggio «Hello World». È costituito da una AWS Lambda funzione e da un Amazon API Gateway e lo si crea utilizzando [AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html), che è un'estensione di [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html).
**Topics**
+ [Prerequisiti](#deploy-tut-lambda-cfn-prereqs)
+ [Fase 1: Creare un archivio di sorgenti](#deploy-tut-lambda-cfn-source)
+ [Fase 2: Creare ruoli AWS](#deploy-tut-lambda-cfn-roles)
+ [Fase 3: Aggiungere ruoli a AWS CodeCatalyst](#deploy-tut-lambda-cfn-roles-add)
+ [Fase 4: creare un bucket Amazon S3](#deploy-tut-lambda-cfn-s3)
+ [Passaggio 5: Aggiungere i file sorgente](#deploy-tut-lambda-cfn-files)
+ [Passaggio 6: creare ed eseguire un flusso di lavoro](#deploy-tut-lambda-cfn-workflow)
+ [Fase 7: Apportare una modifica](#deploy-tut-lambda-cfn-change)
+ [Eliminazione](#deploy-tut-lambda-cfn-clean-up)
## Prerequisiti
Prima di iniziare:
+ È necessario uno CodeCatalyst **spazio** con un AWS account connesso. Per ulteriori informazioni, consulta [Creazione di uno spazio](spaces-create.md).
+ Nel tuo spazio, hai bisogno di un progetto vuoto chiamato:
```
codecatalyst-cfn-project
```
Usa l'opzione **Inizia da zero** per creare questo progetto.
Per ulteriori informazioni, consulta [Creare un progetto vuoto in Amazon CodeCatalyst](projects-create.md#projects-create-empty).
+ Nel tuo progetto, hai bisogno di un CodeCatalyst **ambiente** chiamato:
```
codecatalyst-cfn-environment
```
Configura questo ambiente come segue:
+ Scegli qualsiasi tipo, ad esempio **Non di produzione**.
+ Connect il tuo AWS account.
+ Per il **ruolo IAM predefinito**, scegli un ruolo qualsiasi. Specificherai un ruolo diverso in seguito.
Per ulteriori informazioni, consulta [Implementazione in e Account AWS VPCs](deploy-environments.md).
## Fase 1: Creare un archivio di sorgenti
In questo passaggio, creerai un repository di origine in. CodeCatalyst Questo repository viene utilizzato per archiviare i file sorgente del tutorial, come il file della funzione Lambda.
Per ulteriori informazioni sui repository dei sorgenti, consulta. [Creazione di un repository di sorgenti](source-repositories-create.md)
**Per creare un archivio di sorgenti**
1. Nel CodeCatalyst riquadro di navigazione, scegli **Codice**, quindi scegli Archivi di **origine.**
1. Scegli **Aggiungi repository**, quindi scegli **Crea** repository.
1. Nel **nome del repository, inserisci:**
```
codecatalyst-cfn-source-repository
```
1. Scegli **Create** (Crea).
Ora hai creato un repository chiamato. `codecatalyst-cfn-source-repository`
## Fase 2: Creare ruoli AWS
In questo passaggio, crei i seguenti ruoli AWS IAM:
+ **Ruolo Deploy**: concede all'azione CodeCatalyst **Deploy CloudFormation stack** l'autorizzazione ad accedere al tuo AWS account e al CloudFormation servizio su cui distribuirai la tua applicazione serverless. L'azione **Deploy CloudFormation stack** fa parte del tuo flusso di lavoro.
+ **Ruolo di compilazione**: concede all'azione di CodeCatalyst compilazione l'autorizzazione ad accedere al tuo AWS account e scrivere su Amazon S3 dove verrà archiviato il pacchetto di applicazioni serverless. L'azione di compilazione fa parte del tuo flusso di lavoro.
+ **Ruolo Stack**: concede CloudFormation l'autorizzazione a leggere e modificare le risorse specificate nel AWS SAM modello che fornirai in seguito. Concede inoltre l'autorizzazione a. CloudWatch
Per ulteriori informazioni sui ruoli IAM, consulta i [ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) nella *Guida per l'AWS Identity and Access Management utente*.
**Nota**
Per risparmiare tempo, puoi creare un singolo ruolo, chiamato `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo, anziché i tre ruoli elencati in precedenza. Per ulteriori informazioni, consulta [Creazione del **CodeCatalystWorkflowDevelopmentRole-*spaceName***ruolo per il tuo account e il tuo spazio](ipa-iam-roles.md#ipa-iam-roles-service-create). Tieni presente che il `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo ha autorizzazioni molto ampie che possono rappresentare un rischio per la sicurezza. Ti consigliamo di utilizzare questo ruolo solo in tutorial e scenari in cui la sicurezza è meno preoccupante. Questo tutorial presuppone che stiate creando i tre ruoli elencati in precedenza.
**Nota**
È richiesto anche un [ruolo di esecuzione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html), ma non è necessario crearlo ora perché il `sam-template.yml` file lo crea automaticamente quando si esegue il flusso di lavoro nel passaggio 5.
**Per creare un ruolo di distribuzione**
1. Crea una politica per il ruolo, come segue:
1. Accedi a AWS.
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel riquadro di navigazione, scegli **Policy**.
1. Scegli **Create Policy** (Crea policy).
1. Scegliere la scheda **JSON**.
1. Eliminare il codice esistente.
1. Incolla il codice seguente:
**Nota**
La prima volta che il ruolo viene utilizzato per eseguire azioni del flusso di lavoro, utilizza il carattere jolly nell'informativa sulla politica delle risorse, quindi definisci la politica inserendo il nome della risorsa dopo che è disponibile.
```
"Resource": "*"
```
1. Scegliere **Next: Tags (Successivo: Tag)**.
1. Scegliere **Next:Review (Successivo: Rivedi)**.
1. In **Nome**, inserisci:
```
codecatalyst-deploy-policy
```
1. Scegli **Crea policy**.
Ora hai creato una politica di autorizzazioni.
1. Crea il ruolo di distribuzione, come segue:
1. Nel pannello di navigazione, scegli **Ruoli** e quindi **Crea ruolo**.
1. Scegli una **politica di fiducia personalizzata**.
1. Elimina la politica di fiducia personalizzata esistente.
1. Aggiungi la seguente politica di fiducia personalizzata:
1. Scegli **Next (Successivo)**.
1. Nelle **politiche di autorizzazione**, cerca `codecatalyst-deploy-policy` e seleziona la relativa casella di controllo.
1. Scegli **Next (Successivo)**.
1. Per il **nome del ruolo**, inserisci:
```
codecatalyst-deploy-role
```
1. Per la **descrizione del ruolo**, inserisci:
```
CodeCatalyst deploy role
```
1. Scegli **Crea ruolo**.
Ora hai creato un ruolo di distribuzione con una politica di fiducia e una politica di autorizzazioni.
1. Ottenere l'ARN del ruolo di distribuzione, come segue:
1. Nel riquadro di navigazione, seleziona **Ruoli**.
1. Nella casella di ricerca, inserisci il nome del ruolo che hai appena creato ()`codecatalyst-deploy-role`.
1. Scegli il ruolo dall'elenco.
Viene visualizzata la pagina di **riepilogo** del ruolo.
1. In alto, copia il valore **ARN.**
Ora hai creato il ruolo di distribuzione con le autorizzazioni appropriate e ottenuto il relativo ARN.
**Per creare un ruolo di costruzione**
1. Crea una politica per il ruolo, come segue:
1. Accedi a AWS.
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel riquadro di navigazione, scegli **Policy**.
1. Scegli **Create Policy** (Crea policy).
1. Scegliere la scheda **JSON**.
1. Eliminare il codice esistente.
1. Incolla il codice seguente:
**Nota**
La prima volta che il ruolo viene utilizzato per eseguire azioni del flusso di lavoro, utilizza il carattere jolly nell'informativa sulla politica delle risorse, quindi definisci la politica inserendo il nome della risorsa dopo che è disponibile.
```
"Resource": "*"
```
1. Scegliere **Next: Tags (Successivo: Tag)**.
1. Scegliere **Next:Review (Successivo: Rivedi)**.
1. In **Nome**, inserisci:
```
codecatalyst-build-policy
```
1. Scegli **Crea policy**.
Ora hai creato una politica di autorizzazioni.
1. Crea il ruolo di costruzione, come segue:
1. Nel pannello di navigazione, scegli **Ruoli** e quindi **Crea ruolo**.
1. Scegli una **politica di fiducia personalizzata**.
1. Elimina la politica di fiducia personalizzata esistente.
1. Aggiungi la seguente politica di fiducia personalizzata:
1. Scegli **Next (Successivo)**.
1. Nelle **politiche di autorizzazione**, cerca `codecatalyst-build-policy` e seleziona la relativa casella di controllo.
1. Scegli **Next (Successivo)**.
1. Per il **nome del ruolo**, inserisci:
```
codecatalyst-build-role
```
1. Per la **descrizione del ruolo**, inserisci:
```
CodeCatalyst build role
```
1. Scegli **Crea ruolo**.
Ora hai creato un ruolo di sviluppo con una politica di fiducia e una politica di autorizzazioni.
1. Ottieni l'ARN del ruolo di costruzione, come segue:
1. Nel riquadro di navigazione, seleziona **Ruoli**.
1. Nella casella di ricerca, inserisci il nome del ruolo che hai appena creato (`codecatalyst-build-role`).
1. Scegli il ruolo dall'elenco.
Viene visualizzata la pagina di **riepilogo** del ruolo.
1. In alto, copia il valore **ARN.**
Ora hai creato il ruolo di costruzione con le autorizzazioni appropriate e ottenuto il relativo ARN.
**Per creare un ruolo stack**
1. Accedi AWS utilizzando l'account in cui desideri distribuire lo stack.
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Crea il ruolo dello stack come segue:
1. Nel pannello di navigazione, seleziona **Roles** (Ruoli).
1. Selezionare **Create role (Crea ruolo)**.
1. Scegli un servizio in **Servizio AWS **.
1. Nella sezione **Caso d'uso**, scegli **CloudFormation**dall'elenco a discesa.
1. Seleziona il pulsante **CloudFormation**radio.
1. In basso, scegli **Avanti**.
1. Utilizzando la casella di ricerca, trova le seguenti politiche di autorizzazione, quindi seleziona le rispettive caselle di controllo.
**Nota**
Se cerchi una politica e questa non viene visualizzata, assicurati di scegliere **Cancella filtri** e riprova.
+ **CloudWatchFullAccess**
+ **AWS CloudFormationFullAccess**
+ **IAMFullAccesso**
+ **AWS Lambda\$1 FullAccess**
+ **APIGatewayAmministratore Amazon**
+ **Amazon S3 FullAccess**
+ **AmazonEC2ContainerRegistryFullAccess**
La prima policy consente l'accesso per CloudWatch abilitare i rollback dello stack quando si verifica un allarme.
Le politiche rimanenti consentono di accedere AWS SAM ai servizi e alle risorse dello stack che verrà distribuito in questo tutorial. *Per ulteriori informazioni, consulta [Autorizzazioni nella Guida](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-permissions.html) per gli AWS Serverless Application Model sviluppatori.*
1. Scegli **Next (Successivo)**.
1. Per il **nome del ruolo**, inserisci:
```
codecatalyst-stack-role
```
1. Scegli **Crea ruolo**.
1. Ottieni l'ARN del ruolo stack, come segue:
1. Nel riquadro di navigazione, seleziona **Ruoli**.
1. Nella casella di ricerca, inserisci il nome del ruolo che hai appena creato ()`codecatalyst-stack-role`.
1. Scegli il ruolo dall'elenco.
1. Nella sezione **Riepilogo**, copia il valore **ARN.** perché sarà necessaria in seguito.
Ora hai creato il ruolo stack con le autorizzazioni appropriate e ne hai ottenuto l'ARN.
## Fase 3: Aggiungere ruoli a AWS CodeCatalyst
In questo passaggio, aggiungi build role (`codecatalyst-build-role`) e deploy role (`codecatalyst-deploy-role`) alla connessione dell' CodeCatalyst account nel tuo spazio.
**Nota**
Non è necessario aggiungere lo stack role (`codecatalyst-stack-role`) alla connessione. Questo perché il ruolo stack viene utilizzato da *CloudFormation*(non CodeCatalyst), *dopo* che è già stata stabilita una connessione tra CodeCatalyst e AWS utilizzando il ruolo deploy. Poiché il ruolo stack non viene utilizzato per accedere CodeCatalyst a AWS, non è necessario che sia associato a una connessione all'account.
**Per aggiungere ruoli, build e deploy alla connessione del tuo account**
1. Nel CodeCatalyst, accedi al tuo spazio.
1. Seleziona **AWS accounts (Account)**. Viene visualizzato un elenco di connessioni all'account.
1. Scegli la connessione all'account che rappresenta l' AWS account in cui hai creato i ruoli di compilazione e distribuzione.
1. Scegli **Gestisci ruoli dalla console AWS di gestione**.
Viene visualizzata la pagina **Aggiungi ruolo IAM CodeCatalyst allo spazio Amazon**. Potrebbe essere necessario effettuare il login per accedere alla pagina.
1. Seleziona **Aggiungi un ruolo esistente che hai creato in IAM**.
Viene visualizzato un elenco a discesa. L'elenco mostra tutti i ruoli IAM con una policy di fiducia che include i principali `codecatalyst-runner.amazonaws.com` di `codecatalyst.amazonaws.com` servizio.
1. **Nell'elenco a discesa`codecatalyst-build-role`, scegli e scegli Aggiungi ruolo.**
1. Scegli **Aggiungi ruolo IAM**, scegli **Aggiungi un ruolo esistente che hai creato in IAM** e, nell'elenco a discesa, scegli. `codecatalyst-deploy-role` Scegliere **Add role (Aggiungi ruolo)**.
Ora hai aggiunto i ruoli di creazione e distribuzione al tuo spazio.
1. Copia il valore del **nome CodeCatalyst visualizzato di Amazon**. Questo valore ti servirà in seguito, durante la creazione del tuo flusso di lavoro.
## Fase 4: creare un bucket Amazon S3
In questa fase, crei un bucket Amazon S3 in cui archiviare il file.zip del pacchetto di distribuzione dell'applicazione serverless.
**Come creare un bucket Amazon S3.**
1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Nel riquadro principale, scegli **Crea bucket**.
1. Per il **nome del bucket, inserisci**:
```
codecatalyst-cfn-s3-bucket
```
1. In **AWS Region (Regione)**, scegliere una Regione. Questo tutorial presuppone che tu abbia scelto **US West (Oregon) us-west-2**. Per informazioni sulle regioni supportate da Amazon S3, consulta gli [endpoint e le quote di Amazon Simple Storage Service](https://docs.aws.amazon.com/general/latest/gr/s3.html) nel. *Riferimenti generali di AWS*
1. **Nella parte inferiore della pagina, scegli Crea bucket.**
Ora hai creato un bucket chiamato **codecatalyst-cfn-s3-bucket** nella regione us-west-2 degli Stati Uniti occidentali (Oregon).
## Passaggio 5: Aggiungere i file sorgente
In questo passaggio, aggiungi diversi file sorgente dell'applicazione al tuo repository CodeCatalyst di origine. La `hello-world` cartella contiene i file dell'applicazione che distribuirete. La `tests` cartella contiene i test unitari. La struttura delle cartelle è la seguente:
```
.
|— hello-world
| |— tests
| |— unit
| |— test-handler.js
| |— app.js
|— .npmignore
|— package.json
|— sam-template.yml
|— setup-sam.sh
```
### file.npmignore
Il `.npmignore` file indica quali file e cartelle npm deve escludere dal pacchetto dell'applicazione. In questo tutorial, npm esclude la `tests` cartella perché non fa parte dell'applicazione.
**Per aggiungere il file.npmignore**
1. [Apri la console all'indirizzo https://codecatalyst.aws/ CodeCatalyst .](https://codecatalyst.aws/)
1. Scegli il tuo progetto, `codecatalyst-cfn-project`
1. Nel riquadro di navigazione, scegli **Codice**, quindi scegli **Archivi di origine.**
1. Dall'elenco dei repository di origine, scegli il tuo repository,. `codecatalyst-cfn-source-repository`
1. In **File**, scegli **Crea** file.
1. Per **Nome file**, inserisci:
```
.npmignore
```
1. Nella casella di testo, inserisci il seguente codice:
```
tests/*
```
1. Scegliete **Commit**, quindi scegliete nuovamente **Commit**.
Ora hai creato un file chiamato `.npmignore` nella radice del tuo repository.
### file package.json
Il `package.json` file contiene importanti metadati sul progetto Node, come il nome del progetto, il numero di versione, la descrizione, le dipendenze e altri dettagli che descrivono come interagire ed eseguire l'applicazione.
`package.json`In questo tutorial sono inclusi un elenco di dipendenze e uno script. `test` Lo script di test esegue le seguenti operazioni:
+ Utilizzando [mocha](https://mochajs.org/), lo script di test esegue i test unitari specificati in `hello-world/tests/unit/` e scrive i risultati in un `junit.xml` file utilizzando il reporter [xunit]().
+ [Utilizzando [Istanbul (nyc)](https://istanbul.js.org/), lo script di test genera un rapporto sulla copertura del codice (`clover.xml`) utilizzando il clover reporter.](https://openclover.org/doc/manual/4.2.0/general--about-openclover.html) Per ulteriori informazioni, consulta [Usare reporter alternativi](https://istanbul.js.org/docs/advanced/alternative-reporters/#clover) nella documentazione di Istanbul.
**Per aggiungere il file package.json**
1. **Nel tuo repository, in **File, scegli Crea file**.**
1. Per **Nome file**, inserisci:
```
package.json
```
1. Nella casella di testo, inserisci il seguente codice:
```
{
"name": "hello_world",
"version": "1.0.0",
"description": "hello world sample for NodeJS",
"main": "app.js",
"repository": "https://github.com/awslabs/aws-sam-cli/tree/develop/samcli/local/init/templates/cookiecutter-aws-sam-hello-nodejs",
"author": "SAM CLI",
"license": "MIT",
"dependencies": {
"axios": "^0.21.1",
"nyc": "^15.1.0"
},
"scripts": {
"test": "nyc --reporter=clover mocha hello-world/tests/unit/ --reporter xunit --reporter-option output=junit.xml"
},
"devDependencies": {
"aws-sdk": "^2.815.0",
"chai": "^4.2.0",
"mocha": "^8.2.1"
}
}
```
1. Scegliete **Commit**, quindi scegliete nuovamente **Commit**.
Ora hai aggiunto un file chiamato `package.json` alla radice del repository.
### file sam-template.yml
Il `sam-template.yml` file contiene le istruzioni per implementare la funzione Lambda e API Gateway e configurarli insieme. Segue la specifica del [AWS Serverless Application Model modello, che estende la specifica](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html) del CloudFormation modello.
In questo tutorial utilizzi un AWS SAM modello invece di un CloudFormation modello normale perché AWS SAM offre un utile tipo di risorsa [AWS: :Serverless: :Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html). Questo tipo esegue molte behind-the-scenes configurazioni che normalmente è necessario scrivere per utilizzare la sintassi di base. CloudFormation Ad esempio, `AWS::Serverless::Function` crea una funzione Lambda, un ruolo di esecuzione Lambda e mappature delle sorgenti degli eventi che avviano la funzione. Devi codificare tutto questo se vuoi scriverlo usando basic. CloudFormation
Sebbene questo tutorial utilizzi un modello già scritto, puoi generarne uno come parte del tuo flusso di lavoro utilizzando un'azione di compilazione. Per ulteriori informazioni, consulta [Implementazione di uno stack CloudFormation](deploy-action-cfn.md).
**Per aggiungere il file sam-template.yml**
1. ****Nel tuo repository, in File, scegli Crea file.****
1. Per **Nome file**, inserisci:
```
sam-template.yml
```
1. Nella casella di testo, inserisci il seguente codice:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: >
serverless-api
Sample SAM Template for serverless-api
# More info about Globals: https://github.com/awslabs/serverless-application-model/blob/master/docs/globals.rst
Globals:
Function:
Timeout: 3
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function # For details on this resource type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
Properties:
CodeUri: hello-world/
Handler: app.lambdaHandler
Runtime: nodejs12.x
Events:
HelloWorld:
Type: Api # For details on this event source type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#api
Properties:
Path: /hello
Method: get
Outputs:
# ServerlessRestApi is an implicit API created out of the events key under Serverless::Function
# Find out about other implicit resources you can reference within AWS SAM at
# https://github.com/awslabs/serverless-application-model/blob/master/docs/internals/generated_resources.rst#api
HelloWorldApi:
Description: "API Gateway endpoint URL for the Hello World function"
Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/hello/"
HelloWorldFunction:
Description: "Hello World Lambda function ARN"
Value: !GetAtt HelloWorldFunction.Arn
HelloWorldFunctionIamRole:
Description: "Implicit Lambda execution role created for the Hello World function"
Value: !GetAtt HelloWorldFunctionRole.Arn
```
1. Scegliete **Commit**, quindi scegliete nuovamente **Commit**.
Ora hai aggiunto un file chiamato `sam-template.yml` nella cartella principale del tuo repository.
### file setup-sam.sh
Il `setup-sam.sh` file contiene le istruzioni per scaricare e installare l'utilità AWS SAM CLI. Il flusso di lavoro utilizza questa utilità per impacchettare il `hello-world` codice sorgente.
**Per aggiungere il file setup-sam.sh**
1. Nel tuo repository, in **File**, scegli **Crea file**.
1. Per **Nome file**, inserisci:
```
setup-sam.sh
```
1. Nella casella di testo, inserisci il seguente codice:
```
#!/usr/bin/env bash
echo "Setting up sam"
yum install unzip -y
curl -LO https://github.com/aws/aws-sam-cli/releases/latest/download/aws-sam-cli-linux-x86_64.zip
unzip -qq aws-sam-cli-linux-x86_64.zip -d sam-installation-directory
./sam-installation-directory/install; export AWS_DEFAULT_REGION=us-west-2
```
Nel codice precedente, sostituiscilo *us-west-2* con la tua AWS regione.
1. Scegli **Commit**, quindi scegli nuovamente **Commit**.
Ora hai aggiunto un file chiamato `setup-sam.sh` alla radice del repository.
### file app.js
`app.js`Contiene il codice della funzione Lambda. In questo tutorial, il codice restituisce il testo`hello world`.
**Per aggiungere il file app.js**
1. Nel tuo repository, in **File**, scegli **Crea file**.
1. Per **Nome file**, inserisci:
```
hello-world/app.js
```
1. Nella casella di testo, inserisci il seguente codice:
```
// const axios = require('axios')
// const url = 'http://checkip.amazonaws.com/';
let response;
/**
*
* Event doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
* @param {Object} event - API Gateway Lambda Proxy Input Format
*
* Context doc: https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html
* @param {Object} context
*
* Return doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
* @returns {Object} object - API Gateway Lambda Proxy Output Format
*
*/
exports.lambdaHandler = async (event, context) => {
try {
// const ret = await axios(url);
response = {
'statusCode': 200,
'body': JSON.stringify({
message: 'hello world',
// location: ret.data.trim()
})
}
} catch (err) {
console.log(err);
return err;
}
return response
};
```
1. Scegliete **Commit**, quindi scegliete nuovamente **Commit**.
Ora hai creato una cartella chiamata `hello-world` e un file chiamato`app.js`.
### file test-handler.js
Il `test-handler.js` file contiene test unitari per la funzione Lambda.
**Per aggiungere il file test-handler.js**
1. Nel tuo repository, in **File**, scegli **Crea file**.
1. Per **Nome file**, inserisci:
```
hello-world/tests/unit/test-handler.js
```
1. Nella casella di testo, inserisci il seguente codice:
```
'use strict';
const app = require('../../app.js');
const chai = require('chai');
const expect = chai.expect;
var event, context;
describe('Tests index', function () {
it('verifies successful response', async () => {
const result = await app.lambdaHandler(event, context)
expect(result).to.be.an('object');
expect(result.statusCode).to.equal(200);
expect(result.body).to.be.an('string');
let response = JSON.parse(result.body);
expect(response).to.be.an('object');
expect(response.message).to.be.equal("hello world");
// expect(response.location).to.be.an("string");
});
});
```
1. Scegliete **Commit**, quindi scegliete nuovamente **Commit**.
Ora hai aggiunto un file chiamato `test-handler.js` sotto la `hello-world/tests/unit` cartella.
Ora hai aggiunto tutti i tuoi file sorgente.
Prenditi un momento per ricontrollare il tuo lavoro e assicurati di aver inserito tutti i file nelle cartelle corrette. La struttura delle cartelle è la seguente:
```
.
|— hello-world
| |— tests
| |— unit
| |— test-handler.js
| |— app.js
|— .npmignore
|— README.md
|— package.json
|— sam-template.yml
|— setup-sam.sh
```
## Passaggio 6: creare ed eseguire un flusso di lavoro
In questo passaggio, crei un flusso di lavoro che impacchetta il codice sorgente Lambda e lo distribuisce. Il flusso di lavoro è costituito dai seguenti elementi costitutivi eseguiti in sequenza:
+ Un trigger: questo trigger avvia l'esecuzione automatica del flusso di lavoro quando invii una modifica al tuo repository di origine. Per ulteriori informazioni sui trigger, consulta [L'avvio di un flusso di lavoro viene eseguito automaticamente utilizzando i trigger](workflows-add-trigger.md).
+ Un'azione di test (`Test`): al momento del trigger, questa azione installa il [gestore di pacchetti Node (npm)](https://www.npmjs.com/), quindi esegue il comando. `npm run test` Questo comando dice a npm di eseguire lo `test` script definito nel file. `package.json` Lo `test` script, a sua volta, esegue gli unit test e genera due report: un test report (`junit.xml`) e un rapporto sulla copertura del codice (`clover.xml`). Per ulteriori informazioni, consulta [file package.json](#deploy-tut-lambda-cfn-files-package-json).
Successivamente, l'azione di test trasforma i report XML in CodeCatalyst report e li visualizza nella CodeCatalyst console, nella scheda **Report** dell'azione di test.
Per ulteriori informazioni sull'azione di test, vedere[Test con flussi di lavoroTest con flussi di lavoro](test-workflow-actions.md).
+ Un'azione di compilazione (`BuildBackend`): al termine dell'azione di test, l'azione di compilazione scarica e installa la AWS SAM CLI, impacchetta `hello-world` il codice sorgente e copia il pacchetto nel bucket Amazon S3, dove il servizio Lambda prevede che si trovi. L'azione genera anche un nuovo file AWS SAM modello chiamato `sam-template-packaged.yml` e lo inserisce in un elemento di output chiamato. `buildArtifact`
Per ulteriori informazioni sull'azione di compilazione, consulta. [Creazione con flussi di lavoro](build-workflow-actions.md)
+ A deploy action (`DeployCloudFormationStack`): al termine dell'azione di compilazione, l'azione deploy cerca l'artefatto di output generato dall'azione di compilazione (`buildArtifact`), trova il AWS SAM modello al suo interno e quindi esegue il modello. Il AWS SAM modello crea uno stack che distribuisce l'applicazione serverless.
**Come creare un flusso di lavoro**
1. **Nel riquadro di navigazione, scegli **CI/CD, quindi** scegli Flussi di lavoro.**
1. **Scegli Crea flusso di lavoro.**
1. Per **Source repository**, scegli`codecatalyst-cfn-source-repository`.
1. Per **Branch**, scegli`main`.
1. Scegli **Create** (Crea).
1. Eliminate il codice di esempio YAML.
1. Aggiungi il seguente codice YAML:
**Nota**
Nel codice YAML che segue, puoi omettere le sezioni se lo `Connections:` desideri. Se ometti queste sezioni, devi assicurarti che il ruolo specificato nel campo **Default IAM role** nel tuo ambiente includa le autorizzazioni e le policy di fiducia di entrambi i ruoli descritte in. [Fase 2: Creare ruoli AWS](#deploy-tut-lambda-cfn-roles) Per ulteriori informazioni sulla configurazione di un ambiente con un ruolo IAM predefinito, consulta. [Creazione di un ambiente](deploy-environments-creating-environment.md)
```
Name: codecatalyst-cfn-workflow
SchemaVersion: 1.0
Triggers:
- Type: PUSH
Branches:
- main
Actions:
Test:
Identifier: aws/managed-test@v1
Inputs:
Sources:
- WorkflowSource
Outputs:
Reports:
CoverageReport:
Format: CLOVERXML
IncludePaths:
- "coverage/*"
TestReport:
Format: JUNITXML
IncludePaths:
- junit.xml
Configuration:
Steps:
- Run: npm install
- Run: npm run test
BuildBackend:
Identifier: aws/build@v1
DependsOn:
- Test
Environment:
Name: codecatalyst-cfn-environment
Connections:
- Name: codecatalyst-account-connection
Role: codecatalyst-build-role
Inputs:
Sources:
- WorkflowSource
Configuration:
Steps:
- Run: . ./setup-sam.sh
- Run: sam package --template-file sam-template.yml --s3-bucket codecatalyst-cfn-s3-bucket --output-template-file sam-template-packaged.yml --region us-west-2
Outputs:
Artifacts:
- Name: buildArtifact
Files:
- "**/*"
DeployCloudFormationStack:
Identifier: aws/cfn-deploy@v1
DependsOn:
- BuildBackend
Environment:
Name: codecatalyst-cfn-environment
Connections:
- Name: codecatalyst-account-connection
Role: codecatalyst-deploy-role
Inputs:
Artifacts:
- buildArtifact
Sources: []
Configuration:
name: codecatalyst-cfn-stack
region: us-west-2
role-arn: arn:aws:iam::111122223333:role/StackRole
template: ./sam-template-packaged.yml
capabilities: CAPABILITY_IAM,CAPABILITY_AUTO_EXPAND
```
Nel codice precedente, sostituisci:
+ Entrambe le istanze *codecatalyst-cfn-environment* con il nome dell'ambiente.
+ Entrambe le istanze *codecatalyst-account-connection* con il nome visualizzato della connessione all'account. Il nome visualizzato potrebbe essere un numero. Per ulteriori informazioni, consulta [Fase 3: Aggiungere ruoli a AWS CodeCatalyst](#deploy-tut-lambda-cfn-roles-add).
+ *codecatalyst-build-role*con il nome del ruolo di build in cui hai creato[Fase 2: Creare ruoli AWS](#deploy-tut-lambda-cfn-roles).
+ *codecatalyst-cfn-s3-bucket*con il nome del bucket Amazon S3 in cui hai creato. [Fase 4: creare un bucket Amazon S3](#deploy-tut-lambda-cfn-s3)
+ Entrambe le istanze sono nella regione in cui risiede il bucket Amazon S3 (prima istanza) e in cui verrà distribuito lo stack (seconda istanza). *us-west-2* Queste regioni possono essere diverse. Questo tutorial presuppone che entrambe le regioni siano impostate su. `us-west-2` Per informazioni dettagliate sulle regioni supportate da Amazon S3 e CloudFormation, consulta [Endpoint e quote del servizio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) nel. *Riferimenti generali di AWS*
+ *codecatalyst-deploy-role*con il nome del ruolo di distribuzione in cui hai creato. [Fase 2: Creare ruoli AWS](#deploy-tut-lambda-cfn-roles)
+ *codecatalyst-cfn-environment*con il nome dell'ambiente in [Prerequisiti](#deploy-tut-lambda-cfn-prereqs) cui hai creato.
+ *arn:aws:iam::111122223333:role/StackRole*con l'Amazon Resource Name (ARN) del ruolo stack in cui hai creato. [Fase 2: Creare ruoli AWS](#deploy-tut-lambda-cfn-roles)
**Nota**
Se avete deciso di non creare ruoli di compilazione, distribuzione e impilamento *codecatalyst-build-role**codecatalyst-deploy-role*, sostituiteli e *arn:aws:iam::111122223333:role/StackRole* inserite il nome o l'ARN del ruolo. `CodeCatalystWorkflowDevelopmentRole-spaceName` Per ulteriori informazioni su questo ruolo, consulta [Fase 2: Creare ruoli AWS](#deploy-tut-lambda-cfn-roles).
Per informazioni sulle proprietà del codice mostrato in precedenza, consulta la. [Azione 'Implementa CloudFormation stack' YAML](deploy-action-ref-cfn.md)
1. (Facoltativo) Scegliete **Convalida** per assicurarvi che il codice YAML sia valido prima di eseguire il commit.
1. Scegli **Applica**.
1. Nella finestra di dialogo **Conferma flusso di lavoro**, inserisci quanto segue:
1. Per il **nome del file Workflow**, mantenete il valore predefinito,`codecatalyst-cfn-workflow`.
1. Per il **messaggio** di conferma, inserisci:
```
add initial workflow file
```
1. Per **Repository**, scegli **codecatalyst-cfn-source-repository**.
1. Per il **nome del ramo**, scegli **principale**.
1. Scegli **Applica**.
Ora hai creato un flusso di lavoro. L'esecuzione di un flusso di lavoro viene avviata automaticamente a causa del trigger definito nella parte superiore del flusso di lavoro. In particolare, quando hai eseguito il commit (e inviato) del `codecatalyst-cfn-workflow.yaml` file nell'archivio di origine, il trigger ha avviato l'esecuzione del flusso di lavoro.
**Per visualizzare il flusso di lavoro in corso**
1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.**
1. Scegli il flusso di lavoro che hai appena creato:. `codecatalyst-cfn-workflow`
1. Scegli la scheda **Esecuzioni**.
1. Nella colonna **Run ID**, scegli l'ID di esecuzione.
1. Scegli **Test** per vedere l'avanzamento dei test.
1. Scegli **BuildBackend**di vedere lo stato di avanzamento della costruzione.
1. Scegli **DeployCloudFormationStack**di vedere lo stato di avanzamento della distribuzione.
Per ulteriori informazioni sulla visualizzazione dei dettagli dell'esecuzione, consulta[Visualizzazione dello stato e dei dettagli dell'esecuzione del flusso di lavoro](workflows-view-run.md).
1. Al termine dell'**DeployCloudFormationStack**azione, procedi come segue:
+ Se l'esecuzione del flusso di lavoro è riuscita, passate alla procedura successiva.
+ Se l'esecuzione del flusso di lavoro non è riuscita durante il **test** o **BuildBackend**l'azione, scegli **Registri** per risolvere il problema.
+ **Se l'esecuzione del flusso di lavoro non è riuscita nell'**DeployCloudFormationStack**azione, scegli l'azione di distribuzione, quindi scegli la scheda Riepilogo.** Scorri fino alla sezione **CloudFormation degli eventi** per visualizzare il messaggio di errore dettagliato. Se si è verificato un rollback, elimina lo `codecatalyst-cfn-stack` stack tramite la CloudFormation console AWS prima di eseguire nuovamente il flusso di lavoro.
**Per verificare la distribuzione**
1. Dopo una distribuzione riuscita, scegli **Variabili (7)** dalla barra dei menu orizzontale in alto. (Non scegliete **Variabili** nel riquadro a destra).
1. Successivamente **HelloWorldApi**, incolla l'`https://`URL in un browser.
Viene visualizzato un messaggio JSON **hello world** dalla funzione Lambda, che indica che il flusso di lavoro ha distribuito e configurato correttamente la funzione Lambda e l'API Gateway.
**Suggerimento**
È possibile CodeCatalyst visualizzare questo URL nel diagramma del flusso di lavoro con alcune piccole configurazioni. Per ulteriori informazioni, consulta [Visualizzazione dell'URL dell'app nel diagramma del flusso di lavoro](deploy-app-url.md).
**Per verificare i risultati dei test unitari e la copertura del codice**
1. Nel diagramma del flusso di lavoro, scegli **Test**, quindi scegli **Report**.
1. Scegliete di **TestReport**visualizzare i risultati del test unitario o scegliete di **CoverageReport**visualizzare i dettagli della copertura del codice dei file da testare, in questo caso, `app.js` e`test-handler.js`.
**Per verificare le risorse distribuite**
1. Accedi Console di gestione AWS e apri la console API Gateway all'indirizzo [https://console.aws.amazon.com/apigateway/](https://console.aws.amazon.com/apigateway/).
1. Osserva l'**codecatalyst-cfn-stack**API creata dal AWS SAM modello. Il nome dell'API deriva dal `Configuration/name` valore nel file di definizione del flusso di lavoro (`codecatalyst-cfn-workflow.yaml`).
1. Apri la AWS Lambda console all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Nel riquadro di navigazione, seleziona **Funzioni**.
1. Scegli la tua funzione Lambda,. `codecatalyst-cfn-stack-HelloWorldFunction-string`
1. Puoi vedere come l'API Gateway funge da trigger per la funzione. Questa integrazione è stata configurata automaticamente in base al tipo di AWS SAM `AWS::Serverless::Function` risorsa.
## Fase 7: Apportare una modifica
In questo passaggio, apporti una modifica al codice sorgente Lambda e la esegui il commit. Questo commit avvia l'esecuzione di un nuovo flusso di lavoro. Questa esecuzione implementa la nuova funzione Lambda in uno schema blu-verde che utilizza la configurazione di spostamento del traffico predefinita specificata nella console Lambda.
**Per apportare una modifica alla sorgente Lambda**
1. In CodeCatalyst, accedi al tuo progetto.
1. Nel riquadro di navigazione, scegli **Codice**, quindi scegli **Archivi di origine.**
1. Scegli il tuo repository `codecatalyst-cfn-source-repository` di origine.
1. Cambia il file dell'applicazione:
1. Scegliere la cartella `hello-world`.
1. Scegli il `app.js` file.
1. Scegli **Modifica**.
1. Sulla riga 23, cambia `hello world` in**Tutorial complete\$1**.
1. Scegli **Commetti**, quindi scegli di nuovo **Commetti**.
Il commit avvia l'esecuzione di un flusso di lavoro. Questa esecuzione avrà esito negativo perché non hai aggiornato gli unit test per riflettere la modifica del nome.
1. Aggiorna gli unit test:
1. Scegli `hello-world\tests\unit\test-handler.js`.
1. Scegli **Modifica**.
1. Sulla riga 19, passare `hello world` a**Tutorial complete\$1**.
1. Scegli **Commetti**, quindi scegli di nuovo **Commetti**.
Il commit provoca l'avvio di un altro workflow. L'esecuzione avrà esito positivo.
1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.**
1. **Scegli`codecatalyst-cfn-workflow`, quindi scegli Esecuzioni.**
1. Scegli l'ID di esecuzione dell'ultima esecuzione. Dovrebbe essere ancora in corso.
1. Scegli **Test **BuildBackend****, e **DeployCloudFormationStack**per vedere l'avanzamento del flusso di lavoro viene eseguito.
1. Al termine del flusso di lavoro, scegli **Variabili (7)** nella parte superiore.
1. Successivamente **HelloWorldApi**, incolla l'`https://`URL in un browser.
Nel browser viene visualizzato un `Tutorial complete!` messaggio che indica che la nuova applicazione è stata distribuita correttamente.
## Eliminazione
Pulisci i file e i servizi utilizzati in questo tutorial per evitare che ti vengano addebitati dei costi.
**Per pulire la CodeCatalyst console**
1. Apri la CodeCatalyst console all'[indirizzo https://codecatalyst.aws/](https://codecatalyst.aws/).
1. Elimina`codecatalyst-cfn-workflow`.
1. Eliminare`codecatalyst-cfn-environment`.
1. Eliminare`codecatalyst-cfn-source-repository`.
1. Eliminare`codecatalyst-cfn-project`.
**Per pulire in Console di gestione AWS**
1. Effettuare CloudFormation la pulizia nel modo seguente:
1. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Eliminare il `codecatalyst-cfn-stack`.
L'eliminazione dello stack rimuove tutte le risorse del tutorial dai servizi API Gateway e Lambda.
1. Esegui la pulizia in Amazon S3, come segue:
1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Seleziona `codecatalyst-cfn-s3-bucket`.
1. Elimina il contenuto del bucket.
1. Elimina il bucket.
1. Esegui la pulizia in IAM, come segue:
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Eliminare il `codecatalyst-deploy-policy`.
1. Eliminare il `codecatalyst-build-policy`.
1. Eliminare il `codecatalyst-stack-policy`.
1. Eliminare il `codecatalyst-deploy-role`.
1. Eliminare il `codecatalyst-build-role`.
1. Eliminare il `codecatalyst-stack-role`.
In questo tutorial, hai imparato a distribuire un'applicazione serverless come CloudFormation stack utilizzando un CodeCatalyst flusso di lavoro e un'azione ** CloudFormation Deploy** stack.
# Aggiungere l'azione «Deploy stack» CloudFormation
Utilizza le seguenti istruzioni per aggiungere l'azione **Deploy stack al tuo flusso di lavoro CloudFormation **.
------
#### [ Visual ]
**Per aggiungere l'azione 'Deploy CloudFormation stack' utilizzando l'editor visuale**
1. [Apri la console all'indirizzo https://codecatalyst.aws/ CodeCatalyst .](https://codecatalyst.aws/)
1. Scegliere il progetto.
1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.**
1. Scegli il nome del tuo flusso di lavoro. Puoi filtrare in base al nome del repository o del ramo di origine in cui è definito il flusso di lavoro oppure filtrare in base al nome o allo stato del flusso di lavoro.
1. Scegli **Modifica**.
1. Scegli **Visual**.
1. In alto a sinistra, scegli **\$1 Azioni** per aprire il catalogo delle azioni.
1. **Dall'elenco a discesa, scegli Amazon. CodeCatalyst**
1. Cerca l'azione **Deploy CloudFormation stack** ed esegui una delle seguenti operazioni:
+ Scegli il segno più (**\$1**) per aggiungere l'azione al diagramma del flusso di lavoro e apri il relativo riquadro di configurazione.
Or
+ Scegli **Deploy stack. CloudFormation ** Viene visualizzata la finestra di dialogo con i dettagli dell'azione. In questa finestra di dialogo:
+ (Facoltativo) Scegliete **Scarica** per [visualizzare il codice sorgente dell'azione](workflows-view-source.md#workflows-view-source.title).
+ Scegli **Aggiungi al flusso di lavoro** per aggiungere l'azione al diagramma del flusso di lavoro e aprirne il riquadro di configurazione.
1. Nelle schede **Ingressi** e **Configurazione**, completa i campi in base alle tue esigenze. Per una descrizione di ogni campo, vedi. [Azione 'Implementa CloudFormation stack' YAML](deploy-action-ref-cfn.md) Questo riferimento fornisce informazioni dettagliate su ogni campo (e il valore della proprietà YAML corrispondente) così come appaiono sia nell'editor YAML che in quello visivo.
1. (Facoltativo) Scegliete **Convalida per convalidare il codice YAML** del flusso di lavoro prima di eseguire il commit.
1. **Scegliete **Commit**, inserite un messaggio di commit e scegliete nuovamente Commit.**
------
#### [ YAML ]
**Per aggiungere l'azione 'Deploy CloudFormation stack' utilizzando l'editor YAML**
1. [Apri la console all'indirizzo https://codecatalyst.aws/. CodeCatalyst ](https://codecatalyst.aws/)
1. Scegliere il progetto.
1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.**
1. Scegli il nome del tuo flusso di lavoro. Puoi filtrare in base al nome del repository o del ramo di origine in cui è definito il flusso di lavoro oppure filtrare in base al nome o allo stato del flusso di lavoro.
1. Scegli **Modifica**.
1. Scegli **YAML**.
1. In alto a sinistra, scegli **\$1 Azioni per aprire il catalogo delle azioni**.
1. **Dall'elenco a discesa, scegli Amazon. CodeCatalyst**
1. Cerca l'azione **Deploy CloudFormation stack** ed esegui una delle seguenti operazioni:
+ Scegli il segno più (**\$1**) per aggiungere l'azione al diagramma del flusso di lavoro e apri il relativo riquadro di configurazione.
Or
+ Scegli **Deploy stack. CloudFormation ** Viene visualizzata la finestra di dialogo con i dettagli dell'azione. In questa finestra di dialogo:
+ (Facoltativo) Scegliete **Scarica** per [visualizzare il codice sorgente dell'azione](workflows-view-source.md#workflows-view-source.title).
+ Scegli **Aggiungi al flusso di lavoro** per aggiungere l'azione al diagramma del flusso di lavoro e aprirne il riquadro di configurazione.
1. Modifica le proprietà del codice YAML in base alle tue esigenze. Una spiegazione di ogni proprietà disponibile è fornita in. [Azione 'Implementa CloudFormation stack' YAML](deploy-action-ref-cfn.md)
1. (Facoltativo) Scegliete **Convalida per convalidare** il codice YAML del flusso di lavoro prima di eseguire il commit.
1. **Scegliete **Commit**, inserite un messaggio di commit e scegliete nuovamente Commit.**
------
# Configurazione dei rollback
Per impostazione predefinita, se l'azione **Deploy CloudFormation stack** fallisce, lo stack CloudFormation verrà ripristinato all'ultimo stato stabile conosciuto. Puoi modificare il comportamento in modo che i rollback si verifichino non solo quando l'azione fallisce, ma anche quando si verifica uno specifico CloudWatch allarme Amazon. Per ulteriori informazioni sugli CloudWatch allarmi, consulta [Using Amazon CloudWatch alarms](https://docs.aws.amazon.com/) nella *Amazon CloudWatch User* Guide.
Puoi anche modificare il comportamento predefinito in modo da CloudFormation non ripristinare lo stack quando l'azione fallisce.
Utilizza le seguenti istruzioni per configurare i rollback.
**Nota**
Non è possibile avviare un rollback manualmente.
------
#### [ Visual ]
**Prima di iniziare**
1. Assicurati di disporre di un [flusso di lavoro](workflow.md) che includa un'azione **Deploy CloudFormation stack** funzionante. Per ulteriori informazioni, consulta [Implementazione di uno stack CloudFormation](deploy-action-cfn.md).
1. Nel ruolo specificato nel campo **Stack role - opzionale** dell'azione **Deploy CloudFormation stack**, assicurati di includere l'autorizzazione. **CloudWatchFullAccess** Per informazioni sulla creazione di questo ruolo con le autorizzazioni appropriate, consulta. [Fase 2: Creare ruoli AWS](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles)
**Per configurare gli allarmi di rollback per l'azione «Deploy stack» CloudFormation**
1. [Apri la console all'indirizzo https://codecatalyst.aws/. CodeCatalyst ](https://codecatalyst.aws/)
1. Scegliere il progetto.
1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.**
1. Scegli il nome del tuo flusso di lavoro. Puoi filtrare in base al nome del repository o del ramo di origine in cui è definito il flusso di lavoro oppure filtrare in base al nome o allo stato del flusso di lavoro.
1. Scegli **Modifica**.
1. Scegli **Visual**.
1. Scegli la tua **azione Deploy CloudFormation stack**.
1. **Nel riquadro dei dettagli, scegli Configurazione.**
1. In basso, espandi **Avanzate**.
1. In **Monitora allarme ARNs**, scegli **Aggiungi allarme**.
1. Inserisci le informazioni nei seguenti campi.
+ **Allarme ARN**
Specificare l'Amazon Resource Name (ARN) di un CloudWatch allarme Amazon da utilizzare come trigger di rollback. Ad esempio, `arn:aws:cloudwatch::123456789012:alarm/MyAlarm`. Puoi avere un massimo di cinque trigger di rollback.
**Nota**
Se specifichi un ARN di CloudWatch allarme, dovrai anche configurare autorizzazioni aggiuntive per abilitare l'azione di accesso. CloudWatch Per ulteriori informazioni, consulta [Configurazione dei rollback](#deploy-consumption-enable-alarms).
+ **Tempo di monitoraggio**
Specificare un periodo di tempo, da 0 a 180 minuti, durante il quale CloudFormation monitorare gli allarmi specificati. Il monitoraggio inizia *dopo che* tutte le risorse dello stack sono state distribuite. Se l'allarme si verifica entro il periodo di monitoraggio specificato, l'implementazione fallisce e CloudFormation ripristina l'intera operazione dello stack.
Impostazione predefinita: 0. CloudFormation monitora gli allarmi solo mentre le risorse dello stack vengono distribuite, non dopo.
------
#### [ YAML ]
**Per configurare i trigger di rollback per l'azione «Deploy stack» CloudFormation**
1. [Apri la console all'indirizzo https://codecatalyst.aws/. CodeCatalyst ](https://codecatalyst.aws/)
1. Scegliere il progetto.
1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.**
1. Scegli il nome di un flusso di lavoro che include l'azione ** CloudFormation Deploy** stack. È possibile filtrare in base al nome del repository o del ramo di origine in cui è definito il flusso di lavoro oppure filtrare in base al nome o allo stato del flusso di lavoro.
1. Scegli **Modifica**.
1. Scegli **YAML**.
1. Aggiungi le `monitor-timeout-in-minutes` proprietà `monitor-alarm-arns` and nel codice YAML per aggiungere i trigger di rollback. Per una spiegazione di ciascuna proprietà, vedere. [Azione 'Implementa CloudFormation stack' YAML](deploy-action-ref-cfn.md)
1. Nel ruolo specificato nella `role-arn` proprietà dell'azione **Deploy CloudFormation stack**, assicurati di includere l'**CloudWatchFullAccess**autorizzazione. Per informazioni sulla creazione di questo ruolo con le autorizzazioni appropriate, consulta. [Fase 2: Creare ruoli AWS](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles)
------
------
#### [ Visual ]
**Per disattivare i rollback per l'azione 'Deploy stack' CloudFormation**
1. [Apri la console all'indirizzo https://codecatalyst.aws/. CodeCatalyst ](https://codecatalyst.aws/)
1. Scegliere il progetto.
1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.**
1. Scegli il nome di un flusso di lavoro che include l'azione ** CloudFormation Deploy** stack. È possibile filtrare in base al nome del repository o del ramo di origine in cui è definito il flusso di lavoro oppure filtrare in base al nome o allo stato del flusso di lavoro.
1. Scegli **Modifica**.
1. Scegli **Visual**.
1. Scegli la tua **azione Deploy CloudFormation stack**.
1. **Nel riquadro dei dettagli, scegli Configurazione.**
1. In basso, espandi **Avanzate**.
1. Attiva **Disabilita il rollback.**
------
#### [ YAML ]
**Per disattivare i rollback per l'azione «Deploy stack» CloudFormation**
1. [Apri la console all'indirizzo https://codecatalyst.aws/. CodeCatalyst ](https://codecatalyst.aws/)
1. Scegliere il progetto.
1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.**
1. Scegli il nome di un flusso di lavoro che include l'azione ** CloudFormation Deploy** stack. È possibile filtrare in base al nome del repository o del ramo di origine in cui è definito il flusso di lavoro oppure filtrare in base al nome o allo stato del flusso di lavoro.
1. Scegli **Modifica**.
1. Scegli **YAML**.
1. Aggiungi la `disable-rollback: 1` proprietà nel codice YAML per interrompere i rollback. Per una spiegazione di questa proprietà, vedere. [Azione 'Implementa CloudFormation stack' YAML](deploy-action-ref-cfn.md)
------
# Variabili 'Deploy CloudFormation stack'
L'azione **Deploy CloudFormation stack** produce e imposta le seguenti variabili in fase di esecuzione. Queste sono note come variabili *predefinite*.
Per informazioni su come fare riferimento a queste variabili in un flusso di lavoro, vedere. [Utilizzo di variabili predefinite](workflows-using-predefined-variables.md)
| Chiave | Valore |
| --- | --- |
| piattaforma di distribuzione | Il nome della piattaforma di distribuzione. Codificato in. `AWS:CloudFormation` |
| region | Il codice regionale su Regione AWS cui è stato distribuito durante l'esecuzione del flusso di lavoro. Ad esempio: `us-west-2` |
| stack-id | L'Amazon Resource Name (ARN) dello stack distribuito. Ad esempio: `arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cfn-stack/6aad4380-100a-11ec-a10a-03b8a84d40df` |
# Azione 'Implementa CloudFormation stack' YAML
Di seguito è riportata la definizione YAML dell'azione ** CloudFormation Deploy** stack. Per informazioni su come utilizzare questa azione, consulta. [Implementazione di uno stack CloudFormation](deploy-action-cfn.md)
Questa definizione di azione esiste come sezione all'interno di un file di definizione del flusso di lavoro più ampio. Per ulteriori informazioni su questo file, consulta [Definizione YAML del flusso di lavoro](workflow-reference.md).
**Nota**
La maggior parte delle proprietà YAML che seguono hanno elementi dell'interfaccia utente corrispondenti nell'editor visivo. **Per cercare un elemento dell'interfaccia utente, usa Ctrl\$1F.** L'elemento verrà elencato con la proprietà YAML associata.
```
# The workflow definition starts here.
# See Proprietà di primo livello for details.
Name: MyWorkflow
SchemaVersion: 1.0
Actions:
# The action definition starts here.
DeployCloudFormationStack:
Identifier: aws/cfn-deploy@v1
DependsOn:
- build-action
Compute:
Type: EC2 | Lambda
Fleet: fleet-name
Timeout: timeout-minutes
Environment:
Name: environment-name
Connections:
- Name: account-connection-name
Role: DeployRole
Inputs:
Sources:
- source-name-1
Artifacts:
- CloudFormation-artifact
Configuration:
name: stack-name
region: us-west-2
template: template-path
role-arn: arn:aws:iam::123456789012:role/StackRole
capabilities: CAPABILITY_IAM,CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND
parameter-overrides: KeyOne=ValueOne,KeyTwo=ValueTwo | path-to-JSON-file
no-execute-changeset: 1|0
fail-on-empty-changeset: 1|0
disable-rollback: 1|0
termination-protection: 1|0
timeout-in-minutes: minutes
notification-arns: arn:aws:sns:us-east-1:123456789012:MyTopic,arn:aws:sns:us-east-1:123456789012:MyOtherTopic
monitor-alarm-arns: arn:aws:cloudwatch::123456789012:alarm/MyAlarm,arn:aws:cloudwatch::123456789012:alarm/MyOtherAlarm
monitor-timeout-in-minutes: minutes
tags: '[{"Key":"MyKey1","Value":"MyValue1"},{"Key":"MyKey2","Value":"MyValue2"}]'
```
## DeployCloudFormationStack
(Obbligatorio)
Specificare il nome dell'azione. Tutti i nomi delle azioni devono essere univoci all'interno del flusso di lavoro. I nomi delle azioni sono limitati a caratteri alfanumerici (a-z, A-Z, 0-9), trattini (-) e caratteri di sottolineatura (\$1). Gli spazi non sono consentiti. Non è possibile utilizzare le virgolette per abilitare caratteri e spazi speciali nei nomi delle azioni.
Default: `DeployCloudFormationStack_nn`.
Interfaccia utente corrispondente: scheda di configurazione/nome visualizzato **dell'azione**
## Identifier
(*DeployCloudFormationStack*/**Identifier**)
(Obbligatorio)
Identifica l'azione. Non modificate questa proprietà a meno che non vogliate cambiare la versione. Per ulteriori informazioni, consulta [Specificare la versione dell'azione da utilizzare](workflows-action-versions.md).
Default: `aws/cfn-deploy@v1`.
**Interfaccia utente corrispondente: Workflow diagram/ DeployCloudFormationStack \$1nn/ aws/cfn-deploy @v1 label**
## DependsOn
(*DeployCloudFormationStack*/**DependsOn**)
(Facoltativo)
Specificate un'azione, un gruppo di azioni o un gate che deve essere eseguito correttamente affinché questa azione venga eseguita.
Per ulteriori informazioni sulla funzionalità «dipende da», vedere. [Azioni di sequenziamento](workflows-depends-on.md)
**Interfaccia utente corrispondente: scheda Input/Dipende da - opzionale**
## Compute
(*DeployCloudFormationStack*/**Compute**)
(Facoltativo)
Il motore di calcolo utilizzato per eseguire le azioni del flusso di lavoro. È possibile specificare l'elaborazione a livello di flusso di lavoro o a livello di azione, ma non entrambi. Se specificata a livello di flusso di lavoro, la configurazione di calcolo si applica a tutte le azioni definite nel flusso di lavoro. A livello di flusso di lavoro, puoi anche eseguire più azioni sulla stessa istanza. Per ulteriori informazioni, consulta [Condivisione dell'elaborazione tra le azioni](compute-sharing.md).
Interfaccia utente corrispondente: *nessuna*
## Type
(*DeployCloudFormationStack*/Compute/**Type**)
(Obbligatorio se [Compute](#deploy.action.cfn.computename) incluso)
Il tipo di motore di calcolo. È possibile utilizzare uno dei seguenti valori:
+ **EC2** (editor visivo) o `EC2` (editor YAML)
Ottimizzato per la flessibilità durante le operazioni.
+ **Lambda** (editor visivo) o `Lambda` (editor YAML)
Velocità di avvio delle azioni ottimizzate.
Per ulteriori informazioni sui tipi di calcolo, consulta [Tipi di calcolo](workflows-working-compute.md#compute.types).
**Interfaccia utente corrispondente: configurazione tab/Advanced : opzionale/tipo di calcolo**
## Fleet
(*DeployCloudFormationStack*/Compute/**Fleet**)
(Facoltativo)
Specificate la macchina o il parco macchine che eseguiranno il flusso di lavoro o le azioni del flusso di lavoro. Con le flotte on-demand, all'avvio di un'azione, il flusso di lavoro fornisce le risorse necessarie e le macchine vengono distrutte al termine dell'azione. Esempi di flotte on-demand:,. `Linux.x86-64.Large` `Linux.x86-64.XLarge` Per ulteriori informazioni sulle flotte on-demand, vedere. [Proprietà del parco istanze on demand](workflows-working-compute.md#compute.on-demand)
Con le flotte assegnate, puoi configurare una serie di macchine dedicate per eseguire le azioni del flusso di lavoro. Queste macchine rimangono inattive, pronte a elaborare immediatamente le azioni. Per ulteriori informazioni sulle flotte rifornite, vedere. [Proprietà del parco istanze con provisioning](workflows-working-compute.md#compute.provisioned-fleets)
Se `Fleet` viene omesso, l'impostazione predefinita è. `Linux.x86-64.Large`
**Interfaccia utente corrispondente: Configurazione tab/Advanced : parco opzionale/di calcolo**
## Timeout
(*DeployCloudFormationStack*/**Timeout**)
(Facoltativo)
Specificate il periodo di tempo, in minuti (editor YAML) o in ore e minuti (editor visivo), che l'azione può essere eseguita prima che termini l'azione. CodeCatalyst Il minimo è 5 minuti e il massimo è descritto in. [Quote per i flussi di lavoro in CodeCatalyst](workflows-quotas.md) Il timeout predefinito è lo stesso del timeout massimo.
Interfaccia utente corrispondente: scheda di **configurazione/timeout** in minuti - opzionale
## Environment
(*DeployCloudFormationStack*/**Environment**)
(Obbligatorio)
Specificare l' CodeCatalyst ambiente da utilizzare con l'azione. L'azione si connette Account AWS all'Amazon VPC opzionale specificato nell'ambiente scelto. L'azione utilizza il ruolo IAM predefinito specificato nell'ambiente per connettersi a e utilizza il ruolo IAM specificato nella [connessione Amazon VPC](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) per connettersi ad Amazon VPC. Account AWS
**Nota**
Se il ruolo IAM predefinito non dispone delle autorizzazioni richieste dall'azione, puoi configurare l'azione per utilizzare un ruolo diverso. Per ulteriori informazioni, consulta [Modifica del ruolo IAM di un'azione](deploy-environments-switch-role.md).
Per ulteriori informazioni sugli ambienti, consulta [Implementazione in e Account AWS VPCs](deploy-environments.md) e[Creazione di un ambiente](deploy-environments-creating-environment.md).
**Interfaccia utente corrispondente: scheda di configurazione/ambiente**
## Name
(*DeployCloudFormationStack*/Environment/**Name**)
(Richiesto se [Environment](#deploy.action.cfn.environment) incluso)
Specificate il nome di un ambiente esistente che desiderate associare all'azione.
**Interfaccia utente corrispondente: scheda di configurazione/ambiente**
## Connections
(*DeployCloudFormationStack*/Environment/**Connections**)
(Facoltativo nelle versioni più recenti dell'azione; richiesto nelle versioni precedenti)
Specificare la connessione dell'account da associare all'azione. È possibile specificare al massimo una connessione a un account in`Environment`.
Se non si specifica una connessione all'account:
+ L'azione utilizza la Account AWS connessione e il ruolo IAM predefinito specificati nell'ambiente della CodeCatalyst console. Per informazioni sull'aggiunta di una connessione all'account e del ruolo IAM predefinito all'ambiente, consulta[Creazione di un ambiente](deploy-environments-creating-environment.md).
+ Il ruolo IAM predefinito deve includere le policy e le autorizzazioni richieste dall'azione. Per determinare quali sono tali politiche e autorizzazioni, consulta la descrizione della proprietà **Role nella documentazione** sulla definizione YAML dell'azione.
Per ulteriori informazioni sulle connessioni degli account, vedere. [Consentire l'accesso alle AWS risorse con connessione Account AWS](ipa-connect-account.md) Per informazioni sull'aggiunta di una connessione tramite account a un ambiente, vedere[Creazione di un ambiente](deploy-environments-creating-environment.md).
Interfaccia utente corrispondente: una delle seguenti a seconda della versione dell'azione:
+ (Versioni più recenti) tab/Environment/What La configurazione è attiva? *my-environment* **/three dot menu/ Cambia ruolo**
+ **(Versioni precedenti) Scheda di configurazione/' '/ connessione all'account Environment/account/role AWS **
## Name
(*DeployCloudFormationStack*/Environment/Connections/**Name**)
(Richiesto se incluso[Connections](#deploy.action.cfn.environment.connections))
Specificare il nome della connessione all'account.
Interfaccia utente corrispondente: una delle seguenti a seconda della versione dell'azione:
+ (Versioni più recenti) tab/Environment/What La configurazione è attiva? *my-environment* **/three dot menu/ Cambia ruolo**
+ **(Versioni precedenti) Scheda di configurazione/' '/ connessione all'account Environment/account/role AWS **
## Role
(*DeployCloudFormationStack*/Environment/Connections/**Role**)
(Richiesto se incluso[Connections](#deploy.action.cfn.environment.connections))
Specificate il nome del ruolo IAM **utilizzato dall'azione Deploy CloudFormation stack** per accedere AWS e al CloudFormation servizio. Assicurati di aver [aggiunto il ruolo al tuo CodeCatalyst spazio](ipa-connect-account-addroles.md) e che il ruolo includa le seguenti politiche.
Se non specifichi un ruolo IAM, l'azione utilizza il ruolo IAM predefinito elencato nell'[ambiente](deploy-environments.md) nella CodeCatalyst console. Se utilizzi il ruolo predefinito nell'ambiente, assicurati che abbia le seguenti politiche.
+ La seguente politica di autorizzazioni:
**avvertimento**
Limita le autorizzazioni a quelle mostrate nella seguente politica. L'utilizzo di un ruolo con autorizzazioni più ampie potrebbe rappresentare un rischio per la sicurezza.
**Nota**
La prima volta che il ruolo viene utilizzato, utilizza il seguente carattere jolly nell'informativa sulla politica delle risorse, quindi definisci la politica inserendo il nome della risorsa dopo che è disponibile.
```
"Resource": "*"
```
+ La seguente politica di fiducia personalizzata:
**Nota**
Puoi usare il `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo con questa azione, se lo desideri. Per ulteriori informazioni su questo ruolo, consulta [Creazione del **CodeCatalystWorkflowDevelopmentRole-*spaceName***ruolo per il tuo account e il tuo spazio](ipa-iam-roles.md#ipa-iam-roles-service-create). Tieni presente che il `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo dispone di autorizzazioni di accesso complete, il che può rappresentare un rischio per la sicurezza. Ti consigliamo di utilizzare questo ruolo solo in tutorial e scenari in cui la sicurezza è meno preoccupante.
Interfaccia utente corrispondente: una delle seguenti a seconda della versione di azione:
+ (Versioni più recenti) tab/Environment/What La configurazione è attiva? *my-environment* **/three dot menu/ Cambia ruolo**
+ **(Versioni precedenti) Scheda di configurazione/' '/ Ruolo Environment/account/role**
## Inputs
(*DeployCloudFormationStack*/**Inputs**)
(Facoltativo)
La `Inputs` sezione definisce i dati `DeployCloudFormationStack` necessari durante l'esecuzione di un flusso di lavoro.
**Nota**
Sono consentiti un massimo di quattro input (una fonte e tre artefatti) per ogni azione dello stack ** CloudFormation Deploy**.
Se è necessario fare riferimento a file che risiedono in input diversi (ad esempio una sorgente e un artefatto), l'input di origine è l'input principale e l'artefatto è l'input secondario. I riferimenti ai file negli input secondari richiedono un prefisso speciale per distinguerli dal primario. Per informazioni dettagliate, vedi [Esempio: riferimento a file in più artefatti](workflows-working-artifacts-ex.md#workflows-working-artifacts-ex-ref-file).
**Interfaccia utente corrispondente: scheda Ingressi**
## Sources
(*DeployCloudFormationStack*/Inputs/**Sources**)
(Richiesto se il AWS SAM modello CloudFormation o è archiviato in un repository di origine)
Se il AWS SAM modello CloudFormation o è archiviato in un repository di origine, specifica l'etichetta di tale repository di origine. Attualmente, l'unica etichetta supportata è. `WorkflowSource`
Se il AWS SAM modello CloudFormation o non è contenuto in un repository di origine, deve risiedere in un artefatto generato da un'altra azione o in un bucket Amazon S3.
Per ulteriori informazioni sulle origini, consulta [Connessione degli archivi di origine ai flussi di lavoro](workflows-sources.md).
**Interfaccia utente corrispondente: scheda Input/Sources - opzionale**
## Artifacts - input
(*DeployCloudFormationStack*/Inputs/**Artifacts**)
(Richiesto se il AWS SAM modello CloudFormation o è memorizzato in un elemento [di output di un'azione precedente](workflows-working-artifacts-output.md))
Se il AWS SAM modello CloudFormation o che desideri distribuire è contenuto in un artefatto generato da un'azione precedente, specifica quell'artefatto qui. Se il CloudFormation modello non è contenuto in un artefatto, deve risiedere nel repository di origine o in un bucket Amazon S3.
Per ulteriori informazioni sugli artefatti, inclusi esempi, consulta. [Condivisione di artefatti e file tra azioni](workflows-working-artifacts.md)
**Interfaccia utente corrispondente: scheda di configurazione/artefatti - opzionale**
## Configuration
(*DeployCloudFormationStack*/**Configuration**)
(Obbligatorio)
Una sezione in cui è possibile definire le proprietà di configurazione dell'azione.
Interfaccia utente corrispondente: scheda **Configurazione**
## name
(*DeployCloudFormationStack*/Configuration/**name**)
(Obbligatorio)
Specificate un nome per lo CloudFormation stack creato o aggiornato dall'azione **Deploy CloudFormation stack**.
**Interfaccia utente corrispondente: scheda di configurazione/nome dello stack**
## region
(*DeployCloudFormationStack*/Configuration/**region**)
(Obbligatorio)
Specificare Regione AWS in che modo verrà distribuito lo stack. Per un elenco dei codici regionali, consulta Endpoint [regionali](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes).
**Interfaccia utente corrispondente: scheda di configurazione/regione dello stack**
## template
(*DeployCloudFormationStack*/Configuration/**template**)
(Obbligatorio)
Specificate il nome e il percorso del file CloudFormation o AWS SAM del modello. Il modello può essere in formato JSON o YAML e può risiedere in un repository di origine, in un elemento di un'azione precedente o in un bucket Amazon S3. Se il file modello si trova in un repository o in un artefatto di origine, il percorso è relativo all'origine o alla radice dell'artefatto. Se il modello si trova in un bucket Amazon S3, il percorso è il valore dell'URL dell'**oggetto** del modello.
Esempi:
`./MyFolder/MyTemplate.json`
`MyFolder/MyTemplate.yml`
`https://MyBucket.s3.us-west-2.amazonaws.com/MyTemplate.yml`
**Nota**
Potrebbe essere necessario aggiungere un prefisso al percorso del file del modello per indicare in quale artefatto o fonte trovarlo. Per ulteriori informazioni, consultare [Riferimento ai file del repository di origine](workflows-sources-reference-files.md) e [Riferimento ai file in un artefatto](workflows-working-artifacts-refer-files.md).
**Interfaccia utente corrispondente: scheda di configurazione/modello**
## role-arn
(*DeployCloudFormationStack*/Configuration/**role-arn**)
(Obbligatorio)
Specificare l'Amazon Resource Name (ARN) del ruolo dello stack. CloudFormation utilizza questo ruolo per accedere e modificare le risorse del tuo stack. Ad esempio: `arn:aws:iam::123456789012:role/StackRole`.
Assicurati che il ruolo dello stack includa:
+ Una o più politiche di autorizzazione. Le politiche dipendono dalle risorse presenti nello stack. Ad esempio, se lo stack include una AWS Lambda funzione, devi aggiungere le autorizzazioni che concedono l'accesso a Lambda. Se hai seguito il tutorial descritto in[Tutorial: Implementazione di un'applicazione serverless](deploy-tut-lambda.md), include una procedura intitolata, [Per creare un ruolo stack](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles-stack) che elenca le autorizzazioni necessarie allo stack role se stai distribuendo un tipico stack di applicazioni serverless.
**avvertimento**
Limita le autorizzazioni a quelle richieste dal CloudFormation servizio per accedere alle risorse del tuo stack. L'utilizzo di un ruolo con autorizzazioni più ampie potrebbe rappresentare un rischio per la sicurezza.
+ La seguente politica di fiducia:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "cloudformation.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Facoltativamente, associa questo ruolo alla connessione del tuo account. Per ulteriori informazioni sull'associazione di un ruolo IAM a una connessione all'account, consulta. [Aggiunta di ruoli IAM alle connessioni degli account](ipa-connect-account-addroles.md) Se non associ il ruolo dello stack alla connessione dell'account, il ruolo dello stack non verrà visualizzato nell'elenco a discesa del **ruolo Stack** nell'editor visivo; tuttavia, il ruolo ARN può ancora essere specificato nel campo utilizzando l'editor YAML. `role-arn`
**Nota**
Puoi usare il `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo con questa azione, se lo desideri. Per ulteriori informazioni su questo ruolo, consulta [Creazione del **CodeCatalystWorkflowDevelopmentRole-*spaceName***ruolo per il tuo account e il tuo spazio](ipa-iam-roles.md#ipa-iam-roles-service-create). Tieni presente che il `CodeCatalystWorkflowDevelopmentRole-spaceName` ruolo dispone di autorizzazioni di accesso complete, il che può rappresentare un rischio per la sicurezza. Ti consigliamo di utilizzare questo ruolo solo in tutorial e scenari in cui la sicurezza è meno preoccupante.
Interfaccia utente corrispondente: scheda di configurazione/ruolo **Stack - opzionale**
## capabilities
(*DeployCloudFormationStack*/Configuration/**capabilities**)
(Obbligatorio)
Specificate un elenco di funzionalità IAM necessarie per consentire la creazione CloudFormation di determinati stack. Nella maggior parte dei casi, puoi lasciare `capabilities` il valore predefinito di`CAPABILITY_IAM,CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND`.
Se vedi `##[error] requires capabilities: [capability-name]` nei log delle azioni ** CloudFormation dello stack Deploy**, consulta [Come posso correggere gli errori relativi alle funzionalità IAM?](troubleshooting-workflows.md#troubleshooting-workflows-capabilities) per informazioni su come risolvere il problema.
*Per ulteriori informazioni sulle funzionalità IAM, consulta [Riconoscere le risorse IAM nei CloudFormation modelli nella Guida](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#using-iam-capabilities) per l'utente IAM.*
**Interfaccia utente corrispondente: Configuration Tab/Advanced/ Capabilities**
## parameter-overrides
(*DeployCloudFormationStack*/Configuration/**parameter-overrides**)
(Facoltativo)
Specificate i parametri nel vostro AWS SAM modello CloudFormation o che non hanno valori predefiniti o per i quali desiderate specificare valori non predefiniti. Per ulteriori informazioni sui parametri, consultate [Parametri](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html) nella *Guida per l' AWS CloudFormation utente*.
La `parameter-overrides` proprietà accetta:
+ Un file JSON contenente i parametri e i valori.
+ Un elenco di parametri e valori separati da virgole.
**Per specificare un file JSON**
1. Assicurati che il file JSON utilizzi una delle seguenti sintassi:
```
{
"Parameters": {
"Param1": "Value1",
"Param2": "Value2",
...
}
}
```
Oppure...
```
[
{
"ParameterKey": "Param1",
"ParameterValue": "Value1"
},
...
]
```
(Esistono altre sintassi, ma non sono supportate da CodeCatalyst al momento della scrittura.) *Per ulteriori informazioni sulla specificazione CloudFormation dei parametri in un file JSON, vedete [Sintassi JSON supportata nel Command Reference](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/cloudformation/deploy/index.html#supported-json-syntax).AWS CLI *
1. Specificate il percorso del file JSON utilizzando uno dei seguenti formati:
+ Se il tuo file JSON si trova in un elemento di output di un'azione precedente, usa:
`file:///artifacts/current-action-name/output-artifact-name/path-to-json-file`
Vedi l'**Esempio 1 per i dettagli**.
+ Se il tuo file JSON si trova nel tuo repository di origine, usa:
`file:///sources/WorkflowSource/path-to-json-file`
Vedi l'**Esempio 2** per i dettagli.
**Esempio 1**: il file JSON risiede in un artefatto di output
```
##My workflow YAML
...
Actions:
MyBuildAction:
Identifier: aws/build@v1
Outputs:
Artifacts:
- Name: ParamArtifact
Files:
- params.json
Configuration:
...
MyDeployCFNStackAction:
Identifier: aws/cfn-deploy@v1
Configuration:
parameter-overrides: file:///artifacts/MyDeployCFNStackAction/ParamArtifact/params.json
```
**Esempio 2**: il file JSON si trova nell'archivio di origine, in una cartella denominata `my/folder`
```
##My workflow YAML
...
Actions:
MyDeployCloudFormationStack:
Identifier: aws/cfn-deploy@v1
Inputs:
Sources:
- WorkflowSource
Configuration:
parameter-overrides: file:///sources/WorkflowSource/my/folder/params.json
```
**Per utilizzare un elenco di parametri separati da virgole**
+ Aggiungere coppie nome-valore dei parametri nella `parameter-overrides` proprietà utilizzando il seguente formato:
`param-1=value-1,param-2=value-2`
Ad esempio, supponendo il seguente modello: CloudFormation
```
##My CloudFormation template
Description: My CloudFormation template
Parameters:
InstanceType:
Description: Defines the Amazon EC2 compute for the production server.
Type: String
Default: t2.micro
AllowedValues:
- t2.micro
- t2.small
- t3.medium
Resources:
...
```
... potresti impostare la `parameter-overrides` proprietà come segue:
```
##My workflow YAML
...
Actions:
...
DeployCloudFormationStack:
Identifier: aws/cfn-deploy@v1
Configuration:
parameter-overrides: InstanceType=t3.medium,UseVPC=true
```
**Nota**
È possibile specificare il nome di un parametro senza un valore corrispondente `undefined` da utilizzare come valore. Esempio:
`parameter-overrides: MyParameter=undefined`
L'effetto è che durante un aggiornamento dello stack, CloudFormation utilizza il valore del parametro esistente per il nome del parametro specificato.
Interfaccia utente corrispondente:
+ **Scheda di configurazione/Avanzata/ Sostituzioni dei parametri**
+ **Sostituzioni di configurazione/ Specificare le sostituzioni utilizzando un file tab/Advanced/Parameter**
+ **Sostituzioni di configurazione/ tab/Advanced/Parameter Specificare le sostituzioni utilizzando un set di valori**
## no-execute-changeset
(*DeployCloudFormationStack*/Configuration/**no-execute-changeset**)
(Facoltativo)
Specificate se desiderate creare il set CodeCatalyst di CloudFormation modifiche e quindi interromperlo prima di eseguirlo. In questo modo è possibile rivedere il set di modifiche nella CloudFormation console. Se ritieni che il set di modifiche abbia un bell'aspetto, disabilita questa opzione e quindi riesegui il flusso di lavoro in modo da CodeCatalyst poter creare ed eseguire il set di modifiche senza interruzioni. L'impostazione predefinita prevede la creazione e l'esecuzione del set di modifiche senza interruzioni. Per ulteriori informazioni, vedete il parametro CloudFormation [deploy](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) nel *AWS CLI Command* Reference. Per ulteriori informazioni sulla visualizzazione dei set di modifiche, vedere [Visualizzazione di un set di modifiche](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets-view.html) nella *Guida per l'AWS CloudFormation utente*.
**Interfaccia utente corrispondente: scheda Configurazione/Avanzata/ Nessun set di modifiche da eseguire**
## fail-on-empty-changeset
(*DeployCloudFormationStack*/Configuration/**fail-on-empty-changeset**)
(Facoltativo)
Specificate se desiderate fallire CodeCatalyst l'azione **Deploy CloudFormation stack** se il set di modifiche è vuoto. CloudFormation (Se un set di modifiche è vuoto, significa che non sono state apportate modifiche allo stack durante l'ultima distribuzione.) L'impostazione predefinita prevede il proseguimento dell'azione se il set di modifiche è vuoto e la restituzione di un `UPDATE_COMPLETE` messaggio anche se lo stack non è stato aggiornato.
Per ulteriori informazioni su questa impostazione, vedete il parametro CloudFormation [deploy](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) nel *AWS CLI Command* Reference. Per ulteriori informazioni sui set di modifiche, vedere [Aggiornamento degli stack utilizzando i set di modifiche nella Guida](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets.html) per l'*AWS CloudFormation utente*.
**Interfaccia utente corrispondente: Configuration tab/Advanced/ Fail su changeset vuoto**
## disable-rollback
(*DeployCloudFormationStack*/Configuration/**disable-rollback**)
(Facoltativo)
Specificate se desiderate CodeCatalyst ripristinare la distribuzione dello stack se fallisce. Il rollback riporta lo stack all'ultimo stato stabile conosciuto. L'impostazione predefinita è abilitare i rollback. Per ulteriori informazioni su questa impostazione, vedete il parametro CloudFormation [deploy](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) nel *AWS CLI Command* Reference.
Per ulteriori informazioni su come l'azione **Deploy CloudFormation stack** gestisce i rollback, consulta. [Configurazione dei rollback](deploy-consumption-enable-alarms.md)
*Per ulteriori informazioni sul rollback di uno stack, consulta [Stack failure options](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stack-failure-options.html) nella Guida per l'utente.AWS CloudFormation *
**Interfaccia utente corrispondente: scheda Configurazione/Avanzata/ Disabilita il rollback**
## termination-protection
(*DeployCloudFormationStack*/Configuration/**termination-protection**)
(Facoltativo)
Specificate se desiderate che lo stack **Deploy aggiunga la protezione dalla terminazione allo CloudFormation stack** che sta distribuendo. Se un utente tenta di eliminare uno stack con protezione da cessazione abilitata, l’eliminazione ha esito negativo e lo stack, incluso lo stato, rimane invariato. L'impostazione predefinita è disabilitare la protezione dalla terminazione. Per ulteriori informazioni, consulta [Proteggere uno stack dall'eliminazione nella Guida](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html) per l'*AWS CloudFormation utente*.
**Interfaccia utente corrispondente: scheda di configurazione/Avanzata/Protezione da terminazione**
## timeout-in-minutes
(*DeployCloudFormationStack*/Configuration/**timeout-in-minutes**)
(Facoltativo)
Specificate la quantità di tempo, in minuti, da dedicare prima di scadere le CloudFormation operazioni di creazione dello stack e impostare lo stato dello stack su. `CREATE_FAILED` Se CloudFormation non è in grado di creare l'intero stack nel tempo assegnato, produce un errore di timeout ed esegue il rollback dello stack.
Per impostazione predefinita, non è previsto alcun timeout per la creazione dello stack. Tuttavia, per la natura del servizio che implementano, alcune singole risorse possono avere un proprio timeout. Ad esempio, se una singola risorsa nello stack produce un timeout, anche la creazione dello stack viene arrestata, anche se il timeout specificato per la creazione dello stack non è ancora stato raggiunto.
**Interfaccia utente corrispondente: scheda Configurazione/Avanzata/timeout CloudFormation**
## notification-arns
(*DeployCloudFormationStack*/Configuration/**notification-arns**)
(Facoltativo)
Specificate l'ARN di un argomento Amazon SNS a cui CodeCatalyst desiderate inviare messaggi di notifica. Ad esempio, `arn:aws:sns:us-east-1:111222333:MyTopic`. Quando viene eseguita l'azione **Deploy CloudFormation stack**, si CodeCatalyst coordina con CloudFormation per inviare una notifica per CloudFormation evento che si verifica durante il processo di creazione o aggiornamento dello stack. (Gli eventi sono visibili nella scheda **Eventi** della CloudFormation console relativa allo stack.) È possibile specificare fino a cinque argomenti. Per ulteriori informazioni, consulta [Cos'è Amazon SNS?](https://docs.aws.amazon.com/sns/latest/dg/welcome.html)
**Interfaccia utente corrispondente: scheda Configurazione/Avanzata/Notifica ARNs**
## monitor-alarm-arns
(*DeployCloudFormationStack*/Configuration/**monitor-alarm-arns**)
(Facoltativo)
Specificare l'Amazon Resource Name (ARN) di un CloudWatch allarme Amazon da utilizzare come trigger di rollback. Ad esempio, `arn:aws:cloudwatch::123456789012:alarm/MyAlarm`. Puoi avere un massimo di cinque trigger di rollback.
**Nota**
Se specifichi un ARN di CloudWatch allarme, dovrai anche configurare autorizzazioni aggiuntive per abilitare l'azione di accesso. CloudWatch Per ulteriori informazioni, consulta [Configurazione dei rollback](deploy-consumption-enable-alarms.md).
**Interfaccia utente corrispondente: scheda di configurazione/Avanzata/Monitor alarm ARNs**
## monitor-timeout-in-minutes
(*DeployCloudFormationStack*/Configuration/**monitor-timeout-in-minutes**)
(Facoltativo)
Specificare un periodo di tempo, da 0 a 180 minuti, durante il quale CloudFormation monitorare gli allarmi specificati. Il monitoraggio inizia *dopo che* tutte le risorse dello stack sono state distribuite. Se l'allarme si verifica entro il periodo di monitoraggio specificato, l'implementazione fallisce e CloudFormation ripristina l'intera operazione dello stack.
Impostazione predefinita: 0. CloudFormation monitora gli allarmi solo mentre le risorse dello stack vengono distribuite, non dopo.
**Interfaccia utente corrispondente: scheda Configurazione/Avanzata/Tempo di monitoraggio**
## tags
(*DeployCloudFormationStack*/Configuration/**tags**)
(Facoltativo)
Specificate i tag da allegare allo stack. CloudFormation I tag sono coppie chiave-valore arbitrarie che è possibile utilizzare per identificare lo stack per scopi quali l'allocazione dei costi. Per ulteriori informazioni sui tag e su come possono essere utilizzati, consulta l'argomento relativo al [tagging delle risorse](https://docs.aws.amazon.com/) nella *Guida per l'utente di Amazon EC2*. *Per ulteriori informazioni sull'inserimento dei tag CloudFormation, consulta [Impostazione delle opzioni CloudFormation dello stack](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-add-tags.html) nella Guida per l'utente.AWS CloudFormation *
Una chiave può contenere caratteri alfanumerici o spazi e può contenere fino a 127 caratteri. Un valore può contenere caratteri alfanumerici o spazi e può contenere fino a 255 caratteri.
È possibile aggiungere fino a 50 tag univoci per ogni stack.
**Interfaccia utente corrispondente: Configuration Tab/Advanced/ Tags**