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, talvez você queira usar uma conta para seu funil e outra para seus CodeDeploy recursos.

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

Nesta apresentação e nos seus exemplos, Conta A é a conta usada originalmente 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 usados por. CodeDeploy

Para que o AccountA edite um pipeline para usar o CodeDeploy aplicativo criado pelo AccountB, o AccountA deve:

  • Solicitar o ID da conta ou o Nome de região da Amazon (ARN) da Conta B (nesta apresentação, o ID da Conta B é 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) e AccountB.

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

  • Crie uma política que permita que a AccountA assuma uma função configurada pelo AccountB e anexe essa política à função de serviço (_Service_Role). CodePipeline

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

Para que a Conta A permita o acesso aos seus recursos a um pipeline criado na Conta A, a Conta B deve:

  • Solicitar o ID da conta ou o nome de região da Amazon (ARN) da Conta A (nesta apresentação, o ID da Conta A é 012ID_ACCOUNT_A).

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

  • Crie uma política aplicada à função de instância do Amazon EC2 configurada para CodeDeploy permitir o acesso à chave gerenciada pelo AWS KMS cliente usada para criptografar os artefatos do pipeline na 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 CodePipeline de serviço na AccountA assuma a função.

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

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

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 with AccountA e abra o AWS KMS console.

  2. À esquerda, escolha Chaves gerenciadas pelo cliente.

  3. Escolha Create key (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 de AccountB para concluir o ARN e selecione Próximo.

  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 da Conta A e da Conta B.

Configurar 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, o AccountA deve 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 with 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, em que 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, -2-1234567890). codepipeline-us-east

  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 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 para o bucket do Amazon S3 é -2-1234567890. codepipeline-us-east 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"
	}
   ]
}

  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, escolha Perfis.

  3. Na lista de funções, em Nome da função, escolha o nome da função de serviço para 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 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/*"
       ]
   }
 }

  6. Escolha Revisar política.

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

Configure políticas e funções na conta que possui o 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 instância do Amazon EC2. (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 no AccountA use CodeDeploy recursos criados no AccountB, 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.

  • Criar uma segunda função na Conta B configurada para o acesso entre contas.

    Essa segunda função não deve apenas ter acesso ao bucket do Amazon S3 na AccountA, mas também deve conter uma política que permita o acesso aos CodeDeploy recursos e uma política de relacionamento de confiança que permita que a função de serviço na AccountA CodePipeline assuma 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 instância do Amazon EC2 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, escolha 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 instância do Amazon EC2 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 instâncias do Amazon EC2.

  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 pela AccountA para armazenar artefatos para pipelines (neste exemplo, -2-1234567890): codepipeline-us-east

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

  6. Escolha Revisar política.

  7. Em Name (Nome), insira um nome para essa política. Escolha 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 na AccountA e configurada para permitir que o 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"
          ]
      }
   ]
}
    Importante

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

  9. Escolha Revisar política.

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

Agora, crie uma função do IAM para usar no acesso entre contas e configure-a para que a função de CodePipeline serviço na 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 na 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, escolha Roles. 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 conta, insira a AWS ID da conta que criará o pipeline em CodePipeline (AccountA) e escolha Avançar: Permissões.

    Importante

    Esta etapa cria a política de relação de confiança entre a AccountB e a AccountA. No entanto, isso concede acesso de nível raiz à conta e CodePipeline recomenda reduzir o escopo até a função de CodePipeline serviço na AccountA. Siga a etapa 16 para restringir as 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. 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 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:

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

  9. Escolha Revisar política.

  10. Em Name (Nome), insira um nome para essa política. Escolha 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 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/*"
       ]
     }
   ]
}

  13. Escolha Revisar política.

  14. Em Name (Nome), insira um nome para essa política. Escolha 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 um principal na coluna da esquerda. Em Tipo principal, escolha IAM Roles e, em seguida, forneça o ARN para a função de CodePipeline serviço em AccountA. Remova arn:aws:iam::Account_A:root da lista de AWS diretores e escolha 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 semelhante ao seguinte:

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

    A saída é enviada ao 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 é o nome do bucket do Amazon S3 usado para armazenar artefatos para o pipeline e é o ARN da chave gerenciada pelo cliente que você acabou de criar: 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. Adicione uma ação de implantação em um estágio para usar os CodeDeploy recursos associados ao AccountB, incluindo roleArn os 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 chamada ExternalDeploy. Ele usa os CodeDeploy recursos criados no AccountB em um estágio chamado Staging. 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"
                    }
                ]
            }
    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 ter 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á um erro se tentar visualizar os detalhes para a ação enquanto estiver conectado na AccountA. Saia e, em seguida, entre com AccountB para ver os detalhes da implantação. CodeDeploy