Creación y adición de una acción personalizada en CodePipeline

Para crear una acción personalizada con la AWS CLI

1. Abra un editor de texto y cree un archivo JSON para la acción personalizada que incluye la categoría de acción, el proveedor de la acción y cualquier configuración que requiera la acción del cliente. Por ejemplo, para crear una acción de compilación personalizada que requiera solo una propiedad, el archivo JSON podría tener este aspecto:

   {
       "category": "Build",
       "provider": "My-Build-Provider-Name",
       "version": "1",
       "settings": {
           "entityUrlTemplate": "https://my-build-instance/job/{Config:ProjectName}/",
           "executionUrlTemplate": "https://my-build-instance/job/{Config:ProjectName}/lastSuccessfulBuild/{ExternalExecutionId}/"
       },
       "configurationProperties": [{
           "name": "ProjectName",
           "required": true,
           "key": true,
           "secret": false,
           "queryable": false,
           "description": "The name of the build project must be provided when this action is added to the pipeline.",
           "type": "String"
       }],
       "inputArtifactDetails": {
           "maximumCount": integer,
           "minimumCount": integer
       },
       "outputArtifactDetails": {
           "maximumCount": integer,
           "minimumCount": integer
       },
       "tags": [{
         "key": "Project",
         "value": "ProjectA"
       }]
   }

   Este ejemplo añade el etiquetado a la acción personalizada incluyendo la clave de etiqueta Project y el valor ProjectA a la acción personalizada. Para obtener más información acerca del etiquetado de recursos de CodePipeline, consulte Etiquetado de recursos.

   El archivo JSON incluye dos propiedades, entityUrlTemplate y executionUrlTemplate. Puede consultar un nombre en las propiedades de configuración de la acción personalizada dentro de las plantillas URL si sigue el formato de {Config:name}, siempre y cuando la propiedad de configuración sea obligatoria y no sea secreta. Poe ejemplo, en el ejemplo anterior, el valor entityUrlTemplate hace referencia a la propiedad de configuración ProjectName.

   • entityUrlTemplate: el enlace estático que proporciona información acerca del proveedor de servicios de la acción. En el ejemplo, el sistema de compilación incluye un enlace estático a cada proyecto de compilación. El formato del enlace variará según su proveedor de compilación (o bien, si crea un tipo de acción diferente, como una prueba, otro proveedor de servicios). Debe proporcionar este formato de enlace para que cuando se añada la acción del cliente, el usuario pueda elegir este enlace para abrir un explorador en una página de su sitio web que proporcione la información específica del proyecto de compilación (o entorno de prueba).

   • executionUrlTemplate: el enlace dinámico que se actualizará con información acerca de la ejecución actual o más reciente de la acción. Cuando el empleado de trabajo personalizado actualiza el estado de este (por ejemplo, se ha realizado correctamente, error o en progreso), también proporcionará un externalExecutionId que se usará para completar el enlace. Este enlace se puede usar para proporcionar detalles acerca de la ejecución de una acción.

   Por ejemplo, al ver la acción en la canalización, verá los siguientes dos enlaces:

   

   Este enlace estático aparece después de añadir su acción personalizada y apunta a la dirección en entityUrlTemplate, la que especifica al crear su acción personalizada.

   Este enlace dinámico se actualiza después de cada ejecución de la acción y apunta a la dirección en executionUrlTemplate, la que especifica al crear su acción personalizada.

   Para obtener más información acerca de estos tipos de enlaces, así como RevisionURLTemplate y ThirdPartyURL, consulte ActionTypeSettings y CreateCustomActionType en la CodePipeline API Reference. Para obtener más información acerca de los requisitos de estructura de acción y cómo crear una acción, consulte Referencia de estructura de canalización de CodePipeline.

2. Guarde el archivo JSON y asígnele un nombre que pueda recordar fácilmente (por ejemplo, MyCustomAction.json).

3. Abra una sesión de terminal (Linux, OS X, Unix) o el símbolo del sistema (Windows) en un equipo en el que haya instalado la AWS CLI.

4. Use AWS CLI para ejecutar el comando aws codepipeline create-custom-action-type especificando el nombre del archivo JSON que acaba de crear.

   Por ejemplo, para crear una acción personalizada de compilación:

   importante

   Asegúrese de incluir file:// antes del nombre de archivo. Es obligatorio en este comando.

   aws codepipeline create-custom-action-type --cli-input-json file://MyCustomAction.json

