

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

# Aggiungere un'azione interregionale in CodePipeline
<a name="actions-create-cross-region"></a>

AWS CodePipeline include una serie di azioni che consentono di configurare, testare e distribuire risorse per il processo di rilascio automatico. Puoi aggiungere azioni alla tua pipeline che si trovano in una AWS regione diversa dalla tua pipeline. Quando un Servizio AWS è il fornitore di un'azione e questo type/provider tipo di azione si trova in una AWS regione diversa dalla pipeline, si tratta di un'azione interregionale. 

**Nota**  
Le azioni interregionali sono supportate e possono essere create solo nelle AWS regioni in cui CodePipeline sono supportate. Per un elenco delle AWS regioni supportate per CodePipeline, consulta[Quote in AWS CodePipeline](limits.md).

Puoi utilizzare la console o CloudFormation aggiungere azioni interregionali nelle pipeline. AWS CLI

**Nota**  
Alcuni tipi di azioni CodePipeline potrebbero essere disponibili solo in determinate AWS regioni. Tieni inoltre presente che potrebbero esserci AWS regioni in cui è disponibile un tipo di azione, ma non è disponibile un AWS provider specifico per quel tipo di azione.

Quando crei o modifichi una pipeline, devi disporre di un bucket di artefatti nella regione della pipeline e di un bucket di artefatti per ogni regione in cui prevedi di eseguire un'operazione. Per ulteriori informazioni sul parametro `ArtifactStores`, vedi [CodePipeline riferimento alla struttura della tubazione](reference-pipeline-structure.md).

**Nota**  
CodePipeline gestisce la copia di artefatti da una AWS regione all'altra durante l'esecuzione di azioni interregionali.

Se si utilizza la console per creare una pipeline o azioni interregionali, i bucket di artefatti predefiniti vengono configurati nelle regioni in cui sono presenti le azioni. CodePipeline Quando utilizzi AWS CLI CloudFormation, o un SDK per creare una pipeline o azioni interregionali, fornisci il bucket di artefatti per ogni regione in cui sono presenti azioni. 

**Nota**  
È necessario creare il bucket di artefatti e la chiave di crittografia nella stessa area dell'azione AWS Interregionale e nello stesso account della pipeline.

Non è possibile creare operazioni tra regioni per i seguenti tipi di operazione:
+ Operazioni di origine
+ Operazioni di terze parti
+ Operazioni personalizzate

**Nota**  
Quando si utilizza Cross-region Lambda invoke action CodePipeline in, lo stato dell'esecuzione lambda che utilizza [PutJobSuccessResult[PutJobFailureResult](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutJobFailureResult.html)](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutJobSuccessResult.html)e deve essere inviato alla AWS regione in cui è presente la funzione Lambda e non alla regione in cui esiste. CodePipeline 

Quando una pipeline include un'azione interregionale come parte di una fase, CodePipeline replica solo gli artefatti di input dell'azione Cross-region dalla regione della pipeline alla regione dell'azione.

**Nota**  
La regione della pipeline e la regione in cui sono gestite le risorse di rilevamento delle modifiche CloudWatch agli eventi rimangono invariate. La regione in cui è ospitata la pipeline non cambia.



## Gestione di operazioni tra regioni in una pipeline (console)
<a name="actions-cross-region-console"></a>

Puoi utilizzare la CodePipeline console per aggiungere un'azione interregionale a una pipeline esistente. Per creare una nuova pipeline con operazioni tra regioni utilizzando la procedura guidata di creazione pipeline, consulta [Crea una pipeline personalizzata (console)](pipelines-create.md#pipelines-create-console).

Nella console, crei un'operazione tra regioni in una fase della pipeline scegliendo il provider dell'operazione e il campo **Regione** che elenca le risorse create in quella regione per quel provider. Quando aggiungi un'operazione tra regioni, CodePipeline utilizza un bucket di artefatti separato nella regione dell'operazione. Per ulteriori informazioni sui bucket di artefatti tra più regioni, consulta [CodePipeline riferimento alla struttura della tubazione](reference-pipeline-structure.md).

