Criar um pipeline no CodePipeline que usa recursos de outra conta da AWS.

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

À esquerda, escolha Chaves gerenciadas pelo cliente.

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

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.

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.

Em Definir permissões de uso da chave, em Esta conta, selecione o nome do perfil de serviço do pipeline (por exemplo, CodePipeline_Service_Role). Em Outras contas da AWS, escolha Adicionar outra conta da AWS. Insira o ID da conta de AccountB para concluir o ARN e selecione Próximo.

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

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.

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

Na lista de buckets do Amazon S3, escolha o bucket do Amazon S3 em que os artefatos de seus pipelines serão armazenados. Esse bucket se chamacodepipeline-region-1234567EXAMPLE, em que region é a região da AWS na qual o pipeline foi criado e 1234567EXAMPLE é um número aleatório de dez dígitos que garante a exclusividade do nome do bucket (por exemplo, codepipeline-us-east-2-1234567890).

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

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

Na janela do Editor de política de bucket, digite a seguinte política. Isso permitirá que a AccountB acesse os artefatos do pipeline e dará à AccountB a habilidade de adicionar artefatos de saída se uma ação, como uma fonte padrão ou ação de construção, criar tais artefatos.

No exemplo a seguir, o ARN da Conta B é 012ID_ACCOUNT_B. O ARN do bucket do Amazon S3 é codepipeline-us-east-2-1234567890. Substitua esses ARNs pelo ARN da conta à qual você deseja conceder acesso e pelo ARN do bucket do 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"
	}
   ]
} 

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

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

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

No painel de navegação, escolha Perfis.

Na lista de perfis, em Nome do perfil, escolha o nome do perfil de serviço do CodePipeline.

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

Escolha a guia JSON e insira a política a seguir para permitir que AccountB assuma o perfil. No exemplo a seguir, 012ID_ACCOUNT_B é o ARN da Conta B:

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

Escolha Revisar política.

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

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

No painel de navegação, escolha Perfis.

Na lista de perfis, em Nome do perfil, escolha o nome do perfil de serviço usado como perfil de instância do Amazon EC2 para a aplicação do CodeDeploy. 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 instâncias do Amazon EC2.

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

Escolha a guia JSON e insira a seguinte política para conceder acesso ao bucket Amazon S3 usado por AccountA para armazenar artefatos de pipelines (neste exemplo, 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"
       ]
     }
   ]
 }

Escolha Revisar política.

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

Crie uma segunda política do AWS KMS em que arn:aws:kms:us-east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE seja o ARN da chave gerenciada pelo cliente criada na AccountA e configurada para permitir que AccountB a use:

{
    "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"
          ]
      }
   ]
}

Escolha Revisar política.

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

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

No painel de navegação, escolha Roles. Escolha Criar Perfil.

Em Selecionar tipo de entidade confiável, escolha Outra conta da AWS. Em Especificar contas que podem usar este perfil, em ID da conta, insira o ID da conta da AWS que criará o pipeline no CodePipeline (AccountA) e escolha Próximo: Permissões.

Na página Anexar políticas de permissões, escolha AmazonS3ReadOnlyAccess e escolha Próximo: Etiquetas.

Selecione Next: Review (Próximo: revisar). Em Nome do perfil, digite um nome para este perfil (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.

Na lista de perfis, escolha o perfil que você acabou de criar (por exemplo, CrossAccount_Role) para abrir a página Resumo desse perfil.

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

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

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

Escolha Revisar política.

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

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

Escolha a guia JSON e insira a seguinte política para permitir que esse perfil recupere os artefatos de entrada. Em seguida, os coloque artefatos de saída no bucket do Amazon S3 em AccountA:

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

Escolha Revisar política.

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

Na guia Permissões, localize Amazons3ReadOnlyAccess 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.

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 de entidade principal, escolha Perfis do IAM e forneça o ARN do perfil de serviço do CodePipeline em AccountA. Remova arn:aws:iam::Account_A:root da lista de Entidades principais da AWS e selecione Atualizar política.

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 ao arquivo pipeline.json.

Abra o arquivo JSON em qualquer editor de texto simples. Depois de "type": "S3" no armazenamento de artefatos, adicione a encryptionKey do KMS, o ID e digite informações em que codepipeline-us-east-2-1234567890 seja 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 seja o ARN da chave gerenciada pelo cliente recém-criada:

{
  "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"
    }
  },

Adicione uma ação de implantação em um estágio para usar os recursos do CodeDeploy associados a AccountB, incluindo os valores roleArn para o perfil entre contas que você criou (CrossAccount_Role).

O exemplo a seguir mostra JSON que adiciona uma ação de implantação nomeada de ExternalDeploy. Ele usa os recursos do CodeDeploy criados em AccountB em um estágio chamado Preparação. No exemplo a seguir, o ARN para a Conta B é 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"
                    }
                ]
            }

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.

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

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

Este comando retorna toda a estrutura do pipeline editado.

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 ter mais informações, consulte Iniciar um pipeline manualmente.

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

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

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.

Assista o progresso através do pipeline. Aguarde por uma mensagem de êxito na ação que usa o recurso associado a outra conta da AWS.