View a markdown version of this page

Crea una pipeline in CodePipeline cui vengono utilizzate le risorse di un altro AWS account - AWS CodePipeline
Prerequisito: creare un AWS KMS chiave crittograficaFase 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 in CodePipeline cui vengono utilizzate le risorse di un altro AWS account

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

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.

  • Cross-account le azioni non sono supportate per i seguenti tipi di azione:

    • 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 impostare le politiche e i ruoli degli account per abilitare l'accesso tra account. Per una chiave AWS KMS, puoi utilizzare l'ID della chiave, la chiave ARN o l'alias ARN.

Nota

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

In questa procedura dettagliata e nei relativi esempi, AccountA viene utilizzato originariamente l'account 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 utilizzato da. CodeDeploy

AccountAPer modificare una pipeline per utilizzare l' CodeDeploy applicazione creata daAccountB, AccountA è necessario:

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

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

  • Crea una policy per i bucket Amazon S3 che conceda AccountB l'accesso al bucket Amazon S3 (ad esempio,). codepipeline-us-east-2-1234567890

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

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

AccountBPer consentire l'accesso alle sue risorse a una pipeline creata inAccountA, AccountB deve:

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

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

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

  • Configura e allega un ruolo IAM (CrossAccount_Role) con una politica di relazione di fiducia che consenta al ruolo del CodePipeline servizio di assumere il ruoloAccountA.

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

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

Prerequisito: creare un AWS KMS chiave crittografica

Customer-managed le chiavi sono specifiche di una regione, così come tutte le AWS KMS 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 a Console di gestione AWS with AccountA e apri la AWS KMS console.

  2. A sinistra, scegli Chiavi gestite dal cliente.

  3. Scegli 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, fornire una descrizione per questa chiave e scegliere Fase successiva.

  5. In Definizione delle autorizzazioni amministrative chiave, scegli il ruolo o i ruoli che desideri utilizzare come amministratori per questa chiave, quindi scegli Avanti.

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

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

  8. Dall'elenco di chiavi, scegliere l'alias della chiave e copiare il relativo 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, è necessario creare e allegare politiche che consentano l'accesso tra account. Ciò richiede azioni da parte di entrambi AccountA eAccountB.

Configura politiche e ruoli nell'account che creerà la pipeline (Account A)

Per creare una pipeline che utilizzi CodeDeploy risorse associate a un altro AWS account, è AccountA necessario configurare le policy 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 a Console di gestione AWS with 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 artefatti per le tue pipeline. Questo bucket è denominatocodepipeline-region-1234567EXAMPLE, dov'è la AWS regione in cui hai creato la pipeline ed region è un numero casuale di dieci cifre che garantisce che il nome del bucket 1234567EXAMPLE 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 del bucket. È possibile quindi aggiungere le dichiarazioni nell'esempio seguente alla policy esistente. Per aggiungere una nuova policy, scegli il link e segui le istruzioni nel Policy Generator. AWS Per ulteriori informazioni, consulta Panoramica delle politiche IAM.

  5. Nella finestra Bucket Policy Editor, crea una policy che consenta AccountB l'accesso agli artefatti della pipeline e dia AccountB la possibilità di aggiungere artefatti di output se un'azione, ad esempio un'azione di origine personalizzata o di compilazione, li crea.

  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 a Console di gestione AWS with AccountA e apri la console IAM all'indirizzo https://console.aws.amazon.com/iam/.

  2. Nel riquadro di navigazione, seleziona Ruoli.

  3. Nell'elenco dei ruoli, in Role Name (Nome ruolo), scegliere il nome del ruolo del servizio per CodePipeline.

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

  5. Scegli la scheda JSON e inserisci la seguente policy AccountB per consentire l'assunzione del ruolo. Nel seguente esempio, 012ID_ACCOUNT_B è l'ARN per: AccountB

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

  6. Scegliere Esamina policy.

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

Configura le politiche e i ruoli nell'account che possiede il AWS risorsa (Conto B)

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

  • 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 configurato per l'accesso tra più accountAccountB.

    Questo secondo ruolo non deve solo avere accesso al bucket Amazon S3 inAccountA, ma deve anche contenere una policy che consenta l'accesso alle CodeDeploy risorse e una policy sulle relazioni di fiducia che consenta al ruolo di CodePipeline servizio in di AccountA assumere il ruolo.

    Nota

    Queste politiche sono specifiche per configurare CodeDeploy le risorse da utilizzare in una pipeline creata utilizzando un account diverso. AWS Altre AWS risorse richiederanno politiche specifiche per i loro requisiti in termini di risorse.

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

  1. Accedi a Console di gestione AWS with AccountB e apri la console IAM 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 di istanza Amazon EC2 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 istanza IAM per le tue istanze Amazon EC2.

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

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

    JSON
    {
   "Version":"2012-10-17",
   "Statement": [
     {
       "Effect": "Allow",
       "Action": [
         "s3:Get*"
       ],
       "Resource": [
         "arn:aws:s3:::amzn-s3-demo-bucket/*"
       ]
     },
     {
       "Effect": "Allow",
       "Action": [
         "s3:ListBucket"
       ],
       "Resource": [
         "arn:aws:s3:::amzn-s3-demo-bucket"
       ]
     }
   ]
 }

  6. Scegliere Esamina policy.

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

  8. Crea una seconda policy per indicare AWS KMS dove si arn:aws:kms:us-east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE trova l'ARN della chiave gestita dal cliente creata AccountA e configurata per consentirne l'utilizzo: AccountB

    JSON
    {
    "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:111122223333:key/2222222-3333333-4444-556677EXAMPLE"
            ]
        }
    ]
}
    Importante

    È necessario utilizzare l'ID dell'account AccountA di questa policy come parte dell'ARN della risorsa per la AWS KMS chiave, come mostrato qui, altrimenti la policy non funzionerà.

  9. Scegliere Esamina policy.

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

