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

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

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á o AccountB acesso aos artefatos do pipeline e permitirá adicionar artefatos de saída se uma ação, como uma fonte personalizada ou uma ação de construção, os criar. AccountB

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

No painel de navegação, selecione Perfis.

Na lista de funções, em Role Name (Nome da função), selecione o nome da função de serviço para o 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 você assuma AccountB a função. 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 with AccountB e abra o console do IAM em https://console.aws.amazon.com/iam/.

No painel de navegação, selecione 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 instância do IAM para suas EC2 instâncias da Amazon.

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 do Amazon S3 usado AccountA por para armazenar artefatos para 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 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:

{
    "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 with AccountB e abra o console do IAM em https://console.aws.amazon.com/iam.

No painel de navegação, selecione Perfis. 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 escolha Avançar: Permissões.

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

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.

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.

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

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

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.

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

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

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

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.

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.