Crea una pipeline CodePipeline che utilizzi le risorse di un altro account AWS - AWS CodePipeline
Prerequisito: creare una chiave di crittografia AWS KMSFase 1: impostazione delle policy e dei ruoli dell'accountFase 2: modifica della pipeline

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

Crea una pipeline CodePipeline che utilizzi le risorse di un altro account AWS

Potrebbe essere necessario creare una pipeline che utilizza le risorse create o gestite da un altro account AWS . Ad esempio, potresti voler utilizzare un account per la tua pipeline e un altro per le tue CodeDeploy risorse.

Nota

Quando si crea una pipeline con operazioni da più account, è necessario configurare le operazioni in modo che possano ancora accedere agli artefatti entro i limiti delle pipeline tra account. Le seguenti limitazioni si applicano alle operazioni tra account:

  • In generale, un'operazione può consumare solo un artefatto se:

    • L'operazione è nello stesso account dell'account della pipeline OPPURE

    • L'artefatto è stato creato nell'account della pipeline per un'operazione in un altro account OPPURE

    • L'artefatto è stato prodotto da un'operazione precedente nello stesso account dell'azione

    In altre parole, non è possibile passare un artefatto da un account a un altro se nessun account è l'account della pipeline.

  • Le operazioni tra account non sono supportate per i seguenti tipi di operazione:

    • Operazioni di compilazione Jenkins

Per questo esempio, è necessario creare una chiave AWS Key Management Service (AWS KMS) da utilizzare, aggiungere la chiave alla pipeline e configurare le politiche e i ruoli degli account per consentire l'accesso tra account. Per una AWS KMS chiave, è possibile utilizzare l'ID della chiave, la chiave o l'ARNalias. ARN

Nota

Gli alias vengono riconosciuti solo nell'account che ha creato la KMS chiave. Per le azioni tra account, puoi utilizzare solo l'ID o la chiave ARN per identificare la chiave. Le operazioni tra account comportano l'utilizzo del ruolo dell'altro account (AccountB), pertanto specificando l'ID chiave verrà utilizzata la chiave dell'altro account (AccountB).

In questa procedura dettagliata e nei relativi esempi, AccountA è l'account originariamente utilizzato per creare la pipeline. Ha accesso al bucket Amazon S3 utilizzato per archiviare gli artefatti della pipeline e al ruolo di servizio utilizzato da. AWS CodePipelineAccountB è l'account originariamente utilizzato per creare l' CodeDeploy applicazione, il gruppo di distribuzione e il ruolo di servizio utilizzati da. CodeDeploy

In AccountA per modificare una pipeline per utilizzare l' CodeDeploy applicazione creata da AccountB, AccountA deve:

  • Richiedi l'ID ARN o l'ID dell'account di AccountB (in questa procedura dettagliata, AccountB L'ID è 012ID_ACCOUNT_B).

  • Crea o utilizza una chiave gestita dal AWS KMS cliente nella regione per la pipeline e concedi le autorizzazioni per utilizzare quella chiave per il ruolo di servizio (CodePipeline_Service_Role) e AccountB.

  • Crea una policy sui bucket di Amazon S3 che garantisca AccountB accesso al bucket Amazon S3 (ad esempio, codepipeline-us-east-2-1234567890).

  • Crea una politica che consenta AccountA assumere un ruolo configurato da AccountBe allega tale policy al ruolo di servizio (CodePipeline_Service_Role).

  • Modifica la pipeline per utilizzare la AWS KMS chiave gestita dal cliente anziché la chiave predefinita.

