Crie um pipeline CodePipeline que use recursos de outra AWS conta - AWS CodePipeline
Pré-requisito: criar uma chave de criptografia do AWS KMSEtapa 1: Configurar as políticas e funções da contaEtapa 2: Editar o pipeline

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Crie um pipeline CodePipeline que use recursos de outra AWS conta

Pode ser que você queira criar um pipeline que use os recursos criados ou gerenciados por outra conta da AWS . Por exemplo, você pode querer usar uma conta com o pipeline e outra com os recursos do CodeDeploy .

nota

Depois de criar um pipeline com ações de várias contas, você deve configurar suas ações para que ainda possam acessar artefatos dentro das limitações de pipelines entre contas. As limitações a seguir se aplicam às ações entre contas:

  • Geralmente, uma ação só pode consumir um artefato se:

    • A ação está na mesma conta que o pipeline OU

    • O artefato foi criado na conta do pipeline para uma ação em outra conta OU

    • O artefato foi produzido por uma ação anterior na mesma conta

    Ou seja, você não pode transmitir um artefato de uma conta para outra se nenhuma delas for a conta do pipeline.

  • Ações entre contas não são compatíveis com os seguintes tipos de ações:

    • Ações de compilações Jenkins

Neste exemplo, você deve criar uma chave AWS Key Management Service (AWS KMS) para usar, adicionar a chave ao pipeline e configurar políticas e funções da conta para permitir o acesso entre contas. Para uma chave AWS KMS, você pode usar o ID da chave, o ARN da chave ou o alias ARN.

nota

Os aliases são reconhecidos apenas na conta que criou a chave do KMS. Para ações entre contas, você só pode usar o ID ou o ARN da chave para identificar a chave. As ações entre contas envolvem o uso do perfil da outra conta (AccountB), portanto, a especificação do ID da chave usará a chave da outra conta (AccountB).

Neste passo a passo e em seus exemplos, a conta AccountA é originalmente usada para criar o pipeline. Ele tem acesso ao bucket do Amazon S3 usado para armazenar artefatos do pipeline e à função de serviço usada por. AWS CodePipelineAccountBé a conta originalmente usada para criar o CodeDeploy aplicativo, o grupo de implantação e a função de serviço usada por CodeDeploy.

AccountAPara editar um pipeline para usar o CodeDeploy aplicativo criado porAccountB, é AccountA necessário:

  • Solicite o ARN ou o ID da conta de AccountB (neste passo a passo, o AccountB ID é). 012ID_ACCOUNT_B

  • Crie ou use uma chave gerenciada pelo AWS KMS cliente na região para o pipeline e conceda permissões para usar essa chave para a função de serviço (CodePipeline_Service_Role) AccountB e.

  • Crie uma política de bucket do Amazon S3 que conceda AccountB acesso ao bucket do Amazon S3 (por exemplo,). codepipeline-us-east-2-1234567890

  • Crie uma política que permita AccountA assumir uma função configurada por AccountB e anexe essa política à função de serviço (CodePipeline_Service_Role).

  • Edite o pipeline para usar a AWS KMS chave gerenciada pelo cliente em vez da chave padrão.

Para AccountB permitir o acesso aos seus recursos a um pipeline criado emAccountA, AccountB deve:

  • Solicite o ARN ou o ID da conta de AccountA (neste passo a passo, o AccountA ID é). 012ID_ACCOUNT_A

  • Crie uma política aplicada à função de EC2 instância da Amazon configurada para permitir CodeDeploy o acesso ao bucket do Amazon S3 ()codepipeline-us-east-2-1234567890.

  • Crie uma política aplicada à função de EC2 instância da Amazon configurada para permitir CodeDeploy o acesso à chave gerenciada pelo AWS KMS cliente usada para criptografar os artefatos do pipeline. AccountA

  • Configure e anexe uma função do IAM (CrossAccount_Role) com uma política de relacionamento de confiança que permita que a função de CodePipeline serviço assuma AccountA a função.

  • Crie uma política que permita o acesso aos recursos de implantação exigidos pelo pipeline e anexe-a CrossAccount_Role a.

  • Crie uma política que permita acesso ao bucket do Amazon S3 (codepipeline-us-east-2-1234567890) e anexe-a a. CrossAccount_Role

Pré-requisito: criar uma chave de criptografia do AWS KMS

As chaves gerenciadas pelo cliente são específicas de uma região, assim como todas AWS KMS as chaves. Você deve criar sua AWS KMS chave gerenciada pelo cliente na mesma região em que o funil foi criado (por exemplo,us-east-2).

