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