In AccountB per consentire l'accesso alle sue risorse a una pipeline creata in AccountA, AccountB deve:

  • Richiedi l'ID ARN o l'ID dell'account di AccountA (in questa procedura dettagliata, AccountA L'ID è 012ID_ACCOUNT_A).

  • Crea una policy applicata al ruolo dell'EC2istanza Amazon configurato per CodeDeploy che consenta l'accesso al bucket Amazon S3 (codepipeline-us-east-2-1234567890).

  • Crea una policy applicata al ruolo dell'EC2istanza Amazon configurato per CodeDeploy che consenta l'accesso alla chiave gestita dal AWS KMS cliente utilizzata per crittografare gli artefatti della pipeline in AccountA.

  • Configura e assegna un ruolo (IAMCrossAccount_Role) con una politica di relazioni di fiducia che consenta il ruolo CodePipeline di servizio in AccountA per assumere il ruolo.

  • Crea una policy che consenta l'accesso alle risorse di distribuzione richieste dalla pipeline e collegala a CrossAccount_Role.

  • Crea una policy che consenta l'accesso al bucket Amazon S3 (codepipeline-us-east-2-1234567890) e collegalo a CrossAccount_Role.

Prerequisito: creare una chiave di crittografia AWS KMS

Le chiavi gestite dal cliente sono specifiche di una regione, così come tutte AWS KMS le chiavi. È necessario creare la AWS KMS chiave gestita dal cliente nella stessa regione in cui è stata creata la pipeline (ad esempio,). us-east-2

Per creare una chiave gestita dal cliente in AWS KMS

  1. Accedi al AWS Management Console con AccountA e apri la AWS KMS console.

  2. A sinistra, scegli Chiavi gestite dal cliente.

  3. Scegliere Create key (Crea chiave). In Configura chiave, lasciare selezionata l'impostazione predefinita simmetrica e scegliere Avanti.

  4. In Alias, inserisci un alias da utilizzare per questa chiave (ad esempio, PipelineName-Key). Facoltativamente, fornisci una descrizione e dei tag per questa chiave, quindi scegli Avanti.

  5. In Definisci le autorizzazioni amministrative chiave, scegli il ruolo o i ruoli che desideri ricoprire come amministratori per questa chiave, quindi scegli Avanti.

  6. In Definisci le autorizzazioni di utilizzo delle chiavi, in Questo account, seleziona il nome del ruolo di servizio per la pipeline (ad esempio, _Service_Role). CodePipeline In Altri AWS account, scegli Aggiungi un altro account. AWS Inserisci l'ID dell'account per AccountB per completareARN, quindi scegli Avanti.

  7. In Visualizza un'anteprima della policy della chiave, rivedere la policy e quindi scegliere Fine.

  8. Dall'elenco delle chiavi, scegliete l'alias della chiave e copiatelo ARN (ad esempio,arn:aws:kms:us-east-2:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE). Ciò è richiesto quando si modifica la pipeline e si configurano le policy.

Fase 1: impostazione delle policy e dei ruoli dell'account

Dopo aver creato la AWS KMS chiave, devi creare e allegare politiche che consentano l'accesso da più account. Ciò richiede azioni da parte di entrambi AccountA e AccountB.

Configura le politiche e i ruoli nell'account che creerà la pipeline (AccountA)

Per creare una pipeline che utilizzi CodeDeploy risorse associate a un altro AWS account, AccountA deve configurare le politiche sia per il bucket Amazon S3 utilizzato per archiviare gli artefatti sia per il ruolo del servizio per. CodePipeline

