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à.
# Lavorare con i commit nei repository AWS CodeCommit
I commit sono snapshot dei contenuti e modifiche apportate ai contenuti di un repository. Ogni volta che un utente esegue un commit e invia una modifica, l'informazione viene salvata e archiviata. Così anche le informazioni relative a chi ha eseguito il commit della modifica, la data e l'ora del commit e le modifiche apportate nell'ambito del commit. Puoi anche aggiungere tag ai commit per identificarli facilmente. In CodeCommit, puoi:
+ Esaminare i commit.
+ Visualizzare in un grafico la cronologia dei commit.
+ Confrontare un commit con il padre o con un altro indicatore.
+ Aggiungere commenti ai commit e rispondere ai commenti altrui.
![\[Aggiunta di un commento a una riga modificata in un commit.\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-commenting-addlinecomment.png)
Prima di inviare i commit a un CodeCommit repository, è necessario configurare il computer locale per la connessione al repository. Per il metodo più semplice, consulta [Per utenti HTTPS che utilizzano credenziali Git](setting-up-gc.md).
Per informazioni sull'utilizzo di altri aspetti del repository in CodeCommit, consulta,, [Lavorare con i repository](repositories.md)[Lavorare con i file](files.md), [Utilizzo delle richieste pull](pull-requests.md) e. [Gestione dei rami](branches.md) [Utilizzo delle preferenze dell'utente](user-preferences.md)
**Topics**
+ [Crea un commit in AWS CodeCommit](how-to-create-commit.md)
+ [Visualizza i dettagli del commit in AWS CodeCommit](how-to-view-commit-details.md)
+ [Confronta i commit in AWS CodeCommit](how-to-compare-commits.md)
+ [Commenta un commit in AWS CodeCommit](how-to-commit-comment.md)
+ [Crea un tag Git in AWS CodeCommit](how-to-create-tag.md)
+ [Visualizza i dettagli del tag Git in AWS CodeCommit](how-to-view-tag-details.md)
+ [Eliminare un tag Git in AWS CodeCommit](how-to-delete-tag.md)
# Crea un commit in AWS CodeCommit
Quando si crea il primo commit per un nuovo repository, si utilizza il comando AWS CLI and. **put-file** Questo crea il primo commit e consente di creare e specificare il ramo predefinito per il nuovo repository. Puoi usare Git o the AWS CLI per creare un commit in un CodeCommit repository. Se il repository locale è connesso a un CodeCommit repository, usi Git per inviare il commit dal repository locale al repository. CodeCommit Per creare un commit direttamente nella CodeCommit console, vedi e. [Creare o aggiungere un file a un AWS CodeCommit repository](how-to-create-file.md) [Modifica il contenuto di un file in un AWS CodeCommit repository](how-to-edit-file.md)
**Nota**
Come best practice, ti consigliamo di utilizzare le ultime versioni supportate di AWS CLI, Git e altri software. Se utilizzi il AWS CLI, assicurati che sia installata una versione recente per assicurarti di utilizzare una versione che contenga il `create-commit` comando.
**Topics**
+ [Crea il primo commit per un repository utilizzando il AWS CLI](#how-to-create-first-commit)
+ [Crea un commit usando un client Git](#how-to-create-commit-git)
+ [Crea un commit usando il AWS CLI](#how-to-create-commit-cli)
## Crea il primo commit per un repository utilizzando il AWS CLI
È possibile utilizzare il AWS CLI `put-file` comando and per creare il primo commit per un repository. Using **put-file** crea un primo commit che aggiunge un file al repository vuoto e crea un ramo con il nome specificato. Designa il nuovo ramo come ramo predefinito per il repository.
**Nota**
Per utilizzare AWS CLI i comandi con CodeCommit, installa il. AWS CLI Per ulteriori informazioni, consulta [Guida di riferimento alla riga di comando](cmd-ref.md).
## Per creare il primo commit per un repository utilizzando il AWS CLI
1. Sul tuo computer locale, crea il file che desideri aggiungere come primo file al CodeCommit repository. Una pratica comune consiste nel creare un file `README.md` markdown che spieghi lo scopo di questo repository agli altri utenti del repository. Se includi un `README.md` file, il contenuto del file viene visualizzato automaticamente nella parte inferiore della pagina dei **codici** relativa al repository nella console. CodeCommit
1. Dal terminale o dalla riga di comando, eseguire il comando **put-file**, specificando:
+ Il nome del repository in cui desideri aggiungere il primo file.
+ Il nome del ramo che desideri creare come ramo predefinito.
+ Il percorso locale del file. La sintassi utilizzata per questo percorso varia a seconda del sistema operativo locale.
+ Il nome del file da aggiungere, incluso il percorso in cui il file aggiornato è archiviato nel repository.
+ Il nome utente e l'e-mail che desideri associare a questo file.
+ Un messaggio di commit che spiega perché è stato aggiunto il file.
Il nome utente, l'indirizzo e-mail e il messaggio di commit sono facoltativi, ma possono aiutare gli altri utenti a sapere chi ha apportato la modifica e perché. Se non fornisci un nome utente, per CodeCommit impostazione predefinita utilizza il tuo nome utente IAM o una derivazione del login della console come nome dell'autore.
Ad esempio, per aggiungere un file denominato *README.md* con il contenuto del file codificato in base 6 di esempio a un repository denominato un ramo denominato*MyDemoRepo*: *development*
```
aws codecommit put-file --repository-name MyDemoRepo --branch-name development --file-path README.md --file-content "EXAMPLE0123456789example0123456789EXAMPLE1" --name "Mary Major" --email "mary_major@example.com" --commit-message "I added a quick readme for our new team repository."
```
Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente:
```
{
"commitId": "724caa36EXAMPLE",
"blobId": "a8a94062EXAMPLE",
"treeId": "08b2fc73EXAMPLE"
}
```
## Crea un commit usando un client Git
Puoi creare commit usando un client Git installato sul tuo computer locale e poi inviarli al tuo CodeCommit repository.
1. Completare i prerequisiti, tra cui [Configurazione ](setting-up.md).
**Importante**
Se non è stata completata la configurazione, non è possibile collegarsi o eseguire il commit nel repository usando Git.
1. Assicurarsi che un commit sia stato creato nel ramo corretto. Per consultare un elenco di rami disponibili e scoprire quale ramo è attualmente impostato per l'utilizzo, eseguire **git branch**. Vengono visualizzati tutti i rami. Viene visualizzato un asterisco (`*`) accanto al ramo corrente. Per passare a un altro ramo, eseguire **git checkout *branch-name***. Se questo è il tuo primo commit, esegui il **git config ** comando per configurare il tuo client Git per creare un ramo iniziale con il nome che vuoi usare per quel ramo. Ad esempio, se vuoi che il tuo ramo predefinito abbia il nome*development*:
```
git config --local init.defaultBranch development
```
**Suggerimento**
Questo comando è disponibile solo in Git v.2.28 e versioni successive.
Puoi anche eseguire questo comando per impostare il nome del ramo predefinito su tutti **development** i repository appena creati:
```
git config --global init.defaultBranch development
```
1. Apportare una modifica al ramo (ad esempio aggiungere, modificare o eliminare un file).
Ad esempio, nel repository locale, create un file denominato `bird.txt` con il seguente testo:
```
bird.txt
--------
Birds (class Aves or clade Avialae) are feathered, winged, two-legged, warm-blooded, egg-laying vertebrates.
```
1. Eseguire **git status**, che indica che `bird.txt` non è ancora stato incluso in alcun commit in sospeso:
```
...
Untracked files:
(use "git add ..." to include in what will be committed)
bird.txt
```
1. Eseguire **git add bird.txt** per includere il nuovo file nel commit in sospeso.
1. Se si esegue di nuovo **git status**, viene visualizzato un output simile al seguente. Indica che `bird.txt` fa ora parte del commit in sospeso o è nella gestione temporanea del commit:
```
...
Changes to be committed:
(use "git reset HEAD ..." to unstage)
new file: bird.txt
```
1. Per finalizzare il commit, eseguire **git commit** con l'opzione `-m` (ad esempio ** git commit -m "*Adding bird.txt to the repository.*"**). L'opzione `-m` crea il messaggio di commit.
1. Se si esegue di nuovo **git status**, viene visualizzato un output simile al seguente. Indica che il commit è pronto per essere inviato dal repository locale al repository: CodeCommit
```
...
nothing to commit, working directory clean
```
1. Prima di inviare il commit finalizzato dal repository locale al CodeCommit repository, puoi vedere cosa stai inviando eseguendo**git diff --stat *remote-name*/*branch-name***, *remote-name* dov'è il soprannome che il repository locale usa per il CodeCommit repository e *branch-name* il nome del ramo da confrontare.
**Suggerimento**
Per ottenere il nome alternativo, eseguire **git remote**. Per ottenere un elenco di nomi di rami, eseguire **git branch**. Viene visualizzato un asterisco (`*`) accanto al ramo corrente. È inoltre possibile eseguire **git status** per ottenere il nome del ramo corrente.
**Nota**
Se hai clonato il repository, dal punto di vista del repository locale, non è il nome del repository. *remote-name* CodeCommit Quando si clona un repository, viene impostato automaticamente su. *remote-name* `origin`
Ad esempio, **git diff --stat origin/main** restituisce un output simile al seguente:
```
bird.txt | 1 +
1 file changed, 1 insertion(+)
```
L'output presuppone che tu abbia già collegato il repository locale al repository. CodeCommit Per istruzioni, consultare [Connessione a un repository](how-to-connect.md).
1. Quando sei pronto per inviare il commit dal repository locale al CodeCommit repository, esegui**git push *remote-name* *branch-name***, *remote-name* dov'è il soprannome che il repository locale usa per il CodeCommit repository ed *branch-name* è il nome del ramo da inviare al repository. CodeCommit
Ad esempio, l'esecuzione di **git push origin main** restituisce un output simile al seguente:
Per HTTPS:
```
Counting objects: 7, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (5/5), 516 bytes | 0 bytes/s, done.
Total 5 (delta 2), reused 0 (delta 0)
remote:
To https://git-codecommit.us-east-2.amazonaws.com/v1/repos/MyDemoRepo
b9e7aa6..3dbf4dd main -> main
```
Per SSH:
```
Counting objects: 7, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (5/5), 516 bytes | 0 bytes/s, done.
Total 5 (delta 2), reused 0 (delta 0)
remote:
To ssh://git-codecommit.us-east-2.amazonaws.com/v1/repos/MyDemoRepo
b9e7aa6..3dbf4dd main -> main
```
**Suggerimento**
Se si aggiunge l'opzione `-u` a **git push** (ad esempio **git push -u origin main**), è necessario solo eseguire **git push** in futuro per impostare le informazioni di registrazione upstream. Per ottenere le informazioni di registrazione upstream, eseguire **git remote show *remote-name*** (ad esempio, **git remote show origin**).
Per altre opzioni, consulta la documentazione di Git.
## Crea un commit usando il AWS CLI
È possibile utilizzare il AWS CLI `create-commit` comando and per creare un commit per un repository sulla punta di un ramo specificato. Puoi anche creare un commit di unione senza riferimenti per rappresentare i risultati dell'unione di due specificatori di commit. Per ulteriori informazioni, consulta [Creazione di un commit senza riferimenti](how-to-resolve-conflict-pull-request.md#create-unreferenced-merge-commit).
**Nota**
Per utilizzare AWS CLI i comandi con CodeCommit, installa il AWS CLI. Per ulteriori informazioni, consulta [Guida di riferimento alla riga di comando](cmd-ref.md).
**Come creare un commit**
1. Nel computer locale, apportare le modifiche che devono essere sottoposte a commit nel repository CodeCommit.
1. Dal terminale o dalla riga di comando, eseguire il comando **create-commit**, specificando:
+ Il repository in cui si desidera eseguire il commit delle modifiche.
+ Il ramo in cui si desidera eseguire il commit delle modifiche.
+ L'ID commit completo dell'ultimo commit effettuato al ramo, noto anche come commit di estremità o testa o l'ID commit dell'elemento padre.
+ Se mantenere cartelle vuote se le modifiche apportate eliminano il contenuto di queste cartelle. Questo valore è false per impostazione predefinita.
+ Le informazioni sui file che si desidera aggiungere, modificare o eliminare.
+ Il nome utente e l'indirizzo e-mail che si desidera associare a queste modifiche.
+ Un messaggio di commit che illustra perché sono state apportate queste modifiche.
Il nome utente, l'indirizzo e-mail e il messaggio di commit sono facoltativi, ma consentono agli altri utenti di sapere chi ha apportato le modifiche e il motivo. Se non fornisci un nome utente, per CodeCommit impostazione predefinita utilizza il tuo nome utente IAM o una derivazione dell'accesso alla console come nome dell'autore.
Ad esempio, per creare un commit per un repository che aggiunge un `README.md` file a un repository denominato nel ramo. *MyDemoRepo* *main* Il contenuto del file è in Base64 e recita «Benvenuto nel repository del nostro team\$1» :
```
aws codecommit create-commit --repository-name MyDemoRepo --branch-name main --parent-commit-id 4c925148EXAMPLE --put-files "filePath=README.md,fileContent=V2VsY29tZSB0byBvdXIgdGVhbSByZXBvc2l0b3J5IQo="
```
**Suggerimento**
Per ottenere l'ID di commit principale, esegui il comando [get-branch](how-to-view-branch-details.md#how-to-view-branch-details-cli-details).
Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente:
```
{
"commitId": "4df8b524-EXAMPLE",
"treeId": "55b57003-EXAMPLE",
"filesAdded": [
{
"blobId": "5e1c309dEXAMPLE",
"absolutePath": "meeting.md",
"fileMode": "NORMAL"
}
],
"filesDeleted": [],
"filesUpdated": []
}
```
Per creare un commit che apporti modifiche ai file denominati *file1.py* and*file2.txt*, rinomini un file da *picture.png* a *image1.png* e lo sposti da una directory denominata *pictures* a una directory denominata*images*, ed elimini un file denominato *ExampleSolution.py* in un repository denominato *MyDemoRepo* su un ramo denominato il *MyFeatureBranch* cui commit più recente ha un ID di: *4c925148EXAMPLE*
```
aws codecommit create-commit --repository-name MyDemoRepo --branch-name MyFeatureBranch --parent-commit-id 4c925148EXAMPLE --author-name "Saanvi Sarkar"
--email "saanvi_sarkar@example.com" --commit-message "I'm creating this commit to update a variable name in a number of files."
--keep-empty-folders false --put-files '{"filePath": "file1.py", "fileMode": "EXECUTABLE", "fileContent": "bucket_name = sys.argv[1] region = sys.argv[2]"}'
'{"filePath": "file2.txt", "fileMode": "NORMAL", "fileContent": "//Adding a comment to explain the variable changes in file1.py"}' '{"filePath": "images/image1.png",
"fileMode": "NORMAL", "sourceFile": {"filePath": "pictures/picture.png", "isMove": true}}' --delete-files filePath="ExampleSolution.py"
```
**Nota**
La sintassi del **--put-files** segmento varia a seconda del sistema operativo. L'esempio precedente è ottimizzato per utenti Linux, macOS o Unix e utenti Windows con un emulatore Bash. Gli utenti di Windows sulla riga di comando o in Powershell devono utilizzare una sintassi appropriata per tali sistemi.
Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente:
```
{
"commitId": "317f8570EXAMPLE",
"treeId": "347a3408EXAMPLE",
"filesAdded": [
{
"absolutePath": "images/image1.png",
"blobId": "d68ba6ccEXAMPLE",
"fileMode": "NORMAL"
}
],
"filesUpdated": [
{
"absolutePath": "file1.py",
"blobId": "0a4d55a8EXAMPLE",
"fileMode": "EXECUTABLE"
},
{
"absolutePath": "file2.txt",
"blobId": "915766bbEXAMPLE",
"fileMode": "NORMAL"
}
],
"filesDeleted": [
{
"absolutePath": "ExampleSolution.py",
"blobId": "4f9cebe6aEXAMPLE",
"fileMode": "EXECUTABLE"
},
{
"absolutePath": "pictures/picture.png",
"blobId": "fb12a539EXAMPLE",
"fileMode": "NORMAL"
}
]
}
```
# Visualizza i dettagli del commit in AWS CodeCommit
È possibile utilizzare la AWS CodeCommit console per sfogliare la cronologia dei commit in un repository. Questo può aiutarti a individuare le modifiche apportate in un repository, tra cui:
+ Quando sono state apportate le modifiche e chi le ha apportate.
+ Quando i commit specifici sono stati uniti in un ramo.
Visualizzazione della cronologia di commit per un ramo potrebbe anche aiutarti a comprendere la differenza tra i rami. Se utilizzi il tagging, puoi anche visualizzare rapidamente il commit che è stato contrassegnato da un tag e da elementi padre di quel commit con tag. Nella riga di comando, puoi usare Git per visualizzare i dettagli sui commit in un repository locale o in un repository. CodeCommit
## Sfoglia i commit in un repository
È possibile utilizzare la AWS CodeCommit console per sfogliare la cronologia dei commit in un repository. È anche possibile visualizzare un grafico dei commit nel repository e i suoi rami nel corso del tempo. Questo può aiutarti a comprendere la storia del repository, ad esempio quando sono state apportate le modifiche.
**Nota**
L'utilizzo del comando **git rebase** per un rebase delle modifiche di un repository potrebbe causare il malfunzionamento dei commit. Per ulteriori informazioni, consulta [Rebase del ramo Git](https://git-scm.com/book/en/v2/Git-Branching-Rebasing) o la documentazione Git.
**Topics**
+ [Sfoglia la cronologia dei commit di un repository](#how-to-view-commit-details-console-history)
+ [Visualizza un grafico della cronologia dei commit di un repository](#how-to-view-commit-details-console-visualizer)
### Sfoglia la cronologia dei commit di un repository
È possibile cercare la cronologia di commit per un determinato ramo o tag del repository, incluse informazioni sul committer e sul messaggio di commit. È anche possibile visualizzare il codice per un commit.
**Per cercare la cronologia dei commit**
1. Apri la CodeCommit console su [https://console.aws.amazon.com/codesuite/codecommit/home](https://console.aws.amazon.com/codesuite/codecommit/home).
1. In **Repositories (Repository)**, selezionare il repository per il quale si desidera esaminare la cronologia di commit.
1. Nel riquadro di navigazione selezionare **Commits (Commit)**. Nella visualizzazione della cronologia di commit viene visualizzata la cronologia dei commit per il repository del ramo predefinito, nell'ordine cronologico inverso rispetto alla data di commit. La data e l'ora sono in formato UTC. È possibile visualizzare la cronologia dei commit di un ramo differente, selezionando il pulsante di selezione delle visualizzazioni, quindi scegliendo un ramo dall'elenco. Se stai utilizzando i tag nel repository, puoi visualizzare un commit con un tag specifico e i relativi elementi padre scegliendo quel tag nel pulsante di selezione della visualizzazione.
![\[La visualizzazione dei commit nella console\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-commit-list.png)
1. Per visualizzare la differenza tra un commit e il relativo padre e per visualizzare i commenti sulle modifiche, scegli l'ID di commit abbreviato Per ulteriori informazioni, consultare [Confronta un commit con il suo genitore](how-to-compare-commits.md#how-to-compare-commits-parent) e [Commentare un commit](how-to-commit-comment.md). Per visualizzare la differenza tra un commit e qualsiasi altro specificatore di commit, tra cui un ramo, un tag o un ID di commit, consulta [Confrontare due specificatori di commit](how-to-compare-commits.md#how-to-compare-commits-compare).
1. Effettuare una o più delle seguenti operazioni:
+ Per visualizzare la data e l'ora di una modifica, passa con il mouse sulla data di commit.
+ Per visualizzare l'intero ID di commit, copialo, quindi incollalo in un editor di testo o in altre posizioni. **Per copiarlo, scegli Copia ID.**
+ Per visualizzare il codice così com'era al momento del commit, selezionare **Browse (Cerca)**. Il contenuto del repository al momento del commit viene visualizzato nella visualizzazione **Code (Codice)**. Il selettore di visualizzazione mostra il pulsante ID di commit abbreviato invece di un ramo o tag.
### Visualizza un grafico della cronologia dei commit di un repository
Puoi visualizzare un grafico dei commit eseguiti su un repository. La vista **Commit Visualizer (Visualizzatore commit)** è la rappresentazione di un grafo aciclico orientato (DAG) di tutti i commit eseguiti su un ramo del repository. Questa rappresentazione grafica può aiutarti a comprendere quando viene eseguito il commit e le caratteristiche associate che sono state aggiunte o unite. Può aiutarti anche a comprendere quando viene eseguita una modifica in relazione alle altre modifiche.
**Nota**
I commit uniti utilizzando il metodo di avanzamento rapido non vengono visualizzati come righe separate nel grafico di commit.
**Per visualizzare un grafico di commit**
1. Apri la CodeCommit console su [https://console.aws.amazon.com/codesuite/codecommit/home](https://console.aws.amazon.com/codesuite/codecommit/home).
1. In **Repositories (Repository)**, selezionare il repository per il quale si desidera visualizzare il grafico di commit.
1. Nel riquadro di navigazione, scegliere **Commits (Commit)**, quindi selezionare la scheda **Commit visualizer (Visualizzatore commit)**.
![\[Visualizzazione grafica di un repository nella console\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-cv-complex1.png)
Nel grafico di commit, l'ID di commit abbreviato e l'oggetto di ogni messaggio di commit appaiono accanto a quel punto del grafico.
**Nota**
Il grafico può mostrare fino a 35 rami su una pagina. Se sono presenti più di 35 rami, il grafico è troppo complesso per essere visualizzato. È possibile semplificare la visualizzazione in due modi:
Utilizzando il pulsante dello strumento di selezione della visualizzazione per visualizzare il grafico per un determinato ramo.
Incollando l'ID di commit completo nella casella di ricerca per eseguire il rendering del grafico da quel commit.
1. Per eseguire il rendering di un nuovo grafico da un commit, scegliere il punto del grafico che corrisponde al commit. Il pulsante di selezione della visualizzazione passa all'ID commit abbreviato.
![\[Un nuovo grafico con rendering eseguito da un commit specifico\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-cv-commit.png)
## Visualizza i dettagli del commit ()AWS CLI
Git consente di visualizzare i dettagli sui commit. È inoltre possibile utilizzare il AWS CLI per visualizzare i dettagli sui commit in un repository locale o in un CodeCommit repository eseguendo i seguenti comandi:
+ Per visualizzare informazioni su un commit, eseguire **[aws codecommit get-commit](#how-to-view-commit-details-cli-commit)**.
+ Per visualizzare informazioni su più commit, eseguire **[aws codecommit batch-get-commits](#how-to-view-commit-details-cli-batch-get-commits)**.
+ Per visualizzare le informazioni su un commit di unione, eseguire **[aws codecommit get-merge-commit](#how-to-view-commit-details-cli-merge-commit)**.
+ Per visualizzare informazioni sulle modifiche relative a un identificatore di commit (branch, tag, HEAD o altri riferimenti completi, come commit IDs), esegui. **[aws codecommit get-differences](#how-to-view-commit-details-cli-differences)**
+ Per visualizzare i contenuti con codifica base64 di un oggetto blob Git in un repository, eseguire **[aws codecommit get-blob](#how-to-view-commit-details-cli-blob)**.
### Per visualizzare le informazioni su un commit
1. Eseguire il comando **aws codecommit get-commit** specificando:
+ Il nome del CodeCommit repository (con l'`--repository-name`opzione).
+ L'ID commit completo.
Ad esempio, per visualizzare informazioni su un commit con l'ID `317f8570EXAMPLE` in un CodeCommit repository denominato: `MyDemoRepo`
```
aws codecommit get-commit --repository-name MyDemoRepo --commit-id 317f8570EXAMPLE
```
1. In caso di esito positivo, l'output di questo comando include quanto segue:
+ Le informazioni relative all'autore del commit (come configurato in Git), tra cui la data nel formato timestamp e l'offset UTC.
+ Le informazioni sul committer (come configurato in Git), tra cui la data nel formato timestamp e l'UTC offset.
+ L'ID della struttura Git in cui esiste il commit.
+ L'ID commit del commit dell'elemento padre.
+ Il messaggio commit.
Questo è un esempio di output in base al comando di esempio precedente:
```
{
"commit": {
"additionalData": "",
"committer": {
"date": "1484167798 -0800",
"name": "Mary Major",
"email": "mary_major@example.com"
},
"author": {
"date": "1484167798 -0800",
"name": "Mary Major",
"email": "mary_major@example.com"
},
"treeId": "347a3408EXAMPLE",
"parents": [
"4c925148EXAMPLE"
],
"message": "Fix incorrect variable name"
}
}
```
### Per visualizzare le informazioni su un commit di unione
1. Eseguire il comando **get-merge-commit** specificando:
+ Uno specificatore di commit per l'origine dell'unione (con l'opzione **--source-commit-specifier**).
+ Uno specificatore di commit per la destinazione dell'unione (con l'opzione **--destination-commit-specifier**).
+ L'opzione di unione da utilizzare (con l'opzione **--merge-option**).
+ Il nome del repository (con l'opzione **--repository-name**).
Ad esempio, per visualizzare le informazioni su un commit di unione per il ramo di origine denominato *bugfix-bug1234* con un ramo di destinazione denominato *main* utilizzando la *THREE\$1WAY\$1MERGE* strategia in un repository denominato: *MyDemoRepo*
```
aws codecommit get-merge-commit --source-commit-specifier bugfix-bug1234 --destination-commit-specifier main --merge-option THREE_WAY_MERGE --repository-name MyDemoRepo
```
1. Se il comando viene eseguito correttamente, l'output restituisce informazioni simili alle seguenti:
```
{
"sourceCommitId": "c5709475EXAMPLE",
"destinationCommitId": "317f8570EXAMPLE",
"baseCommitId": "fb12a539EXAMPLE",
"mergeCommitId": "ffc4d608eEXAMPLE"
}
```
### Come visualizzare informazioni su più commit
1. Eseguire il comando **batch-get-commits** specificando:
+ Il nome del CodeCommit repository (con l'`--repository-name`opzione).
+ Un elenco completo di commit IDs per ogni commit su cui si desidera visualizzare informazioni.
Ad esempio, per visualizzare informazioni sui commit con IDs `317f8570EXAMPLE` e `4c925148EXAMPLE` in un CodeCommit repository denominato: `MyDemoRepo`
```
aws codecommit batch-get-commits --repository-name MyDemoRepo --commit-ids 317f8570EXAMPLE 4c925148EXAMPLE
```
1. In caso di esito positivo, l'output di questo comando include quanto segue:
+ Le informazioni relative all'autore dei commit (come configurato in Git), tra cui la data nel formato timestamp e l'offset UTC.
+ Le informazioni sui committer (come configurato in Git), tra cui la data nel formato timestamp e l'UTC offset.
+ L' IDs albero Git in cui esiste il commit.
+ Il commit IDs del commit principale.
+ I messaggi commit.
Questo è un esempio di output in base al comando di esempio precedente:
```
{
"commits": [
{
"additionalData": "",
"committer": {
"date": "1508280564 -0800",
"name": "Mary Major",
"email": "mary_major@example.com"
},
"author": {
"date": "1508280564 -0800",
"name": "Mary Major",
"email": "mary_major@example.com"
},
"commitId": "317f8570EXAMPLE",
"treeId": "1f330709EXAMPLE",
"parents": [
"6e147360EXAMPLE"
],
"message": "Change variable name and add new response element"
},
{
"additionalData": "",
"committer": {
"date": "1508280542 -0800",
"name": "Li Juan",
"email": "li_juan@example.com"
},
"author": {
"date": "1508280542 -0800",
"name": "Li Juan",
"email": "li_juan@example.com"
},
"commitId": "4c925148EXAMPLE",
"treeId": "1f330709EXAMPLE",
"parents": [
"317f8570EXAMPLE"
],
"message": "Added new class"
}
}
```
### Per visualizzare informazioni sulle modifiche per un specificatore di commit
1. Eseguire il comando **aws codecommit get-differences** specificando:
+ Il nome del CodeCommit repository (con l'`--repository-name`opzione).
+ Gli specificatori di commit sui quali si desidera ottenere informazioni. È richiesto solo `--after-commit-specifier`. Se non si specifica `--before-commit-specifier`, vengono visualizzati tutti i file correnti relativi a `--after-commit-specifier`.
Ad esempio, per visualizzare informazioni sulle differenze tra i commit con IDs `317f8570EXAMPLE` e `4c925148EXAMPLE` in un CodeCommit repository denominato: `MyDemoRepo`
```
aws codecommit get-differences --repository-name MyDemoRepo --before-commit-specifier 317f8570EXAMPLE --after-commit-specifier 4c925148EXAMPLE
```
1. In caso di esito positivo, l'output di questo comando include quanto segue:
+ Un elenco di differenze, tra cui il tipo di modifica (A per aggiunto, D per eliminato o M per modificato).
+ Le modalità del tipo di modifica del file.
+ L'ID dell'oggetto blob Git che contiene la modifica.
Questo è un esempio di output in base al comando di esempio precedente:
```
{
"differences": [
{
"afterBlob": {
"path": "blob.txt",
"blobId": "2eb4af3bEXAMPLE",
"mode": "100644"
},
"changeType": "M",
"beforeBlob": {
"path": "blob.txt",
"blobId": "bf7fcf28fEXAMPLE",
"mode": "100644"
}
}
]
}
```
### Come visualizzare le informazioni su un oggetto blob Git
1. Eseguire il comando **aws codecommit get-blob** specificando:
+ Il nome del CodeCommit repository (con l'`--repository-name`opzione).
+ L'ID del blob Git (con l'opzione `--blob-id `).
Ad esempio, per visualizzare informazioni su un blob Git con l'ID di `2eb4af3bEXAMPLE` in un CodeCommit repository denominato: `MyDemoRepo`
```
aws codecommit get-blob --repository-name MyDemoRepo --blob-id 2eb4af3bEXAMPLE
```
1. In caso di esito positivo, l'output di questo comando include quanto segue:
+ Il contenuto con codifica base64 del blob, in genere un file.
Ad esempio, l'output del comando precedente dovrebbe essere simile all'esempio seguente:
```
{
"content": "QSBCaW5hcnkgTGFyToEXAMPLE="
}
```
## Visualizza i dettagli del commit (Git)
Prima di seguire questi passaggi, dovresti aver già collegato il repository locale al CodeCommit repository e aver eseguito le modifiche. Per istruzioni, consulta [Connessione a un repository](how-to-connect.md).
Per mostrare le modifiche apportate al commit più recente in un repository, esegui il comando. **git show**
```
git show
```
Il comando genera un output simile al seguente:
```
commit 4f8c6f9d
Author: Mary Major
Date: Mon May 23 15:56:48 2016 -0700
Added bumblebee.txt
diff --git a/bumblebee.txt b/bumblebee.txt
new file mode 100644
index 0000000..443b974
--- /dev/null
+++ b/bumblebee.txt
@@ -0,0 +1 @@
+A bumblebee, also written bumble bee, is a member of the bee genus Bombus, in the family Apidae.
\ No newline at end of file
```
**Nota**
In questo e nei seguenti esempi, commit è IDs stato abbreviato. I commit completi non IDs vengono mostrati.
Per visualizzare le modifiche effettuate, utilizzare il comando **git show** con l'ID di commit:
```
git show 94ba1e60
commit 94ba1e60
Author: John Doe
Date: Mon May 23 15:39:14 2016 -0700
Added horse.txt
diff --git a/horse.txt b/horse.txt
new file mode 100644
index 0000000..080f68f
--- /dev/null
+++ b/horse.txt
@@ -0,0 +1 @@
+The horse (Equus ferus caballus) is one of two extant subspecies of Equus ferus.
```
Per vedere le differenze tra due commit, esegui il **git diff** comando e includi i due commit IDs.
```
git diff ce22850d 4f8c6f9d
```
In questo esempio, la differenza tra i due commit è data dal fatto che sono stati aggiunti due file. Il comando genera un output simile al seguente:
```
diff --git a/bees.txt b/bees.txt
new file mode 100644
index 0000000..cf57550
--- /dev/null
+++ b/bees.txt
@@ -0,0 +1 @@
+Bees are flying insects closely related to wasps and ants, and are known for their role in pollination and for producing honey and beeswax.
diff --git a/bumblebee.txt b/bumblebee.txt
new file mode 100644
index 0000000..443b974
--- /dev/null
+++ b/bumblebee.txt
@@ -0,0 +1 @@
+A bumblebee, also written bumble bee, is a member of the bee genus Bombus, in the family Apidae.
\ No newline at end of file
```
Per usare Git per visualizzare i dettagli sui commit in un repository locale, esegui il **git log** comando:
```
git log
```
Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente:
```
commit 94ba1e60
Author: John Doe
Date: Mon May 23 15:39:14 2016 -0700
Added horse.txt
commit 4c925148
Author: Jane Doe
Date: Mon May 22 14:54:55 2014 -0700
Added cat.txt and dog.txt
```
Per mostrare solo i commit IDs e i messaggi, esegui il **git log --pretty=oneline** comando:
```
git log --pretty=oneline
```
Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente:
```
94ba1e60 Added horse.txt
4c925148 Added cat.txt and dog.txt
```
Per altre opzioni, consulta la documentazione di Git.
# Confronta i commit in AWS CodeCommit
È possibile utilizzare la CodeCommit console per visualizzare le differenze tra gli specificatori di commit in un repository. CodeCommit Puoi visualizzare rapidamente la differenza tra un commit e il relativo padre. Puoi anche confrontare due riferimenti qualsiasi, incluso il commit. IDs
**Topics**
+ [Confronta un commit con il suo genitore](#how-to-compare-commits-parent)
+ [Confrontare due specificatori di commit](#how-to-compare-commits-compare)
## Confronta un commit con il suo genitore
Puoi visualizzare rapidamente la differenza tra un commit e il relativo padre per esaminare il messaggio di commit, il committer e cosa è cambiato.
1. Apri la CodeCommit console su [https://console.aws.amazon.com/codesuite/codecommit/home](https://console.aws.amazon.com/codesuite/codecommit/home).
1. Nella pagina **Repositories (Repository)**, scegliere il repository in cui si desidera visualizzare la differenza tra un commit e il relativo padre.
1. Nel riquadro di navigazione selezionare **Commits (Commit)**.
1. Scegliere l'ID commit abbreviato di qualsiasi commit nell'elenco. La visualizzazione cambia per mostrare i dettagli di questo commit, incluse le differenze tra il commit e il commit padre.
![\[Scegliere l'ID commit abbreviato per mostrare le differenze tra questo commit e il relativo padre\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-commit-changes1.png)
È possibile mostrare le modifiche nei file affiancati (visualizzazione **Split (Doppia)**) o inline (visualizzazione (**Unified (Unificata)**). È anche possibile nascondere o visualizzare le modifiche degli spazi vuoti. È inoltre possibile aggiungere commenti. Per ulteriori informazioni, consulta [Commentare un commit](how-to-commit-comment.md).
**Nota**
Le preferenze per la visualizzazione del codice e per altre impostazioni della console vengono salvate come cookie del browser a ogni modifica. Per ulteriori informazioni, consulta [Utilizzo delle preferenze dell'utente](user-preferences.md).
![\[Modifiche mostrate nella visualizzazione unificata, con le modifiche agli spazi bianchi nascoste\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-commit-changes2c.png)
![\[Modifiche mostrate nella visualizzazione divisa, con un commento su una riga\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-commenting-commenttab.png)
**Nota**
A seconda dello stile finale della riga, dell'editor di codice e da altri fattori, è possibile che vengano visualizzate intere righe aggiunte o eliminate anziché modifiche specifiche di una riga. Il livello di dettaglio corrisponde a quello che viene restituito nel comando **git show** o **git diff**.
1. Per confrontare un commit con il relativo padre dalla scheda **Commit visualizer (Visualizzatore commit)**, scegliere l'ID commit abbreviato. Verranno visualizzati i dettagli del commit, comprese le modifiche tra il commit e il relativo padre.
## Confrontare due specificatori di commit
È possibile visualizzare le differenze tra due specificatori di commit qualsiasi nella CodeCommit console. Gli specificatori di commit sono riferimenti, come branch, tags e commit. IDs
1. [Apri la CodeCommit console su codecommit/homehttps://console.aws.amazon.com/codesuite/.](https://console.aws.amazon.com/codesuite/codecommit/home)
1. Nella pagina **Repositories (Repository)**, selezionare il repository in cui si desidera confrontare commit, rami o commit con tag.
1. Nel riquadro di navigazione scegliere **Commits (Commit)**, quindi selezionare **Compare commits (Confronta commit)**.
![\[Confrontare due specificatori di commit\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-compare-1.png)
1. Utilizza le caselle per confrontare due specificatori di commit.
+ Per confrontare l'estremità di un ramo, scegli il nome del ramo dall'elenco. In tal modo viene selezionato il commit più recente dal ramo per il confronto.
+ Per confrontare un commit con un determinato tag associato, scegliere il nome tag dall'elenco. In tal modo viene selezionato il commit con tag per il confronto.
+ Per confrontare un determinato commit, immettere o incollare l'ID commit nella casella. Per ottenere l'ID commit completo, scegliere **Commits (Commit)** nella barra di navigazione e copiare l'ID commit dall'elenco. **Nella pagina **Confronta i commit**, incolla l'ID di commit completo nella casella di testo e scegli Usa commit ID.**
![\[Confronta rami, tag o commit IDs\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-compare-2.png)
1. Dopo aver selezionato gli specificatori, scegliere **Compare (Confronta)**.
![\[La visualizzazione del confronto tra due rami\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-compare-branches.png)
È possibile mostrare le differenze nei file affiancati (visualizzazione **Split (Doppia)**) o inline (visualizzazione (**Unified (Unificata)**). È anche possibile nascondere o visualizzare le modifiche degli spazi vuoti.
1. Per annullare le opzioni di confronto, scegliere **Cancel (Annulla)**.
# Commenta un commit in AWS CodeCommit
È possibile utilizzare la CodeCommit console per commentare i commit in un repository e visualizzare e rispondere ai commenti di altri utenti sui commit. Questo può aiutarti a discutere le modifiche apportate in un repository, tra cui:
+ Perché sono state apportate modifiche.
+ Se sono necessarie più modifiche.
+ Se le modifiche devono essere unite in un altro ramo.
Puoi commentare un intero commit, un file in un commit oppure una riga o una modifica specifica di un file. È inoltre possibile creare un collegamento a una riga di codice selezionando la riga e quindi copiando l'URL risultante nel browser.
**Nota**
Per ottenere i migliori risultati, usa la funzione di commento quando accedi come utente IAM. La funzionalità dei commenti non è ottimizzata per gli utenti che effettuano l'accesso con le credenziali dell'account radice, l'accesso federato o le credenziali provvisorie.
**Topics**
+ [Visualizza i commenti su un commit in un repository](#how-to-commit-comment-view-console)
+ [Aggiungi e rispondi ai commenti su un commit in un repository](#how-to-commit-comment-add-console)
+ [Visualizza, aggiungi, aggiorna e rispondi ai commenti ()AWS CLI](#how-to-commit-comment-cli)
## Visualizza i commenti su un commit in un repository
È possibile utilizzare la CodeCommit console per visualizzare i commenti su un commit.
**Come visualizzare i commenti su un commit**
1. Apri la CodeCommit console su [https://console.aws.amazon.com/codesuite/codecommit/home](https://console.aws.amazon.com/codesuite/codecommit/home).
1. In **Repositories (Repository)**, selezionare il repository per il quale si desidera esaminare i commenti sui commit.
1. Nel riquadro di navigazione selezionare **Commits (Commit)**. Scegliere l'ID del commit per cui si desidera visualizzare i commenti.
Viene visualizzata la pagina per il commit insieme con i commenti.
## Aggiungi e rispondi ai commenti su un commit in un repository
È possibile utilizzare la CodeCommit console per aggiungere commenti al confronto tra un commit e un commit principale o al confronto tra due commit specificati. Puoi anche rispondere ai commenti con emoji, con i tuoi commenti o entrambi.
### Aggiungi e rispondi ai commenti su un commit (console)
Puoi aggiungere e rispondere ai commenti a un commit con testo ed emoji. I tuoi commenti ed emoji sono contrassegnati come appartenenti all'utente o al ruolo IAM che hai usato per accedere alla console.
**Per aggiungere e rispondere a commenti su un commit**
1. Apri la CodeCommit console su [https://console.aws.amazon.com/codesuite/codecommit/home](https://console.aws.amazon.com/codesuite/codecommit/home).
1. In **Repositories (Repository)**, selezionare il repository in cui si desidera aggiungere un commento sui commit.
1. Nel riquadro di navigazione selezionare **Commits (Commit)**. Scegliere l'ID del commit per cui si desidera aggiungere o rispondere ai commenti.
Viene visualizzata la pagina per il commit insieme con i commenti.
1. Per aggiungere un commento, procedere in uno dei seguenti modi:
+ Per aggiungere un commento generale, in **Comments on changes (Commenti sulle modifiche)**, immettere il commento e quindi scegliere **Save (Salva)**. È possibile utilizzare [Markdown](https://en.wikipedia.org/wiki/Markdown) o immettere il commento in testo normale.
![\[Un commento generale sulle modifiche in un commit.\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-commenting-changecomment.png)
+ Per aggiungere un commento a un file nel commit, individuare il nome del file. Scegliere **Comment on file (Commenta file)**, immettere il commento e quindi selezionare **Save (Salva)**.
![\[Aggiunta di un commento su un file in un commit.\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-commenting-addfilecomment.png)
+ Per aggiungere un commento a una riga modificata nel commit, andare alla riga in cui è presente la modifica. Scegliere l'icona del commento ![\[The comment bubble icon that that indicates that you can leave a comment on that line of code.\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-commentbubble.png), immettere il commento e quindi scegliere **Save (Salva)**.
![\[Aggiunta di un commento su una riga in un commit.\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-commenting-addlinecomment.png)
**Nota**
Puoi modificare il commento dopo averlo salvato. Puoi anche eliminarne il contenuto. Il commento resterà con un messaggio che indica che il contenuto è stato eliminato. Provare a utilizzare la modalità **Preview markdown (Markdown anteprima)** per il commento prima di salvarlo.
1. Per rispondere a commenti su un commit, scegliere **Reply (Rispondi)**. Per rispondere a un commento con un'emoji, scegli l'emoji che desideri dall'elenco. Puoi scegliere solo un'emoji per commento. Se desideri modificare la tua reazione emoji, scegline un'altra dall'elenco o scegli **Nessuna** per rimuovere la reazione.
![\[Aggiungere risposte e reazioni emoji a un commento.\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-commenting-commenttab.png)
### Aggiungi e rispondi ai commenti confrontando due specificatori di commit
Puoi aggiungere commenti a un confronto tra rami, tag o commit.
**Per aggiungere o rispondere a commenti per il confronto di specificatori di commit**
1. [Apri la CodeCommit console su codecommit/homehttps://console.aws.amazon.com/codesuite/.](https://console.aws.amazon.com/codesuite/codecommit/home)
1. In **Repositories (Repository)**, selezionare il repository in cui si desidera confrontare commit, rami o commit con tag.
1. Nel riquadro di navigazione scegliere **Commits (Commit)**, quindi selezionare la scheda **Compare commits (Confronta commit)**.
![\[Confrontare due specificatori di commit\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-compare-1.png)
1. Usare i campi **Destination (Destinazione)** e **Source (Origine)** per confrontare due specificatori di commit. Usa gli elenchi a discesa o incolla il commit. IDs Scegli **Confronta**.
![\[Un risultato di esempio del confronto di un ID commit con un ramo\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-compare-4.png)
1. Effettuare una o più delle seguenti operazioni:
+ Per aggiungere commenti a file o righe, scegliere l'icona del commento ![\[The comment bubble icon that that indicates that you can leave a comment on that line of code.\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-commentbubble.png).
+ Per aggiungere commenti generali sulle modifiche confrontate, andare a **Comments on changes (Commenti sulle modifiche)**.
## Visualizza, aggiungi, aggiorna e rispondi ai commenti ()AWS CLI
È possibile visualizzare, aggiungere, rispondere, aggiornare ed eliminare i contenuti di un commento eseguendo i seguenti comandi:
+ Per visualizzare i commenti sul confronto tra due commit, eseguire **[get-comments-for-compared-commit](#how-to-commit-comment-cli-get-comments)**.
+ Per visualizzare ulteriori informazioni su un commento, eseguire [**get-comment**](#how-to-commit-comment-cli-get-comment-info).
+ Per eliminare i contenuti di un commento creato, eseguire [**delete-comment-content**](#how-to-commit-comment-cli-commit-delete).
+ Per creare un commento sul confronto tra due commit, eseguire [**post-comment-for-compared-commit**](#how-to-commit-comment-cli-comment).
+ Per aggiornare un commento, eseguire [**update-comment**](#how-to-commit-comment-cli-commit-update).
+ Per rispondere a un commento, [**post-comment-reply**](#how-to-commit-comment-cli-commit-reply)esegui.
+ Per rispondere a un commento con un'emoji, corri [**put-comment-reaction**](#how-to-commit-comment-cli-commit-reply-emoji).
+ Per visualizzare le reazioni emoji a un commento, esegui. [**get-comment-reactions**](#how-to-commit-comment-cli-commit-emoji-view)
### Come visualizzare i commenti su un commit
1. Eseguire il comando **get-comments-for-compared-commit** specificando:
+ Il nome del CodeCommit repository (con l'`--repository-name`opzione).
+ L'ID commit completo del commit after per stabilire la direzionalità del confronto (con l'opzione `--after-commit-id option`).
+ L'ID commit completo del commit before per stabilire la direzionalità del confronto (con l'opzione `--before-commit-id`).
+ (Facoltativo) Un token di enumerazione per restituire il batch dei risultati successivo (con l'opzione `--next-token`).
+ (Facoltativo) Un numero intero non negativo per limitare il numero di risultati restituiti (con l'opzione `--max-results`).
Ad esempio, per visualizzare i commenti fatti sul confronto tra due commit in un repository chiamato *MyDemoRepo*:
```
aws codecommit get-comments-for-compared-commit --repository-name MyDemoRepo --before-commit-id 6e147360EXAMPLE --after-commit-id 317f8570EXAMPLE
```
1. Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente:
```
{
"commentsForComparedCommitData": [
{
"afterBlobId": "1f330709EXAMPLE",
"afterCommitId": "317f8570EXAMPLE",
"beforeBlobId": "80906a4cEXAMPLE",
"beforeCommitId": "6e147360EXAMPLE",
"comments": [
{
"authorArn": "arn:aws:iam::111111111111:user/Li_Juan",
"clientRequestToken": "123Example",
"commentId": "ff30b348EXAMPLEb9aa670f",
"content": "Whoops - I meant to add this comment to the line, not the file, but I don't see how to delete it.",
"creationDate": 1508369768.142,
"deleted": false,
"CommentId": "123abc-EXAMPLE",
"lastModifiedDate": 1508369842.278,
"callerReactions": [],
"reactionCounts":
{
"SMILE" : 6,
"THUMBSUP" : 1
}
},
{
"authorArn": "arn:aws:iam::111111111111:user/Li_Juan",
"clientRequestToken": "123Example",
"commentId": "553b509bEXAMPLE56198325",
"content": "Can you add a test case for this?",
"creationDate": 1508369612.240,
"deleted": false,
"commentId": "456def-EXAMPLE",
"lastModifiedDate": 1508369612.240,
"callerReactions": [],
"reactionCounts":
{
"THUMBSUP" : 2
}
}
],
"location": {
"filePath": "cl_sample.js",
"filePosition": 1232,
"relativeFileVersion": "after"
},
"repositoryName": "MyDemoRepo"
}
],
"nextToken": "exampleToken"
}
```
### Per visualizzare i dettagli di un commento su un commit
1. Eseguire il comando **get-comment** specificando l'ID commento generato dal sistema. Esempio:
```
aws codecommit get-comment --comment-id ff30b348EXAMPLEb9aa670f
```
1. Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente:
```
{
"comment": {
"authorArn": "arn:aws:iam::111111111111:user/Li_Juan",
"clientRequestToken": "123Example",
"commentId": "ff30b348EXAMPLEb9aa670f",
"content": "Whoops - I meant to add this comment to the line, but I don't see how to delete it.",
"creationDate": 1508369768.142,
"deleted": false,
"commentId": "",
"lastModifiedDate": 1508369842.278,
"callerReactions": [],
"reactionCounts":
{
"SMILE" : 6,
"THUMBSUP" : 1
}
}
}
```
### Per eliminare i contenuti di un commento su un commit
1. Eseguire il comando **delete-comment-content** specificando l'ID commento generato dal sistema. Esempio:
```
aws codecommit delete-comment-content --comment-id ff30b348EXAMPLEb9aa670f
```
**Nota**
Puoi eliminare il contenuto di un commento solo se hai applicato la AWSCode CommitFullAccess politica o se hai l'`DeleteCommentContent`autorizzazione impostata su **Consenti**.
1. Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente:
```
{
"comment": {
"creationDate": 1508369768.142,
"deleted": true,
"lastModifiedDate": 1508369842.278,
"clientRequestToken": "123Example",
"commentId": "ff30b348EXAMPLEb9aa670f",
"authorArn": "arn:aws:iam::111111111111:user/Li_Juan",
"callerReactions": [],
"reactionCounts":
{
"CLAP" : 1
}
}
}
```
### Come creare un commento su un commit
1. Eseguire il comando **post-comment-for-compared-commit** specificando:
+ Il nome del CodeCommit repository (con l'`--repository-name`opzione).
+ L'ID commit completo del commit after per stabilire la direzionalità del confronto (con l'opzione `--after-commit-id `).
+ L'ID commit completo del commit before per stabilire la direzionalità del confronto (con l'opzione `--before-commit-id`).
+ Un token di idempotenza univoco generato dal client (con l'opzione **--client-request-token**).
+ Il contenuto del commento (con l'opzione **--content**).
+ Un elenco di informazioni sulla posizione in cui inserire il commento, tra cui:
+ Il nome del file che viene confrontato, inclusa l'estensione e la sottodirectory, se presente (con l'attributo **filePath**).
+ Il numero di riga della modifica in un file confrontato (con l'attributo **filePosition**).
+ Se il commento sulla modifica è before o after nel confronto tra i rami di origine e di destinazione (con l'attributo **relativeFileVersion**).
Ad esempio, per aggiungere il commento *"Can you add a test case for this?"* sulla modifica al *cl\$1sample.js* file nel confronto tra due commit in un repository denominato: *MyDemoRepo*
```
aws codecommit post-comment-for-compared-commit --repository-name MyDemoRepo --before-commit-id 317f8570EXAMPLE --after-commit-id 5d036259EXAMPLE --client-request-token 123Example --content "Can you add a test case for this?" --location filePath=cl_sample.js,filePosition=1232,relativeFileVersion=AFTER
```
1. Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente:
```
{
"afterBlobId": "1f330709EXAMPLE",
"afterCommitId": "317f8570EXAMPLE",
"beforeBlobId": "80906a4cEXAMPLE",
"beforeCommitId": "6e147360EXAMPLE",
"comment": {
"authorArn": "arn:aws:iam::111111111111:user/Li_Juan",
"clientRequestToken": "",
"commentId": "553b509bEXAMPLE56198325",
"content": "Can you add a test case for this?",
"creationDate": 1508369612.203,
"deleted": false,
"commentId": "abc123-EXAMPLE",
"lastModifiedDate": 1508369612.203,
"callerReactions": [],
"reactionCounts": []
},
"location": {
"filePath": "cl_sample.js",
"filePosition": 1232,
"relativeFileVersion": "AFTER"
},
"repositoryName": "MyDemoRepo"
}
```
### Come aggiornare un commento su un commit
1. Eseguire il comando **update-comment** specificando l'ID commento generato dal sistema e i contenuti con cui si desidera sostituire i contenuti esistenti.
Ad esempio, per aggiungere il contenuto *"Fixed as requested. I'll update the pull request."* a un commento con un ID di: *442b498bEXAMPLE5756813*
```
aws codecommit update-comment --comment-id 442b498bEXAMPLE5756813 --content "Fixed as requested. I'll update the pull request."
```
1. Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente:
```
{
"comment": {
"authorArn": "arn:aws:iam::111111111111:user/Li_Juan",
"clientRequestToken": "",
"commentId": "442b498bEXAMPLE5756813",
"content": "Fixed as requested. I'll update the pull request.",
"creationDate": 1508369929.783,
"deleted": false,
"lastModifiedDate": 1508369929.287,
"callerReactions": [],
"reactionCounts":
{
"THUMBSUP" : 2
}
}
}
```
### Per rispondere a un commento su un commit
1. Per pubblicare la risposta a un commento in una richiesta pull, eseguire il comando **post-comment-reply** specificando:
+ L'ID generato dal sistema del commento a cui si desidera rispondere (con l'opzione **--in-reply-to**).
+ Un token di idempotenza univoco generato dal client (con l'opzione **--client-request-token**).
+ Il contenuto della risposta (con l'opzione **--content**).
Ad esempio, per aggiungere la risposta *"Good catch. I'll remove them."* al commento con l'ID generato dal sistema di: *abcd1234EXAMPLEb5678efgh*
```
aws codecommit post-comment-reply --in-reply-to abcd1234EXAMPLEb5678efgh --content "Good catch. I'll remove them." --client-request-token 123Example
```
1. Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente:
```
{
"comment": {
"authorArn": "arn:aws:iam::111111111111:user/Li_Juan",
"clientRequestToken": "123Example",
"commentId": "442b498bEXAMPLE5756813",
"content": "Good catch. I'll remove them.",
"creationDate": 1508369829.136,
"deleted": false,
"CommentId": "abcd1234EXAMPLEb5678efgh",
"lastModifiedDate": 150836912.221,
"callerReactions": [],
"reactionCounts": []
}
}
```
### Come rispondere a un commento su un commit con un’emoji
1. Per rispondere a un commento in una pull request con un'emoji o per modificare il valore della tua reazione emoji, esegui il **put-comment-reaction** comando, specificando:
+ L'ID generato dal sistema del commento a cui vuoi rispondere con un'emoji.
+ Il valore della reazione che desideri aggiungere o aggiornare. I valori accettabili includono emoji, codici brevi e valori Unicode supportati.
I seguenti valori sono supportati per gli emoji in: CodeCommit
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/how-to-commit-comment.html)
Ad esempio, per aggiungere l'emoji *:thumbsup:* al commento con l'ID generato dal sistema di: *abcd1234EXAMPLEb5678efgh*
```
aws codecommit put-comment-reaction --comment-id abcd1234EXAMPLEb5678efgh --reaction-value :thumbsup:
```
1. Se il comando ha esito positivo, non produce alcun output.
### Come visualizzare le reazioni emoji a un commento
1. Per visualizzare le reazioni emoji a un commento, inclusi gli utenti che hanno reagito con tali emoji, esegui il **get-comment-reactions** comando, specificando l'ID del commento generato dal sistema.
Ad esempio, per visualizzare le reazioni emoji al commento con l'ID generato dal sistema di: *abcd1234EXAMPLEb5678efgh*
```
aws codecommit get-comment-reactions --comment-id abcd1234EXAMPLEb5678efgh
```
1. Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente:
```
{
"reactionsForComment": {
[
{
"reaction": {
"emoji:"👍",
"shortCode": "thumbsup",
"unicode": "U+1F44D"
},
"users": [
"arn:aws:iam::123456789012:user/Li_Juan",
"arn:aws:iam::123456789012:user/Mary_Major",
"arn:aws:iam::123456789012:user/Jorge_Souza"
]
},
{
"reaction": {
"emoji": "👎",
"shortCode": "thumbsdown",
"unicode": "U+1F44E"
},
"users": [
"arn:aws:iam::123456789012:user/Nikhil_Jayashankar"
]
},
{
"reaction": {
"emoji": "😕",
"shortCode": "confused",
"unicode": "U+1F615"
},
"users": [
"arn:aws:iam::123456789012:user/Saanvi_Sarkar"
]
}
]
}
}
```
# Crea un tag Git in AWS CodeCommit
È possibile utilizzare un tag Git per contrassegnare un commit con un'etichetta che aiuta gli altri utenti del repository a comprenderne l'importanza. Per creare un tag Git in un CodeCommit repository, puoi usare Git da un repository locale connesso al CodeCommit repository. Dopo aver creato un tag Git nel repository locale, puoi usarlo **git push --tags** per inviarlo al CodeCommit repository.
Per ulteriori informazioni, consulta [Visualizza i dettagli del tag](how-to-view-tag-details.md).
## Usa Git per creare un tag
Segui questi passaggi per utilizzare Git da un repository locale per creare un tag Git in un CodeCommit repository.
In questi passaggi, supponiamo che tu abbia già collegato il repository locale al repository. CodeCommit Per istruzioni, consulta [Connessione a un repository](how-to-connect.md).
1. Esegui il **git tag *new-tag-name* *commit-id*** comando, dove *new-tag-name* è il nome del nuovo tag Git e *commit-id* l'ID del commit da associare al tag Git.
Ad esempio, il comando seguente crea un tag Git denominato `beta` e lo associa all'ID commit `dc082f9a...af873b88`:
```
git tag beta dc082f9a...af873b88
```
1. Per inviare il nuovo tag Git dal repository locale al CodeCommit repository, esegui il **git push *remote-name* *new-tag-name*** comando, where *remote-name* è il nome del CodeCommit repository ed *new-tag-name* è il nome del nuovo tag Git.
Ad esempio, per inviare un nuovo tag Git denominato `beta` a un CodeCommit repository denominato`origin`:
```
git push origin beta
```
**Nota**
Per inviare tutti i nuovi tag Git dal repository locale al CodeCommit repository, esegui. **git push --tags**
Per assicurarti che il tuo repository locale sia aggiornato con tutti i tag Git nel CodeCommit repository, esegui **git fetch** seguito da. **git fetch --tags**
Per altre opzioni, consulta la documentazione di Git.
# Visualizza i dettagli del tag Git in AWS CodeCommit
In Git, un tag è un'etichetta che è possibile applicare a un riferimento come un commit per contrassegnarlo con le informazioni che potrebbero essere importanti per altri utenti del repository. Ad esempio, è possibile assegnare un tag al commit che era il punto di rilascio beta di un progetto con il tag **beta**. Per ulteriori informazioni, consulta [Usa Git per creare un tag](how-to-create-tag.md#how-to-create-tag-git). I tag Git sono diversi dai tag del repository. Per ulteriori informazioni su come usare i tag del repository, consulta [Aggiunta di un tag a un repository](how-to-tag-repository-add.md).
Puoi usare la AWS CodeCommit console per visualizzare le informazioni sui tag Git nel tuo repository, inclusi la data e il messaggio di commit del commit a cui fa riferimento ogni tag Git. Utilizzando la console, è possibile confrontare il commit contrassegnato dal tag con il commit principale del ramo predefinito nel proprio repository. Come per qualsiasi altro commit, è anche possibile visualizzare il codice nel punto di tale tag Git.
Puoi anche usare Git dal tuo terminale o dalla riga di comando per visualizzare i dettagli sui tag Git in un repository locale.
**Topics**
+ [Visualizza i dettagli dei tag (console)](#how-to-view-tag-details-console)
+ [Visualizza i dettagli del tag Git (Git)](#how-to-view-tag-details-git)
## Visualizza i dettagli dei tag (console)
Usa la AWS CodeCommit console per visualizzare rapidamente un elenco di tag Git per il tuo repository e i dettagli sui commit a cui fanno riferimento i tag Git.
1. [Apri la CodeCommit console su codecommit/home. https://console.aws.amazon.com/codesuite/](https://console.aws.amazon.com/codesuite/codecommit/home)
1. In **Repositories (Repository)**, selezionare il nome del repository in cui si desidera visualizzare i tag.
1. Nel riquadro di navigazione, scegliere **Git tags (Tag Git)**.
![\[Una visualizzazione di tag in un repository\]](http://docs.aws.amazon.com/it_it/codecommit/latest/userguide/images/codecommit-tags-view.png)
1. Esegui una delle seguenti operazioni:
+ Per visualizzare il codice così com'era al commit, selezionare il nome del tag Git.
+ Per visualizzare i dettagli del commit, tra cui il messaggio di commit completo, il committer e l'autore, scegliere l'ID di commit abbreviato.
## Visualizza i dettagli del tag Git (Git)
Per usare Git per visualizzare i dettagli sui tag Git in un repository locale, esegui uno dei seguenti comandi:
+ [git tag](#how-to-view-tag-details-git-tag) per visualizzare una lista dei nomi dei tag Git.
+ [git show](#how-to-view-tag-details-git-show) per visualizzare informazioni su un tag Git specifico.
+ [git ls-remote](#how-to-view-tag-details-git-remote) per visualizzare informazioni sui tag Git in un CodeCommit repository.
**Nota**
Per assicurarti che il tuo repository locale sia aggiornato con tutti i tag Git presenti nel CodeCommit repository, esegui **git fetch** seguito da. **git fetch --tags**
Nei passaggi seguenti, supponiamo che tu abbia già collegato il repository locale a un repository. CodeCommit Per istruzioni, consulta [Connessione a un repository](how-to-connect.md).
### Per visualizzare un elenco di tag Git in un repository locale
1. Eseguire il comando **git tag**:
```
git tag
```
1. Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente:
```
beta
release
```
**Nota**
Se non è stato definito alcun tag, **git tag** non restituisce alcun valore.
Per altre opzioni, consulta la documentazione di Git.
### Per visualizzare informazioni su un tag Git in un repository locale
1. Esegui il comando **git show *tag-name***. Ad esempio, per visualizzare informazioni su un tag Git denominato `beta`, eseguire:
```
git show beta
```
1. Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente:
```
commit 317f8570...ad9e3c09
Author: John Doe
Date: Tue Sep 23 13:49:51 2014 -0700
Added horse.txt
diff --git a/horse.txt b/horse.txt
new file mode 100644
index 0000000..df42ff1
--- /dev/null
+++ b/horse.txt
@@ -0,0 +1 @@
+The horse (Equus ferus caballus) is one of two extant subspecies of Equus ferus
\ No newline at end of file
```
**Nota**
Per uscire dell'output delle informazioni del tag Git, digitare **:q**.
Per altre opzioni, consulta la documentazione di Git.
### Per visualizzare informazioni sui tag Git in un CodeCommit repository
1. Esegui il comando **git ls-remote --tags**.
```
git ls-remote --tags
```
1. In caso di successo, questo comando produce come output un elenco dei tag Git nel CodeCommit repository:
```
129ce87a...70fbffba refs/tags/beta
785de9bd...59b402d8 refs/tags/release
```
Se non sono stati definiti tag Git, **git ls-remote --tags** restituisce una riga vuota.
Per altre opzioni, consulta la documentazione di Git.
# Eliminare un tag Git in AWS CodeCommit
Per eliminare un tag Git in un CodeCommit repository, usa Git da un repository locale connesso al CodeCommit repository.
## Usa Git per eliminare un tag Git
Segui questi passaggi per utilizzare Git da un repository locale per eliminare un tag Git in un CodeCommit repository.
Questi passaggi sono scritti partendo dal presupposto che tu abbia già collegato il repository locale al repository. CodeCommit Per istruzioni, consulta [Connessione a un repository](how-to-connect.md).
1. Per eliminare il tag Git dal repository locale, esegui il **git tag -d *tag-name*** comando where *tag-name* è il nome del tag Git che desideri eliminare.
**Suggerimento**
Per ottenere un elenco di nomi di tag Git, eseguire **git tag**.
Ad esempio, per eliminare un tag Git nel repository locale denominato`beta`:
```
git tag -d beta
```
1. Per eliminare il tag Git dal CodeCommit repository, esegui il **git push *remote-name* --delete *tag-name*** comando dove *remote-name* è il soprannome che il repository locale usa per il CodeCommit repository ed *tag-name* è il nome del tag Git che desideri eliminare dal repository. CodeCommit
**Suggerimento**
Per ottenere un elenco dei nomi dei CodeCommit repository e i relativi URLs nomi, esegui il comando. **git remote -v**
Ad esempio, per eliminare un tag Git denominato `beta` nel CodeCommit repository denominato`origin`:
```
git push origin --delete beta
```