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à.
# Distribuzioni del ramo feature e flussi di lavoro del team
Amplify Hosting è progettato per funzionare con feature branch e flussi di lavoro. GitFlow Amplify utilizza i branch Git per creare una nuova distribuzione ogni volta che connetti un nuovo ramo nel tuo repository. Dopo aver collegato la prima filiale, crei rami di funzionalità aggiuntive.
**Per aggiungere un ramo a un'app**
1. Scegli l'app a cui vuoi aggiungere un ramo.
1. Scegli **Impostazioni app**, quindi **Impostazioni Branch**.
1. Nella pagina **delle impostazioni Branch**, scegli **Aggiungi filiale**.
1. Seleziona un ramo dal tuo repository.
1. Scegli **Aggiungi ramo**.
1. Ridistribuisci la tua app.
Dopo aver aggiunto un ramo, l'app ha due distribuzioni disponibili nei domini predefiniti di Amplify, ad esempio e. *https://main.appid.amplifyapp.com*https://dev.appid.amplifyapp.com** Questo può variare team-to-team, ma in genere la **filiale principale tiene traccia del codice di rilascio ed è la filiale** di produzione. Il **ramo develop** è utilizzato come ramo integrativo per testare le nuove funzionalità. Ciò consente ai beta tester di testare funzionalità inedite nell'implementazione della filiale di sviluppo, senza influire sugli utenti finali di produzione coinvolti nell'implementazione della filiale principale.
**Topics**
+ [Flussi di lavoro in team con app complete Amplify Gen 2](team-workflows-gen2.md)
+ [Flussi di lavoro in team con app complete Amplify Gen 1](team-workflows-with-amplify-cli-backend-environments.md)
+ [Implementazioni di feature branch basate su pattern](pattern-based-feature-branch-deployments.md)
+ [Generazione automatica in fase di compilazione della configurazione Amplify (solo app di prima generazione)](amplify-config-autogeneration.md)
+ [Build di backend condizionali (solo app di prima generazione)](conditional-backends.md)
+ [Usa i backend Amplify tra le app (solo app di prima generazione)](reuse-backends.md)
# Flussi di lavoro in team con app complete Amplify Gen 2
AWS Amplify Gen 2 introduce TypeScript un'esperienza di sviluppo basata sul codice per la definizione dei backend. [https://docs.amplify.aws/nextjs/deploy-and-host/fullstack-branching/](https://docs.amplify.aws/nextjs/deploy-and-host/fullstack-branching/)
# Flussi di lavoro in team con app complete Amplify Gen 1
Una distribuzione di feature branch consiste in un **frontend** e un ambiente **backend** opzionale. Il frontend è costruito e distribuito su una rete globale di distribuzione dei contenuti (CDN), mentre il backend viene distribuito da Amplify Studio o dalla CLI di Amplify. AWS Per informazioni su come configurare questo scenario di distribuzione, consulta. [Creazione di un backend per un'applicazione](deploy-backend.md)
Amplify Hosting implementa continuamente risorse di backend come le funzioni GraphQL e Lambda con le APIs tue implementazioni di feature branch. Puoi utilizzare i seguenti modelli di ramificazione per implementare il backend e il frontend con Amplify Hosting.
## Flusso di lavoro del ramo feature
+ Crea ambienti di backend di **produzione**, **test** e **sviluppo** con Amplify Studio o Amplify CLI.
+ ****Mappa il backend prod sul ramo principale.****
+ **Mappa il backend **di test** sul ramo di sviluppo.**
+ I membri del team possono utilizzare l'ambiente di backend di **sviluppo** per testare singoli rami di **funzionalità**.
![\[Un diagramma che mostra come mappare le relazioni dagli ambienti di backend ai rami di frontend.\]](http://docs.aws.amazon.com/it_it/amplify/latest/userguide/images/FeatureBranchWorkflow.png)
1. Installare l'interfaccia a riga di comando di Amplify per inizializzare un nuovo progetto Amplify.
```
npm install -g @aws-amplify/cli
```
1. Inizializzare un ambiente di back-end *prod* per il progetto. Se non hai un progetto, creane uno usando strumenti di bootstrap come o Gatsby. create-react-app
```
create-react-app next-unicorn
cd next-unicorn
amplify init
? Do you want to use an existing environment? (Y/n): n
? Enter a name for the environment: prod
...
amplify push
```
1. Aggiungere gli ambienti di back-end *test* e *dev*.
```
amplify env add
? Do you want to use an existing environment? (Y/n): n
? Enter a name for the environment: test
...
amplify push
amplify env add
? Do you want to use an existing environment? (Y/n): n
? Enter a name for the environment: dev
...
amplify push
```
1. Invia il codice a un repository Git di tua scelta (in questo esempio supponiamo che tu abbia eseguito il push su main).
```
git commit -am 'Added dev, test, and prod environments'
git push origin main
```
1. Visita Amplify nel per vedere Console di gestione AWS il tuo ambiente di backend attuale. **Sali di livello dal breadcrumb per visualizzare un elenco di tutti gli ambienti di backend creati nella scheda Ambienti di backend.**
![\[La console Amplify che mostra gli ambienti di backend associati a un'app Amplify.\]](http://docs.aws.amazon.com/it_it/amplify/latest/userguide/images/reuse-backend-5.png)
1. *Passa alla scheda **Ambienti frontend** e collega il provider del repository e la filiale principale.*
1. Nella pagina delle impostazioni di compilazione, seleziona un ambiente di backend esistente per configurare la distribuzione continua con il ramo principale. Scegli *prod* dall'elenco e concedi il ruolo di servizio ad Amplify. Scegliere **Save and deploy (Salva e distribuisci)**. Una volta completata la build, sarà disponibile una distribuzione della filiale principale all'indirizzo. *https://main.appid.amplifyapp.com*
![\[La pagina Configura le impostazioni di build con un elenco di backend esistenti.\]](http://docs.aws.amazon.com/it_it/amplify/latest/userguide/images/reuse-backend-2.png)
1. Connect *develop* branch in Amplify (*supponiamo che develop* *e* main branch siano gli stessi a questo punto). Scegliere l'ambiente di back-end *test*.
![\[La pagina Aggiungi ramo del repository con un branch e un ambiente di backend selezionati.\]](http://docs.aws.amazon.com/it_it/amplify/latest/userguide/images/reuse-backend-4.png)
1. Amplify è ora configurato. È possibile iniziare a lavorare su nuove funzionalità in un ramo feature. Aggiungere funzionalità di back-end utilizzando l'ambiente di back-end *dev* dalla workstation locale.
```
git checkout -b newinternet
amplify env checkout dev
amplify add api
...
amplify push
```
1. Dopo avere terminato di lavorare sulla funzionalità, eseguire il commit del codice e creare una richiesta di pull da rivedere internamente.
```
git commit -am 'Decentralized internet v0.1'
git push origin newinternet
```
1. Per vedere in anteprima come saranno le modifiche, vai alla console Amplify e collega il tuo ramo di funzionalità. Nota: se lo hai AWS CLI installato sul tuo sistema (non l'Amplify CLI), puoi collegare un ramo direttamente dal tuo terminale. È possibile reperire il proprio appid accedendo a App settings > General > AppARN (Impostazioni applicazione > Generali > ARNapp): *arn:aws:amplify:::apps/*
```
aws amplify create-branch --app-id --branch-name
aws amplify start-job --app-id --branch-name --job-type RELEASE
```
1. La tua funzionalità sarà accessibile da condividerla con i tuoi *https://newinternet.appid.amplifyapp.com*compagni di squadra. Se tutto appare corretto, unire PR al ramo develop.
```
git checkout develop
git merge newinternet
git push
```
1. Questo darà il via a una build che aggiornerà il backend e il frontend in Amplify con una distribuzione in filiale presso. *https://dev.appid.amplifyapp.com* È possibile condividere questo link con parti interessate interne affinché possano esaminare la nuova funzionalità.
1. Elimina il tuo ramo di funzionalità da Git, Amplify e rimuovi l'ambiente di backend dal cloud (puoi sempre crearne uno nuovo basandoti su «amplify env checkout prod» ed eseguendo «amplify env add»).
```
git push origin --delete newinternet
aws amplify delete-branch --app-id --branch-name
amplify env remove dev
```
## GitFlow flusso di lavoro
GitFlow utilizza due rami per registrare la cronologia del progetto. Il ramo *principale* tiene traccia solo del codice di rilascio e il ramo di *sviluppo* viene utilizzato come ramo di integrazione per nuove funzionalità. GitFlow semplifica lo sviluppo parallelo isolando il nuovo sviluppo dal lavoro completato. Il nuovo sviluppo (come le funzionalità e le correzioni di bug non urgenti) viene svolto nei rami *feature*. Quando lo sviluppatore è sicuro che il codice sia pronto per il rilascio, il ramo *feature* viene ricollegato al ramo *develop* delle integrazioni. Gli unici commit verso il ramo principale sono le fusioni tra le branch *release* e le branch *hotfix (per correggere i bug* di emergenza).
Il diagramma seguente mostra una configurazione consigliata con. GitFlow Puoi seguire lo stesso processo descritto nella sezione relativa al flusso di lavoro del ramo feature di cui sopra.
![\[Un diagramma che mostra una configurazione consigliata con. GitFlow\]](http://docs.aws.amazon.com/it_it/amplify/latest/userguide/images/GitflowWorkflow.png)
## Per sandbox sviluppatore
+ Ogni sviluppatore di un team crea un ambiente sandbox nel cloud che è separato dal computer locale. Ciò consente agli sviluppatori di lavorare in modo isolato gli uni dagli altri senza sovrascrivere le modifiche degli altri membri del team.
+ Ogni filiale di Amplify ha il proprio backend. Ciò garantisce che Amplify utilizzi il repository Git come unica fonte di verità da cui distribuire le modifiche, anziché affidarsi agli sviluppatori del team per inviare manualmente il backend o il front-end alla produzione dai computer locali.
![\[Un diagramma che mostra un flusso di lavoro sandbox per sviluppatore.\]](http://docs.aws.amazon.com/it_it/amplify/latest/userguide/images/AmplifySandboxWorkflow.png)
1. Installare l'interfaccia a riga di comando di Amplify per inizializzare un nuovo progetto Amplify.
```
npm install -g @aws-amplify/cli
```
1. Inizializza un ambiente di backend *Mary* per il tuo progetto. Se non hai un progetto, creane uno usando strumenti di bootstrap come create-react-app o Gatsby.
```
cd next-unicorn
amplify init
? Do you want to use an existing environment? (Y/n): n
? Enter a name for the environment: mary
...
amplify push
```
1. Invia il codice a un repository Git di tua scelta (in questo esempio supponiamo che tu abbia eseguito il push su main.
```
git commit -am 'Added mary sandbox'
git push origin main
```
1. Connect il repo > *main ad Amplify*.
1. La console Amplify rileverà gli ambienti di backend creati dalla CLI Amplify. Scegli *Crea nuovo ambiente* dal menu a discesa e concedi il ruolo di servizio ad Amplify. Scegliere **Save and deploy (Salva e distribuisci)**. Una volta completata la build, avrai a disposizione una distribuzione della filiale principale *https://main.appid.amplifyapp.com*con un nuovo ambiente di backend collegato alla filiale.
1. *Connetti il ramo di *sviluppo* in Amplify (*supponiamo che* develop *e* main branch siano gli stessi a questo punto) e scegli Crea*
# Implementazioni di feature branch basate su pattern
Le distribuzioni di filiali basate su pattern consentono di distribuire automaticamente le filiali che corrispondono a uno schema specifico su Amplify. I team di prodotto che utilizzano feature branch o GitFlow flussi di lavoro per le loro versioni possono ora definire modelli come **release\$1\$1** distribuire automaticamente i rami Git che iniziano con «release» su un URL condivisibile.
1. **Scegli **Impostazioni app, quindi Impostazioni** Branch.**
1. Nella pagina delle **impostazioni di Branch**, scegli **Modifica**.
1. Seleziona **Rilevamento automatico del ramo** per connettere automaticamente i rami ad Amplify che corrispondono a un set di pattern.
1. Nella casella **Rilevamento automatico di Branch - pattern**, inserisci i modelli per la distribuzione automatica dei rami.
+ **\$1**— Distribuisce tutte le filiali del tuo repository.
+ **release\$1**— Distribuisce tutti i rami che iniziano con la parola «rilascio».
+ **release\$1/**— Distribuisce tutti i rami che corrispondono a uno schema 'release /'.
+ Specificate più modelli in un elenco separato da virgole. Ad esempio, **release\$1, feature\$1**.
1. Imposta la protezione automatica con password per tutte le filiali che vengono create automaticamente selezionando il controllo di accesso con rilevamento **automatico di Branch**.
1. Per le applicazioni di prima generazione create con un backend Amplify, puoi scegliere di creare un nuovo ambiente per ogni filiale connessa o indirizzare tutte le filiali verso un backend esistente.
1. Scegli **Save** (Salva).
## Implementazioni di feature branch basate su pattern per un'app connessa a un dominio personalizzato
Puoi utilizzare distribuzioni di branch basate su funzionalità basate su pattern per un'app connessa a un dominio personalizzato Amazon Route 53.
+ Per istruzioni sulla configurazione di distribuzioni di feature branch basate su pattern, consulta [Configurazione di sottodomini automatici per un dominio personalizzato Amazon Route 53](to-set-up-automatic-subdomains-for-a-Route-53-custom-domain.md)
+ Per istruzioni su come connettere un'app Amplify a un dominio personalizzato gestito in Route 53, vedi [Aggiungere un dominio personalizzato gestito da Amazon Route 53](to-add-a-custom-domain-managed-by-amazon-route-53.md)
+ Per ulteriori informazioni sull'uso di Route 53, consulta [What is Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html).
# Generazione automatica in fase di compilazione della configurazione Amplify (solo app di prima generazione)
**Nota**
Le informazioni in questa sezione si riferiscono solo alle app di prima generazione. *Se desideri implementare automaticamente le modifiche al codice dell'infrastruttura e dell'applicazione dai rami delle funzionalità per un'app di seconda generazione, consulta le [implementazioni delle filiali Fullstack nei documenti](https://docs.amplify.aws/nextjs/deploy-and-host/fullstack-branching/branch-deployments/) di Amplify*
Amplify supporta la generazione automatica in fase di compilazione del file di configurazione Amplify per le app `aws-exports.js` di prima generazione. Disattivando le implementazioni CI/CD complete dello stack, consenti alla tua app di generare automaticamente il file e assicuri che non vengano apportati aggiornamenti al backend in fase di compilazione. `aws-exports.js`
**Da `aws-exports.js` generare automaticamente in fase di compilazione**
1. Accedi Console di gestione AWS e apri la console [Amplify.](https://console.aws.amazon.com/amplify/)
1. Scegli l'app da modificare.
1. Scegli la scheda **Ambienti di hosting**.
1. Individua il ramo da modificare e scegli **Modifica**.
![\[La posizione del link Modifica per un ramo nella console Amplify.\]](http://docs.aws.amazon.com/it_it/amplify/latest/userguide/images/amplify_edit_backend_alternate.png)
1. Nella pagina **Modifica backend di destinazione**, deseleziona **Abilita le distribuzioni continue a stack completo (CI/CD) per disattivare la CI/CD full-stack** per questo backend.
![\[La posizione della casella di controllo da disattivare CI/CD nella console Amplify.\]](http://docs.aws.amazon.com/it_it/amplify/latest/userguide/images/amplify_turnoff_CICD.png)
1. Seleziona un ruolo di servizio esistente per concedere ad Amplify le autorizzazioni necessarie per apportare modifiche al backend dell'app. **Se devi creare un ruolo di servizio, scegli Crea nuovo ruolo.** Per ulteriori informazioni sulla creazione di un ruolo del servizio, consulta [Aggiungere un ruolo di servizio con autorizzazioni per distribuire risorse di backend](amplify-service-role.md).
1. Scegli **Save** (Salva). Amplify applica queste modifiche la prossima volta che crei l'app.
# Build di backend condizionali (solo app di prima generazione)
**Nota**
Le informazioni in questa sezione si riferiscono solo alle app di prima generazione. Amplify Gen 2 introduce TypeScript un'esperienza di sviluppo basata sul codice. Pertanto, questa funzionalità non è necessaria per i backend di seconda generazione.
Amplify supporta build di backend condizionali su tutte le filiali in un'app di prima generazione. Per configurare build di backend condizionali, imposta la variabile di ambiente su. `AMPLIFY_DIFF_BACKEND` `true` L'abilitazione delle build condizionali di backend contribuirà a velocizzare le build in cui le modifiche vengono apportate solo al frontend.
Quando abiliti le build di backend basate su diff, all'inizio di ogni build, Amplify tenta di eseguire un diff nella cartella del tuo repository. `amplify` Se Amplify non rileva alcuna differenza, salta la fase di creazione del backend e non aggiorna le risorse del backend. Se il progetto non ha una `amplify` cartella nel repository, Amplify ignora il valore della variabile di ambiente. `AMPLIFY_DIFF_BACKEND` Per istruzioni sull'impostazione della variabile di `AMPLIFY_DIFF_BACKEND` ambiente, consulta. [Configurazione di build di backend basate su diff per un'app di prima generazione](edit-build-settings.md#enable-diff-backend)
Se al momento sono stati specificati comandi personalizzati nelle impostazioni di compilazione della fase di backend, le build condizionali di backend non funzioneranno. Se desideri che questi comandi personalizzati vengano eseguiti, devi spostarli nella fase di frontend delle impostazioni di build nel file dell'app. `amplify.yml` Per ulteriori informazioni sull'aggiornamento del `amplify.yml` file, consulta[Riferimento alle specifiche della build](yml-specification-syntax.md).
# Usa i backend Amplify tra le app (solo app di prima generazione)
**Nota**
Le informazioni in questa sezione si riferiscono solo alle app di prima generazione. Se desideri condividere risorse di backend per un'app di seconda generazione, consulta [Condividere risorse tra filiali](https://docs.amplify.aws/nextjs/deploy-and-host/fullstack-branching/share-resources/) nei documenti *Amplify*
Amplify ti consente di riutilizzare gli ambienti di backend esistenti in tutte le tue app di prima generazione in una determinata regione. Puoi farlo quando crei una nuova app, connetti una nuova filiale a un'app esistente o aggiorni un frontend esistente in modo che punti a un ambiente di backend diverso.
## Riutilizza i backend quando crei una nuova app
**Per riutilizzare un backend durante la creazione di una nuova app Amplify**
1. Accedi Console di gestione AWS e apri la console [Amplify.](https://console.aws.amazon.com/amplify/)
1. Per creare un nuovo backend da utilizzare per questo esempio, procedi come segue:
1. Nel riquadro di navigazione, scegli **Tutte le app**.
1. Scegli **Nuova app**, **Crea un'app**.
1. Inserisci un nome per la tua app, ad esempio**Example-Amplify-App**.
1. Scegli **Conferma distribuzione**.
1. Per connettere un frontend al nuovo backend, scegli la scheda **Ambienti di hosting.**
1. Scegli il tuo provider git, quindi scegli **Connect branch**.
1. Nella pagina **Aggiungi ramo del repository**, per **Archivi aggiornati di recente**, scegli il nome del repository. Per **Branch**, seleziona il ramo dal tuo repository per connetterti.
1. Nella pagina **Build settings**, procedi come segue:
1. Per **il nome dell'app**, seleziona l'app da utilizzare per aggiungere un ambiente di backend. Puoi scegliere l'app corrente o qualsiasi altra app nella regione corrente.
1. Per **Ambiente**, seleziona il nome dell'ambiente di backend da aggiungere. È possibile utilizzare un ambiente esistente o crearne uno nuovo.
1. Per impostazione predefinita, lo stack completo CI/CD è disattivato. *La disattivazione del CI/CD full-stack fa sì che l'app venga eseguita in modalità pull only.* In fase di compilazione, Amplify genererà automaticamente solo `aws-exports.js` il file, senza modificare l'ambiente di backend.
1. Seleziona un ruolo di servizio esistente per concedere ad Amplify le autorizzazioni necessarie per apportare modifiche al backend dell'app. **Se devi creare un ruolo di servizio, scegli Crea nuovo ruolo.** Per ulteriori informazioni sulla creazione di un ruolo del servizio, consulta [Aggiungere un ruolo di servizio con autorizzazioni per distribuire risorse di backend](amplify-service-role.md).
1. Scegli **Next (Successivo)**.
1. Scegliere **Save and deploy (Salva e distribuisci)**.
## Riutilizza i backend quando connetti una filiale a un'app esistente
**Per riutilizzare un backend quando si collega una filiale a un'app Amplify esistente**
1. Accedi Console di gestione AWS e apri la console [Amplify.](https://console.aws.amazon.com/amplify/)
1. Scegli l'app a cui connettere una nuova filiale.
1. Nel riquadro di navigazione, scegli **Impostazioni app**, **Generali**.
1. Nella sezione **Filiali**, scegli **Connetti una filiale**.
1. Nella pagina **Aggiungi ramo del repository**, per **Branch**, seleziona il ramo dal tuo repository per connetterti.
1. Per **il nome dell'app**, seleziona l'app da utilizzare per aggiungere un ambiente di backend. Puoi scegliere l'app corrente o qualsiasi altra app nella regione corrente.
1. Per **Ambiente**, seleziona il nome dell'ambiente di backend da aggiungere. È possibile utilizzare un ambiente esistente o crearne uno nuovo.
1. Se devi configurare un ruolo di servizio per concedere ad Amplify le autorizzazioni necessarie per apportare modifiche al backend dell'app, la console ti chiederà di eseguire questa operazione. Per ulteriori informazioni sulla creazione di un ruolo del servizio, consulta [Aggiungere un ruolo di servizio con autorizzazioni per distribuire risorse di backend](amplify-service-role.md).
1. Per impostazione predefinita, lo stack completo è disattivato. CI/CD *La disattivazione dello stack completo CI/CD fa sì che l'app venga eseguita in modalità pull only.* In fase di compilazione, Amplify genererà automaticamente solo `aws-exports.js` il file, senza modificare l'ambiente di backend.
1. Scegli **Next (Successivo)**.
1. Scegliere **Save and deploy (Salva e distribuisci)**.
## Modifica un frontend esistente in modo che punti a un backend diverso
**Per modificare un frontend, l'app Amplify in modo che punti a un backend diverso**
1. Accedi Console di gestione AWS e apri la console [Amplify.](https://console.aws.amazon.com/amplify/)
1. Scegli l'app per cui modificare il backend.
1. Scegli la scheda **Ambienti di hosting**.
1. Individua il ramo da modificare e scegli **Modifica**.
![\[La posizione del link Modifica per un ramo nella console Amplify.\]](http://docs.aws.amazon.com/it_it/amplify/latest/userguide/images/amplify_edit_backend.png)
1. Nella pagina **Seleziona un ambiente di backend da usare con questo ramo**, per **Nome app**, seleziona l'app di frontend per cui desideri modificare l'ambiente di backend. Puoi scegliere l'app corrente o qualsiasi altra app nella regione corrente.
1. Per **Ambiente di backend**, seleziona il nome dell'ambiente di backend da aggiungere.
1. Per impostazione predefinita, lo stack completo CI/CD è abilitato. Deseleziona questa opzione per disattivare lo stack completo CI/CD per questo backend. *La disattivazione del full-stack CI/CD fa sì che l'app venga eseguita in modalità pull only.* In fase di compilazione, Amplify genererà automaticamente solo `aws-exports.js` il file, senza modificare l'ambiente di backend.
1. Scegli **Save** (Salva). Amplify applica queste modifiche la prossima volta che crei l'app.