Per creare una policy per il bucket Amazon S3 che conceda l'accesso a AccountB (console)

  1. Accedi al con AWS Management Console AccountA e apri la console Amazon S3 all'indirizzo. https://console.aws.amazon.com/s3/

  2. Nell'elenco dei bucket Amazon S3, scegli il bucket Amazon S3 in cui sono archiviati gli elementi per le tue pipeline. codepipeline-region-1234567EXAMPLEQuesto bucket si chiama, dove region è la AWS regione in cui è stata creata la pipeline e 1234567EXAMPLE è un numero casuale a dieci cifre che assicura che il nome del bucket sia univoco (ad esempio, codepipeline-us-east-2-1234567890).

  3. Nella pagina dei dettagli del bucket Amazon S3, scegli Proprietà.

  4. Nel riquadro delle proprietà, espandere Permissions (Autorizzazioni), quindi scegliere Add bucket policy (Aggiungi policy di bucket).

    Nota

    Se una policy è già associata al tuo bucket Amazon S3, scegli Modifica policy bucket. È possibile quindi aggiungere le dichiarazioni nell'esempio seguente alla policy esistente. Per aggiungere una nuova politica, scegli il link e segui le istruzioni nel Policy Generator. AWS Per ulteriori informazioni, vedere Panoramica delle IAM politiche.

  5. Nella finestra Bucket Policy Editor (Editor policy di bucket), digitare la seguente policy. Ciò consentirà AccountB accesso agli artefatti del gasdotto, e darà AccountB la possibilità di aggiungere artefatti di output se un'azione, come un'origine personalizzata o un'azione di compilazione, li crea.

    Nell'esempio seguente, è per ARN AccountB è 012ID_ACCOUNT_B. Il ARN bucket per Amazon S3 è codepipeline-us-east-2-1234567890. Sostituiscili ARNs con quello ARN per l'account a cui desideri consentire l'accesso e il ARN per il bucket Amazon S3:

     {
  "Version": "2012-10-17",
  "Id": "SSEAndSSLPolicy",
  "Statement": [
	{
  	"Sid": "DenyUnEncryptedObjectUploads",
	  "Effect": "Deny",
	  "Principal": "*",
	  "Action": "s3:PutObject",
	  "Resource": "arn:aws:s3:::codepipeline-us-east-2-1234567890/*",
	  "Condition": {
		"StringNotEquals": {
		"s3:x-amz-server-side-encryption": "aws:kms"
		}
	   }
	 },
	{
	  "Sid": "DenyInsecureConnections",
	  "Effect": "Deny",
	  "Principal": "*",
	  "Action": "s3:*",
	  "Resource": "arn:aws:s3:::codepipeline-us-east-2-1234567890/*",
	  "Condition": {
		"Bool": {
	  		"aws:SecureTransport": false
			}
		}
	  },
	{
	  "Sid": "",
	  "Effect": "Allow",
	  "Principal": {
		"AWS": "arn:aws:iam::012ID_ACCOUNT_B:root"
		},
	  "Action": [
            "s3:Get*",
            "s3:Put*"
        ],
	  "Resource": "arn:aws:s3:::codepipeline-us-east-2-1234567890/*"
	},
	{
	  "Sid": "",
	  "Effect": "Allow",
	  "Principal": {
	      "AWS": "arn:aws:iam::012ID_ACCOUNT_B:root"
			},
	  "Action": "s3:ListBucket",
  	"Resource": "arn:aws:s3:::codepipeline-us-east-2-1234567890"
	}
   ]
}

  6. Scegliere Save (Salva), quindi chiudere l'editor di policy.

  7. Scegli Salva per salvare le autorizzazioni per il bucket Amazon S3.

Per creare una policy per il ruolo di servizio per CodePipeline (console)

  1. Accedi al AWS Management Console con AccountA e apri la IAM console all'indirizzo https://console.aws.amazon.com/iam/.

  2. Nel riquadro di navigazione, seleziona Ruoli.

  3. Nell'elenco dei ruoli, in Nome ruolo, scegli il nome del ruolo di servizio per CodePipeline.

  4. Nella scheda Permissions (Autorizzazioni) scegliere Add inline policy (Aggiungi policy inline).

  5. Scegli la JSONscheda e inserisci la seguente politica per consentire AccountB per assumere il ruolo. Nell'esempio seguente, 012ID_ACCOUNT_B è la ARN per AccountB:

    {
   "Version": "2012-10-17",
   "Statement": {
       "Effect": "Allow",
       "Action": "sts:AssumeRole",
       "Resource": [
           "arn:aws:iam::012ID_ACCOUNT_B:role/*"
       ]
   }
 }

  6. Scegli Verifica policy.

  7. In Name (Nome), immetti un nome per la policy. Scegli Create Policy (Crea policy).

Configura le politiche e i ruoli nell'account proprietario della AWS risorsa (AccountB)