Ora crea un ruolo IAM da utilizzare per l'accesso tra più account e configuralo in modo che il ruolo del CodePipeline servizio in AccountA possa assumere il ruolo. Questo ruolo deve contenere politiche che consentano l'accesso alle CodeDeploy risorse e al bucket Amazon S3 in cui archiviare gli artefatti. AccountA

Per configurare il ruolo tra account diversi in IAM

  1. Accedi a Console di gestione AWS with AccountB e apri la console IAM all'indirizzo 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 Specifica gli account che possono utilizzare questo ruolo, in ID account, inserisci l' AWS ID dell'account che creerà la pipeline in CodePipeline (AccountA), quindi scegli Avanti: Autorizzazioni.

    Importante

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

  4. In Allega criteri di autorizzazione, scegli AmazonS3ReadOnlyAccess, 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 ruolo (ad esempio,CrossAccount_Role). Puoi assegnare a questo ruolo il nome che preferisci purché segua le convenzioni di denominazione in IAM. Valutare se assegnare al ruolo un nome che ne indica chiaramente lo scopo. Selezionare Crea ruolo.

  6. Dall'elenco dei ruoli, scegli il ruolo che hai appena creato (ad esempioCrossAccount_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 scheda JSON e inserisci la seguente politica per consentire l'accesso alle CodeDeploy risorse:

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

  9. Scegliere Esamina policy.

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

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

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

    JSON
    {
   "Version":"2012-10-17",
   "Statement": [
     {
       "Effect": "Allow",
       "Action": [
         "s3:GetObject*",
         "s3:PutObject",
         "s3:PutObjectAcl"               
       ],
       "Resource": [
         "arn:aws:s3:::amzn-s3-demo-bucket/*"
       ]
     }
   ]
}

  13. Scegliere Esamina policy.

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

  15. Nella scheda Autorizzazioni, cerca AmazonS3ReadOnlyAccess nell'elenco delle policy in Policy Name e scegli l'icona di eliminazione (X) accanto alla policy. 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 il tipo Principal, scegli IAM Roles, quindi fornisci l'ARN per il ruolo CodePipeline di servizio inAccountA. Rimuovi arn:aws:iam::Account_A:root dall'elenco dei AWS Principal, quindi scegli Aggiorna policy.

Fase 2: modifica della pipeline

Non puoi 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 console 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'altra 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. Copiare l'output del comando in un file JSON. Ad esempio, per una pipeline denominata MyFirstPipeline, digitare un comando simile al seguente:

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

    L'output viene inviato al file pipeline.json.

  2. Aprire il file JSON in qualsiasi editor di testo normale. Una volta "type": "S3" inserito nell'artifact store, aggiungi KMS EncryptionKey, ID e type informationcodepipeline-us-east-2-1234567890, indicando il nome del bucket Amazon S3 utilizzato per archiviare gli artefatti per la pipeline e l'ARN della chiave gestita dal cliente che hai appena creato: arn:aws:kms:us-east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE

    {
  "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 CodeDeploy risorse associate, inclusi i valori per il ruolo tra account che hai creato (). AccountB roleArn CrossAccount_Role

    L'esempio seguente mostra JSON che aggiunge un'azione di distribuzione denominata. ExternalDeploy Utilizza le CodeDeploy risorse create AccountB in una fase denominata. Staging Nel seguente esempio, l'ARN per 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 del JSON per l'intera pipeline, ma solo della struttura per l'operazione in una fase.

  4. Rimuovi le righe metadata dal file per consentire al comando update-pipeline di utilizzarlo. Rimuovere la sezione dalla struttura della pipeline nel file JSON (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.

  5. Per applicare le modifiche, eseguire il comando update-pipeline, specificando il file JSON della pipeline, in modo analogo 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'altra AWS account

  1. In un terminale (Linux, macOS o Unix) o nel 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 Console di gestione AWS with AccountA e apri la console all'indirizzo. CodePipeline 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 esito positivo sull'azione che utilizza la risorsa associata a un altro AWS account.

    Nota

    Riceverai un errore se tenti di visualizzare i dettagli dell'azione mentre sei connesso conAccountA. Esci, quindi accedi con AccountB per visualizzare i dettagli di distribuzione. CodeDeploy