

Amazon non CodeCatalyst è più aperta a nuovi clienti. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per ulteriori informazioni, consulta [Come migrare da CodeCatalyst](migration.md).

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

# Tutorial: caricare artefatti su Amazon S3
<a name="build-deploy"></a>

[In questo tutorial, imparerai come caricare artefatti in un bucket Amazon S3 utilizzando un flusso di lavoro CodeCatalyst [Amazon che include un paio](workflows-concepts.md#workflows-concepts-workflows) di azioni di compilazione.](workflows-concepts.md#workflows-concepts-actions) Queste azioni vengono eseguite in serie all'avvio del flusso di lavoro. La prima azione di compilazione genera due file `Hello.txt` e `Goodbye.txt` li raggruppa in un elemento di compilazione. La seconda azione di compilazione carica l'artefatto su Amazon S3. Configurerai il flusso di lavoro in modo che venga eseguito ogni volta che invii un commit al tuo repository di origine.

**Topics**
+ [Prerequisiti](#build-deploy-tut-prereqs)
+ [Fase 1: Creare un AWS ruolo](#build-deploy-tut-role)
+ [Fase 2: creare un bucket Amazon S3](#build-deploy-tut-artifact)
+ [Fase 3: Creare un archivio di sorgenti](#deploy-tut-lambda-cfn-source)
+ [Fase 4: Creare un flusso di lavoro](#build-deploy-tut-workflow.title)
+ [Passaggio 5: verifica i risultati](#build-deploy.s3.verify)
+ [Eliminazione](#deploy-tut-lambda-cfn-clean-up)

## Prerequisiti
<a name="build-deploy-tut-prereqs"></a>

Prima di iniziare, avrai bisogno di:
+ È necessario uno CodeCatalyst **spazio** con un AWS account connesso. Per ulteriori informazioni, consulta [Creazione di uno spazio](spaces-create.md).
+ Nel tuo spazio, hai bisogno di un progetto vuoto chiamato:

  ```
  codecatalyst-artifact-project
  ```

  Usa l'opzione **Inizia da zero** per creare questo progetto.

  Per ulteriori informazioni, consulta [Creare un progetto vuoto in Amazon CodeCatalyst](projects-create.md#projects-create-empty).
+ Nel tuo progetto, hai bisogno di un CodeCatalyst **ambiente** chiamato:

  ```
  codecatalyst-artifact-environment
  ```

  Configura questo ambiente come segue:
  + Scegli qualsiasi tipo, ad esempio **Development**.
  + Connect il tuo AWS account.
  + Per il **ruolo IAM predefinito**, scegli un ruolo qualsiasi. Specificherai un ruolo diverso in seguito.

  Per ulteriori informazioni, consulta [Implementazione in e Account AWS VPCs](deploy-environments.md).

## Fase 1: Creare un AWS ruolo
<a name="build-deploy-tut-role"></a>

In questo passaggio, crei un ruolo AWS IAM che successivamente assegnerai all'azione di compilazione nel tuo flusso di lavoro. Questo ruolo concede all'azione di CodeCatalyst compilazione l'autorizzazione ad accedere al tuo AWS account e scrivere su Amazon S3 dove verrà archiviato il tuo artefatto. **Il ruolo è chiamato ruolo Build.**

**Nota**  
Se hai già un ruolo di costruzione che hai creato per un altro tutorial, puoi utilizzarlo anche per questo tutorial. Assicurati solo che disponga delle autorizzazioni e della politica di fiducia mostrate nella procedura seguente.

Per ulteriori informazioni sui ruoli IAM, consulta i [ruoli IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) nella *Guida per l'AWS AWS Identity and Access Management utente*.

**Per creare un ruolo di costruzione**

1. Crea una politica per il ruolo, come segue:

   1. Accedi a AWS.

   1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

   1. Nel riquadro di navigazione, scegli **Policy**.

   1. Scegli **Create Policy** (Crea policy).

   1. Scegliere la scheda **JSON**.

   1. Eliminare il codice esistente.

   1. Incolla il codice seguente:

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

****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Sid": "VisualEditor0",
                  "Effect": "Allow",
                  "Action": [
                      "s3:PutObject",
                      "s3:ListBucket"
                  ],
                  "Resource": "*"
              }
          ]
      }
      ```

------
**Nota**  
La prima volta che il ruolo viene utilizzato per eseguire azioni del flusso di lavoro, utilizza il carattere jolly nell'informativa sulla politica delle risorse, quindi definisci la politica inserendo il nome della risorsa dopo che è disponibile.  

      ```
      "Resource": "*"
      ```

   1. Scegliere **Next: Tags (Successivo: Tag)**.

   1. Scegliere **Next:Review (Successivo: Rivedi)**.

   1. In **Nome**, inserisci:

      ```
      codecatalyst-s3-build-policy
      ```

   1. Scegli **Crea policy**.

      Ora hai creato una politica di autorizzazioni.

1. Crea il ruolo di costruzione, come segue:

   1. Nel pannello di navigazione, scegli **Ruoli** e quindi **Crea ruolo**.

   1. Scegli una **politica di fiducia personalizzata**.

   1. Elimina la politica di fiducia personalizzata esistente.

   1. Aggiungi la seguente politica di fiducia personalizzata:

   1. Scegli **Next (Successivo)**.

   1. Nelle **politiche di autorizzazione**, cerca `codecatalyst-s3-build-policy` e seleziona la relativa casella di controllo.

   1. Scegli **Next (Successivo)**.

   1. Per il **nome del ruolo**, inserisci:

      ```
      codecatalyst-s3-build-role
      ```

   1. Per la **descrizione del ruolo**, inserisci:

      ```
      CodeCatalyst build role
      ```

   1. Scegli **Crea ruolo**.

   Ora hai creato un ruolo di sviluppo con una politica di fiducia e una politica di autorizzazioni.

## Fase 2: creare un bucket Amazon S3
<a name="build-deploy-tut-artifact"></a>

In questo passaggio, crei un bucket Amazon S3 in cui verranno caricati gli elementi `Hello.txt` e gli `Goodbye.txt` artefatti.

**Come creare un bucket Amazon S3.**

1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

1. Nel riquadro principale, scegli **Crea bucket**.

1. Per il **nome del bucket, inserisci**:

   ```
   codecatalyst-artifact-bucket
   ```

1. In **AWS Region (Regione)**, scegliere una Regione. Questo tutorial presuppone che tu abbia scelto **US West (Oregon) us-west-2**. Per informazioni sulle regioni supportate da Amazon S3, consulta gli [endpoint e le quote di Amazon Simple Storage Service](https://docs.aws.amazon.com/general/latest/gr/s3.html) nel. *Riferimenti generali di AWS*

1. **Nella parte inferiore della pagina, scegli Crea bucket.**

1. Copia il nome del bucket che hai appena creato, ad esempio:

   ```
   codecatalyst-artifact-bucket
   ```

Ora hai creato un bucket chiamato **codecatalyst-artifact-bucket** nella regione us-west-2 degli Stati Uniti occidentali (Oregon).

## Fase 3: Creare un archivio di sorgenti
<a name="deploy-tut-lambda-cfn-source"></a>

In questo passaggio, creerai un repository di origine in. CodeCatalyst Questo repository viene utilizzato per archiviare il file di definizione del flusso di lavoro del tutorial. 

Per ulteriori informazioni sugli archivi di origine, vedere. [Creazione di un repository di sorgenti](source-repositories-create.md)

**Per creare un archivio dei sorgenti**

1. Apri la CodeCatalyst console all'indirizzo [https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Vai al tuo progetto,`codecatalyst-artifact-project`.

1. Nel riquadro di navigazione, scegli **Codice**, quindi scegli **Archivi di origine.** 

1. Scegli **Aggiungi repository**, quindi scegli **Crea** repository.

1. Nel **nome del repository, inserisci:**

   ```
   codecatalyst-artifact-source-repository
   ```

1. Scegli **Create** (Crea).

Ora hai creato un repository chiamato. `codecatalyst-artifact-source-repository`

## Fase 4: Creare un flusso di lavoro
<a name="build-deploy-tut-workflow.title"></a>

In questo passaggio, crei un flusso di lavoro costituito dai seguenti elementi costitutivi eseguiti in sequenza:
+ Un trigger: questo trigger avvia l'esecuzione automatica del flusso di lavoro quando si invia una modifica all'archivio di origine. Per ulteriori informazioni sui trigger, consulta. [L'avvio di un flusso di lavoro viene eseguito automaticamente utilizzando i trigger](workflows-add-trigger.md)
+ Un'azione di compilazione chiamata`GenerateFiles`: al momento del trigger, l'`GenerateFiles`azione crea due file `Hello.txt` e `Goodbye.txt` li impacchetta in un elemento di output chiamato. `codecatalystArtifact`
+ Un'altra azione di compilazione chiamata`Upload`: al termine dell'`GenerateFiles`azione, l'`Upload`azione esegue il AWS CLI comando `aws s3 sync` per caricare i file nel `codecatalystArtifact` e nel repository di origine nel bucket Amazon S3. AWS CLI Viene fornito preinstallato e preconfigurato sulla piattaforma di CodeCatalyst elaborazione, quindi non è necessario installarlo o configurarlo.

  Per ulteriori informazioni sul software preconfezionato sulla piattaforma di elaborazione, consulta CodeCatalyst . [Specificazione delle immagini dell'ambiente di runtime](build-images.md) *Per ulteriori informazioni sul `aws s3 sync` comando AWS CLI's, consulta [sync](https://docs.aws.amazon.com/cli/latest/reference/s3/sync.html) nel Command Reference.AWS CLI *

Per ulteriori informazioni sull'azione di compilazione, consulta[Creazione con flussi di lavoro](build-workflow-actions.md).

**Come creare un flusso di lavoro**

1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.**

1. **Scegli Crea flusso di lavoro.**

1. Elimina il codice di esempio YAML.

1. Aggiungi il seguente codice YAML:
**Nota**  
Nel codice YAML che segue, puoi omettere la sezione se lo `Connections:` desideri. Se ometti questa sezione, devi assicurarti che il ruolo specificato nel campo **Default IAM role** nel tuo ambiente includa le autorizzazioni e le politiche di fiducia descritte in. [Fase 1: Creare un AWS ruolo](#build-deploy-tut-role) Per ulteriori informazioni sulla configurazione di un ambiente con un ruolo IAM predefinito, consulta. [Creazione di un ambiente](deploy-environments-creating-environment.md)

   ```
   Name: codecatalyst-artifact-workflow
   SchemaVersion: 1.0
   
   Triggers:
     - Type: Push
       Branches:
         - main   
   Actions:
     GenerateFiles:
       Identifier: aws/build@v1
       Configuration: 
         Steps:
           # Create the output files.
           - Run: echo "Hello, World!" > "Hello.txt"
           - Run: echo "Goodbye!" > "Goodbye.txt"
       Outputs:
         Artifacts:
           - Name: codecatalystArtifact
             Files:
               - "**/*"
     Upload:
       Identifier: aws/build@v1
       DependsOn: 
         - GenerateFiles
       Environment:
         Name: codecatalyst-artifact-environment
         Connections:
           - Name: codecatalyst-account-connection
             Role: codecatalyst-s3-build-role
       Inputs:
         Artifacts:
           - codecatalystArtifact
       Configuration: 
         Steps:
           # Upload the output artifact to the S3 bucket.
           - Run: aws s3 sync . s3://codecatalyst-artifact-bucket
   ```

   Nel codice precedente, sostituisci:
   + *codecatalyst-artifact-environment*con il nome dell'ambiente in cui hai creato[Prerequisiti](#build-deploy-tut-prereqs).
   + *codecatalyst-account-connection*con il nome della connessione all'account in cui hai creato[Prerequisiti](#build-deploy-tut-prereqs).
   + *codecatalyst-s3-build-role*con il nome del ruolo di build in cui hai creato[Fase 1: Creare un AWS ruolo](#build-deploy-tut-role).
   + *codecatalyst-artifact-bucket*con il nome dell'Amazon S3 in cui hai creato. [Fase 2: creare un bucket Amazon S3](#build-deploy-tut-artifact)

   Per informazioni sulle proprietà di questo file, consulta[Crea e testa azioni YAML](build-action-ref.md).

1. (Facoltativo) Scegliete **Convalida** per assicurarvi che il codice YAML sia valido prima di eseguire il commit.

1. Scegli **Applica**.

1. Nella finestra di dialogo **Conferma flusso di lavoro**, inserisci quanto segue:

   1. Per il **nome del file Workflow**, lasciate il valore predefinito,`codecatalyst-artifact-workflow`.

   1. Per il **messaggio** di conferma, inserisci:

      ```
      add initial workflow file
      ```

   1. Per **Repository**, scegli **codecatalyst-artifact-source-repository**.

   1. Per il **nome del ramo**, scegli **principale**.

   1. Scegli **Applica**.

   Ora hai creato un flusso di lavoro. L'esecuzione di un flusso di lavoro viene avviata automaticamente a causa del trigger definito nella parte superiore del flusso di lavoro. In particolare, quando hai eseguito il commit (e inviato) del `codecatalyst-artifact-workflow.yaml` file nell'archivio di origine, il trigger ha avviato l'esecuzione del flusso di lavoro.

**Per visualizzare il flusso di lavoro in corso**

1. **Nel riquadro di navigazione, scegli **CI/CD**, quindi scegli Flussi di lavoro.**

1. Scegli il flusso di lavoro che hai appena creato:. `codecatalyst-artifact-workflow`

1. Scegli **GenerateFiles**di vedere lo stato di avanzamento della prima azione di costruzione.

1. Scegli **Carica** per vedere lo stato di avanzamento della seconda azione di build.

1. Al termine dell'azione di **caricamento**, procedi come segue:
   + Se l'esecuzione del flusso di lavoro è riuscita, passate alla procedura successiva.
   + Se l'esecuzione del flusso di lavoro non è riuscita, scegli **Registri** per risolvere il problema.

## Passaggio 5: verifica i risultati
<a name="build-deploy.s3.verify"></a>

Dopo l'esecuzione del flusso di lavoro, accedi al servizio Amazon S3 e cerca nel tuo *codecatalyst-artifact-bucket* bucket. Ora dovrebbe includere i seguenti file e cartelle:

```
.
|— .aws/
|— .git/
|Goodbye.txt
|Hello.txt
|REAME.md
```

I `Hello.txt` file `Goodbye.txt` e sono stati caricati perché facevano parte dell'`codecatalystArtifact`artefatto. I `README.md` file `.aws/``.git/`, e sono stati caricati perché erano presenti nel repository di origine.

## Eliminazione
<a name="deploy-tut-lambda-cfn-clean-up"></a>

Effettua la pulizia CodeCatalyst ed AWS evita che questi servizi vengano addebitati.

**Per pulire CodeCatalyst**

1. Apri la CodeCatalyst console all'[indirizzo https://codecatalyst.aws/](https://codecatalyst.aws/).

1. Eliminare il repository di `codecatalyst-artifact-source-repository` origine.

1. Eliminare il `codecatalyst-artifact-workflow` flusso di lavoro.

**Per ripulire AWS**

1. Esegui la pulizia in Amazon S3, come segue:

   1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)

   1. Elimina i file nel `codecatalyst-artifact-bucket` bucket.

   1. Eliminare il `codecatalyst-artifact-bucket` bucket.

1. Esegui la pulizia in IAM, come segue:

   1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

   1. Eliminare il `codecatalyst-s3-build-policy`.

   1. Eliminare il `codecatalyst-s3-build-role`.