

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Crea una canalización CodePipeline que utilice recursos de otra AWS cuenta
<a name="pipelines-create-cross-account"></a>

Puede ser conveniente crear una canalización que use recursos creados o administrados por otra cuenta de AWS . Por ejemplo, podría ser conveniente usar una cuenta para una canalización y otra para los recursos de CodeDeploy . 

**nota**  
Al crear una canalización con acciones de varias cuentas, debe configurar sus acciones para que puedan obtener acceso a los artefactos en las limitaciones de las canalizaciones entre cuentas. Las siguientes limitaciones se aplican a las acciones entre cuentas:  
En general, una acción solo puede consumir un artefacto si:  
La acción está en la misma cuenta que la cuenta de canalización, o
El artefacto se creó en la cuenta de la canalización para una acción en otra cuenta, o 
El artefacto se produjo por una acción anterior en la misma cuenta que la acción
En otras palabras, no puede pasar un artefacto de una cuenta a otra si ninguna de las dos cuentas es la de canalización.
No se admiten las acciones entre cuentas para los siguientes tipos de acción:  
Acciones de compilación Jenkins

Para este ejemplo, debes crear una clave AWS Key Management Service (AWS KMS) para utilizarla, añadir la clave a la canalización y configurar las políticas y funciones de la cuenta para permitir el acceso entre cuentas. Para una clave AWS KMS, puede usar el ID de clave, el ARN de clave o el alias ARN. 

**nota**  
Los alias se reconocen únicamente en la cuenta que ha creado la clave de KMS. Para las acciones entre cuentas, solo puede utilizar el ID de clave o un ARN de clave para identificar la clave. Las acciones entre cuentas implican el uso del rol de la otra cuenta (AccountB), por lo que al especificar el ID de clave se utilizará la clave de la otra cuenta (AccountB).

En este tutorial y en sus ejemplos, *AccountA* se muestra la cuenta que se utilizó originalmente para crear la canalización. Tiene acceso al bucket de Amazon S3 que se utiliza para almacenar los artefactos de la canalización y a la función de servicio que utiliza AWS CodePipeline. *AccountB*es la cuenta utilizada originalmente para crear la CodeDeploy aplicación, el grupo de implementación y el rol de servicio que utilizaba CodeDeploy. 

*AccountA*Para editar una canalización y utilizar la CodeDeploy aplicación creada por ella*AccountB*, *AccountA* debe: 
+ Solicita el ARN o el ID de cuenta de *AccountB* (en este tutorial, el *AccountB* ID es). *012ID\$1ACCOUNT\$1B*
+ Cree o use una clave administrada por el AWS KMS cliente en la región para la canalización y otorgue permisos para usar esa clave para el rol de servicio (*CodePipeline\$1Service\$1Role*) y. *AccountB* 
+ Cree una política de bucket de Amazon S3 que conceda *AccountB* acceso al bucket de Amazon S3 (por ejemplo,*codepipeline-us-east-2-1234567890*). 
+ Cree una política que permita *AccountA* asumir una función configurada por *AccountB* y adjunte esa política a la función de servicio (*CodePipeline\$1Service\$1Role*).
+ Edite la canalización para usar la AWS KMS clave administrada por el cliente en lugar de la clave predeterminada.

*AccountB*Para permitir el acceso a sus recursos a una canalización creada en*AccountA*, *AccountB* debe:
+ Solicita el ARN o el ID de cuenta de *AccountA* (en este tutorial, el *AccountA* ID es). *012ID\$1ACCOUNT\$1A*
+ Cree una política que se aplique al [rol de instancia de Amazon EC2](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-iam-instance-profile.html) configurado para CodeDeploy el acceso al bucket de Amazon S3 ()*codepipeline-us-east-2-1234567890*.
+ Cree una política que se aplique al [rol de instancia de Amazon EC2](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-iam-instance-profile.html) configurado para el acceso a la clave administrada por el AWS KMS cliente CodeDeploy que se utiliza para cifrar los artefactos de la canalización. *AccountA*
+ Configure y asocie un rol de IAM (*CrossAccount\$1Role*) con una política de relación de confianza que permita que el rol de CodePipeline servicio asuma el *AccountA* rol.
+ Cree una política que permita el acceso a los recursos de despliegue necesarios para la canalización y adjúntela a *CrossAccount\$1Role* ella.
+ Cree una política que permita el acceso al bucket de Amazon S3 (*codepipeline-us-east-2-1234567890*) y adjúntelo a*CrossAccount\$1Role*.

