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à.
# Riferimento per la struttura delle operazioni
Questa sezione è un riferimento solo per la configurazione dell'operazione. Per una panoramica dei concetti di base della struttura della pipeline, consulta [CodePipeline riferimento alla struttura della tubazione](reference-pipeline-structure.md).
Ogni provider di azioni CodePipeline utilizza un set di campi di configurazione obbligatori e opzionali nella struttura della pipeline. Questa sezione fornisce le seguenti informazioni di riferimento in base al provider di operazione:
+ Valori validi per i campi `ActionType` inclusi nel blocco dell'operazione della struttura della pipeline, ad esempio `Owner` e `Provider`.
+ Descrizioni e altre informazioni di riferimento per i parametri `Configuration` (obbligatori e facoltativi) inclusi nella sezione relativa all'operazione della struttura della pipeline.
+ Campi delle operazioni JSON e YAML di esempio validi.
Questa sezione viene aggiornata periodicamente con più provider di operazione. Le informazioni di riferimento sono attualmente disponibili per i seguenti provider di operazione:
**Topics**
+ [Riferimento all'azione di Amazon EC2](action-reference-EC2Deploy.md)
+ [Riferimento all'azione sorgente di Amazon ECR](action-reference-ECR.md)
+ [`ECRBuildAndPublish`crea un riferimento all'azione](action-reference-ECRBuildAndPublish.md)
+ [Riferimento sulle azioni di distribuzione di Amazon ECS e CodeDeploy blue-green](action-reference-ECSbluegreen.md)
+ [Riferimento all'azione di distribuzione di Amazon Elastic Container Service](action-reference-ECS.md)
+ [Riferimento all'azione di distribuzione di Amazon Elastic Kubernetes Service `EKS`](action-reference-EKS.md)
+ [AWS Lambda distribuisci un riferimento all'azione](action-reference-LambdaDeploy.md)
+ [Riferimento alle azioni di distribuzione di Amazon S3](action-reference-S3Deploy.md)
+ [Riferimento all'azione del codice sorgente di Amazon S3](action-reference-S3.md)
+ [AWS AppConfig distribuisci un riferimento all'azione](action-reference-AppConfig.md)
+ [CloudFormation distribuisci un riferimento all'azione](action-reference-CloudFormation.md)
+ [CloudFormation StackSets](action-reference-StackSets.md)
+ [AWS CodeBuild riferimento all'azione di compilazione e test](action-reference-CodeBuild.md)
+ [AWS CodePipeline invoca un riferimento all'azione](action-reference-PipelineInvoke.md)
+ [AWS CodeCommit riferimento all'azione di origine](action-reference-CodeCommit.md)
+ [AWS CodeDeploy distribuisci un riferimento all'azione](action-reference-CodeDeploy.md)
+ [CodeStarSourceConnection per Bitbucket Cloud, GitHub Enterprise Server GitHub, .com e azioni autogestite GitLab GitLab](action-reference-CodestarConnectionSource.md)
+ [Comandi, azione, riferimento](action-reference-Commands.md)
+ [AWS Device Farm riferimento all'azione di test](action-reference-DeviceFarm.md)
+ [Riferimento all'azione di distribuzione di Elastic Beanstalk](action-reference-Beanstalk.md)
+ [Riferimento all'azione di richiamo di Amazon `InspectorScan` Inspector](action-reference-InspectorScan.md)
+ [AWS Lambda invoca un riferimento all'azione](action-reference-Lambda.md)
+ [AWS OpsWorks distribuisci un riferimento all'azione](action-reference-OpsWorks.md)
+ [AWS Service Catalog distribuisci un riferimento all'azione](action-reference-ServiceCatalog.md)
+ [AWS Step Functions](action-reference-StepFunctions.md)
# Riferimento all'azione di Amazon EC2
Utilizzi un'`EC2`azione Amazon EC2 per distribuire il codice dell'applicazione nella tua flotta di distribuzione. La tua flotta di implementazione può essere composta da istanze Amazon EC2 Linux o nodi gestiti da Linux SSM. Sulle istanze deve essere installato l'agente SSM.
**Nota**
Questa azione supporta solo i tipi di istanze Linux. La dimensione massima del parco istanze supportata è di 500 istanze.
L'azione sceglierà un numero di istanze in base a un massimo specificato. Le istanze fallite delle istanze precedenti verranno scelte per prime. L'azione salterà la distribuzione su determinate istanze se l'istanza ha già ricevuto la distribuzione dello stesso elemento di input, ad esempio in un caso in cui l'azione non è riuscita in precedenza.
**Nota**
Questa azione è supportata solo per le pipeline di tipo V2.
**Topics**
+ [Tipo di operazione](#action-reference-EC2Deploy-type)
+ [Parametri di configurazione](#action-reference-EC2Deploy-parameters)
+ [Input artifact (Artefatti di input)](#action-reference-EC2Deploy-input)
+ [Artefatti di output](#action-reference-EC2Deploy-output)
+ [Autorizzazioni relative alla policy del ruolo di servizio per l'azione di implementazione di EC2](#action-reference-EC2Deploy-permissions-action)
+ [Distribuisci il riferimento al file delle specifiche](#action-reference-EC2Deploy-spec-reference)
+ [Dichiarazione dell'operazione](#action-reference-EC2Deploy-example)
+ [Dichiarazione di azione con esempio di specifiche Deploy](#action-reference-EC2Deploy-example-spec)
+ [Consulta anche](#action-reference-EC2Deploy-links)
## Tipo di operazione
+ Categoria: `Deploy`
+ Proprietario: `AWS`
+ Provider: `EC2`
+ Versione: `1`
## Parametri di configurazione
**InstanceTagKey**
Obbligatorio: sì
La chiave tag delle istanze che hai creato in Amazon EC2, ad esempio. `Name`
**InstanceTagValue**
Obbligatorio: no
Il valore del tag delle istanze che hai creato in Amazon EC2, ad esempio. `my-instances`
Quando questo valore non è specificato, tutte le istanze con **InstanceTagKey**verranno abbinate.
**InstanceType**
Obbligatorio: sì
Il tipo di istanze o nodi SSM creati in Amazon EC2. I valori validi sono `EC2` e `SSM_MANAGED_NODE`.
È necessario aver già creato, etichettato e installato l'agente SSM su tutte le istanze.
Quando crei l'istanza, crei o utilizzi un ruolo di istanza EC2 esistente. Per evitare `Access Denied` errori, devi aggiungere le autorizzazioni del bucket S3 al ruolo dell'istanza per assegnare le autorizzazioni dell'istanza al bucket di artefatti. CodePipeline Crea un ruolo predefinito o aggiorna il tuo ruolo esistente con l'`s3:GetObject`autorizzazione limitata al bucket di artefatti per la regione della tua pipeline.
**TargetDirectory**
Obbligatorio: Sì (se è specificato uno script)
La directory da utilizzare sull'istanza Amazon EC2 per eseguire gli script.
**DeploySpec**
Obbligatorio: Sì (se sono specificate le specifiche di distribuzione)
Il file da utilizzare per configurare gli eventi di distribuzione, installazione e ciclo di vita. Per le descrizioni e le informazioni sui campi delle specifiche di distribuzione, vedere. [Distribuisci il riferimento al file delle specifiche](#action-reference-EC2Deploy-spec-reference) Per visualizzare una configurazione di azione con il file deploy spec specificato, consulta l'esempio in. [Dichiarazione di azione con esempio di specifiche Deploy](#action-reference-EC2Deploy-example-spec)
**MaxBatch**
Obbligatorio: no
Il numero massimo di istanze consentite per l'implementazione in parallelo.
**MaxError**
Obbligatorio: no
Il numero massimo di errori di istanza consentiti durante la distribuzione.
**TargetGroupNameList**
Obbligatorio: no
L'elenco dei nomi dei gruppi target per la distribuzione. È necessario aver già creato i gruppi target.
I gruppi target forniscono una serie di istanze per elaborare richieste specifiche. Se viene specificato il gruppo target, le istanze verranno rimosse dal gruppo di destinazione prima della distribuzione e aggiunte nuovamente al gruppo di destinazione dopo la distribuzione.
**PreScript**
Obbligatorio: no
Lo script da eseguire prima della fase di azione Deploy.
**PostScript**
Obbligatorio: sì
Lo script da eseguire dopo la fase di azione Deploy.
L'immagine seguente mostra un esempio della pagina **Modifica** per l'azione in cui è stata scelta **Use action configurations**.
![\[La pagina Modifica azione per una nuova pipeline con l'azione EC2 Distribuisci che specifica l'utilizzo della configurazione dell'azione\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/ec2deploy-action.png)
L'immagine seguente mostra un esempio della pagina **Modifica** per l'azione in cui è stato scelto **Usa un DeploySpec file**.
![\[La pagina Modifica azione per una nuova pipeline con l'opzione di azione EC2 Deploy per utilizzare un file di specifiche\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/ec2deploy-action-spec.png)
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1`
+ **Descrizione:** i file forniti, se presenti, per supportare le azioni dello script durante la distribuzione.
## Artefatti di output
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di output non si applicano a questo tipo di azione.
## Autorizzazioni relative alla policy del ruolo di servizio per l'azione di implementazione di EC2
Quando CodePipeline esegue l'azione, il ruolo di CodePipeline servizio richiede le seguenti autorizzazioni, specificate in modo appropriato per l'accesso con il minimo privilegio.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "StatementWithAllResource",
"Effect": "Allow",
"Action": [
"ec2:DescribeInstances",
"elasticloadbalancing:DescribeTargetGroupAttributes",
"elasticloadbalancing:DescribeTargetGroups",
"elasticloadbalancing:DescribeTargetHealth",
"ssm:CancelCommand",
"ssm:DescribeInstanceInformation",
"ssm:ListCommandInvocations"
],
"Resource": [
"*"
]
},
{
"Sid": "StatementForLogs",
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/aws/codepipeline/{{pipelineName}}:*"
]
},
{
"Sid": "StatementForElasticloadbalancing",
"Effect": "Allow",
"Action": [
"elasticloadbalancing:DeregisterTargets",
"elasticloadbalancing:RegisterTargets"
],
"Resource": [
"arn:aws:elasticloadbalancing:us-east-1:111122223333:targetgroup/[[targetGroupName]]/*"
]
},
{
"Sid": "StatementForSsmOnTaggedInstances",
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ec2:us-east-1:111122223333:instance/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceTag/{{tagKey}}": "{{tagValue}}"
}
}
},
{
"Sid": "StatementForSsmApprovedDocuments",
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ssm:us-east-1::document/AWS-RunPowerShellScript",
"arn:aws:ssm:us-east-1::document/AWS-RunShellScript"
]
}
]
}
```
------
### Registra i gruppi per la tua pipeline nei log CloudWatch
Quando CodePipeline esegue l'azione, CodePipeline crea un gruppo di log utilizzando il nome della pipeline come segue. Ciò consente di ridurre l'ambito delle autorizzazioni per registrare le risorse utilizzando il nome della pipeline.
```
/aws/codepipeline/MyPipelineName
```
Le seguenti autorizzazioni per la registrazione sono incluse negli aggiornamenti precedenti per il ruolo di servizio.
+ registri: CreateLogGroup
+ registri: CreateLogStream
+ registri: PutLogEvents
Per visualizzare i log nella console utilizzando la pagina di dialogo dei dettagli dell'azione, è necessario aggiungere l'autorizzazione alla visualizzazione dei log al ruolo della console. Per ulteriori informazioni, consulta l'esempio di policy sulle autorizzazioni della console in. [Autorizzazioni necessarie per visualizzare i log di calcolo nella console](security-iam-permissions-console-logs.md)
### Autorizzazioni relative ai criteri dei ruoli di servizio per i registri CloudWatch
Quando CodePipeline esegue l'azione, CodePipeline crea un gruppo di log utilizzando il nome della pipeline come segue. Ciò consente di ridurre l'ambito delle autorizzazioni per registrare le risorse utilizzando il nome della pipeline.
```
/aws/codepipeline/MyPipelineName
```
Per visualizzare i log nella console utilizzando la pagina di dialogo dei dettagli dell'azione, è necessario aggiungere l'autorizzazione per visualizzare i log al ruolo della console. Per ulteriori informazioni, consulta l'esempio di policy sulle autorizzazioni della console in. [Autorizzazioni necessarie per visualizzare i log di calcolo nella console](security-iam-permissions-console-logs.md)
## Distribuisci il riferimento al file delle specifiche
Quando si CodePipeline esegue l'azione, è possibile specificare un file di specifiche per configurare la distribuzione nelle istanze. Il file deploy spec specifica cosa installare e quali hook di eventi del ciclo di vita eseguire in risposta agli eventi del ciclo di vita della distribuzione. Il file deploy spec è sempre in formato YAML. Il file deploy spec viene utilizzato per:
+ Mappare i file sorgente nella revisione dell'applicazione nelle loro destinazioni sull'istanza.
+ Specificare autorizzazioni personalizzate per i file distribuiti.
+ Specificare script da eseguire su ciascuna istanza in diverse fasi del processo di distribuzione.
Il file deploy spec supporta parametri di configurazione di distribuzione specifici supportati dal CodeDeploy file. AppSpec È possibile utilizzare direttamente il AppSpec file esistente e tutti i parametri non supportati verranno ignorati. Per ulteriori informazioni sul AppSpec file in CodeDeploy, consultate il riferimento al file delle specifiche dell'applicazione nella Guida per l'*[CodeDeploy](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)utente*.
I parametri di distribuzione dei file sono specificati come segue.
+ `files`- Il file deploy spec indica l'`source:`e `destination:` per i file di distribuzione.
+ `scripts`- Gli eventi programmati per la distribuzione. Sono supportati due eventi: `BeforeDeploy` e`AfterDeploy`.
+ `hooks`- I ganci del ciclo di vita dell'evento. Sono supportati i seguenti hook:`ApplicationStop`,,`BeforeInstall`, `AfterInstall` e. `ApplicationStart` `ValidateService`
**Nota**
Il parametro hooks è disponibile per AppSpec compatibilità con CodeDeploy ed è disponibile solo nella versione 0.0 (AppSpec formato). Per questo formato, CodePipeline eseguirà al meglio la mappatura degli eventi.
È necessario utilizzare la spaziatura YAML corretta nel file spec; in caso contrario, viene generato un errore se le posizioni e il numero di spazi in un file di spec di distribuzione non sono corretti. Per ulteriori informazioni sulla spaziatura, consulta la specifica [YAML](http://www.yaml.org/).
Di seguito è riportato un esempio di file deploy spec.
```
version: 0.1
files:
- source: /index.html
destination: /var/www/html/
scripts:
BeforeDeploy:
- location: scripts/install_dependencies
timeout: 300
runas: myuser
AfterDeploy:
- location: scripts/start_server
timeout: 300
runas: myuser
```
Per visualizzare una configurazione di azione con il file deploy spec specificato, vedi l'esempio in. [Dichiarazione di azione con esempio di specifiche Deploy](#action-reference-EC2Deploy-example-spec)
## Dichiarazione dell'operazione
------
#### [ YAML ]
```
name: DeployEC2
actions:
- name: EC2
actionTypeId:
category: Deploy
owner: AWS
provider: EC2
version: '1'
runOrder: 1
configuration:
InstanceTagKey: Name
InstanceTagValue: my-instances
InstanceType: EC2
PostScript: "test/script.sh",
TargetDirectory: "/home/ec2-user/deploy"
outputArtifacts: []
inputArtifacts:
- name: SourceArtifact
region: us-east-1
```
------
#### [ JSON ]
```
{
"name": "DeployEC2",
"actions": [
{
"name": "EC2Deploy",
"actionTypeId": {
"category": "Deploy",
"owner": "AWS",
"provider": "EC2",
"version": "1"
},
"runOrder": 1,
"configuration": {
"InstanceTagKey": "Name",
"InstanceTagValue": "my-instances",
"InstanceType": "EC2",
"PostScript": "test/script.sh",
"TargetDirectory": "/home/ec2-user/deploy"
},
"outputArtifacts": [],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-east-1"
}
]
},
```
------
## Dichiarazione di azione con esempio di specifiche Deploy
------
#### [ YAML ]
```
name: DeployEC2
actions:
- name: EC2
actionTypeId:
category: Deploy
owner: AWS
provider: EC2
version: '1'
runOrder: 1
configuration:
DeploySpec: "deployspec.yaml"
InstanceTagKey: Name
InstanceTagValue: my-instances
InstanceType: EC2
outputArtifacts: []
inputArtifacts:
- name: SourceArtifact
region: us-east-1
```
------
#### [ JSON ]
```
{
"name": "DeployEC2",
"actions": [
{
"name": "EC2Deploy",
"actionTypeId": {
"category": "Deploy",
"owner": "AWS",
"provider": "EC2",
"version": "1"
},
"runOrder": 1,
"configuration": {
"DeploySpec": "deployspec.yaml",
"InstanceTagKey": "Name",
"InstanceTagValue": "my-instances",
"InstanceType": "EC2"
},
"outputArtifacts": [],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-east-1"
}
]
},
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Tutorial: Esegui la distribuzione su istanze Amazon EC2 con CodePipeline](tutorials-ec2-deploy.md)— Questo tutorial ti guida attraverso la creazione di un'istanza EC2 in cui distribuirai un file di script, insieme alla creazione della pipeline utilizzando l'azione EC2.
+ [L'azione EC2 Deploy fallisce e viene visualizzato un messaggio di errore `No such file`](troubleshooting.md#troubleshooting-ec2-deploy)— Questo argomento descrive la risoluzione degli errori relativi ai file non trovati con l'azione EC2.
# Riferimento all'azione sorgente di Amazon ECR
Attiva la pipeline quando una nuova immagine viene inviata al repository Amazon ECR. Questa azione fornisce un file di definizioni delle immagini che fa riferimento all'URI per l'immagine che è stata inviata ad Amazon ECR. Questa azione sorgente viene spesso utilizzata in combinazione con un'altra azione sorgente, ad esempio CodeCommit, per consentire una posizione di origine per tutti gli altri artefatti di origine. Per ulteriori informazioni, consulta [Tutorial: crea una pipeline con una sorgente e una distribuzione Amazon ECR ECS-to-CodeDeploy](tutorials-ecs-ecr-codedeploy.md).
Quando usi la console per creare o modificare la pipeline, CodePipeline crea una EventBridge regola che avvia la pipeline quando si verifica una modifica nel repository.
**Nota**
Per Amazon ECR, Amazon S3 CodeCommit o sorgenti, puoi anche creare un'override di origine utilizzando input transform entry per utilizzare l' EventBridge in per `revisionValue` il tuo evento pipeline, dove è derivato dalla variabile `revisionValue` dell'evento source per la chiave oggetto, il commit o l'ID immagine. Per ulteriori informazioni, consulta il passaggio facoltativo per l'immissione della trasformazione di input incluso nelle procedure riportate in, o. [Azioni e risorse relative ai sorgenti di Amazon ECR EventBridge](create-cwe-ecr-source.md) [Connessione alle azioni di origine di Amazon S3 con una fonte abilitata per gli eventi](create-S3-source-events.md) [CodeCommit azioni di origine e EventBridge](triggering.md)
Devi aver già creato un repository Amazon ECR e inviato un'immagine prima di connettere la pipeline tramite un'azione Amazon ECR.
**Topics**
+ [Tipo di operazione](#action-reference-ECR-type)
+ [Parametri di configurazione](#action-reference-ECR-config)
+ [Input artifact (Artefatti di input)](#action-reference-ECR-input)
+ [Artefatti di output](#action-reference-ECR-output)
+ [Variabili di output](#action-reference-ECR-variables)
+ [Autorizzazioni per ruoli di servizio: azione Amazon ECR](#edit-role-ecr)
+ [Dichiarazione di azione (esempio di Amazon ECR)](#action-reference-ECR-example)
+ [Consulta anche](#action-reference-ECR-links)
## Tipo di operazione
+ Categoria: `Source`
+ Proprietario: `AWS`
+ Provider: `ECR`
+ Versione: `1`
## Parametri di configurazione
**RepositoryName**
Obbligatorio: sì
Il nome del repository Amazon ECR in cui è stata inserita l'immagine.
**ImageTag**
Obbligatorio: no
Il tag utilizzato per l'immagine.
Se non viene specificato un valore per `ImageTag`, il valore predefinito è `latest`.
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di input non si applicano a questo tipo di azione.
## Artefatti di output
+ **Numero di artefatti:** `1`
+ **Descrizione:** questa azione produce un artefatto che contiene un file `imageDetail.json` contenente l'URI per l'immagine che ha attivato l'esecuzione della pipeline. Per ulteriori informazioni sul file `imageDetail.json`, consulta [File ImageDetail.json per le azioni di distribuzione di Amazon ECS blue/green](file-reference.md#file-reference-ecs-bluegreen).
## Variabili di output
Quando è configurata, questa azione produce variabili che possono essere referenziate dalla configurazione dell'azione di un'azione downstream nella pipeline. Questa azione produce variabili che possono essere viste come variabili di output, anche se l'azione non ha uno spazio dei nomi. È possibile configurare un'azione con uno spazio dei nomi per rendere tali variabili disponibili per la configurazione delle azioni downstream.
Per ulteriori informazioni, consulta [Riferimento alle variabili](reference-variables.md).
**RegistryId**
L'ID AWS dell'account associato al registro che contiene il repository.
**RepositoryName**
Il nome del repository Amazon ECR in cui è stata inserita l'immagine.
**ImageTag**
Il tag utilizzato per l'immagine.
La variabile `ImageTag` di output non viene emessa quando viene sovrascritta la revisione del codice sorgente
**ImageDigest**
Il file digest `sha256` del manifest delle immagini.
**ImageURI**
L'URI dell'immagine.
## Autorizzazioni per ruoli di servizio: azione Amazon ECR
Per il supporto di Amazon ECR, aggiungi quanto segue alla tua dichiarazione sulla politica:
```
{
"Effect": "Allow",
"Action": [
"ecr:DescribeImages"
],
"Resource": "resource_ARN"
},
```
Per ulteriori informazioni su questa azione, consulta[Riferimento all'azione sorgente di Amazon ECR](#action-reference-ECR).
## Dichiarazione di azione (esempio di Amazon ECR)
------
#### [ YAML ]
```
Name: Source
Actions:
- InputArtifacts: []
ActionTypeId:
Version: '1'
Owner: AWS
Category: Source
Provider: ECR
OutputArtifacts:
- Name: SourceArtifact
RunOrder: 1
Configuration:
ImageTag: latest
RepositoryName: my-image-repo
Name: ImageSource
```
------
#### [ JSON ]
```
{
"Name": "Source",
"Actions": [
{
"InputArtifacts": [],
"ActionTypeId": {
"Version": "1",
"Owner": "AWS",
"Category": "Source",
"Provider": "ECR"
},
"OutputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"RunOrder": 1,
"Configuration": {
"ImageTag": "latest",
"RepositoryName": "my-image-repo"
},
"Name": "ImageSource"
}
]
},
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Tutorial: crea una pipeline con una sorgente e una distribuzione Amazon ECR ECS-to-CodeDeploy](tutorials-ecs-ecr-codedeploy.md)— Questo tutorial fornisce un esempio di file di specifiche dell'app e un gruppo di CodeDeploy applicazione e distribuzione di esempio per creare una pipeline con una fonte CodeCommit Amazon ECR da distribuire su istanze Amazon ECS.
# `ECRBuildAndPublish`crea un riferimento all'azione
Questa azione di compilazione consente di automatizzare la creazione e l'invio di una nuova immagine quando si verifica una modifica nella fonte. Questa azione si basa sulla posizione specificata del file Docker e invia l'immagine. Questa azione di compilazione non è la stessa dell'azione di origine di Amazon ECR in CodePipeline, che attiva la pipeline quando si verifica una modifica nel tuo repository di origine Amazon ECR. Per informazioni su questa azione, consulta. [Riferimento all'azione sorgente di Amazon ECR](action-reference-ECR.md)
Questa non è un'azione di origine che attiverà la pipeline. Questa azione crea un'immagine e la invia al tuo repository di immagini Amazon ECR.
Devi aver già creato un repository Amazon ECR e aver aggiunto un Dockerfile al tuo repository di codice sorgente, ad esempio prima di aggiungere l'azione alla tua pipeline. GitHub
**Importante**
Questa azione utilizza l' CodeBuild elaborazione CodePipeline gestita per eseguire comandi in un ambiente di compilazione. L'esecuzione dell'azione dei comandi comporterà costi separati in. AWS CodeBuild
**Nota**
Questa azione è disponibile solo per le pipeline di tipo V2.
**Topics**
+ [Tipo di operazione](#action-reference-ECRBuildAndPublish-type)
+ [Parametri di configurazione](#action-reference-ECRBuildAndPublish-config)
+ [Input artifact (Artefatti di input)](#action-reference-ECRBuildAndPublish-input)
+ [Artefatti di output](#action-reference-ECRBuildAndPublish-output)
+ [Variabili di output](#action-reference-ECRBuildAndPublish-output-variables)
+ [Autorizzazioni per i ruoli di servizio: azione `ECRBuildAndPublish`](#edit-role-ECRBuildAndPublish)
+ [Dichiarazione dell'operazione](#action-reference-ECRBuildAndPublish-example)
+ [Consulta anche](#action-reference-ECRBuildAndPublish-links)
## Tipo di operazione
+ Categoria: `Build`
+ Proprietario: `AWS`
+ Provider: `ECRBuildAndPublish`
+ Versione: `1`
## Parametri di configurazione
**ECRRepositoryNome**
Obbligatorio: sì
Il nome del repository Amazon ECR in cui viene inserita l'immagine.
**DockerFilePath**
Obbligatorio: no
La posizione del file Docker utilizzato per creare l'immagine. Facoltativamente, puoi fornire una posizione alternativa per il file docker se non è a livello root.
Se non `DockerFilePath` viene specificato un valore per, il valore predefinito è il livello principale del repository di origine.
**ImageTags**
Obbligatorio: no
I tag usati per l'immagine. È possibile inserire più tag come elenco di stringhe delimitato da virgole.
Se non viene specificato un valore per `ImageTags`, il valore predefinito è `latest`.
**RegistryType**
Obbligatorio: no
Speciifica se il repository è pubblico o privato. I valori validi sono `private | public`.
Se non viene specificato un valore per `RegistryType`, il valore predefinito è `private`.
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1`
+ **Descrizione:** l'artefatto prodotto dall'azione sorgente che contiene il Dockerfile necessario per creare l'immagine.
## Artefatti di output
+ **Numero di artefatti:** `0`
## Variabili di output
Quando è configurata, questa azione produce variabili che possono essere referenziate dalla configurazione dell'azione di un'azione downstream nella pipeline. Questa azione produce variabili che possono essere viste come variabili di output, anche se l'azione non ha uno spazio dei nomi. È possibile configurare un'azione con uno spazio dei nomi per rendere tali variabili disponibili per la configurazione delle azioni downstream.
Per ulteriori informazioni, consulta [Riferimento alle variabili](reference-variables.md).
**ECRImageDigestId **
Il file digest `sha256` del manifest delle immagini.
**ECRRepositoryNome **
Il nome del repository Amazon ECR in cui è stata inserita l'immagine.
## Autorizzazioni per i ruoli di servizio: azione `ECRBuildAndPublish`
Per il supporto `ECRBuildAndPublish` all'azione, aggiungi quanto segue alla tua dichiarazione politica:
```
{
"Statement": [
{
"Sid": "ECRRepositoryAllResourcePolicy",
"Effect": "Allow",
"Action": [
"ecr:DescribeRepositories",
"ecr:GetAuthorizationToken",
"ecr-public:DescribeRepositories",
"ecr-public:GetAuthorizationToken"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ecr:GetAuthorizationToken",
"ecr:InitiateLayerUpload",
"ecr:UploadLayerPart",
"ecr:CompleteLayerUpload",
"ecr:PutImage",
"ecr:GetDownloadUrlForLayer",
"ecr:BatchCheckLayerAvailability"
],
"Resource": "PrivateECR_Resource_ARN"
},
{
"Effect": "Allow",
"Action": [
"ecr-public:GetAuthorizationToken",
"ecr-public:DescribeRepositories",
"ecr-public:InitiateLayerUpload",
"ecr-public:UploadLayerPart",
"ecr-public:CompleteLayerUpload",
"ecr-public:PutImage",
"ecr-public:BatchCheckLayerAvailability",
"sts:GetServiceBearerToken"
],
"Resource": "PublicECR_Resource_ARN"
},
{
"Effect": "Allow",
"Action": [
"sts:GetServiceBearerToken"
],
"Resource": "*"
}
]
}
```
Inoltre, se non è già stato aggiunto all'`Commands`azione, aggiungi le seguenti autorizzazioni al tuo ruolo di servizio per visualizzare i CloudWatch log.
```
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "resource_ARN"
},
```
**Nota**
Riduci le autorizzazioni a livello di risorsa della pipeline utilizzando le autorizzazioni basate sulle risorse nella dichiarazione sulla politica del ruolo di servizio.
Per ulteriori informazioni su questa azione, vedere. [`ECRBuildAndPublish`crea un riferimento all'azione](#action-reference-ECRBuildAndPublish)
## Dichiarazione dell'operazione
------
#### [ YAML ]
```
name: ECRBuild
actionTypeId:
category: Build
owner: AWS
provider: ECRBuildAndPublish
version: '1'
runOrder: 1
configuration:
ECRRepositoryName: actions/my-imagerepo
outputArtifacts: []
inputArtifacts:
- name: SourceArtifact
region: us-east-1
namespace: BuildVariables
```
------
#### [ JSON ]
```
{
"name": "ECRBuild",
"actionTypeId": {
"category": "Build",
"owner": "AWS",
"provider": "ECRBuildAndPublish",
"version": "1"
},
"runOrder": 1,
"configuration": {
"ECRRepositoryName": "actions/my-imagerepo"
},
"outputArtifacts": [],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-east-1",
"namespace": "BuildVariables"
},
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Tutorial: crea e invia un'immagine Docker ad Amazon ECR con CodePipeline (tipo V2)](tutorials-ecr-build-publish.md)— Questo tutorial fornisce un Dockerfile di esempio e istruzioni per creare una pipeline che invii l'immagine a ECR in caso di modifica al repository di origine e quindi la distribuisca su Amazon ECS.
# Riferimento alle azioni di distribuzione di Amazon Elastic Container Service e CodeDeploy blue-green
Puoi configurare una pipeline in AWS CodePipeline cui distribuire applicazioni container utilizzando una distribuzione. blue/green In una blue/green distribuzione, è possibile avviare una nuova versione dell'applicazione insieme alla versione precedente e testare la nuova versione prima di reindirizzare il traffico verso di essa. Puoi anche monitorare il processo di distribuzione ed eseguire rapidamente il rollback in caso di problemi.
La pipeline completata rileva le modifiche alle immagini o al file di definizione delle attività e le utilizza CodeDeploy per indirizzare e distribuire il traffico verso un cluster Amazon ECS e un sistema di bilanciamento del carico. CodeDeploy crea un nuovo listener sul tuo sistema di bilanciamento del carico che può indirizzare la nuova attività tramite una porta speciale. Puoi anche configurare la pipeline per utilizzare una posizione di origine, ad esempio un CodeCommit repository, in cui è archiviata la definizione delle attività di Amazon ECS.
Prima di creare la pipeline, devi aver già creato le risorse Amazon ECS, le risorse, il CodeDeploy sistema di bilanciamento del carico e il gruppo target. Devi aver già taggato e archiviato l'immagine nel tuo repository di immagini e aver caricato la definizione dell'attività e il file nel tuo archivio di AppSpec file.
**Nota**
Questo argomento descrive l'azione di distribuzione di Amazon ECS to CodeDeploy blue/green per. CodePipeline Per informazioni di riferimento sulle azioni di distribuzione standard di Amazon ECS in CodePipeline, consulta[Riferimento all'azione di distribuzione di Amazon Elastic Container Service](action-reference-ECS.md).
**Topics**
+ [Tipo di operazione](#action-reference-ECSbluegreen-type)
+ [Parametri di configurazione](#action-reference-ECSbluegreen-config)
+ [Input artifact (Artefatti di input)](#action-reference-ECSbluegreen-input)
+ [Artefatti di output](#action-reference-ECSbluegreen-output)
+ [Autorizzazioni per i ruoli di servizio: azione `CodeDeployToECS`](#edit-role-codedeploy-ecs)
+ [Dichiarazione dell'operazione](#action-reference-ECSbluegreen-example)
+ [Consulta anche](#action-reference-ECSbluegreen-links)
## Tipo di operazione
+ Categoria: `Deploy`
+ Proprietario: `AWS`
+ Provider: `CodeDeployToECS`
+ Versione: `1`
## Parametri di configurazione
**ApplicationName**
Obbligatorio: sì
Il nome dell'applicazione in CodeDeploy. Prima di creare la pipeline, è necessario aver già creato l'applicazione in CodeDeploy.
**DeploymentGroupName**
Obbligatorio: sì
Il gruppo di distribuzione specificato per i set di attività di Amazon ECS che hai creato per la tua CodeDeploy applicazione. Prima di creare la pipeline, devi aver già creato il gruppo di distribuzione in. CodeDeploy
**TaskDefinitionTemplateArtifact**
Obbligatorio: sì
Il nome dell'elemento di input che fornisce il file di definizione dell'attività all'azione di distribuzione. Questo è in genere il nome dell'artefatto di output dell'azione di origine. Quando si utilizza la console, il nome predefinito per l'elemento di output dell'azione di origine è. `SourceArtifact`
**AppSpecTemplateArtifact**
Obbligatorio: sì
Il nome dell'elemento di input che fornisce il AppSpec file all'azione di distribuzione. Tale valore viene aggiornato quando la pipeline viene eseguita. Questo è generalmente il nome dell'artefatto di output dell'azione di origine. Quando si utilizza la console, il nome predefinito per l'elemento di output dell'azione di origine è. `SourceArtifact` [Per `TaskDefinition` nel AppSpec file, puoi conservare il testo `` segnaposto come mostrato qui.](tutorials-ecs-ecr-codedeploy.md#tutorials-ecs-ecr-codedeploy-taskdefinition)
**AppSpecTemplatePath**
Obbligatorio: no
Il nome del file memorizzato nella posizione del AppSpec file di origine della pipeline, ad esempio nel repository della pipeline. CodeCommit Il nome file predefinito è `appspec.yaml`. Se il AppSpec file ha lo stesso nome ed è archiviato al livello principale del repository di file, non è necessario fornire il nome del file. Se il percorso non è quello predefinito, inserite il percorso e il nome del file.
**TaskDefinitionTemplatePath**
Obbligatorio: no
Il nome del file della definizione dell'attività memorizzata nella posizione di origine del file della pipeline, ad esempio nel repository della CodeCommit pipeline. Il nome file predefinito è `taskdef.json`. Se il file di definizione dell'attività ha lo stesso nome ed è archiviato a livello principale nel repository dei file, non è necessario fornire il nome del file. Se il percorso non è quello predefinito, inserite il percorso e il nome del file.
**Immagine ArtifactName**
Obbligatorio: no
Il nome dell'elemento di input che fornisce l'immagine all'azione di distribuzione. Si tratta in genere dell'artefatto di output del repository di immagini, ad esempio l'output dell'azione sorgente di Amazon ECR.
I valori disponibili per `` sono compresi tra 1 e 4.
**Immagine ContainerName**
Obbligatorio: no
Il nome dell'immagine disponibile nell'archivio di immagini, ad esempio l'archivio dei sorgenti di Amazon ECR.
I valori disponibili per `` sono compresi tra 1 e 4.
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1 to 5`
+ **Descrizione:** l'`CodeDeployToECS`azione cerca innanzitutto il file di definizione dell'attività e il AppSpec file nell'archivio dei file di origine, quindi cerca l'immagine nell'archivio delle immagini, quindi genera dinamicamente una nuova revisione della definizione dell'attività e infine esegue AppSpec i comandi per distribuire il set di attività e il contenitore nel cluster.
L'`CodeDeployToECS`azione cerca un `imageDetail.json` file che associa l'URI dell'immagine all'immagine. Quando esegui una modifica al tuo repository di immagini Amazon ECR, l'azione sorgente ECR della pipeline crea un `imageDetail.json` file per quel commit. Puoi anche aggiungere manualmente un `imageDetail.json` file per una pipeline in cui l'azione non è automatizzata. Per ulteriori informazioni sul file `imageDetail.json`, consulta [File ImageDetail.json per le azioni di distribuzione di Amazon ECS blue/green](file-reference.md#file-reference-ecs-bluegreen).
L'`CodeDeployToECS`azione genera dinamicamente una nuova revisione della definizione dell'attività. In questa fase, questa azione sostituisce i segnaposto nel file di definizione dell'attività nell'URI dell'immagine recuperato dai file ImageDetail.json. *Ad esempio, se imposti *IMAGE1\$1NAME* come ContainerName parametro Image1, devi specificare il segnaposto < \$1NAME> come valore del campo immagine nel file di definizione dell'attività. IMAGE1* In questo caso, l'azione CodeDeployTo ECS sostituisce il segnaposto *< IMAGE1 \$1NAME> nell'URI effettivo dell'immagine recuperato da ImageDetail.json nell'artefatto specificato come Image1*. ArtifactName
Per gli aggiornamenti `TaskDefinition` delle definizioni delle CodeDeploy `AppSpec.yaml` attività, il file contiene la proprietà.
```
TaskDefinition:
```
Questa proprietà verrà aggiornata dall'`CodeDeployToECS`azione dopo la creazione della nuova definizione di attività.
Per il valore del `TaskDefinition` campo, il testo segnaposto deve essere. L'`CodeDeployToECS`azione sostituisce questo segnaposto con l'ARN effettivo della definizione dell'attività generata dinamicamente.
## Artefatti di output
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di output non si applicano a questo tipo di azione.
## Autorizzazioni per i ruoli di servizio: azione `CodeDeployToECS`
Per l'`CodeDeployToECS`azione (azione di blue/green deployments), the following are the minimum permissions needed to create pipelines with a CodeDeploy to Amazon ECS blue/green distribuzione).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowCodeDeployDeploymentActions",
"Action": [
"codedeploy:CreateDeployment",
"codedeploy:GetDeployment"
],
"Resource": [
"arn:aws:codedeploy:*:111122223333:deploymentgroup:[[ApplicationName]]/*"
],
"Effect": "Allow"
},
{
"Sid": "AllowCodeDeployApplicationActions",
"Action": [
"codedeploy:GetApplication",
"codedeploy:GetApplicationRevision",
"codedeploy:RegisterApplicationRevision"
],
"Resource": [
"arn:aws:codedeploy:*:111122223333:application:[[ApplicationName]]",
"arn:aws:codedeploy:*:111122223333:application:[[ApplicationName]]/*"
],
"Effect": "Allow"
},
{
"Sid": "AllowCodeDeployDeploymentConfigAccess",
"Action": [
"codedeploy:GetDeploymentConfig"
],
"Resource": [
"arn:aws:codedeploy:*:111122223333:deploymentconfig:*"
],
"Effect": "Allow"
},
{
"Sid": "AllowECSRegisterTaskDefinition",
"Action": [
"ecs:RegisterTaskDefinition"
],
"Resource": [
"*"
],
"Effect": "Allow"
},
{
"Sid": "AllowPassRoleToECS",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": [
"arn:aws:iam::111122223333:role/[[PassRoles]]"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"ecs.amazonaws.com",
"ecs-tasks.amazonaws.com"
]
}
}
}
]
}
```
------
Puoi scegliere di utilizzare l'autorizzazione all'etichettatura in Amazon ECS. Iscrivendoti, devi concedere le seguenti autorizzazioni:. `ecs:TagResource` Per ulteriori informazioni su come attivare e determinare se l'autorizzazione è richiesta e l'autorizzazione dei tag è applicata, consulta la [cronologia dell'autorizzazione all'etichettatura](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html#tag-resources-timeline) nella Amazon Elastic Container Service Developer Guide.
È inoltre necessario aggiungere le `iam:PassRole` autorizzazioni per utilizzare i ruoli IAM per le attività. Per ulteriori informazioni, consulta il [ruolo IAM di esecuzione delle attività di Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html) e [IAM Roles for Tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html).
Puoi anche aggiungerli `ecs-tasks.amazonaws.com` all'elenco dei servizi in base alla `iam:PassedToService` condizione, come mostrato nell'esempio precedente.
## Dichiarazione dell'operazione
------
#### [ YAML ]
```
Name: Deploy
Actions:
- Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CodeDeployToECS
Version: '1'
RunOrder: 1
Configuration:
AppSpecTemplateArtifact: SourceArtifact
ApplicationName: ecs-cd-application
DeploymentGroupName: ecs-deployment-group
Image1ArtifactName: MyImage
Image1ContainerName: IMAGE1_NAME
TaskDefinitionTemplatePath: taskdef.json
AppSpecTemplatePath: appspec.yaml
TaskDefinitionTemplateArtifact: SourceArtifact
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
- Name: MyImage
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"Actions": [
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CodeDeployToECS",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"AppSpecTemplateArtifact": "SourceArtifact",
"ApplicationName": "ecs-cd-application",
"DeploymentGroupName": "ecs-deployment-group",
"Image1ArtifactName": "MyImage",
"Image1ContainerName": "IMAGE1_NAME",
"TaskDefinitionTemplatePath": "taskdef.json",
"AppSpecTemplatePath": "appspec.yaml",
"TaskDefinitionTemplateArtifact": "SourceArtifact"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
},
{
"Name": "MyImage"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
]
}
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Tutorial: crea una pipeline con una sorgente e una distribuzione Amazon ECR ECS-to-CodeDeploy](tutorials-ecs-ecr-codedeploy.md)— Questo tutorial illustra la creazione delle CodeDeploy risorse Amazon ECS necessarie per una blue/green distribuzione. Il tutorial mostra come inviare un'immagine Docker ad Amazon ECR e creare una definizione di attività Amazon ECS che elenchi il nome dell'immagine Docker, il nome del contenitore, il nome del servizio Amazon ECS e la configurazione del load balancer. Il tutorial ti guida quindi attraverso la creazione del AppSpec file e della pipeline per la tua implementazione.
**Nota**
Questo argomento e questo tutorial descrivono l'azione CodeDeploy/ECS blu/verde per. CodePipeline Per informazioni sulle azioni standard ECS in CodePipeline, vedere [Tutorial: Continuous](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-cd-pipeline.html) Deployment with. CodePipeline
+ *AWS CodeDeploy Guida per l'utente*: per informazioni su come utilizzare il load balancer, il listener di produzione, i gruppi target e l'applicazione Amazon ECS in una blue/green distribuzione, consulta [Tutorial: Deploy an Amazon](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorial-ecs-deployment.html) ECS Service. Queste informazioni di riferimento nella *Guida per l'AWS CodeDeploy utente* forniscono una panoramica delle distribuzioni blu/green con Amazon ECS e. AWS CodeDeploy
+ *Guida per sviluppatori di Amazon Elastic Container Service*: per informazioni sull'utilizzo di immagini e contenitori Docker, servizi e cluster ECS e set di attività ECS, consulta What Is Amazon [ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/)?
# Riferimento all'azione di distribuzione di Amazon Elastic Container Service
Puoi utilizzare un'azione Amazon ECS per distribuire un servizio Amazon ECS e un set di attività. Un servizio Amazon ECS è un'applicazione contenitore che viene distribuita in un cluster Amazon ECS. Un cluster Amazon ECS è una raccolta di istanze che ospitano l'applicazione container nel cloud. La distribuzione richiede una definizione di attività creata in Amazon ECS e un file di definizioni delle immagini da utilizzare CodePipeline per distribuire l'immagine.
**Importante**
L'azione di distribuzione standard di Amazon ECS CodePipeline crea la propria revisione della definizione dell'attività in base alla revisione utilizzata dal servizio Amazon ECS. Se crei nuove revisioni per la definizione dell'attività senza aggiornare il servizio Amazon ECS, l'azione di distribuzione ignorerà tali revisioni.
Prima di creare la pipeline, devi aver già creato le risorse Amazon ECS, taggato e archiviato l'immagine nel tuo repository di immagini e caricato il BuildSpec file nel tuo archivio di file.
**Nota**
Questo argomento di riferimento descrive l'azione di distribuzione standard di Amazon ECS per CodePipeline. Per informazioni di riferimento sulle azioni di distribuzione da Amazon ECS a CodeDeploy blue/green in CodePipeline, consulta. [Riferimento alle azioni di distribuzione di Amazon Elastic Container Service e CodeDeploy blue-green](action-reference-ECSbluegreen.md)
**Topics**
+ [Tipo di operazione](#action-reference-ECS-type)
+ [Parametri di configurazione](#action-reference-ECS-config)
+ [Input artifact (Artefatti di input)](#action-reference-ECS-input)
+ [Artefatti di output](#action-reference-ECS-output)
+ [Autorizzazioni per ruoli di servizio: azione standard di Amazon ECS](#edit-role-ecs)
+ [Dichiarazione dell'operazione](#action-reference-ECS-example)
+ [Consulta anche](#action-reference-ECS-links)
## Tipo di operazione
+ Categoria: `Deploy`
+ Proprietario: `AWS`
+ Provider: `ECS`
+ Versione: `1`
## Parametri di configurazione
**ClusterName**
Obbligatorio: sì
Il cluster Amazon ECS in Amazon ECS.
**ServiceName**
Obbligatorio: sì
Il servizio Amazon ECS che hai creato in Amazon ECS.
**FileName**
Obbligatorio: no
Il nome del file di definizioni delle immagini, il file JSON che descrive il nome del contenitore del servizio, l'immagine e il tag. Utilizzi questo file per le distribuzioni standard ECS. Per ulteriori informazioni, consultare [Input artifact (Artefatti di input)](#action-reference-ECS-input) e [file imagedefinitions.json per le azioni di distribuzione standard di Amazon ECS](file-reference.md#pipelines-create-image-definitions).
**DeploymentTimeout**
Obbligatorio: no
Il timeout dell'azione di distribuzione di Amazon ECS in minuti. Il timeout è configurabile fino al timeout predefinito massimo per questa operazione. Esempio:
```
"DeploymentTimeout": "15"
```
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1`
+ **Descrizione:** l'azione cerca un `imagedefinitions.json` file nell'archivio dei file di origine della pipeline. Un documento di definizioni delle immagini è un file JSON che descrive il nome del contenitore Amazon ECS, l'immagine e il tag. CodePipeline utilizza il file per recuperare l'immagine dal tuo repository di immagini come Amazon ECR. Puoi aggiungere manualmente un `imagedefinitions.json` file per una pipeline in cui l'azione non è automatizzata. Per ulteriori informazioni sul file `imagedefinitions.json`, consulta [file imagedefinitions.json per le azioni di distribuzione standard di Amazon ECS](file-reference.md#pipelines-create-image-definitions).
L'azione richiede un'immagine esistente che è già stata inserita nel tuo archivio di immagini. Poiché la mappatura delle immagini è fornita dal `imagedefinitions.json` file, l'azione non richiede che la sorgente Amazon ECR sia inclusa come azione sorgente nella pipeline.
## Artefatti di output
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di output non si applicano a questo tipo di azione.
## Autorizzazioni per ruoli di servizio: azione standard di Amazon ECS
Per Amazon ECS, le seguenti sono le autorizzazioni minime necessarie per creare pipeline con un'azione di distribuzione di Amazon ECS.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "TaskDefinitionPermissions",
"Effect": "Allow",
"Action": [
"ecs:DescribeTaskDefinition",
"ecs:RegisterTaskDefinition"
],
"Resource": [
"*"
]
},
{
"Sid": "ECSServicePermissions",
"Effect": "Allow",
"Action": [
"ecs:DescribeServices",
"ecs:UpdateService"
],
"Resource": [
"arn:aws:ecs:*:111122223333:service/[[clusters]]/*"
]
},
{
"Sid": "ECSTagResource",
"Effect": "Allow",
"Action": [
"ecs:TagResource"
],
"Resource": [
"arn:aws:ecs:*:111122223333:task-definition/[[taskDefinitions]]:*"
],
"Condition": {
"StringEquals": {
"ecs:CreateAction": [
"RegisterTaskDefinition"
]
}
}
},
{
"Sid": "IamPassRolePermissions",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": [
"arn:aws:iam::111122223333:role/[[passRoles]]"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"ecs.amazonaws.com",
"ecs-tasks.amazonaws.com"
]
}
}
}
]
}
```
------
Puoi scegliere di utilizzare l'autorizzazione all'etichettatura in Amazon ECS. Iscrivendoti, devi concedere le seguenti autorizzazioni:. `ecs:TagResource` Per ulteriori informazioni su come attivare e determinare se l'autorizzazione è richiesta e l'autorizzazione dei tag è applicata, consulta la [cronologia dell'autorizzazione all'etichettatura](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-account-settings.html#tag-resources-timeline) nella Amazon Elastic Container Service Developer Guide.
È necessario aggiungere le `iam:PassRole` autorizzazioni per utilizzare i ruoli IAM per le attività. Per ulteriori informazioni, consulta il [ruolo IAM di esecuzione delle attività di Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html) e [IAM Roles for Tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html). Utilizza il seguente testo di policy.
## Dichiarazione dell'operazione
------
#### [ YAML ]
```
Name: DeployECS
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: ECS
Version: '1'
RunOrder: 2
Configuration:
ClusterName: my-ecs-cluster
ServiceName: sample-app-service
FileName: imagedefinitions.json
DeploymentTimeout: '15'
OutputArtifacts: []
InputArtifacts:
- Name: my-image
```
------
#### [ JSON ]
```
{
"Name": "DeployECS",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "ECS",
"Version": "1"
},
"RunOrder": 2,
"Configuration": {
"ClusterName": "my-ecs-cluster",
"ServiceName": "sample-app-service",
"FileName": "imagedefinitions.json",
"DeploymentTimeout": "15"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "my-image"
}
]
},
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ Guarda [Tutorial: crea e invia un'immagine Docker ad Amazon ECR con CodePipeline (tipo V2)](tutorials-ecr-build-publish.md) un tutorial che mostra come utilizzare l'azione ECRBuildand Pubblica per inviare un'immagine e quindi utilizzare l'azione standard ECS per la distribuzione su Amazon ECS.
+ [Tutorial: distribuzione continua con CodePipeline](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-cd-pipeline.html): questo tutorial mostra come creare un Dockerfile da archiviare in un archivio di file sorgente come. CodeCommit Successivamente, il tutorial mostra come incorporare un CodeBuild BuildSpec file che crea e invia la tua immagine Docker ad Amazon ECR e crea il tuo file imagedefinitions.json. Infine, crei un servizio Amazon ECS e una definizione di attività, quindi crei la pipeline con un'azione di distribuzione di Amazon ECS.
**Nota**
Questo argomento e questo tutorial descrivono l'azione di distribuzione standard di Amazon ECS per CodePipeline. Per informazioni sulle azioni di distribuzione da Amazon ECS a CodeDeploy blue/green in CodePipeline, consulta. [Tutorial: crea una pipeline con una sorgente e una distribuzione Amazon ECR ECS-to-CodeDeploy](tutorials-ecs-ecr-codedeploy.md)
+ *Guida per sviluppatori di Amazon Elastic Container Service*: per informazioni sull'utilizzo di immagini e contenitori Docker, servizi e cluster Amazon ECS e set di attività Amazon ECS, consulta What Is Amazon [ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/)?
# Riferimento all'azione di distribuzione di Amazon Elastic Kubernetes Service `EKS`
Puoi utilizzare l'`EKSDeploy`azione per distribuire un servizio Amazon EKS. La distribuzione richiede un file manifest Kubernetes da CodePipeline utilizzare per distribuire l'immagine.
Prima di creare la pipeline, devi aver già creato le risorse Amazon EKS e aver archiviato l'immagine nel tuo repository di immagini. Facoltativamente, puoi fornire informazioni sul VPC per il tuo cluster.
**Importante**
Questa azione utilizza l' CodeBuild elaborazione CodePipeline gestita per eseguire comandi in un ambiente di compilazione. L'esecuzione dell'azione dei comandi comporterà costi separati in. AWS CodeBuild
**Nota**
L'azione di `EKS` distribuzione è disponibile solo per le pipeline di tipo V2.
L'azione EKS supporta cluster EKS pubblici e privati. I cluster privati sono il tipo consigliato da EKS; tuttavia, entrambi i tipi sono supportati.
L'azione EKS è supportata per le azioni tra account. Per aggiungere un'azione EKS su più account, aggiungila `actionRoleArn` dal tuo account di destinazione nella dichiarazione di azione.
**Topics**
+ [Tipo di operazione](#action-reference-EKS-type)
+ [Parametri di configurazione](#action-reference-EKS-config)
+ [Input artifact (Artefatti di input)](#action-reference-EKS-input)
+ [Artefatti di output](#action-reference-EKS-output)
+ [Variabili di ambiente](#action-reference-EKS-env-variables)
+ [Variabili di output](#action-reference-EKS-output-vars)
+ [Autorizzazioni relative alla politica del ruolo di servizio](#action-reference-EKS-service-role)
+ [Dichiarazione dell'operazione](#action-reference-EKS-example)
+ [Consulta anche](#action-reference-EKS-links)
## Tipo di operazione
+ Categoria: `Deploy`
+ Proprietario: `AWS`
+ Provider: `EKS`
+ Versione: `1`
## Parametri di configurazione
**ClusterName**
Obbligatorio: sì
Il cluster Amazon EKS in Amazon EKS.
**Opzioni in Helm**
Le seguenti sono le opzioni disponibili quando **Helm** è lo strumento di distribuzione selezionato.
**HelmReleaseName **
Obbligatorio: Sì (richiesto solo per il tipo di **Helm)**
Il nome della versione per la distribuzione.
**HelmChartLocation **
Obbligatorio: Sì (richiesto solo per il tipo **Helm)**
La posizione sulla mappa per la distribuzione.
**HelmValuesFiles **
Obbligatorio: No (opzionale solo per il tipo di **timone)**
Per sostituire i file dei valori di helm, inserisci i file dei valori di helm separati da virgole nella posizione del grafico Helm.
**Opzioni in Kubectl**
Le seguenti sono opzioni disponibili quando **Kubectl** è lo strumento di distribuzione selezionato.
**ManifestFiles**
**Richiesto: Sì (richiesto solo per il tipo Kubectl)**
Il nome del file manifest, il file di testo che descrive il nome del contenitore del servizio, l'immagine e il tag. Utilizzate questo file per parametrizzare l'URI dell'immagine e altre informazioni. È possibile utilizzare la variabile di ambiente per questo scopo.
Questo file viene archiviato nel repository di origine della pipeline.
**Namespace**
Obbligatorio: no
Lo spazio dei nomi Kubernetes da utilizzare nei nostri comandi. `kubectl` `helm`
**Sottoreti**
Obbligatorio: no
Le sottoreti per il VPC del tuo cluster. Fanno parte dello stesso VPC collegato al cluster. Puoi anche fornire sottoreti che non sono già collegate al cluster e specificarle qui.
**SecurityGroupIds**
Obbligatorio: no
I gruppi di sicurezza per il VPC del tuo cluster. Fanno parte dello stesso VPC collegato al cluster. Puoi anche fornire gruppi di sicurezza che non sono già collegati al tuo cluster e specificarli qui.
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1`
+ **Descrizione:** l'azione cerca il file manifest di Kubernetes o il grafico Helm nell'archivio dei file di origine della pipeline. Se desideri utilizzare i grafici helm in formato.tgz archiviati in un bucket S3, puoi farlo configurando S3 come azione di origine. Bucket/Key Ad esempio, la chiave dell'oggetto fornita sarebbe. `my-chart-0.1.0.tgz`
## Artefatti di output
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di output non si applicano a questo tipo di azione.
## Variabili di ambiente
Utilizzato per sostituire variabili come archivi di immagini o tag di immagine nei file manifest o nei file di valori dei grafici Helm.
**Chiave**
La chiave in una coppia di variabili di ambiente chiave-valore, ad esempio. `$IMAGE_TAG`
**Valore**
Il valore per la coppia chiave-valore, ad esempio. `v1.0` Il valore può essere parametrizzato con variabili di output provenienti da azioni di pipeline o variabili di pipeline. Ad esempio, la pipeline può avere un' ECRBuildAndPublish azione con `${codepipeline.PipelineExecutionId}` cui crea un'immagine ECR e l'azione EKS può utilizzare questa immagine `${codepipeline.PipelineExecutionId}` come valore della variabile di ambiente.
## Variabili di output
**EKSClusterNome**
Il cluster Amazon EKS in Amazon EKS.
## Autorizzazioni relative alla politica del ruolo di servizio
Per eseguire questa azione, le seguenti autorizzazioni devono essere disponibili nella politica dei ruoli di servizio della pipeline.
+ **Azioni EC2:** quando CodePipeline viene eseguita l'azione, sono necessarie le autorizzazioni dell'istanza EC2. Tieni presente che questo non è lo stesso ruolo dell'istanza EC2 richiesto per la creazione del cluster EKS.
Se utilizzi un ruolo di servizio esistente, per utilizzare questa azione, dovrai aggiungere le seguenti autorizzazioni per il ruolo di servizio.
+ ec2: CreateNetworkInterface
+ ec2: DescribeDhcpOptions
+ ec2: DescribeNetworkInterfaces
+ ec2: DeleteNetworkInterface
+ ec2: DescribeSubnets
+ ec2: DescribeSecurityGroups
+ ec2: DescribeVpcs
+ **Azioni EKS:** quando si CodePipeline esegue l'azione, sono necessarie le autorizzazioni del cluster EKS. Tieni presente che questo non è lo stesso ruolo del cluster IAM EKS richiesto per la creazione del cluster EKS.
Se utilizzi un ruolo di servizio esistente, per utilizzare questa azione, dovrai aggiungere la seguente autorizzazione per il ruolo di servizio.
+ es: DescribeCluster
+ **Registra le azioni del flusso:** quando CodePipeline esegue l'azione, CodePipeline crea un gruppo di log utilizzando il nome della pipeline come segue. Ciò consente di limitare le autorizzazioni per registrare le risorse utilizzando il nome della pipeline.
```
/aws/codepipeline/MyPipelineName
```
Se si utilizza un ruolo di servizio esistente, per utilizzare questa azione, è necessario aggiungere le seguenti autorizzazioni per il ruolo di servizio.
+ registri: CreateLogGroup
+ registri: CreateLogStream
+ registri: PutLogEvents
Nella dichiarazione sulla politica del ruolo del servizio, riduci le autorizzazioni al livello della risorsa, come illustrato nell'esempio seguente.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"eks:DescribeCluster"
],
"Resource": "arn:aws:eks:*:111122223333:cluster/YOUR_CLUSTER_NAME"
},
{
"Effect": "Allow",
"Action": [
"ec2:CreateNetworkInterface",
"ec2:CreateNetworkInterfacePermission",
"ec2:DescribeDhcpOptions",
"ec2:DescribeNetworkInterfaces",
"ec2:DeleteNetworkInterface",
"ec2:DescribeSubnets",
"ec2:DescribeSecurityGroups",
"ec2:DescribeVpcs",
"ec2:DescribeRouteTables"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:CreateLogGroup",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:*:111122223333:log-group:/aws/codepipeline/YOUR_PIPELINE_NAME",
"arn:aws:logs:*:111122223333:log-group:/aws/codepipeline/YOUR_PIPELINE_NAME:*"
]
}
]
}
```
------
Per visualizzare i log nella console utilizzando la pagina di dialogo dei dettagli delle azioni, è necessario aggiungere l'autorizzazione alla visualizzazione dei log al ruolo della console. Per ulteriori informazioni, consulta l'esempio di policy sulle autorizzazioni della console in. [Autorizzazioni necessarie per visualizzare i log di calcolo nella console](security-iam-permissions-console-logs.md)
### Aggiungere il ruolo di servizio come voce di accesso per il cluster
Dopo che le autorizzazioni sono disponibili nella politica del ruolo di servizio della pipeline, configuri le autorizzazioni del cluster aggiungendo il ruolo di CodePipeline servizio come voce di accesso per il cluster.
Puoi anche utilizzare un ruolo d'azione con le autorizzazioni aggiornate. Per ulteriori informazioni, consulta l'esempio del tutorial in[Fase 4: Creare una voce di accesso per il ruolo di servizio CodePipeline](tutorials-eks-deploy.md#tutorials-eks-deploy-access-entry).
## Dichiarazione dell'operazione
------
#### [ YAML ]
```
Name: DeployEKS
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: EKS
Version: '1'
RunOrder: 2
Configuration:
ClusterName: my-eks-cluster
ManifestFiles: ManifestFile.json
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
```
------
#### [ JSON ]
```
{
"Name": "DeployECS",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "EKS",
"Version": "1"
},
"RunOrder": 2,
"Configuration": {
"ClusterName": "my-eks-cluster",
"ManifestFiles": "ManifestFile.json"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
]
},
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ Vedi [Tutorial: Esegui la distribuzione su Amazon EKS con CodePipeline](tutorials-eks-deploy.md) un tutorial che dimostra come creare un cluster EKS e un file manifest Kubernetes per aggiungere l'azione alla tua pipeline.
# AWS Lambda distribuire un riferimento all'azione
Utilizzi un'azione di AWS Lambda distribuzione per gestire la distribuzione del codice dell'applicazione per la distribuzione senza server. È possibile implementare una funzione e utilizzare strategie di distribuzione per la distribuzione del traffico come segue:
+ Implementazioni canarie e lineari per lo spostamento del traffico
+ Implementazioni tutte in una volta
**Nota**
Questa azione è supportata solo per le pipeline di tipo V2.
**Topics**
+ [Tipo di operazione](#action-reference-LambdaDeploy-type)
+ [Parametri di configurazione](#action-reference-LambdaDeploy-parameters)
+ [Input artifact (Artefatti di input)](#action-reference-LambdaDeploy-input)
+ [Artefatti di output](#action-reference-LambdaDeploy-output)
+ [Variabili di output](#action-reference-LambdaDeploy-output-variables)
+ [Autorizzazioni della policy del ruolo di servizio per l'azione di distribuzione Lambda](#action-reference-LambdaDeploy-permissions-action)
+ [Dichiarazione dell'operazione](#action-reference-LambdaDeploy-example)
+ [Consulta anche](#action-reference-LambdaDeploy-links)
## Tipo di operazione
+ Categoria: `Deploy`
+ Proprietario: `AWS`
+ Provider: `Lambda`
+ Versione: `1`
## Parametri di configurazione
**FunctionName**
Obbligatorio: sì
Il nome della funzione che hai creato in Lambda, ad esempio. `MyLambdaFunction`
Devi aver già creato una versione.
**FunctionAlias**
Obbligatorio: no
L'alias della funzione che hai creato in Lambda ed è la funzione su cui distribuire, ad esempio. `live` L'alias deve esistere e deve avere una versione supportata quando iniziano le esecuzioni delle azioni. (Sarà la versione di destinazione del rollback.)
Se non viene fornita, l'azione distribuisce l'artefatto di origine `$LATEST` e ne crea una nuova versione. In questo caso d'uso, le opzioni relative alla strategia di distribuzione e alla versione di destinazione non sono disponibili.
**PublishedTargetVersion**
Obbligatorio: no
La versione della funzione Lambda desiderata su cui distribuire. FunctionAlias Possono essere variabili a livello di pipeline o di azione, ad esempio. `#{variables.lambdaTargetVersion}` La versione deve essere pubblicata all'avvio dell'esecuzione dell'azione.
Obbligatorio se non viene fornito alcun elemento di input.
**DeployStrategy**
Obbligatorio: No (l'impostazione predefinita è) `AllAtOnce`
Determina la velocità che l'azione di distribuzione Lambda adotta per spostare il traffico dalla versione originale della funzione Lambda alla nuova versione per. **FunctionAlias** Le strategie di implementazione disponibili sono canarie o lineari. Formati accettati:
+ `AllAtOnce` -
Sposta tutto il traffico verso le funzioni Lambda aggiornate contemporaneamente.
Se non specificato, l'impostazione predefinita è) `AllAtOnce`
+ `Canary10Percent5Minutes`- Sposta il 10 percento del traffico nel primo incremento. Il restante 90% viene reinstradato cinque minuti più tardi.
I valori della percentuale e dei minuti possono essere modificati.
+ `Linear10PercentEvery1Minute`- Sposta il 10% del traffico ogni minuto fino a quando tutto il traffico non viene spostato.
I valori della percentuale e dei minuti possono essere modificati.
Le seguenti considerazioni si applicano a questo campo:
+ Il tempo di attesa totale massimo è di 2 giorni.
+ Disponibile solo quando **FunctionAlias**viene fornito.
**Allarmi**
Obbligatorio: no
Un elenco separato da virgole di nomi di allarmi configurati per la distribuzione Lambda. È possibile aggiungere un massimo di 10 allarmi. L'azione fallisce quando gli allarmi monitorati passano allo stato ALARM.
L'immagine seguente mostra un esempio della pagina Modifica dell'azione.
![\[La pagina Modifica azione per una nuova pipeline con l'azione di distribuzione Lambda\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/lambdadeploy-edit-screen.png)
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1`
+ **Descrizione:** i file forniti, se presenti, per supportare le azioni dello script durante la distribuzione.
## Artefatti di output
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di output non si applicano a questo tipo di azione.
## Variabili di output
Quando è configurata, questa azione produce variabili che possono essere referenziate dalla configurazione dell'azione di un'azione downstream nella pipeline. Questa azione produce variabili che possono essere viste come variabili di output, anche se l'azione non ha uno spazio dei nomi. È possibile configurare un'azione con uno spazio dei nomi per rendere tali variabili disponibili per la configurazione delle azioni downstream.
Per ulteriori informazioni, consulta [Riferimento alle variabili](reference-variables.md).
**FunctionVersion**
La nuova versione della funzione Lambda che è stata distribuita.
## Autorizzazioni della policy del ruolo di servizio per l'azione di distribuzione Lambda
Quando CodePipeline esegue l'azione, il ruolo di CodePipeline servizio richiede le seguenti autorizzazioni, specificate in modo appropriato per l'accesso con il privilegio minimo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "StatementForLambda",
"Effect": "Allow",
"Action": [
"lambda:GetAlias",
"lambda:GetFunctionConfiguration",
"lambda:GetProvisionedConcurrencyConfig",
"lambda:PublishVersion",
"lambda:UpdateAlias",
"lambda:UpdateFunctionCode"
],
"Resource": [
"arn:aws:lambda:us-east-1:111122223333:function:{{FunctionName}}",
"arn:aws:lambda:us-east-1:111122223333:function:{{FunctionName}}:*"
]
},
{
"Sid": "StatementForCloudWatch",
"Effect": "Allow",
"Action": [
"cloudwatch:DescribeAlarms"
],
"Resource": [
"arn:aws:cloudwatch:us-east-1:111122223333:alarm:{{AlarmNames}}"
]
},
{
"Sid": "StatementForLogs1",
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/us-east-1/codepipeline/{{pipelineName}}",
"arn:aws:logs:us-east-1:111122223333:log-group:/us-east-1/codepipeline/{{pipelineName}}:*"
]
},
{
"Sid": "StatementForLogs2",
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/us-east-1/codepipeline/{{pipelineName}}:log-stream:*"
]
}
]
}
```
------
## Dichiarazione dell'operazione
------
#### [ YAML ]
```
name: Deploy
actionTypeId:
category: Deploy
owner: AWS
provider: Lambda
version: '1'
runOrder: 1
configuration:
DeployStrategy: Canary10Percent5Minutes
FunctionAlias: aliasV1
FunctionName: MyLambdaFunction
outputArtifacts: []
inputArtifacts:
- name: SourceArtifact
region: us-east-1
namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"name": "Deploy",
"actionTypeId": {
"category": "Deploy",
"owner": "AWS",
"provider": "Lambda",
"version": "1"
},
"runOrder": 1,
"configuration": {
"DeployStrategy": "Canary10Percent5Minutes",
"FunctionAlias": "aliasV1",
"FunctionName": "MyLambdaFunction"
},
"outputArtifacts": [],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-east-1",
"namespace": "DeployVariables"
},
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Tutorial: implementazioni di funzioni Lambda con CodePipeline](tutorials-lambda-deploy.md)— Questo tutorial illustra la creazione di una funzione Lambda di esempio in cui è possibile creare un alias e una versione, aggiungere la funzione Lambda zippata alla posizione di origine ed eseguire l'azione Lambda nella pipeline.
# Riferimento alle azioni di distribuzione di Amazon S3
Utilizzi un'azione di distribuzione di Amazon S3 per distribuire file in un bucket Amazon S3 per l'hosting o l'archiviazione di siti Web statici. Puoi specificare se estrarre i file di distribuzione prima di caricarli nel bucket.
**Nota**
Questo argomento di riferimento descrive l'azione di distribuzione di Amazon S3 per i CodePipeline casi in cui la piattaforma di distribuzione è un bucket Amazon S3 configurato per l'hosting. Per informazioni di riferimento sull'azione del codice sorgente di Amazon S3 in CodePipeline, consulta. [Riferimento all'azione del codice sorgente di Amazon S3](action-reference-S3.md)
**Topics**
+ [Tipo di operazione](#action-reference-S3Deploy-type)
+ [Parametri di configurazione](#action-reference-S3Deploy-config)
+ [Input artifact (Artefatti di input)](#action-reference-S3Deploy-input)
+ [Artefatti di output](#action-reference-S3Deploy-output)
+ [Autorizzazioni per i ruoli di servizio: S3 deploy action](#edit-role-s3deploy)
+ [Esempio di configurazione dell'operazione](#action-reference-S3Deploy-example)
+ [Consulta anche](#action-reference-S3Deploy-links)
## Tipo di operazione
+ Categoria: `Deploy`
+ Proprietario: `AWS`
+ Provider: `S3`
+ Versione: `1`
## Parametri di configurazione
**BucketName**
Obbligatorio: sì
Il nome del bucket Amazon S3 in cui devono essere distribuiti i file.
**Estrarre**
Obbligatorio: sì
Se true, specifica che i file devono essere estratti prima del caricamento. In caso contrario, i file dell'applicazione rimangono compressi durante il caricamento, come nel caso di un sito Web statico ospitato. Se false, allora `ObjectKey` è necessario.
**ObjectKey**
Condizionale. Obbligatoria se `Extract` = false
Il nome della chiave oggetto Amazon S3 che identifica in modo univoco l'oggetto nel bucket S3.
**KMSEncryptionKeyArn**
Obbligatorio: no
L'ARN della chiave di AWS KMS crittografia per il bucket host. Il `KMSEncryptionKeyARN` parametro crittografa gli artefatti caricati con quanto fornito. AWS KMS key Per una chiave KMS, puoi utilizzare l'ID chiave, la chiave ARN o l'alias ARN.
Gli alias sono riconosciuti solo nell'account che ha creato la chiave KMS. Per le operazioni tra account, puoi utilizzare solo l'ID della chiave o l'ARN della chiave per identificare la chiave. Le operazioni tra account comportano l'utilizzo del ruolo dell'altro account (AccountB), pertanto specificando l'ID chiave verrà utilizzata la chiave dell'altro account (AccountB).
CodePipeline supporta solo chiavi KMS simmetriche. Non utilizzare una chiave KMS asimmetrica per crittografare i dati nel bucket S3.
**CannedACL**
Obbligatorio: no
Il `CannedACL` parametro applica l'[ACL predefinito specificato](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl) agli oggetti distribuiti su Amazon S3. Tale applicazione sovrascrive l'ACL esistente applicata all'oggetto.
**CacheControl**
Obbligatorio: no
Il `CacheControl` parametro controlla il comportamento di memorizzazione nella cache degli oggetti nel bucket requests/responses . Per un elenco dei valori validi, vedi il campo di intestazione [http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9) per le operazioni HTTP. Per inserire più valori in `CacheControl`, utilizzare una virgola tra ogni valore. Puoi aggiungere uno spazio dopo ogni virgola (facoltativo), come mostrato in questo esempio per l'interfaccia a riga di comando:
```
"CacheControl": "public, max-age=0, no-transform"
```
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1`
+ **Descrizione:** i file per la distribuzione o l'archiviazione sono ottenuti dal repository di origine, compressi e caricati da. CodePipeline
## Artefatti di output
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di output non si applicano a questo tipo di azione.
## Autorizzazioni per i ruoli di servizio: S3 deploy action
Per il supporto di S3 deploy Action, aggiungi quanto segue alla tua dichiarazione politica:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:PutObjectAcl",
"s3:PutObjectVersionAcl",
"s3:GetBucketVersioning",
"s3:GetBucketAcl",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::[[s3DeployBuckets]]",
"arn:aws:s3:::[[s3DeployBuckets]]/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "111122223333"
}
}
}
]
}
```
------
Per il supporto di S3 deploy Action, se i tuoi oggetti S3 hanno tag, devi anche aggiungere le seguenti autorizzazioni alla tua dichiarazione politica:
```
"s3:GetObjectTagging",
"s3:GetObjectVersionTagging",
"s3:PutObjectTagging"
```
## Esempio di configurazione dell'operazione
Di seguito sono riportati alcuni esempi per la configurazione dell'azione.
### Esempio di configurazione quando `Extract` è impostato su `false`
L'esempio seguente mostra la configurazione dell'azione predefinita quando l'azione viene creata con il `Extract` campo impostato su`false`.
------
#### [ YAML ]
```
Name: Deploy
Actions:
- Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: S3
Version: '1'
RunOrder: 1
Configuration:
BucketName: website-bucket
Extract: 'false'
ObjectKey: MyWebsite
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"Actions": [
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "S3",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"BucketName": "website-bucket",
"Extract": "false",
"ObjectKey": "MyWebsite"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
]
},
```
------
### Esempio di configurazione quando `Extract` è impostato su `true`
L'esempio seguente mostra la configurazione dell'azione predefinita quando l'azione viene creata con il `Extract` campo impostato su`true`.
------
#### [ YAML ]
```
Name: Deploy
Actions:
- Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: S3
Version: '1'
RunOrder: 1
Configuration:
BucketName: website-bucket
Extract: 'true'
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"Actions": [
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "S3",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"BucketName": "website-bucket",
"Extract": "true"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
]
},
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Tutorial: crea una pipeline che utilizzi Amazon S3 come provider di distribuzione](tutorials-s3deploy.md)— Questo tutorial illustra due esempi per creare una pipeline con un'azione di distribuzione di S3. Scarichi file di esempio, carichi i file nel tuo CodeCommit repository, crei il tuo bucket S3 e configuri il bucket per l'hosting. Successivamente, usi la CodePipeline console per creare la pipeline e specificare una configurazione di distribuzione di Amazon S3.
+ [Riferimento all'azione del codice sorgente di Amazon S3](action-reference-S3.md)— Questo riferimento all'azione fornisce informazioni di riferimento ed esempi per le azioni di origine di Amazon S3 in. CodePipeline
# Riferimento all'azione del codice sorgente di Amazon S3
Attiva la pipeline quando un nuovo oggetto viene caricato nel bucket e nella chiave oggetto configurati.
**Nota**
Questo argomento di riferimento descrive l'azione sorgente di Amazon S3 per CodePipeline cui la posizione di origine è un bucket Amazon S3 configurato per il controllo delle versioni. Per informazioni di riferimento sull'azione di distribuzione di Amazon S3 in CodePipeline, consulta. [Riferimento alle azioni di distribuzione di Amazon S3](action-reference-S3Deploy.md)
Puoi creare un bucket Amazon S3 da utilizzare come posizione di origine per i file dell'applicazione.
**Nota**
Quando crei il bucket di origine, assicurati di abilitare il controllo delle versioni nel bucket. Se desideri utilizzare un bucket Amazon S3 esistente, consulta [Usare il controllo delle versioni per abilitare il controllo delle versioni](https://docs.aws.amazon.com/AmazonS3/latest/dev/Versioning.html) su un bucket esistente.
Se usi la console per creare o modificare la pipeline, CodePipeline crea una EventBridge regola che avvia la pipeline quando si verifica una modifica nel bucket di origine S3.
**Nota**
Per Amazon ECR, Amazon S3 CodeCommit o sorgenti, puoi anche creare un'override di origine utilizzando input transform entry per utilizzare l' EventBridge in per `revisionValue` il tuo evento pipeline, dove è derivato dalla variabile `revisionValue` dell'evento source per la chiave oggetto, il commit o l'ID immagine. Per ulteriori informazioni, consulta il passaggio facoltativo per l'immissione della trasformazione di input incluso nelle procedure riportate in, o. [Azioni e risorse relative ai sorgenti di Amazon ECR EventBridge](create-cwe-ecr-source.md) [Connessione alle azioni di origine di Amazon S3 con una fonte abilitata per gli eventi](create-S3-source-events.md) [CodeCommit azioni di origine e EventBridge](triggering.md)
È necessario aver già creato un bucket di origine Amazon S3 e aver caricato i file di origine come singolo file ZIP prima di connettere la pipeline tramite un'azione Amazon S3.
**Nota**
Se Amazon S3 è il fornitore di origine per la tua pipeline, puoi comprimere il file o i file sorgente in un unico .zip e caricare il file.zip nel tuo bucket di origine. È inoltre possibile caricare un singolo file decompresso; tuttavia, le operazioni a valle che si aspettano un file con estensione .zip avranno esito negativo.
**Topics**
+ [Tipo di operazione](#action-reference-S3-type)
+ [Parametri di configurazione](#action-reference-S3-config)
+ [Input artifact (Artefatti di input)](#action-reference-S3-input)
+ [Artefatti di output](#action-reference-S3-output)
+ [Variabili di output](#action-reference-S3-variables)
+ [Autorizzazioni per i ruoli di servizio: S3 source action](#edit-role-s3source)
+ [Dichiarazione dell'operazione](#action-reference-S3-example)
+ [Consulta anche](#action-reference-S3-links)
## Tipo di operazione
+ Categoria: `Source`
+ Proprietario: `AWS`
+ Provider: `S3`
+ Versione: `1`
## Parametri di configurazione
**S3Bucket**
Obbligatorio: sì
Il nome del bucket Amazon S3 in cui devono essere rilevate le modifiche all'origine.
**S3 ObjectKey**
Obbligatorio: sì
Il nome della chiave oggetto Amazon S3 in cui devono essere rilevate le modifiche all'origine.
**AllowOverrideForS3ObjectKey**
Obbligatorio: no
`AllowOverrideForS3ObjectKey`controlla se l'override della fonte `StartPipelineExecution` può sovrascrivere quello già configurato `S3ObjectKey` nell'azione di origine. Per ulteriori informazioni sulle sostituzioni dei sorgenti con la chiave S3 Object, consulta. [Avvia una pipeline con una modifica della revisione del codice sorgente](pipelines-trigger-source-overrides.md)
Se ometti`AllowOverrideForS3ObjectKey`, per CodePipeline impostazione predefinita la possibilità di sovrascrivere S3 ObjectKey nell'azione di origine impostando questo parametro su. `false`
I valori validi per questo parametro sono:
+ `true`: Se impostata, la chiave oggetto S3 preconfigurata può essere sostituita dalle sostituzioni delle revisioni del codice sorgente durante l'esecuzione di una pipeline.
**Nota**
Se intendi consentire a tutti CodePipeline gli utenti la possibilità di sovrascrivere la chiave oggetto S3 preconfigurata durante l'avvio di una nuova esecuzione della pipeline, devi impostare su. `AllowOverrideForS3ObjectKey` `true`
+ `false`:
Se impostata, non CodePipeline consentirà la sovrascrittura della chiave oggetto S3 utilizzando le sostituzioni delle revisioni del codice sorgente. Questo è anche il valore predefinito per questo parametro.
**PollForSourceChanges**
Obbligatorio: no
`PollForSourceChanges`controlla se interroga CodePipeline il bucket di origine di Amazon S3 per verificare eventuali modifiche alla fonte. Ti consigliamo invece di utilizzare CloudWatch Events e di rilevare CloudTrail le modifiche all'origine. Per ulteriori informazioni sulla configurazione CloudWatch degli eventi, consulta [Migra le pipeline di polling con un codice sorgente e trail CloudTrail (CLI) S3](update-change-detection.md#update-change-detection-cli-S3) o[Migra le pipeline di polling con una sorgente e un trail S3 (modello) CloudTrail CloudFormation](update-change-detection.md#update-change-detection-cfn-s3).
Se intendi configurare gli CloudWatch eventi, devi impostarlo su `PollForSourceChanges` per `false` evitare esecuzioni duplicate della pipeline.
I valori validi per questo parametro sono:
+ `true`: Se impostata, verifica la posizione di origine per CodePipeline verificare se sono state apportate modifiche alla fonte.
**Nota**
Se si omette`PollForSourceChanges`, per CodePipeline impostazione predefinita esegue il sondaggio della posizione di origine per verificare eventuali modifiche alla fonte. Questo comportamento è lo stesso se `PollForSourceChanges` è incluso e impostato su `true`.
+ `false`: se impostata, CodePipeline non esegue il sondaggio della posizione di origine per verificare eventuali modifiche alla fonte. Utilizza questa impostazione se intendi configurare una regola CloudWatch Events per rilevare le modifiche all'origine.
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di input non si applicano a questo tipo di azione.
## Artefatti di output
+ **Numero di artefatti:** `1`
+ **Descrizione:** fornisce gli artefatti disponibili nel bucket di origine configurato per connettersi alla pipeline. Gli artefatti generati dal bucket sono gli artefatti di output per l'azione Amazon S3. I metadati dell'oggetto Amazon S3 (ETag e l'ID della versione) vengono visualizzati CodePipeline come revisione di origine per l'esecuzione della pipeline attivata.
## Variabili di output
Quando è configurata, questa azione produce variabili che possono essere referenziate dalla configurazione dell'azione di un'azione downstream nella pipeline. Questa azione produce variabili che possono essere viste come variabili di output, anche se l'azione non ha uno spazio dei nomi. È possibile configurare un'azione con uno spazio dei nomi per rendere tali variabili disponibili per la configurazione delle azioni downstream.
Per ulteriori informazioni sulle variabili in, consulta. CodePipeline [Riferimento alle variabili](reference-variables.md)
**BucketName**
Il nome del bucket Amazon S3 relativo alla modifica dell'origine che ha attivato la pipeline.
**ETag**
Il tag entità per l'oggetto correlato alla modifica di origine che ha attivato la pipeline. ETag È un MD5 hash dell'oggetto. ETag riflette solo le modifiche al contenuto di un oggetto, non ai relativi metadati.
**ObjectKey**
Il nome della chiave oggetto Amazon S3 correlato alla modifica dell'origine che ha attivato la pipeline.
**VersionId**
L'ID di versione per la versione dell'oggetto correlata alla modifica di origine che ha attivato la pipeline.
## Autorizzazioni per i ruoli di servizio: S3 source action
Per il supporto di S3 source action, aggiungi quanto segue alla tua dichiarazione politica:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetObjectVersion",
"s3:GetBucketVersioning",
"s3:GetBucketAcl",
"s3:GetBucketLocation",
"s3:GetObjectTagging",
"s3:GetObjectVersionTagging"
],
"Resource": [
"arn:aws:s3:::[[S3Bucket]]",
"arn:aws:s3:::[[S3Bucket]]/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceAccount": "111122223333"
}
}
}
]
}
```
------
## Dichiarazione dell'operazione
------
#### [ YAML ]
```
Name: Source
Actions:
- RunOrder: 1
OutputArtifacts:
- Name: SourceArtifact
ActionTypeId:
Provider: S3
Owner: AWS
Version: '1'
Category: Source
Region: us-west-2
Name: Source
Configuration:
S3Bucket: amzn-s3-demo-source-bucket
S3ObjectKey: my-application.zip
PollForSourceChanges: 'false'
InputArtifacts: []
```
------
#### [ JSON ]
```
{
"Name": "Source",
"Actions": [
{
"RunOrder": 1,
"OutputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"ActionTypeId": {
"Provider": "S3",
"Owner": "AWS",
"Version": "1",
"Category": "Source"
},
"Region": "us-west-2",
"Name": "Source",
"Configuration": {
"S3Bucket": "amzn-s3-demo-source-bucket",
"S3ObjectKey": "my-application.zip",
"PollForSourceChanges": "false"
},
"InputArtifacts": []
}
]
},
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Tutorial: creazione di una semplice pipeline (bucket S3)](tutorials-simple-s3.md)— Questo tutorial fornisce un esempio di file di specifiche dell'app e un esempio di CodeDeploy applicazione e gruppo di distribuzione. Usa questo tutorial per creare una pipeline con un sorgente Amazon S3 da distribuire su istanze Amazon EC2.
# AWS AppConfig distribuire un riferimento all'azione
AWS AppConfig è una capacità di. AWS Systems Manager AppConfig supporta implementazioni controllate su applicazioni di qualsiasi dimensione e include controlli di convalida e monitoraggio integrati. Puoi utilizzarlo AppConfig con applicazioni ospitate su istanze Amazon EC2, container AWS Lambda, applicazioni mobili o dispositivi IoT.
**L'azione di `AppConfig` distribuzione è un' AWS CodePipeline azione che distribuisce le configurazioni archiviate nella posizione di origine della pipeline in un' AppConfig *applicazione*, un ambiente e un profilo di configurazione specifici.** *Utilizza le preferenze definite in una strategia di distribuzione. AppConfig *
## Tipo di operazione
+ Categoria: `Deploy`
+ Proprietario: `AWS`
+ Provider: `AppConfig`
+ Versione: `1`
## Parametri di configurazione
**Applicazione**
Obbligatorio: sì
L'ID dell' AWS AppConfig applicazione con i dettagli per la configurazione e la distribuzione.
**Ambiente**
Obbligatorio: sì
L'ID dell' AWS AppConfig ambiente in cui viene distribuita la configurazione.
**ConfigurationProfile**
Obbligatorio: sì
L'ID del profilo di AWS AppConfig configurazione da distribuire.
**InputArtifactConfigurationPath**
Obbligatorio: sì
Il percorso del file dei dati di configurazione all'interno dell'elemento di input da distribuire.
**DeploymentStrategy**
Obbligatorio: no
La strategia AWS AppConfig di distribuzione da utilizzare per la distribuzione.
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1`
+ **Descrizione:** l'artefatto di input per l'azione di distribuzione.
## Artefatti di output
Non applicabile.
## Autorizzazioni per i ruoli di servizio: azione `AppConfig`
Quando CodePipeline esegue l'azione, la policy del ruolo di CodePipeline servizio richiede le seguenti autorizzazioni, opportunamente ripartite in base al livello della risorsa per mantenere l'accesso con il minimo privilegio.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"appconfig:StartDeployment",
"appconfig:StopDeployment",
"appconfig:GetDeployment"
],
"Resource": [
"arn:aws:appconfig:*:111122223333:application/[[Application]]",
"arn:aws:appconfig:*:111122223333:application/[[Application]]/*",
"arn:aws:appconfig:*:111122223333:deploymentstrategy/*"
],
"Effect": "Allow"
}
]
}
```
------
## Esempio di configurazione dell'operazione
------
#### [ YAML ]
```
name: Deploy
actions:
- name: Deploy
actionTypeId:
category: Deploy
owner: AWS
provider: AppConfig
version: '1'
runOrder: 1
configuration:
Application: 2s2qv57
ConfigurationProfile: PvjrpU
DeploymentStrategy: frqt7ir
Environment: 9tm27yd
InputArtifactConfigurationPath: /
outputArtifacts: []
inputArtifacts:
- name: SourceArtifact
region: us-west-2
namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"name": "Deploy",
"actions": [
{
"name": "Deploy",
"actionTypeId": {
"category": "Deploy",
"owner": "AWS",
"provider": "AppConfig",
"version": "1"
},
"runOrder": 1,
"configuration": {
"Application": "2s2qv57",
"ConfigurationProfile": "PvjrpU",
"DeploymentStrategy": "frqt7ir",
"Environment": "9tm27yd",
"InputArtifactConfigurationPath": "/"
},
"outputArtifacts": [],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-west-2",
"namespace": "DeployVariables"
}
]
}
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [AWS AppConfig](https://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig.html)*— Per informazioni sulle AWS AppConfig distribuzioni, consultare la Guida per l'utente.AWS Systems Manager *
+ [Tutorial: crea una pipeline da utilizzare AWS AppConfig come provider di distribuzione](tutorials-AppConfig.md)— Questo tutorial consente di iniziare a configurare semplici file e AppConfig risorse di configurazione della distribuzione e mostra come utilizzare la console per creare una pipeline con un' AWS AppConfig azione di distribuzione.
# CloudFormation distribuire un riferimento all'azione
Esegue un'operazione su uno CloudFormation stack. Uno stack è una raccolta di AWS risorse che è possibile gestire come singola unità. Le risorse di uno stack sono definite dal modello CloudFormation dello stack. Un set di modifiche crea un confronto che può essere visualizzato senza modificare lo stack originale. Per informazioni sui tipi di CloudFormation azioni che possono essere eseguite su pile e set di modifiche, consulta il `ActionMode` parametro.
Per creare un messaggio di errore per un' CloudFormation azione in cui un'operazione di stack non è riuscita, CodePipeline chiama l' CloudFormation `DescribeStackEvents`API. Se un ruolo IAM di azione è autorizzato ad accedere a quell'API, i dettagli sulla prima risorsa fallita verranno inclusi nel CodePipeline messaggio di errore. Altrimenti, se la policy relativa al ruolo non dispone dell'autorizzazione appropriata, CodePipeline ignorerà l'accesso all'API e mostrerà invece un messaggio di errore generico. A tale scopo, è necessario aggiungere l'`cloudformation:DescribeStackEvents`autorizzazione al ruolo di servizio o ad altri ruoli IAM per la pipeline.
Se non desideri che i dettagli delle risorse vengano visualizzati nei messaggi di errore della pipeline, puoi revocare questa autorizzazione per il ruolo IAM dell'azione rimuovendo l'autorizzazione. `cloudformation:DescribeStackEvents`
**Topics**
+ [Tipo di operazione](#action-reference-CloudFormation-type)
+ [Parametri di configurazione](#action-reference-CloudFormation-config)
+ [Input artifact (Artefatti di input)](#action-reference-CloudFormation-input)
+ [Artefatti di output](#action-reference-CloudFormation-output)
+ [Variabili di output](#action-reference-CloudFormation-variables)
+ [Autorizzazioni per i ruoli di servizio: azione CloudFormation](#edit-role-cloudformation)
+ [Dichiarazione dell'operazione](#action-reference-CloudFormation-example)
+ [Consulta anche](#action-reference-CloudFormation-links)
## Tipo di operazione
+ Categoria: `Deploy`
+ Proprietario: `AWS`
+ Provider: `CloudFormation`
+ Versione: `1`
## Parametri di configurazione
**ActionMode**
Obbligatorio: sì
`ActionMode`è il nome dell'azione CloudFormation eseguita su uno stack o un set di modifiche. Sono disponibili le modalità operazione seguenti:
+ `CHANGE_SET_EXECUTE` esegue un set di modifiche per lo stack di risorse basato su un set di aggiornamenti delle risorse specificati. Con questa azione, CloudFormation inizia a modificare lo stack.
+ `CHANGE_SET_REPLACE` crea il set di modifiche, se non esiste, in base al nome dello stack e al modello che invii. Se il set di modifiche esiste, lo CloudFormation elimina e ne crea uno nuovo.
+ `CREATE_UPDATE` crea lo stack, se non esiste. Se lo stack esiste, lo CloudFormation aggiorna. Utilizza questa operazione per aggiornare gli stack esistenti. Al contrario`REPLACE_ON_FAILURE`, se lo stack esiste e si trova in uno stato di errore, CodePipeline non eliminerà e sostituirà lo stack.
+ `DELETE_ONLY` elimina uno stack. Se specifichi uno stack che non esiste, l’operazione viene completata senza l’eliminazione di uno stack.
+ `REPLACE_ON_FAILURE` crea uno stack, se non esiste. Se lo stack esiste e si trova in uno stato di errore, CloudFormation elimina lo stack e ne crea uno nuovo. Se lo stack non è in uno stato di errore, lo aggiorna. CloudFormation
Lo stack si trova nello stato non riuscito quando uno dei seguenti tipi di stato viene visualizzato in CloudFormation:
+ `ROLLBACK_FAILED`
+ `CREATE_FAILED`
+ `DELETE_FAILED`
+ `UPDATE_ROLLBACK_FAILED`
Utilizza questa operazione per sostituire automaticamente gli stack non riusciti senza effettuarne il ripristino o eseguire la relativa risoluzione di problemi.
**Importante**
Ti consigliamo di utilizzare `REPLACE_ON_FAILURE` solo a scopo di test perché potrebbe eliminare lo stack.
**StackName**
Obbligatorio: sì
`StackName` è il nome di uno stack esistente o che desideri creare.
**Funzionalità**
Obbligatorio: condizionale
L'utilizzo di `Capabilities` conferma che il modello potrebbe disporre delle capacità per creare e aggiornare automaticamente alcune risorse e che queste funzionalità sono determinate in base ai tipi di risorse nel modello.
Questa proprietà è obbligatoria se disponi di risorse IAM nel modello di stack o crei uno stack direttamente da un modello contenente macro. Affinché l' CloudFormation azione funzioni correttamente in questo modo, è necessario riconoscere esplicitamente che si desidera che venga eseguita con una delle seguenti funzionalità:
+ `CAPABILITY_IAM`
+ `CAPABILITY_NAMED_IAM`
+ `CAPABILITY_AUTO_EXPAND`
Puoi specificare più funzionalità utilizzando una virgola (nessuno spazio) tra le funzionalità. L'esempio in [Dichiarazione dell'operazione](#action-reference-CloudFormation-example) mostra una voce con entrambe le proprietà CAPABILITY\$1IAM e CAPABILITY\$1AUTO\$1EXPAND.
Per ulteriori informazioni in merito`Capabilities`, consulta le proprietà [UpdateStack](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStack.html)nella sezione *AWS CloudFormation API Reference.*
**ChangeSetName**
Obbligatorio: condizionale
`ChangeSetName` il nome di un set di modifiche esistente o di uno nuovo che desideri creare per lo stack specificato.
Questa proprietà è obbligatoria per le seguenti modalità di operazione: CHANGE\$1SET\$1REPLACE e CHANGE\$1SET\$1EXECUTE. La proprietà viene ignorata per tutte le altre modalità operazione.
**RoleArn**
Obbligatorio: condizionale
`RoleArn` è l'ARN del ruolo del servizio IAM che viene assunto da CloudFormation quando utilizza risorse nello stack specificato. `RoleArn` non viene applicato durante l'esecuzione di un set di modifiche. Se non lo utilizzate CodePipeline per creare il set di modifiche, assicuratevi che al set o allo stack di modifiche sia associato un ruolo.
Questo ruolo deve trovarsi nello stesso account del ruolo per l'azione in esecuzione, come configurato nella dichiarazione `RoleArn` dell'azione.
Questa proprietà è obbligatoria per le seguenti modalità operazione:
+ CREATE\$1UPDATE
+ REPLACE\$1ON\$1FAILURE
+ DELETE\$1ONLY
+ CHANGE\$1SET\$1REPLACE
CloudFormation al modello viene assegnato un URL con firma S3; pertanto, `RoleArn` non è necessaria l'autorizzazione per accedere al bucket di artefatti. Tuttavia, l'azione `RoleArn` *richiede* l'autorizzazione per accedere al bucket di artefatti, per generare l'URL firmato.
**TemplatePath**
Obbligatorio: condizionale
`TemplatePath`rappresenta il file modello. CloudFormation Includi il file in un artefatto di input per questa operazione. Il nome del file segue questo formato:
`Artifactname::TemplateFileName`
`Artifactname` è il nome dell'artefatto di input come visualizzato in CodePipeline. Ad esempio, una fase di origine con il nome di artefatto di `SourceArtifact` e un nome file di `template-export.json` crea un nome `TemplatePath` come mostrato in questo esempio:
```
"TemplatePath": "SourceArtifact::template-export.json"
```
Questa proprietà è obbligatoria per le seguenti modalità operazione:
+ CREATE\$1UPDATE
+ REPLACE\$1ON\$1FAILURE
+ CHANGE\$1SET\$1REPLACE
La proprietà viene ignorata per tutte le altre modalità operazione.
Il file CloudFormation modello contenente il corpo del modello ha una lunghezza minima di 1 byte e una lunghezza massima di 1 MB. Per le azioni CloudFormation di distribuzione in CodePipeline, la dimensione massima dell'artefatto di input è sempre 256 MB. Per ulteriori informazioni, consulta [Quote in AWS CodePipeline](limits.md) e [Limiti di CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html).
**OutputFileName**
Obbligatorio: no
`OutputFileName`Utilizzatelo per specificare un nome di file di output, ad esempio`CreateStackOutput.json`, da CodePipeline aggiungere all'artefatto di output della pipeline per questa azione. Il file JSON contiene il contenuto della `Outputs` sezione dello stack. CloudFormation
Se non si specifica un nome, CodePipeline non genera un file o un artefatto di output.
**ParameterOverrides**
Obbligatorio: no
I parametri sono definiti nel modello di stack e consentono di fornire valori per gli stessi al momento della creazione o dell'aggiornamento dello stack. Puoi utilizzare un oggetto JSON per impostare i valori dei parametri nel modello. Questi valori sostituiscono quelli impostati nel file di configurazione del modello. Per ulteriori informazioni sull'utilizzo delle sostituzioni dei parametri, consulta [Proprietà di configurazione (oggetto JSON)](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-action-reference.html#w4363ab1c13c13b9).
Ti consigliamo di utilizzare il file di configurazione del modello per la maggior parte dei valori dei parametri. Utilizza le sostituzioni dei parametri solo per i valori che non sono noti finché la pipeline non è in esecuzione. *Per ulteriori informazioni, vedete [Using Parameter Override Functions with CodePipeline Pipelines](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-parameter-override-functions.html) nella Guida per l'utente.AWS CloudFormation *
Tutti i nomi dei parametri devono essere presenti nel modello di stack.
**TemplateConfiguration**
Obbligatorio: no
`TemplateConfiguration` è il file di configurazione del modello. Includi il file in un artefatto di input per questa operazione. Può contenere i valori di parametro del modello e una policy stack. [Per ulteriori informazioni sul formato del file di configurazione del modello, vedete AWS CloudFormation Artifacts.](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-cfn-artifacts.html)
Il nome del file di configurazione del modello segue questo formato:
`Artifactname::TemplateConfigurationFileName`
`Artifactname` è il nome dell'artefatto di input come visualizzato in CodePipeline. Ad esempio, una fase di origine con il nome di artefatto di `SourceArtifact` e un nome file di `test-configuration.json` crea un nome `TemplateConfiguration` come mostrato in questo esempio:
```
"TemplateConfiguration": "SourceArtifact::test-configuration.json"
```
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `0 to 10`
+ **Descrizione:** come input, l' CloudFormation azione accetta facoltativamente artefatti per i seguenti scopi:
+ Per fornire il file di modello dello stack da eseguire. Consulta il parametro `TemplatePath`.
+ Per fornire il file di configurazione del modello da utilizzare. Consulta il parametro `TemplateConfiguration`. [Per ulteriori informazioni sul formato del file di configurazione del modello, vedere Artifacts.AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-cfn-artifacts.html)
+ Fornire l'artefatto per una funzione Lambda da distribuire come parte dello stack. CloudFormation
## Artefatti di output
+ **Numero di artefatti:** `0 to 1`
+ **Descrizione:** se il parametro `OutputFileName` è specificato, esiste un artefatto di output prodotto da questa operazione che contiene un file JSON con il nome specificato. Il file JSON contiene i contenuti della sezione output dello stack CloudFormation .
Per ulteriori informazioni sulla sezione output che puoi creare per l'operazione CloudFormation , consulta [Output](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html).
## Variabili di output
Quando è configurata, questa azione produce variabili che possono essere referenziate dalla configurazione dell'azione di un'azione downstream nella pipeline. È possibile configurare un'azione con uno spazio dei nomi per rendere tali variabili disponibili per la configurazione delle azioni downstream.
Per CloudFormation le azioni, le variabili vengono prodotte a partire da qualsiasi valore indicato nella `Outputs` sezione di un modello di pila. Tieni presente che le uniche modalità di CloudFormation azione che generano output sono quelle che comportano la creazione o l'aggiornamento di uno stack, come la creazione dello stack, gli aggiornamenti dello stack e l'esecuzione dei set di modifiche. Le modalità di operazione corrispondenti che generano variabili sono:
+ `CHANGE_SET_EXECUTE`
+ `CHANGE_SET_REPLACE`
+ `CREATE_UPDATE`
+ `REPLACE_ON_FAILURE`
Per ulteriori informazioni, consulta [Riferimento alle variabili](reference-variables.md). Per un tutorial che mostra come creare una pipeline con un'azione di CloudFormation distribuzione in una pipeline che utilizza variabili di output, consulta. CloudFormation [Tutorial: crea una pipeline che utilizza le variabili delle azioni di AWS CloudFormation distribuzione](tutorials-cloudformation-action.md)
## Autorizzazioni per i ruoli di servizio: azione CloudFormation
Quando CodePipeline viene eseguita l'azione, la policy del ruolo di CodePipeline servizio richiede le seguenti autorizzazioni, assegnate in modo appropriato all'ARN della risorsa della pipeline per mantenere l'accesso con il minimo privilegio. Ad esempio, aggiungi quanto segue alla tua dichiarazione politica:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowCFNStackAccess",
"Effect": "Allow",
"Action": [
"cloudformation:CreateStack",
"cloudformation:UpdateStack",
"cloudformation:DeleteStack",
"cloudformation:DescribeStacks",
"cloudformation:DescribeStackResources",
"cloudformation:DescribeStackEvents",
"cloudformation:GetTemplate",
"cloudformation:DescribeChangeSet",
"cloudformation:CreateChangeSet",
"cloudformation:DeleteChangeSet",
"cloudformation:ExecuteChangeSet"
],
"Resource": [
"arn:aws:cloudformation:*:111122223333:stack/[[cfnDeployStackNames]]/*"
]
},
{
"Sid": "ValidateTemplate",
"Effect": "Allow",
"Action": [
"cloudformation:ValidateTemplate"
],
"Resource": "*"
},
{
"Sid": "AllowIAMPassRole",
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/[[cfnExecutionRoles]]"
],
"Condition": {
"StringEqualsIfExists": {
"iam:PassedToService": [
"cloudformation.amazonaws.com"
]
}
}
}
]
}
```
------
Tieni presente che l'`cloudformation:DescribeStackEvents`autorizzazione è facoltativa. Consente all' CloudFormation azione di mostrare un messaggio di errore più dettagliato. Questa autorizzazione può essere revocata dal ruolo IAM se non desideri che i dettagli delle risorse vengano visualizzati nei messaggi di errore della pipeline.
## Dichiarazione dell'operazione
------
#### [ YAML ]
```
Name: ExecuteChangeSet
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormation
Version: '1'
RunOrder: 2
Configuration:
ActionMode: CHANGE_SET_EXECUTE
Capabilities: CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND
ChangeSetName: pipeline-changeset
ParameterOverrides: '{"ProjectId": "my-project","CodeDeployRole": "CodeDeploy_Role_ARN"}'
RoleArn: CloudFormation_Role_ARN
StackName: my-project--lambda
TemplateConfiguration: 'my-project--BuildArtifact::template-configuration.json'
TemplatePath: 'my-project--BuildArtifact::template-export.yml'
OutputArtifacts: []
InputArtifacts:
- Name: my-project-BuildArtifact
```
------
#### [ JSON ]
```
{
"Name": "ExecuteChangeSet",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CloudFormation",
"Version": "1"
},
"RunOrder": 2,
"Configuration": {
"ActionMode": "CHANGE_SET_EXECUTE",
"Capabilities": "CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND",
"ChangeSetName": "pipeline-changeset",
"ParameterOverrides": "{\"ProjectId\": \"my-project\",\"CodeDeployRole\": \"CodeDeploy_Role_ARN\"}",
"RoleArn": "CloudFormation_Role_ARN",
"StackName": "my-project--lambda",
"TemplateConfiguration": "my-project--BuildArtifact::template-configuration.json",
"TemplatePath": "my-project--BuildArtifact::template-export.yml"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "my-project-BuildArtifact"
}
]
},
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Riferimento alle proprietà di configurazione](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-action-reference.html): questo capitolo di riferimento della *Guida per l'AWS CloudFormation utente* fornisce ulteriori descrizioni ed esempi per questi parametri. CodePipeline
+ [AWS CloudFormation Riferimento API](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/): il [CreateStack](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html)parametro nel *riferimento AWS CloudFormation API* descrive i parametri dello stack per i CloudFormation modelli.
# CloudFormation StackSets distribuire un riferimento all'azione
CodePipeline offre la possibilità di eseguire CloudFormation StackSets operazioni come parte del processo CI/CD. È possibile utilizzare un set di stack per creare pile negli AWS account di tutte AWS le regioni utilizzando un unico modello. CloudFormation Tutte le risorse incluse in ogni stack sono definite dal modello del set di stack. CloudFormation Quando create il set di stack, specificate il modello da utilizzare, nonché tutti i parametri e le funzionalità richiesti dal modello.
Per ulteriori informazioni sui concetti di CloudFormation StackSets, consulta [StackSets i concetti](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-concepts.html) nella *Guida per l'AWS CloudFormation utente*.
Puoi integrare la tua pipeline CloudFormation StackSets attraverso due tipi di azioni distinti che usi insieme:
+ L'`CloudFormationStackSet`azione crea o aggiorna un set di stack o istanze di stack dal modello memorizzato nella posizione di origine della pipeline. Ogni volta che uno stack set viene creato o aggiornato, avvia una distribuzione di tali modifiche su istanze specifiche. Nella console, puoi scegliere il provider di azioni **CloudFormation Stack Set** quando crei o modifichi la tua pipeline.
+ L'`CloudFormationStackInstances`azione distribuisce le modifiche dall'`CloudFormationStackSet`azione alle istanze specificate, crea nuove istanze dello stack e definisce le sostituzioni dei parametri alle istanze specificate. Nella console, puoi scegliere il provider di azioni **CloudFormation Stack Instances** quando modifichi una pipeline esistente.
È possibile utilizzare queste azioni per eseguire la distribuzione su AWS account di destinazione o sull'unità IDs organizzativa AWS Organizations di destinazione.
**Nota**
Per eseguire la distribuzione sugli account o sull'unità organizzativa di destinazione di AWS Organizations IDs e utilizzare il modello di autorizzazioni gestite dal servizio, è necessario abilitare l'accesso affidabile tra e Organizzazioni. AWS CloudFormation StackSets AWS Per ulteriori informazioni, consulta [Enabling trusted](https://docs.aws.amazon.com/organizations/latest/userguide/services-that-can-integrate-cloudformation.html#integrate-enable-ta-cloudformation) access with Stacksets. AWS CloudFormation
**Topics**
+ [Come funzionano le CloudFormation StackSets azioni](#action-reference-StackSets-concepts)
+ [Come strutturare le StackSets azioni in una pipeline](#action-reference-StackSets-bestpractices)
+ [L'operazione `CloudFormationStackSet`](#action-reference-StackSet)
+ [L'azione CloudFormationStackInstances](#action-reference-StackInstances)
+ [Autorizzazioni per i ruoli di servizio: azione `CloudFormationStackSet`](#edit-role-cfn-stackset)
+ [Autorizzazioni per i ruoli di servizio: azione `CloudFormationStackInstances`](#edit-role-cfn-stackinstances)
+ [Modelli di autorizzazioni per le operazioni relative agli stack set](#action-reference-StackSets-permissions)
+ [Tipi di dati dei parametri del modello](#action-reference-StackSets-datatypes)
+ [Consulta anche](#action-reference-CloudFormation-links)
## Come funzionano le CloudFormation StackSets azioni
Un'`CloudFormationStackSet`azione crea o aggiorna risorse a seconda che l'azione venga eseguita per la prima volta.
L'`CloudFormationStackSet`azione *crea* o *aggiorna* il set di stack e distribuisce tali modifiche in istanze specifiche.
**Nota**
Se si utilizza questa azione per effettuare un aggiornamento che include l'aggiunta di istanze dello stack, le nuove istanze vengono distribuite per prime e l'aggiornamento viene completato per ultime. Le nuove istanze ricevono prima la versione precedente, quindi l'aggiornamento viene applicato a tutte le istanze.
+ *Crea*: quando non viene specificata alcuna istanza e lo stack set non esiste, l'**CloudFormationStackSet**azione crea il set di stack senza creare alcuna istanza.
+ *Aggiornamento*: quando l'**CloudFormationStackSet**azione viene eseguita per un set di stack già creato, l'azione aggiorna il set di stack. Se non viene specificata alcuna istanza e lo stack set esiste già, tutte le istanze vengono aggiornate. Se questa azione viene utilizzata per aggiornare istanze specifiche, tutte le istanze rimanenti passano allo stato OBSOLETO.
È possibile utilizzare l'**CloudFormationStackSet**azione per aggiornare lo stack set nei seguenti modi.
+ Aggiorna il modello su alcune o tutte le istanze.
+ Aggiorna i parametri su alcune o tutte le istanze.
+ Aggiorna il ruolo di esecuzione per lo stack set (deve corrispondere al ruolo di esecuzione specificato nel ruolo Amministratore).
+ Modificate il modello di autorizzazioni (solo se non sono state create istanze).
+ Abilita/disabilita `AutoDeployment` se il modello di permessi del set di stack è. `Service Managed`
+ Agisci come amministratore delegato in un account membro se il modello di autorizzazioni dello stack set lo è. `Service Managed`
+ Aggiorna il ruolo di amministratore.
+ Aggiorna la descrizione sullo stack set.
+ Aggiungi obiettivi di distribuzione all'aggiornamento del set di stack per creare nuove istanze dello stack.
L'`CloudFormationStackInstances`azione crea nuove istanze dello stack o aggiorna le istanze dello stack obsolete. Un'istanza diventa obsoleta quando un set di stack viene aggiornato, ma non tutte le istanze al suo interno vengono aggiornate.
+ *Crea*: se lo stack esiste già, l'`CloudFormationStackInstances`azione aggiorna solo le istanze e non crea istanze dello stack.
+ *Aggiornamento*: dopo l'esecuzione dell'`CloudFormationStackSet`azione, se il modello o i parametri sono stati aggiornati solo in alcuni casi, il resto verrà contrassegnato. `OUTDATED` Nelle fasi successive della pipeline, `CloudFormationStackInstances` aggiorna il resto delle istanze dello stack in ondate in modo che tutte le istanze siano contrassegnate. `CURRENT` Questa azione può essere utilizzata anche per aggiungere istanze aggiuntive o sostituire parametri su istanze nuove o esistenti.
Come parte di un aggiornamento, le `CloudFormationStackInstances` azioni `CloudFormationStackSet` and possono specificare nuovi obiettivi di distribuzione, che creano nuove istanze stack.
Come parte di un aggiornamento, le `CloudFormationStackInstances` azioni `CloudFormationStackSet` and non eliminano set di stack, istanze o risorse. Quando l'azione aggiorna uno stack ma non specifica tutte le istanze da aggiornare, le istanze che non erano state specificate per l'aggiornamento vengono rimosse dall'aggiornamento e impostate su uno stato di. `OUTDATED`
Durante una distribuzione, le istanze dello stack possono anche mostrare lo stato `OUTDATED` se la distribuzione sulle istanze non è riuscita.
## Come strutturare le StackSets azioni in una pipeline
Come best practice, è consigliabile costruire la pipeline in modo che lo stack set venga creato e inizialmente distribuito su un sottoinsieme o su una singola istanza. Dopo aver testato la distribuzione e visualizzato lo stack set generato, aggiungete l'`CloudFormationStackInstances`azione in modo che le istanze rimanenti vengano create e aggiornate.
Utilizza la console o la CLI per creare la struttura di pipeline consigliata come segue:
1. Crea una pipeline con un'azione di origine (obbligatoria) e l'`CloudFormationStackSet`azione come azione di distribuzione. Esegui la tua pipeline.
1. Quando la pipeline viene eseguita per la prima volta, l'`CloudFormationStackSet`azione *crea* il set di stack e almeno un'istanza iniziale. Verifica la creazione del set di stack ed esamina la distribuzione sull'istanza iniziale. Ad esempio, per la creazione iniziale dello stack set per l'account Account-A dove si `us-east-1` trova la regione specificata, l'istanza dello stack viene creata con lo stack set:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/action-reference-StackSets.html)
1. Modifica la pipeline e create/update aggiungila `CloudFormationStackInstances` come seconda azione di distribuzione per impilare le istanze per gli obiettivi designati. Ad esempio, per la creazione di istanze stack per un account `Account-A` in cui sono specificate le `eu-central-1` regioni `us-east-2` e, le istanze dello stack rimanenti vengono create e l'istanza iniziale rimane aggiornata come segue:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/action-reference-StackSets.html)
1. Esegui la pipeline secondo necessità per aggiornare il set di stack e aggiornare o creare istanze dello stack.
Quando si avvia un aggiornamento dello stack in cui sono stati rimossi gli obiettivi di distribuzione dalla configurazione dell'azione, le istanze dello stack che non erano destinate all'aggiornamento vengono rimosse dalla distribuzione e passano allo stato OBSOLETO. Ad esempio, per l'aggiornamento dell'istanza dello stack per l'account `Account-A` in cui la `us-east-2` regione viene rimossa dalla configurazione dell'azione, vengono create le istanze dello stack rimanenti e l'istanza rimossa viene impostata su OBSOLETA come segue:
****
| Istanza Stack | Region | Status |
| --- | --- | --- |
| StackInstanceID-1 | us-east-1 | CURRENT |
| StackInstanceID-2 | us-east-2 | ANTIQUATO |
| StackInstanceID-3 | eu-central-1 | CURRENT |
*Per ulteriori informazioni sulle migliori pratiche per la distribuzione dei set di stack, consulta la sezione [Best practice StackSets nella Guida](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-bestpractices.html) per l'AWS CloudFormation utente.*
## L'operazione `CloudFormationStackSet`
Questa azione crea o aggiorna uno stack set a partire dal modello memorizzato nella posizione di origine della pipeline.
Dopo aver definito un set di stack, è possibile creare, aggiornare o eliminare gli stack negli account e nelle regioni di destinazione specificati nei parametri di configurazione. Durante la creazione, l'aggiornamento e l'eliminazione degli stack, è possibile specificare altre preferenze, come l'ordine delle regioni per le operazioni da eseguire, la percentuale di tolleranza agli errori oltre la quale le operazioni dello stack si interrompono e il numero di account in cui le operazioni vengono eseguite contemporaneamente sugli stack.
Un set di stack è una risorsa di livello regionale. Se si crea uno stack impostato in una AWS regione, non è possibile accedervi da altre regioni.
Quando questa azione viene utilizzata come azione di aggiornamento dello stack set, gli aggiornamenti allo stack non sono consentiti senza una distribuzione su almeno un'istanza dello stack.
**Topics**
+ [Tipo di operazione](#action-reference-StackSet-type)
+ [Parametri di configurazione](#action-reference-StackSet-config)
+ [Input artifact (Artefatti di input)](#action-reference-StackSet-input)
+ [Artefatti di output](#action-reference-StackSet-output)
+ [Variabili di output](#action-reference-StackSet-variables)
+ [Esempio di configurazione **CloudFormationStackSet**dell'azione](#action-reference-StackSet-example)
### Tipo di operazione
+ Categoria: `Deploy`
+ Proprietario: `AWS`
+ Provider: `CloudFormationStackSet`
+ Versione: `1`
### Parametri di configurazione
**StackSetName**
Obbligatorio: sì
Il nome da associare al set di stack. Questo nome deve essere univoco nella regione in cui è stato creato.
Il nome può contenere solo caratteri alfanumerici e trattini. Deve iniziare con un carattere alfabetico e contenere al massimo 128 caratteri.
**Description**
Obbligatorio: no
Una descrizione del set di stack. Puoi usarlo per descrivere lo scopo del set di stack o altre informazioni pertinenti.
**TemplatePath**
Obbligatorio: sì
La posizione del modello che definisce le risorse nello stack set. Deve puntare a un modello con una dimensione massima di 460.800 byte.
Immettete il percorso del nome dell'artefatto di origine e del file modello nel formato`"InputArtifactName::TemplateFileName"`, come illustrato nell'esempio seguente.
```
SourceArtifact::template.txt
```
**Parameters**
Obbligatorio: no
Un elenco di parametri del modello per il set di stack da aggiornare durante una distribuzione.
Puoi fornire i parametri come elenco letterale o percorso di file:
+ È possibile inserire i parametri nel seguente formato di sintassi abbreviata:. `ParameterKey=string,ParameterValue=string,UsePreviousValue=boolean,ResolvedValue=string ParameterKey=string,ParameterValue=string,UsePreviousValue=boolean,ResolvedValue=string` Per ulteriori informazioni su questi tipi di dati, vedere. [Tipi di dati dei parametri del modello](#action-reference-StackSets-datatypes)
L'esempio seguente mostra un parametro denominato `BucketName` con il valore`amzn-s3-demo-source-bucket`.
```
ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket
```
L'esempio seguente mostra una voce con più parametri:
```
ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket
ParameterKey=Asset1,ParameterValue=true
ParameterKey=Asset2,ParameterValue=true
```
+ È possibile immettere la posizione del file contenente un elenco di sostituzioni dei parametri del modello immesse nel formato`"InputArtifactName::ParametersFileName"`, come illustrato nell'esempio seguente.
```
SourceArtifact::parameters.txt
```
L'esempio seguente mostra il contenuto del file per. `parameters.txt`
```
[
{
"ParameterKey": "KeyName",
"ParameterValue": "true"
},
{
"ParameterKey": "KeyName",
"ParameterValue": "true"
}
]
```
**Funzionalità**
Obbligatorio: no
Indica che il modello può creare e aggiornare risorse, a seconda dei tipi di risorse presenti nel modello.
È necessario utilizzare questa proprietà se nel modello di stack sono presenti risorse IAM o se si crea uno stack direttamente da un modello contenente macro. CloudFormation Affinché l'azione funzioni correttamente in questo modo, è necessario utilizzare una delle seguenti funzionalità:
+ `CAPABILITY_IAM`
+ `CAPABILITY_NAMED_IAM`
È possibile specificare più di una funzionalità utilizzando una virgola e senza spazi tra le funzionalità. L'esempio in [Esempio di configurazione **CloudFormationStackSet**dell'azione](#action-reference-StackSet-example) mostra una voce con funzionalità multiple.
**PermissionModel**
Obbligatorio: no
Determina come vengono creati e gestiti i ruoli IAM. Se il campo non è specificato, viene utilizzato il valore predefinito. Per informazioni, consulta [Modelli di autorizzazioni per le operazioni relative agli stack set](#action-reference-StackSets-permissions).
I valori validi sono:
+ `SELF_MANAGED`(impostazione predefinita): è necessario creare ruoli di amministratore ed esecuzione da distribuire agli account di destinazione.
+ `SERVICE_MANAGED`: crea CloudFormation StackSets automaticamente i ruoli IAM necessari per la distribuzione negli account gestiti da AWS Organizations. Ciò richiede che un account sia membro di un'organizzazione.
Questo parametro può essere modificato solo quando non esistono istanze di stack nello stack set.
****AdministrationRoleArn****
Poiché CloudFormation StackSets esegue operazioni su più account, è necessario definire le autorizzazioni necessarie in tali account prima di poter creare lo stack set.
Obbligatorio: no
Questo parametro è facoltativo per il modello di autorizzazioni SELF\$1MANAGED e non viene utilizzato per il modello di autorizzazioni SERVICE\$1MANAGED.
L'ARN del ruolo IAM nell'account amministratore utilizzato per eseguire operazioni di stack set.
Il nome può contenere caratteri alfanumerici, uno dei seguenti caratteri: \$1\$1=, .@- e senza spazi. Il nome non fa distinzione tra maiuscole e minuscole. Questo nome di ruolo deve avere una lunghezza minima di 20 caratteri e una lunghezza massima di 2048 caratteri. I nomi dei ruoli devono essere univoci all'interno dell'account. Il nome del ruolo specificato qui deve essere un nome di ruolo esistente. Se non si specifica il nome del ruolo, viene impostato su AWSCloudFormationStackSetAdministrationRole. Se si specifica ServiceManaged, non è necessario definire un nome di ruolo.
****ExecutionRoleName****
Poiché CloudFormation StackSets esegue operazioni su più account, è necessario definire le autorizzazioni necessarie in tali account prima di poter creare lo stack set.
Obbligatorio: no
Questo parametro è facoltativo per il modello di autorizzazioni SELF\$1MANAGED e non viene utilizzato per il modello di autorizzazioni SERVICE\$1MANAGED.
Il nome del ruolo IAM negli account di destinazione utilizzati per eseguire le operazioni di stack set. Il nome può contenere caratteri alfanumerici, uno dei seguenti caratteri: \$1\$1=, .@- e senza spazi. Il nome non fa distinzione tra maiuscole e minuscole. Questo nome di ruolo deve avere una lunghezza minima di 1 carattere e una lunghezza massima di 64 caratteri. I nomi dei ruoli devono essere univoci all'interno dell'account. Il nome del ruolo specificato qui deve essere un nome di ruolo esistente. Non specificare questo ruolo se si utilizzano ruoli di esecuzione personalizzati. Se non si specifica il nome del ruolo, viene impostato su`AWSCloudFormationStackSetExecutionRole`. Se si imposta Service\$1Managed su true, non è necessario definire un nome di ruolo.
****OrganizationsAutoDeployment****
Obbligatorio: no
Questo parametro è facoltativo per il modello di autorizzazioni SERVICE\$1MANAGED e non viene utilizzato per il modello di autorizzazioni SELF\$1MANAGED.
Descrive se CloudFormation StackSets viene distribuito automaticamente agli account AWS Organizations aggiunti a un'organizzazione o a un'unità organizzativa (OU) di destinazione. Se `OrganizationsAutoDeployment` è specificato, non specificare `DeploymentTargets` e`Regions`.
Se non viene fornito alcun input`OrganizationsAutoDeployment`, il valore predefinito è`Disabled`.
I valori validi sono:
+ `Enabled`. Obbligatorio: No.
StackSets distribuisce automaticamente istanze stack aggiuntive agli account AWS Organizations che vengono aggiunti a un'organizzazione o unità organizzativa (OU) di destinazione nelle regioni specificate. Se un account viene rimosso da un'organizzazione o unità organizzativa di destinazione, CloudFormation StackSets elimina le istanze dello stack dall'account nelle regioni specificate.
+ `Disabled`. Obbligatorio: No.
StackSets non distribuisce automaticamente istanze stack aggiuntive agli account AWS Organizations che vengono aggiunti a un'organizzazione o unità organizzativa (OU) di destinazione nelle regioni specificate.
+ `EnabledWithStackRetention`. Obbligatorio: No.
Le risorse dello stack vengono conservate quando un account viene rimosso da un'organizzazione o unità organizzativa di destinazione.
****DeploymentTargets****
Obbligatorio: no
Per il modello di autorizzazioni SERVICE\$1MANAGED, è possibile fornire l'ID radice dell'organizzazione o l'unità organizzativa per gli obiettivi di distribuzione. IDs Per il modello di autorizzazioni SELF\$1MANAGED, puoi fornire solo account.
**Quando questo parametro è selezionato, è necessario selezionare anche Regioni.**
Un elenco di AWS account o unità organizzative IDs in cui è necessario creare/aggiornare le istanze dello stack set.
+ **Account:**
È possibile fornire gli account come elenco letterale o percorso di file:
+ *Letterale*: immettete i parametri nel formato sintattico abbreviato`account_ID,account_ID`, come illustrato nell'esempio seguente.
```
111111222222,333333444444
```
+ *Percorso del file:* la posizione del file contenente un elenco di AWS account in cui le istanze dello stack set devono essere create/aggiornate, inserita nel formato. `InputArtifactName::AccountsFileName` Se si utilizza il percorso del file per specificare **gli account** oppure **OrganizationalUnitIds**, il formato del file deve essere in JSON, come illustrato nell'esempio seguente.
```
SourceArtifact::accounts.txt
```
L'esempio seguente mostra il contenuto del file per`accounts.txt`.
```
[
"111111222222"
]
```
L'esempio seguente mostra il contenuto del file per `accounts.txt` quando si elencano più di un account:
```
[
"111111222222","333333444444"
]
```
+ **OrganizationalUnitIds**:
**Nota**
Questo parametro è facoltativo per il modello di autorizzazioni SERVICE\$1MANAGED e non viene utilizzato per il modello di autorizzazioni SELF\$1MANAGED. Non utilizzarlo se si seleziona. **OrganizationsAutoDeployment**
Le unità AWS organizzative in cui aggiornare le istanze dello stack associate.
Puoi fornire l'unità organizzativa IDs come elenco letterale o percorso di file:
+ *Letterale*: inserisci una matrice di stringhe separate da virgole, come illustrato nell'esempio seguente.
```
ou-examplerootid111-exampleouid111,ou-examplerootid222-exampleouid222
```
+ *Percorso del file:* la posizione del file contenente un elenco OrganizationalUnitIds in cui creare o aggiornare le istanze dello stack set. Se si utilizza il percorso del file per specificare **gli account** oppure **OrganizationalUnitIds**, il formato del file deve essere in JSON, come illustrato nell'esempio seguente.
Immettete il percorso del file nel formato`InputArtifactName::OrganizationalUnitIdsFileName`.
```
SourceArtifact::OU-IDs.txt
```
L'esempio seguente mostra il contenuto del file per`OU-IDs.txt`:
```
[
"ou-examplerootid111-exampleouid111","ou-examplerootid222-exampleouid222"
]
```
****Regioni****
Obbligatorio: no
Quando questo parametro è selezionato, è necessario selezionare anche **DeploymentTargets**.
Un elenco di AWS regioni in cui vengono create o aggiornate le istanze dello stack set. Le regioni vengono aggiornate nell'ordine in cui vengono inserite.
Immettete un elenco di AWS regioni valide nel formato`Region1,Region2`, come illustrato nell'esempio seguente.
```
us-west-2,us-east-1
```
****FailureTolerancePercentage****
Obbligatorio: no
La percentuale di account per regione per i quali questa operazione di stack può fallire prima che l' CloudFormation operazione venga interrotta in quella regione. Se l'operazione viene interrotta in una regione, CloudFormation non tenta l'operazione nelle regioni successive. Quando si calcola il numero di conti in base alla percentuale specificata, viene CloudFormation arrotondato per *difetto* al numero intero successivo.
****MaxConcurrentPercentage****
Obbligatorio: no
La percentuale massima di account in cui eseguire questa operazione simultaneamente. *Quando si calcola il numero di conti in base alla percentuale specificata, CloudFormation arrotonda per difetto al numero intero successivo.* Se l'arrotondamento per difetto dà come risultato zero, CloudFormation imposta invece il numero a uno. Sebbene si utilizzi questa impostazione per specificare il *valore massimo*, per le distribuzioni di grandi dimensioni il numero effettivo di account su cui si agisce contemporaneamente potrebbe essere inferiore a causa della limitazione del servizio.
**RegionConcurrencyType**
Obbligatorio: no
È possibile specificare se lo stack set deve essere distribuito in Regioni AWS sequenza o in parallelo configurando il parametro Region concurrency deployment. Quando viene specificata la concorrenza Region per distribuire stack su più stack in Regioni AWS parallelo, ciò può comportare tempi di implementazione complessivi più rapidi.
+ *Parallelo*: le implementazioni di set di stack verranno eseguite contemporaneamente, a condizione che gli errori di distribuzione in una regione non superino una tolleranza di errore specificata.
+ *Sequenziale*: le implementazioni di set di stack verranno eseguite una alla volta, a condizione che gli errori di distribuzione in una regione non superino una tolleranza di errore specificata. La distribuzione sequenziale è la selezione predefinita.
**ConcurrencyMode**
Obbligatorio: no
La modalità di concorrenza consente di scegliere il comportamento del livello di concorrenza durante le operazioni di stack set, con una tolleranza agli errori rigorosa o morbida. La **tolleranza rigorosa ai guasti** riduce la velocità di implementazione quando si verificano errori nelle operazioni del set di stack, poiché la simultaneità diminuisce per ogni errore. **Soft Failure Tolerance** dà priorità alla velocità di implementazione sfruttando al contempo le funzionalità di sicurezza. CloudFormation
+ `STRICT_FAILURE_TOLERANCE`: Questa opzione riduce dinamicamente il livello di concorrenza per garantire che il numero di account falliti non superi mai una particolare tolleranza di errore. Questo è il comportamento che segue di default.
+ `SOFT_FAILURE_TOLERANCE`: questa opzione disaccoppia la tolleranza agli errori dalla concorrenza effettiva. Ciò consente alle operazioni di stack set di essere eseguite a un livello di concorrenza prestabilito, indipendentemente dal numero di errori.
**CallAs**
Obbligatorio: no
Questo parametro è facoltativo per il modello di `SERVICE_MANAGED` autorizzazioni e non viene utilizzato per il modello di autorizzazioni. `SELF_MANAGED`
Speciifica se si agisce nell'account di gestione dell'organizzazione o come amministratore delegato in un account membro.
Se questo parametro è impostato su`DELEGATED_ADMIN`, assicurati che il ruolo IAM della pipeline disponga dell'autorizzazione. `organizations:ListDelegatedAdministrators` In caso contrario, l'azione avrà esito negativo durante l'esecuzione con un errore simile al seguente:`Account used is not a delegated administrator`.
+ `SELF`: La distribuzione di Stack Set utilizzerà le autorizzazioni gestite dal servizio una volta effettuato l'accesso all'account di gestione.
+ `DELEGATED_ADMIN`: la distribuzione di Stack Set utilizzerà le autorizzazioni gestite dal servizio una volta effettuato l'accesso a un account amministratore delegato.
### Input artifact (Artefatti di input)
È necessario includere almeno un elemento di input che contenga il modello per lo stack set in un'azione. `CloudFormationStackSet` È possibile includere più artefatti di input per elenchi di obiettivi, account e parametri di distribuzione.
+ **Numero di artefatti:** `1 to 3`
+ **Descrizione:** puoi includere artefatti per fornire:
+ Il file modello dello stack. Consulta il parametro `TemplatePath`.
+ Il file dei parametri. Consulta il parametro `Parameters`.
+ Il file degli account. Consulta il parametro `DeploymentTargets`.
### Artefatti di output
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di output non si applicano a questo tipo di azione.
### Variabili di output
Se si configura questa azione, produce variabili a cui può fare riferimento la configurazione dell'azione di un'azione a valle nella pipeline. È possibile configurare un'azione con uno spazio dei nomi per rendere tali variabili disponibili per la configurazione delle azioni downstream.
+ **StackSetId**: L'ID dello stack set.
+ **OperationId**: L'ID dell'operazione di set di stack.
Per ulteriori informazioni, consulta [Riferimento alle variabili](reference-variables.md).
### Esempio di configurazione **CloudFormationStackSet**dell'azione
Gli esempi seguenti mostrano la configurazione dell'**CloudFormationStackSet**azione.
#### Esempio di modello di autorizzazioni autogestite
L'esempio seguente mostra un'**CloudFormationStackSet**azione in cui l'obiettivo di distribuzione immesso è un ID AWS account.
------
#### [ YAML ]
```
Name: CreateStackSet
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormationStackSet
Version: '1'
RunOrder: 1
Configuration:
DeploymentTargets: '111111222222'
FailureTolerancePercentage: '20'
MaxConcurrentPercentage: '25'
PermissionModel: SELF_MANAGED
Regions: us-east-1
StackSetName: my-stackset
TemplatePath: 'SourceArtifact::template.json'
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "CreateStackSet",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CloudFormationStackSet",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"DeploymentTargets": "111111222222",
"FailureTolerancePercentage": "20",
"MaxConcurrentPercentage": "25",
"PermissionModel": "SELF_MANAGED",
"Regions": "us-east-1",
"StackSetName": "my-stackset",
"TemplatePath": "SourceArtifact::template.json"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
```
------
#### Esempio del modello di autorizzazioni gestite dal servizio
L'esempio seguente mostra un'**CloudFormationStackSet**azione per il modello di autorizzazioni gestite dal servizio in cui l'opzione per la distribuzione automatica in AWS Organizations è abilitata con stack retention.
------
#### [ YAML ]
```
Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormationStackSet
Version: '1'
RunOrder: 1
Configuration:
Capabilities: 'CAPABILITY_IAM,CAPABILITY_NAMED_IAM'
OrganizationsAutoDeployment: EnabledWithStackRetention
PermissionModel: SERVICE_MANAGED
StackSetName: stacks-orgs
TemplatePath: 'SourceArtifact::template.json'
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: eu-central-1
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CloudFormationStackSet",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"Capabilities": "CAPABILITY_IAM,CAPABILITY_NAMED_IAM",
"OrganizationsAutoDeployment": "EnabledWithStackRetention",
"PermissionModel": "SERVICE_MANAGED",
"StackSetName": "stacks-orgs",
"TemplatePath": "SourceArtifact::template.json"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "eu-central-1",
"Namespace": "DeployVariables"
}
```
------
## L'azione CloudFormationStackInstances
Questa azione crea nuove istanze e distribuisce set di stack su istanze specifiche. Un'istanza di stack è un riferimento a uno stack in un account target all'interno di una Regione. Un'istanza dello stack può esistere senza uno stack; ad esempio, se la creazione dello stack non ha esito positivo, l'istanza dello stack mostra il motivo dell'errore di creazione dello stack. Un'istanza di stack è associata a un solo set di stack.
Dopo la creazione iniziale di un set di stack, puoi aggiungere nuove istanze di stack utilizzando. `CloudFormationStackInstances` I valori dei parametri del modello possono essere sovrascritti a livello di istanza dello stack durante le operazioni di creazione o aggiornamento dell'istanza dello stack set.
Ogni set di stack ha un modello e un set di parametri di modello. Quando aggiorni il modello o i parametri del modello, li aggiorni per l'intero set. Quindi tutti gli stati dell'istanza vengono impostati su `OUTDATED` fino a quando le modifiche non vengono distribuite a quell'istanza.
Per sovrascrivere i valori dei parametri su istanze specifiche, ad esempio, se il modello contiene un parametro per `stage` con un valore di`prod`, è possibile sovrascrivere il valore di quel parametro come o. `beta` `gamma`
**Topics**
+ [Tipo di operazione](#action-reference-StackInstances-type)
+ [Parametri di configurazione](#action-reference-StackInstances-config)
+ [Input artifact (Artefatti di input)](#action-reference-StackInstances-input)
+ [Artefatti di output](#action-reference-StackInstances-output)
+ [Variabili di output](#action-reference-StackInstances-variables)
+ [Esempio di configurazione dell'operazione](#action-reference-StackInstances-example)
### Tipo di operazione
+ Categoria: `Deploy`
+ Proprietario: `AWS`
+ Provider: `CloudFormationStackInstances`
+ Versione: `1`
### Parametri di configurazione
**StackSetName**
Obbligatorio: sì
Il nome da associare al set di stack. Questo nome deve essere univoco nella regione in cui è stato creato.
Il nome può contenere solo caratteri alfanumerici e trattini. Deve iniziare con un carattere alfabetico e contenere al massimo 128 caratteri.
****DeploymentTargets****
Obbligatorio: no
Per il modello di autorizzazioni SERVICE\$1MANAGED, è possibile fornire l'ID radice dell'organizzazione o l'unità organizzativa per gli obiettivi di distribuzione. IDs Per il modello di autorizzazioni SELF\$1MANAGED, puoi fornire solo account.
**Quando questo parametro è selezionato, è necessario selezionare anche Regioni.**
Un elenco di AWS account o unità organizzative IDs in cui è necessario creare/aggiornare le istanze dello stack set.
+ **Account:**
È possibile fornire gli account come elenco letterale o percorso di file:
+ *Letterale*: immettete i parametri nel formato sintattico abbreviato`account_ID,account_ID`, come illustrato nell'esempio seguente.
```
111111222222,333333444444
```
+ *Percorso del file:* la posizione del file contenente un elenco di AWS account in cui le istanze dello stack set devono essere create/aggiornate, inserita nel formato. `InputArtifactName::AccountsFileName` Se si utilizza il percorso del file per specificare **gli account** oppure **OrganizationalUnitIds**, il formato del file deve essere in JSON, come illustrato nell'esempio seguente.
```
SourceArtifact::accounts.txt
```
L'esempio seguente mostra il contenuto del file per`accounts.txt`:
```
[
"111111222222"
]
```
L'esempio seguente mostra il contenuto del file per `accounts.txt` quando si elencano più di un account:
```
[
"111111222222","333333444444"
]
```
+ **OrganizationalUnitIds**:
**Nota**
Questo parametro è facoltativo per il modello di autorizzazioni SERVICE\$1MANAGED e non viene utilizzato per il modello di autorizzazioni SELF\$1MANAGED. Non utilizzarlo se si seleziona. **OrganizationsAutoDeployment**
Le unità AWS organizzative in cui aggiornare le istanze dello stack associate.
È possibile fornire un'unità organizzativa IDs come elenco letterale o percorso di file.
+ *Letterale*: immettete una matrice di stringhe separate da virgole, come illustrato nell'esempio seguente.
```
ou-examplerootid111-exampleouid111,ou-examplerootid222-exampleouid222
```
+ *Percorso del file:* la posizione del file contenente un elenco OrganizationalUnitIds in cui creare o aggiornare le istanze dello stack set. Se si utilizza il percorso del file per specificare **gli account** oppure **OrganizationalUnitIds**, il formato del file deve essere in JSON, come illustrato nell'esempio seguente.
Immettete il percorso del file nel formato`InputArtifactName::OrganizationalUnitIdsFileName`.
```
SourceArtifact::OU-IDs.txt
```
L'esempio seguente mostra il contenuto del file per`OU-IDs.txt`:
```
[
"ou-examplerootid111-exampleouid111","ou-examplerootid222-exampleouid222"
]
```
****Regioni****
Obbligatorio: sì
Quando questo parametro è selezionato, è necessario selezionare anche **DeploymentTargets**.
Un elenco di AWS regioni in cui vengono create o aggiornate le istanze dello stack set. Le regioni vengono aggiornate nell'ordine in cui vengono inserite.
Immettete un elenco di AWS regioni valide nel formato:`Region1,Region2`, come illustrato nell'esempio seguente.
```
us-west-2,us-east-1
```
**ParameterOverrides**
Obbligatorio: no
Un elenco di parametri dello stack set che desideri sovrascrivere nelle istanze dello stack selezionate. I valori dei parametri sostituiti vengono applicati a tutte le istanze dello stack negli account e nelle regioni specificati.
Puoi fornire i parametri come elenco letterale o percorso di file:
+ È possibile inserire i parametri nel seguente formato di sintassi abbreviata:. `ParameterKey=string,ParameterValue=string,UsePreviousValue=boolean,ResolvedValue=string ParameterKey=string,ParameterValue=string,UsePreviousValue=boolean,ResolvedValue=string` Per ulteriori informazioni su questi tipi di dati, vedere. [Tipi di dati dei parametri del modello](#action-reference-StackSets-datatypes)
L'esempio seguente mostra un parametro denominato `BucketName` con il valore`amzn-s3-demo-source-bucket`.
```
ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket
```
L'esempio seguente mostra una voce con più parametri.
```
ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket
ParameterKey=Asset1,ParameterValue=true
ParameterKey=Asset2,ParameterValue=true
```
+ È possibile immettere la posizione del file contenente un elenco di sostituzioni dei parametri del modello immesse nel formato`InputArtifactName::ParameterOverridessFileName`, come illustrato nell'esempio seguente.
```
SourceArtifact::parameter-overrides.txt
```
L'esempio seguente mostra il contenuto del file per. `parameter-overrides.txt`
```
[
{
"ParameterKey": "KeyName",
"ParameterValue": "true"
},
{
"ParameterKey": "KeyName",
"ParameterValue": "true"
}
]
```
****FailureTolerancePercentage****
Obbligatorio: no
La percentuale di account per regione per i quali questa operazione di stack può fallire prima dell' CloudFormation interruzione dell'operazione in quella regione. Se l'operazione viene interrotta in una regione, CloudFormation non tenta l'operazione nelle regioni successive. Quando si calcola il numero di conti in base alla percentuale specificata, viene CloudFormation arrotondato per *difetto* al numero intero successivo.
****MaxConcurrentPercentage****
Obbligatorio: no
La percentuale massima di account su cui eseguire questa operazione contemporaneamente. Quando si calcola il numero di conti in base alla percentuale specificata, viene CloudFormation arrotondato per *difetto* al numero intero successivo. Se l'arrotondamento per difetto dà come risultato zero, CloudFormation imposta invece il numero a uno. Sebbene si specifichi il *valore massimo*, per le distribuzioni di grandi dimensioni il numero effettivo di account su cui si agisce contemporaneamente potrebbe essere inferiore a causa della limitazione del servizio.
**RegionConcurrencyType**
Obbligatorio: no
È possibile specificare se lo stack set deve essere distribuito in Regioni AWS sequenza o in parallelo configurando il parametro region concurrency deployment. Quando viene specificata la concorrenza Region per distribuire stack su più stack in Regioni AWS parallelo, ciò può comportare tempi di implementazione complessivi più rapidi.
+ *Parallelo*: le implementazioni di set di stack verranno eseguite contemporaneamente, a condizione che gli errori di distribuzione in una regione non superino una tolleranza di errore specificata.
+ *Sequenziale*: le implementazioni di set di stack verranno eseguite una alla volta, a condizione che gli errori di distribuzione in una regione non superino una tolleranza di errore specificata. La distribuzione sequenziale è la selezione predefinita.
**ConcurrencyMode**
Obbligatorio: no
La modalità di concorrenza consente di scegliere il comportamento del livello di concorrenza durante le operazioni di stack set, con una tolleranza agli errori rigorosa o morbida. La **tolleranza rigorosa ai guasti** riduce la velocità di implementazione quando si verificano errori nelle operazioni del set di stack, poiché la simultaneità diminuisce per ogni errore. **Soft Failure Tolerance** dà priorità alla velocità di implementazione sfruttando al contempo le funzionalità di sicurezza. CloudFormation
+ `STRICT_FAILURE_TOLERANCE`: Questa opzione riduce dinamicamente il livello di concorrenza per garantire che il numero di account falliti non superi mai una particolare tolleranza di errore. Questo è il comportamento che segue di default.
+ `SOFT_FAILURE_TOLERANCE`: questa opzione disaccoppia la tolleranza agli errori dalla concorrenza effettiva. Ciò consente alle operazioni di stack set di essere eseguite a un livello di concorrenza prestabilito, indipendentemente dal numero di errori.
**CallAs**
Obbligatorio: no
Questo parametro è facoltativo per il modello di `SERVICE_MANAGED` autorizzazioni e non viene utilizzato per il modello di autorizzazioni. `SELF_MANAGED`
Speciifica se si agisce nell'account di gestione dell'organizzazione o come amministratore delegato in un account membro.
Se questo parametro è impostato su`DELEGATED_ADMIN`, assicurati che il ruolo IAM della pipeline disponga dell'autorizzazione. `organizations:ListDelegatedAdministrators` In caso contrario, l'azione avrà esito negativo durante l'esecuzione con un errore simile al seguente:`Account used is not a delegated administrator`.
+ `SELF`: La distribuzione di Stack Set utilizzerà le autorizzazioni gestite dal servizio una volta effettuato l'accesso all'account di gestione.
+ `DELEGATED_ADMIN`: la distribuzione di Stack Set utilizzerà le autorizzazioni gestite dal servizio una volta effettuato l'accesso a un account amministratore delegato.
### Input artifact (Artefatti di input)
`CloudFormationStackInstances`può contenere artefatti che elencano gli obiettivi e i parametri di distribuzione.
+ **Numero di artefatti:** `0 to 2`
+ **Descrizione:** come input, l'azione stack set accetta facoltativamente artefatti per i seguenti scopi:
+ Per fornire il file dei parametri da utilizzare. Consulta il parametro `ParameterOverrides`.
+ Per fornire il file degli account di destinazione da utilizzare. Consulta il parametro `DeploymentTargets`.
### Artefatti di output
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di output non si applicano a questo tipo di azione.
### Variabili di output
Quando è configurata, questa azione produce variabili che possono essere referenziate dalla configurazione dell'azione di un'azione downstream nella pipeline. È possibile configurare un'azione con uno spazio dei nomi per rendere tali variabili disponibili per la configurazione delle azioni downstream.
+ **StackSetId**: L'ID dello stack set.
+ **OperationId**: L'ID dell'operazione di set di stack.
Per ulteriori informazioni, consulta [Riferimento alle variabili](reference-variables.md).
### Esempio di configurazione dell'operazione
Gli esempi seguenti mostrano la configurazione dell'**CloudFormationStackInstances**azione.
#### Esempio di modello di autorizzazioni autogestite
L'esempio seguente mostra un'**CloudFormationStackInstances**azione in cui l'obiettivo di distribuzione immesso è un Account AWS ID. `111111222222`
------
#### [ YAML ]
```
Name: my-instances
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormationStackInstances
Version: '1'
RunOrder: 2
Configuration:
DeploymentTargets: '111111222222'
Regions: 'us-east-1,us-east-2,us-west-1,us-west-2'
StackSetName: my-stackset
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
```
------
#### [ JSON ]
```
{
"Name": "my-instances",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CloudFormationStackInstances",
"Version": "1"
},
"RunOrder": 2,
"Configuration": {
"DeploymentTargets": "111111222222",
"Regions": "us-east-1,us-east-2,us-west-1,us-west-2",
"StackSetName": "my-stackset"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2"
}
```
------
#### Esempio del modello di autorizzazioni gestite dal servizio
L'esempio seguente mostra un'**CloudFormationStackInstances**azione per il modello di autorizzazioni gestite dal servizio in cui l'obiettivo di distribuzione è un ID di unità organizzativa AWS Organizations. `ou-1111-1example`
------
#### [ YAML ]
```
Name: Instances
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CloudFormationStackInstances
Version: '1'
RunOrder: 2
Configuration:
DeploymentTargets: ou-1111-1example
Regions: us-east-1
StackSetName: my-stackset
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: eu-central-1
```
------
#### [ JSON ]
```
{
"Name": "Instances",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CloudFormationStackInstances",
"Version": "1"
},
"RunOrder": 2,
"Configuration": {
"DeploymentTargets": "ou-1111-1example",
"Regions": "us-east-1",
"StackSetName": "my-stackset"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "eu-central-1"
}
```
------
## Autorizzazioni per i ruoli di servizio: azione `CloudFormationStackSet`
Per CloudFormation StackSets le azioni, sono richieste le seguenti autorizzazioni minime.
Per l'`CloudFormationStackSet`azione, aggiungi quanto segue alla tua dichiarazione politica:
```
{
"Effect": "Allow",
"Action": [
"cloudformation:CreateStackSet",
"cloudformation:UpdateStackSet",
"cloudformation:CreateStackInstances",
"cloudformation:DescribeStackSetOperation",
"cloudformation:DescribeStackSet",
"cloudformation:ListStackInstances"
],
"Resource": "resource_ARN"
},
```
## Autorizzazioni per i ruoli di servizio: azione `CloudFormationStackInstances`
Per l'`CloudFormationStackInstances`azione, aggiungi quanto segue alla tua dichiarazione politica:
```
{
"Effect": "Allow",
"Action": [
"cloudformation:CreateStackInstances",
"cloudformation:DescribeStackSetOperation"
],
"Resource": "resource_ARN"
},
```
## Modelli di autorizzazioni per le operazioni relative agli stack set
Poiché CloudFormation StackSets esegue operazioni su più account, è necessario definire le autorizzazioni necessarie in tali account prima di poter creare lo stack set. È possibile definire le autorizzazioni tramite autorizzazioni autogestite o autorizzazioni gestite dal servizio.
Con le autorizzazioni autogestite, puoi creare i due ruoli IAM richiesti da StackSets : un ruolo di amministratore, ad esempio nell'account AWSCloud FormationStackSetAdministrationRole in cui definisci il set di stack, e un ruolo di esecuzione come quello AWSCloud FormationStackSetExecutionRole in ciascuno degli account in cui distribuisci le istanze dello stack set. Utilizzando questo modello di autorizzazioni, StackSets puoi eseguire la distribuzione su qualsiasi AWS account in cui l'utente dispone delle autorizzazioni per creare un ruolo IAM. *Per ulteriori informazioni, consulta [Concedere autorizzazioni autogestite](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-prereqs-self-managed.html) nella Guida per l'utente.AWS CloudFormation *
**Nota**
Poiché CloudFormation StackSets esegue operazioni su più account, è necessario definire le autorizzazioni necessarie in tali account prima di poter creare lo stack set.
Con le autorizzazioni gestite dal servizio, puoi distribuire istanze stack su account gestiti da Organizations. AWS Utilizzando questo modello di autorizzazioni, non è necessario creare i ruoli IAM necessari, in quanto StackSets crea i ruoli IAM per conto dell'utente. Con questo modello, puoi anche abilitare le distribuzioni automatiche agli account che verranno aggiunti all'organizzazione in futuro. Vedi [Enable trusted access with AWS Organizations](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-orgs-enable-trusted-access.html) nella *Guida AWS CloudFormation per l'utente*.
## Tipi di dati dei parametri del modello
I parametri del modello utilizzati nelle operazioni di stack set includono i seguenti tipi di dati. Per ulteriori informazioni, consulta [DescribeStackSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Parameter.html).
ParameterKey
+ Descrizione: la chiave associata al parametro. Se non specificate una chiave e un valore per un particolare parametro, AWS CloudFormation utilizza il valore predefinito specificato nel modello.
+ Esempio:
```
"ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket"
```
ParameterValue
+ Descrizione: il valore di input associato al parametro.
+ Esempio:
```
"ParameterKey=BucketName,ParameterValue=amzn-s3-demo-source-bucket"
```
UsePreviousValue
+ Durante un aggiornamento dello stack, utilizzate il valore del parametro esistente utilizzato dallo stack per una determinata chiave di parametro. Se lo specificate`true`, non specificate il valore di un parametro.
+ Esempio:
```
"ParameterKey=Asset1,UsePreviousValue=true"
```
Ogni set di stack ha un modello e un set di parametri di modello. Quando aggiorni il modello o i parametri del modello, li aggiorni per l'intero set. Quindi tutti gli stati delle istanze vengono impostati su OBSOLETO fino a quando le modifiche non vengono distribuite a quell'istanza.
Per sovrascrivere i valori dei parametri su istanze specifiche, ad esempio, se il modello contiene un parametro per `stage` con un valore di`prod`, è possibile sovrascrivere il valore di quel parametro impostando or. `beta` `gamma`
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Tipi di parametri](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html#parameters-section-structure-properties-type): questo capitolo di riferimento della *Guida per l'AWS CloudFormation utente* fornisce ulteriori descrizioni ed esempi per CloudFormation i parametri del modello.
+ Procedure ottimali: per ulteriori informazioni sulle migliori pratiche per la distribuzione di set di stack, [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-bestpractices.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stacksets-bestpractices.html) consulta la Guida per l'*AWS CloudFormation utente*.
+ [AWS CloudFormation Riferimento alle API](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/): puoi fare riferimento CloudFormation alle seguenti azioni nell'*AWS CloudFormation API Reference* per ulteriori informazioni sui parametri utilizzati nelle operazioni relative agli stack set:
+ L'[CreateStackSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStackSet.html)azione crea un set di stack.
+ L'[UpdateStackSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStackSet.html)azione aggiorna il set di stack e le istanze di stack associate negli account e nelle regioni specificati. Anche se l'operazione di stack set creata aggiornando lo stack set fallisce (completamente o parzialmente, al di sotto o al di sopra di una tolleranza di errore specificata), il set di stack viene aggiornato con queste modifiche. Le CreateStackInstances chiamate successive sul set di stack specificato utilizzano il set di stack aggiornato.
+ L'[CreateStackInstances](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStackInstances.html)azione crea un'istanza stack per tutte le regioni specificate all'interno di tutti gli account specificati su un modello di autorizzazione autogestito o all'interno di tutti gli obiettivi di distribuzione specificati su un modello di autorizzazione gestito dal servizio. È possibile sovrascrivere i parametri per le istanze create da questa azione. Se le istanze esistono già, CreateStackInstances chiamate UpdateStackInstances con gli stessi parametri di input. Quando utilizzate questa azione per creare istanze, non modifica lo stato delle altre istanze dello stack.
+ L'[UpdateStackInstances](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStackInstances.html)azione aggiorna le istanze dello stack con lo stack impostato per tutte le regioni specificate all'interno di tutti gli account specificati su un modello di autorizzazione autogestito o entro tutti gli obiettivi di distribuzione specificati su un modello di autorizzazione gestito dal servizio. È possibile sovrascrivere i parametri per le istanze aggiornate da questa azione. Quando si utilizza questa azione per aggiornare un sottoinsieme di istanze, non modifica lo stato delle altre istanze dello stack.
+ L'[DescribeStackSetOperation](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeStackSetOperation.html)azione restituisce la descrizione dell'operazione di stack set specificata.
+ L'[DescribeStackSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeStackSet.html)azione restituisce la descrizione del set di stack specificato.
# AWS CodeBuild riferimento all'azione di compilazione e test
Consente di eseguire compilazioni e test come parte della pipeline. Quando esegui un'azione di CodeBuild compilazione o test, i comandi specificati in buildspec vengono eseguiti all'interno di un contenitore. CodeBuild Tutti gli artefatti specificati come artefatti di input per un' CodeBuild azione sono disponibili all'interno del contenitore che esegue i comandi. CodeBuild può fornire un'azione di compilazione o di test. Per ulteriori informazioni, consulta la [Guida per l'utente AWS CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/).
Quando si utilizza la CodePipeline procedura guidata nella console per creare un progetto di compilazione, il progetto di CodeBuild compilazione mostra che il provider di origine lo è CodePipeline. Quando crei un progetto di compilazione nella CodeBuild console, non puoi specificarlo CodePipeline come fornitore di origine, ma l'aggiunta dell'azione di compilazione alla pipeline modifica il codice sorgente nella console. CodeBuild Per ulteriori informazioni, consulta [ProjectSource](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_ProjectSource.html) nella *documentazione di riferimento dell’API AWS CodeBuild *.
**Topics**
+ [Tipo di operazione](#action-reference-CodeBuild-type)
+ [Parametri di configurazione](#action-reference-CodeBuild-config)
+ [Input artifact (Artefatti di input)](#action-reference-CodeBuild-input)
+ [Artefatti di output](#action-reference-CodeBuild-output)
+ [Variabili di output](#action-reference-CodeBuild-variables)
+ [Autorizzazioni per i ruoli di servizio: azione CodeBuild](#edit-role-codebuild)
+ [Dichiarazione di azione (CodeBuild esempio)](#action-reference-CodeBuild-example)
+ [Consulta anche](#action-reference-CodeBuild-links)
## Tipo di operazione
+ Categoria: `Build` o `Test`
+ Proprietario: `AWS`
+ Provider: `CodeBuild`
+ Versione: `1`
## Parametri di configurazione
**ProjectName**
Obbligatorio: sì
`ProjectName`è il nome del progetto di compilazione in. CodeBuild
**PrimarySource**
Obbligatorio: condizionale
Il valore del `PrimarySource` parametro deve essere il nome di uno degli elementi di input dell'azione. CodeBuild cerca il file buildspec ed esegue i comandi buildspec nella directory che contiene la versione decompressa di questo elemento.
Questo parametro è obbligatorio se vengono specificati più artefatti di input per un'operazione CodeBuild . Quando è presente un solo artefatto di origine per l'operazione, l'impostazione predefinita per l'artefatto `PrimarySource` è tale artefatto.
**BatchEnabled**
Obbligatorio: no
Il valore booleano del `BatchEnabled` parametro consente all'azione di eseguire più build nella stessa esecuzione di build.
Quando questa opzione è abilitata, l'`CombineArtifacts`opzione è disponibile.
Per esempi di pipeline con compilazioni in batch abilitate, consulta [CodePipeline Integrazione con CodeBuild e compilazioni in batch](https://docs.aws.amazon.com/codebuild/latest/userguide/sample-pipeline-batch.html).
**BuildspecOverride**
Obbligatorio: no
Una definizione buildspec in linea o una dichiarazione di file buildspec che sostituisce quella più recente definita nel progetto di compilazione, solo per questa build. Il buildspec definito nel progetto non viene modificato.
Se questo valore è impostato, può essere uno dei seguenti:
+ Una definizione buildspec in linea. [Per ulteriori informazioni, vedere il riferimento alla sintassi in Buildspec syntax.](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec-ref-syntax)
+ Il percorso di un file buildspec alternativo relativo al valore della variabile di `CODEBUILD_SRC_DIR` ambiente integrata o al percorso di un bucket S3. Il bucket deve essere uguale al progetto di compilazione. Regione AWS Specificare il file buildspec utilizzando il relativo ARN (ad esempio, `arn:aws:s3:::my-codebuild-sample2/buildspec.yml`). Se questo valore non viene fornito o è impostato su una stringa vuota, il codice sorgente deve contenere un file buildspec nella sua directory principale. Per ulteriori informazioni sull'aggiunta di un percorso, vedere [Buildspec](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec-ref-name-storage) File Name and Storage Location.
Poiché questa proprietà consente di modificare i comandi di build che verranno eseguiti nel contenitore, tieni presente che un principale IAM con la capacità di chiamare questa API e impostare questo parametro può sovrascrivere le impostazioni predefinite. Inoltre, ti consigliamo di utilizzare una posizione buildspec affidabile come un file nel tuo repository di origine o un bucket Amazon S3.
**CombineArtifacts**
Obbligatorio: no
Il valore booleano del `CombineArtifacts` parametro combina tutti gli elementi di compilazione di una compilazione in batch in un unico file di artefatto per l'azione di compilazione.
Per utilizzare questa opzione, il parametro deve essere abilitato. `BatchEnabled`
**EnvironmentVariables**
Obbligatorio: no
Il valore di questo parametro viene utilizzato per impostare le variabili di ambiente per l'operazione CodeBuild nella pipeline. Il valore per il parametro `EnvironmentVariables` assume la forma di un array JSON di oggetti variabili di ambiente. Vedi il parametro di esempio in [Dichiarazione di azione (CodeBuild esempio)](#action-reference-CodeBuild-example).
Ogni oggetto ha tre parti, tutte costituite da stringhe:
+ `name`: il nome o la chiave della variabile di ambiente.
+ `value`: il valore della variabile di ambiente. Quando si utilizza il `SECRETS_MANAGER` tipo `PARAMETER_STORE` o, questo valore deve essere il nome di un parametro già archiviato in AWS Systems Manager Parameter Store o un segreto già archiviato in AWS Secrets Manager, rispettivamente.
**Nota**
Sconsigliamo vivamente l'uso di variabili di ambiente per archiviare valori sensibili, in particolare AWS le credenziali. Quando si utilizza la CodeBuild console o la AWS CLI, le variabili di ambiente vengono visualizzate in testo semplice. Per i valori sensibili, si consiglia di utilizzare invece il tipo `SECRETS_MANAGER`.
+ `type`: (facoltativo) il tipo di variabile di ambiente. I valori validi sono `PARAMETER_STORE`, `SECRETS_MANAGER` o `PLAINTEXT`. Se il valore non viene specificato, viene usato il valore predefinito `PLAINTEXT`.
Quando inserite la `name` configurazione e `type` per le variabili di ambiente, specialmente se la variabile di ambiente contiene la sintassi della variabile di CodePipeline output, non superate il limite di 1000 caratteri per il campo del valore della configurazione. `value` Quando questo limite viene superato, viene restituito un errore di convalida.
Per ulteriori informazioni, consulta l'API [ EnvironmentVariable](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_EnvironmentVariable.html)Reference. AWS CodeBuild Per un esempio di CodeBuild azione con una variabile di ambiente che si risolve nel nome del GitHub ramo, vedi. [Esempio: utilizzare una BranchName variabile con variabili di CodeBuild ambiente](actions-variables.md#actions-variables-examples-env-branchname)
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1 to 5`
+ **Descrizione:** CodeBuild cerca il file buildspec ed esegue i comandi buildspec dalla directory dell'artefatto sorgente primario. Quando viene specificata una singola sorgente di input o quando vengono specificate più di una fonte di input per l' CodeBuild azione, è necessario impostare il singolo artefatto o l'artefatto principale nel caso di più sorgenti di input utilizzando il parametro di configurazione dell'azione in. `PrimarySource` CodePipeline
Ogni artefatto di input viene estratto nella propria directory, le cui posizioni sono archiviate in variabili di ambiente. La directory per l'artefatto di origine principale viene resa disponibile con `$CODEBUILD_SRC_DIR`. Le directory per tutti gli altri artefatti di input sono rese disponibili con `$CODEBUILD_SRC_DIR_yourInputArtifactName`.
**Nota**
L'artefatto configurato nel CodeBuild progetto diventa l'artefatto di input utilizzato dall'azione nella pipeline. CodeBuild
## Artefatti di output
+ **Numero di artefatti:** `0 to 5`
+ **Descrizione:** possono essere usati per rendere gli artefatti definiti nel file CodeBuild buildspec disponibili per le azioni successive nella pipeline. Quando viene definito un solo artefatto di output, questo artefatto può essere definito direttamente nella sezione del file buildspec. `artifacts` Quando viene specificato più di un artefatto di output, tutti gli artefatti a cui si fa riferimento devono essere definiti come artefatti secondari nel file buildspec. I nomi degli artefatti di output in devono corrispondere agli identificatori degli artefatti nel file buildspec. CodePipeline
**Nota**
L'artefatto configurato nel progetto diventa l'artefatto di input nell'azione della pipeline CodeBuild . CodePipeline
Se il `CombineArtifacts` parametro è selezionato per le compilazioni in batch, la posizione dell'artefatto di output contiene gli artefatti combinati di più build eseguite nella stessa esecuzione.
## Variabili di output
Questa azione produrrà come variabili tutte le variabili di ambiente che sono state esportate come parte della build. *Per maggiori dettagli su come esportare le variabili di ambiente, consulta la Guida API. [ EnvironmentVariable](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_EnvironmentVariable.html)AWS CodeBuild *
Per ulteriori informazioni sull'utilizzo delle variabili di CodeBuild ambiente in CodePipeline, consulta gli esempi in[CodeBuild azioni (variabili di output).](reference-variables.md#reference-variables-list-configured-codebuild). Per un elenco delle variabili di ambiente in cui è possibile utilizzare CodeBuild, consulta [Variabili di ambiente negli ambienti di compilazione](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html) nella *Guida per l'AWS CodeBuild utente*.
## Autorizzazioni per i ruoli di servizio: azione CodeBuild
Per CodeBuild ricevere assistenza, aggiungi quanto segue alla tua dichiarazione sulla politica:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"codebuild:BatchGetBuilds",
"codebuild:StartBuild",
"codebuild:BatchGetBuildBatches",
"codebuild:StartBuildBatch"
],
"Resource": [
"arn:aws:codebuild:*:111122223333:project/[[ProjectName]]"
],
"Effect": "Allow"
}
]
}
```
------
## Dichiarazione di azione (CodeBuild esempio)
------
#### [ YAML ]
```
Name: Build
Actions:
- Name: PackageExport
ActionTypeId:
Category: Build
Owner: AWS
Provider: CodeBuild
Version: '1'
RunOrder: 1
Configuration:
BatchEnabled: 'true'
CombineArtifacts: 'true'
ProjectName: my-build-project
PrimarySource: MyApplicationSource1
EnvironmentVariables: '[{"name":"TEST_VARIABLE","value":"TEST_VALUE","type":"PLAINTEXT"},{"name":"ParamStoreTest","value":"PARAMETER_NAME","type":"PARAMETER_STORE"}]'
OutputArtifacts:
- Name: MyPipeline-BuildArtifact
InputArtifacts:
- Name: MyApplicationSource1
- Name: MyApplicationSource2
```
------
#### [ JSON ]
```
{
"Name": "Build",
"Actions": [
{
"Name": "PackageExport",
"ActionTypeId": {
"Category": "Build",
"Owner": "AWS",
"Provider": "CodeBuild",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"BatchEnabled": "true",
"CombineArtifacts": "true",
"ProjectName": "my-build-project",
"PrimarySource": "MyApplicationSource1",
"EnvironmentVariables": "[{\"name\":\"TEST_VARIABLE\",\"value\":\"TEST_VALUE\",\"type\":\"PLAINTEXT\"},{\"name\":\"ParamStoreTest\",\"value\":\"PARAMETER_NAME\",\"type\":\"PARAMETER_STORE\"}]"
},
"OutputArtifacts": [
{
"Name": "MyPipeline-BuildArtifact"
}
],
"InputArtifacts": [
{
"Name": "MyApplicationSource1"
},
{
"Name": "MyApplicationSource2"
}
]
}
]
}
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [AWS CodeBuild Guida per l'utente](https://docs.aws.amazon.com/codebuild/latest/userguide/): per un esempio di pipeline con un' CodeBuild azione, consulta [Use CodePipeline with CodeBuild to Test Code e Run Builds](https://docs.aws.amazon.com/codebuild/latest/userguide/how-to-create-pipeline.html). Per esempi di progetti con più CodeBuild artefatti di input e output, consulta [CodePipelineIntegration with and Multiple Input Sources CodeBuild and Output Artifacts Sample e Multiple Input Sources and [Output](https://docs.aws.amazon.com/codebuild/latest/userguide/sample-multi-in-out.html) Artifacts Sample](https://docs.aws.amazon.com/codebuild/latest/userguide/sample-pipeline-multi-input-output.html).
+ [Tutorial: crea una pipeline con cui creare e testare la tua app Android AWS Device Farm](tutorials-codebuild-devicefarm.md)— Questo tutorial fornisce un file buildspec di esempio e un'applicazione di esempio per creare una pipeline con un GitHub sorgente che crea e testa un'app Android con e. CodeBuild AWS Device Farm
+ [Riferimento alle specifiche di compilazione per CodeBuild ](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html): questo argomento di riferimento fornisce definizioni ed esempi per comprendere i file buildspec. CodeBuild *Per un elenco delle variabili di ambiente in cui è possibile utilizzare CodeBuild, consulta [Variabili di ambiente negli ambienti di compilazione nella Guida per](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html) l'AWS CodeBuild utente.*
# AWS CodePipeline richiama il riferimento all'azione
Si utilizza un'azione CodePipeline invoke per semplificare l'attivazione delle esecuzioni di pipeline a valle e il passaggio delle variabili di pipeline e delle revisioni dei sorgenti tra le pipeline.
**Nota**
Questa azione è supportata solo per le pipeline di tipo V2.
**Topics**
+ [Tipo di operazione](#action-reference-PipelineInvoke-type)
+ [Parametri di configurazione](#action-reference-PipelineInvoke-parameters)
+ [Input artifact (Artefatti di input)](#action-reference-PipelineInvoke-input)
+ [Artefatti di output](#action-reference-PipelineInvoke-output)
+ [Autorizzazioni relative alla policy del ruolo di servizio per l'azione di richiamo CodePipeline](#action-reference-PipelineInvoke-permissions-action)
+ [Dichiarazione dell'operazione](#action-reference-PipelineInvoke-example)
+ [Consulta anche](#action-reference-PipelineInvoke-links)
## Tipo di operazione
+ Categoria: `Invoke`
+ Proprietario: `AWS`
+ Provider: `CodePipeline`
+ Versione: `1`
## Parametri di configurazione
**PipelineName**
Obbligatorio: sì
Il nome della pipeline che, una volta eseguita, avvierà la pipeline di destinazione corrente. È necessario aver già creato la pipeline di invocazione. L'azione avvierà la pipeline `s3-pipeline-test` (di destinazione) quando la pipeline (di invocazione) denominata avvia un'esecuzione. `my-s3-pipeline`
**SourceRevisions**
Obbligatorio: no
Le revisioni di origine che si desidera che la pipeline di destinazione utilizzi quando viene avviata dalla pipeline di richiamo. Ad esempio, un'azione di origine di S3 fornisce variabili di output come l'ID della versione di S3 e la chiave dell'oggetto. È possibile specificare un valore di revisione da utilizzare quando viene richiamata la pipeline.
Per la CLI, si specificano le revisioni del codice sorgente come stringa JSON serializzata. *Per ulteriori informazioni sull'utilizzo delle sostituzioni delle revisioni dei sorgenti, consulta la Guida API. [SourceRevisionOverride](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_SourceRevisionOverride.html)CodePipeline *
La mappatura utilizza un formato di stringa, come illustrato nell'esempio seguente:
```
[{"actionName":"Source","revisionType":"S3_OBJECT_VERSION_ID","revision
Value":"zq8mjNEXAMPLE"}]
```
**Variabili**
Obbligatorio: no
I nomi e i valori delle variabili che si desidera che l'azione supporti.
Per la CLI, si specificano le variabili come stringa JSON serializzata. *Per ulteriori informazioni sull'utilizzo delle variabili di pipeline, consulta la Guida API [PipelineVariable](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PipelineVariable.html). CodePipeline *
La mappatura utilizza un formato di stringa, come mostrato nell'esempio seguente:
```
[{"name":"VAR1","value":"VALUE1"}]
```
L'immagine seguente mostra un esempio dell'azione aggiunta a una pipeline nella console.
![\[Una pipeline con una sorgente S3 e una fase di compilazione che include l'azione di invocazione della pipeline\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/example-pipeline-invoke-run.png)
L'immagine seguente mostra un esempio della pagina **Modifica** per l'azione. Nell'esempio seguente, la pipeline denominata `s3-pipeline-test` ha un'azione di richiamo della pipeline configurata come mostrato per la console. L'azione avvierà la `s3-pipeline-test` pipeline quando la pipeline denominata completerà un'esecuzione. `my-s3-pipeline` L'esempio mostra l'override della revisione di origine per l'override del codice sorgente S3\$1OBJECT\$1VERSION\$1ID con il valore di revisione specificato di. `zq8mjNYEexample`
![\[alt text not found\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/example-pipeline-invoke-edit.png)
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di input non si applicano a questo tipo di azione.
## Artefatti di output
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di output non si applicano a questo tipo di azione.
## Autorizzazioni relative alla policy del ruolo di servizio per l'azione di richiamo CodePipeline
Quando CodePipeline viene eseguita l'azione, la policy del ruolo del CodePipeline servizio richiede l'`codepipeline:StartPipelineExecution`autorizzazione, opportunamente limitata all'ARN della risorsa della pipeline per mantenere l'accesso con il minimo privilegio.
```
{
"Sid": "StatementForPipelineInvokeAction",
"Effect": "Allow",
"Action": "codepipeline:StartPipelineExecution",
"Resource": [
"arn:aws:codepipeline:{{region}}:{{AccountId}}:{{pipelineName}}"
]
}
```
## Dichiarazione dell'operazione
------
#### [ YAML ]
```
name: Invoke-pipeline
actionTypeId:
category: Invoke
owner: AWS
provider: CodePipeline
version: '1'
runOrder: 2
configuration:
PipelineName: my-s3-pipeline
SourceRevisions: '[{"actionName":"Source","revisionType":"S3_OBJECT_VERSION_ID","revision
Value":"zq8mjNEXAMPLE"}]'
Variables: '[{"name":"VAR1","value":"VALUE1"}]'
```
------
#### [ JSON ]
```
{
"name": "Invoke-pipeline",
"actionTypeId": {
"category": "Invoke",
"owner": "AWS",
"provider": "CodePipeline",
"version": "1"
},
"runOrder": 2,
"configuration": {
"PipelineName": "my-s3-pipeline",
"SourceRevisions": "[{\"actionName\":\"Source\",\"revisionType\":\"S3_OBJECT_VERSION_ID\",\"revisionValue\":\"zq8mjNEXAMPLE"}]",
"Variables": "[{\"name\":\"VAR1\",\"value\":\"VALUE1\"}]"
}
},
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Avvia una pipeline con una modifica della revisione del codice sorgente](pipelines-trigger-source-overrides.md)— Questa sezione descrive l'avvio di una pipeline con le revisioni dei sorgenti manualmente o tramite l'Event Input Transformer. EventBridge
# CodeCommit riferimento all'azione di origine
Avvia la pipeline quando viene effettuato un nuovo commit sul CodeCommit repository e sul ramo configurati.
Se utilizzi la console per creare o modificare la pipeline, CodePipeline crea una EventBridge regola che avvia la pipeline quando si verifica una modifica nel repository.
**Nota**
Per Amazon ECR, Amazon S3 CodeCommit o sorgenti, puoi anche creare un'override di origine utilizzando input transform entry per utilizzare l' EventBridge in per `revisionValue` il tuo evento pipeline, dove è derivato dalla variabile `revisionValue` dell'evento source per la chiave oggetto, il commit o l'ID immagine. Per ulteriori informazioni, consulta il passaggio facoltativo per l'immissione della trasformazione di input incluso nelle procedure riportate in, o. [Azioni e risorse relative ai sorgenti di Amazon ECR EventBridge](create-cwe-ecr-source.md) [Connessione alle azioni di origine di Amazon S3 con una fonte abilitata per gli eventi](create-S3-source-events.md) [CodeCommit azioni di origine e EventBridge](triggering.md)
È necessario aver già creato un CodeCommit repository prima di connettere la pipeline tramite un' CodeCommit azione.
Una volta rilevata una modifica del codice, sono disponibili le seguenti opzioni per passare il codice alle operazioni successive:
+ **Predefinito**: configura l'azione di CodeCommit origine per generare un file ZIP con una copia superficiale del commit.
+ **Clone completo**: configura l'azione di origine per inviare un riferimento URL Git al repository per le azioni successive.
Attualmente, il riferimento all'URL Git può essere utilizzato solo dalle CodeBuild azioni a valle per clonare il repository e i metadati Git associati. Il tentativo di passare un riferimento URL Git a non CodeBuild azioni genera un errore.
**Topics**
+ [Tipo di operazione](#action-reference-CodeCommit-type)
+ [Parametri di configurazione](#action-reference-CodeCommit-config)
+ [Input artifact (Artefatti di input)](#action-reference-CodeCommit-input)
+ [Artefatti di output](#action-reference-CodeCommit-output)
+ [Variabili di output](#action-reference-CodeCommit-variables)
+ [Autorizzazioni per i ruoli di servizio: azione CodeCommit](#edit-role-codecommit)
+ [Esempio di configurazione dell'operazione](#action-reference-CodeCommit-example)
+ [Consulta anche](#action-reference-CodeCommit-links)
## Tipo di operazione
+ Categoria: `Source`
+ Proprietario: `AWS`
+ Provider: `CodeCommit`
+ Versione: `1`
## Parametri di configurazione
**RepositoryName**
Obbligatorio: sì
Il nome del repository in cui devono essere rilevate le modifiche di origine.
**BranchName**
Obbligatorio: sì
Il nome del ramo in cui devono essere rilevate le modifiche di origine.
**PollForSourceChanges**
Obbligatorio: no
`PollForSourceChanges`controlla se interroga CodePipeline il CodeCommit repository per verificare la presenza di modifiche all'origine. Ti consigliamo invece di utilizzare CloudWatch Events per rilevare le modifiche all'origine. Per ulteriori informazioni sulla configurazione CloudWatch degli eventi, consulta [Migrazione delle pipeline di polling (CodeCommit origine) (CLI)](update-change-detection.md#update-change-detection-cli-codecommit) o[Migra le pipeline di polling (CodeCommit source) (modello)CloudFormation](update-change-detection.md#update-change-detection-cfn-codecommit).
Se intendi configurare una regola CloudWatch Events, devi impostarla su `PollForSourceChanges` per `false` evitare esecuzioni duplicate della pipeline.
I valori validi per questo parametro sono:
+ `true`: Se impostata, analizza il repository per CodePipeline verificare se sono state apportate modifiche all'origine.
**Nota**
Se si omette`PollForSourceChanges`, per CodePipeline impostazione predefinita esegue il polling del repository per verificare la presenza di modifiche all'origine. Questo comportamento è lo stesso se `PollForSourceChanges` è incluso e impostato su `true`.
+ `false`: se impostata, CodePipeline non esegue il polling del repository per verificare la presenza di modifiche all'origine. Utilizzate questa impostazione se intendete configurare una regola CloudWatch Events per rilevare le modifiche all'origine.
****OutputArtifactFormat****
Obbligatorio: no
Il formato dell'artefatto di output. I valori possono essere uno o due. `CODEBUILD_CLONE_REF` `CODE_ZIP` Se non altrimenti specificato, l'impostazione predefinita è `CODE_ZIP`.
L'opzione `CODEBUILD_CLONE_REF` può essere utilizzata solo da operazioni downstream di CodeBuild.
Se scegli questa opzione, devi aggiungere l'`codecommit:GitPull`autorizzazione al tuo ruolo di CodeBuild servizio, come mostrato in[Aggiungi le CodeBuild GitClone autorizzazioni per le azioni di origine CodeCommit](troubleshooting.md#codebuild-role-codecommitclone). È inoltre necessario aggiungere l'`codecommit:GetRepository`autorizzazione al proprio ruolo CodePipeline di servizio, come mostrato in[Aggiungi le autorizzazioni al ruolo di servizio CodePipeline](how-to-custom-role.md#how-to-update-role-new-services). Per un tutorial che mostra come usare l'opzione **Full clone**, vedi[Tutorial: usa il clone completo con una sorgente di CodeCommit pipeline](tutorials-codecommit-gitclone.md).
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di input non si applicano a questo tipo di azione.
## Artefatti di output
+ **Numero di artefatti:** `1`
+ **Descrizione:** l'artefatto di output di questa azione è un file ZIP che contiene il contenuto del repository configurato e del ramo al commit specificato come revisione di origine per l'esecuzione della pipeline. Gli artefatti generati dal repository sono gli artefatti di output dell'azione. CodeCommit L'ID di commit del codice sorgente viene visualizzato CodePipeline come revisione del codice sorgente per l'esecuzione della pipeline attivata.
## Variabili di output
Quando è configurata, questa azione produce variabili che possono essere referenziate dalla configurazione dell'azione di un'azione downstream nella pipeline. Questa azione produce variabili che possono essere viste come variabili di output, anche se l'azione non ha uno spazio dei nomi. È possibile configurare un'azione con uno spazio dei nomi per rendere tali variabili disponibili per la configurazione delle azioni downstream.
Per ulteriori informazioni, consulta [Riferimento alle variabili](reference-variables.md).
**CommitId**
L'ID di CodeCommit commit che ha attivato l'esecuzione della pipeline. IDs I commit sono gli SHA completi del commit.
**CommitMessage**
Il messaggio di descrizione, se presente, associato al commit che ha attivato l'esecuzione della pipeline.
**RepositoryName**
Il nome del CodeCommit repository in cui è stato effettuato il commit che ha attivato la pipeline.
**BranchName**
Il nome del ramo del CodeCommit repository in cui è stata apportata la modifica all'origine.
**AuthorDate**
La data in cui il commit è stato creato, in formato timestamp.
**CommitterDate**
La data in cui è stato eseguito il commit, in formato timestamp.
## Autorizzazioni per i ruoli di servizio: azione CodeCommit
Quando CodePipeline viene eseguita l'azione, la policy del ruolo di CodePipeline servizio richiede le seguenti autorizzazioni, assegnate in modo appropriato all'ARN della risorsa della pipeline per mantenere l'accesso con il minimo privilegio. Ad esempio, aggiungi quanto segue alla tua dichiarazione politica:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codecommit:CancelUploadArchive",
"codecommit:GetBranch",
"codecommit:GetCommit",
"codecommit:GetRepository",
"codecommit:GetUploadArchiveStatus",
"codecommit:UploadArchive"
],
"Resource": [
"arn:aws:codecommit:*:111122223333:[[codecommitRepostories]]"
]
}
]
}
```
------
## Esempio di configurazione dell'operazione
### Esempio di formato predefinito degli artefatti di output
------
#### [ YAML ]
```
name: Source
actionTypeId:
category: Source
owner: AWS
provider: CodeCommit
version: '1'
runOrder: 1
configuration:
BranchName: main
PollForSourceChanges: 'false'
RepositoryName: MyWebsite
outputArtifacts:
- name: Artifact_MyWebsiteStack
inputArtifacts: []
region: us-west-2
namespace: SourceVariables
```
------
#### [ JSON ]
```
{
"name": "Source",
"actionTypeId": {
"category": "Source",
"owner": "AWS",
"provider": "CodeCommit",
"version": "1"
},
"runOrder": 1,
"configuration": {
"BranchName": "main",
"PollForSourceChanges": "false",
"RepositoryName": "MyWebsite"
},
"outputArtifacts": [
{
"name": "Artifact_MyWebsiteStack"
}
],
"inputArtifacts": [],
"region": "us-west-2",
"namespace": "SourceVariables"
}
```
------
### Esempio di formato degli artefatti di output del clone completo
------
#### [ YAML ]
```
name: Source
actionTypeId:
category: Source
owner: AWS
provider: CodeCommit
version: '1'
runOrder: 1
configuration:
BranchName: main
OutputArtifactFormat: CODEBUILD_CLONE_REF
PollForSourceChanges: 'false'
RepositoryName: MyWebsite
outputArtifacts:
- name: SourceArtifact
inputArtifacts: []
region: us-west-2
namespace: SourceVariables
```
------
#### [ JSON ]
```
{
"name": "Source",
"actionTypeId": {
"category": "Source",
"owner": "AWS",
"provider": "CodeCommit",
"version": "1"
},
"runOrder": 1,
"configuration": {
"BranchName": "main",
"OutputArtifactFormat": "CODEBUILD_CLONE_REF",
"PollForSourceChanges": "false",
"RepositoryName": "MyWebsite"
},
"outputArtifacts": [
{
"name": "SourceArtifact"
}
],
"inputArtifacts": [],
"region": "us-west-2",
"namespace": "SourceVariables"
}
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Tutorial: crea una pipeline semplice (CodeCommit repository)](tutorials-simple-codecommit.md)— Questo tutorial fornisce un esempio di file di specifiche dell'app e un esempio di CodeDeploy applicazione e gruppo di distribuzione. Usa questo tutorial per creare una pipeline con un CodeCommit sorgente da distribuire su istanze Amazon EC2.
# AWS CodeDeploy distribuire un riferimento all'azione
Utilizzi un' AWS CodeDeploy azione per distribuire il codice dell'applicazione nella tua flotta di distribuzione. La tua flotta di distribuzione può essere composta da istanze Amazon EC2, istanze locali o entrambe.
**Nota**
Questo argomento di riferimento descrive l'azione di CodeDeploy distribuzione per i paesi CodePipeline in cui la piattaforma di distribuzione è Amazon EC2. Per informazioni di riferimento su Amazon Elastic Container Service per le azioni di CodeDeploy blue/green distribuzione in CodePipeline, consulta[Riferimento alle azioni di distribuzione di Amazon Elastic Container Service e CodeDeploy blue-green](action-reference-ECSbluegreen.md).
**Topics**
+ [Tipo di operazione](#action-reference-CodeDeploy-type)
+ [Parametri di configurazione](#action-reference-CodeDeploy-config)
+ [Input artifact (Artefatti di input)](#action-reference-CodeDeploy-input)
+ [Artefatti di output](#action-reference-CodeDeploy-output)
+ [Autorizzazioni per i ruoli di servizio: azione AWS CodeDeploy](#edit-role-codedeploy)
+ [Dichiarazione dell'operazione](#action-reference-CodeDeploy-example)
+ [Consulta anche](#action-reference-CodeDeploy-links)
## Tipo di operazione
+ Categoria: `Deploy`
+ Proprietario: `AWS`
+ Provider: `CodeDeploy`
+ Versione: `1`
## Parametri di configurazione
**ApplicationName**
Obbligatorio: sì
Il nome dell'applicazione in cui hai creato CodeDeploy.
**DeploymentGroupName**
Obbligatorio: sì
Il gruppo di distribuzione in cui hai creato CodeDeploy.
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1`
+ **Descrizione:** Il AppSpec file che viene CodeDeploy utilizzato per determinare:
+ Cosa installare sulle istanze dalla revisione dell'applicazione in Amazon S3 oppure. GitHub
+ Quali hook di eventi del ciclo di vita eseguire in risposta agli eventi del ciclo di vita della distribuzione.
[Per ulteriori informazioni sul AppSpec file, consulta la sezione File Reference. CodeDeploy AppSpec ](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html)
## Artefatti di output
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di output non si applicano a questo tipo di azione.
## Autorizzazioni per i ruoli di servizio: azione AWS CodeDeploy
Per AWS CodeDeploy ricevere assistenza, aggiungi quanto segue alla tua dichiarazione sulla politica:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"codedeploy:CreateDeployment",
"codedeploy:GetApplication",
"codedeploy:GetDeployment",
"codedeploy:RegisterApplicationRevision",
"codedeploy:ListDeployments",
"codedeploy:ListDeploymentGroups",
"codedeploy:GetDeploymentGroup"
],
"Resource": [
"arn:aws:codedeploy:*:111122223333:application:[[codedeployApplications]]",
"arn:aws:codedeploy:*:111122223333:deploymentgroup:[[codedeployApplications]]/*"
]
},
{
"Effect": "Allow",
"Action": [
"codedeploy:GetDeploymentConfig"
],
"Resource": [
"arn:aws:codedeploy:*:111122223333:deploymentconfig:[[deploymentConfigs]]"
]
},
{
"Effect": "Allow",
"Action": [
"codedeploy:ListDeploymentConfigs"
],
"Resource": [
"*"
]
}
]
}
```
------
## Dichiarazione dell'operazione
------
#### [ YAML ]
```
Name: Deploy
Actions:
- Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: CodeDeploy
Version: '1'
RunOrder: 1
Configuration:
ApplicationName: my-application
DeploymentGroupName: my-deployment-group
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"Actions": [
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "CodeDeploy",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"ApplicationName": "my-application",
"DeploymentGroupName": "my-deployment-group"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
]
},
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Tutorial: creazione di una semplice pipeline (bucket S3)](tutorials-simple-s3.md)— Questo tutorial illustra la creazione di un bucket di sorgenti, istanze EC2 e CodeDeploy risorse per distribuire un'applicazione di esempio. Quindi costruisci la tua pipeline con un'azione di CodeDeploy distribuzione che distribuisce il codice mantenuto nel tuo bucket S3 sulla tua istanza Amazon EC2.
+ [Tutorial: crea una pipeline semplice (CodeCommit repository)](tutorials-simple-codecommit.md)— Questo tutorial ti guida attraverso la creazione del tuo repository di CodeCommit sorgenti, delle istanze EC2 e delle risorse per distribuire un'applicazione di esempio. CodeDeploy Quindi costruisci la tua pipeline con un'azione di CodeDeploy distribuzione che distribuisce il codice dal tuo CodeCommit repository alla tua istanza Amazon EC2.
+ [CodeDeploy AppSpec Riferimento ai file](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html): questo capitolo di riferimento della *Guida per l'AWS CodeDeploy utente* fornisce informazioni di riferimento ed esempi di file. CodeDeploy AppSpec
# CodeStarSourceConnection per Bitbucket Cloud, GitHub Enterprise Server GitHub, GitLab .com e GitLab azioni autogestite
Le azioni di origine per le connessioni sono supportate da. AWS CodeConnections CodeConnections consente di creare e gestire connessioni tra AWS risorse e repository di terze parti come GitHub. Avvia una pipeline quando viene effettuato un nuovo commit su un repository di codice sorgente di terze parti. L'azione source recupera le modifiche al codice quando una pipeline viene eseguita manualmente o quando un evento webhook viene inviato dal provider di origine.
Puoi configurare le azioni nella tua pipeline per utilizzare una configurazione Git che ti consenta di avviare la pipeline con i trigger. Per configurare la configurazione dei trigger della pipeline per filtrare con i trigger, vedi maggiori dettagli in. [Aggiungi trigger con tipi di eventi code push o pull request](pipelines-filter.md)
**Nota**
Questa funzionalità non è disponibile nelle regioni Asia Pacifico (Hong Kong), Asia Pacifico (Hyderabad), Asia Pacifico (Giacarta), Asia Pacifico (Melbourne), Asia Pacifico (Osaka), Africa (Città del Capo), Medio Oriente (Bahrein), Medio Oriente (Emirati Arabi Uniti), Europa (Spagna), Europa (Zurigo), Israele (Tel Aviv) o (Stati Uniti occidentali). AWS GovCloud Per fare riferimento ad altre azioni disponibili, consulta. [Integrazioni di prodotti e servizi con CodePipeline](integrations.md) Per considerazioni su questa azione nella regione Europa (Milano), si veda la nota in[CodeStarSourceConnection per Bitbucket Cloud, GitHub Enterprise Server GitHub, GitLab .com e GitLab azioni autogestite](#action-reference-CodestarConnectionSource).
Le connessioni possono associare AWS le tue risorse ai seguenti repository di terze parti:
+ Bitbucket Cloud (tramite l'opzione provider **Bitbucket** nella CodePipeline console o il provider `Bitbucket` nella CLI)
**Nota**
È possibile creare connessioni a un repository Bitbucket Cloud. I tipi di provider Bitbucket installati, ad esempio Bitbucket Server, non sono supportati.
+
**Nota**
Se utilizzi un'area di lavoro Bitbucket, devi disporre dell'accesso come amministratore per creare la connessione.
+ GitHub ed GitHub Enterprise Cloud **GitHub (tramite l'opzione provider (tramite GitHub app)** nella CodePipeline console o il `GitHub` provider nella CLI)
**Nota**
Se il repository si trova in un' GitHub organizzazione, devi essere il proprietario dell'organizzazione per creare la connessione. Se utilizzi un repository che non fa parte di un'organizzazione, devi essere il proprietario del repository.
+ GitHub Enterprise Server (tramite l'opzione provider **GitHub Enterprise Server** nella CodePipeline console o il `GitHub Enterprise Server` provider nella CLI)
+ GitLab.com (tramite l'opzione **GitLab**provider nella CodePipeline console o il `GitLab` provider nella CLI)
**Nota**
È possibile creare connessioni a un repository in cui si ricopre il ruolo di **proprietario** e quindi la connessione può essere utilizzata con il repository con risorse come. GitLab CodePipeline Per i repository nei gruppi, non è necessario essere il proprietario del gruppo.
+ Installazione gestita automaticamente per GitLab (Enterprise Edition o Community Edition) (tramite l'opzione provider **GitLab autogestita** nella CodePipeline console o il `GitLabSelfManaged` provider nella CLI)
**Nota**
Ogni connessione supporta tutti gli archivi che hai con quel provider. Devi solo creare una nuova connessione per ogni tipo di provider.
Le connessioni consentono alla pipeline di rilevare le modifiche alla fonte tramite l'app di installazione del provider terzo. Ad esempio, i webhook vengono utilizzati per sottoscrivere tipi di GitHub eventi e possono essere installati su un'organizzazione, un repository o un'app. GitHub La tua connessione installa un webhook di archivio sull' GitHub app che si iscrive a eventi di tipo push. GitHub
Una volta rilevata una modifica del codice, sono disponibili le seguenti opzioni per passare il codice alle operazioni successive:
+ Predefinito: come altre azioni di CodePipeline origine esistenti, `CodeStarSourceConnection` può generare un file ZIP con una copia superficiale del commit.
+ Clone completo: `CodeStarSourceConnection` può anche essere configurato per inviare un riferimento URL al repository per le azioni successive.
Attualmente, il riferimento all'URL Git può essere utilizzato solo dalle CodeBuild azioni a valle per clonare il repository e i metadati Git associati. Il tentativo di passare un riferimento URL Git a non CodeBuild azioni genera un errore.
CodePipeline ti chiede di aggiungere l'app di installazione AWS Connector al tuo account di terze parti quando crei una connessione. È necessario aver già creato l'account e l'archivio del provider di terze parti prima di poterti connettere tramite l'azione. `CodeStarSourceConnection`
**Nota**
Per creare o allegare una policy al tuo ruolo con le autorizzazioni necessarie per utilizzare le AWS CodeStar connessioni, vedi Riferimento alle [autorizzazioni di Connections](https://docs.aws.amazon.com/dtconsole/latest/userguide/security-iam.html#permissions-reference-connections). A seconda di quando è stato creato il ruolo di CodePipeline servizio, potrebbe essere necessario aggiornarne le autorizzazioni per supportare le connessioni. AWS CodeStar Per istruzioni, consulta [Aggiungi le autorizzazioni al ruolo di servizio CodePipeline](how-to-custom-role.md#how-to-update-role-new-services).
**Nota**
Per utilizzare le connessioni in Europa (Milano) Regione AWS, devi:
Installare un'app specifica per la regione
Abilitare la regione
Questa app specifica per la regione supporta i collegamenti nella regione Europa (Milano). È pubblicata sul sito del provider di terze parti ed è separata dall'app esistente che supporta le connessioni per altre regioni. Installando questa app, autorizzi i provider di terze parti a condividere i tuoi dati con il servizio solo per questa regione e puoi revocare le autorizzazioni in qualsiasi momento disinstallando l'app.
Il servizio non elaborerà o memorizzerà i dati a meno che tu non abiliti la Regione. Abilitando questa regione, concedi al nostro servizio le autorizzazioni per elaborare e archiviare i dati.
Anche se la regione non è abilitata, i provider di terze parti possono comunque condividere i tuoi dati con il nostro servizio se l'app specifica per la regione rimane installata, quindi assicurati di disinstallarla dopo aver disabilitato la regione. Per ulteriori informazioni, consulta [Enabling a Region](https://docs.aws.amazon.com/general/latest/gr/rande-manage.html#rande-manage-enable) (Abilitare una regione).
**Topics**
+ [Tipo di operazione](#action-reference-CodestarConnectionSource-type)
+ [Parametri di configurazione](#action-reference-CodestarConnectionSource-config)
+ [Input artifact (Artefatti di input)](#action-reference-CodestarConnectionSource-input)
+ [Artefatti di output](#action-reference-CodestarConnectionSource-output)
+ [Variabili di output](#action-reference-CodestarConnectionSource-variables)
+ [Autorizzazioni per i ruoli di servizio: azione CodeConnections](#edit-role-connections)
+ [Dichiarazione dell'operazione](#action-reference-CodestarConnectionSource-example)
+ [Installazione dell'app di installazione e creazione di una connessione](#action-reference-CodestarConnectionSource-auth)
+ [Consulta anche](#action-reference-CodestarConnectionSource-links)
## Tipo di operazione
+ Categoria: `Source`
+ Proprietario: `AWS`
+ Provider: `CodeStarSourceConnection`
+ Versione: `1`
## Parametri di configurazione
****ConnectionArn****
Obbligatorio: sì
L'ARN della connessione configurato e autenticato per il provider di origine.
****FullRepositoryId****
Obbligatorio: sì
Il proprietario e il nome del repository in cui devono essere rilevate le modifiche di origine.
Ad esempio: `some-user/my-repo`
È necessario utilizzare le maiuscole e minuscole corrette per il **FullRepositoryId**valore. Ad esempio, se il nome utente è `some-user` e il nome del repository è`My-Repo`, il valore consigliato di **FullRepositoryId**è`some-user/My-Repo`.
****BranchName****
Obbligatorio: sì
Il nome del ramo in cui devono essere rilevate le modifiche di origine.
****OutputArtifactFormat****
Obbligatorio: no
Specifica il formato dell'artefatto di output. Può essere `CODEBUILD_CLONE_REF` o `CODE_ZIP`. Se non altrimenti specificato, l'impostazione predefinita è `CODE_ZIP`.
L'opzione `CODEBUILD_CLONE_REF` può essere utilizzata solo da operazioni downstream di CodeBuild.
Se scegli questa opzione, dovrai aggiornare le autorizzazioni per il tuo ruolo di CodeBuild Project Service come mostrato in. [Aggiungi le autorizzazioni per le connessioni a Bitbucket, Enterprise Server o.com CodeBuild GitClone GitHub GitHub GitLab](troubleshooting.md#codebuild-role-connections) Per un tutorial che mostra come usare l'opzione **Full clone**, consulta. [Tutorial: usa il clone completo con una sorgente di GitHub pipeline](tutorials-github-gitclone.md)
**DetectChanges**
Obbligatorio: no
Controlla l'avvio automatico della pipeline quando viene effettuato un nuovo commit sul repository e sul ramo configurati. Se non specificato, il valore predefinito è `true` e il campo non viene visualizzato per impostazione predefinita. I valori validi per questo parametro sono:
+ `true`: avvia CodePipeline automaticamente la pipeline con nuovi commit.
+ `false`: CodePipeline non avvia la pipeline con nuovi commit.
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di input non si applicano a questo tipo di azione.
## Artefatti di output
+ **Numero di artefatti:** `1`
+ **Descrizione:** gli artefatti generati dal repository sono gli artefatti di output per l'operazione `CodeStarSourceConnection`. L'ID di commit del codice sorgente viene visualizzato CodePipeline come revisione del codice sorgente per l'esecuzione della pipeline attivata. È possibile configurare l'artefatto di output di questa operazione:
+ Un file ZIP che contiene il contenuto del repository configurato e del ramo al commit specificato come revisione di origine per l'esecuzione della pipeline.
+ Un file JSON che contiene un riferimento URL al repository in modo che le operazioni downstream possano eseguire direttamente comandi Git.
**Importante**
Questa opzione può essere utilizzata solo dalle CodeBuild azioni a valle.
Se scegli questa opzione, dovrai aggiornare le autorizzazioni per il tuo ruolo di CodeBuild Project Service come mostrato in. [Risoluzione dei problemi CodePipeline](troubleshooting.md) Per un tutorial che mostra come usare l'opzione **Full clone**, consulta. [Tutorial: usa il clone completo con una sorgente di GitHub pipeline](tutorials-github-gitclone.md)
## Variabili di output
Quando è configurata, questa azione produce variabili che possono essere referenziate dalla configurazione dell'azione di un'azione downstream nella pipeline. Questa azione produce variabili che possono essere viste come variabili di output, anche se l'azione non ha uno spazio dei nomi. È possibile configurare un'azione con uno spazio dei nomi per rendere tali variabili disponibili per la configurazione delle azioni downstream.
Per ulteriori informazioni, consulta [Riferimento alle variabili](reference-variables.md).
AuthorDate
La data in cui il commit è stato creato, in formato timestamp.
BranchName
Il nome del ramo per il repository in cui è stata apportata la modifica dell’origine.
CommitId
L'ID di commit che ha attivato l'esecuzione della pipeline.
CommitMessage
Il messaggio di descrizione, se presente, associato al commit che ha attivato l'esecuzione della pipeline.
ConnectionArn
L'ARN della connessione configurato e autenticato per il provider di origine.
FullRepositoryName
Il nome del repository in cui è stato effettuato il commit che ha attivato la pipeline.
## Autorizzazioni per i ruoli di servizio: azione CodeConnections
Infatti CodeConnections, è richiesta la seguente autorizzazione per creare pipeline con una fonte che utilizza una connessione, come Bitbucket Cloud.
```
{
"Effect": "Allow",
"Action": [
"codeconnections:UseConnection"
],
"Resource": "resource_ARN"
},
```
[Per ulteriori informazioni sulle autorizzazioni IAM per le connessioni, consulta Connections permissions reference.](https://docs.aws.amazon.com/dtconsole/latest/userguide/security-iam.html#permissions-reference-connections)
## Dichiarazione dell'operazione
Nell'esempio seguente, l'elemento di output è impostato sul formato ZIP predefinito `CODE_ZIP` per la connessione con ARN. `arn:aws:codestar-connections:region:account-id:connection/connection-id`
------
#### [ YAML ]
```
Name: Source
Actions:
- InputArtifacts: []
ActionTypeId:
Version: '1'
Owner: AWS
Category: Source
Provider: CodeStarSourceConnection
OutputArtifacts:
- Name: SourceArtifact
RunOrder: 1
Configuration:
ConnectionArn: "arn:aws:codestar-connections:region:account-id:connection/connection-id"
FullRepositoryId: "some-user/my-repo"
BranchName: "main"
OutputArtifactFormat: "CODE_ZIP"
Name: ApplicationSource
```
------
#### [ JSON ]
```
{
"Name": "Source",
"Actions": [
{
"InputArtifacts": [],
"ActionTypeId": {
"Version": "1",
"Owner": "AWS",
"Category": "Source",
"Provider": "CodeStarSourceConnection"
},
"OutputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"RunOrder": 1,
"Configuration": {
"ConnectionArn": "arn:aws:codestar-connections:region:account-id:connection/connection-id",
"FullRepositoryId": "some-user/my-repo",
"BranchName": "main",
"OutputArtifactFormat": "CODE_ZIP"
},
"Name": "ApplicationSource"
}
]
},
```
------
## Installazione dell'app di installazione e creazione di una connessione
La prima volta che usi la console per aggiungere una nuova connessione a un repository di terze parti, devi autorizzare CodePipeline l'accesso ai tuoi repository. È possibile selezionare o creare un'app di installazione che permette di connettersi all'account in cui è stato creato il repository di codice di terze parti.
Quando si utilizza AWS CLI o un CloudFormation modello, è necessario fornire l'ARN di connessione di una connessione che è già stata sottoposta all'handshake di installazione. In caso contrario, la pipeline non viene attivata.
**Nota**
Per un'azione di `CodeStarSourceConnection` origine, non è necessario impostare un webhook o impostare come impostazione predefinita il polling. L'azione connessioni gestisce automaticamente il rilevamento delle modifiche alla fonte.
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [AWS::CodeStarConnections::Connection](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codestarconnections-connection.html)— Il riferimento al CloudFormation modello per la risorsa AWS CodeStar Connections fornisce parametri ed esempi per le connessioni nei CloudFormation modelli.
+ [AWS CodeStarRiferimento all'API AWS CodeStar Connections](https://docs.aws.amazon.com/codestar-connections/latest/APIReference/Welcome.html)*: il riferimento all'API Connections* fornisce informazioni di riferimento per le azioni di connessione disponibili.
+ Per visualizzare i passaggi per la creazione di una pipeline con azioni di origine supportate dalle connessioni, consulta quanto segue:
+ Per Bitbucket Cloud, utilizza l'opzione **Bitbucket** nella console o l'azione nella CLI`CodestarSourceConnection`. Per informazioni, consulta [Connessioni Bitbucket Cloud](connections-bitbucket.md).
+ Per GitHub GitHub Enterprise Cloud, utilizza l'opzione **GitHub**provider nella console o l'`CodestarSourceConnection`azione nella CLI. Per informazioni, consulta [GitHub connessioni](connections-github.md).
+ Per GitHub Enterprise Server, utilizzate l'opzione provider **GitHub Enterprise Server** nella console o l'`CodestarSourceConnection`azione nella CLI. Per informazioni, consulta [GitHub Connessioni Enterprise Server](connections-ghes.md).
+ Per GitLab .com, utilizza l'opzione **GitLab**provider nella console o l'`CodestarSourceConnection`azione con il `GitLab` provider nella CLI. Per informazioni, consulta [GitLabconnessioni.com](connections-gitlab.md).
+ Per visualizzare un tutorial introduttivo che crea una pipeline con un'origine Bitbucket e un' CodeBuild azione, vedi [Guida introduttiva](https://docs.aws.amazon.com/dtconsole/latest/userguide/getting-started-connections.html) alle connessioni.
+ Per un tutorial che mostra come connettersi a un GitHub repository e utilizzare l'opzione **Full clone** con un'azione a valle, consulta. CodeBuild [Tutorial: usa il clone completo con una sorgente di GitHub pipeline](tutorials-github-gitclone.md)
# Riferimento all'azione dei comandi
L'azione Comandi consente di eseguire comandi shell in un'istanza di calcolo virtuale. Quando si esegue l'azione, i comandi specificati nella configurazione dell'azione vengono eseguiti in un contenitore separato. Tutti gli artefatti specificati come artefatti di input per un' CodeBuild azione sono disponibili all'interno del contenitore che esegue i comandi. Questa azione consente di specificare i comandi senza prima creare un progetto. CodeBuild Per ulteriori informazioni, consulta le pagine [ActionDeclaration](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ActionDeclaration.html) e [OutputArtifact](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_OutputArtifact.html) nella *Documentazione di riferimento dell'API AWS CodePipeline *.
**Importante**
Questa azione utilizza l' CodeBuild elaborazione CodePipeline gestita per eseguire comandi in un ambiente di compilazione. L'esecuzione dell'azione dei comandi comporterà costi separati in. AWS CodeBuild
**Nota**
L'azione Comandi è disponibile solo per le pipeline di tipo V2.
**Topics**
+ [Considerazioni sull'azione Comandi](#action-reference-Commands-considerations)
+ [Autorizzazioni relative ai ruoli di servizio](#action-reference-Commands-policy)
+ [Tipo di operazione](#action-reference-Commands-type)
+ [Parametri di configurazione](#action-reference-Commands-config)
+ [Input artifact (Artefatti di input)](#action-reference-Commands-input)
+ [Artefatti di output](#action-reference-Commands-output)
+ [Variabili di ambiente](#action-reference-Commands-envvars)
+ [Autorizzazioni del ruolo di servizio: azione dei comandi](#edit-role-Commands)
+ [Dichiarazione di azione (esempio)](#action-reference-Commands-example)
+ [Consulta anche](#action-reference-Commands-links)
## Considerazioni sull'azione Comandi
Le considerazioni seguenti si applicano all'azione Comandi.
+ L'azione dei comandi utilizza CodeBuild risorse simili all' CodeBuild azione, ma consente i comandi in ambiente shell in un'istanza di calcolo virtuale senza la necessità di associare o creare un progetto di compilazione.
**Nota**
L'esecuzione dell'azione dei comandi comporterà costi separati in. AWS CodeBuild
+ Poiché l'azione Comandi in CodePipeline utilizza CodeBuild risorse, le build eseguite dall'azione verranno attribuite ai limiti di build per il tuo account in. CodeBuild Le build eseguite dall'azione Comandi verranno conteggiate ai fini dei limiti di compilazione simultanea configurati per quell'account.
+ Il timeout per le build con l'azione Comandi è di 55 minuti, in base alle build. CodeBuild
+ L'istanza di calcolo utilizza un ambiente di compilazione isolato in. CodeBuild
**Nota**
Poiché l'ambiente di compilazione isolato viene utilizzato a livello di account, un'istanza potrebbe essere riutilizzata per un'altra esecuzione della pipeline.
+ Sono supportati tutti i formati tranne i formati multilinea. È necessario utilizzare il formato a riga singola quando si immettono i comandi.
+ L'azione dei comandi è supportata per le azioni tra account. Per aggiungere un'azione di comandi tra account, aggiungila `actionRoleArn` dal tuo account di destinazione nella dichiarazione dell'azione.
+ Per questa azione, CodePipeline assumerà il ruolo di servizio di pipeline e utilizzerà tale ruolo per consentire l'accesso alle risorse in fase di esecuzione. Si consiglia di configurare il ruolo di servizio in modo che le autorizzazioni siano limitate al livello di azione.
+ Le autorizzazioni aggiunte al ruolo di CodePipeline servizio sono dettagliate in. [Aggiungi le autorizzazioni al ruolo di servizio CodePipeline](how-to-custom-role.md#how-to-update-role-new-services)
+ Le autorizzazioni necessarie per visualizzare i log nella console sono dettagliate in. [Autorizzazioni necessarie per visualizzare i log di calcolo nella console](security-iam-permissions-console-logs.md)
+ A differenza di altre azioni in CodePipeline, non si impostano campi nella configurazione dell'azione; si impostano i campi di configurazione dell'azione al di fuori della configurazione dell'azione.
## Autorizzazioni relative ai ruoli di servizio
Quando CodePipeline esegue l'azione, CodePipeline crea un gruppo di log utilizzando il nome della pipeline come segue. Ciò consente di ridurre l'ambito delle autorizzazioni per registrare le risorse utilizzando il nome della pipeline.
```
/aws/codepipeline/MyPipelineName
```
Se si utilizza un ruolo di servizio esistente, per utilizzare l'azione Comandi è necessario aggiungere le seguenti autorizzazioni per il ruolo di servizio.
+ registri: CreateLogGroup
+ registri: CreateLogStream
+ registri: PutLogEvents
Nella dichiarazione sulla politica relativa al ruolo del servizio, riduci le autorizzazioni a livello di pipeline, come mostrato nell'esempio seguente.
```
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:*:YOUR_AWS_ACCOUNT_ID:log-group:/aws/codepipeline/YOUR_PIPELINE_NAME",
"arn:aws:logs:*:YOUR_AWS_ACCOUNT_ID:log-group:/aws/codepipeline/YOUR_PIPELINE_NAME:*"
]
}
```
Per visualizzare i log nella console utilizzando la pagina di dialogo dei dettagli delle azioni, è necessario aggiungere l'autorizzazione alla visualizzazione dei log al ruolo della console. Per ulteriori informazioni, consulta l'esempio di policy sulle autorizzazioni della console in. [Autorizzazioni necessarie per visualizzare i log di calcolo nella console](security-iam-permissions-console-logs.md)
## Tipo di operazione
+ Categoria: `Compute`
+ Proprietario: `AWS`
+ Provider: `Commands`
+ Versione: `1`
## Parametri di configurazione
**Comandi**
Obbligatorio: sì
È possibile fornire comandi di shell per l'`Commands`azione da eseguire. Nella console, i comandi vengono immessi su righe separate. Nella CLI, i comandi vengono immessi come stringhe separate.
I formati multilinea non sono supportati e genereranno un messaggio di errore. È necessario utilizzare il formato a riga singola per immettere i comandi nel campo **Comandi**.
I ComputeType valori EnvironmentType and corrispondono a quelli di CodeBuild. Supportiamo un sottoinsieme dei tipi disponibili. Per ulteriori informazioni, consulta [Tipi di calcolo di ambiente di compilazione](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html).
**EnvironmentType**
Obbligatorio: no
L'immagine del sistema operativo per l'ambiente di compilazione che supporta l'azione Commands. Di seguito sono riportati i valori validi per gli ambienti di compilazione:
+ LINUX\$1CONTAINER
+ WINDOWS\$1SERVER\$12022\$1CONTAINER
La selezione di **EnvironmentType**consentirà quindi il tipo di calcolo per quel sistema operativo nel campo. **ComputeType** Per ulteriori informazioni sui tipi di CodeBuild calcolo disponibili per questa azione, consulta il riferimento alle [modalità e ai tipi di calcolo dell'ambiente di creazione](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html) nella Guida per l' CodeBuild utente.
Se non viene specificato, per impostazione predefinita il calcolo per l'ambiente di compilazione è il seguente:
+ **Tipo di calcolo**: BUILD\$1 \$1SMALL GENERAL1
+ **Tipo di ambiente: LINUX\$1CONTAINER**
**ComputeType**
Obbligatorio: no
In base alla selezione di EnvironmentType, è possibile fornire il tipo di calcolo. Di seguito sono riportati i valori disponibili per il calcolo; tuttavia, tieni presente che le opzioni disponibili possono variare in base al sistema operativo.
+ GENERAL1BUILD\$1 \$1SMALL
+ COSTRUZIONE\$1 GENERAL1 \$1MEDIA
+ COSTRUZIONE\$1 GENERAL1 \$1GRANDE
Alcuni tipi di elaborazione non sono compatibili con determinati tipi di ambiente. Ad esempio, WINDOWS\$1SERVER\$12022\$1CONTAINER non è compatibile con BUILD\$1 \$1SMALL. GENERAL1 L'utilizzo di combinazioni incompatibili causa l'esito negativo dell'azione e genera un errore di runtime.
**Variabili di output**
Obbligatorio: no
Specificate i nomi delle variabili dell'ambiente che desiderate esportare. Per un riferimento alle variabili di CodeBuild ambiente, consulta [Variabili di ambiente negli ambienti di compilazione](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html) nella *Guida CodeBuild per l'utente*.
**File**
Obbligatorio: no
Potete fornire i file che desiderate esportare come artefatti di output per l'azione.
Il formato supportato per i file è lo stesso dei modelli di CodeBuild file. Ad esempio, immettere `**/` per tutti i file. Per ulteriori informazioni, consulta il [riferimento alle specifiche di Build CodeBuild nella Guida per](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec.artifacts.files) *l'CodeBuild utente*.
![\[La pagina Modifica azione per una nuova pipeline con l'azione Comandi\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/commands-edit-screen.png)
**VpcId**
Obbligatorio: no
L'ID VPC per le tue risorse.
**Sottoreti**
Obbligatorio: no
Le sottoreti per il VPC. Questo campo è necessario quando i comandi devono connettersi alle risorse in un VPC.
**SecurityGroupIds**
Obbligatorio: no
I gruppi di sicurezza per il VPC. Questo campo è necessario quando i comandi devono connettersi alle risorse in un VPC.
Di seguito è riportato un esempio JSON dell'azione con i campi di configurazione mostrati per l'ambiente e il tipo di calcolo, insieme a una variabile di ambiente di esempio.
```
{
"name": "Commands1",
"actionTypeId": {
"category": "Compute",
"owner": "AWS",
"provider": "Commands",
"version": "1"
},
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"commands": [
"ls",
"echo hello",
"echo $BEDROCK_TOKEN",
],
"configuration": {
"EnvironmentType": "LINUX_CONTAINER",
"ComputeType": "BUILD_GENERAL1_MEDIUM"
},
"environmentVariables": [
{
"name": "BEDROCK_TOKEN",
"value": "apiTokens:bedrockToken",
"type": "SECRETS_MANAGER"
}
],
"runOrder": 1
}
```
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1 to 10`
## Artefatti di output
+ **Numero di artefatti:** `0 to 1`
## Variabili di ambiente
**Chiave**
La chiave in una coppia di variabili d'ambiente chiave-valore, ad esempio. `BEDROCK_TOKEN`
**Valore**
Il valore per la coppia chiave-valore, ad esempio. `apiTokens:bedrockToken` Il valore può essere parametrizzato con variabili di output provenienti da azioni di pipeline o variabili di pipeline.
Quando si utilizza il `SECRETS_MANAGER` tipo, questo valore deve essere il nome di un segreto già archiviato in AWS Secrets Manager.
**Tipo**
Speciifica il tipo di utilizzo del valore della variabile di ambiente. Il valore può essere `PLAINTEXT` o `SECRETS_MANAGER`. Se il valore è`SECRETS_MANAGER`, fornite il riferimento Secrets nel `EnvironmentVariable` valore. Se il valore non viene specificato, viene usato il valore predefinito `PLAINTEXT`.
Sconsigliamo vivamente l'uso di variabili di ambiente in *testo semplice* per memorizzare valori sensibili, in particolare le credenziali. AWS Quando si utilizza la CodeBuild console o AWS CLI, le variabili di ambiente in *testo semplice vengono visualizzate in testo semplice*. Per i valori sensibili, si consiglia di utilizzare invece il tipo `SECRETS_MANAGER`.
**Nota**
Quando inserite la configurazione e `type` per le variabili di ambiente `name``value`, specialmente se la variabile di ambiente contiene la sintassi della variabile di CodePipeline output, non superate il limite di 1000 caratteri per il campo del valore della configurazione. Quando questo limite viene superato, viene restituito un errore di convalida.
Per un esempio di dichiarazione di azione che mostra una variabile di ambiente, vedere. [Parametri di configurazione](#action-reference-Commands-config)
**Nota**
Il `SECRETS_MANAGER` tipo è supportato solo per l'azione Commands.
I segreti a cui si fa riferimento nell'azione Comandi verranno oscurati nei log di build in modo simile a. CodeBuild Tuttavia, gli utenti della pipeline che dispongono dell'accesso **Modifica** alla pipeline possono comunque accedere potenzialmente a questi valori segreti modificando i comandi.
Per utilizzare SecretsManager, devi aggiungere le seguenti autorizzazioni al tuo ruolo di servizio di pipeline:
```
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"SECRET_ARN"
]
}
```
## Autorizzazioni del ruolo di servizio: azione dei comandi
Per il supporto ai comandi, aggiungi quanto segue alla tua dichiarazione politica:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:iam::*:role/Service*",
"arn:aws:iam::*:role/Service*"
]
}
]
}
```
------
## Dichiarazione di azione (esempio)
------
#### [ YAML ]
```
name: Commands_action
actionTypeId:
category: Compute
owner: AWS
provider: Commands
version: '1'
runOrder: 1
configuration: {}
commands:
- ls
- echo hello
- 'echo pipeline Execution Id is #{codepipeline.PipelineExecutionId}'
outputArtifacts:
- name: BuildArtifact
files:
- **/
inputArtifacts:
- name: SourceArtifact
outputVariables:
- AWS_DEFAULT_REGION
region: us-east-1
namespace: compute
```
------
#### [ JSON ]
```
{
"name": "Commands_action",
"actionTypeId": {
"category": "Compute",
"owner": "AWS",
"provider": "Commands",
"version": "1"
},
"runOrder": 1,
"configuration": {},
"commands": [
"ls",
"echo hello",
"echo pipeline Execution Id is #{codepipeline.PipelineExecutionId}"
],
"outputArtifacts": [
{
"name": "BuildArtifact",
"files": [
"**/"
]
}
],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"outputVariables": [
"AWS_DEFAULT_REGION"
],
"region": "us-east-1",
"namespace": "compute"
}
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Tutorial: crea una pipeline che esegue comandi con compute (tipo V2)](tutorials-commands.md)— Questo tutorial fornisce una pipeline di esempio con l'azione Commands.
# AWS Device Farm riferimento all'azione di test
Nella tua pipeline, puoi configurare un'azione di test AWS Device Farm da utilizzare per eseguire e testare l'applicazione sui dispositivi. Device Farm utilizza pool di test di dispositivi e framework di test per testare le applicazioni su dispositivi specifici. Per informazioni sui tipi di framework di test supportati dall'azione Device Farm, vedere [Working with Test Types in AWS Device](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types.html) Farm.
**Topics**
+ [Tipo di operazione](#action-reference-DeviceFarm-type)
+ [Parametri di configurazione](#action-reference-DeviceFarm-config)
+ [Input artifact (Artefatti di input)](#action-reference-DeviceFarm-input)
+ [Artefatti di output](#action-reference-DeviceFarm-output)
+ [Autorizzazioni per i ruoli di servizio: azione AWS Device Farm](#edit-role-devicefarm)
+ [Dichiarazione dell'operazione](#action-reference-DeviceFarm-example)
+ [Consulta anche](#action-reference-DeviceFarm-links)
## Tipo di operazione
+ Categoria: `Test`
+ Proprietario: `AWS`
+ Provider: `DeviceFarm`
+ Versione: `1`
## Parametri di configurazione
**AppType**
Obbligatorio: sì
Il sistema operativo e il tipo di applicazione che stai testando. Di seguito è riportato un elenco di valori validi:
+ `iOS`
+ `Android`
+ `Web`
**ProjectId**
Obbligatorio: sì
L'ID del progetto Device Farm.
Per trovare l'ID del progetto, nella console Device Farm, scegli il tuo progetto. Nel browser, copiare l'URL del nuovo progetto. L'URL contiene l'ID del progetto. L'ID del progetto è il valore nell'URL successivo`projects/`. Nell'esempio seguente, l'ID del progetto è`eec4905f-98f8-40aa-9afc-4c1cfexample`.
```
https:///devicefarm/home?region=us-west-2#/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs
```
**App**
Obbligatorio: sì
Il nome e la posizione del file dell'applicazione nell'elemento di input. Ad esempio: `s3-ios-test-1.ipa`
**TestSpec**
Condizionale: Sì
La posizione del file di definizione delle specifiche di test nell'artefatto di input. Questo è necessario per il test in modalità personalizzata.
**DevicePoolArn**
Obbligatorio: sì
L'ARN del pool di dispositivi Device Farm.
Per ottenere il pool di dispositivi disponibile ARNs per il progetto, incluso l'ARN per i dispositivi principali, utilizza la AWS CLI per immettere il seguente comando:
```
aws devicefarm list-device-pools --arn arn:aws:devicefarm:us-west-2:account_ID:project:project_ID
```
**TestType**
Obbligatorio: sì
Speciifica il framework di test supportato per il test. Di seguito è riportato un elenco di valori validi per`TestType`:
+ **APPIUM\$1JAVA\$1JUNIT**
+ **APPIUM\$1JAVA\$1TESTNG**
+ **NODO\$1APPIUM**
+ **APPIUM\$1RUBY**
+ **APPIUM\$1PYTHON**
+ **APPIUM\$1WEB\$1JAVA JUNIT**
+ **APPIUM\$1WEB\$1JAVA\$1TESTNG**
+ **NODO APPIUM\$1WEB**
+ **APPIUM\$1WEB\$1RUBY**
+ **APPIUM\$1WEB\$1PYTHON**
+ **BUILTIN\$1FUZZ**
+ **INSTRUMENTATION**
+ **XCTEST**
+ **XCTEST\$1UI**
I seguenti tipi di test non sono supportati dall'azione in CodePipeline:`WEB_PERFORMANCE_PROFILE`, e. `REMOTE_ACCESS_RECORD` `REMOTE_ACCESS_REPLAY`
Per informazioni sui tipi di test di Device Farm, vedere [Working with Test Types in AWS Device Farm](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types.html).
**RadioBluetoothEnabled**
Obbligatorio: no
Un valore booleano che indica se abilitare il Bluetooth all'inizio del test.
**RecordAppPerformanceData**
Obbligatorio: no
Un valore booleano che indica se registrare dati sulle prestazioni del dispositivo come CPU, FPS e prestazioni della memoria durante il test.
**RecordVideo**
Obbligatorio: no
Un valore booleano che indica se registrare video durante il test.
**RadioWifiEnabled**
Obbligatorio: no
Un valore booleano che indica se abilitare il Wi-Fi all'inizio del test.
**RadioNfcEnabled**
Obbligatorio: no
Un valore booleano che indica se abilitare NFC all'inizio del test.
**RadioGpsEnabled**
Obbligatorio: no
Un valore booleano che indica se abilitare il GPS all'inizio del test.
**Test**
Obbligatorio: no
Il nome e il percorso del file di definizione del test nella posizione di origine. Il percorso è relativo alla cartella principale dell'artefatto di input del test.
**FuzzEventCount**
Obbligatorio: no
Il numero di eventi dell'interfaccia utente che il fuzz test deve eseguire, compreso tra 1 e 10.000.
**FuzzEventThrottle**
Obbligatorio: no
Il numero di millisecondi di attesa del fuzz test prima di eseguire il successivo evento dell'interfaccia utente, compreso tra 1 e 1.000.
**FuzzRandomizerSeed**
Obbligatorio: no
Un seme per il fuzz test da utilizzare per randomizzare gli eventi dell'interfaccia utente. Utilizzando lo stesso numero per i fuzz test successivi si ottengono sequenze di eventi identiche.
**CustomHostMachineArtifacts**
Obbligatorio: no
La posizione sul computer host in cui verranno archiviati gli elementi personalizzati.
**CustomDeviceArtifacts**
Obbligatorio: no
La posizione sul dispositivo in cui verranno archiviati gli artefatti personalizzati.
**UnmeteredDevicesOnly**
Obbligatorio: no
Un valore booleano che indica se utilizzare solo i dispositivi illimitati durante l'esecuzione dei test in questa fase.
**JobTimeoutMinutes**
Obbligatorio: no
Il numero di minuti di esecuzione di un test per dispositivo prima del timeout.
**Latitudine**
Obbligatorio: no
La latitudine del dispositivo espressa in gradi del sistema di coordinate geografiche.
**Longitudine**
Obbligatorio: no
La longitudine del dispositivo espressa in gradi del sistema di coordinate geografiche.
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1`
+ **Descrizione:** L'insieme di artefatti da mettere a disposizione dell'azione di test. Device Farm cerca l'applicazione integrata e le definizioni di test da utilizzare.
## Artefatti di output
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di output non si applicano a questo tipo di azione.
## Autorizzazioni per i ruoli di servizio: azione AWS Device Farm
Quando CodePipeline viene eseguita l'azione, la policy del ruolo di CodePipeline servizio richiede le seguenti autorizzazioni, assegnate in modo appropriato all'ARN della risorsa della pipeline per mantenere l'accesso con il minimo privilegio. Ad esempio, aggiungi quanto segue alla tua dichiarazione politica:
```
{
"Effect": "Allow",
"Action": [
"devicefarm:ListProjects",
"devicefarm:ListDevicePools",
"devicefarm:GetRun",
"devicefarm:GetUpload",
"devicefarm:CreateUpload",
"devicefarm:ScheduleRun"
],
"Resource": "resource_ARN"
},
```
## Dichiarazione dell'operazione
------
#### [ YAML ]
```
Name: Test
Actions:
- Name: TestDeviceFarm
ActionTypeId: null
category: Test
owner: AWS
provider: DeviceFarm
version: '1'
RunOrder: 1
Configuration:
App: s3-ios-test-1.ipa
AppType: iOS
DevicePoolArn: >-
arn:aws:devicefarm:us-west-2::devicepool:0EXAMPLE-d7d7-48a5-ba5c-b33d66efa1f5
ProjectId: eec4905f-98f8-40aa-9afc-4c1cfEXAMPLE
TestType: APPIUM_PYTHON
TestSpec: example-spec.yml
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
```
------
#### [ JSON ]
```
{
"Name": "Test",
"Actions": [
{
"Name": "TestDeviceFarm",
"ActionTypeId": null,
"category": "Test",
"owner": "AWS",
"provider": "DeviceFarm",
"version": "1"
}
],
"RunOrder": 1,
"Configuration": {
"App": "s3-ios-test-1.ipa",
"AppType": "iOS",
"DevicePoolArn": "arn:aws:devicefarm:us-west-2::devicepool:0EXAMPLE-d7d7-48a5-ba5c-b33d66efa1f5",
"ProjectId": "eec4905f-98f8-40aa-9afc-4c1cfEXAMPLE",
"TestType": "APPIUM_PYTHON",
"TestSpec": "example-spec.yml"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2"
},
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Utilizzo dei tipi di test in Device Farm](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types.html): questo capitolo di riferimento della *Device Farm Developer Guide* fornisce ulteriori descrizioni sui framework di test per Android, iOS e applicazioni Web supportati da Device Farm.
+ [Azioni in Device Farm](https://docs.aws.amazon.com/devicefarm/latest/APIReference/Welcome.html): le chiamate e i parametri API nel *Device Farm API Reference* possono aiutarti a lavorare con i progetti Device Farm.
+ [Tutorial: crea una pipeline con cui creare e testare la tua app Android AWS Device Farm](tutorials-codebuild-devicefarm.md)— Questo tutorial fornisce un esempio di file di specifiche di build e un'applicazione di esempio per creare una pipeline con un GitHub sorgente che crea e testa un'app Android con Device CodeBuild Farm.
+ [Tutorial: crea una pipeline con cui testare la tua app iOS AWS Device Farm](tutorials-codebuild-devicefarm-S3.md)— Questo tutorial fornisce un'applicazione di esempio per creare una pipeline con un sorgente Amazon S3 che testa un'app iOS integrata con Device Farm.
# Riferimento all'azione di distribuzione di Elastic Beanstalk
Elastic Beanstalk è una AWS piattaforma interna utilizzata per la distribuzione e il ridimensionamento di applicazioni Web. Utilizzi un'azione Elastic Beanstalk per distribuire il codice dell'applicazione nel tuo ambiente di distribuzione.
**Topics**
+ [Tipo di operazione](#action-reference-Beanstalk-type)
+ [Parametri di configurazione](#action-reference-Beanstalk-config)
+ [Input artifact (Artefatti di input)](#action-reference-Beanstalk-input)
+ [Artefatti di output](#action-reference-Beanstalk-output)
+ [Autorizzazioni per i ruoli di servizio: distribuisci l'azione `ElasticBeanstalk`](#edit-role-beanstalk)
+ [Dichiarazione dell'operazione](#action-reference-Beanstalk-example)
+ [Consulta anche](#action-reference-Beanstalk-links)
## Tipo di operazione
+ Categoria: `Deploy`
+ Proprietario: `AWS`
+ Provider: `ElasticBeanstalk`
+ Versione: `1`
## Parametri di configurazione
**ApplicationName**
Obbligatorio: sì
Il nome dell'applicazione che hai creato in Elastic Beanstalk.
**EnvironmentName**
Obbligatorio: sì
Il nome dell'ambiente che hai creato in Elastic Beanstalk. Un ambiente è una raccolta di AWS risorse che eseguono una versione dell'applicazione. Ogni ambiente esegue una sola versione dell'applicazione alla volta. Tuttavia, puoi eseguire la stessa versione dell'applicazione o versioni dell'applicazione diverse in molti ambienti contemporaneamente.
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1`
+ **Descrizione:** l'artefatto di input per l'azione.
## Artefatti di output
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di output non si applicano a questo tipo di azione.
## Autorizzazioni per i ruoli di servizio: distribuisci l'azione `ElasticBeanstalk`
Per Elastic Beanstalk, le seguenti sono le autorizzazioni minime necessarie per creare pipeline con un'azione di distribuzione. `ElasticBeanstalk`
```
{
"Effect": "Allow",
"Action": [
"elasticbeanstalk:*",
"ec2:*",
"elasticloadbalancing:*",
"autoscaling:*",
"cloudwatch:*",
"s3:*",
"sns:*",
"cloudformation:*",
"rds:*",
"sqs:*",
"ecs:*"
],
"Resource": "resource_ARN"
},
```
**Nota**
È necessario sostituire i caratteri jolly nella politica delle risorse con le risorse dell'account a cui si desidera limitare l'accesso. Per ulteriori informazioni sulla creazione di una politica che garantisca l'accesso con privilegi minimi, consulta. [https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege)
## Dichiarazione dell'operazione
------
#### [ YAML ]
```
Name: Deploy
Actions:
- Name: Deploy
ActionTypeId:
Category: Deploy
Owner: AWS
Provider: ElasticBeanstalk
Version: '1'
RunOrder: 1
Configuration:
ApplicationName: my-application
EnvironmentName: my-environment
OutputArtifacts: []
InputArtifacts:
- Name: SourceArtifact
Region: us-west-2
Namespace: DeployVariables
```
------
#### [ JSON ]
```
{
"Name": "Deploy",
"Actions": [
{
"Name": "Deploy",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Provider": "ElasticBeanstalk",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"ApplicationName": "my-application",
"EnvironmentName": "my-environment"
},
"OutputArtifacts": [],
"InputArtifacts": [
{
"Name": "SourceArtifact"
}
],
"Region": "us-west-2",
"Namespace": "DeployVariables"
}
]
},
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Distribuzione di un'applicazione Flask su Elastic Beanstalk](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create-deploy-python-flask.html): questo tutorial illustra la creazione delle risorse dell'applicazione e dell'ambiente in Elastic Beanstalk utilizzando un'applicazione Flask di esempio. È quindi possibile creare la pipeline con un'azione di distribuzione di Elastic Beanstalk che distribuisce l'applicazione dal repository di origine all'ambiente Elastic Beanstalk.
# Riferimento all'azione di richiamo di Amazon `InspectorScan` Inspector
Amazon Inspector è un servizio di gestione delle vulnerabilità che rileva automaticamente i carichi di lavoro e li analizza continuamente per individuare vulnerabilità del software ed esposizione involontaria alla rete. L'`InspectorScan`azione CodePipeline automatizza il rilevamento e la correzione delle vulnerabilità di sicurezza nel codice open source. L'azione è un'azione di elaborazione gestita con funzionalità di scansione di sicurezza. Puoi utilizzarlo InspectorScan con il codice sorgente dell'applicazione nel tuo repository di terze parti, ad GitHub esempio Bitbucket Cloud, o con immagini per applicazioni container. La tua azione analizzerà e segnalerà i livelli di vulnerabilità e gli avvisi che configuri.
**Importante**
Questa azione utilizza l' CodeBuild elaborazione CodePipeline gestita per eseguire comandi in un ambiente di compilazione. L'esecuzione dell'azione comporterà addebiti separati in. AWS CodeBuild
**Topics**
+ [ID del tipo di azione](#action-reference-InspectorScan-type)
+ [Parametri di configurazione](#action-reference-InspectorScan-parameters)
+ [Input artifact (Artefatti di input)](#action-reference-InspectorScan-input)
+ [Artefatti di output](#action-reference-InspectorScan-output)
+ [Variabili di output](#w2aac56c62c19)
+ [Autorizzazioni per i ruoli di servizio: azione `InspectorScan`](#edit-role-InspectorScan)
+ [Dichiarazione dell'operazione](#w2aac56c62c23)
+ [Consulta anche](#action-reference-InspectorScan-links)
## ID del tipo di azione
+ Categoria: `Invoke`
+ Proprietario: `AWS`
+ Provider: `InspectorScan`
+ Versione: `1`
Esempio:
```
{
"Category": "Invoke",
"Owner": "AWS",
"Provider": "InspectorScan",
"Version": "1"
},
```
## Parametri di configurazione
**InspectorRunMode**
(Obbligatorio) La stringa che indica la modalità della scansione. I valori validi sono `SourceCodeScan | ECRImageScan`.
**ECRRepositoryNome**
Il nome del repository Amazon ECR in cui è stata inserita l'immagine.
**ImageTag**
Il tag utilizzato per l'immagine.
I parametri per questa azione analizzano i livelli di vulnerabilità specificati. Sono disponibili i seguenti livelli per le soglie di vulnerabilità:
**CriticalThreshold **
Il numero di vulnerabilità di gravità critica rilevate nella fonte oltre il quale l'azione CodePipeline dovrebbe fallire.
**HighThreshold **
Il numero di vulnerabilità di elevata gravità rilevate nella fonte oltre il quale l'azione CodePipeline dovrebbe fallire.
**MediumThreshold**
Il numero di vulnerabilità di gravità media rilevate nella fonte oltre il quale l'azione CodePipeline dovrebbe fallire.
**LowThreshold **
Il numero di vulnerabilità di bassa gravità rilevate nella fonte oltre il quale CodePipeline dovrebbe fallire l'azione.
![\[\]](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/inspectorscan-edit.png)
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1`
+ **Descrizione:** il codice sorgente per la scansione delle vulnerabilità. Se la scansione riguarda un repository ECR, questo elemento di input non è necessario.
## Artefatti di output
+ **Numero di artefatti:** `1`
+ **Descrizione:** informazioni sulla vulnerabilità dell'origine sotto forma di file SBOM (Software Bill of Materials).
## Variabili di output
Quando è configurata, questa azione produce variabili che possono essere referenziate dalla configurazione dell'azione di un'azione downstream nella pipeline. Questa azione produce variabili che possono essere viste come variabili di output, anche se l'azione non ha uno spazio dei nomi. È possibile configurare un'azione con uno spazio dei nomi per rendere tali variabili disponibili per la configurazione delle azioni downstream.
Per ulteriori informazioni, consulta [Riferimento alle variabili](reference-variables.md).
**HighestScannedSeverity **
L'output della scansione con la massima severità. I valori validi sono `medium | high | critical`.
## Autorizzazioni per i ruoli di servizio: azione `InspectorScan`
Per il supporto `InspectorScan` all'azione, aggiungi quanto segue alla tua dichiarazione politica:
```
{
"Effect": "Allow",
"Action": "inspector-scan:ScanSbom",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ecr:GetDownloadUrlForLayer",
"ecr:BatchGetImage",
"ecr:BatchCheckLayerAvailability"
],
"Resource": "resource_ARN"
},
```
Inoltre, se non è già stato aggiunto all'azione Comandi, aggiungi le seguenti autorizzazioni al tuo ruolo di servizio per visualizzare i CloudWatch log.
```
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "resource_ARN"
},
```
**Nota**
Riduci le autorizzazioni a livello di risorsa della pipeline utilizzando le autorizzazioni basate sulle risorse nella dichiarazione sulla politica del ruolo di servizio.
## Dichiarazione dell'operazione
------
#### [ YAML ]
```
name: Scan
actionTypeId:
category: Invoke
owner: AWS
provider: InspectorScan
version: '1'
runOrder: 1
configuration:
InspectorRunMode: SourceCodeScan
outputArtifacts:
- name: output
inputArtifacts:
- name: SourceArtifact
region: us-east-1
```
------
#### [ JSON ]
```
{
"name": "Scan",
"actionTypeId": {
"category": "Invoke",
"owner": "AWS",
"provider": "InspectorScan",
"version": "1"
},
"runOrder": 1,
"configuration": {
"InspectorRunMode": "SourceCodeScan"
},
"outputArtifacts": [
{
"name": "output"
}
],
"inputArtifacts": [
{
"name": "SourceArtifact"
}
],
"region": "us-east-1"
},
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ Per ulteriori informazioni su Amazon Inspector, consulta la Amazon [Inspector User Guide](https://aws.amazon.com/inspector/).
# AWS Lambda richiama il riferimento all'azione
Consente di eseguire una funzione Lambda come azione nella pipeline. Utilizzando l'oggetto evento che è un input per questa funzione, la funzione ha accesso alla configurazione dell'operazione, alle posizioni degli artefatti di input, alle posizioni degli artefatti di output e ad altre informazioni necessarie per accedere agli artefatti. Per un esempio di evento passato a una funzione di invoke Lambda, vedere. [Evento JSON di esempio](#action-reference-Lambda-event) Come parte dell'implementazione della funzione Lambda, deve esserci una chiamata a `[PutJobSuccessResult API](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutJobSuccessResult.html)` o `[PutJobFailureResult API](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutJobFailureResult.html)`. In caso contrario, l'esecuzione di questa operazione si blocca fino a che l'operazione non scade. Se specifichi artefatti di output per l'operazione, questi devono essere caricati nel bucket S3 come parte dell'implementazione della funzione.
**Importante**
Non registrate l'evento JSON CodePipeline inviato a Lambda perché ciò può comportare la registrazione delle credenziali utente nei log. CloudWatch Il CodePipeline ruolo utilizza un evento JSON per passare credenziali temporanee a Lambda sul campo. `artifactCredentials` Per un evento di esempio, consultare [Evento JSON di esempio](actions-invoke-lambda-function.md#actions-invoke-lambda-function-json-event-example).
## Tipo di operazione
+ Categoria: `Invoke`
+ Proprietario: `AWS`
+ Provider: `Lambda`
+ Versione: `1`
## Parametri di configurazione
**FunctionName**
Obbligatorio: sì
`FunctionName`è il nome della funzione creata in Lambda.
**UserParameters**
Obbligatorio: no
Una stringa che può essere elaborata come input dalla funzione Lambda.
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `0 to 5`
+ **Descrizione:** il set di artefatti da rendere disponibili per la funzione Lambda.
## Artefatti di output
+ **Numero di artefatti:** `0 to 5`
+ **Descrizione:** l'insieme di artefatti prodotti come output dalla funzione Lambda.
## Variabili di output
[Questa azione produrrà come variabili tutte le coppie chiave-valore incluse nella `outputVariables` sezione della richiesta API. PutJobSuccessResult ](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutJobSuccessResult.html)
Per ulteriori informazioni sulle variabili in CodePipeline, vedere. [Riferimento alle variabili](reference-variables.md)
## Esempio di configurazione dell'operazione
------
#### [ YAML ]
```
Name: Lambda
Actions:
- Name: Lambda
ActionTypeId:
Category: Invoke
Owner: AWS
Provider: Lambda
Version: '1'
RunOrder: 1
Configuration:
FunctionName: myLambdaFunction
UserParameters: 'http://192.0.2.4'
OutputArtifacts: []
InputArtifacts: []
Region: us-west-2
```
------
#### [ JSON ]
```
{
"Name": "Lambda",
"Actions": [
{
"Name": "Lambda",
"ActionTypeId": {
"Category": "Invoke",
"Owner": "AWS",
"Provider": "Lambda",
"Version": "1"
},
"RunOrder": 1,
"Configuration": {
"FunctionName": "myLambdaFunction",
"UserParameters": "http://192.0.2.4"
},
"OutputArtifacts": [],
"InputArtifacts": [],
"Region": "us-west-2"
}
]
},
```
------
## Evento JSON di esempio
L'azione Lambda invia un evento JSON che contiene l'ID del lavoro, la configurazione dell'azione della pipeline, le posizioni degli artefatti di input e output e qualsiasi informazione di crittografia per gli artefatti. Il job worker accede a questi dettagli per completare l'azione Lambda. Per ulteriori informazioni, consulta [Dettagli del processo](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_JobDetails.html). Di seguito è riportato un esempio di evento.
```
{
"CodePipeline.job": {
"id": "11111111-abcd-1111-abcd-111111abcdef",
"accountId": "111111111111",
"data": {
"actionConfiguration": {
"configuration": {
"FunctionName": "MyLambdaFunction",
"UserParameters": "input_parameter"
}
},
"inputArtifacts": [
{
"location": {
"s3Location": {
"bucketName": "bucket_name",
"objectKey": "filename"
},
"type": "S3"
},
"revision": null,
"name": "ArtifactName"
}
],
"outputArtifacts": [],
"artifactCredentials": {
"secretAccessKey": "secret_key",
"sessionToken": "session_token",
"accessKeyId": "access_key_ID"
},
"continuationToken": "token_ID",
"encryptionKey": {
"id": "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
"type": "KMS"
}
}
}
}
```
L'evento JSON fornisce i seguenti dettagli del lavoro per l'azione Lambda in: CodePipeline
+ `id`: l'ID univoco generato dal sistema del processo.
+ `accountId`: l'ID AWS dell'account associato al job.
+ `data`: altre informazioni richieste da un esecutore del processo per completare il processo.
+ `actionConfiguration`: i parametri di operazione per l'operazione Lambda. Per le definizioni, consulta [Parametri di configurazione](#action-reference-Lambda-config).
+ `inputArtifacts`: l'artefatto fornito all'operazione.
+ `location`: la posizione dello store degli artefatti.
+ `s3Location`: le informazioni sulla posizione dell'artefatto di input per l'operazione.
+ `bucketName`: il nome dell'archivio di artefatti della pipeline per l'azione (ad esempio, un bucket Amazon S3 denominato -2-1234567890). codepipeline-us-east
+ `objectKey`: il nome dell'applicazione (ad esempio, `CodePipelineDemoApplication.zip`).
+ `type`: il tipo di artefatto nella posizione. Al momento, `S3` è l'unico tipo di artefatto valido.
+ `revision`: l'ID revisione dell'artefatto. A seconda del tipo di oggetto, può essere un ID di commit (GitHub) o un ID di revisione (Amazon Simple Storage Service). Per ulteriori informazioni, consulta [ArtifactRevision](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ArtifactRevision.html).
+ `name`: il nome dell'artefatto da utilizzare, ad esempio `MyApp`.
+ `outputArtifacts`: l'output dell'operazione.
+ `location`: la posizione dello store degli artefatti.
+ `s3Location`: le informazioni sulla posizione dell'artefatto di output per l'operazione.
+ `bucketName`: il nome dell'archivio di artefatti della pipeline per l'azione (ad esempio, un bucket Amazon S3 denominato -2-1234567890). codepipeline-us-east
+ `objectKey`: il nome dell'applicazione (ad esempio, `CodePipelineDemoApplication.zip`).
+ `type`: il tipo di artefatto nella posizione. Al momento, `S3` è l'unico tipo di artefatto valido.
+ `revision`: l'ID revisione dell'artefatto. A seconda del tipo di oggetto, può essere un ID di commit (GitHub) o un ID di revisione (Amazon Simple Storage Service). Per ulteriori informazioni, consulta [ArtifactRevision](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ArtifactRevision.html).
+ `name`: il nome dell'output di un artefatto, ad esempio `MyApp`.
+ `artifactCredentials`: le credenziali di AWS sessione utilizzate per accedere agli artefatti di input e output nel bucket Amazon S3. Queste credenziali sono credenziali temporanee emesse da AWS Security Token Service (AWS STS).
+ `secretAccessKey`: la chiave di accesso segreta per la sessione.
+ `sessionToken`: il token per la sessione.
+ `accessKeyId`: la chiave di accesso segreta per la sessione.
+ `continuationToken`: un token generato dall'operazione. Le operazioni future utilizzano questo token per identificare l'istanza in esecuzione dell'operazione. Al termine dell'operazione, non è necessario fornire alcun token di continuazione.
+ `encryptionKey`: La chiave di crittografia utilizzata per crittografare i dati nell'archivio degli artefatti, ad esempio una chiave. AWS KMS Se non è definito, viene utilizzata la chiave predefinita per Amazon Simple Storage Service.
+ `id`: l'ID utilizzato per identificare la chiave. Per una chiave AWS KMS , puoi utilizzare l'ID della chiave, l'ARN della chiave o l'ARN dell'alias.
+ `type`: il tipo di chiave di crittografia, ad esempio una chiave AWS KMS .
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [AWS CloudFormation Guida per l'utente](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/)[: per ulteriori informazioni sulle azioni e gli CloudFormation artefatti Lambda per le pipeline, vedere [Utilizzo delle funzioni di sostituzione dei parametri con CodePipeline le pipeline, [Automazione](https://docs.aws.amazon.com/lambda/latest/dg/automating-deployment.html) della distribuzione](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-parameter-override-functions.html) di applicazioni basate su Lambda e Artifacts.AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-cfn-artifacts.html)
+ [Invoca una AWS Lambda funzione in una pipeline in CodePipeline](actions-invoke-lambda-function.md)— Questa procedura fornisce una funzione Lambda di esempio e mostra come utilizzare la console per creare una pipeline con un'azione di richiamo Lambda.
# AWS OpsWorks distribuire un riferimento all'azione
Si utilizza un' AWS OpsWorks azione per la distribuzione OpsWorks utilizzando la pipeline.
## Tipo di operazione
+ Categoria: `Deploy`
+ Proprietario: `AWS`
+ Provider: `OpsWorks`
+ Versione: `1`
## Parametri di configurazione
**App**
Obbligatorio: sì
La OpsWorks pila. Uno stack è un contenitore per l'infrastruttura applicativa.
**Pila**
Obbligatorio: sì
L' OpsWorks app. L'app rappresenta il codice che desideri distribuire ed eseguire.
**Livello**
Obbligatorio: no
La OpsWorks pila. Un livello specifica la configurazione e le risorse per un set di istanze.
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1`
+ **Descrizione:** questo è l'artefatto di input per la tua azione.
## Artefatti di output
+ **Numero di artefatti:** `0 to 1`
+ **Descrizione:** gli artefatti di output non si applicano a questo tipo di azione.
## Autorizzazioni per i ruoli di servizio: azione AWS OpsWorks
Per AWS OpsWorks ricevere assistenza, aggiungi quanto segue alla tua dichiarazione sulla politica:
```
{
"Effect": "Allow",
"Action": [
"opsworks:CreateDeployment",
"opsworks:DescribeApps",
"opsworks:DescribeCommands",
"opsworks:DescribeDeployments",
"opsworks:DescribeInstances",
"opsworks:DescribeStacks",
"opsworks:UpdateApp",
"opsworks:UpdateStack"
],
"Resource": "resource_ARN"
},
```
## Esempio di configurazione dell'operazione
------
#### [ YAML ]
```
Name: ActionName
ActionTypeId:
Category: Deploy
Owner: AWS
Version: 1
Provider: OpsWorks
InputArtifacts:
- Name: myInputArtifact
Configuration:
Stack: my-stack
App: my-app
```
------
#### [ JSON ]
```
{
"Name": "ActionName",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Version": 1,
"Provider": "OpsWorks"
},
"InputArtifacts": [
{
"Name": "myInputArtifact"
}
],
"Configuration": {
"Stack": "my-stack",
"App": "my-app"
}
}
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [AWS OpsWorks Guida per l'utente](https://docs.aws.amazon.com/step-functions/latest/dg/): per informazioni sulla distribuzione con AWS OpsWorks, consulta la *Guida per l'AWS OpsWorks utente*.
# AWS Service Catalog distribuire un riferimento all'azione
Si utilizza un' AWS Service Catalog azione per distribuire i modelli utilizzando la pipeline. Si tratta di modelli di risorse creati in Service Catalog.
## Tipo di operazione
+ Categoria: `Deploy`
+ Proprietario: `AWS`
+ Provider: `ServiceCatalog`
+ Versione: `1`
## Parametri di configurazione
**TemplateFilePath**
Obbligatorio: sì
Il percorso del file per il modello di risorsa nella posizione di origine.
**ProductVersionName**
Obbligatorio: sì
La versione del prodotto in Service Catalog.
**ProductType**
Obbligatorio: sì
Il tipo di prodotto in Service Catalog.
**ProductId**
Obbligatorio: sì
L'ID del prodotto in Service Catalog.
**ProductVersionDescription**
Obbligatorio: no
La descrizione della versione del prodotto in Service Catalog.
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `1`
+ **Descrizione:** questo è l'artefatto di input per la tua azione.
## Artefatti di output
+ **Numero di artefatti:** `0`
+ **Descrizione:** gli artefatti di output non si applicano a questo tipo di azione.
## Autorizzazioni del ruolo di servizio: azione Service Catalog
Per il supporto di Service Catalog, aggiungi quanto segue alla tua informativa sulla politica:
```
{
"Effect": "Allow",
"Action": [
"servicecatalog:ListProvisioningArtifacts",
"servicecatalog:CreateProvisioningArtifact",
"servicecatalog:DescribeProvisioningArtifact",
"servicecatalog:DeleteProvisioningArtifact",
"servicecatalog:UpdateProduct"
],
"Resource": "resource_ARN"
},
{
"Effect": "Allow",
"Action": [
"cloudformation:ValidateTemplate"
],
"Resource": "resource_ARN"
}
```
## Esempi di configurazioni di azioni per tipo di file di configurazione
L'esempio seguente mostra una configurazione valida per un'azione di distribuzione che utilizza Service Catalog, per una pipeline creata nella console senza un file di configurazione separato:
```
"configuration": {
"TemplateFilePath": "S3_template.json",
"ProductVersionName": "devops S3 v2",
"ProductType": "CLOUD_FORMATION_TEMPLATE",
"ProductVersionDescription": "Product version description",
"ProductId": "prod-example123456"
}
```
L'esempio seguente mostra una configurazione valida per un'azione di distribuzione che utilizza Service Catalog, per una pipeline creata nella console con un file di `sample_config.json` configurazione separato:
```
"configuration": {
"ConfigurationFilePath": "sample_config.json",
"ProductId": "prod-example123456"
}
```
### Esempio di configurazione dell'operazione
------
#### [ YAML ]
```
Name: ActionName
ActionTypeId:
Category: Deploy
Owner: AWS
Version: 1
Provider: ServiceCatalog
OutputArtifacts:
- Name: myOutputArtifact
Configuration:
TemplateFilePath: S3_template.json
ProductVersionName: devops S3 v2
ProductType: CLOUD_FORMATION_TEMPLATE
ProductVersionDescription: Product version description
ProductId: prod-example123456
```
------
#### [ JSON ]
```
{
"Name": "ActionName",
"ActionTypeId": {
"Category": "Deploy",
"Owner": "AWS",
"Version": 1,
"Provider": "ServiceCatalog"
},
"OutputArtifacts": [
{
"Name": "myOutputArtifact"
}
],
"Configuration": {
"TemplateFilePath": "S3_template.json",
"ProductVersionName": "devops S3 v2",
"ProductType": "CLOUD_FORMATION_TEMPLATE",
"ProductVersionDescription": "Product version description",
"ProductId": "prod-example123456"
}
}
```
------
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [Guida per l'utente del Service Catalog](https://docs.aws.amazon.com/servicecatalog/latest/userguide/): per informazioni sulle risorse e sui modelli in Service Catalog, consulta la *Service Catalog User Guide*.
+ [Tutorial: crea una pipeline da distribuire su Service Catalog](tutorials-S3-servicecatalog.md)— Questo tutorial mostra come creare e configurare una pipeline per distribuire il modello di prodotto in Service Catalog e fornire le modifiche apportate nel repository di origine.
# AWS Step Functions richiama il riferimento all'azione
Un' AWS CodePipeline azione che esegue le seguenti operazioni:
+ Avvia l'esecuzione di una macchina a AWS Step Functions stati dalla pipeline.
+ Fornisce uno stato iniziale alla macchina a stati tramite una proprietà nella configurazione dell'operazione o un file contenuto in un artefatto della pipeline da passare come input.
+ Facoltativamente, imposta un prefisso dell'ID di esecuzione per identificare le esecuzioni che provengono dall'operazione.
+ Supporta macchine a stati [Standard ed Express](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-standard-vs-express.html) .
**Nota**
L'azione Step Functions viene eseguita su Lambda e pertanto ha quote di dimensione degli artefatti uguali alle quote di dimensione degli artefatti per le funzioni Lambda. Per ulteriori informazioni, consulta le [quote Lambda nella Lambda Developer](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html) Guide.
## Tipo di operazione
+ Categoria: `Invoke`
+ Proprietario: `AWS`
+ Provider: `StepFunctions`
+ Versione: `1`
## Parametri di configurazione
**StateMachineArn**
Obbligatorio: sì
L’ Amazon Resource Name (ARN) per la macchina a stati da richiamare.
**ExecutionNamePrefix**
Obbligatorio: no
Per impostazione predefinita, l'ID di esecuzione dell'operazione viene utilizzato come nome di esecuzione della macchina a stati. Se viene fornito un prefisso, viene anteposto all'ID di esecuzione dell'operazione con un trattino e utilizzato insieme come nome di esecuzione della macchina a stati.
```
myPrefix-1624a1d1-3699-43f0-8e1e-6bafd7fde791
```
Per una macchina a stati di tipo Express, il nome deve contenere solo caratteri 0-9, A-Z, a-z, - e \$1.
**InputType**
Obbligatorio: no
+ **Literal (Letterale)** (impostazione predefinita): se specificato, il valore nel campo **Input** viene passato direttamente all'input della macchina a stati.
Esempio di voce per il campo **Input** quando è selezionato **Literal (Letterale)** :
```
{"action": "test"}
```
+ **FilePath**: Il contenuto di un file nell'elemento di input specificato dal campo **Input viene utilizzato come input** per l'esecuzione della macchina a stati. Un artefatto di input è richiesto quando **InputType**è impostato su. **FilePath**
Esempio di immissione per il campo **Input** quando **FilePath**è selezionato:
```
assets/input.json
```
**Input**
Obbligatorio: condizionale
+ **Letterale**: quando **InputType**è impostato su **Literal** (impostazione predefinita), questo campo è facoltativo.
Se fornito, il campo **Input** viene utilizzato direttamente come input per l'esecuzione della macchina a stati. In caso contrario, la macchina a stati viene richiamata con un oggetto JSON vuoto `{}`.
+ **FilePath**: Quando **InputType**è impostato su **FilePath**, questo campo è obbligatorio.
Un artefatto di input è richiesto anche quando **InputType**è impostato su. **FilePath**
Il contenuto del file nell'artefatto di input specificato viene utilizzato come input per l'esecuzione della macchina a stati.
## Input artifact (Artefatti di input)
+ **Numero di artefatti:** `0 to 1`
+ **Descrizione:** se **InputType**impostato su **FilePath**, questo artefatto è obbligatorio e viene utilizzato per generare l'input per l'esecuzione della macchina a stati.
## Artefatti di output
+ **Numero di artefatti:** `0 to 1`
+ **Descrizione:**
+ **Macchine a stati Standard**: se fornito, l'artefatto di output viene popolato con l'output della macchina a stati. Questo viene ottenuto dalla `output` proprietà della risposta dell'[ DescribeExecution API Step Functions](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeExecution.html) dopo che l'esecuzione della macchina a stati è stata completata correttamente.
+ **Macchine a stati Express**: non supportate.
## Variabili di output
Questa operazione produce variabili di output che possono essere referenziate mediante configurazione dell'operazione di un'operazione a valle nella pipeline.
Per ulteriori informazioni, consulta [Riferimento alle variabili](reference-variables.md).
**StateMachineArn**
ARN della macchina a stati.
**ExecutionArn**
L'ARN di esecuzione della macchina a stati. Solo macchine a stati Standard.
## Autorizzazioni per i ruoli di servizio: azione `StepFunctions`
Per l'`StepFunctions`azione, le seguenti sono le autorizzazioni minime necessarie per creare pipeline con un'azione di invoca Step Functions.
```
{
"Effect": "Allow",
"Action": [
"states:DescribeStateMachine",
"states:DescribeExecution",
"states:StartExecution"
],
"Resource": "resource_ARN"
},
```
## Esempio di configurazione dell'operazione
### Esempio di input predefinito
------
#### [ YAML ]
```
Name: ActionName
ActionTypeId:
Category: Invoke
Owner: AWS
Version: 1
Provider: StepFunctions
OutputArtifacts:
- Name: myOutputArtifact
Configuration:
StateMachineArn: arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine
ExecutionNamePrefix: my-prefix
```
------
#### [ JSON ]
```
{
"Name": "ActionName",
"ActionTypeId": {
"Category": "Invoke",
"Owner": "AWS",
"Version": 1,
"Provider": "StepFunctions"
},
"OutputArtifacts": [
{
"Name": "myOutputArtifact"
}
],
"Configuration": {
"StateMachineArn": "arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine",
"ExecutionNamePrefix": "my-prefix"
}
}
```
------
### Esempio di input letterale
------
#### [ YAML ]
```
Name: ActionName
ActionTypeId:
Category: Invoke
Owner: AWS
Version: 1
Provider: StepFunctions
OutputArtifacts:
- Name: myOutputArtifact
Configuration:
StateMachineArn: arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine
ExecutionNamePrefix: my-prefix
Input: '{"action": "test"}'
```
------
#### [ JSON ]
```
{
"Name": "ActionName",
"ActionTypeId": {
"Category": "Invoke",
"Owner": "AWS",
"Version": 1,
"Provider": "StepFunctions"
},
"OutputArtifacts": [
{
"Name": "myOutputArtifact"
}
],
"Configuration": {
"StateMachineArn": "arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine",
"ExecutionNamePrefix": "my-prefix",
"Input": "{\"action\": \"test\"}"
}
}
```
------
### Esempio di file di input
------
#### [ YAML ]
```
Name: ActionName
InputArtifacts:
- Name: myInputArtifact
ActionTypeId:
Category: Invoke
Owner: AWS
Version: 1
Provider: StepFunctions
OutputArtifacts:
- Name: myOutputArtifact
Configuration:
StateMachineArn: 'arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine'
ExecutionNamePrefix: my-prefix
InputType: FilePath
Input: assets/input.json
```
------
#### [ JSON ]
```
{
"Name": "ActionName",
"InputArtifacts": [
{
"Name": "myInputArtifact"
}
],
"ActionTypeId": {
"Category": "Invoke",
"Owner": "AWS",
"Version": 1,
"Provider": "StepFunctions"
},
"OutputArtifacts": [
{
"Name": "myOutputArtifact"
}
],
"Configuration": {
"StateMachineArn": "arn:aws:states:us-east-1:111122223333:stateMachine:HelloWorld-StateMachine",
"ExecutionNamePrefix": "my-prefix",
"InputType": "FilePath",
"Input": "assets/input.json"
}
}
```
------
## Comportamento
Durante una versione, CodePipeline esegue la macchina a stati configurata utilizzando l'input specificato nella configurazione dell'azione.
Quando **InputType**è impostato su **Literal**, il contenuto del campo di configurazione dell'azione di **input** viene utilizzato come input per la macchina a stati. Quando l'input letterale non viene fornito, l'esecuzione della macchina a stati utilizza un oggetto JSON vuoto `{}`. Per ulteriori informazioni sull'esecuzione di un'esecuzione di una macchina a stati senza input, consulta l'[ StartExecutionAPI Step Functions](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html).
Quando **InputType**è impostata su **FilePath**, l'azione decomprime l'elemento di input e utilizza il contenuto del file specificato nel campo di configurazione dell'azione di **input** come input per la macchina a stati. Quando **FilePath**viene specificato, il campo **di input** è obbligatorio e deve esistere un elemento di input; in caso contrario, l'azione fallisce.
Dopo l'esecuzione di un avvio riuscito, il comportamento divergerà per i due tipi di macchina a stati, *Standard* ed *Express*.
### Macchine a stati Standard
Se l'esecuzione della macchina a stati standard è stata avviata correttamente, esegue il CodePipeline polling dell'`DescribeExecution`API finché l'esecuzione non raggiunge lo stato di terminale. Se l'esecuzione viene completata correttamente, l'operazione ha esito positivo; in caso contrario, ha esito negativo.
Se è configurato un artefatto di output, l'artefatto conterrà il valore restituito dalla macchina a stati. Questo viene ottenuto dalla `output` proprietà della risposta dell'[ DescribeExecution API Step Functions](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeExecution.html) dopo che l'esecuzione della macchina a stati è stata completata correttamente. Si noti che vi sono dei vincoli di lunghezza di output applicati a questa API.
#### Gestione degli errori
+ Se l'operazione non riesce ad avviare un'esecuzione di una macchina a stati, l'esecuzione dell'operazione ha esito negativo.
+ Se l'esecuzione della macchina a stati non riesce a raggiungere lo stato di terminale prima che l'azione CodePipeline Step Functions raggiunga il suo timeout (impostazione predefinita di 7 giorni), l'esecuzione dell'azione fallisce. La macchina a stati potrebbe continuare nonostante questo errore. Per ulteriori informazioni sui timeout di esecuzione delle macchine a stati in Step Functions, consulta Flussi di lavoro [Standard e Express.](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-standard-vs-express.html)
**Nota**
È possibile richiedere un aumento della quota per il timeout dell'azione di richiamo per l'account con l'operazione. Tuttavia, l'aumento delle quote si applica a tutte le operazioni di questo tipo in tutte le regioni per tale account.
+ Se l'esecuzione della macchina a stati raggiunge uno stato terminale di FAILED, TIMED\$1OUT o ABORTED, l'esecuzione dell'operazione ha esito negativo.
### Macchine a stati Express
Se l'esecuzione della macchina a stati Express è stata avviata correttamente, l'esecuzione dell'operazione di richiamo viene completata correttamente.
Considerazioni relative alle operazioni configurate per le macchine a stati Express:
+ Non è possibile designare un artefatto di output.
+ L'operazione non attende il completamento dell'esecuzione della macchina a stati.
+ Dopo l'avvio dell'esecuzione dell'azione CodePipeline, l'esecuzione dell'azione riesce anche se l'esecuzione della macchina a stati fallisce.
#### Gestione degli errori
+ Se CodePipeline non riesce ad avviare l'esecuzione di una macchina a stati, l'esecuzione dell'azione fallisce. Altrimenti, l'operazione viene eseguita immediatamente con esito positivo. L'azione riesce CodePipeline indipendentemente dal tempo impiegato dall'esecuzione della macchina a stati per essere completata o dal relativo risultato.
## Consulta anche
Le risorse correlate seguenti possono essere utili durante l'utilizzo di questa operazione.
+ [AWS Step Functions Guida per gli sviluppatori](https://docs.aws.amazon.com/step-functions/latest/dg/)*: per informazioni sulle macchine a stati, le esecuzioni e gli input per le macchine a stati, consulta la Guida per gli AWS Step Functions sviluppatori.*
+ [Tutorial: utilizzare un'azione di AWS Step Functions richiamo in una pipeline](tutorials-step-functions.md)— Questo tutorial ti consente di iniziare con una macchina a stati standard di esempio e mostra come utilizzare la console per aggiornare una pipeline aggiungendo un'azione di invoca Step Functions.