Quando crei un'applicazione, una distribuzione e un gruppo di distribuzione in CodeDeploy, crei anche un ruolo di EC2 istanza Amazon. (Questo ruolo viene creato automaticamente se utilizzi la procedura dettagliata di distribuzione, ma puoi anche crearlo manualmente.) Per una pipeline creata in AccountA per utilizzare CodeDeploy le risorse create in AccountB, è necessario:

  • Configura una policy per il ruolo dell'istanza che le consenta di accedere al bucket Amazon S3 in cui sono archiviati gli artefatti della pipeline.

  • Crea un secondo ruolo in AccountB configurato per l'accesso su più account.

    Questo secondo ruolo non deve solo avere accesso al bucket Amazon S3 in AccountA, deve inoltre contenere una politica che consenta l'accesso alle CodeDeploy risorse e una politica di relazione di fiducia che consenta il ruolo di CodePipeline servizio in AccountA per assumere il ruolo.

    Nota

    Queste politiche sono specifiche per l'impostazione CodeDeploy delle risorse da utilizzare in una pipeline creata utilizzando un AWS account diverso. Altre AWS risorse richiederanno politiche specifiche in base ai rispettivi requisiti di risorse.

Per creare una policy per il ruolo dell'EC2istanza Amazon configurato per CodeDeploy (console)

  1. Accedi al AWS Management Console con AccountB e apri la IAM console all'indirizzo https://console.aws.amazon.com/iam/.

  2. Nel riquadro di navigazione, seleziona Ruoli.

  3. Nell'elenco dei ruoli, in Nome ruolo, scegli il nome del ruolo di servizio utilizzato come ruolo dell'EC2istanza Amazon per l' CodeDeploy applicazione. Questo nome ruolo può variare e un gruppo di distribuzione può utilizzare più ruoli dell'istanza. Per ulteriori informazioni, consulta Creare un profilo di IAM istanza per le tue EC2 istanze Amazon.

  4. Nella scheda Permissions (Autorizzazioni) scegliere Add inline policy (Aggiungi policy inline).

  5. Scegli la JSONscheda e inserisci la seguente politica per concedere l'accesso al bucket Amazon S3 utilizzato da AccountA per archiviare artefatti per le pipeline (in questo esempio, codepipeline-us-east-2-1234567890):

    {
   "Version": "2012-10-17",
   "Statement": [
     {
       "Effect": "Allow",
       "Action": [
         "s3:Get*"
       ],
       "Resource": [
         "arn:aws:s3:::codepipeline-us-east-2-1234567890/*"
       ]
     },
     {
       "Effect": "Allow",
       "Action": [
         "s3:ListBucket"
       ],
       "Resource": [
         "arn:aws:s3:::codepipeline-us-east-2-1234567890"
       ]
     }
   ]
 }

  6. Scegli Verifica policy.

  7. In Name (Nome), immetti un nome per la policy. Scegli Create Policy (Crea policy).

  8. Crea una seconda policy per sapere AWS KMS dove si arn:aws:kms:us-east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE trova la chiave ARN gestita dal cliente creata in AccountA e configurato per consentire AccountB per usarlo:

    {
    "Version": "2012-10-17",
    "Statement": [
      {
        "Effect": "Allow",
        "Action": [
           "kms:DescribeKey",
           "kms:GenerateDataKey*",
           "kms:Encrypt",
           "kms:ReEncrypt*",
           "kms:Decrypt"
          ],
        "Resource": [
           "arn:aws:kms:us-east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE"
          ]
      }
   ]
}
    Importante

    È necessario utilizzare l'ID dell'account di AccountA in questo criterio come parte della risorsa ARN per la AWS KMS chiave, come illustrato qui, altrimenti il criterio non funzionerà.

  9. Scegli Verifica policy.

  10. In Name (Nome), immetti un nome per la policy. Scegli Create Policy (Crea policy).

Ora create un IAM ruolo da utilizzare per l'accesso tra più account e configuratelo in modo che il ruolo CodePipeline di servizio in AccountA può assumere il ruolo. Questo ruolo deve contenere politiche che consentano l'accesso alle CodeDeploy risorse e al bucket Amazon S3 utilizzato per archiviare gli artefatti AccountA.