**Topics**
+ [

## Requisito previo: cree una clave AWS KMS de cifrado
](#pipelines-create-cross-account-create-key)
+ [

## Paso 1: Configurar roles y políticas de cuenta
](#pipelines-create-cross-account-setup)
+ [

## Paso 2: Editar la canalización
](#pipelines-create-cross-account-create)

## Requisito previo: cree una clave AWS KMS de cifrado
<a name="pipelines-create-cross-account-create-key"></a>

Las claves administradas por el cliente son específicas de una región, al igual que todas AWS KMS las claves. Debes crear tu AWS KMS clave gestionada por el cliente en la misma región en la que se creó la canalización (por ejemplo,`us-east-2`).

**Para crear una clave gestionada por el cliente en AWS KMS**

1. Inicie sesión en Consola de administración de AWS with *AccountA* y abra la AWS KMS consola.

1. A la izquierda, seleccione **Claves administradas por el cliente**.

1. Elija **Crear clave**. En la **Configurar clave**, deje el valor predeterminado **Simétrico** seleccionado y elija **Siguiente**.

1. En **Alias**, introduce un alias para usarlo en esta clave (por ejemplo,*PipelineName-Key*). Opcionalmente, proporcione una descripción y las etiquetas de esta clave; después, elija **Paso siguiente**.

1. En **Definir permisos de administración de claves**, elija su usuario de y cualesquiera otros usuarios o grupos que desee que actúen como administradores de esta clave y, a continuación, elija **Siguiente**.

1. En **Definir permisos de uso de claves**, en **Esta cuenta**, seleccione el nombre del rol de servicio de la canalización (por ejemplo, CodePipeline \$1Service\$1Role). En **Otras AWS cuentas**, selecciona **Añadir** otra cuenta. AWS **Introduzca el ID de cuenta *AccountB* para completar el ARN y, a continuación, seleccione Siguiente.**

1. En **Revisar y editar política de claves**, revise la política y, después, elija **Terminar**.

1. En la lista de claves, elija el alias de la clave y copie su ARN (por ejemplo, ***arn:aws:kms:us-east-2:012ID\$1ACCOUNT\$1A:key/2222222-3333333-4444-556677EXAMPLE***). Lo necesitará cuando edite la canalización y configure las políticas.

## Paso 1: Configurar roles y políticas de cuenta
<a name="pipelines-create-cross-account-setup"></a>

Después de crear la AWS KMS clave, debe crear y adjuntar políticas que permitan el acceso entre cuentas. Esto requiere acciones tanto de parte como *AccountA* de. *AccountB*

**Topics**
+ [

### Configure las políticas y las funciones en la cuenta que creará la canalización (*AccountA*)
](#pipelines-create-cross-account-setup-accounta)
+ [

### Configure las políticas y las funciones en la cuenta propietaria del AWS recurso () *AccountB*
](#pipelines-create-cross-account-setup-accountb)

### Configure las políticas y las funciones en la cuenta que creará la canalización (*AccountA*)
<a name="pipelines-create-cross-account-setup-accounta"></a>

Para crear una canalización que utilice CodeDeploy los recursos asociados a otra AWS cuenta, *AccountA* debe configurar políticas tanto para el bucket de Amazon S3 que se utiliza para almacenar los artefactos como para la función de servicio CodePipeline.

**Para crear una política para el bucket de Amazon S3 que concede acceso a AccountB (consola)**

1. Inicie sesión en Consola de administración de AWS with *AccountA* y abra la consola de Amazon S3 en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. En la lista de buckets de Amazon S3, elija el bucket de Amazon S3 en el que se almacenan los artefactos para la canalización. Este depósito recibe el nombre `codepipeline-region-1234567EXAMPLE` de la AWS región en la que creó la canalización y *1234567EXAMPLE* es un número aleatorio de diez dígitos que garantiza que el nombre del depósito sea único (por ejemplo,*codepipeline-us-east-2-1234567890*). *region*

1. En la página de detalles del bucket de Amazon S3, elija **Propiedades**.

1. En el panel de propiedades, expanda **Permisos** y después elija **Añadir política de bucket**.
**nota**  
Si ya hay una política asociada al bucket de Amazon S3, elija **Editar política de bucket**. A continuación, puede añadir las instrucciones del siguiente ejemplo a la política. Para añadir una nueva política, selecciona el enlace y sigue las instrucciones del generador de AWS políticas. Para obtener más información, consulte [Información general de las políticas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/policies_overview.html). 

1. En la ventana del **editor de políticas de Bucket**, cree una política que permita el *AccountB* acceso a los artefactos de *AccountB* la canalización y que permita añadir los artefactos de salida si los crea una acción, como una fuente personalizada o una acción de compilación. 

1. Elija **Guardar** y, a continuación, cierre el editor de políticas.

1. Elija **Guardar** para guardar los permisos para el bucket de Amazon S3.

**Para crear una política para el rol de servicio de CodePipeline (consola)**

1. Inicie sesión en Consola de administración de AWS with *AccountA* y abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

1. Seleccione **Roles** en el panel de navegación.

1. En la lista de funciones, bajo **Role Name (Nombre de función)**, elija el nombre de la función de servicio para CodePipeline.

1. En la pestaña **Permisos**, elija **Añadir política en línea**.

1. Seleccione la pestaña **JSON** e introduzca la siguiente política para poder *AccountB* asumir el rol. En el siguiente ejemplo, *012ID\$1ACCOUNT\$1B* es el ARN de: *AccountB*

------
#### [ JSON ]

****  

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

------

1. Elija **Revisar política**. 

1. En **Name (Nombre)**, introduzca un nombre para esta política. Elija **Crear política**.

### Configure las políticas y las funciones en la cuenta propietaria del AWS recurso () *AccountB*
<a name="pipelines-create-cross-account-setup-accountb"></a>

Al crear una aplicación, una implementación y un grupo de implementaciones en CodeDeploy, también crea una función de [instancia de Amazon EC2](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-iam-instance-profile.html). (Este rol se crea automáticamente cuando se usa el asistente para ejecutar la implementación, pero también puede crearlo manualmente). Para que una canalización creada en *AccountA* utilice CodeDeploy los recursos creados en*AccountB*, debe: 
+ Configurar una política para el rol de instancia que le permita el acceso al bucket de Amazon S3 donde se almacenan los artefactos de la canalización.
+ Cree un segundo rol si *AccountB* está configurado para el acceso entre cuentas.

  Esta segunda función no solo debe tener acceso al bucket de Amazon S3*AccountA*, sino que también debe contener una política que permita el acceso a los CodeDeploy recursos y una política de relación de confianza que permita que la función de CodePipeline servicio asuma la función. *AccountA*
**nota**  
Estas políticas son específicas para configurar CodeDeploy los recursos que se utilizarán en una canalización creada con una AWS cuenta diferente. Otros AWS recursos requerirán políticas específicas para sus necesidades de recursos.

**Para crear una política para el rol de instancia de Amazon EC2 configurado para CodeDeploy (consola)**

1. Inicie sesión en Consola de administración de AWS with *AccountB* y abra la consola de IAM en. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)

1. Seleccione **Roles** en el panel de navegación.

1. En la lista de funciones, en **Nombre de función**, elija el nombre de la función de servicio utilizada como función de instancia de Amazon EC2 para la CodeDeploy aplicación. El nombre de este rol puede variar, y un grupo de implementaciones puede usar más de un rol de instancia. Para obtener más información, consulte [Crear un perfil de instancia de IAM para sus instancias de Amazon EC2](https://docs.aws.amazon.com/codedeploy/latest/userguide/how-to-create-iam-instance-profile.html). 

1. En la pestaña **Permisos**, elija **Añadir política en línea**.

1. Elija la pestaña **JSON** e introduzca la siguiente política para conceder acceso al bucket de Amazon S3 que utiliza *AccountA* para almacenar artefactos para canalizaciones (en este ejemplo,*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"
          ]
        }
      ]
    }
   ```

------

1. Elija **Revisar política**. 

1. En **Name (Nombre)**, introduzca un nombre para esta política. Elija **Crear política**.

1. Cree una segunda política para AWS KMS determinar dónde ***arn:aws:kms:us-east-1:012ID\$1ACCOUNT\$1A:key/2222222-3333333-4444-556677EXAMPLE*** está el ARN de la clave administrada por el cliente creada *AccountA* y configurada *AccountB* para permitir su 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**  
Debe usar el identificador de cuenta de *AccountA* esta política como parte del ARN del recurso para la AWS KMS clave, como se muestra aquí, o la política no funcionará.

1. Elija **Revisar política**. 

1. En **Name (Nombre)**, introduzca un nombre para esta política. Elija **Crear política**.

Ahora cree una función de IAM para utilizarla en el acceso entre cuentas y configúrela para que la función de CodePipeline servicio *AccountA* pueda asumir esa función. Esta función debe contener políticas que permitan el acceso a los CodeDeploy recursos y al bucket de Amazon S3 que se utiliza para almacenar los artefactos*AccountA*.

**Para configurar el rol de acceso entre cuentas en IAM**

1. Inicie sesión en Consola de administración de AWS with *AccountB* y abra la consola de IAM en [https://console.aws.amazon.com/iam.](https://console.aws.amazon.com/iam)

1. Seleccione **Roles** en el panel de navegación. Elija **Create role** (Crear rol).

1. En **Seleccione el tipo de entidad de confianza**, elija **Otra cuenta de AWS )**. En **Especificar las cuentas que pueden usar esta función**, en **ID de cuenta**, introduce el ID de AWS cuenta de la cuenta que creará la canalización en CodePipeline (*AccountA*) y, a continuación, selecciona **Siguiente**: permisos.
**importante**  
Este paso crea la política de relación de confianza entre *AccountB* y*AccountA*. Sin embargo, esto otorga acceso de nivel raíz a la cuenta y se CodePipeline recomienda limitarlo a la función de CodePipeline servicio en *AccountA* la que se encuentra. Siga el paso 16 para restringir los permisos.

1. En **Adjuntar políticas de permisos**, selecciona **AmazonS3** yReadOnlyAccess, a continuación, selecciona **Siguiente: etiquetas**.
**nota**  
Esta no es la política que usará. Debe elegir una política para completar el asistente.

1. Elija **Siguiente: Revisar**. Escriba un nombre para este rol en **Nombre del rol** (por ejemplo,*CrossAccount\$1Role*). Puede dar a este rol el nombre que desee, siempre y cuando siga las convenciones de nomenclatura de IAM. Considere dar al rol un nombre que indique claramente su finalidad. Seleccione **Crear rol**.

1. En la lista de funciones, elija la función que acaba de crear (por ejemplo,*CrossAccount\$1Role*) para abrir la página de **resumen** de esa función.

1. En la pestaña **Permisos**, elija **Añadir política en línea**. 

1. Elija la pestaña **JSON** e introduzca la siguiente política para permitir el acceso a CodeDeploy los recursos:

------
#### [ JSON ]

****  

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

------

1. Elija **Revisar política**.

1. En **Name (Nombre)**, introduzca un nombre para esta política. Elija **Crear política**.

1. En la pestaña **Permisos**, elija **Añadir política en línea**.

1. Elija la pestaña **JSON** e introduzca la siguiente política para permitir que esta función recupere los artefactos de entrada y coloque los artefactos de salida en el bucket de Amazon S3*AccountA*:

------
#### [ JSON ]

****  

   ```
   {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
        {
          "Effect": "Allow",
          "Action": [
            "s3:GetObject*",
            "s3:PutObject",
            "s3:PutObjectAcl"               
          ],
          "Resource": [
            "arn:aws:s3:::amzn-s3-demo-bucket/*"
          ]
        }
      ]
   }
   ```

------

1. Elija **Revisar política**.

1. En **Name (Nombre)**, introduzca un nombre para esta política. Elija **Crear política**.

1. En la pestaña **Permisos**, busque **AmazonS3 ReadOnlyAccess** en la lista de políticas que aparece debajo del **nombre de la política** y elija el icono de eliminación (**X**) situado junto a la política. Cuando se le pregunte, elija **Separar**.

1. Seleccione la pestaña **Relación de confianza** y, a continuación, **Editar la política de confianza**. Seleccione la opción **Agregar una entidad principal** en la columna de la izquierda. En el **tipo principal**, elija **Funciones de IAM** y, a continuación, proporcione el ARN de CodePipeline la función de servicio en. *AccountA* Elimine `arn:aws:iam::Account_A:root` de la lista de **Entidades principales de AWS ** y, a continuación, seleccione **Actualizar la política**.

## Paso 2: Editar la canalización
<a name="pipelines-create-cross-account-create"></a>

No puedes usar la CodePipeline consola para crear o editar una canalización que utilice recursos asociados a otra AWS cuenta. Sin embargo, puedes usar la consola para crear la estructura general de la canalización y, después, usarla AWS CLI para editar la canalización y añadir esos recursos. Como alternativa, puede usar la estructura de una canalización existente y agregarle los recursos manualmente. 

**Para añadir los recursos asociados a otra AWS cuenta (AWS CLI)**

1. En un terminal (Linux, macOS o Unix) o el símbolo del sistema (Windows), ejecute el comando **get-pipeline** para la canalización a la que desea añadir recursos. Copie el resultado del comando a un archivo JSON. Por ejemplo, para una canalización denominada MyFirstPipeline, debería escribir un texto similar al siguiente:

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

   El resultado se envía al archivo *pipeline.json*.

1. Abra el archivo JSON en cualquier editor de texto sin formato. Una vez `"type": "S3"` en el almacén de artefactos, añada la clave de cifrado de KMS, el ID y escriba la información, *codepipeline-us-east-2-1234567890* donde es el nombre del depósito de Amazon S3 que se utiliza para almacenar los artefactos de la canalización y ***arn:aws:kms:us-east-1:012ID\$1ACCOUNT\$1A:key/2222222-3333333-4444-556677EXAMPLE*** es el ARN de la clave gestionada por el cliente que acaba de crear:

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

1. Añada una acción de despliegue en una fase para utilizar los CodeDeploy recursos asociados*AccountB*, incluidos los `roleArn` valores del rol multicuenta que creó (). *CrossAccount\$1Role*

   En el siguiente ejemplo, se muestra un JSON que añade una acción de despliegue denominada*ExternalDeploy*. Utiliza los CodeDeploy recursos creados *AccountB* en una etapa llamada*Staging*. En el siguiente ejemplo, el ARN de es: *AccountB* *012ID\$1ACCOUNT\$1B*

   ```
   ,
               {
                   "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 no es el JSON para toda la canalización, sino solo la estructura de la acción en una etapa.

1. Debe eliminar las líneas `metadata` del archivo para que el comando **update-pipeline** pueda utilizarlo. Quite la sección de la estructura de canalizaciones del archivo JSON (las líneas `"metadata": { }` y los campos `"created"`, `"pipelineARN"` y `"updated"` que contenga).

   Por ejemplo, quite las siguientes líneas de la estructura: 

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

   Guarde el archivo.

1.  Para aplicar los cambios, ejecute el comando **update-pipeline**, especificando el archivo JSON de la canalización, de forma similar a como se muestra a continuación:
**importante**  
Asegúrese de incluir `file://` antes del nombre de archivo. Es obligatorio en este comando.

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

   Este comando devuelve la estructura completa de la canalización editada.

**Para probar la canalización que utiliza los recursos asociados a otra cuenta AWS**

1. En un terminal (Linux, macOS o Unix) o el símbolo del sistema (Windows), ejecute el comando **start-pipeline-execution**, especificando el nombre de la canalización, de un modo similar al siguiente:

   ```
   aws codepipeline start-pipeline-execution --name MyFirstPipeline
   ```

   Para obtener más información, consulte [Iniciar la canalización manualmente](pipelines-rerun-manually.md).

1. Inicia sesión en Consola de administración de AWS with *AccountA* y abre la CodePipeline consola en [http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

   Se muestran los nombres de todas las canalizaciones asociadas a tu AWS cuenta.

1. En **Name**, elija el nombre de la canalización que acaba de editar. Esto abre una vista detallada de la canalización, que incluye el estado de cada acción en cada etapa de la canalización.

1. Vea el progreso en la canalización. Espere a que aparezca un mensaje de éxito sobre la acción que utiliza el recurso asociado a otra AWS cuenta.
**nota**  
Recibirás un error si intentas ver los detalles de la acción con la sesión iniciada*AccountA*. Cierre sesión y, a continuación, inicie sesión con *AccountB* para ver los detalles de la implementación CodeDeploy. 