

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Utilizzo delle revisioni delle applicazioni per CodeDeploy
<a name="application-revisions"></a>

In CodeDeploy, una revisione contiene una versione dei file sorgente che CodeDeploy verrà distribuita nelle tue istanze o gli script verranno eseguiti sulle tue istanze. CodeDeploy 

Pianifica la revisione, aggiungi un AppSpec file alla revisione e quindi invia la revisione ad Amazon S3 o. GitHub Dopo aver inviato la revisione, è possibile distribuirla.

**Topics**
+ [Pianifica una revisione](application-revisions-plan.md)
+ [Aggiungere un file AppSpec](application-revisions-appspec-file.md)
+ [Scegli un tipo di repository](application-revisions-repository-type.md)
+ [Invia una revisione](application-revisions-push.md)
+ [Visualizza i dettagli della revisione dell'applicazione](application-revisions-view-details.md)
+ [Registra una revisione dell'applicazione](application-revisions-register.md)

# Pianifica una revisione per CodeDeploy
<a name="application-revisions-plan"></a>

Una buona pianificazione semplifica molto la distribuzione di revisioni.

Per le distribuzioni su una piattaforma di calcolo AWS Lambda o Amazon ECS, una revisione è la stessa del file. AppSpec Le seguenti informazioni non si applicano. Per ulteriori informazioni, consulta [Aggiungere un file di specifiche dell'applicazione a una revisione per CodeDeploy](application-revisions-appspec-file.md) 

Per le distribuzioni su una piattaforma di calcolo EC2 /On-Premises, inizia creando una directory principale (cartella) vuota sulla macchina di sviluppo. Questa è la cartella in cui memorizzare i file di origine (ad esempio testo e file binari, eseguibili, pacchetti e così via) per essere distribuiti alle istanze o gli script da eseguire sulle istanze.

Ad esempio, nella cartella `/tmp/` principale di Linux, macOS o Unix o nella cartella `c:\temp` principale di Windows:

```
/tmp/ or c:\temp (root folder)
  |--content (subfolder)
  |    |--myTextFile.txt
  |    |--mySourceFile.rb
  |    |--myExecutableFile.exe
  |    |--myInstallerFile.msi
  |    |--myPackage.rpm
  |    |--myImageFile.png
  |--scripts (subfolder)
  |    |--myShellScript.sh
  |    |--myBatchScript.bat 
  |    |--myPowerShellScript.ps1 
  |--appspec.yml
```

La cartella principale deve includere anche un file con le specifiche dell'applicazione (AppSpec file), come illustrato di seguito. Per ulteriori informazioni, consulta [Aggiungere un file di specifiche dell'applicazione a una revisione per CodeDeploy](application-revisions-appspec-file.md).

# Aggiungere un file di specifiche dell'applicazione a una revisione per CodeDeploy
<a name="application-revisions-appspec-file"></a>

Questo argomento mostra come aggiungere un AppSpec file alla distribuzione. Include anche modelli per creare un AppSpec file per una distribuzione AWS Lambda ed EC2/on-premise.

**Topics**
+ [Aggiungi un AppSpec file per una distribuzione Amazon ECS](#add-appspec-file-ecs)
+ [Aggiungere un AppSpec file per una distribuzione AWS Lambda](#add-appspec-file-lambda)
+ [Aggiungi un AppSpec file per una distribuzione EC2/on-premise](#add-appspec-file-server)

## Aggiungi un AppSpec file per una distribuzione Amazon ECS
<a name="add-appspec-file-ecs"></a>

Per una distribuzione su una piattaforma di calcolo Amazon ECS:
+ Il AppSpec file specifica la definizione del task di Amazon ECS utilizzata per la distribuzione, una mappatura del nome del contenitore e delle porte utilizzata per instradare il traffico e le funzioni Lambda opzionali eseguite dopo gli eventi del ciclo di vita della distribuzione.
+ Una revisione è uguale a un file. AppSpec 
+ Un AppSpec file può essere scritto usando JSON o YAML.
+ Un AppSpec file può essere salvato come file di testo o inserito direttamente in una console quando si crea una distribuzione. Per ulteriori informazioni, consulta [Crea un'implementazione di Amazon ECS Compute Platform (console)](deployments-create-console-ecs.md).

**Per creare un AppSpec file**

1. Copia il modello JSON o YAML in un editor di testo o nell' AppSpec editor della console.

1. Modifica il modello in base alle esigenze.

1. Usa un validatore JSON o YAML per convalidare il file. AppSpec **Se utilizzi l' AppSpeceditor, il file viene convalidato quando scegli Crea distribuzione.**

1. Se si utilizza un editor di testo, salvare il file. Se utilizzi il AWS CLI per creare la tua distribuzione, fai riferimento al AppSpec file se si trova sul tuo disco rigido o in un bucket Amazon S3. Se usi la console, devi inviare il AppSpec file ad Amazon S3.

### Modello di AppSpec file YAML per una distribuzione Amazon ECS con istruzioni
<a name="app-spec-template-yaml-ecs"></a>

Di seguito è riportato un modello YAML di un AppSpec file per una distribuzione Amazon ECS con tutte le opzioni disponibili. Per informazioni sugli eventi del ciclo di vita da utilizzare nella sezione `hooks`, consulta [AppSpec sezione 'hook' per una distribuzione Amazon ECS](reference-appspec-file-structure-hooks.md#appspec-hooks-ecs).

```
# This is an appspec.yml template file for use with an Amazon ECS deployment in CodeDeploy.
# The lines in this template that start with the hashtag are 
#   comments that can be safely left in the file or 
#   ignored.
# For help completing this file, see the "AppSpec File Reference" in the  
#   "CodeDeploy User Guide" at
#   https://docs.aws.amazon.com/codedeploy/latest/userguide/app-spec-ref.html
version: 0.0
# In the Resources section, you must specify the following: the Amazon ECS service, task definition name, 
# and the name and port of the load balancer to route traffic,
# target version, and (optional) the current version of your AWS Lambda function. 
Resources:
  - TargetService:
      Type: AWS::ECS::Service
      Properties:
        TaskDefinition: "" # Specify the ARN of your task definition (arn:aws:ecs:region:account-id:task-definition/task-definition-family-name:task-definition-revision-number)
        LoadBalancerInfo: 
          ContainerName: "" # Specify the name of your Amazon ECS application's container
          ContainerPort: "" # Specify the port for your container where traffic reroutes 
# Optional properties
        PlatformVersion: "" # Specify the version of your Amazon ECS Service
        NetworkConfiguration:
          AwsvpcConfiguration:
            Subnets: ["",""] # Specify one or more comma-separated subnets in your Amazon ECS service
            SecurityGroups: ["",""] # Specify one or more comma-separated security groups in your Amazon ECS service
            AssignPublicIp: "" # Specify "ENABLED" or "DISABLED"             
# (Optional) In the Hooks section, specify a validation Lambda function to run during 
# a lifecycle event. 
Hooks:
# Hooks for Amazon ECS deployments are:
    - BeforeInstall: "" # Specify a Lambda function name or ARN
    - AfterInstall: "" # Specify a Lambda function name or ARN
    - AfterAllowTestTraffic: "" # Specify a Lambda function name or ARN
    - BeforeAllowTraffic: "" # Specify a Lambda function name or ARN
    - AfterAllowTraffic: "" # Specify a Lambda function name or ARN
```

### AppSpec File JSON per un modello di distribuzione Amazon ECS
<a name="app-spec-template-json-ecs"></a>

Di seguito è riportato un modello JSON per un AppSpec file per una distribuzione Amazon ECS con tutte le opzioni disponibili. Per le istruzioni relative al modello, consulta i commenti nella versione YAML nella sezione precedente. Per informazioni sugli eventi del ciclo di vita da utilizzare nella sezione `hooks`, consulta [AppSpec sezione 'hook' per una distribuzione Amazon ECS](reference-appspec-file-structure-hooks.md#appspec-hooks-ecs).

```
{
	"version": 0.0,
	"Resources": [
		{
			"TargetService": {
				"Type": "AWS::ECS::Service",
				"Properties": {
    			"TaskDefinition": "",
    			"LoadBalancerInfo": {
    				"ContainerName": "",
    				"ContainerPort":
    			},
    			"PlatformVersion": "",
    			"NetworkConfiguration": {
    				"AwsvpcConfiguration": {
    					"Subnets": [
    						"",
    						""
    					],
    					"SecurityGroups": [
    						"",
    						""
    					],
    					"AssignPublicIp": ""
    				}
    			}
  			}				
			}
		}
	],
	"Hooks": [
		{
			"BeforeInstall": ""
		},
		{
			"AfterInstall": ""
		},
		{
			"AfterAllowTestTraffic": ""
		},
		{
			"BeforeAllowTraffic": ""
		},
		{
			"AfterAllowTraffic": ""
		}
	]
}
```

## Aggiungere un AppSpec file per una distribuzione AWS Lambda
<a name="add-appspec-file-lambda"></a>

Per una distribuzione su una piattaforma di elaborazione AWS Lambda:
+ Il AppSpec file contiene istruzioni sulle funzioni Lambda da distribuire e utilizzare per la convalida della distribuzione.
+ Una revisione è uguale a un file. AppSpec 
+ Un AppSpec file può essere scritto usando JSON o YAML.
+ Un AppSpec file può essere salvato come file di testo o inserito direttamente in un AppSpec editor di console durante la creazione di una distribuzione. Per ulteriori informazioni, consulta [Creare un'implementazione della AWS Lambda Compute Platform (console)](deployments-create-console-lambda.md).

Per creare un AppSpec file:

1. Copia il modello JSON o YAML in un editor di testo o nell' AppSpec editor della console.

1. Modifica il modello in base alle esigenze.

1. Usa un validatore JSON o YAML per convalidare il file. AppSpec **Se utilizzi l' AppSpeceditor, il file viene convalidato quando scegli Crea distribuzione.**

1. Se si utilizza un editor di testo, salvare il file. Se utilizzi il AWS CLI per creare la tua distribuzione, fai riferimento al AppSpec file se si trova sul tuo disco rigido o in un bucket Amazon S3. Se usi la console, devi inviare il AppSpec file ad Amazon S3.



### Modello di AppSpec file YAML per una distribuzione con istruzioni AWS Lambda
<a name="app-spec-template-yaml-lambda"></a>

Per informazioni sugli eventi del ciclo di vita da utilizzare nella sezione Hooks, consulta [AppSpec sezione 'hooks' per una distribuzione AWS Lambda](reference-appspec-file-structure-hooks.md#appspec-hooks-lambda).

```
# This is an appspec.yml template file for use with an AWS Lambda deployment in CodeDeploy.
# The lines in this template starting with the hashtag symbol are 
#   instructional comments and can be safely left in the file or 
#   ignored.
# For help completing this file, see the "AppSpec File Reference" in the  
#   "CodeDeploy User Guide" at
#   https://docs.aws.amazon.com/codedeploy/latest/userguide/app-spec-ref.html
version: 0.0
# In the Resources section specify the name, alias, 
# target version, and (optional) the current version of your AWS Lambda function. 
Resources:
  - MyFunction: # Replace "MyFunction" with the name of your Lambda function 
      Type: AWS::Lambda::Function
      Properties:
        Name: "" # Specify the name of your Lambda function
        Alias: "" # Specify the alias for your Lambda function
        CurrentVersion: "" # Specify the current version of your Lambda function
        TargetVersion: "" # Specify the version of your Lambda function to deploy
# (Optional) In the Hooks section, specify a validation Lambda function to run during 
# a lifecycle event. Replace "LifeCycleEvent" with BeforeAllowTraffic
# or AfterAllowTraffic. 
Hooks:
    - LifeCycleEvent: "" # Specify a Lambda validation function between double-quotes.
```

### AppSpec File JSON per un modello di distribuzione AWS Lambda
<a name="app-spec-template-json-lambda"></a>

Nel modello seguente, sostituisci "MyFunction" con il nome della tua AWS Lambda funzione. Nella sezione Hooks opzionale, sostituisci gli eventi del ciclo di vita con o. BeforeAllowTraffic AfterAllowTraffic

Per informazioni sugli eventi del ciclo di vita da utilizzare nella sezione Hooks, consulta [AppSpec sezione 'hooks' per una distribuzione AWS Lambda](reference-appspec-file-structure-hooks.md#appspec-hooks-lambda).

```
{
 	"version": 0.0,
 	"Resources": [{
 		"MyFunction": {
 			"Type": "AWS::Lambda::Function",
 			"Properties": {
 				"Name": "",
 				"Alias": "",
 				"CurrentVersion": "",
 				"TargetVersion": ""
 			}
 		}
 	}],
 	"Hooks": [{
 			"LifeCycleEvent": ""
 		}
 	]
 }
```

## Aggiungi un AppSpec file per una distribuzione EC2/on-premise
<a name="add-appspec-file-server"></a>

Senza un AppSpec file, CodeDeploy non è possibile mappare i file di origine nella revisione dell'applicazione alle relative destinazioni o eseguire script per la distribuzione su una piattaforma di elaborazione EC2/on-premise,.

Ogni revisione deve contenere un solo file. AppSpec 

Per aggiungere un AppSpec file a una revisione:

1. Copiare il modello in un editor di testo.

1. Modifica il modello in base alle esigenze.

1. Usa un validatore YAML per verificare la validità del tuo file. AppSpec 

1. Salvare il file come `appspec.yml` nella cartella principale della versione.

1. Esegui uno dei seguenti comandi per verificare di aver inserito il AppSpec file nella directory principale:
   + Per Linux, macOS o Unix:

     ```
     find /path/to/root/directory -name appspec.yml
     ```

     Non ci sarà alcun output se il AppSpec file non viene trovato lì.
   + Per Windows:

     ```
     dir path\to\root\directory\appspec.yml
     ```

     Se **il file non è memorizzato** lì, verrà visualizzato un errore AppSpec File Not Found.

1. Invia la revisione ad Amazon GitHub S3 o. 

   Per istruzioni, consulta [Invia una revisione CodeDeploy ad Amazon S3 (solo distribuzioni EC2/on-premise)](application-revisions-push.md).

### AppSpec modello di file per una distribuzione EC2/on-premise con istruzioni
<a name="app-spec-template-server"></a>

**Nota**  
 Le distribuzioni su istanze di Windows Server non supportano l'elemento. `runas` Se si esegue la distribuzione su istanze di Windows Server, non includerlo nel file. AppSpec 

```
# This is an appspec.yml template file for use with an EC2/On-Premises deployment in CodeDeploy.
# The lines in this template starting with the hashtag symbol are 
#   instructional comments and can be safely left in the file or 
#   ignored.
# For help completing this file, see the "AppSpec File Reference" in the  
#   "CodeDeploy User Guide" at
#   https://docs.aws.amazon.com/codedeploy/latest/userguide/app-spec-ref.html
version: 0.0
# Specify "os: linux" if this revision targets Amazon Linux, 
#   Red Hat Enterprise Linux (RHEL), or Ubuntu Server  
#   instances.
# Specify "os: windows" if this revision targets Windows Server instances.
# (You cannot specify both "os: linux" and "os: windows".)
os: linux 
# os: windows
# During the Install deployment lifecycle event (which occurs between the 
#   BeforeInstall and AfterInstall events), copy the specified files 
#   in "source" starting from the root of the revision's file bundle 
#   to "destination" on the Amazon EC2 instance.
# Specify multiple "source" and "destination" pairs if you want to copy 
#   from multiple sources or to multiple destinations.
# If you are not copying any files to the Amazon EC2 instance, then remove the
#   "files" section altogether. A blank or incomplete "files" section
#   may cause associated deployments to fail.
files:
  - source: 
    destination:
  - source:
    destination:
# For deployments to Amazon Linux, Ubuntu Server, or RHEL instances,
#   you can specify a "permissions" 
#   section here that describes special permissions to apply to the files 
#   in the "files" section as they are being copied over to 
#   the Amazon EC2 instance.
#   For more information, see the documentation.
# If you are deploying to Windows Server instances,
#   then remove the 
#   "permissions" section altogether. A blank or incomplete "permissions"
#   section may cause associated deployments to fail.
permissions:
  - object:
    pattern:
    except:
    owner:
    group:
    mode: 
    acls:
      -
    context:
      user:
      type:
      range:
    type:
      -
# If you are not running any commands on the Amazon EC2 instance, then remove 
#   the "hooks" section altogether. A blank or incomplete "hooks" section
#   may cause associated deployments to fail.
hooks:
# For each deployment lifecycle event, specify multiple "location" entries 
#   if you want to run multiple scripts during that event.
# You can specify "timeout" as the number of seconds to wait until failing the deployment 
#   if the specified scripts do not run within the specified time limit for the 
#   specified event. For example, 900 seconds is 15 minutes. If not specified, 
#   the default is 1800 seconds (30 minutes).
#   Note that the maximum amount of time that all scripts must finish executing 
#   for each individual deployment lifecycle event is 3600 seconds (1 hour). 
#   Otherwise, the deployment will stop and CodeDeploy will consider the deployment
#   to have failed to the Amazon EC2 instance. Make sure that the total number of seconds 
#   that are specified in "timeout" for all scripts in each individual deployment 
#   lifecycle event does not exceed a combined 3600 seconds (1 hour).
# For deployments to Amazon Linux, Ubuntu Server, or RHEL instances,
#   you can specify "runas" in an event to
#   run as the specified user. For more information, see the documentation.
#   If you are deploying to Windows Server instances,
#   remove "runas" altogether.
# If you do not want to run any commands during a particular deployment
#   lifecycle event, remove that event declaration altogether. Blank or 
#   incomplete event declarations may cause associated deployments to fail.
# During the ApplicationStop deployment lifecycle event, run the commands 
#   in the script specified in "location" starting from the root of the 
#   revision's file bundle.
  ApplicationStop:
    - location: 
      timeout:
      runas:
    - location: 
      timeout:
      runas: 
# During the BeforeInstall deployment lifecycle event, run the commands 
#   in the script specified in "location".
  BeforeInstall:
    - location: 
      timeout:
      runas: 
    - location: 
      timeout:
      runas:
# During the AfterInstall deployment lifecycle event, run the commands 
#   in the script specified in "location".
  AfterInstall:
    - location:     
      timeout: 
      runas:
    - location: 
      timeout:
      runas:
# During the ApplicationStart deployment lifecycle event, run the commands 
#   in the script specified in "location".
  ApplicationStart:
    - location:     
      timeout: 
      runas:
    - location: 
      timeout:
      runas:
# During the ValidateService deployment lifecycle event, run the commands 
#   in the script specified in "location".
  ValidateService:
    - location:     
      timeout: 
      runas:
    - location: 
      timeout:
      runas:
```

# Scegli un tipo di CodeDeploy repository
<a name="application-revisions-repository-type"></a>

La posizione di archiviazione per i file richiesta da CodeDeploy è denominata *repository*. L'uso di un repository dipende dalla piattaforma di elaborazione utilizzata dalla distribuzione.
+ **EC2/On-Premises**: per distribuire il codice dell'applicazione in una o più istanze, il codice deve essere raggruppato in un file di archivio e inserito in un repository a cui CodeDeploy sia possibile accedervi durante il processo di distribuzione. Il contenuto distribuibile e un AppSpec file vengono raggruppati in un file di archivio, quindi caricati in uno dei tipi di repository supportati da. CodeDeploy
+ **AWS Lambda** e **Amazon ECS: le** distribuzioni richiedono un AppSpec file, a cui è possibile accedere durante una distribuzione in uno dei seguenti modi: 
  +  Da un bucket Amazon S3. 
  +  Dal testo digitato direttamente nell' AppSpec editor della console. Per ulteriori informazioni, consultare [Creare un'implementazione della AWS Lambda Compute Platform (console)](deployments-create-console-lambda.md) e [Crea un'implementazione di Amazon ECS Compute Platform (console)](deployments-create-console-ecs.md). 
  +  Se si utilizza il AWS CLI, è possibile fare riferimento a un AppSpec file presente sul disco rigido o su un'unità di rete. Per ulteriori informazioni, consultare [Crea un'implementazione della AWS Lambda Compute Platform (CLI)](deployments-create-lambda-cli.md) e [Crea un'implementazione di Amazon ECS Compute Platform (CLI)](deployments-create-ecs-cli.md). 

CodeDeploy attualmente supporta i seguenti tipi di repository: 


|  |  |  | 
| --- |--- |--- |
| Tipo di archivio | Dettagli repository | Piattaforme di elaborazione supportate | 
| Amazon S3 | [Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/) (Amazon S3) è la AWS soluzione per lo storage di oggetti sicuro e scalabile. Amazon S3 archivia i dati come oggetti in bucket. Un oggetto è composto da un file e facoltativamente da qualsiasi metadato che lo descriva. Per archiviare un oggetto in Amazon S3, devi caricare il file in un bucket. Al caricamento del file è possibile configurare le autorizzazioni e i metadati per l'oggetto. Ulteriori informazioni: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/application-revisions-repository-type.html) | Le distribuzioni che utilizzano le seguenti piattaforme di elaborazione possono archiviare la revisione in un bucket Amazon S3.[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/application-revisions-repository-type.html) | 
| GitHub | È possibile archiviare le revisioni delle applicazioni in [GitHub](http://www.github.com)repository. È possibile attivare una distribuzione da un GitHub repository ogni volta che il codice sorgente in tale repository viene modificato.Ulteriori informazioni:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/application-revisions-repository-type.html) | Solo le distribuzioni EC2 /On-Premises possono archiviare la revisione in un repository. GitHub  | 
| Bitbucket |  [https://bitbucket.org/product/features/pipelines/integrations?p=atlassian/aws-code-deploy](https://bitbucket.org/product/features/pipelines/integrations?p=atlassian/aws-code-deploy) Bitbucket Pipelines offre funzionalità di integrazione continua e distribuzione continua (CI/CD), incluse le [distribuzioni Bitbucket](https://confluence.atlassian.com/bitbucket/bitbucket-deployments-940695276.html). La CodeDeploy pipe invia prima l'artefatto a un bucket S3 che hai specificato, quindi distribuisce l'elemento di codice dal bucket. Ulteriori informazioni:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/application-revisions-repository-type.html)  | Solo le distribuzioni EC2 /On-Premises possono archiviare la revisione in un repository. BitBucket  | 

**Nota**  
Una AWS Lambda distribuzione funziona solo con un repository Amazon S3.

# Invia una revisione CodeDeploy ad Amazon S3 (solo distribuzioni EC2/on-premise)
<a name="application-revisions-push"></a>

Dopo aver pianificato la revisione come descritto in [Pianifica una revisione per CodeDeploy](application-revisions-plan.md) e aver aggiunto un AppSpec file alla revisione come descritto in[Aggiungere un file di specifiche dell'applicazione a una revisione per CodeDeploy](application-revisions-appspec-file.md), sei pronto per raggruppare i file dei componenti e inviare la revisione ad Amazon S3. Per le distribuzioni su istanze Amazon EC2, dopo aver inviato la revisione, puoi CodeDeploy utilizzare per distribuire la revisione da Amazon S3 alle istanze.

**Nota**  
CodeDeploy può essere utilizzato anche per distribuire le revisioni che sono state trasferite a. GitHub Per ulteriori informazioni, consulta la documentazione. GitHub 

Si presuppone che siano già state seguite le istruzioni in [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md) per configurare il AWS CLI. Questo è particolarmente importante per chiamare il comando **push** descritto più avanti.

Assicurati di avere un bucket Amazon S3. Segui le istruzioni in [Creare un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html).

Se la distribuzione è su istanze Amazon EC2, il bucket Amazon S3 di destinazione deve essere creato o esistere nella stessa regione delle istanze di destinazione. Ad esempio, se desideri distribuire una revisione in alcune istanze nella regione Stati Uniti orientali (Virginia settentrionale) e altre istanze nella regione Stati Uniti occidentali (Oregon), devi avere un bucket nella regione Stati Uniti orientali (Virginia settentrionale) con una copia della revisione e un altro bucket nella regione Stati Uniti occidentali (Oregon) con un'altra copia della stessa revisione. In questo scenario, sarebbe quindi necessario creare due distribuzioni separate, una nella regione Stati Uniti orientali (Virginia settentrionale) e l'altra nella regione Stati Uniti occidentali (Oregon), anche se la revisione è la stessa in entrambe le regioni e i periodi.

È necessario disporre delle autorizzazioni per il caricamento nel bucket Amazon S3. Puoi specificare queste autorizzazioni tramite una policy sui bucket di Amazon S3. Ad esempio, nella seguente policy sui bucket di Amazon S3, l'utilizzo del carattere wildcard (\$1) consente `111122223333` all' AWS account di caricare file in qualsiasi directory del bucket Amazon S3 denominata: `amzn-s3-demo-bucket`

```
{
    "Statement": [
        {
            "Action": [
                "s3:PutObject"
            ],
            "Effect": "Allow",
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
            "Principal": {
                "AWS": [
                    "111122223333"
                ]
            }
        }
    ]
}
```

[Per visualizzare l'ID del tuo AWS account, consulta Finding Your account ID. AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html#FindingYourAWSId)

Per informazioni su come generare e allegare una bucket policy di Amazon S3, consulta Esempi di policy [Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html).

L'utente che chiama il **push** comando deve disporre almeno delle autorizzazioni per caricare la revisione in ogni bucket Amazon S3 di destinazione. Ad esempio, la seguente policy consente all'utente di caricare le revisioni in qualsiasi punto del bucket Amazon S3 denominato: `amzn-s3-demo-bucket`

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:PutObject"
            ],
            "Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*"
        }
    ]
}
```

------

Per informazioni su come creare e allegare una policy IAM, consulta [Working](https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingPolicies.html#AddingPermissions_Console) with policies.

## Invia una revisione utilizzando il AWS CLI
<a name="push-with-cli"></a>

**Nota**  
 Il `push` comando raggruppa gli elementi dell'applicazione e un AppSpec file in una revisione. Il formato di file di questa revisione è un file ZIP compresso. Il comando non può essere utilizzato con una distribuzione AWS Lambda o Amazon ECS perché ognuna prevede una revisione che sia un file in formato JSON o in formato YAML. AppSpec 

Chiama il comando **push** per aggregare e inviare la revisione per una distribuzione. I parametri sono:
+  **--application-name**: (stringa) obbligatorio. Il nome dell'applicazione CodeDeploy da associare a questa revisione dell'applicazione. 
+  **--s3-location**: (stringa) obbligatorio. Informazioni sulla posizione della revisione dell'applicazione da caricare su Amazon S3. È necessario specificare un bucket Amazon S3 e una chiave. La chiave è il nome della revisione. CodeDeploy comprime il contenuto prima che venga caricato. Utilizzare il formato `s3://amzn-s3-demo-bucket/your-key.zip`. 
+  **--ignore-hidden-files** o **--no-ignore-hidden-files**: (booleano) Facoltativo. Usa il `--no-ignore-hidden-files` flag (impostazione predefinita) per raggruppare e caricare file nascosti su Amazon S3. Usa il `--ignore-hidden-files` flag per non raggruppare e caricare file nascosti su Amazon S3. 
+  **--source** (stringa) Facoltativo. La posizione del contenuto da distribuire e del AppSpec file sulla macchina di sviluppo da comprimere e caricare su Amazon S3. La posizione è specificata come un percorso relativo alla directory corrente. Se il percorso relativo non è specificato o se viene utilizzato un punto singolo per il percorso ("."), viene utilizzata la directory corrente. 
+  **--description** (stringa) Facoltativo. Un commento che riepiloga la revisione dell'applicazione. Se non viene specificata, viene utilizzata la stringa predefinita «Uploaded by AWS CLI 'time' UTC», dove 'time' è l'ora corrente del sistema in UTC (Coordinated Universal Time). 

Puoi usare il AWS CLI per inviare una revisione per una distribuzione di Amazon EC2. Un comando di invio di esempio è simile a quanto segue: 

In Linux, macOS o Unix:

```
aws deploy push \
  --application-name WordPress_App \
  --description "This is a revision for the application WordPress_App" \
  --ignore-hidden-files \
  --s3-location s3://amzn-s3-demo-bucket/WordPressApp.zip \
  --source .
```

 Su Windows: 

```
aws deploy push --application-name WordPress_App --description "This is a revision for the application WordPress_App" --ignore-hidden-files --s3-location s3://amzn-s3-demo-bucket/WordPressApp.zip --source .
```

 Questo comando funziona nel modo seguente: 
+  Associa i file aggregati con un'applicazione denominata `WordPress_App`. 
+  Collega una descrizione alla revisione. 
+  Ignora i file nascosti. 
+  Rinomina la revisione `WordPressApp.zip` e la invia e un bucket denominato `amzn-s3-demo-bucket`. 
+  Aggrega tutti i file nella directory root nella revisione. 

Dopo che il push è andato a buon fine, puoi utilizzare la console AWS CLI o la CodeDeploy console per distribuire la revisione da Amazon S3. Per distribuire questa revisione con: AWS CLI

 In Linux, macOS o Unix: 

```
aws deploy create-deployment \
  --application-name WordPress_App \ 
  --deployment-config-name your-deployment-config-name \ 
  --deployment-group-name your-deployment-group-name \ 
  --s3-location bucket=amzn-s3-demo-bucket,key=WordPressApp.zip,bundleType=zip
```

 Su Windows: 

```
aws deploy create-deployment --application-name WordPress_App --deployment-config-name your-deployment-config-name --deployment-group-name your-deployment-group-name --s3-location bucket=amzn-s3-demo-bucket,key=WordPressApp.zip,bundleType=zip
```

 Per ulteriori informazioni, consulta [Crea una distribuzione con CodeDeploy](deployments-create.md). 

# Visualizza i dettagli della revisione dell'applicazione con CodeDeploy
<a name="application-revisions-view-details"></a>

Puoi utilizzare la CodeDeploy console AWS CLI, la o la CodeDeploy APIs per visualizzare i dettagli su tutte le revisioni dell'applicazione registrate nel tuo AWS account per un'applicazione specifica.

Per ulteriori informazioni sulla registrazione di una revisione, consulta [Registra una revisione dell'applicazione in Amazon S3 con CodeDeploy](application-revisions-register.md).

**Topics**
+ [Visualizza i dettagli della revisione dell'applicazione (console)](#application-revisions-view-details-console)
+ [Visualizza i dettagli della revisione dell'applicazione (CLI)](#application-revisions-view-details-cli)

## Visualizza i dettagli della revisione dell'applicazione (console)
<a name="application-revisions-view-details-console"></a>

Per visualizzare i dettagli delle revisioni delle applicazioni:

1. Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**Nota**  
Accedi con lo stesso utente con cui hai effettuato la configurazione. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)

1. Nel riquadro di navigazione espandere **Deploy (Distribuisci)** e scegliere **Applications (Applicazioni)**.
**Nota**  
Se non viene visualizzata alcuna voce, assicurati che sia selezionata la regione corretta. Nella barra di navigazione, nel selettore di regione, scegli una delle regioni elencate in [Regione ed endpoint](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) in. *Riferimenti generali di AWS* CodeDeploy è supportato solo in queste regioni.

1. Scegliere il nome dell'applicazione che contiene la revisione da visualizzare.

1. Nella pagina **Application details (Dettagli applicazione)**, scegliere la scheda **Revisions (Revisioni)** e rivedere l'elenco delle revisioni registrate per l'applicazione. Selezionare una revisione, quindi scegliere **View details (Visualizza dettagli)**.

## Visualizza i dettagli della revisione dell'applicazione (CLI)
<a name="application-revisions-view-details-cli"></a>

Per utilizzare AWS CLI per visualizzare la revisione di un'applicazione, chiamate il ****get-application-revision****comando o il comando. ****list-application-revisions****

**Nota**  
 Riferimenti da GitHub applicare alle distribuzioni solo alle distribuzioni EC2/on-premise. Le revisioni per le distribuzioni non funzionano con. AWS Lambda GitHub 

Per visualizzare i dettagli relativi a una singola revisione di applicazione, chiamare il comando [get-application-revision](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-application-revision.html) specificando: 
+ Nome dell'applicazione. [Per ottenere il nome dell'applicazione, chiamate il comando list-applications.](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html)
+ Per una revisione memorizzata in GitHub, il nome del GitHub repository e l'ID del commit che fa riferimento alla revisione dell'applicazione che è stata inserita nel repository.
+ Per una revisione archiviata in Amazon S3, il nome del bucket Amazon S3 contenente la revisione, il nome e il tipo di file del file di archivio caricato e, facoltativamente, l'identificatore di versione Amazon S3 del file di archivio e. ETag Se l'identificatore di versione o entrambi sono stati specificati durante una chiamata a ETag, devono essere specificati qui. [register-application-revision](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-application-revision.html)

Per visualizzare i dettagli relativi a più revisioni di applicazione, chiamare il comando [list-application-revisions](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-application-revisions.html) specificando:
+ Nome dell'applicazione. Per ottenere il nome dell'applicazione, chiamate il comando [list-applications](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html).
+ Facoltativamente, per visualizzare i dettagli solo per le revisioni delle applicazioni Amazon S3, il nome del bucket Amazon S3 contenente le revisioni.
+ Facoltativamente, per visualizzare i dettagli solo per le revisioni delle applicazioni Amazon S3, una stringa di prefisso per limitare la ricerca alle revisioni delle applicazioni Amazon S3. (Se non specificato, CodeDeploy elencherà tutte le revisioni delle applicazioni Amazon S3 corrispondenti.)
+ Facoltativamente, se i dettagli di revisione devono essere elencati distinguendo le revisioni di destinazione di un gruppo di distribuzione. (Se non specificato, CodeDeploy elencherà tutte le revisioni corrispondenti.)
+ Facoltativamente, il nome di colonna e l'ordine in base al quale ordinare l'elenco dei dettagli delle revisioni. (Se non specificato, CodeDeploy elencherà i risultati in un ordine arbitrario.)

Puoi elencare tutte le revisioni o solo quelle archiviate in Amazon S3. Non puoi elencare solo le revisioni memorizzate in. GitHub

# Registra una revisione dell'applicazione in Amazon S3 con CodeDeploy
<a name="application-revisions-register"></a>

Se hai già chiamato il comando [push](https://docs.aws.amazon.com/cli/latest/reference/deploy/push.html) per inviare una revisione dell'applicazione ad Amazon S3, non è necessario registrare la revisione. Tuttavia, se carichi una revisione su Amazon S3 con altri mezzi e desideri che la revisione venga visualizzata nella console o tramite CodeDeploy AWS CLI il, segui questi passaggi per registrare prima la revisione.

Se hai inserito una revisione dell'applicazione in un GitHub repository e desideri che la revisione venga visualizzata nella CodeDeploy console o tramite il AWS CLI, devi seguire anche questi passaggi.

Puoi utilizzare solo il AWS CLI o CodeDeploy APIs per registrare le revisioni delle applicazioni in Amazon GitHub S3 o.

**Topics**
+ [Registra una revisione in Amazon S3 con CodeDeploy (CLI)](#application-revisions-register-s3)
+ [Registrare una revisione GitHub con CodeDeploy (CLI)](#application-revisions-register-github)

## Registra una revisione in Amazon S3 con CodeDeploy (CLI)
<a name="application-revisions-register-s3"></a>

1. Carica la revisione su Amazon S3.

1. Chiama il comando [register-application-revision](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-application-revision.html), specificando:
   + Nome dell'applicazione. Per visualizzare un elenco di nomi di applicazioni, chiama il comando [list-applications](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html).
   + Informazioni relative alla revisione da registrare:
     + Il nome del bucket Amazon S3 che contiene la revisione.
     + Il nome e il tipo di file della revisione caricata. Per le AWS Lambda distribuzioni, la revisione è un AppSpec file scritto in JSON o YAML. Per le distribuzioni EC2/on-premise, la revisione contiene una versione dei file sorgente che verranno distribuiti sulle istanze o gli script che CodeDeploy verranno eseguiti sulle istanze. CodeDeploy 
**Nota**  
I formati di file di archivio tar e tar compressi (.tar e .tar.gz) non sono supportati per le istanze di Windows Server.
     + (Facoltativo) L'identificatore della versione Amazon S3 della revisione. (Se l'identificatore di versione non è specificato, CodeDeploy utilizzerà la versione più recente.)
     + (Facoltativo) La revisione. ETag (Se non ETag è specificato, CodeDeploy salterà la convalida dell'oggetto.)
   + (Facoltativo) Qualsiasi descrizione che si desidera associare alla revisione.

Le informazioni su una revisione in Amazon S3 possono essere specificate nella riga di comando, utilizzando questa sintassi come parte della chiamata. **register-application-revision** (`version`e `eTag` sono opzionali).

Per un file di revisione per una distribuzione EC2/on-premise:

```
--s3-location bucket=string,key=string,bundleType=tar|tgz|zip,version=string,eTag=string
```

Per un file di revisione per una distribuzione AWS Lambda:

```
--s3-location bucket=string,key=string,bundleType=JSON|YAML,version=string,eTag=string
```

## Registrare una revisione GitHub con CodeDeploy (CLI)
<a name="application-revisions-register-github"></a>

**Nota**  
AWS Lambda le distribuzioni non funzionano con. GitHub 

1. Carica la revisione nel tuo repository. GitHub 

1. Chiama il comando [register-application-revision](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-application-revision.html), specificando:
   + Nome dell'applicazione. Per visualizzare un elenco di nomi di applicazioni, chiamate il comando [list-applications](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html).
   + Informazioni relative alla revisione da registrare:
     + Il nome GitHub dell'utente o del gruppo assegnato al repository che contiene la revisione, seguito da una barra (`/`), seguita dal nome del repository.
     + L'ID del commit che fa riferimento alla revisione nel repository.
   + (Facoltativo) Qualsiasi descrizione che si desidera associare alla revisione.

Le informazioni su una revisione in GitHub possono essere specificate nella riga di comando, utilizzando questa sintassi come parte della chiamata: **register-application-revision**

```
--github-location repository=string,commitId=string
```