Para criar uma chave gerenciada pelo cliente em AWS KMS

  1. Faça login no AWS Management Console com AccountA e abra o AWS KMS console.

  2. À esquerda, escolha Chaves gerenciadas pelo cliente.

  3. Escolha Criar chave. Em Configurar chave, deixe a opção padrão Simétrica selecionada e escolha Próximo.

  4. Em Alias, insira um alias a ser usado para essa chave (por exemplo,PipelineName-Key). Ou então, forneça uma descrição e tags para essa chave e selecione Próximo.

  5. Em Definir permissões administrativas da chave, escolha o(s) perfil(is) que devem atuar como administradores para essa chave e, em seguida, escolha Próximo.

  6. Em Definir permissões de uso da chave, em Esta conta, selecione o nome da função de serviço para o pipeline (por exemplo, CodePipeline _Service_Role). Em Outras AWS contas, escolha Adicionar outra AWS conta. Insira o ID da conta AccountB para preencher o ARN e, em seguida, escolha Avançar.

  7. Em Revisar e editar política de chaves, revise a política e selecione Concluir.

  8. Na lista de chaves, selecione o alias da chave e copie o ARN (por exemplo, arn:aws:kms:us-east-2:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE). Você precisará disso ao editar seu pipeline e configurar políticas.

Etapa 1: Configurar as políticas e funções da conta

Depois de criar a AWS KMS chave, você deve criar e anexar políticas que permitirão o acesso entre contas. Isso requer ações de ambos AccountA AccountB e.

Configure políticas e funções na conta que criará o pipeline (AccountA)

Para criar um pipeline que usa CodeDeploy recursos associados a outra AWS conta, é AccountA necessário configurar políticas para o bucket do Amazon S3 usado para armazenar artefatos e para a função de serviço para. CodePipeline

Para criar uma política para o bucket do Amazon S3 que conceda acesso a AccountB (console)

  1. Faça login no AWS Management Console com AccountA e abra o console do Amazon S3 em. https://console.aws.amazon.com/s3/

  2. Na lista de buckets do Amazon S3, escolha o bucket do Amazon S3 em que os artefatos de seus pipelines serão armazenados. Esse intervalo é denominadocodepipeline-region-1234567EXAMPLE, onde region está a AWS região na qual você criou o pipeline e 1234567EXAMPLE é um número aleatório de dez dígitos que garante que o nome do intervalo seja exclusivo (por exemplo,). codepipeline-us-east-2-1234567890

  3. Na página de detalhes do bucket do Amazon S3, escolha Propriedades.

  4. No painel de propriedades, expanda Permissões e depois selecione Adicionar política de bucket.

    nota

    Se uma política já estiver anexada ao bucket do Amazon S3, escolha Editar política de bucket. Em seguida, você pode adicionar as instruções no exemplo a seguir para a política existente. Para adicionar uma nova política, escolha o link e siga as instruções no AWS Policy Generator. Para obter mais informações, consulte Visão geral das políticas do IAM.

  5. Na janela Bucket Policy Editor, crie uma política que permita AccountB acesso aos artefatos do pipeline e permita adicionar artefatos de saída se uma ação, como uma fonte personalizada ou uma ação de criação, os criar. AccountB

  6. Selecione Salvar e depois feche o editor de políticas.

  7. Escolha Salvar para salvar as permissões para o bucket do Amazon S3.

Para criar uma política para a função de serviço para CodePipeline (console)

  1. Faça login no AWS Management Console with AccountA e abra o console do IAM em https://console.aws.amazon.com/iam/.

  2. No painel de navegação, selecione Perfis.

  3. Na lista de funções, em Role Name (Nome da função), selecione o nome da função de serviço para o CodePipeline.

  4. Na guia Permissions (Permissões), escolha Add inline policy (Adicionar política em linha).

  5. Escolha a guia JSON e insira a política a seguir para permitir que você assuma AccountB a função. No exemplo a seguir, 012ID_ACCOUNT_B é o ARN para: AccountB

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

  6. Selecione Revisar política.

  7. Em Name (Nome), insira um nome para essa política. Selecione Criar política.

Configure políticas e funções na conta proprietária do AWS recurso (AccountB)

