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à.
# Sincronizzazione degli stack con il codice sorgente archiviato in un repository Git con la sincronizzazione Git
Con Git sync, puoi gestire i tuoi CloudFormation stack con il controllo del codice sorgente. Puoi farlo configurando CloudFormation per monitorare un repository Git. Il repository viene monitorato per rilevare eventuali modifiche a due file:
+ Un file CloudFormation modello che definisce uno stack
+ Un file di implementazione dello stack che contiene i parametri per la configurazione dello stack
Con Git sync, puoi utilizzare le pull request e il monitoraggio delle versioni per configurare, distribuire e aggiornare i tuoi CloudFormation stack da una posizione centralizzata. Quando esegui modifiche al modello o al file di distribuzione, aggiorna CloudFormation automaticamente lo stack. Se utilizzi le richieste pull, CloudFormation puoi lasciare un commento sulla richiesta pull spiegando quali modifiche verranno apportate al tuo stack prima di aggiornarlo effettivamente. Tuttavia, devi prima abilitare questa funzionalità.
Git sync fornisce un'interfaccia console che puoi usare per collegarti a un repository, generare un file di distribuzione dello stack, aggiornare un CloudFormation modello e inviare una richiesta pull al tuo repository. La sincronizzazione Git presenta anche una dashboard di stato attraverso la quale puoi monitorare e modificare le implementazioni attive dello stack di sincronizzazione Git, nonché risolvere eventuali problemi. La sincronizzazione Git è accessibile tramite la [CloudFormation console](https://console.aws.amazon.com/cloudformation/) quando [crei uno stack](cfn-console-create-stack.md). Puoi anche accedere a Git sync usando CodeConnections. Per ulteriori informazioni, consulta [Utilizzo delle configurazioni di sincronizzazione per i repository collegati](https://docs.aws.amazon.com/dtconsole/latest/userguide/configurations.html) nella *Guida per l’utente della Console Strumenti per gli sviluppatori*.
Git sync supporta [GitHub Enterprise [GitHub[GitLab](https://about.gitlab.com/)](https://github.com/)](https://github.com/enterprise), [Bitbucket](https://bitbucket.org) e repository [GitLab autogestiti](https://docs.gitlab.com/subscriptions/self_managed/).
**Nota**
La sincronizzazione Git è disponibile nelle Regioni seguenti: Stati Uniti orientali (Virginia settentrionale), Stati Uniti orientali (Ohio), Stati Uniti occidentali (California settentrionale), Stati Uniti occidentali (Oregon), Canada (Centrale), Asia Pacifico (Mumbai), Asia Pacifico (Tokyo), Asia Pacifico (Seoul), Asia Pacifico (Singapore), Asia Pacifico (Sydney), Europa (Irlanda), Europa (Londra), Europa (Parigi), Europa (Stoccolma), Europa (Francoforte), Europa (Milano) e Sud America (San Paolo).
Per informazioni sull’utilizzo della configurazione Git con una strategia multi-account, consulta il seguente post sul blog [Use CloudFormation Git sync to configure resources in customer accounts](https://aws.amazon.com/blogs/devops/use-aws-cloudformation-git-sync-to-configure-resources-in-customer-accounts/).
**Topics**
+ [Come funziona la sincronizzazione Git](git-sync-concepts-terms.md)
+ [Prerequisiti](git-sync-prereq.md)
+ [Creazione di uno stack dal codice sorgente del repository](git-sync-create-stack-from-repository-source-code.md)
+ [Abilitazione dei commenti nelle richieste pull](gitsync-enable-comments-on-pull-requests.md)
+ [Dashboard di stato](git-sync-status.md)
# Come funziona Git sync con CloudFormation
Questo argomento descrive come funziona la sincronizzazione Git e introduce i concetti chiave necessari per utilizzarla.
**Topics**
+ [Come funziona la sincronizzazione Git](#git-sync-concepts-terms-how)
+ [Commenti sulle richieste pull](#git-sync-comments-on-pull-requests)
+ [File di implementazione dello stack](#git-sync-concepts-terms-depoyment-file)
+ [CloudFormation file modello](#git-sync-concepts-terms-template-file)
+ [Repository delle definizioni dei modelli](#git-sync-concepts-terms-template-definition-repository)
## Come funziona la sincronizzazione Git
Per utilizzare Git sync, devi prima connettere un provider Git all' CloudFormation utilizzo del [CodeConnections](https://docs.aws.amazon.com/codeconnections/latest/APIReference/Welcome.html)servizio. Nelle procedure di questa guida, la connessione viene creata tramite la CodeConnections console. In alternativa, puoi crearla anche tramite la AWS CLI. Puoi utilizzare uno dei seguenti provider Git:
+ [GitHub](https://github.com/)
+ [GitHub Impresa](https://github.com/enterprise/)
+ [GitLab](https://about.gitlab.com/)
+ [Bitbucket](https://bitbucket.org)
+ [GitLabautogestita](https://docs.gitlab.com/subscriptions/self_managed/)
Successivamente, crei un CloudFormation modello che definisca il tuo stack e lo aggiungi al tuo repository. Questo file modello viene monitorato. CloudFormation aggiorna automaticamente lo stack quando vengono apportate modifiche.
Nella CloudFormation console, crei un nuovo stack e scegli **Sincronizza da Git** per dire di CloudFormation usare Git sync. Specificherai il repository e il ramo che desideri CloudFormation monitorare e specificherai il CloudFormation modello nel tuo repository che definisce lo stack.
Durante la configurazione, puoi fornire il tuo file di implementazione dello stack dal repository o fare in modo che la sincronizzazione Git ne generi uno per te. Il file di implementazione dello stack contiene parametri e valori che configurano le risorse dello stack. Questo file di distribuzione dello stack viene monitorato. CloudFormation aggiorna automaticamente lo stack quando vengono apportate modifiche.
Git sync crea una richiesta pull nel tuo repository per sincronizzare lo stack con il file CloudFormation modello e il file di distribuzione dello stack. Il file di implementazione dello stack viene inviato al tuo repository dalla sincronizzazione Git se quest’ultima lo genera al posto tuo.
Quindi unisci la pull request al tuo repository in modo da effettuare il CloudFormation provisioning dello stack, configurarlo con i parametri di distribuzione e iniziare a monitorare il repository per rilevare eventuali modifiche.
Da quel momento in poi, ogni volta che apporti modifiche al tuo file modello o al file di distribuzione dello stack e le esegui nel tuo repository, rileverà automaticamente le modifiche. CloudFormation Se il tuo team utilizza le richieste pull, i membri possono rivedere e approvare le modifiche prima che vengano implementate. Una volta accettata la pull request, CloudFormation distribuisce le modifiche.
Puoi monitorare lo stato della configurazione di sincronizzazione Git per lo stack e vedere una cronologia dei commit applicati allo stack nella console. CloudFormation La console fornisce anche strumenti per la riconfigurazione della sincronizzazione Git e la risoluzione dei problemi.
## Commenti sulle richieste pull
Puoi scegliere di CloudFormation creare un riepilogo delle modifiche al codice nelle richieste pull tramite il CodeConnections servizio attivando l'opzione **Abilita commento sulla pull request** nella console. Fornire un riepilogo delle modifiche nelle richieste pull significa che i membri del team possono facilmente esaminare e comprendere l’impatto delle modifiche proposte prima di unire la richiesta pull. Per ulteriori informazioni, consulta [Abilita CloudFormation la pubblicazione di un riepilogo delle modifiche allo stack nelle richieste pull](gitsync-enable-comments-on-pull-requests.md).
## File di implementazione dello stack
Un file di distribuzione dello stack è un file in formato standard JSON ( JavaScript Object Notation) o YAML che contiene parametri e valori che gestiscono lo stack. CloudFormation Viene monitorato per rilevare eventuali modifiche. Quando viene eseguito il commit delle modifiche al file nel repository, lo stack associato viene aggiornato automaticamente.
Il file di implementazione dello stack contiene una coppia chiave-valore e due dizionari:
+ `template-file-path`
Questo è il percorso completo del repository per il file modello. CloudFormation Il file modello dichiara le risorse per lo CloudFormation stack associato a questo file di distribuzione.
+ `parameters`
Il dizionario dei parametri contiene coppie chiave-valore che configurano le risorse nello stack. Un file di implementazione dello stack può avere fino a 50 parametri.
+ `tags`
Il dizionario dei tag contiene coppie chiave-valore facoltative che puoi utilizzare per identificare e classificare le risorse nello stack. Un file di implementazione dello stack può avere fino a 50 tag.
Puoi fornire il tuo file di implementazione dello stack o fare in modo che la sincronizzazione Git ne crei uno per te e invii automaticamente una richiesta pull al repository. Puoi gestire i parametri e i tag modificando il file di implementazione dello stack ed eseguendo il commit delle modifiche al repository.
Di seguito è riportato l’esempio di un file di implementazione dello stack della sincronizzazione Git:
```
template-file-path: fargate-srvc/my-stack-template.yaml
parameters:
image: public.ecr.aws/lts/nginx:latest
task_size: x-small
max_capacity: 5
port: 8080
env: production
tags:
cost-center: '123456'
org: 'AWS'
```
## CloudFormation file modello
Un file modello contiene una dichiarazione delle AWS risorse che compongono uno CloudFormation stack. Con la sincronizzazione Git, il file di modello a cui il file di implementazione dello stack fa riferimento viene archiviato nel repository Git. Puoi gestire lo stack modificando il file di modello ed eseguendo il commit delle modifiche al repository.
Per ulteriori informazioni, consulta [Lavorare con i CloudFormation modelli](template-guide.md).
## Repository delle definizioni dei modelli
Il repository delle definizioni dei modelli è il repository Git a cui è collegato tramite CloudFormation Git sync. Il repository viene monitorato per rilevare eventuali modifiche al CloudFormation modello e al file di distribuzione dello stack. Quando esegui il commit delle modifiche al file, lo stack associato viene aggiornato automaticamente.
**Importante**
Quando configuri il repository delle definizioni dei modelli nella console della sincronizzazione Git, seleziona il *repository* e il *ramo* corretti dalla connessione Git. Git sync monitora solo il repository e il ramo configurati per le modifiche al CloudFormation modello e al file di distribuzione dello stack.
# Prerequisiti per sincronizzare gli stack con un repository Git utilizzando la sincronizzazione Git
Prima di sincronizzare uno CloudFormation stack con il tuo repository Git, verifica che siano soddisfatti i seguenti requisiti.
**Topics**
+ [Repository Git](#git-sync-prereq-repo)
+ [CloudFormation modello](#git-sync-prereq-template)
+ [Ruolo di servizio della sincronizzazione Git](#git-sync-prereq-iam)
+ [Autorizzazioni IAM per utenti della console](#git-sync-prereq-user-permissions)
## Repository Git
Devi disporre di un repository Git ospitato su una delle seguenti piattaforme:
+ [GitHub](https://github.com/)
+ [GitHub Impresa](https://github.com/enterprise)
+ [GitLab](https://about.gitlab.com/)
+ [Bitbucket](https://bitbucket.org)
+ [GitLabautogestita](https://docs.gitlab.com/subscriptions/self_managed/)
Il repository può essere pubblico o privato. Dovrai connettere questo repository Git CloudFormation tramite la [console Connections](https://console.aws.amazon.com/codesuite/settings/connections).
## CloudFormation modello
Il tuo repository Git deve contenere un [file CloudFormation modello](git-sync-concepts-terms.md#git-sync-concepts-terms-template-file) archiviato nel ramo a cui intendi connetterti con Git sync. Il [file di implementazione dello stack](git-sync-concepts-terms.md#git-sync-concepts-terms-depoyment-file) fa riferimento a questo modello.
## Ruolo di servizio della sincronizzazione Git
La sincronizzazione Git richiede un ruolo IAM. Al momento della configurazione della sincronizzazione Git puoi scegliere di creare un ruolo IAM per il tuo stack o utilizzare un ruolo già esistente.
**Nota**
Un ruolo IAM generato automaticamente applica le autorizzazioni solo allo stack per il quale viene generato. Per riutilizzare un ruolo IAM generato automaticamente, devi modificare il ruolo per il nuovo stack.
### Autorizzazioni richieste per il ruolo di servizio della sincronizzazione Git
Il ruolo IAM fornito per la sincronizzazione Git richiede le seguenti autorizzazioni.
+ `cloudformation:CreateChangeSet`
+ `cloudformation:DeleteChangeSet`
+ `cloudformation:DescribeChangeSet`
+ `cloudformation:DescribeStackEvents`
+ `cloudformation:DescribeStacks`
+ `cloudformation:ExecuteChangeSet`
+ `cloudformation:ListChangeSets`
+ `cloudformation:ValidateTemplate`
+ `events:PutRule`
+ `events:PutTargets`
**Nota**
Le precedenti autorizzazioni richieste vengono aggiunte automaticamente ai ruoli IAM generati dalla sincronizzazione Git.
Il seguente esempio di ruolo IAM include le autorizzazioni di prerequisito necessarie per la sincronizzazione Git.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "SyncToCloudFormation",
"Effect": "Allow",
"Action": [
"cloudformation:CreateChangeSet",
"cloudformation:DeleteChangeSet",
"cloudformation:DescribeChangeSet",
"cloudformation:DescribeStackEvents",
"cloudformation:DescribeStacks",
"cloudformation:ExecuteChangeSet",
"cloudformation:GetTemplate",
"cloudformation:ListChangeSets",
"cloudformation:ListStacks",
"cloudformation:ValidateTemplate"
],
"Resource": "*"
},
{
"Sid": "PolicyForManagedRules",
"Effect": "Allow",
"Action": [
"events:PutRule",
"events:PutTargets"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"events:ManagedBy": ["cloudformation.sync.codeconnections.amazonaws.com"]
}
}
},
{
"Sid": "PolicyForDescribingRule",
"Effect": "Allow",
"Action": "events:DescribeRule",
"Resource": "*"
}
]
}
```
------
#### Policy di attendibilità
Devi fornire la seguente policy di attendibilità quando crei il ruolo per definire la relazione di attendibilità.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CfnGitSyncTrustPolicy",
"Effect": "Allow",
"Principal": {
"Service": "cloudformation.sync.codeconnections.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Si consiglia di utilizzare le chiavi di condizione `aws:SourceArn` e `aws:SourceAccount` per proteggersi dal problema del "confused deputy". L'account di origine è l'ID del tuo account e l'ARN di origine è l'ARN della connessione nel [CodeConnections](https://docs.aws.amazon.com/codeconnections/latest/APIReference/Welcome.html)servizio che consente di connettersi CloudFormation al tuo repository Git.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CfnGitSyncTrustPolicy",
"Effect": "Allow",
"Principal": {
"Service": "cloudformation.sync.codeconnections.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "123456789012"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:codeconnections:us-east-1:123456789012:connection/EXAMPLE64-8aad-4d5d-8878-dfcab0bc441f"
}
}
}
]
}
```
------
Per ulteriori informazioni sul problema del "confused deputy", consulta [Prevenzione del problema "confused deputy" tra servizi](cross-service-confused-deputy-prevention.md).
## Autorizzazioni IAM per utenti della console
Per configurare correttamente la sincronizzazione Git tramite la CloudFormation console, agli utenti finali devono essere concesse le autorizzazioni anche tramite IAM.
Le seguenti autorizzazioni `codeconnections` sono necessarie per creare e gestire la connessione al tuo repository Git.
+ `codeconnections:CreateRepositoryLink`
+ `codeconnections:CreateSyncConfiguration`
+ `codeconnections:DeleteRepositoryLink`
+ `codeconnections:DeleteSyncConfiguration`
+ `codeconnections:GetRepositoryLink`
+ `codeconnections:GetSyncConfiguration`
+ `codeconnections:ListRepositoryLinks`
+ `codeconnections:ListSyncConfigurations`
+ `codeconnections:ListTagsForResource`
+ `codeconnections:TagResource`
+ `codeconnections:UntagResource`
+ `codeconnections:UpdateRepositoryLink`
+ `codeconnections:UpdateSyncBlocker`
+ `codeconnections:UpdateSyncConfiguration`
+ `codeconnections:UseConnection`
Gli utenti della console devono inoltre disporre delle seguenti autorizzazioni `cloudformation` per visualizzare e gestire gli stack durante il processo di configurazione della sincronizzazione Git.
+ `cloudformation:CreateChangeSet`
+ `cloudformation:DeleteChangeSet`
+ `cloudformation:DescribeChangeSet`
+ `cloudformation:DescribeStackEvents`
+ `cloudformation:DescribeStacks`
+ `cloudformation:ExecuteChangeSet`
+ `cloudformation:GetTemplate`
+ `cloudformation:ListChangeSets`
+ `cloudformation:ListStacks`
+ `cloudformation:ValidateTemplate`
**Nota**
Anche se le autorizzazioni di modifica del set (`cloudformation:CreateChangeSet`, `cloudformation:DeleteChangeSet`, `cloudformation:DescribeChangeSet`, `cloudformation:ExecuteChangeSet`) potrebbero non essere strettamente necessarie per l’utilizzo solo su console, sono consigliate per abilitare le funzionalità complete di ispezione e gestione dello stack.
La seguente policy IAM include le autorizzazioni utente necessarie per configurare la sincronizzazione Git tramite la console.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "CodeConnectionsPermissions",
"Effect": "Allow",
"Action": [
"codeconnections:CreateRepositoryLink",
"codeconnections:CreateSyncConfiguration",
"codeconnections:DeleteRepositoryLink",
"codeconnections:DeleteSyncConfiguration",
"codeconnections:GetRepositoryLink",
"codeconnections:GetSyncConfiguration",
"codeconnections:ListRepositoryLinks",
"codeconnections:ListSyncConfigurations",
"codeconnections:ListTagsForResource",
"codeconnections:TagResource",
"codeconnections:UntagResource",
"codeconnections:UpdateRepositoryLink",
"codeconnections:UpdateSyncBlocker",
"codeconnections:UpdateSyncConfiguration",
"codeconnections:UseConnection",
"codeconnections:CreateForcedTargetSync",
"codeconnections:CreatePullRequestForResource"
],
"Resource": "*"
},
{
"Sid": "CloudFormationConsolePermissions",
"Effect": "Allow",
"Action": [
"cloudformation:CreateChangeSet",
"cloudformation:DeleteChangeSet",
"cloudformation:DescribeChangeSet",
"cloudformation:DescribeStackEvents",
"cloudformation:DescribeStacks",
"cloudformation:ExecuteChangeSet",
"cloudformation:GetTemplate",
"cloudformation:ListChangeSets",
"cloudformation:ListStacks",
"cloudformation:ValidateTemplate"
],
"Resource": "*"
}
]
}
```
------
**Nota**
Quando crei una policy IAM che include le autorizzazioni `codeconnections:CreateForcedTargetSync` e `codeconnections:CreatePullRequestForResource`, potresti visualizzare un avviso nella console IAM che indica che queste azioni non esistono. Puoi ignorare questo avviso e la policy verrà comunque creata correttamente. Queste autorizzazioni sono necessarie per determinate operazioni di sincronizzazione Git nonostante non siano riconosciute dalla console IAM.
# Creazione di uno stack dal codice sorgente del repository con la sincronizzazione Git
Questo argomento spiega come creare uno CloudFormation stack che si sincronizzi con un repository Git con Git sync.
**Importante**
Prima di continuare, completa tutti i [prerequisiti indicati](git-sync-prereq.md) nella sezione precedente.
## Creazione di uno stack dal codice sorgente del repository
1. [Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo /cloudformazione. https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)
1. Nella barra di navigazione nella parte superiore dello schermo, scegli in cui Regione AWS creare lo stack.
1. Nella pagina **Stack** scegli **Crea Stack**, quindi scegli **Con nuove risorse (standard)**.
1. Nella pagina **Create stack** (Crea stack), esegui le operazioni seguenti:
1. Per **Prerequisito - Prepara modello**, mantieni selezionata l’opzione **Scegli un modello esistente**.
1. Per **Specifica modello**, scegli **Sincronizza da Git**, quindi scegli **Avanti**.
1. Nella pagina **Specifica dettagli stack** digita il nome dello stack in **Nome stack**. Il nome dello stack può includere lettere (A-Z o a-z), numeri (0-9) e trattini (-).
1. Per **File di implementazione dello stack**, **Creazione del file di implementazione**:
+ Se *non hai* creato un file di implementazione corrispondente e non lo hai inserito nel repository, scegli **Crea il file utilizzando i seguenti parametri e inseriscilo nel repository**.
+ Se nel repository è presente un file di implementazione corrispondente, seleziona **Fornisco il file nel repository**.
1. Per **Template definition repository**, scegli **Scegli un repository Git collegato** per scegliere un repository Git già collegato oppure Collega **un repository Git** per collegarne uno nuovo. CloudFormation Se scegli **Collega un repository Git**, procedi come segue:
1. Per **Seleziona un provider di repository**, scegli una delle seguenti opzioni:
+ **GitHub**
+ **GitHub Server aziendale**
+ **GitLab**
+ **Bitbucket**
+ **GitLab autogestito**
1. Per **Connessione**, scegli una connessione dall’elenco. Se non viene visualizzata alcuna opzione nell’elenco **Connessione**, scegli **aggiungi una nuova connessione** per andare alla [Console Connessioni](https://console.aws.amazon.com/codesuite/settings/connections) e creare una connessione al tuo repository.
1. Nell’elenco **Repository**, seleziona il repository Git che contiene il tuo file di modello dello stack.
1. Nell’elenco **Ramo**, seleziona il ramo che la sincronizzazione Git deve monitorare.
**Nota**
Git sync monitora solo il ramo selezionato per le modifiche al CloudFormation modello e ai file di distribuzione dello stack. Per qualsiasi modifica che desideri apportare al tuo stack è necessario eseguire il commit su questo ramo.
1. Specifica il percorso completo per il **Percorso del file di distribuzione**, incluso il nome del file di implementazione dello stack dalla radice del ramo del repository.
Se CloudFormation sta generando il file per te, è qui che il file verrà salvato nel tuo repository. Se sei tu a fornire il file, questa sarà la sua posizione nel repository.
1. Aggiungi un **ruolo IAM**. Il ruolo IAM include le autorizzazioni necessarie per CloudFormation sincronizzare lo stack dal tuo repository Git. Puoi scegliere **Nuovo ruolo IAM** per generare un nuovo ruolo o **Ruolo IAM esistente** per selezionare uno già esistente dal tuo Account AWS. Se scegli di generare un nuovo ruolo, le autorizzazioni necessarie sono già incluse.
1. Attiva o disattiva i commenti sulla richiesta pull:
+ Per inserire le informazioni relative ai CloudFormation post change set nelle richieste pull per gli aggiornamenti dello stack, tieni acceso l'interruttore **Enable comment on pull request**.
+ Se disattivi questo interruttore, CloudFormation non descriverà le differenze tra la configurazione corrente dello stack e le modifiche proposte nelle richieste pull quando i file del repository vengono aggiornati.
1. Per il **Percorso del file modello**, specifica il percorso completo dalla radice del repository per il file del modello di stack.
1. (Facoltativo) Per specificare i parametri dello stack, scegli **Aggiungi parametro**, fornisci una chiave e un valore per ogni parametro, quindi scegli **Avanti**. Per ulteriori informazioni, consulta [File di implementazione dello stack](git-sync-concepts-terms.md#git-sync-concepts-terms-depoyment-file).
Ad esempio, per specificare un parametro **port=8080** nel file di implementazione dello stack, procedi come segue:
1. Scegli **Add parameter (Aggiungi parametro)**.
1. In **Chiave**, inserire **port**.
1. In **Valore**, specifica **8080**.
1. (Facoltativo) Per aggiungere tag dello stack, scegli **Aggiungi tag**, fornisci una chiave e un valore di tag, quindi scegli **Avanti**. Per ulteriori informazioni, consulta [File di implementazione dello stack](git-sync-concepts-terms.md#git-sync-concepts-terms-depoyment-file).
1. Scegli **Avanti** per continuare con **Configura opzioni dello stack**. Per informazioni sulla configurazione delle opzioni dello stack, consulta [Configurazione delle opzioni dello stack](cfn-console-create-stack.md#configure-stack-options).
Una volta completata la configurazione dello stack, scegli **Avanti** per continuare.
1. Controlla le impostazioni dello stack e verifica quanto segue:
+ Il modello di stack è configurato correttamente e impostato su **Sincronizza da Git**.
+ Il file di implementazione è configurato correttamente.
+ Il repository delle definizioni dei modelli è configurato correttamente e, in particolare, è selezionato il **Repository** e il **Nome ramo** corretto.
+ L’anteprima del file di implementazione è corretta e contiene i parametri e i valori previsti.
1. Scegli **Invia** per creare lo stack.
Quando scegli **Invia** viene creata automaticamente una richiesta pull nel repository Git. Per creare il tuo stack devi unire questa richiesta pull al repository Git. Dopo aver creato lo stack, CloudFormation monitora il tuo repository Git per rilevare eventuali modifiche.
## Aggiornamento dello stack dal repository Git
Per aggiornare lo stack, esegui modifiche direttamente sul file modello o sul file di implementazione dello stack corrispondente nel repository Git. Dopo aver eseguito il commit delle modifiche nel ramo monitorato, aggiorna CloudFormation automaticamente lo stack. Se utilizzi le richieste pull, prima che venga aggiornato lo stack viene creata automaticamente una richiesta pull nel repository Git. Per aggiornare lo stack devi unire questa richiesta pull al repository Git.
Nella CloudFormation console, puoi selezionare lo stack e scegliere la scheda **Git sync** per visualizzare informazioni sullo stato dello stack e sugli eventi di sincronizzazione. Per ulteriori informazioni, consulta [Dashboard di stato della sincronizzazione Git](git-sync-status.md).
# Abilita CloudFormation la pubblicazione di un riepilogo delle modifiche allo stack nelle richieste pull
Questo argomento mostra come CloudFormation abilitare la pubblicazione di un riepilogo delle modifiche allo stack nelle richieste pull nel tuo repository Git.
Abilitando la funzionalità dei commenti sulle richieste pull, si consente di CloudFormation pubblicare un commento che descrive le differenze tra la configurazione corrente dello stack e le modifiche proposte quando i file del repository vengono aggiornati. Questo commento fornisce un riepilogo delle risorse che verranno aggiunte, modificate o eliminate e consente di eseguire una revisione approfondita del codice prima di unire la richiesta pull.
**Abilitazione dei commenti nelle richieste pull per un nuovo stack (console)**
Quando crei lo stack, nella pagina **Specifica dettagli stack**, in **Repository delle definizioni dei modelli**, assicurati che sia attiva l’opzione **Abilita commento in richieste pull**. Questa è l’impostazione predefinita per i nuovi stack.
**Abilitazione dei commenti nelle richieste pull per uno stack esistente (console)**
1. [Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo https://console.aws.amazon.com /cloudformazione.](https://console.aws.amazon.com/cloudformation/)
1. Nella barra di navigazione nella parte superiore dello schermo, scegli lo stack in Regione AWS cui hai creato lo stack.
1. Nella pagina **Stack**, seleziona lo stack in esecuzione da aggiornare.
1. Seleziona la scheda **Sincronizzazione Git**, quindi scegli **Modifica**.
1. Nella pagina **Modifica impostazioni sincronizzazione Git**, in **Repository delle definizioni dei modelli**, attiva l’opzione **Abilita commento in richieste pull**.
1. Selezionare **Update configuration (Aggiorna configurazione)**.
# Dashboard di stato della sincronizzazione Git
Per visualizzare lo stato di una distribuzione AWS CloudFormation Git sync, seleziona lo stack nella CloudFormation console e scegli la scheda **Git sync**.
La scheda Sincronizzazione Git è divisa in due pannelli: **Stato della sincronizzazione Git** ed **Eventi di sincronizzazione più recenti**.
## Stato della sincronizzazione Git
Il pannello superiore fornisce le seguenti informazioni sulla configurazione della sincronizzazione Git per lo stack.
****Repository****
Un collegamento al repository connesso alla sincronizzazione Git
****Provider di repository****
Il nome del provider di repository
****Ramo****
Il nome del ramo monitorato dalla sincronizzazione Git
****Percorso del file di implementazione****
Il percorso completo del file di implementazione dello stack per lo stack in questione
****Stato di sincronizzazione del repository****
Lo stato dell’operazione di sincronizzazione più recente
****Messaggio sullo stato della sincronizzazione del repository****
Il messaggio relativo all’operazione di sincronizzazione più recente
****Stato della sincronizzazione Git****
Lo stato della sincronizzazione Git per lo stack in questione
****Stato del provisioning****
Lo stato dell’operazione di provisioning
Nella sezione in alto a destra del pannello, utilizza i pulsanti seguenti per modificare o aggiornare la sincronizzazione Git:
+ **Modifica**: modifica la configurazione della sincronizzazione Git.
+ **Riprova l’ultimo commit**: aggiorna lo stack in base al commit più recente al repository.
+ **Disconnetti**: disconnetti la sincronizzazione Git dallo stack.
+ **Aggiorna**: aggiorna il pannello di stato della sincronizzazione Git.
## Eventi di sincronizzazione più recenti
Il pannello **Eventi di sincronizzazione più recenti** mostra una tabella dei commit che sono stati eseguiti sullo stack.
È possibile ordinare la tabella utilizzando le frecce presenti nell’intestazione di ogni colonna. La tabella può essere ordinata in ordine crescente o decrescente in base ai seguenti parametri:
+ **Data**
+ **ID commit**
+ **Evento**
+ **Data**
+ **Tipo di evento**
## Stati dello stack supportati
La sincronizzazione Git può essere configurata per uno stack solo se quest’ultimo si trova in uno dei seguenti stati supportati:
+ `CREATE_COMPLETE`
+ `UPDATE_COMPLETE`
+ `UPDATE_ROLLBACK_COMPLETE`
+ `IMPORT_COMPLETE`
+ `IMPORT_ROLLBACK_COMPLETE`
La tabella seguente contiene un elenco completo dei codici di stato dello stack con le relative descrizioni:
| Stato dello stack e stato dettagliato opzionale | Description |
| --- | --- |
| `CREATE_COMPLETE` | Creazione di uno o più stack completata. |
| `CREATE_IN_PROGRESS` | Creazione di uno o più stack in corso. |
| `CREATE_FAILED` | Creazione di uno o più stack non riuscita. Visualizzare gli eventi dello stack per vedere gli eventuali messaggi di errore associati. Le possibili ragioni di una creazione non riuscita includono le autorizzazioni insufficienti per lavorare con tutte le risorse dello stack, i valori dei parametri rifiutati da un AWS servizio o un timeout durante la creazione delle risorse. |
| `DELETE_COMPLETE` | Eliminazione di uno o più stack completata. Gli stack eliminati vengono conservati e sono visualizzabili per 90 giorni. |
| `DELETE_FAILED` | Eliminazione di uno o più stack non riuscita. Poiché l’eliminazione non è riuscita, è possibile che alcune risorse siano ancora in esecuzione; tuttavia, non è possibile utilizzare o aggiornare lo stack. Eliminare nuovamente lo stack o visualizzare gli eventi dello stack per visualizzare gli eventuali messaggi di errore associati. |
| `DELETE_IN_PROGRESS` | Rimozione di uno o più stack in corso. |
| `REVIEW_IN_PROGRESS` | Creazione di uno o più stack in corso con un StackId previsto ma senza modelli o risorse. Un stack con questo codice di stato conta fino al raggiungimento del [massimo numero possibile di stack](cloudformation-limits.md). |
| `ROLLBACK_COMPLETE` | Rimozione di uno o più stack completata dopo una creazione stack non riuscita o dopo una creazione stack annullata in maniera esplicita. Lo stack torna allo stato di funzionamento precedente. Le eventuali risorse che sono state create durante l’operazione di creazione dello stack vengono eliminate. Questo stato esiste solo dopo una creazione stack non riuscita. Indica che tutte le operazioni dallo stack creato parzialmente sono state opportunamente rimosse. In questo stato, è possibile eseguire solo un’operazione di eliminazione. |
| `ROLLBACK_FAILED` | Rimozione di uno o più stack non riuscita dopo una creazione stack non riuscita o dopo una creazione stack annullata in maniera esplicita. Eliminare lo stack o visualizzare gli eventi dello stack per visualizzare gli eventuali messaggi di errore associati. |
| `ROLLBACK_IN_PROGRESS` | Rimozione di uno o più stack in corso dopo una creazione stack non riuscita o dopo una creazione stack annullata in maniera esplicita. |
| `UPDATE_COMPLETE` | Aggiornamento di uno o più stack completato. |
| `UPDATE_COMPLETE_CLEANUP_IN_PROGRESS` | Rimozione in corso di risorse obsolete per uno o più stack dopo un aggiornamento dello stack completato. Per gli aggiornamenti dello stack che richiedono la sostituzione di risorse, CloudFormation crea prima le nuove risorse e poi elimina le vecchie risorse per ridurre eventuali interruzioni dello stack. In questo stato, lo stack è stato aggiornato ed è utilizzabile, ma le vecchie risorse CloudFormation vengono comunque eliminate. |
| `UPDATE_FAILED` | Aggiornamento non completato di uno o più stack. Visualizzare gli eventi dello stack per vedere gli eventuali messaggi di errore associati. |
| `UPDATE_IN_PROGRESS` | Aggiornamento di uno o più stack in corso. |
| `UPDATE_ROLLBACK_COMPLETE` | Restituzione di uno o più stack completata in uno stato attivo precedente dopo un aggiornamento stack non riuscito. |
| `UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS` | Rimozione in corso di nuove risorse per uno o più stack dopo un aggiornamento dello stack non riuscito. In questo stato, lo stack è stato ripristinato allo stato di funzionamento precedente ed è utilizzabile, ma CloudFormation sta comunque eliminando tutte le nuove risorse create durante l'aggiornamento dello stack. |
| `UPDATE_ROLLBACK_FAILED` | Restituzione di uno o più stack non riuscita in uno stato attivo precedente dopo un aggiornamento stack non riuscito. In questo stato, puoi eliminare lo stack o [continuare il rollback](using-cfn-updating-stacks-continueupdaterollback.md). Prima che lo stack possa tornare in uno stato attivo, potrebbe essere necessario risolvere gli errori. In alternativa, puoi contattare Supporto per ripristinare lo stack a uno stato utilizzabile. |
| `UPDATE_ROLLBACK_IN_PROGRESS` | Restituzione di uno o più stack in corso allo stato attivo precedente dopo un aggiornamento stack non riuscito. |
| `IMPORT_IN_PROGRESS` | L’operazione di importazione è attualmente in corso. |
| `IMPORT_COMPLETE` | L’operazione di importazione è stata completata correttamente per tutte le risorse nello stack che supportano `resource import`. |
| `IMPORT_ROLLBACK_IN_PROGRESS` | L’importazione verrà ripristinata alla configurazione del modello precedente. |
| `IMPORT_ROLLBACK_FAILED` | L’operazione di rollback di importazione non è riuscita per almeno una risorsa nello stack. I risultati saranno disponibili per le risorse importate CloudFormation con successo. |
| `IMPORT_ROLLBACK_COMPLETE` | Il rollback dell’importazione alla configurazione del modello precedente è riuscita. |