Per configurare il ruolo tra account diversi in IAM

  1. Accedi al con AWS Management Console AccountB e apri la IAM console in https://console.aws.amazon.com/iam.

  2. Nel pannello di navigazione, seleziona Roles (Ruoli). Selezionare Create role (Crea ruolo).

  3. In Seleziona tipo di entità attendibile, scegli Un altro account AWS . In Specificare gli account che possono utilizzare questo ruolo, in ID account, inserisci l'ID AWS account per l'account che creerà la pipeline in ( CodePipelineAccountA), quindi scegli Avanti: Autorizzazioni.

    Importante

    Questo passaggio crea la politica di relazione di fiducia tra AccountB e AccountA. Tuttavia, ciò garantisce l'accesso di livello root all'account e CodePipeline consiglia di limitarlo al ruolo di CodePipeline servizio in AccountA. Segui il passaggio 16 per limitare le autorizzazioni.

  4. In Allega politiche di autorizzazione, scegli AmazonS3 ReadOnlyAccess, quindi scegli Avanti: tag.

    Nota

    Questa non è la policy che verrà utilizzata. Scegliere una policy per completare la procedura guidata.

  5. Scegli Prossimo: Rivedi. Digita un nome per questo ruolo in Nome del ruolo (ad esempio, CrossAccount_Role). Puoi assegnare a questo ruolo il nome che preferisci, purché segua le convenzioni di denominazione. IAM Valutare se assegnare al ruolo un nome che ne indica chiaramente lo scopo. Selezionare Create Role (Crea ruolo).

  6. Dall'elenco dei ruoli, scegli il ruolo che hai appena creato (ad esempio, CrossAccount_Role) per aprire la pagina di riepilogo relativa a quel ruolo.

  7. Nella scheda Permissions (Autorizzazioni) scegliere Add inline policy (Aggiungi policy inline).

  8. Scegli la JSONscheda e inserisci la seguente politica per consentire l'accesso alle CodeDeploy risorse:

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "codedeploy:CreateDeployment",
        "codedeploy:GetDeployment",
        "codedeploy:GetDeploymentConfig",
        "codedeploy:GetApplicationRevision",
        "codedeploy:RegisterApplicationRevision"
      ],
      "Resource": "*"
    }
  ]
}

  9. Scegli Verifica policy.

  10. In Name (Nome), immetti un nome per la policy. Scegli Create Policy (Crea policy).

  11. Nella scheda Permissions (Autorizzazioni) scegliere Add inline policy (Aggiungi policy inline).

  12. Scegli la JSONscheda e inserisci la seguente policy per consentire a questo ruolo di recuperare gli artefatti di input e di inserire gli artefatti di output nel bucket Amazon S3 AccountA:

    {
   "Version": "2012-10-17",
   "Statement": [
     {
       "Effect": "Allow",
       "Action": [
         "s3:GetObject*",
         "s3:PutObject",
         "s3:PutObjectAcl"               
       ],
       "Resource": [
         "arn:aws:s3:::codepipeline-us-east-2-1234567890/*"
       ]
     }
   ]
}

  13. Scegli Verifica policy.

  14. In Name (Nome), immetti un nome per la policy. Scegli Create Policy (Crea policy).

  15. Nella scheda Autorizzazioni, trova AmazonS3 ReadOnlyAccess nell'elenco delle politiche in Nome della politica e scegli l'icona di eliminazione (X) accanto alla politica. Quando richiesto, scegliere Detach (Scollega).

  16. Seleziona la scheda Relazione di fiducia, quindi scegli Modifica politica di fiducia. Scegli l'opzione Aggiungi un principale nella colonna di sinistra. Per Tipo principale, scegli IAMRuoli, quindi fornisci ARN il ruolo CodePipeline di servizio in AccountA. Rimuovi arn:aws:iam::Account_A:root dall'elenco dei AWS Principi, quindi scegli Aggiorna politica.

Fase 2: modifica della pipeline

Non è possibile utilizzare la CodePipeline console per creare o modificare una pipeline che utilizza risorse associate a un altro AWS account. Tuttavia, è possibile utilizzare la console per creare la struttura generale della pipeline e quindi utilizzare la AWS CLI per modificare la pipeline e aggiungere tali risorse. In alternativa, puoi utilizzare la struttura di una pipeline esistente e aggiungere manualmente le risorse.