5. Este comando devuelve toda la estructura de la acción personalizada que ha creado, así como la propiedad de configuración de la acción JobList, que ya se ha añadido. Al añadir una acción personalizada a una canalización, puede usar JobList para especificar los proyectos del proveedor que puede sondear en búsqueda de trabajos. Si no configura esto, todos los trabajos disponibles se devolverán cuando el empleado de trabajo personalizado sondee trabajos.

   Por ejemplo, el comando anterior podría devolver una estructura similar a la siguiente:

   {
       "actionType": {
           "inputArtifactDetails": {               
               "maximumCount": 1,                
               "minimumCount": 1
          },
          "actionConfigurationProperties": [
               {
                   "secret": false,
                   "required": true,
                   "name": "ProjectName",
                   "key": true,
                   "description": "The name of the build project must be provided when this action is added to the pipeline."
               }
           ],
           "outputArtifactDetails": {               
               "maximumCount": 0,                
               "minimumCount": 0
           },
           "id": {
               "category": "Build",
               "owner": "Custom",
               "version": "1",
               "provider": "My-Build-Provider-Name"
           },
           "settings": {
               "entityUrlTemplate": "https://my-build-instance/job/{Config:ProjectName}/",
               "executionUrlTemplate": "https://my-build-instance/job/mybuildjob/lastSuccessfulBuild/{ExternalExecutionId}/"
           }
       }
   }

   nota

   Como parte de la salida del comando create-custom-action-type, la sección id incluye "owner": "Custom". CodePipeline asigna automáticamente Custom como propietario de los tipos de acciones personalizadas. Este valor no se puede asignar ni cambiar cuando usa el comando create-custom-action-type o el comando update-pipeline.

Para configurar instancias de Amazon EC2

1. Obtenga más información acerca de Amazon EC2 y determine si es la opción correcta para su integración. Para más información, consulte Amazon EC2 - Alojamiento de servidores virtuales.

2. Comience a crear sus instancias de Amazon EC2. Para obtener información, consulte Introducción a instancias de Linux con Amazon EC2.

Para configurar la identidad federada

1. Obtenga más información acerca de la federación de identidades de IAM. Para obtener información, consulte Administrar federación.

2. Revise los ejemplos en Escenarios para conceder acceso temporal para identificar el escenario de acceso temporal que mejor se adapte a las necesidades de su acción personalizada.

3. Revise los ejemplos de códigos de identidad federada pertinentes a su infraestructura, como:

   • Aplicación de la muestra de identidad federada para un caso de uso de Active Directory

4. Comience a configurar una identidad federada. Para obtener información, consulte Federación y proveedores de identidades en la Guía de usuarios de IAM.

1. Abra una sesión de terminal (Linux, macOS, or Unix) o el símbolo del sistema (Windows) y ejecute el comando get-pipeline para copiar la estructura de canalización que desee editar en un archivo JSON. Por ejemplo, para una canalización denominada MyFirstPipeline, debería escribir el siguiente comando:

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

   Este comando no devuelve nada, pero el archivo creado debería aparecer en el directorio en el que se ejecutó el comando.

2. Abra el archivo JSON en cualquier editor de texto y modifique la estructura del archivo para añadir su acción personalizada a la etapa existente.

   nota

   Si desea que su acción se ejecute en paralelo con otra acción en esa etapa, asegúrese de asignarla al mismo valor de runOrder que esa acción.

   Por ejemplo, para modificar la estructura de una canalización que permita añadir una etapa denominada Build y añadir una acción personalizada de compilación a esa etapa, es posible modificar el JSON para añadir la etapa Build antes de una etapa de implementación de la siguiente manera:

   ,
       {
         "name": "MyBuildStage",
         "actions":  [
                 {
                   "inputArtifacts": [
                   {
                      "name": "MyApp"
                    }
                      ],
                       "name": "MyBuildCustomAction",
                       "actionTypeId": {
                           "category": "Build",
                           "owner": "Custom",
                           "version": "1",
                           "provider": "My-Build-Provider-Name"
                       },
                       "outputArtifacts": [
                           {
                             "name": "MyBuiltApp"
                           }
                       ],
                       "configuration": {
                           "ProjectName": "MyBuildProject"
                       },
                       "runOrder": 1
                   }
               ]
           },      
           {
               "name": "Staging",
               "actions": [
                       {
                           "inputArtifacts": [
                               {
                                   "name": "MyBuiltApp"
                               }
                           ],
                           "name": "Deploy-CodeDeploy-Application",
                           "actionTypeId": {
                               "category": "Deploy",
                               "owner": "AWS",
                               "version": "1",
                               "provider": "CodeDeploy"
                           },
                           "outputArtifacts": [],
                           "configuration": {
                               "ApplicationName": "CodePipelineDemoApplication",
                               "DeploymentGroupName": "CodePipelineDemoFleet"
                           },
                           "runOrder": 1
                       }
                   ]
                }      
       ]
   }

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

4. Abra la consola de CodePipeline y elija el nombre de la canalización que acaba de editar.

   La canalización muestra los cambios. La próxima vez que haga un cambio en la ubicación de código fuente, la canalización ejecutará dicha revisión a través de la estructura revisada de la canalización.