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à.
# 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)