Per aggiungere le risorse associate a un altro AWS account ()AWS CLI

  1. In un terminale (Linux, macOS o Unix) o nel prompt dei comandi (Windows), esegui il get-pipeline comando sulla pipeline a cui desideri aggiungere risorse. Copiate l'output del comando in un file. JSON Ad esempio, per una pipeline denominata MyFirstPipeline, digitate qualcosa di simile al seguente:

    aws codepipeline get-pipeline --name MyFirstPipeline >pipeline.json

    L'output viene inviato a pipeline.json file.

  2. Aprire il JSON file in qualsiasi editor di testo semplice. Dopo essere "type": "S3" entrato nell'archivio degli artefatti, aggiungi KMSencryptionKey, ID e digita le informazioni dove codepipeline-us-east-2-1234567890 è il nome del bucket Amazon S3 utilizzato per archiviare gli artefatti per la pipeline ed arn:aws:kms:us-east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE è la chiave gestita dal cliente che hai appena ARN creato:

    {
  "artifactStore”: {
    "location": "codepipeline-us-east-2-1234567890", 
    "type": "S3",
    "encryptionKey": {
      "id": "arn:aws:kms:us-east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE",
      "type": "KMS"
    }
  },

  3. Aggiungi un'azione di distribuzione in una fase per utilizzare le risorse associate a CodeDeploy AccountB, inclusi roleArn i valori per il ruolo tra account diversi che hai creato (CrossAccount_Role).

    L'esempio seguente mostra JSON che aggiunge un'azione di distribuzione denominata ExternalDeploy. Utilizza le CodeDeploy risorse create in AccountB in una fase denominata Staging. Nell'esempio seguente, ARN il AccountB è 012ID_ACCOUNT_B:

    ,
            {
                "name": "Staging",
                "actions": [
                    {
                        "inputArtifacts": [
                            {
                                "name": "MyAppBuild"
                            }
                        ],
                        "name": "ExternalDeploy",
                        "actionTypeId": {
                            "category": "Deploy",
                            "owner": "AWS",
                            "version": "1",
                            "provider": "CodeDeploy"
                        },
                        "outputArtifacts": [],
                        "configuration": {
                            "ApplicationName": "AccountBApplicationName",
                            "DeploymentGroupName": "AccountBApplicationGroupName"
                        },
                        "runOrder": 1,
                        "roleArn": "arn:aws:iam::012ID_ACCOUNT_B:role/CrossAccount_Role"
                    }
                ]
            }
    Nota

    Non si tratta dell'JSONintera pipeline, ma solo della struttura dell'azione in una fase.

  4. Rimuovi le righe metadata dal file per consentire al comando update-pipeline di utilizzarlo. Rimuovete la sezione dalla struttura della pipeline nel JSON file (le "metadata": { } linee e i "updated" campi "created""pipelineARN", e).

    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.

  5. Per applicare le modifiche, esegui il update-pipeline comando, specificando il JSON file della pipeline, simile al seguente:

    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.

Per testare la pipeline che utilizza risorse associate a un altro account AWS

  1. In un terminale (Linux, macOS o Unix) o dal prompt dei comandi (Windows), esegui il start-pipeline-execution comando, specificando il nome della pipeline, in modo simile al seguente:

    aws codepipeline start-pipeline-execution --name MyFirstPipeline

    Per ulteriori informazioni, consulta Avvio manuale di una pipeline.

  2. Accedi a con AWS Management Console AccountA e apri la CodePipeline console all'indirizzo http://console.aws.amazon.com/codesuite/codepipeline/home.

    Vengono visualizzati i nomi di tutte le pipeline associate al tuo AWS account.

  3. In Name (Nome), scegliere il nome della pipeline modificata. Questa operazione apre una visualizzazione dettagliata della pipeline, che include lo stato di ciascuna operazione in ogni fase della pipeline.

  4. Osservare l'avanzamento nella pipeline. Attendi un messaggio di successo sull'azione che utilizza la risorsa associata a un altro AWS account.

    Nota

    Riceverai un errore se tenti di visualizzare i dettagli dell'azione dopo aver effettuato l'accesso con AccountA. Esci, quindi accedi con AccountB per visualizzare i dettagli della distribuzione in CodeDeploy.