### Aggiunta di un'operazione tra regioni a una fase della pipeline (console)
<a name="actions-cross-region-console-add"></a>

Utilizza la console per aggiungere un'operazione tra regioni a una pipeline.

**Nota**  
Se la pipeline è in esecuzione quando le modifiche vengono salvate, l'esecuzione non viene portata a termine.

**Per aggiungere un'operazione tra regioni**

1. [Accedi alla console all'indirizzo http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. Seleziona la pipeline, quindi scegli **Edit (Modifica)**.

1. Nella parte inferiore del diagramma, scegli **\+ Add stage (\+ Aggiungi fase)** se stai aggiungendo una nuova fase oppure scegli **Edit stage (Modifica fase)** se vuoi aggiungere l'operazione a una fase esistente.

1. In **Edit: <Stage> (Modifica: <Fase>)**, scegli **\+ Add action group (\+ Aggiungi gruppo di operazioni)** per aggiungere un'operazione seriale. In alternativa, scegli **\+ Add action (\+ Aggiungi operazione)** per aggiungere un'operazione parallela.

1. Nella pagina **Edit action (Modifica operazione)**:

   1. In **Nome operazione** immetti un nome per l'operazione tra regioni.

   1. In **Azione provider (Provider operazione)**, scegli il provider dell'operazione.

   1. In **Regione**, scegli la AWS regione in cui hai creato o intendi creare la risorsa per l'azione. Quando la regione viene selezionata, le risorse disponibili per la regione sono elencate per la selezione. Il campo **Regione** indica dove vengono create le AWS risorse per questo tipo di azione e tipo di provider. Questo campo viene visualizzato solo per le azioni in cui il fornitore dell'azione è un Servizio AWS. Per impostazione predefinita, il campo **Regione** è lo Regione AWS stesso della pipeline.

   1. In **Input artifacts (Artefatti di input)** scegli l'input appropriato dalla fase precedente. Ad esempio, se la fase precedente è una fase di origine, scegli. **SourceArtifact**

   1. Completa tutti i campi obbligatori per il provider dell'operazione che stai configurando.

   1. In **Output artifacts (Artefatti di output)** scegli l'output appropriato per la prossima fase. Ad esempio, se la fase successiva è una fase di distribuzione, scegli **BuildArtifact**.

   1. Scegli **Save** (Salva).

1. In **Edit: <Stage> (Modifica: <Fase>)**, scegli **Done (Fatto)**.

1. Scegli **Save** (Salva).

### Modifica di un'operazione tra regioni in una fase della pipeline (console)
<a name="actions-cross-region-console-edit"></a>

Utilizza la console per modificare un'operazione tra regioni esistente in una pipeline.

**Nota**  
Se la pipeline è in esecuzione quando le modifiche vengono salvate, l'esecuzione non viene portata a termine.

**Per modificare un'operazione tra regioni**

1. Accedi alla console all'indirizzo [https://console.aws.amazon.com/codesuite/codepipeline/home.](https://console.aws.amazon.com/codesuite/codepipeline/home.)

1. Seleziona la pipeline, quindi scegli **Edit (Modifica)**.

1. Scegli **Edit stage (Modifica fase)**.

1. In **Edit: <Stage> (Modifica: <Fase>)**, scegli l'icona per modificare un'operazione esistente.

1. Nella pagina **Edit action (Modifica operazione)**, apporta modifiche ai campi in base alle esigenze.

1. In **Edit: <Stage> (Modifica: <Fase>)**, scegli **Done (Fatto)**.

1. Scegli **Save** (Salva).

### Eliminazione di un'operazione tra regioni da una fase della pipeline (console)
<a name="actions-cross-region-console-delete"></a>

Utilizza la console per eliminare un'operazione tra regioni esistente da una pipeline.

**Nota**  
Se la pipeline è in esecuzione quando le modifiche vengono salvate, l'esecuzione non viene portata a termine.

**Per eliminare un'operazione tra regioni**

1. Accedi alla console all'indirizzo [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. Seleziona la pipeline, quindi scegli **Edit (Modifica)**.

1. Scegli **Edit stage (Modifica fase)**.

1. In **Edit: <Stage> (Modifica: <Fase>)**, scegli l'icona per eliminare un'operazione esistente.

1. In **Edit: <Stage> (Modifica: <Fase>)**, scegli **Done (Fatto)**.

1. Scegli **Save** (Salva).

## Aggiunta di un'operazione tra regioni a una pipeline (CLI)
<a name="actions-cross-region-cli"></a>

È possibile utilizzare il AWS CLI per aggiungere un'azione interregionale a una pipeline esistente.

Per creare un'azione interregionale in una fase di pipeline con AWS CLI, aggiungete l'azione di configurazione insieme a un campo opzionale. `region` Devi avere inoltre già creato un bucket di artefatti nella regione dell'operazione. Invece di fornire il parametro `artifactStore` della pipeline della singola regione, utilizza il parametro `artifactStores` per includere un elenco del bucket di artefatti di ogni regione.

**Nota**  
In questa procedura dettagliata e nei relativi esempi, {{RegionA}} è indicata la regione in cui viene creata la pipeline. Ha accesso al bucket {{RegionA}} Amazon S3 utilizzato per archiviare gli artefatti della pipeline e al ruolo di servizio utilizzato da. CodePipeline {{RegionB}}è la regione in cui vengono creati l' CodeDeploy applicazione, il gruppo di distribuzione e il ruolo di servizio utilizzati. CodeDeploy 

### Prerequisiti
<a name="actions-create-cross-region-prereq"></a>

Devi aver creato i seguenti elementi:
+ Una pipeline in {{RegionA}} entrata. 
+ Un bucket di artefatti Amazon S3 in. {{RegionB}} 
+ Le risorse per la tua azione, ad esempio CodeDeploy l'applicazione e il gruppo di distribuzione per un'azione di distribuzione tra regioni, in. {{RegionB}}

### Aggiunta di un'operazione tra regioni a una pipeline (CLI)
<a name="actions-create-cross-region-cli"></a>

Usa AWS CLI per aggiungere un'azione interregionale a una pipeline.

**Per aggiungere un'operazione tra regioni**

1. Per inserire una pipeline{{RegionA}}, eseguite il **get-pipeline** comando per copiare la struttura della pipeline in un file JSON. Ad esempio, per una pipeline denominata `MyFirstPipeline`, esegui il seguente comando: 

   ```
   aws codepipeline get-pipeline --name {{MyFirstPipeline}} >{{pipeline.json}}
   ```

   Questo comando non restituisce alcun valore, ma nella directory in cui è stato eseguito dovrebbe comparire il file creato.

1. Aggiungi il campo `region` per aggiungere una nuova fase con l'operazione tra regioni che include la regione e le risorse per l'operazione. L'esempio JSON seguente aggiunge una fase di distribuzione con un'azione di distribuzione tra regioni in cui si trova il provider, in una nuova regione. CodeDeploy `us-east-1`

   ```
    {
                   "name": "Deploy",
                   "actions": [
                       {
                           "inputArtifacts": [
                               {
                                   "name": "SourceArtifact"
                               }
                           ],
                           "name": "Deploy",
                           "region": "{{RegionB}}",
                           "actionTypeId": {
                               "category": "Deploy",
                               "owner": "AWS",
                               "version": "1",
                               "provider": "CodeDeploy"
                           },
                           "outputArtifacts": [],
                           "configuration": {
                               "ApplicationName": "{{name}}",
                               "DeploymentGroupName": "{{name}}"
                           },
                           "runOrder": 1
                       }
   ```

1. Nella struttura della pipeline, rimuovi il campo `artifactStore` e aggiungi la mappa `artifactStores` per la nuova operazione tra regioni. La mappatura deve includere una voce per ogni AWS regione in cui sono presenti azioni. Per ogni voce della mappatura, le risorse devono trovarsi nella rispettiva AWS regione. Nell'esempio seguente, `ID-A` è l'ID della chiave di crittografia per{{RegionA}}, ed `ID-B` è l'ID della chiave di crittografia per{{RegionB}}.

   ```
   "artifactStores":{  
      "{{RegionA}}":{  
         "{{encryptionKey}}":{  
            "id":"{{ID-A}}",
            "type":"KMS"
         },
         "location":"{{Location1}}",
         "type":"S3"
      },
      "{{RegionB}}":{  
         "{{encryptionKey}}":{  
            "id":"{{ID-B}}",
            "type":"KMS"
         },
         "location":"{{Location2}}",
         "type":"S3"
      }
   }
   ```

   L'esempio di JSON seguente mostra il bucket us-west-2 come `my-storage-bucket` e aggiunge il nuovo bucket us-east-1 denominato `my-storage-bucket-us-east-1`.

   ```
           "artifactStores": {
               "us-west-2": {
                   "type": "S3",
                   "location": "my-storage-bucket"
               },
               "us-east-1": {
                   "type": "S3",
                   "location": "my-storage-bucket-us-east-1"
               }
           },
   ```

1. Se stai utilizzando la struttura della pipeline recuperata tramite il comando **get-pipeline**, rimuovi le righe `metadata` dal file JSON. In caso contrario, il comando **update-pipeline** non è in grado di utilizzarlo. Rimuovi le righe `"metadata": { }` e i campi `"created"`, `"pipelineARN"` e `"updated"`.

   Ad esempio, rimuovere dalla struttura le seguenti righe: 

   ```
   "metadata": {  
     "pipelineArn": "arn:aws:codepipeline:{{region}}:{{account-ID}}:{{pipeline-name}}",
     "created": "{{date}}",
     "updated": "{{date}}"
     }
   ```

   Salvare il file.

1. Per applicare le modifiche, eseguire il comando **update-pipeline**, specificando il file JSON della pipeline:
**Importante**  
Assicurarsi di includere `file://` prima del nome del file. Questo è obbligatorio in questo comando.

   ```
   aws codepipeline update-pipeline --cli-input-json file://{{pipeline.json}}
   ```

   Questo comando restituisce l'intera struttura della pipeline modificata. L'output è simile a quello riportato di seguito.

   ```
   {
       "pipeline": {
           "version": 4,
           "roleArn": "{{ARN}}",
           "stages": [
               {
                   "name": "Source",
                   "actions": [
                       {
                           "inputArtifacts": [],
                           "name": "Source",
                           "actionTypeId": {
                               "category": "Source",
                               "owner": "AWS",
                               "version": "1",
                               "provider": "CodeCommit"
                           },
                           "outputArtifacts": [
                               {
                                   "name": "SourceArtifact"
                               }
                           ],
                           "configuration": {
                               "PollForSourceChanges": "false",
                               "BranchName": "main",
                               "RepositoryName": "MyTestRepo"
                           },
                           "runOrder": 1
                       }
                   ]
               },
               {
                   "name": "Deploy",
                   "actions": [
                       {
                           "inputArtifacts": [
                               {
                                   "name": "SourceArtifact"
                               }
                           ],
                           "name": "Deploy",
                           "region": "us-east-1",
                           "actionTypeId": {
                               "category": "Deploy",
                               "owner": "AWS",
                               "version": "1",
                               "provider": "CodeDeploy"
                           },
                           "outputArtifacts": [],
                           "configuration": {
                               "ApplicationName": "{{name}}",
                               "DeploymentGroupName": "{{name}}"
                           },
                           "runOrder": 1
                       }
                   ]
               }
           ],
           "name": "AnyCompanyPipeline",
           "artifactStores": {
               "us-west-2": {
                   "type": "S3",
                   "location": "my-storage-bucket"
               },
               "us-east-1": {
                   "type": "S3",
                   "location": "my-storage-bucket-us-east-1"
               }
           }
       }
   }
   ```
**Nota**  
Il comando **update-pipeline** arresta la pipeline. Se è in corso di elaborazione una versione durante l'esecuzione del comando **update-pipeline**, tale elaborazione viene arrestata. Per elaborare tale versione utilizzando la pipeline aggiornata, devi avviare manualmente la pipeline. Utilizza il comando **`start-pipeline-execution`** per avviare manualmente la pipeline.

1. Dopo aver aggiornato la pipeline, l'azione Interregionale viene visualizzata nella console.  
![Una vista generale di una pipeline che include un'operazione tra regioni.](http://docs.aws.amazon.com/it_it/codepipeline/latest/userguide/images/cross-region-icon.png)

## Aggiunta di un'operazione tra regioni a una pipeline (CloudFormation)
<a name="actions-create-cross-region-cfn"></a>

È possibile utilizzare CloudFormation per aggiungere un'azione interregionale a una pipeline esistente.

**Per aggiungere un'azione interregionale con CloudFormation**

1. Aggiungi il parametro `Region` alla risorsa `ActionDeclaration` nel modello, come illustrato in questo esempio:

   ```
   ActionDeclaration:
                 Type: Object
                 Properties:
                   ActionTypeId:
                     Type: ActionTypeId
                     Required: true
                   Configuration:
                     Type: Map
                   InputArtifacts:
                     Type: Array
                     ItemType:
                       Type: InputArtifact
                   Name:
                     Type: String
                     Required: true
                   OutputArtifacts:
                     Type: Array
                     ItemType:
                       Type: OutputArtifact
                   RoleArn:
                     Type: String
                   RunOrder:
                     Type: Integer
                   {{Region:}}
                     {{Type: String}}
   ```

1. In `Mappings`, aggiungi la mappa della regione come illustrato in questo esempio, relativo a una mappatura denominata `SecondRegionMap` che mappa i valori per le chiavi `RegionA` e `RegionB`. Nella risorsa `Pipeline`, nel campo `artifactStore`, aggiungi la mappa `artifactStores` per la nuova operazione tra regioni come segue:

   ```
   Mappings:
     SecondRegionMap:
       {{RegionA}}:
         SecondRegion: "{{RegionB}}"
       {{RegionB}}:
         SecondRegion: "{{RegionA}}"
   
   ...
   
             Properties:
               ArtifactStores:
                 -
                   Region: {{RegionB}}
                   ArtifactStore:
                     Type: "S3"
                     Location: test-cross-region-artifact-store-bucket-{{RegionB}}
                 -
                   Region: {{RegionA}}
                   ArtifactStore:
                     Type: "S3"
                     Location: test-cross-region-artifact-store-bucket-{{RegionA}}
   ```

   Il seguente esempio YAML mostra il {{RegionA}} bucket come `us-west-2` e aggiunge il nuovo bucket: {{RegionB}} `eu-central-1`

   ```
   Mappings:
     SecondRegionMap:
       us-west-2:
         SecondRegion: "eu-central-1"
       eu-central-1:
         SecondRegion: "us-west-2"
   
   ...
   
             Properties:
               ArtifactStores:
                 -
                   Region: eu-central-1
                   ArtifactStore:
                     Type: "S3"
                     Location: test-cross-region-artifact-store-bucket-eu-central-1
                 -
                   Region: us-west-2
                   ArtifactStore:
                     Type: "S3"
                     Location: test-cross-region-artifact-store-bucket-us-west-2
   ```

1. Salva il modello aggiornato nel computer locale e quindi apri la console CloudFormation .

1. Seleziona lo stack e scegli **Create Change Set for Current Stack (Crea set di modifiche per lo stack corrente)**. 

1. Carica il modello e quindi visualizza le modifiche elencate in CloudFormation. Queste sono le modifiche da apportare allo stack. Le nuove risorse dovrebbero essere visibili nell'elenco.

1. Scegli **Esegui**.