Ao criar um aplicativo, uma implantação e um grupo de implantação no CodeDeploy, você também cria uma função de EC2 instância da Amazon. (Essa função é criada caso você use o assistente de apresentação de implantação de execução, mas também é possível criá-la manualmente.) Para que um pipeline criado em AccountA use CodeDeploy recursos criados emAccountB, você deve:

  • Configurar uma política para o perfil de instância que permita o acesso ao bucket do Amazon S3 em que os artefatos do pipeline serão armazenados.

  • Crie uma segunda função AccountB configurada para acesso entre contas.

    Essa segunda função não deve apenas ter acesso ao bucket do Amazon S3AccountA, mas também deve conter uma política que permita acesso aos CodeDeploy recursos e uma política de relação de confiança que permita que a função de CodePipeline serviço assuma AccountA a função.

    nota

    Essas políticas são específicas para configurar CodeDeploy recursos a serem usados em um pipeline criado usando uma AWS conta diferente. Outros AWS recursos exigirão políticas específicas para seus requisitos de recursos.

Para criar uma política para a função de EC2 instância da Amazon configurada para CodeDeploy (console)

  1. Faça login no AWS Management Console with AccountB e abra o console do IAM em https://console.aws.amazon.com/iam/.

  2. No painel de navegação, selecione Perfis.

  3. Na lista de funções, em Nome da função, escolha o nome da função de serviço usada como função de EC2 instância da Amazon para o CodeDeploy aplicativo. Esse nome da função pode variar e mais de uma função de instância pode ser usada por um grupo de implantação. Para obter mais informações, consulte Criar um perfil de instância do IAM para suas EC2 instâncias da Amazon.

  4. Na guia Permissions (Permissões), escolha Add inline policy (Adicionar política em linha).

  5. Escolha a guia JSON e insira a seguinte política para conceder acesso ao bucket do Amazon S3 usado AccountA por para armazenar artefatos para pipelines (neste exemplo,): 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. Selecione Revisar política.

  7. Em Name (Nome), insira um nome para essa política. Selecione Criar política.

  8. Crie uma segunda política de AWS KMS onde arn:aws:kms:us-east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE está o ARN da chave gerenciada pelo cliente criada AccountA e configurada AccountB para permitir seu uso:

    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

    Você deve usar o ID da AccountA conta desta política como parte do ARN do recurso para a AWS KMS chave, conforme mostrado aqui, ou a política não funcionará.

  9. Selecione Revisar política.

  10. Em Name (Nome), insira um nome para essa política. Selecione Criar política.

Agora, crie uma função do IAM para usar no acesso entre contas e configure-a para que a função CodePipeline de serviço em AccountA possa assumir a função. Essa função deve conter políticas que permitam o acesso aos CodeDeploy recursos e ao bucket do Amazon S3 usados para armazenar artefatos. AccountA

Para configurar o perfil entre contas no IAM

  1. Faça login no AWS Management Console with AccountB e abra o console do IAM em https://console.aws.amazon.com/iam.

  2. No painel de navegação, selecione Perfis. Escolha Criar Perfil.

  3. Em Selecionar tipo de entidade confiável, escolha Outra conta da AWS . Em Especificar contas que podem usar essa função, em ID da AWS conta, insira a ID da conta que criará o pipeline em CodePipeline (AccountA) e escolha Avançar: Permissões.

    Importante

    Esta etapa cria a política de relacionamento de confiança entre AccountB AccountA e. No entanto, isso concede acesso de nível raiz à conta e CodePipeline recomenda reduzi-la à função de CodePipeline serviço emAccountA. Siga a etapa 16 para restringir permissões.

  4. Em Anexar políticas de permissões, escolha AmazonS3 eReadOnlyAccess, em seguida, escolha Avançar: Tags.

    nota

    Esta não é a política que você utilizará. Você deve escolher uma política para concluir o assistente.

  5. Escolha Próximo: revisar. Digite um nome para essa função em Nome da função (por exemplo,CrossAccount_Role). Você pode nomear esse perfil como quiser, desde que ele siga as convenções de nomenclatura do IAM. Considere atribuir uma nome à função que indique claramente o seu propósito. Selecione Criar função.

  6. Na lista de funções, escolha a função que você acabou de criar (por exemplo,CrossAccount_Role) para abrir a página Resumo dessa função.

  7. Na guia Permissions (Permissões), escolha Add inline policy (Adicionar política em linha).

  8. Escolha a guia JSON e insira a seguinte política para permitir o acesso aos CodeDeploy recursos:

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

  9. Selecione Revisar política.

  10. Em Name (Nome), insira um nome para essa política. Selecione Criar política.

  11. Na guia Permissions (Permissões), escolha Add inline policy (Adicionar política em linha).

  12. Escolha a guia JSON e insira a seguinte política para permitir que essa função recupere artefatos de entrada e coloque artefatos de saída no bucket do Amazon S3 em: 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. Selecione Revisar política.

  14. Em Name (Nome), insira um nome para essa política. Selecione Criar política.

  15. Na guia Permissões, encontre o AmazonS3 ReadOnlyAccess na lista de políticas em Nome da política e escolha o ícone de exclusão (X) ao lado da política. Quando solicitado, selecione Desanexar.

  16. Selecione a guia Relação de confiança e escolha Editar política de confiança. Escolha a opção Adicionar uma entidade principal na coluna à esquerda. Em Tipo principal, escolha Funções do IAM e, em seguida, forneça o ARN para a função CodePipeline de serviço em. AccountA Remova arn:aws:iam::Account_A:root da lista de Entidades principais da AWS e selecione Atualizar política.

