Crie um pipeline CodePipeline que use recursos de outra AWS conta

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

À 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). Opcionalmente, forneça uma descrição e tags para essa chave e escolha Avançar.

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 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 para AccountB para concluir o eARN, em seguida, escolha Avançar.

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

Na lista de chaves, escolha o alias da sua chave e copie-a 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 tem o nome decodepipeline-region-1234567EXAMPLE, onde region é 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 bucket seja exclusivo (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á AccountB acesso aos artefatos do gasoduto, e fornecerá AccountB a capacidade de adicionar artefatos de saída se uma ação, como uma fonte personalizada ou uma ação de criação, os criar.

No exemplo a seguir, o ARN é para AccountB é 012ID_ACCOUNT_B. O ARN para o bucket do Amazon S3 é codepipeline-us-east-2-1234567890. Substitua-os ARNs ARN pelo da conta que você deseja permitir acesso e ARN pelo 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 IAM console em https://console.aws.amazon.com/iam/.

No painel de navegação, escolha Perfis.

Na lista de funções, em Nome da função, escolha o nome da função de serviço para CodePipeline.

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

Escolha a JSONguia e insira a seguinte política para permitir AccountB para assumir o papel. No exemplo a seguir, 012ID_ACCOUNT_B é o ARN para AccountB:

{
   "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 IAM console em https://console.aws.amazon.com/iam/.

No painel de navegação, escolha Perfis.

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 IAM instância para suas EC2 instâncias da Amazon.

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

Escolha a JSONguia e insira a seguinte política para conceder acesso ao bucket do Amazon S3 usado pelo AccountA para armazenar artefatos para tubulações (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 para AWS KMS saber onde arn:aws:kms:us-east-1:012ID_ACCOUNT_A:key/2222222-3333333-4444-556677EXAMPLE está ARN a chave gerenciada pelo cliente criada em AccountA e configurado para permitir AccountB para usá-lo:

{
    "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 IAM console em https://console.aws.amazon.com/iam.

No painel de navegação, escolha Roles. Selecione Create role.

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, em seguida, escolha Avançar: Permissões.

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

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

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

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

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

{
  "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 JSONguia 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:

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

Selecione a guia Relação de Confiança e escolha Editar política de confiança. Escolha a opção Adicionar um principal na coluna da esquerda. Em Tipo principal, escolha IAMFunções e, em seguida, forneça a ARN para a função CodePipeline de serviço em AccountA. Remova arn:aws:iam::Account_A:root da lista de AWS diretores e escolha 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 JSON arquivo. Por exemplo, para um pipeline chamado MyFirstPipeline, você digitaria algo semelhante ao seguinte:

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

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

Abra o JSON arquivo em qualquer editor de texto sem formatação. Depois de entrar "type": "S3" no armazenamento de artefatos, adicione as informações KMSencryptionKey, ID e digite onde codepipeline-us-east-2-1234567890 é 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 nome da chave gerenciada pelo cliente que você acabou ARN 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"
    }
  },

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

O exemplo a seguir mostra JSON que adiciona uma ação de implantação chamada ExternalDeploy. Ele usa os CodeDeploy recursos criados em AccountB em um palco chamado Staging. 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"
                    }
                ]
            }

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 JSON arquivo (as "metadata": { } linhas e os "updated" campos "created""pipelineARN", e).

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 update-pipeline comando, especificando o JSON arquivo do pipeline, 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 obter mais informações, consulte Iniciar um pipeline manualmente.

Faça login no AWS Management Console com 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.

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 uma mensagem de sucesso sobre a ação que usa o recurso associado a outra AWS conta.