Etapa 2: Editar o pipeline

Você não pode usar o CodePipeline console para criar ou editar um pipeline que usa recursos associados a outra AWS conta. No entanto, você pode usar o console para criar a estrutura geral do pipeline e, em seguida, usar o AWS CLI para editar o pipeline e adicionar esses recursos. Como alternativa, você pode usar a estrutura de um pipeline existente e adicionar manualmente os recursos.

Para adicionar os recursos associados a outra AWS conta (AWS CLI)

  1. Em um terminal (Linux, macOS ou Unix) ou prompt de comando (Windows), execute o comando get-pipeline no pipeline ao qual deseja adicionar recursos. Copie a saída do comando em um arquivo JSON. Por exemplo, para um pipeline chamado MyFirstPipeline, você digitaria algo assim:

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

    A saída é enviada para o arquivo pipeline.json.

  2. Abra o arquivo JSON em qualquer editor de texto simples. Depois de "type": "S3" entrar no armazenamento de artefatos, adicione as informações de EncryptionKey, ID e tipo do KMS, onde codepipeline-us-east-2-1234567890 está o nome do bucket do Amazon S3 usado para armazenar artefatos para o pipeline e arn:aws:kms:us-east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE é o ARN da chave gerenciada pelo cliente que você acabou de criar:

    {
  "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. Adicione uma ação de implantação em um estágio para usar os CodeDeploy recursos associadosAccountB, incluindo os roleArn valores da função entre contas que você criou (CrossAccount_Role).

    O exemplo a seguir mostra o JSON que adiciona uma ação de implantação chamadaExternalDeploy. Ele usa os CodeDeploy recursos criados AccountB em um estágio chamadoStaging. No exemplo a seguir, o ARN para 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

    Este não é o JSON para todo o pipeline, apenas a estrutura para a ação em um estágio.

  4. Você deve remover as linhas metadata do arquivo para que o comando update-pipeline possa usá-lo. Remova a seção da estrutura do pipeline no arquivo JSON (as linhas de "metadata": { } e os campos "created", "pipelineARN" e "updated").

    Por exemplo, remova as seguintes linhas da estrutura: 

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

    Salve o arquivo.

  5. Para aplicar suas alterações, execute o comando update-pipeline, especificando o pipeline do arquivo JSON, de modo semelhante ao seguinte:

    Importante

    Não se esqueça de incluir file:// antes do nome de arquivo. Ele é obrigatório nesse comando.

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

    Este comando retorna toda a estrutura do pipeline editado.

Para testar o pipeline que usa recursos associados a outra AWS conta

  1. Em um terminal (Linux, macOS ou Unix) ou prompt de comando (Windows), execute o comando start-pipeline-execution, especificando o nome do pipeline, da seguinte maneira:

    aws codepipeline start-pipeline-execution --name MyFirstPipeline

    Para obter mais informações, consulte Iniciar um pipeline manualmente.

  2. Faça login no AWS Management Console with AccountA e abra o CodePipeline console em http://console.aws.amazon. com/codesuite/codepipeline/home.

    Os nomes de todos os pipelines associados à sua AWS conta são exibidos.

  3. Em Nome, selecione o nome do pipeline recém-editado. Isso abre uma visão detalhada do pipeline, incluindo o estado de cada ação em cada estágio do pipeline.

  4. Assista o progresso através do pipeline. Aguarde uma mensagem de sucesso sobre a ação que usa o recurso associado a outra AWS conta.

    nota

    Você receberá uma mensagem de erro se tentar visualizar os detalhes da ação enquanto estiver conectado comAccountA. Saia e, em seguida, entre com AccountB para ver os detalhes da implantação CodeDeploy.