# Pipelines ## Componentes de ayuda ### catalyst-pipelines.yaml -------------------------------------------------------------------------------- title: "Introducción" description: "Conoce el servicio Catalyst Pipelines y los conceptos básicos de las definiciones del esquema YAML." last_updated: "2026-07-02T09:34:15.875Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/catalyst-pipelines.yaml/introduction/" service: "Pipelines" related: - Pipeline Triggers (/es/pipelines/help/triggers/introduction) -------------------------------------------------------------------------------- # catalyst-pipelines.yaml # Introducción El archivo catalyst-pipelines.yaml funciona como el componente central para ejecutar el pipeline, donde se define su flujo de trabajo. Puedes definir el flujo de ejecución del pipeline en este archivo agregando los componentes del pipeline requeridos mediante nuestro editor de código integrado o el constructor visual. Puedes consultar esta página de ayuda para obtener más información sobre la configuración del pipeline. Ya sea que el pipeline se active manualmente o automáticamente, este archivo dicta las acciones del pipeline. Si tu pipeline está vinculado a un sistema de control de versiones, cualquier modificación en el código fuente del repositorio vinculado activa automáticamente la ejecución del pipeline, ejecutando el flujo de trabajo definido en este archivo. De manera similar, cuando el pipeline se activa manualmente desde la consola de Catalyst, este archivo se ejecuta directamente desde la interfaz de la consola. Antes de profundizar en las definiciones predefinidas del esquema YAML de Catalyst Pipelines y su uso, tomemos un momento para explorar YAML en términos generales. Un archivo YAML es un formato versátil para representar datos estructurados en diversos contextos, como archivos de configuración, intercambio de datos y serialización. Las características comunes de un archivo YAML incluyen: * YAML no está vinculado a ningún lenguaje de programación específico, lo que lo hace adecuado para el intercambio de datos entre diferentes sistemas y plataformas. * Este archivo se compone de pares clave-valor simples, listas y mapas, que pueden combinarse y anidarse para representar estructuras de datos y configuraciones complejas. * Utiliza la indentación para definir la estructura de los datos. * YAML admite varios tipos de datos, incluyendo escalares (strings, enteros, flotantes, booleanos, null), listas, mapas (pares clave-valor) y estructuras anidadas. Catalyst Pipelines sigue sus propios estándares de esquema YAML, que deben respetarse estrictamente al configurar el pipeline. En la siguiente sección, profundizaremos en las definiciones del esquema YAML de Catalyst. -------------------------------------------------------------------------------- title: "Referencia del esquema" description: "Conoce en detalle las definiciones de esquema predefinidas del archivo catalyst-pipelines.yaml." last_updated: "2026-07-02T09:34:15.876Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/catalyst-pipelines.yaml/schema-reference/" service: "Pipelines" -------------------------------------------------------------------------------- # Referencia del esquema La referencia del esquema YAML para Catalyst Pipelines describe las claves predefinidas para los diversos componentes del pipeline. Utilizando estas claves, puedes incorporar los componentes necesarios y definir el flujo de ejecución del pipeline. A continuación se analizan los componentes en detalle en sus respectivas páginas de ayuda. Puedes comenzar desde aquí. Consulta esta página para obtener más información sobre la configuración del pipeline desde la consola de Catalyst. ### Definiciones YAML A continuación se muestra la lista de claves compatibles en Catalyst para el archivo catalyst-pipelines.yaml. <table class="content-table"> <thead> <tr> <th>Keyword</th> <th>Descripción</th> </tr> </thead> <tbody> <tr> <td>version</td> <td>La versión del pipeline se puede definir como cualquier valor entero, con el propósito de preservar las configuraciones del pipeline como versiones distintas y reutilizables.</td> </tr> <tr> <td>runners</td> <td>Un runner es una configuración de máquina virtual que se puede definir a nivel de stage o de job. Puedes definir la especificación del runner como valor de la clave config-id en runners. Obtén más información en esta página de ayuda.</td> </tr> <tr> <td>images</td> <td>Una image es un paquete o conjunto de dependencias requeridas para la ejecución de jobs en el pipeline. Las images se pueden definir a nivel de stage o de job. Puedes definir el nombre de la image en la clave image y la URL del registro de paquetes externo (como Dockerhub) en la clave registry. También debes definir la clave auth para autenticar el registro especificado. Obtén más información en esta página de ayuda. </td> </tr> <tr> <td>auth</td> <td>Para autenticar cualquier cuenta de registro externo y obtener los paquetes requeridos para la ejecución de jobs, deberás especificar las claves username y password en la clave auth. Puedes consultar esta sección de ayuda para saber más al respecto.</td> </tr> <tr> <td>variables</td> <td>Esta palabra clave se utiliza para almacenar valores de marcadores de posición a nivel de pipeline o de job. Consulta esta página de ayuda para más detalles.</td> </tr> <tr> <td>steps</td> <td>Son un conjunto de comandos que se pueden definir para llevar a cabo los procesos de compilación, prueba y despliegue en el pipeline. Puedes definir los steps según las aplicaciones que compilas, los procedimientos de prueba para ellas y los entornos en los que la aplicación debe desplegarse. Consulta esta página de ayuda para obtener más información sobre los steps.</td> </tr> <tr> <td>jobs</td> <td>Un job es una secuencia de steps definidos en un stage. Puedes definir hasta cinco jobs dentro de un stage, y bajo cada job, puedes definir steps, variables, runners e images utilizando la clave jobs. Si has configurado el pipeline para compilar tu aplicación antes de probarla o desplegarla, puedes almacenar temporalmente los archivos de compilación generados de tu código en el servicio Catalyst Stratus. Estas configuraciones se pueden definir utilizando la clave artifacts. Esta clave incluye dos subclaves adicionales llamadas notify y approve. Puedes obtener más información en detalle en esta página de ayuda. </td> </tr> <tr> <td>notify</td> <td>Esta clave te permite enviar notificaciones ya sea al inicio de la ejecución del job o tras la finalización exitosa del job. Puedes utilizar las claves on-start u on-end para este propósito. Consulta esta sección de ayuda para más detalles.</td> </tr> <tr> <td>approve</td> <td>Esta clave se utiliza para jobs de aprobación para definir los detalles del revisor del job y el mensaje de aprobación personalizado. Puedes establecer el tipo de aprobación utilizando la subclave type-name y agregar la dirección de correo electrónico del revisor y un mensaje de revisión personalizado en la clave type-variables que incluye las subclaves reviewers y message, respectivamente. </td> </tr> <tr> <td>artifacts</td> <td>Esta clave se utiliza para representar el proceso de carga y descarga de los archivos de compilación de la aplicación generados durante la ejecución del pipeline. Para esto, puedes establecer los valores en las claves upload y download respectivamente. Puedes obtener más información sobre los artifacts en su página de ayuda.</td> </tr> <tr> <td>upload</td> <td>Esta clave se utiliza para almacenar los archivos zip de compilación generados en el servicio Catalyst Stratus. Debes definir el nombre del archivo de compilación, la ubicación en la que se debe almacenar el archivo y otras condiciones del archivo utilizando las subclaves name, location y files respectivamente.</td> </tr> <tr> <td>download</td> <td>Esta clave se puede utilizar para recuperar los archivos zip de compilación almacenados del servicio Catalyst Stratus. También puedes definir las subclaves name, location y files de manera similar a la palabra clave upload.</td> </tr> <tr> <td>stages</td> <td>Un stage es una fase distinta que contiene múltiples jobs. Puedes definir hasta cinco stages en un pipeline, cada uno conteniendo un conjunto de jobs. También puedes definir runners e images a nivel de stage.</td> </tr> <tr> <td>when-equal</td> <td>Esta clave se puede utilizar para evaluar si dos valores coinciden exactamente entre sí y proceder con el flujo de ejecución especificado del pipeline, solo si la validación resulta verdadera.</td> </tr> <tr> <td>when-not</td> <td>Esta clave se puede utilizar para evaluar si una condición particular es true o false. Según el resultado de la evaluación, se ejecutará el flujo de pipeline definido.</td> </tr> <tr> <td>when-not-equal</td> <td>Esta clave se puede utilizar para evaluar si dos valores no coinciden entre sí, y luego proceder a ejecutar el flujo de pipeline definido.</td> </tr> <tr> <td>when-and</td> <td>Esta clave se puede utilizar para evaluar si las dos condiciones definidas en la clave and resultan verdaderas. Si es así, se ejecuta el flujo definido en la condición when.</td> </tr> <tr> <td>when-or</td> <td>Esta clave se puede utilizar para evaluar si alguna de las condiciones definidas en la clave or resulta verdadera. Si es así, se ejecuta el flujo del pipeline definido en la clave when.</td> </tr> <tr> <td>pipeline-when</td> <td>La lógica condicional que se puede definir a nivel de pipeline, la cual dicta el flujo de ejecución de todo el pipeline. Puedes utilizar las claves and, equal, or, not, not-equal junto con la condición pipeline-when.</td> </tr> <tr> <td>pipeline-runner</td> <td>Esta clave se puede utilizar para definir un runner a nivel de pipeline, el cual es accesible en todos los stages y jobs.</td> </tr> <tr> <td>pipeline-image</td> <td>Esta clave se puede utilizar para definir una image a nivel de pipeline, la cual es accesible en todos los stages y jobs.</td> </tr> </tbody> </table> Note: Al definir el flujo de ejecución del pipeline en el archivo pipeline-image , asegúrate de utilizar las palabras clave exactas designadas por Catalyst como claves y asignar los datos correspondientes a cada clave. -------------------------------------------------------------------------------- title: "Implementación" description: "Conoce las instrucciones paso a paso para configurar el pipeline directamente desde la consola de Catalyst." last_updated: "2026-07-02T09:34:15.876Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/catalyst-pipelines.yaml/implementation/" service: "Pipelines" related: - Runners (/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/runners) - Images (/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/images) - Artifacts (/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/artifacts) - Variables (/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/variables) - When-condition (/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/when-condition) - Steps (/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/steps) - Jobs (/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/jobs/introduction) - Stages (/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/stages/introduction) - YAML Schema Reference (/es/pipelines/help/catalyst-pipelines.yaml/schema-reference) - Pipeline Triggers (/es/pipelines/help/triggers/introduction) -------------------------------------------------------------------------------- # Implementación Puedes construir un pipeline utilizando el constructor visual integrado o el editor de código directamente desde la consola de Catalyst. Asegúrate de seguir los pasos que se indican a continuación: Comencemos configurando el pipeline utilizando el editor de código. 1. Después de crear el pipeline, el editor de código se abre automáticamente. Un código YAML básico estará predefinido en este archivo; puedes comenzar a actualizarlo según sea necesario. 2. En el panel del asistente a la derecha, haz clic en **Add Variable**. Ingresa los pares clave-valor y haz clic en **Generate**. 3. Haz clic en **Add to Code**. Las variables ahora se han agregado en el código YAML. 4. Ahora, agreguemos las images requeridas para la ejecución del pipeline. Haz clic en **Create Image**. En la ventana emergente **Create Image**, ingresa el nombre de la variable de Image, el nombre de la image, la URL del registro, el nombre de usuario y la contraseña del registro. Haz clic en **Generate**. Haz clic en **Add to Code**. La image ahora se ha agregado en el código YAML. 5. Haz clic en **Add Runners**. Ingresa el nombre del runner y elige la configuración del runner. Puedes obtener más información sobre las configuraciones de runners en esta página de ayuda. Haz clic en **Generate**. Haz clic en **Add to Code**. El runner ahora se ha agregado en el código YAML. 6. Ahora agreguemos los jobs requeridos para el pipeline. Haz clic en **Add Job**. Proporciona un nombre para el job. Puedes crear el job utilizando cualquiera de las siguientes opciones: * **Create using Steps** : Esta opción te permite definir tu propio conjunto de comandos en el editor de scripts a continuación. Puedes seleccionar las configuraciones de runner e image requeridas para el job. Agrega la ruta del directorio de trabajo actual como se muestra a continuación. Haz clic en **Generate**. * **Create using Approvals** : Esto crea un job de aprobación para el pipeline. Selecciona la dirección de correo electrónico del aprobador requerido e ingresa un mensaje como se muestra a continuación. Haz clic en **Generate**. * **Create using Templates** : Esto crea los jobs utilizando las plantillas predefinidas disponibles en Catalyst. Si tu caso de uso encaja en alguna de estas operaciones, puedes elegir directamente la plantilla. Haz clic en **Generate**. Haz clic en **Add to Code** y el job se agregará al YAML. 7. Ahora, definamos los stages del pipeline. Haz clic en **Add Stage**. Proporciona el nombre del stage y selecciona los jobs requeridos para el stage. Haz clic en **Show Advanced Options** y habilita **Checks** si necesitas agregar alguna lógica condicional dentro de la ejecución del stage. Puedes agregar checks como se muestra a continuación y hacer clic en **Add to Stage**. Haz clic en **Generate** y luego en **Add to Code**. El stage ahora se ha agregado en el código YAML. Una vez que hayas completado la configuración del YAML, puedes hacer clic en **Save**. Cuando necesites guardar tus configuraciones parcialmente y continuar editándolas más tarde, puedes hacer clic en **Save as Draft**. Puedes elegir la rama en la que se debe hacer commit del archivo YAML como se muestra en la captura de pantalla a continuación y hacer clic en **Commit**. Ingresa el mensaje de commit y haz clic en **Commit**. El archivo catalyst-pipelines.yaml se actualizará en tu repositorio Git. De manera similar, puedes configurar el mismo pipeline utilizando el constructor visual. Primero, cambia a la pestaña **Builder tab** como se muestra en la captura de pantalla a continuación. La interfaz del constructor de arrastrar y soltar se abrirá automáticamente. Aquí, simplemente puedes arrastrar y soltar los componentes y seguir los mismos pasos mencionados anteriormente. Después de configurar el YAML por primera vez, puedes realizar cambios en cualquier momento haciendo clic en **Configure YAML**. También puedes agregar variables globales que sean accesibles en todo el pipeline simplemente haciendo clic en **Global Variables**. Agrega el nombre de la variable como clave y su valor correspondiente. Haz clic en **Save**. En la siguiente sección se analiza la ejecución del pipeline. #### Construir un Pipeline -------------------------------------------------------------------------------- title: "Ejecutores" description: "Conoce en detalle los runners de Catalyst Pipelines, las palabras clave asociadas y fragmentos de código de ejemplo." last_updated: "2026-07-02T09:34:15.876Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/runners/" service: "Pipelines" related: - Configure the Pipeline (/es/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Construir el Pipeline En esta sección se analizan en detalle los diversos componentes del pipeline, su uso en el archivo catalyst-pipelines.yaml, cómo incorporar estos componentes directamente desde la consola de Catalyst y construir un Catalyst Pipeline. ¡Comencemos! # Runners ## Introducción Un runner es un agente o recurso de cómputo que ejecuta los jobs definidos en un pipeline. Los runners de Catalyst ofrecen una infraestructura robusta y flexible para compilar, probar y desplegar aplicaciones de software de manera eficiente y confiable. Puedes definir los runners requeridos para el pipeline como pares clave-valor utilizando la palabra clave runners. Las configuraciones de runner compatibles con Catalyst Pipelines se enumeran a continuación: <table class="content-table"> <thead> <tr> <th>Configuración del runner</th> <th>Almacenamiento RAM</th> <th>Capacidad de CPU</th> <th>Espacio en disco</th> </tr> </thead> <tbody> <tr> <td>Low</td> <td>1 GB</td> <td>0.8 vCPU</td> <td>2 GB</td> </tr> <tr> <td>Medium</td> <td>2 GB</td> <td>1.2 vCPU</td> <td>4 GB</td> </tr> <tr> <td>High</td> <td>4 GB</td> <td>2.0 vCPU</td> <td>8 GB</td> </tr> </tbody> </table> Note: 1. Definir un runner no es obligatorio. Si no se especifica un runner, se utiliza el runner con configuración medium por defecto para ejecutar los jobs. 2. Puedes definir runners a nivel de pipeline, de stage o de job. En caso de múltiples definiciones, la especificada en el nivel más bajo (es decir, job) tiene prioridad. ### Propiedades de un Runner <table class="content-table"> <thead> <tr> <th>Clave</th> <th>Valor</th> <th>Es obligatorio</th> </tr> </thead> <tbody> <tr> <td>Nombre del runner (El nombre de la variable del runner utilizado para acceder al runner)</td> <td></td> <td>Sí</td> </tr> <tr> <td>config-id</td> <td>El ID de la configuración de runner requerida. Low = config-id : 1<br/> Medium = config-id :2<br/> High = config-id : 3 </td> <td>Sí</td> </tr> </tbody> </table> ### Fragmento de código YAML para Runner runners: runner1: config-id: 2 runner2: config-id: 3 ### Configuración global También puedes definir los runners a nivel de pipeline, si es necesario. Esta configuración de runner será accesible para todos los stages y jobs. Puedes configurar un runner a nivel de pipeline de la siguiente manera: pipeline-runner:runner1 -------------------------------------------------------------------------------- title: "Imágenes" description: "Conoce en detalle las images de Catalyst Pipelines, las palabras clave asociadas y fragmentos de código de ejemplo." last_updated: "2026-07-02T09:34:15.877Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/images/" service: "Pipelines" related: - Configure the Pipeline (/es/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Images # Introducción Una image es un paquete ejecutable que contiene las dependencias necesarias para ejecutar un job en el pipeline. Catalyst Pipelines se integra de forma transparente con registros de contenedores como Docker Hub u otros registros privados para obtener images y dependencias durante la ejecución del pipeline. Puedes elegir entre una amplia variedad de images que admiten diversos sistemas operativos, lenguajes de programación, frameworks y herramientas para adaptarse a tus requisitos específicos. Además, el uso de images predefinidas garantiza consistencia y reproducibilidad en las diferentes fases del pipeline y entornos. Puedes obtener images especificando la URL del registro de contenedores explícitamente utilizando la clave registry. Si la URL del registro no se define, las images se obtienen del contenedor de Dockerhub por defecto. Puedes definir las images requeridas para el pipeline utilizando la clave images. ### Propiedades de una Image <table class="content-table"> <thead> <tr> <th>Clave</th> <th>Valor</th> <th>Es obligatorio</th> </tr> </thead> <tbody> <tr> <td>Nombre de la variable de Image</td> <td>El nombre de la variable de image utilizado para acceder a la image</td> <td>Sí</td> </tr> <tr> <td>image</td> <td>El nombre de la image</td> <td>Sí</td> </tr> <tr> <td>registry</td> <td>La URL desde la cual se debe obtener la image.</td> <td>No</td> </tr> <tr> <td>auth</td> <td>Contiene las claves username y password.</td> <td>Sí</td> </tr> <tr> <td>auth</td> <td>Contiene las claves username y password.</td> <td>Sí</td> </tr> <tr> <td>username</td> <td>La credencial de nombre de usuario de la cuenta del registro especificado.</td> <td>Sí</td> </tr> <tr> <td>password</td> <td>La credencial de contraseña de la cuenta del registro especificado.</td> <td>Sí</td> </tr> </tbody> </table> Note: 1. Definir una image no es obligatorio. Si no se especifica una image, se utiliza por defecto la image de Ubuntu con Catalyst CLI preinstalado para ejecutar los jobs. 2. Puedes definir images a nivel de pipeline, de stage o de job. En caso de múltiples definiciones, la especificada en el nivel más bajo (es decir, job) tiene prioridad. 3. Si se especifica la misma image para dos jobs dentro de un stage, la image en caché se reutilizará automáticamente para el segundo job, mejorando la velocidad de rendimiento. 4. Si se especifica el nombre de la image y no se proporciona la URL del registro, asegúrate de proporcionar las credenciales de username y password de tu cuenta de Dockerhub en la clave auth. La image se obtendrá de DockerHub por defecto. Por razones de seguridad, recomendamos encarecidamente almacenar la información de tu contraseña como una variable en la configuración global y acceder a ella mediante << env.{variable_name} >> en el archivo catalyst-pipelines.yaml. Puedes consultar esta sección de ayuda para aprender cómo configurar variables globalmente desde la consola. ### Fragmento de código YAML para Image A continuación se muestra un fragmento de código de ejemplo para images que se pueden definir en un pipeline: images: testImage1: image: node:18 registry: my.private.registry.com auth: username: ameliab password: zylker@123 testImage2: image: node:20 auth: username: ameliab password: zylker@123 El fragmento de código anterior ilustra lo siguiente: * Se definen dos images en el pipeline (testImage1 y testImage2). * La testImage1 utiliza las dependencias de node18 desde la URL del registro definida. Se han agregado las credenciales de autenticación para el registro en la palabra clave auth. * Por defecto, dado que no se especifica el registro, la testimage2 utiliza las dependencias de node20 desde Dockerhub. ### Configuración global También puedes definir la image a nivel de pipeline, si es necesario. Esta configuración de image será accesible para todos los stages y jobs. Puedes configurar una image a nivel de pipeline de la siguiente manera: pipeline-image: image1 -------------------------------------------------------------------------------- title: "Variables" description: "Conoce en detalle las variables de Catalyst Pipelines, las palabras clave asociadas y fragmentos de código de ejemplo." last_updated: "2026-07-02T09:34:15.877Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/variables/" service: "Pipelines" related: - Configure the Pipeline (/es/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Variables # Introducción Una variable es un valor de marcador de posición que se puede definir a nivel de job o de pipeline según sea necesario. No es posible definir una variable a nivel de stage. Puedes definir las variables requeridas para el pipeline como pares clave-valor utilizando la clave variables. ### Propiedades de una Variable <table class="content-table"> <thead> <tr> <th>Clave</th> <th>Valor</th> <th>Es obligatorio</th> </tr> </thead> <tbody> <tr> <td>Nombre de la variable</td> <td>Especifica un valor de tipo string para la variable</td> <td>Sí</td> </tr> </tbody> </table> ### Fragmento de código YAML para Variable Puedes declarar una variable a nivel de job en el archivo catalyst-pipelines.yaml utilizando la siguiente sintaxis: variables: target:'app3.1' ### Variables globales Puedes definir una variable a nivel de pipeline directamente desde la consola. Consulta esta página de ayuda para conocer los pasos exactos para crear una variable. Note: Debes establecer obligatoriamente una variable global llamada CATALYST_TOKEN e ingresar el token generado desde tu Catalyst CLI, en caso de que hayas utilizado Catalyst CLI en la ejecución del pipeline. Para obtener tu token, consulta los pasos mencionados en esta sección de ayuda. ### Acceder a la Variable Se puede acceder a una variable utilizando cualquiera de los siguientes métodos: * **<< variables.{variable_name} >>** : Se puede utilizar para acceder a cualquier variable definida a nivel de job. * **<< event.{variable_name} >>** : Se puede utilizar para acceder a cualquier variable pasada en el JSON del evento al activar el pipeline manualmente desde la consola. * **<< env.{variable_name} >>** : Se puede utilizar para acceder a variables definidas a nivel de pipeline. -------------------------------------------------------------------------------- title: "Condición When" description: "Conoce en detalle las condiciones de Catalyst Pipelines, las palabras clave asociadas y fragmentos de código de ejemplo." last_updated: "2026-07-02T09:34:15.877Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/when-condition/" service: "Pipelines" related: - Configure the Pipeline (/es/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # When Condition # Introducción La condición when es una lógica básica que se puede configurar para definir el flujo de ejecución del pipeline. Puedes definir la condición when a nivel de stage, de job o de pipeline. Es importante tener en cuenta que la condición when se puede aplicar en cualquiera de estos niveles, y el orden de los componentes no es significativo. Los siguientes operadores se pueden utilizar junto con la condición when: ### when-equal when: equal: - << status.build.package >> - success when-not-equal ### when-not-equal not-equal: - << status.build.package >> - failed ### when-not when: -not:true ### when-and/when-or when: or: - and: - equal: - << pipeline.status.build >> - success - not-equal: - << pipeline.status.build.hello-world >> - failed - equal: - << pipeline.event.{{Event Variable Placeholder}} >> Note: No podrás configurar condiciones when para jobs de aprobación. ### Configuración global Puedes definir una condición when a nivel de pipeline, si es necesario. Esta condición determina exclusivamente el flujo de ejecución del pipeline. Puedes configurar la condición de la siguiente manera: pipeline-when: equal: - << event.ref >> - refs/heads/main -------------------------------------------------------------------------------- title: "Pasos" description: "Conoce en detalle los steps de Catalyst Pipelines, las palabras clave asociadas y fragmentos de código de ejemplo." last_updated: "2026-07-02T09:34:15.877Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/steps/" service: "Pipelines" related: - Configure the Pipeline (/es/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Steps # Introducción Un step es el bloque de construcción más pequeño de un pipeline. Son un conjunto de comandos que se ejecutan para compilar, desplegar o probar el código fuente. Puedes definir los steps para tu job, agregando los comandos mediante un guion (-). Puedes definir los steps del pipeline utilizando la clave steps. ### Fragmento de código YAML para Steps steps: - ls - >- catalyst deploy appsail --name spring-boot --build-path "/catalyst/SNAPSHOT.jar" --stack java17 --platform javase --command "sh -c 'java -jar SNAPSHOT.jar --server.port=\${X_ZOHO_CATALYST_LISTEN_PORT}'" --verbose -------------------------------------------------------------------------------- title: "Artefactos" description: "Conoce en detalle los artifacts de Catalyst Pipelines, las palabras clave asociadas y fragmentos de código de ejemplo." last_updated: "2026-07-02T09:34:15.877Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/artifacts/" service: "Pipelines" related: - Configure the Pipeline (/es/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Artifacts # Introducción Un artifact es un archivo o zip generado durante el proceso de compilación de la aplicación en la ejecución del pipeline. Estos artifacts son entidades desplegables, que incluyen infraestructura y aplicaciones. Puedes almacenar y recuperar los artifacts durante la ejecución del pipeline en el servicio Catalyst Stratus. Existen dos tipos de artifacts: * **Un archivo de artifact único:** Este archivo de compilación se puede cargar directamente a un bucket en Catalyst Stratus y luego descargarse cuando sea necesario. * **Un zip de artifact:** Este tipo incluye la configuración de expresiones regulares para seleccionar los archivos relevantes, comprimirlos y cargarlos a un bucket en Catalyst Stratus, y luego descargar el zip cuando sea necesario. Puedes definir los artifacts requeridos para el pipeline como pares clave-valor utilizando la clave artifacts. Estos artifacts se pueden incluir como parte de los jobs creados mediante steps en la consola de Catalyst. Puedes consultar esta sección de ayuda para obtener más información sobre la configuración de artifacts en jobs. Sin embargo, no son aplicables a jobs paralelos ni de aprobación. ### Propiedades de un Artifact #### Upload <table class="content-table"> <thead> <tr> <th>Clave</th> <th>Valor</th> <th>Es obligatorio</th> </tr> </thead> <tbody> <tr> <td>upload</td> <td>Esta clave contiene las configuraciones requeridas para el proceso de carga del artifact.</td> <td>Sí</td> </tr> <tr> <td>type</td> <td>Proporciona el valor como file o zip.</td> <td>Sí</td> </tr> <tr> <td>name</td> <td>El nombre del artifact. (nombre del archivo o nombre del zip) Por ejemplo: SNAPSHOT.jar (para tipo file) Build.zip (para tipo zip) </td> <td>Sí</td> </tr> <tr> <td>file</td> <td>La ruta de origen del archivo de artifact. Por ejemplo: target/demo-0.0.1-SNAPSHOT.jar </td> <td>Sí (si el tipo de artifact es file)</td> </tr> <tr> <td>regex</td> <td>El patrón de expresión regular que identifica archivos y comprime todos los que coinciden. Por ejemplo: - /catalyst/node_modules/**/ </td> <td>Sí (si el tipo de artifact es zip)</td> </tr> <tr> <td>location</td> <td>La ruta de ubicación en Stratus donde se debe cargar el archivo o zip. Por ejemplo: stratus://<<env.BUCKET_NAME >>/ (destino) </td> <td>Sí</td> </tr> </tbody> </table> #### Download <table class="content-table"> <thead> <tr> <th>Clave</th> <th>Valor</th> <th>Es obligatorio</th> </tr> </thead> <tbody> <tr> <td>download</td> <td>Esta clave contiene las configuraciones requeridas para el proceso de descarga del artifact.</td> <td>Sí</td> </tr> <tr> <td>type</td> <td>file o zip. Proporciona este valor según tu preferencia.</td> <td>Sí</td> </tr> <tr> <td>name</td> <td>El nombre del artifact en Stratus. Por ejemplo: SNAPSHOT.jar (para tipo file) Build.zip (para tipo zip) </td> <td>Sí</td> </tr> <tr> <td>file</td> <td>La ruta de destino donde se debe descargar el archivo. Por ejemplo: /SNAPSHOT.jar. </td> <td>Sí (si el tipo de artifact es file)</td> </tr> <tr> <td>location</td> <td>La ubicación en Stratus desde la cual se debe descargar el archivo. Por ejemplo: stratus://<<env.BUCKET_NAME >>/ nombre del artifact </td> <td>Sí</td> </tr> </tbody> </table> Note: Si el tipo de artifact se establece como zip, el archivo zip se descargará en el directorio raíz por defecto. Consulta esta sección para ver un fragmento de código YAML de ejemplo configurado con artifacts. -------------------------------------------------------------------------------- title: "Etapas" description: "Conoce en detalle los stages de Catalyst Pipelines, las palabras clave asociadas y fragmentos de código de ejemplo." last_updated: "2026-07-02T09:34:15.877Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/stages/" service: "Pipelines" related: - Configure the Pipeline (/es/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Stages # Introducción Un stage es un componente fundamental en un pipeline que organiza la secuencia de ejecución de los jobs dentro de un pipeline. Cada stage representa una fase distinta en el proceso de entrega de software, como la compilación, las pruebas o el despliegue de una aplicación. Los stages permiten la agrupación lógica y la separación de jobs, lo que facilita la ejecución paralela para tiempos de compilación y despliegue más rápidos. También facilitan la gestión eficiente de pipelines complejos al dividir el flujo de trabajo en unidades manejables, proporcionando claridad y control sobre todo el proceso de despliegue. Puedes definir los stages requeridos para el pipeline como pares clave-valor utilizando la clave stages. Puedes obtener el estado actual de un stage utilizando &lt;&lt; status.{stage_name} &gt;&gt;. Note: 1. Los múltiples stages en un pipeline se ejecutan secuencialmente por defecto, procediendo uno tras otro. Tienes la opción de definir condiciones para la ejecución de stages, lo que permite un control personalizado sobre cuándo se activa cada stage. Consulta esta sección para aprender sobre la definición de condiciones en el pipeline. 2. En una configuración de pipeline, debe haber al menos un stage y no más de cinco stages. Además, cada stage puede alojar un máximo de cinco jobs, que incluye jobs paralelos. ### Propiedades de un Stage Puedes definir los stages en tu pipeline con una o más combinaciones de los atributos listados a continuación: <table class="content-table"> <thead> <tr> <th>Clave</th> <th>Valor</th> <th>Es obligatorio</th> </tr> </thead> <tbody> <tr> <td>name</td> <td>Proporciona el nombre del stage como un valor de tipo string.</td> <td>Sí</td> </tr> <tr> <td>jobs</td> <td>Un arreglo de jobs</td> <td>Sí</td> </tr> </tr> <tr> <td>runner</td> <td>El nombre del runner en el cual se deben ejecutar los jobs</td> <td>No</td> </tr> <tr> <td>image</td> <td>El nombre de la image que se utiliza para la ejecución de jobs en el stage particular.</td> <td>No</td> </tr> <tr> <td>when</td> <td>La lógica condicional en base a la cual se debe ejecutar el stage. Puedes utilizar los operadores "and", "or", "not", "not-equal" o "equal" junto con la condición base.</td> <td>No</td> </tr> </tbody> </table> ### Fragmento de código YAML para Stage A continuación se muestra un fragmento de código de ejemplo para stages que se pueden definir en un pipeline: stages: - name: testStage1 runner: runner1 image: testImage1 jobs: - testJob1 when: - and: - equal: - << pipeline.event.branch >> - master - true - name: testStage2 jobs: - testJob1 - - testJob2 - testJob3 El código anterior ilustra el siguiente flujo de trabajo: * Hay dos stages definidos en el pipeline: testStage1 y testStage2. * El stage testStage1 ejecuta un job (testJob1) y el stage testStage2 ejecuta tres jobs (testJob1 y un job paralelo). El job paralelo incluye los jobs testJob2 y testJob3, respectivamente. * El runner y la image se han definido a nivel de stage y serán utilizados por ambos stages. * La condición when valida si la rama actual apunta a master, y si esto se cumple, se ejecutará el testJob1. ##### Jobs -------------------------------------------------------------------------------- title: "Introducción" description: "Conoce en detalle los jobs de Catalyst Pipelines, las palabras clave asociadas y fragmentos de código de ejemplo." last_updated: "2026-07-02T09:34:15.877Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/jobs/introduction/" service: "Pipelines" related: - Configure the Pipeline (/es/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Jobs # Introducción Un job es una secuencia de steps que se ejecutan en el pipeline. Es obligatorio definir al menos un job en el pipeline. Puedes definir los jobs requeridos para el pipeline como pares clave-valor utilizando la clave jobs. Además de los jobs regulares definidos en el pipeline, puedes configurar los siguientes jobs: * **Approval Job** * **Parallel Job** Puedes obtener el estado de un job utilizando &lt;&lt; status.{stage_name}.{job_name} &gt;&gt;. ### Propiedades de un Job <table class="content-table"> <thead> <tr> <th>Clave</th> <th>Valor</th> <th>Es obligatorio</th> </tr> </thead> <tbody> <tr> <td>variables</td> <td>Un arreglo de variables</td> <td>No</td> </tr> <tr> <td>artifacts</td> <td>Incluye las claves upload y download. Consulta esta página de ayuda para más detalles.</td> <td>No</td> </tr> <tr> <td>notify</td> <td>Esta clave se puede configurar para enviar correos electrónicos de notificación sobre el job antes de que comience su ejecución y después de que la ejecución del job se complete. Contiene las subclaves on-start y on - end</td> <td>No</td> </tr> <tr> <td>on-start / on -end</td> <td>Contiene las subclaves notify-type y notify-variables.</td> <td>Sí (si se utiliza notify)</td> </tr> <tr> <td>notify-type</td> <td>Proporciona el valor como email.</td> <td>Sí (si se utiliza notify)</td> </tr> <tr> <td>notify-variables</td> <td>Proporciona la dirección de correo electrónico a notificar cuando comience la ejecución del job (para on-start) y la dirección de correo electrónico a notificar cuando el job complete su ejecución exitosamente (para on-end)</td> <td>Sí (si se utiliza notify)</td> </tr> <tr> <td>runner</td> <td>Especifica el nombre del runner en el cual se deben ejecutar los jobs.</td> <td>No</td> </tr> <tr> <td>image</td> <td>Especifica el nombre de la image necesaria para la ejecución del job específico.</td> <td>No</td> </tr> <tr> <td>cwd</td> <td>Especifica el directorio de trabajo actual en el cual se debe ejecutar el job.</td> <td>No</td> </tr> <tr> <td>steps</td> <td>Un arreglo que contiene los scripts que necesitan ejecutarse en el pipeline.</td> <td>Sí</td> </tr> <tr> <td>when</td> <td>Especifica las condiciones que determinan si el job debe ejecutarse o no.</td> <td>No</td> </tr> </tbody> </table> ### Fragmento de código YAML para Job A continuación se muestra un fragmento de código de ejemplo para jobs que se pueden definir en un pipeline: jobs: testJob1: steps: - echo "Enter your scripts here" testJob2: variables: BRANCH: main artifacts: upload: - name: artifactTest type: zip location: stratus://mybucket/home/artifacts files: - '**/*' download: - name: artifactTest type: zip location: stratus://mybucket/home/artifacts notify: on-start: - notify-type: email notify-variables: to: amelia.burrows@zylker.com on-end: - notify-type: email notify-variables: to: amelia.burrows@zylker.com runner: runner2 image: testImage1 cwd: cd ./src steps: - echo "Enter your scripts here" and: - equal: - << pipeline.event.branch >> - main - true testJob3: steps: - echo "Hello" El código anterior ilustra el siguiente flujo de trabajo: * Hay tres jobs definidos en el pipeline: testJob1, testJob2, testJob3. * El testJob2 está configurado para ejecutarse solo si la rama de trabajo actual en el repositorio es la rama main. * El testJob2 maneja el proceso de almacenar y recuperar los archivos de compilación generados hacia y desde Catalyst Stratus. Esto se define utilizando las claves upload y download. * También envía una notificación a la dirección de correo electrónico definida para mantenerla informada sobre el inicio de la ejecución del job y la finalización del mismo. Esto se logra utilizando las claves notify on-start y on-end. -------------------------------------------------------------------------------- title: "Trabajo de aprobación" description: "Conoce en detalle los jobs de aprobación de Catalyst Pipelines, las palabras clave asociadas y fragmentos de código de ejemplo." last_updated: "2026-07-02T09:34:15.880Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/jobs/approval-job/" service: "Pipelines" related: - Configure the Pipeline (/es/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Approval Job # Introducción Las tareas críticas que requieren una revisión manual para proceder se pueden definir como un approval job en el pipeline. Los steps definidos en el approval job suelen ser un conjunto de validaciones necesarias antes de que se ejecute un despliegue. Cuando se configura un approval job, la ejecución del pipeline se pausa hasta que el aprobador apruebe el job. Se enviará una notificación por correo electrónico al aprobador para que apruebe el job. También puede aprobarlo directamente desde la consola. Obtén más información sobre cómo aprobar un job desde la consola en esta sección de ayuda. Puedes definir los approval jobs para el pipeline como pares clave-valor utilizando la clave approve. ### Propiedades de un Approval Job <table class="content-table"> <thead> <tr> <th>Clave</th> <th>Valor</th> <th>Es obligatorio</th> </tr> </thead> <tbody> <tr> <td>type</td> <td>Esta clave contiene la subclave type-name.</td> <td>Sí</td> </tr> <tr> <td>type-name</td> <td>Especifica este valor como "approval".</td> <td>Sí</td> </tr> <tr> <td>type-variables</td> <td>Esta clave contiene las subclaves reviewers y message.</td> <td>Sí</td> </tr> <tr> <td>reviewers</td> <td>Especifica las direcciones de correo electrónico de los revisores que pueden aprobar este job.</td> <td>Sí</td> </tr> <tr> <td>message</td> <td>Proporciona el mensaje que se debe enviar al aprobador.</td> <td>Sí</td> </tr> </tbody> </table> Note: 1. Solo puedes agregar un único revisor para el approval job. 2. El approval job no tiene un tiempo de espera específico, lo que significa que la ejecución del pipeline permanecerá pausada hasta que el aprobador tome acción. ### Fragmento de código YAML para Approval Job A continuación se muestra un fragmento de código de ejemplo para un approval job: approve: type: type-name: approval type-variables: reviewers: - amelia.b@zylker.com message: Review this -------------------------------------------------------------------------------- title: "Trabajo paralelo" description: "Conoce en detalle los jobs paralelos de Catalyst Pipelines, las palabras clave asociadas y fragmentos de código de ejemplo." last_updated: "2026-07-02T09:34:15.880Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/catalyst-pipelines.yaml/build-the-pipeline/jobs/parallel-job/" service: "Pipelines" related: - Configure the Pipeline (/es/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Parallel Job Un parallel job puede incluir dos jobs distintos que se pueden ejecutar en paralelo. Puedes definir un parallel job agregando dos guiones (--) antes del nombre del primer job y un solo guion (-) antes del nombre del segundo job. Esto denota simbólicamente que ambos jobs se ejecutarán en paralelo. Note: Un job secuencial se puede definir simplemente utilizando un solo guion (-). ### Fragmento de código YAML para Parallel Job A continuación se muestra un fragmento de código de ejemplo para un parallel job: name: testStage1 jobs: - testJob1 - - testJob2 - testJob3 ### Despliegue -------------------------------------------------------------------------------- title: "Desplegar en AppSail" description: "Conoce más sobre el fragmento de código YAML de ejemplo para desplegar una aplicación en Catalyst AppSail utilizando el servicio Pipelines." last_updated: "2026-07-02T09:34:15.880Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/deployments/deploy-to-appsail/" service: "Pipelines" related: - Catalyst AppSail (/es/serverless/help/appsail/introduction/) -------------------------------------------------------------------------------- # Desplegar en AppSail Después de compilar y probar tu aplicación, debe desplegarse en cualquier máquina virtual para que los usuarios puedan utilizarla. Puedes personalizar el flujo de despliegue en el pipeline según tus necesidades específicas. Puedes automatizar todo el proceso o automatizarlo parcialmente incluyendo un approval job para completar el proceso de despliegue. A continuación se muestra un fragmento de código YAML de ejemplo que se puede utilizar para desplegar una aplicación Java construida con el framework Springboot en el servicio Catalyst AppSail. Antes de ejecutar el pipeline, deberás configurar las siguientes claves como variables globales en tu pipeline. Puedes consultar esta sección de ayuda para aprender sobre la configuración de variables. * CATALYST_TOKEN : Un token único para acceder a Catalyst CLI desde el YAML. Consulta esta página de ayuda para obtener más información sobre la generación de tokens. * DOCKER_PASS : La contraseña de tu cuenta de Docker Hub. * BUCKET_NAME : El nombre de tu bucket de Stratus. version: 1.0 runners: high: config-id: 3 pipeline-when: equal: - << event.ref >> - refs/heads/main images: maven: image: maven:3.8.5-openjdk-17 auth: username: ameliaburrows password: << env.DOCKER_PASS >> jobs: unit-test: steps: - mvn surefire-report:report artifacts: upload: - type: zip regex: - /catalyst/target/surefire-reports/** name: junit.zip location: stratus://<< env.BUCKET_NAME >>/ package: steps: - mvn clean package -DskipTests=true artifacts: upload: - type: file name: SNAPSHOT.jar file: target/demo-0.0.1-SNAPSHOT.jar location: stratus://<< env.BUCKET_NAME >>/ catalyst-deploy: when: equal: - << status.build.package >> - success steps: - npm install -g zcatalyst-cli@beta - >- catalyst deploy appsail --name spring-boot --build-path "/catalyst/SNAPSHOT.jar" --stack java17 --platform javase --command "sh -c 'java -jar SNAPSHOT.jar --server.port=\${X_ZOHO_CATALYST_LISTEN_PORT}'" --verbose artifacts: download: - type: file name: SNAPSHOT.jar file: /SNAPSHOT.jar location: stratus://<< env.BUCKET_NAME >>/ stages: - name: test image: maven jobs: - unit-test - name: build image: maven jobs: - package - name: deploy jobs: - catalyst-deploy -------------------------------------------------------------------------------- title: "Desplegar en Catalyst" description: "Conoce más sobre el fragmento de código YAML de ejemplo para desplegar una aplicación en Catalyst utilizando el servicio Pipelines." last_updated: "2026-07-02T09:34:15.880Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/deployments/deploy-to-catalyst/" service: "Pipelines" related: - Deploy Basic Web Client (/es/cli/v1/deploy-resources/deploy-client/) -------------------------------------------------------------------------------- # Desplegar en Catalyst En esta sección, analizaremos un código YAML de ejemplo para automatizar el despliegue de un Client web básico de Catalyst y el componente Catalyst Serverless Functions. Este código es aplicable a **Java**, **Node.js** y **Python**. Deberás configurar las siguientes claves como variables globales en tu pipeline. Puedes consultar esta sección de ayuda para aprender sobre la configuración de variables. * PROJECT_ID : El identificador único de tu proyecto asignado por Catalyst. Puedes obtener este valor desde **General Settings** en la consola. * CATALYST_ORG : La organización de Catalyst a la que pertenece el proyecto actual. Puedes obtener este valor desde el portal Multi-Org en la consola. * CATALYST_TOKEN : Un token único para acceder a Catalyst CLI desde el YAML. Consulta esta página de ayuda para obtener más información sobre la generación de tokens. * USER_NAME : El nombre de usuario de tu cuenta de Docker Hub. * USER_PASSWORD : La contraseña de tu cuenta de Docker Hub. version: 1 runners: Machine: config-id: 2 images: DeployMachine: image: ubuntu auth: username: << env.USER_NAME >> password: << env.USER_PASSWORD >> jobs: Deploy_Client_Functions: steps: - apt-get update - apt-get -y install openjdk-17-jdk curl - curl -fsSL https://deb.nodesource.com/setup_18.x | bash - - apt-get install -y nodejs - apt-get update && \ - apt-get install -y software-properties-common wget curl && \ - add-apt-repository ppa:deadsnakes/ppa && \ - apt-get update && \ - apt-get install -y python3.9 python3.9-distutils && \ - wget https://bootstrap.pypa.io/get-pip.py && \ - python3.9 get-pip.py && \ - rm get-pip.py - npm i -g zcatalyst-cli - catalyst -v - cd functions/Node - npm install - cd ../.. - catalyst deploy --project << env.PROJECT_NAME >> --org << env.CATALYST_ORG >> --token << env.CATALYST_TOKEN >> stages: - name: build image: DeployMachine jobs: - Deploy_Client_Functions ### Disparadores -------------------------------------------------------------------------------- title: "Introducción" description: "Conoce los diversos triggers del pipeline y su uso." last_updated: "2026-07-02T09:34:15.880Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/triggers/introduction/" service: "Pipelines" -------------------------------------------------------------------------------- # Triggers # Introducción ### Automatic Trigger El Automatic Trigger en Catalyst Pipelines es el proceso de iniciar ejecuciones del pipeline basándose en ciertos eventos o condiciones. Cuando creas un pipeline desde la consola, tendrás la opción de integrar tu pipeline con un sistema de control de versiones externo. Puedes consultar esta sección para obtener más información sobre esta integración. Es importante tener en cuenta que conectar pipelines a sistemas de control de versiones es el enfoque recomendado y ofrece muchos beneficios, como trazabilidad, colaboración y la capacidad de activar compilaciones basadas en cambios de código. Cuando hayas integrado tu pipeline con un sistema de control de versiones externo, el pipeline comenzará a ejecutarse cada vez que ocurra un evento de push o merge en el repositorio vinculado. Puedes ver el estado de ejecución del pipeline desde la consola de Catalyst. Consulta esta sección para obtener más información sobre el monitoreo del estado de ejecución del pipeline. ### Manual Trigger En caso de que no hayas integrado tu pipeline con ningún sistema de control de versiones externo, puedes ejecutar el pipeline manualmente cada vez desde la consola de Catalyst. Para ejecutar el pipeline directamente desde la consola, sigue los pasos que se indican a continuación: 1. Haz clic en **Execute Pipeline**. 2. Proporciona los detalles del evento para el pipeline en formato JSON, si es necesario. Haz clic en **Execute**. Los detalles del evento son opcionales aquí. La ejecución del pipeline comenzará ahora. El estado del pipeline progresará de **QUEUED** a **RUNNING** a **SUCESS/FAILED**. Puedes ver el estado del pipeline en la sección **Execution History**. Se analiza en la siguiente sección. -------------------------------------------------------------------------------- title: "Monitorear el estado de ejecución" description: "Conoce cómo monitorear el estado de ejecución de los pipelines de Catalyst directamente desde la consola." last_updated: "2026-07-02T09:34:15.880Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/triggers/monitor-execution-status/" service: "Pipelines" -------------------------------------------------------------------------------- # Monitorear el estado de ejecución Después de que la ejecución del pipeline se activa de forma automática o manual, puedes ver el estado de ejecución del pipeline directamente desde la consola de Catalyst. 1. En la sección **Execution History**, puedes ver los detalles de la ejecución del pipeline. 2. Haz clic en el registro de ejecución para ver información detallada sobre la ejecución. La pestaña **Basic tab** te permite ver el estado de ejecución de cada stage y job definido en el pipeline como un resumen general. Puedes cambiar a la pestaña **Advanced tab** para ver los logs en tiempo real de la ejecución del pipeline. Note: Mientras el pipeline se está ejecutando, se pausará si se ha configurado un approval job para el pipeline. En ese caso, la ejecución del pipeline se reanudará solo después de que el revisor apruebe el job. El revisor puede aprobar el job directamente desde la consola en la pestaña **Basic Tab**. ### Pipelines -------------------------------------------------------------------------------- title: "Introducción" description: "Conoce los conceptos básicos de Catalyst Pipelines y el flujo de trabajo general del servicio y su implementación." last_updated: "2026-07-02T09:34:15.881Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/pipelines/introduction/" service: "Pipelines" related: - Java SDK (/es/sdk/java/v1/pipelines/get-pipeline-details) - Nodejs SDK (/es/sdk/nodejs/v2/pipelines/get-pipeline-details) - Python SDK (/es/sdk/python/v1/pipelines/get-pipeline-details) - Configure the Pipeline (/es/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Pipelines # Introducción Un pipeline es la unidad de trabajo de nivel más alto en el servicio Catalyst Pipelines. Incluye una secuencia personalizable de stages, como compilar código, ejecutar pruebas y desplegar aplicaciones, todo orquestado de manera fluida para optimizar el proceso del ciclo de vida de tu software. Puedes crear un pipeline y configurar el flujo del pipeline directamente desde la consola de Catalyst. Discutiremos los pasos detallados en esta sección. Al crear el pipeline, puedes elegir integrarlo con un sistema de control de versiones externo como GitLab, GitHub o Bitbucket. Esta integración te permite vincular un repositorio en particular en el sistema de control de versiones con el pipeline, y cada vez que se envíen cambios al repositorio, el pipeline se activará automáticamente. También puedes activar manualmente el pipeline desde la consola de Catalyst, si es necesario. Para más información sobre los triggers de pipeline, puedes consultar esta sección. Los Catalyst Pipelines se orquestan basándose en el código YAML especificado en el archivo catalyst-pipelines.yaml. Puedes consultar esta página para entender las definiciones del esquema YAML de Catalyst Pipelines y adaptar el pipeline según tus necesidades específicas. Este archivo YAML se ejecuta directamente desde la consola para triggers manuales o directamente desde el sistema de control de versiones externo en el caso de triggers automáticos. También puedes implementar el trigger manual del pipeline y obtener los detalles de un pipeline existente dentro del código de tu aplicación usando nuestro paquete SDK de Pipelines disponible en Java, Node.js y Python. Para definir el flujo de ejecución del pipeline en el archivo YAML, tienes dos opciones: puedes usar nuestro constructor visual de arrastrar y soltar integrado para un enfoque intuitivo, o puedes configurar el código YAML usando nuestro editor de código. Puedes encontrar las instrucciones paso a paso para configurar el pipeline en esta página de ayuda. Ahora, exploremos los componentes del pipeline, su estructura jerárquica y su uso. -------------------------------------------------------------------------------- title: "Componentes de un Pipeline" description: "Conoce los diversos componentes de Catalyst Pipelines, su funcionalidad de uso y jerarquía." last_updated: "2026-07-02T09:34:15.882Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/pipelines/components-of-pipeline/" service: "Pipelines" related: - Configure the Pipeline (/es/pipelines/help/catalyst-pipelines.yaml/implementation) -------------------------------------------------------------------------------- # Componentes de un Pipeline El pipeline puede incluir cualquier combinación de los siguientes componentes, cada uno de los cuales define la secuencia de ejecución del pipeline. Puedes obtener más información sobre cómo configurar el flujo de ejecución del pipeline en esta sección de ayuda. * **Pipeline** : Una herramienta para automatizar los procesos de compilación, prueba y despliegue de aplicaciones de software. * **Runner** : Una máquina virtual o contenedor que proporciona la infraestructura subyacente para ejecutar el pipeline. * **Image** : Un recurso externo del que depende un pipeline, como bibliotecas, paquetes o servicios, para completar su ejecución correctamente. * **Variable** : Los marcadores de posición para valores que pueden reutilizarse en múltiples instancias dentro del alcance del pipeline. * **Artifact** : El archivo zip producido durante el proceso de compilación de la aplicación y almacenado en el servicio Catalyst Stratus, que puede desplegarse en los entornos especificados. * **When Condition** : La lógica condicional que se puede definir para controlar el flujo de ejecución del pipeline. * **Step** : Un step es el bloque de construcción más básico de un pipeline. Contiene un conjunto de comandos para realizar operaciones específicas como compilar código, ejecutar pruebas o desplegar una aplicación. * **Job** : Un job es una serie de steps secuenciales o paralelos que se ejecutan dentro del pipeline. * **Stage** : El nivel más alto de organización en Catalyst Pipelines, que representa fases distintas del proceso de entrega de software. Cada stage abarca múltiples jobs. Puedes codificar el flujo de ejecución del pipeline definiendo cualquiera de los componentes mencionados anteriormente en el archivo catalyst-pipelines.yaml según tus requisitos específicos. Dentro del pipeline de Catalyst, los stages y los jobs, tienes la flexibilidad de configurar otros componentes como images, runners, variables y conditions, cada uno desempeñando un rol distinto en la ejecución del pipeline. La siguiente ilustración proporciona una visión general completa de los componentes que se pueden definir en cada nivel: A continuación se analiza en detalle cada componente en sus respectivas páginas de ayuda. Consulta esta página de ayuda para comenzar. El siguiente diagrama muestra la secuencia jerárquica de los diversos componentes del pipeline. ## Consideraciones clave 1. Un pipeline puede contener hasta cinco stages, y cada stage puede alojar un máximo de cinco jobs, incluyendo jobs paralelos. 2. Es obligatorio incluir al menos un stage y un job en el pipeline. 3. Puedes definir variables, images y runners a nivel de pipeline, de stage o de job. En caso de múltiples definiciones, la especificada en el nivel más bajo (es decir, job) tiene prioridad. -------------------------------------------------------------------------------- title: "Flujo de trabajo del Pipeline" description: "Conoce los diversos procesos de CI/CD involucrados en el servicio Catalyst Pipelines." last_updated: "2026-07-02T09:34:15.882Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/pipelines/pipeline-workflow/" service: "Pipelines" related: - Configure the Pipeline (/es/pipelines/help/catalyst-pipelines.yaml/implementation) - Pipeline Triggers (/es/pipelines/help/triggers/introduction) - Catalyst Serverless Functions (/es/serverless/help/functions/introduction/) - Catalyst AppSail (/es/serverless/help/appsail/introduction/) -------------------------------------------------------------------------------- # Flujo de trabajo del Pipeline El siguiente diagrama de arquitectura ilustra el flujo de extremo a extremo de un Catalyst Pipeline. ### Activar el Pipeline Al crear un Catalyst Pipeline, puedes optar por integrar tu pipeline con cualquiera de los sistemas de control de versiones compatibles (es decir, GitHub, GitLab o Bitbucket). Esta integración determina el modo de activación de tu pipeline: * **Activación automática del Pipeline:** El pipeline se activará automáticamente cada vez que envíes cambios de código al repositorio vinculado en el sistema de control de versiones integrado. Cuando se activa el pipeline, el código fuente completo del repositorio Git integrado, junto con el archivo YAML, se obtendrá y descargará automáticamente como un archivo ZIP en Catalyst. * **Activación manual del Pipeline:** Puedes activar manualmente el pipeline desde la consola de Catalyst. Esto es adecuado para tareas puntuales que no requieren integración con el sistema de control de versiones. En ambos casos mencionados, al activar el pipeline, se ejecutará el flujo de trabajo codificado en el archivo catalyst-pipelines.yaml. Consulta esta sección para conocer en detalle los triggers de Catalyst Pipelines y su implementación. ### Ejecutar el Pipeline Al activarse, el pipeline se ejecutará secuencialmente, un stage tras otro. Los objetivos comúnmente alcanzados al ejecutar un pipeline incluyen los siguientes: #### Build Puedes configurar el pipeline para compilar aplicaciones de cualquier escala utilizando el servicio Catalyst Pipelines. A continuación se muestran algunos ejemplos de aplicaciones comúnmente compiladas: * **Aplicaciones web:** Puedes compilar aplicaciones web desarrolladas con frameworks como ASP.NET, Node.js, Django, Flask, entre otros. * **Aplicaciones móviles:** Compila aplicaciones móviles para plataformas como iOS, Android o Windows utilizando frameworks como Xamarin, React Native o Flutter. * **Servicios API:** Compila APIs RESTful o microservicios utilizando frameworks como Express.js, ASP.NET Web API, Spring Boot, entre otros. * **Aplicaciones serverless:** Puedes compilar aplicaciones serverless utilizando Catalyst Serverless Functions, Azure Functions, AWS Lambda o Google Cloud Functions. * **Aplicaciones contenedorizadas:** Compila aplicaciones contenedorizadas utilizando Docker, Kubernetes u otras herramientas de orquestación de contenedores. Existe una amplia variedad de aplicaciones que se pueden compilar automáticamente utilizando el servicio Catalyst Pipelines. Necesitarás configurar el componente steps en el pipeline con los comandos específicos a ejecutar para compilar la aplicación de manera eficiente. #### Test Una vez que la aplicación se compila automáticamente, puedes proceder a probarla antes de desplegarla en cualquier entorno. De manera similar al proceso de compilación, puedes especificar los comandos necesarios para probar la aplicación en el archivo catalyst-pipelines.yaml. A continuación se muestra una lista de pruebas comunes que se pueden ejecutar en el pipeline: * **Pruebas unitarias:** Ejecución de pruebas unitarias para componentes o módulos individuales de la aplicación, para asegurar que funcionen correctamente de forma aislada. * **Pruebas de integración:** Realización de pruebas de integración para verificar las interacciones entre los distintos componentes o módulos de la aplicación. * **Pruebas de API:** Prueba de la funcionalidad, rendimiento y seguridad de las APIs utilizadas por la aplicación, incluyendo pruebas de API tanto manuales como automatizadas. * **Pruebas de regresión:** Ejecución de pruebas de regresión para asegurar que los cambios recientes en el código no hayan introducido nuevos errores o regresiones en la aplicación. #### Deploy Puedes desplegar tu aplicación en cualquier entorno, como desarrollo, staging o producción, según tus necesidades específicas. A continuación se muestra una lista de destinos de despliegue comunes: * **Plataforma como servicio (PaaS):** Plataformas como Catalyst AppSail, Heroku o Google App Engine proporcionan un entorno gestionado para desplegar aplicaciones web sin necesidad de administrar la infraestructura subyacente. Los desarrolladores pueden concentrarse en escribir código sin preocuparse por la gestión de servidores. * **Contenedorización:** Uso de tecnologías de contenedorización como Docker para empaquetar la aplicación web junto con sus dependencias en contenedores. Estos contenedores pueden desplegarse de manera consistente en diferentes entornos, proporcionando portabilidad y escalabilidad. * **Orquestación de contenedores:** Herramientas como Kubernetes permiten el despliegue automatizado, el escalado y la gestión de aplicaciones contenedorizadas. Kubernetes ayuda a desplegar y gestionar contenedores a escala, proporcionando características como balanceo de carga y escalado automático. Se analizan los destinos de despliegue comunes y las instrucciones paso a paso para configurar el pipeline en esta página de ayuda. -------------------------------------------------------------------------------- title: "Crear un Pipeline" description: "Conoce el servicio Catalyst Pipelines y las instrucciones paso a paso para crear un pipeline en tu proyecto." last_updated: "2026-07-02T09:34:15.882Z" source: "https://docs.catalyst.zoho.com/es/pipelines/help/pipelines/create-a-pipeline/" service: "Pipelines" related: - Configure the Pipeline (/es/pipelines/help/catalyst-pipelines.yaml/implementation) - YAML Schema Reference (/es/pipelines/help/catalyst-pipelines.yaml/schema-reference) -------------------------------------------------------------------------------- # Crear un Pipeline Para crear un pipeline en la consola de Catalyst, asegúrate de seguir los pasos que se indican a continuación: 1. Haz clic en el ícono del servicio **Pipelines** en el menú izquierdo de la consola de Catalyst. 2. Haz clic en **Create Pipeline**. 3. En la ventana emergente que aparece, proporciona un nombre para el pipeline. 4. Selecciona tu fuente de integración preferida. Note: Este paso es completamente opcional. Si decides no integrar tu pipeline con ningún proveedor de Git, puedes proceder directamente al Paso 8. 5. Agrega una nueva cuenta de Git haciendo clic en la opción **+Add account**. Si tienes cuentas de Git integradas previamente con tu proyecto de Catalyst, se mostrarán en el menú desplegable. Simplemente elige la cuenta y continúa. 6. Selecciona la organización a la que pertenece la cuenta elegida. Note: Este atributo se refiere al nombre de tu organización en GitHub, el nombre del proyecto en GitLab y el nombre del workspace en Bitbucket. 7. Selecciona el repositorio donde deseas hacer commit del nuevo archivo catalyst-pipelines.yaml. Haz clic en **Continue**. Note: Si ya existe un archivo YAML en tu repositorio, asegúrate de nombrarlo obligatoriamente como catalyst-pipelines.yaml. 8. El editor de código se abre ahora. Puedes proceder a configurar el pipeline agregando los componentes requeridos en el editor. También puedes seleccionar la rama en la que se debe hacer commit del archivo, como se muestra en la captura de pantalla a continuación. Una vez que hayas definido el flujo de ejecución del pipeline, haz clic en **Commit**. También puedes guardar como borrador y trabajar en la lógica más adelante, si es necesario. Puedes optar por configurar el pipeline en modo **Builder** cambiando las pestañas, como se muestra en la captura de pantalla a continuación. Se analiza con más detalle la configuración del pipeline en esta página de ayuda. ## Primeros pasos -------------------------------------------------------------------------------- title: "Introducción" description: "Conoce el servicio Catalyst Pipelines que proporciona capacidades de integración y entrega continua para tu proceso de desarrollo de software." last_updated: "2026-07-02T09:34:15.882Z" source: "https://docs.catalyst.zoho.com/es/pipelines/getting-started/introduction/" service: "Pipelines" -------------------------------------------------------------------------------- # Primeros pasos # Introducción Pipelines es un servicio de integración continua y entrega continua (CI/CD) ofrecido por Catalyst que ayuda a optimizar y automatizar tu proceso de desarrollo y despliegue de software. Con Catalyst Pipelines, puedes compilar, probar y desplegar aplicaciones de manera eficiente en diversas plataformas y entornos en la nube. Al proporcionar una infraestructura escalable, junto con una integración fluida con sistemas de control de versiones populares y otros servicios de Catalyst, el servicio Pipelines permite a los equipos de desarrollo entregar software de alta calidad más rápido, con menos intervención manual y mejor colaboración. Antes de profundizar en los detalles, comencemos explorando los conceptos generales de CI/CD. ### Integración continua La Integración Continua (CI) es una práctica de desarrollo de software en la que cualquier actualización al repositorio de código fuente activa un proceso de compilación automatizado. Este proceso produce artefactos de lanzamiento desplegables que avanzan a través del pipeline de entrega continua y se despliegan en los entornos designados. Las características principales de la Integración Continua incluyen: **Integración con control de versiones** CI se integra de manera fluida con sistemas de control de versiones como GitHub, GitLab y Bitbucket. El repositorio de código fuente se monitorea continuamente; cada vez que se envían commits al sistema integrado, el pipeline inicia automáticamente los procesos de compilación, construcción y pruebas. Esto garantiza que la última versión de la aplicación esté siempre disponible. **Compilaciones y pruebas automatizadas** Los sistemas de CI soportan compilaciones concurrentes, lo que reduce los tiempos de espera de compilación y acelera el proceso general de desarrollo. Al ejecutar compilaciones en paralelo y probarlas simultáneamente, se proporciona retroalimentación sobre múltiples cambios de código más rápidamente, mejorando la productividad y permitiendo a los desarrolladores abordar problemas antes. Después del proceso de compilación, los sistemas de CI pueden ejecutar automáticamente un conjunto de pruebas sobre el nuevo código para identificar cualquier problema o regresión. **Retroalimentación instantánea** La Integración Continua tiene como objetivo proporcionar retroalimentación rápida sobre los cambios de código, empoderando a los equipos para rectificar problemas temprano en el ciclo de desarrollo. Este proceso mejora la calidad del software, minimiza riesgos y facilita una entrega más rápida de nuevas funcionalidades. ### Entrega continua La Entrega Continua se basa en el proceso de Integración Continua (CI) tomando los artefactos de lanzamiento desplegables y desplegándolos automáticamente en los entornos seleccionados. Este enfoque de ingeniería de software enfatiza la automatización del pipeline de entrega de software, asegurando despliegues rápidos con mínima intervención manual. Las características principales de la Entrega Continua incluyen: **Despliegues automatizados y gestión de entornos** La Entrega Continua optimiza el despliegue de cambios de código en diversos entornos, incluyendo desarrollo, pruebas, staging y producción, asegurando procedimientos de despliegue consistentes y confiables. Gestiona eficientemente múltiples entornos con diferentes configuraciones, permitiendo que los cambios de código se desplieguen y prueben en entornos aislados antes de enviarse a producción. **Actualizaciones incrementales y menor tiempo de comercialización** CD permite la entrega fluida de cambios pequeños e incrementales a los entornos de producción. Al dividir las actualizaciones en segmentos manejables, CD reduce los riesgos asociados con despliegues a gran escala. Este enfoque promueve ciclos de retroalimentación más rápidos, permitiendo la identificación y resolución oportuna de problemas. En última instancia, la Entrega Continua acelera el tiempo de comercialización para nuevas funcionalidades y mejoras, asegurando una entrega más rápida de valor a los usuarios finales. ### CI/CD en Catalyst Pipelines Catalyst Pipelines emplea el enfoque CI/CD para automatizar la compilación, pruebas y despliegue de tus aplicaciones en los entornos preferidos. Ya sea que estés desarrollando aplicaciones web o móviles, puedes desplegarlas fácilmente en cualquier plataforma, incluyendo Catalyst AppSail, Amazon S3, Google Cloud Platform, Heroku, Microsoft Azure, Firebase, y más. Independientemente de tu lenguaje de programación, Catalyst Pipelines soporta la automatización fluida para la compilación y despliegue de aplicaciones. Puedes consultar algunos ejemplos comunes de destinos de despliegue en esta página de ayuda. Puedes aprovechar completamente el ecosistema de Catalyst de las siguientes maneras: * Despliega cualquier aplicación en Catalyst usando el servicio Catalyst AppSail. * Despliega aplicaciones de Catalyst construidas con el componente Catalyst Serverless Functions en la nube de Catalyst. En ambos casos, puedes automatizar de manera fluida todo el proceso de compilación, pruebas y despliegue de tu aplicación usando el servicio Catalyst Pipelines. Puedes crear el pipeline directamente desde la consola de Catalyst. Los Catalyst Pipelines se ejecutan basándose en el código declarativo YAML definido en el archivo catalyst-pipelines.yaml, donde debes definir el flujo de ejecución del pipeline. Puedes definir el flujo agregando los componentes necesarios usando nuestro editor de código YAML integrado o el constructor visual según tus necesidades específicas. Puedes consultar esta página de ayuda para obtener más información sobre los componentes del pipeline. Para más detalles sobre la configuración del pipeline, consulta esta página de ayuda. Puedes elegir integrar tu pipeline con cualquier proveedor de Git que prefieras, como GitHub, GitLab o Bitbucket, para automatizar el proceso de ejecución. Profundizaremos en este tema en esta página de ayuda. También puedes implementar los métodos de nuestro Pipeline SDK en **Java**, **Node.js** y **Python** en tu aplicación, para obtener los detalles del pipeline y ejecutar un pipeline. Primero entendamos las ventajas clave de usar un pipeline en la siguiente sección. -------------------------------------------------------------------------------- title: "Beneficios" description: "Conoce los beneficios del servicio Catalyst Pipelines para la integración y entrega continua." last_updated: "2026-07-02T09:34:15.882Z" source: "https://docs.catalyst.zoho.com/es/pipelines/getting-started/benefits/" service: "Pipelines" -------------------------------------------------------------------------------- # Beneficios **Acelerar el ciclo de vida del desarrollo de software** Catalyst Pipelines automatiza el proceso de compilación, pruebas y despliegue de código en los entornos seleccionados, minimizando la intervención manual y permitiendo la entrega rápida de funcionalidades a los usuarios finales. Además, Catalyst Pipelines acelera el proceso de desarrollo al proporcionar retroalimentación oportuna a los desarrolladores, facilitando una resolución de problemas más rápida y mejorando la velocidad de iteración y refinamiento. Asegurar la confiabilidad y minimizar el riesgo Al emplear procesos de despliegue automatizados y procedimientos de pruebas, Catalyst Pipelines mitiga eficazmente el riesgo de desplegar código defectuoso en entornos de producción. Esta estrategia proactiva minimiza la probabilidad de interrupciones del servicio y tiempos de inactividad. La automatización reduce significativamente el potencial de error humano durante los despliegues, asegurando una entrega confiable. En última instancia, estas prácticas mejoran la eficiencia general del código fuente desplegado. **Versatilidad en el desarrollo** Catalyst Pipelines facilita el proceso de compilación para una amplia gama de lenguajes de programación, plataformas y herramientas, proporcionando adaptabilidad para desarrollar, probar y desplegar aplicaciones. **Configuraciones fácilmente personalizables y reutilizables** El servicio Catalyst Pipelines utiliza una sintaxis declarativa basada en YAML para definir pipelines, lo que te permite reutilizar las definiciones de pipeline según tus necesidades. Puedes personalizar fácilmente el flujo de trabajo de los pipelines usando nuestro editor de código YAML integrado o el constructor visual en la consola de Catalyst. **Escalar de manera rentable** Catalyst Pipelines puede manejar proyectos de cualquier tamaño y complejidad, desde pequeños proyectos personales hasta aplicaciones de nivel empresarial, gracias a su infraestructura escalable. Esto significa que mantiene la eficiencia del flujo de trabajo a medida que el tamaño del código base aumenta proporcionalmente, sin ningún incremento en el esfuerzo de mantenimiento de tu parte. El proceso de automatización allana el camino hacia ahorros de costos en términos de tiempo y recursos. Además, la detección temprana de errores y problemas puede prevenir costosas correcciones posteriores en el ciclo de desarrollo. **Automatización de flujos de trabajo en el ecosistema de Catalyst** Catalyst Pipelines se integra de manera fluida con otros servicios de Catalyst, como Catalyst Serverless Functions y Catalyst AppSail, habilitando el desarrollo de aplicaciones, la automatización optimizada de flujos de trabajo y el despliegue dentro del ecosistema de Catalyst. -------------------------------------------------------------------------------- title: "Casos de uso" description: "Conoce los casos de uso ideales del servicio Catalyst Pipelines." last_updated: "2026-07-02T09:34:15.883Z" source: "https://docs.catalyst.zoho.com/es/pipelines/getting-started/use-cases/" service: "Pipelines" -------------------------------------------------------------------------------- # Casos de uso Estos son algunos casos de uso ideales que demuestran la versatilidad y eficiencia del servicio Catalyst Pipelines: 1. **Iteración rápida para startups:** Para startups que desarrollan aplicaciones web, la velocidad y la agilidad son cruciales. Catalyst Pipelines permite a equipos pequeños: * Desplegar rápidamente nuevas funcionalidades y actualizaciones. * Ejecutar pruebas automáticamente antes de cada despliegue. * Revertir cambios fácilmente si surge algún problema. * Mantener un entorno de producción estable mientras experimentan con nuevas ideas. Esto permite a las startups mantenerse competitivas y responder a las demandas del mercado sin sacrificar la calidad del código ni la estabilidad. 2. **Despliegues empresariales a gran escala:** Las empresas que gestionan aplicaciones web complejas en múltiples entornos pueden aprovechar Catalyst Pipelines para: * Estandarizar los procesos de despliegue entre equipos y proyectos. * Coordinar despliegues en entornos de staging, desarrollo y producción. * Gestionar pruebas A/B y otros métodos de prueba comunes a escala. Esto asegura consistencia, reduce el error humano y optimiza el pipeline de despliegue para organizaciones grandes. 3. **Habilitación de la cultura DevOps:** Las organizaciones en transición a una cultura DevOps pueden usar Catalyst Pipelines para: * Cerrar la brecha entre los equipos de desarrollo y operaciones. * Implementar prácticas de infraestructura como código. * Automatizar tareas de despliegue repetitivas. * Proporcionar el estado del despliegue y métricas en tiempo real a todas las partes interesadas. Esto fomenta la colaboración, aumenta la transparencia y acelera el ciclo de vida de entrega de software. 4. **Automatización de aseguramiento de calidad y pruebas:** Los equipos de QA pueden aprovechar Catalyst Pipelines para: * Ejecutar automáticamente suites de pruebas completas antes del despliegue. * Integrar diversas herramientas de pruebas (unitarias, de integración, de rendimiento, de seguridad). * Generar informes de pruebas y métricas de cobertura de código. * Prevenir despliegues si las pruebas críticas fallan. Esto asegura que solo el código de alta calidad llegue a producción, reduciendo el riesgo de introducir errores o vulnerabilidades de seguridad. Las posibilidades son infinitas con Catalyst Pipelines, ya que soporta una amplia gama de escenarios de despliegue de aplicaciones web. Desde pequeñas startups hasta grandes empresas, y desde sitios web simples hasta arquitecturas complejas de microservicios, el servicio Pipelines proporciona las herramientas necesarias para despliegues eficientes, confiables y escalables. -------------------------------------------------------------------------------- title: "Guía de inicio rápido" description: "Conoce el proceso completo de utilización del servicio Catalyst Pipelines paso a paso." last_updated: "2026-07-02T09:34:15.883Z" source: "https://docs.catalyst.zoho.com/es/pipelines/getting-started/quick-start-guide/" service: "Pipelines" -------------------------------------------------------------------------------- # Guía de inicio rápido Esta sección detalla el proceso completo de utilización del servicio Catalyst Pipelines, desde la creación del pipeline y su configuración definiendo los componentes necesarios en un archivo YAML, hasta la ejecución del pipeline. Veamos los pasos en detalle: 1. **Crear un proyecto de Catalyst:** Accede a la consola de Catalyst para crear un nuevo proyecto. Una vez creado el proyecto, podrás acceder al servicio Catalyst Pipelines en la consola. También puedes explorar otros servicios de Catalyst desde la consola. 2. **Crear un pipeline:** En el servicio Catalyst Pipelines, puedes crear un pipeline directamente desde la consola. Consulta esta página de ayuda para conocer los pasos detallados para crear un pipeline. * **Conectar una fuente de integración** - Al crear un pipeline, puedes elegir integrarlo con cualquier proveedor de Git, como GitHub, GitLab o Bitbucket. Para habilitarlo, necesitas configurar el flujo de ejecución del pipeline en el archivo catalyst-pipelines.yaml y hacer commit de este archivo en el repositorio del proveedor de Git integrado. Esta configuración activará automáticamente el pipeline cada vez que se envíen cambios al repositorio vinculado. Cuando se active el pipeline, el código fuente completo del repositorio Git integrado, junto con el archivo YAML, se obtendrá y descargará automáticamente como un archivo ZIP en Catalyst. Ten en cuenta que esta integración es opcional. Nota: También puedes crear el pipeline sin integrarlo con un repositorio externo. En ese caso, necesitarás activar manualmente el pipeline cada vez desde la consola de Catalyst. 3. **Configurar el pipeline:** Puedes configurar el flujo de ejecución del pipeline definiendo los componentes necesarios como stages, jobs, runners, images, conditions y variables según tus requisitos en el catalyst-pipelines.yaml. Puedes usar nuestro editor de código YAML integrado o el constructor visual para este propósito. Consulta esta página para más detalles sobre la configuración del pipeline. 4. **Hacer commit del archivo catalyst-pipelines.yaml:** Este paso aplica solo si has vinculado una fuente de integración con el pipeline durante su creación. Una vez que hayas terminado de configurar el pipeline, necesitas hacer commit del archivo catalyst-pipelines.yaml en cualquier rama preferida de tu repositorio fuente. El archivo YAML se enviará a la rama en la fuente de integración seleccionada del **Paso 2**. Es obligatorio hacer commit del archivo YAML cada vez que se realicen cambios en el flujo del pipeline. Nota: Si no has conectado el pipeline con una fuente de integración, puedes omitir este paso y proceder a ejecutar el pipeline. 5. **Ejecutar el pipeline:** Después de configurar el pipeline, puedes iniciar su ejecución directamente desde la consola de Catalyst. Si el pipeline está vinculado a una fuente de integración, se ejecutará automáticamente cada vez que se envíen cambios al repositorio vinculado. Además, puedes monitorear el estado de ejecución y acceder a logs detallados de la ejecución del pipeline usando las pestañas **Basic** y **Advanced** dentro de la sección **Execution History** de la consola. Discutiremos esto en detalle en esta página de ayuda. --- ## API Reference — Pipelines -------------------------------------------------------------------------------- title: "Obtener detalles del Pipeline" description: "Esta API te permite obtener los detalles de un Catalyst Pipeline existente desde la consola de Catalyst." last_updated: "2026-07-02T09:34:15.886Z" source: "https://docs.catalyst.zoho.com/es/api/code-reference/pipelines/get-pipeline-details/" service: "Pipelines" -------------------------------------------------------------------------------- # Catalyst Pipelines Catalyst Pipelines es un servicio CI/CD de Catalyst que te permite automatizar los procesos de compilación, prueba y despliegue de tus aplicaciones. Puedes crear un pipeline desde la consola de Catalyst. Discutiremos las APIs que se pueden aprovechar para activar el pipeline y obtener los detalles de un pipeline existente en las siguientes secciones. # Obtener detalles del Pipeline Esta API te permite obtener los detalles de un pipeline creado en la consola de Catalyst. Esto se puede hacer pasando el pipeline_id y el project_id en la URL de solicitud. La API obtiene los detalles del proyecto en el que se creó el pipeline y los detalles del pipeline. ### Detalles de la solicitud #### URL de solicitud <p>{api-domain}/baas/v1/project/{project_id}/pipeline/{pipeline_id}</p> La URL del dominio de tu DC El ID único del proyecto en el que se ha creado el pipeline El ID único del pipeline para el que se deben obtener los detalles. #### Alcance pipeline.READ ### Detalles de la respuesta Se devolverá como respuesta el objeto de detalles del pipeline. Incluye detalles como el nombre del pipeline, detalles del proyecto incluyendo el project_name y project_type, los detalles del usuario que ha creado el pipeline incluyendo el user_id, email_id, first_name, last_name y user_type, el estado del pipeline, los detalles de los usuarios que modificaron el pipeline junto con los detalles del tiempo de modificación y también la configuración predeterminada del runner del pipeline. curl -X GET \ https://api.catalyst.zoho.com/baas/v1/project/4000000006007/pipeline/29810101101 \ -H "Authorization: Zoho-oauthtoken 1000.910*************************16.2f*************************57" \ { "status": "success", "data": { "pipeline_id": "29810101101", "name": "test1", "project_details": { "project_name": "Project-Rainfall", "id": "4000000006007", "project_type": "Live" }, "created_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "created_time": "Mar 19, 2024 11:28 AM", "modified_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "modified_time": "Mar 19, 2024 11:28 AM", "git_account_id": "", "mask_regex": [ null ], "pipeline_status": "Active", "config_id": 2, "integ_id": 1 } } Get Pipeline Details - Java SDK<br/><br/> Get Pipeline Details - Node.js SDK<br/><br/> Get Pipeline Details - Python SDK -------------------------------------------------------------------------------- title: "Ejecutar Pipeline" description: "Esta API te permite ejecutar un Catalyst Pipeline existente desde la consola de Catalyst." last_updated: "2026-07-02T09:34:15.886Z" source: "https://docs.catalyst.zoho.com/es/api/code-reference/pipelines/execute-pipeline/" service: "Pipelines" -------------------------------------------------------------------------------- # Ejecutar Pipelines Esta API te permite activar el pipeline en una rama particular del repositorio Git. Esto se puede hacer pasando el nombre de la rama como parámetro en el cuerpo de la solicitud. Al activar pipelines manuales, simplemente puedes ignorar el parámetro del nombre de la rama en el JSON de la solicitud. Al activar esta API, el pipeline se ejecutará y el estado de la ejecución se devolverá como respuesta. # Obtener detalles del Pipeline Esta API te permite obtener los detalles de un pipeline creado en la consola de Catalyst. Esto se puede hacer pasando el pipeline_id y el project_id en la URL de solicitud. La API obtiene los detalles del proyecto en el que se creó el pipeline y los detalles del pipeline. ### Detalles de la solicitud #### URL de solicitud <p>{api-domain}/baas/v1/project/{project_id}/pipeline/{pipeline_id}/run</p> La URL del dominio de tu DC El ID único del proyecto en el que se ha creado el pipeline El ID único del pipeline para el que se deben obtener los detalles. #### Propiedades JSON de la solicitud Proporciona el nombre de la rama de Git Proporciona cualquier detalle del evento Cualquier parámetro adicional requerido Nota: 1. BRANCH_NAME es opcional cuando necesitas activar un pipeline manual de Catalyst. 2. Hemos agregado las claves EVENT y URL como variables de entorno. Puedes pasar cualquier clave requerida para la ejecución del pipeline en el JSON del evento. #### Alcance pipeline.execution.CREATE ### Detalles de la respuesta Se devolverá como respuesta un objeto que contiene los detalles del historial de creación del pipeline. El objeto incluye detalles como el history_id, event_time, history_status. curl -X POST \ https://api.catalyst.zoho.com/baas/v1/project/4000000006007/pipeline/29810101101/run -H "Authorization: Zoho-oauthtoken 1000.910*************************16.2f*************************57" \ -d '{ "BRANCH_NAME" : "main", \ "EVENT": "push", \ "URL": "https://www.google.com" \ } { "status": "success", "data": { "history_id": "5000000021007", "pipeline_id": "29810101101", "event_time": "Mar 20, 2024 02:02 PM", "event_details": { "BRANCH_NAME": "main", "EVENT": "push", "URL": "https://www.google.com" }, "history_status": "Queued" } } Execute Pipeline - Java SDK<br/><br/> Execute Pipeline - Node.js SDK<br/><br/> Execute Pipeline - Python SDK --- ## SDK — Java — Pipelines -------------------------------------------------------------------------------- title: "Obtener instancia de Pipeline" description: "Esta página describe el método para obtener la instancia del pipeline y usarla para otras operaciones de pipeline." last_updated: "2026-07-02T09:34:15.891Z" source: "https://docs.catalyst.zoho.com/es/sdk/java/v1/pipelines/get-pipeline-instance/" service: "All Services" related: - Catalyst Pipelines (/es/pipelines/help/pipelines/introduction) - Create a Pipeline (/es/pipelines/help/pipelines/create-a-pipeline) - Node.js SDK (/es/sdk/nodejs/v2/pipelines/get-pipeline-instance) - Python SDK (/es/sdk/python/v1/pipelines/get-pipeline-instance) - REST API (/es/api/code-reference/pipelines/get-pipeline-details) -------------------------------------------------------------------------------- # Catalyst Pipelines Catalyst Pipelines implementa un enfoque CI/CD para permitir la automatización de la compilación, pruebas y despliegue de aplicaciones web o móviles en los entornos preferidos. Puedes crear un pipeline desde la consola de Catalyst. Usando los SDKs a continuación, puedes recuperar los detalles de un Pipeline de Catalyst y también ejecutar un pipeline incorporando los fragmentos de código en tu aplicación. #### Fragmento de código de ejemplo <br> import com.zc.component.pipeline.ZCPipeline; import com.zc.component.pipeline.ZCPipelineDetails; import com.zc.component.pipeline.ZCPipelineRunHistory; # Obtener instancia de Pipeline Una instancia de componente es un objeto que puede usarse para acceder a las propiedades específicas de un componente particular. Puedes crear una instancia de componente para realizar las acciones listadas a continuación en Catalyst Pipelines. Puedes crear una nueva instancia de pipelines_service como se muestra a continuación. Esta instancia del componente se usará para todas las operaciones de Pipeline en el SDK de Java. ZCPipeline pipelines_service = ZCPipeline.getInstance(); -------------------------------------------------------------------------------- title: "Obtener detalles del Pipeline" description: "Esta página describe el método para obtener todos los detalles de un Pipeline de Catalyst existente." last_updated: "2026-07-02T09:34:15.899Z" source: "https://docs.catalyst.zoho.com/es/sdk/java/v1/pipelines/get-pipeline-details/" service: "All Services" related: - Node.js SDK (/es/sdk/nodejs/v2/pipelines/get-pipeline-instance) - Python SDK (/es/sdk/python/v1/pipelines/get-pipeline-instance) -------------------------------------------------------------------------------- # Obtener detalles del Pipeline Puedes obtener los detalles del Pipeline de Catalyst pasando el ID del pipeline como parámetro al método getPipelineDetails(). El nombre del pipeline, los detalles del proyecto de Catalyst en el que se creó el pipeline, los detalles del usuario que lo creó, la hora de creación, y si se realizaron modificaciones, los detalles del usuario que modificó el pipeline, la hora de modificación, el estado del pipeline y otros detalles como las especificaciones del runner se devuelven como respuesta a este método. La referencia pipelines_service usada a continuación ya está definida en esta página de instancia del componente. ZCPipelineDetails pipeline_details = pipelines_service.getPipelineDetails(16965000000019202L); A continuación se muestra una respuesta de ejemplo: { "status": "success", "data": { "pipeline_id": "16965000000019202L", "name": "test1", "project_details": { "project_name": "Project-Rainfall", "id": "5000000000072", "project_type": "Live" }, "created_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "created_time": "Mar 19, 2024 11:28 AM", "modified_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "modified_time": "Mar 19, 2024 11:28 AM", "git_account_id": "", "mask_regex": [ null ], "pipeline_status": "Active", "config_id": 2, "integ_id": 1 } } -------------------------------------------------------------------------------- title: "Ejecutar Pipeline" description: "Esta página describe el método para ejecutar el Pipeline de Catalyst manualmente." last_updated: "2026-07-02T09:34:15.899Z" source: "https://docs.catalyst.zoho.com/es/sdk/java/v1/pipelines/execute-pipeline/" service: "All Services" related: - Node.js SDK (/es/sdk/nodejs/v2/pipelines/get-pipeline-instance) - Python SDK (/es/sdk/python/v1/pipelines/get-pipeline-instance) -------------------------------------------------------------------------------- # Ejecutar Pipeline Puedes iniciar una ejecución de pipeline de Catalyst pasando el ID del pipeline y el nombre de la rama como parámetros al método runPipeline(). También puedes pasar variables de entorno requeridas para la ejecución del pipeline en un objeto JSON a este método, y es completamente opcional. Este método devuelve los detalles del historial de ejecución del pipeline como respuesta. JSONObject env = new JSONObject(); env.put("EVENT", "push"); env.put("URL", "https://www.google.com"); ZCPipelineRunHistory run = pipelines_service.runPipeline(8431000000161112051L,main,env); A continuación se muestra una respuesta de ejemplo: { "status": "success", "data": { "history_id": "5000000021007", "pipeline_id": "8431000000161112051L", "event_time": "Mar 20, 2024 02:02 PM", "event_details": { "BRANCH_NAME": "detective_pre", "EVENT": "push", "URL": "https://www.google.com" }, "history_status": "Queued" } } --- ## SDK — Node JS — Pipelines -------------------------------------------------------------------------------- title: "Obtener instancia de Pipeline" description: "Esta página describe el método para obtener la instancia de pipeline y usarla para otras operaciones de pipeline." last_updated: "2026-07-02T09:34:15.899Z" source: "https://docs.catalyst.zoho.com/es/sdk/nodejs/v2/pipelines/get-pipeline-instance/" service: "All Services" related: - Catalyst Pipelines (/es/pipelines/help/pipelines/introduction) - Create a Pipeline (/es/pipelines/help/pipelines/create-a-pipeline) - Java SDK (/es/sdk/java/v1/pipelines/get-pipeline-instance) - Python SDK (/es/sdk/python/v1/pipelines/get-pipeline-instance) - REST API (/es/api/code-reference/pipelines/get-pipeline-details) -------------------------------------------------------------------------------- # Catalyst Pipelines Catalyst Pipelines implementa un enfoque CI/CD para habilitar la automatización de la construcción, pruebas y despliegue de aplicaciones web o móviles en los entornos preferidos. Puedes crear un pipeline desde la consola de Catalyst. Usando los SDKs a continuación, puedes recuperar los detalles de un Catalyst Pipeline y también ejecutar un pipeline incorporando los fragmentos de código en tu aplicación. # Obtener instancia de Pipeline Una instancia de componente es un objeto que se puede usar para acceder a las propiedades específicas de un componente en particular. Puedes crear una instancia de componente para realizar las acciones listadas a continuación en Catalyst Pipelines. La referencia app utilizada en el código a continuación es el objeto Node devuelto como respuesta durante la inicialización del SDK. Puedes crear una nueva instancia de pipelines_service como se muestra a continuación. const pipelines_service = app.pipeline() Esta instancia de componente se utilizará para todas las operaciones de Pipeline en el SDK de Node.js. -------------------------------------------------------------------------------- title: "Obtener detalles del Pipeline" description: "Esta página describe el método para obtener todos los detalles de un Catalyst Pipeline existente." last_updated: "2026-07-02T09:34:15.900Z" source: "https://docs.catalyst.zoho.com/es/sdk/nodejs/v2/pipelines/get-pipeline-details/" service: "All Services" related: - Catalyst Pipelines (/es/pipelines/help/pipelines/introduction) - Create a Pipeline (/es/pipelines/help/pipelines/create-a-pipeline) - Java SDK (/es/sdk/java/v1/pipelines/get-pipeline-instance) - Python SDK (/es/sdk/python/v1/pipelines/get-pipeline-instance) - REST API (/es/api/code-reference/pipelines/get-pipeline-details) -------------------------------------------------------------------------------- # Obtener detalles del Pipeline Puedes obtener los detalles del Catalyst Pipeline pasando el ID del pipeline como parámetro al método getPipelineDetails(). El nombre del pipeline, los detalles del proyecto Catalyst en el que se creó el pipeline, los detalles del usuario que creó el pipeline, la hora de creación, y si se realizaron modificaciones, los detalles del usuario que modificó el pipeline, la hora de modificación, el estado del pipeline y otros detalles como las especificaciones del runner se devuelven como respuesta a este método. La referencia pipelines_service utilizada a continuación ya está definida en esta página de instancia de componente. let pipline_details = pipelines_service.getPipelineDetails("16965000000019146") A continuación se muestra una respuesta de ejemplo: { "status": "success", "data": { "pipeline_id": "16965000000019146", "name": "test1", "project_details": { "project_name": "Project-Rainfall", "id": "5000000000072", "project_type": "Live" }, "created_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "created_time": "Mar 19, 2024 11:28 AM", "modified_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "modified_time": "Mar 19, 2024 11:28 AM", "git_account_id": "", "mask_regex": [ null ], "pipeline_status": "Active", "config_id": 2, "integ_id": 1 } } -------------------------------------------------------------------------------- title: "Ejecutar Pipeline" description: "Esta página describe el método para ejecutar el Catalyst Pipeline manualmente." last_updated: "2026-07-02T09:34:15.900Z" source: "https://docs.catalyst.zoho.com/es/sdk/nodejs/v2/pipelines/execute-pipeline/" service: "All Services" related: - Catalyst Pipelines (/es/pipelines/help/pipelines/introduction) - Create a Pipeline (/es/pipelines/help/pipelines/create-a-pipeline) - Java SDK (/es/sdk/java/v1/pipelines/get-pipeline-instance) - Python SDK (/es/sdk/python/v1/pipelines/get-pipeline-instance) - REST API (/es/api/code-reference/pipelines/get-pipeline-details) -------------------------------------------------------------------------------- # Ejecutar Pipeline Puedes iniciar una ejecución de Catalyst pipeline pasando el ID del pipeline y el nombre de la rama como parámetros al método runPipeline(). También puedes pasar variables de entorno requeridas para la ejecución del pipeline en un objeto JSON a este método, y es completamente opcional. Este método devuelve los detalles del historial de ejecución del pipeline como respuesta. La referencia pipelines_service utilizada a continuación ya está definida en esta página de instancia de componente. let execution_details = pipelines_service.runPipeline("8431000000162051", main,{"EVENT": "push", "URL":"https://www.google.com"}) A continuación se muestra una respuesta de ejemplo: { "status": "success", "data": { "history_id": "5000000021007", "pipeline_id": "8431000000162051", "event_time": "Mar 20, 2024 02:02 PM", "event_details": { "BRANCH_NAME": "main", "EVENT": "push", "URL": "https://www.google.com" }, "history_status": "Queued" } } --- ## SDK — Python — Pipelines -------------------------------------------------------------------------------- title: "Obtener instancia de Pipeline" description: "Esta página describe el método para obtener la instancia de pipeline y usarla para otras operaciones de pipeline." last_updated: "2026-07-02T09:34:15.901Z" source: "https://docs.catalyst.zoho.com/es/sdk/python/v1/pipelines/get-pipeline-instance/" service: "All Services" related: - Catalyst Pipelines (/es/pipelines/help/pipelines/introduction) - Create a Pipeline (/es/pipelines/help/pipelines/create-a-pipeline) - Java SDK (/es/sdk/java/v1/pipelines/get-pipeline-instance) - NodeJS SDK (/es/sdk/nodejs/v2/pipelines/get-pipeline-instance) - REST API (/es/api/code-reference/pipelines/get-pipeline-details) -------------------------------------------------------------------------------- # Catalyst Pipelines Catalyst Pipelines implementa un enfoque CI/CD para habilitar la automatización de la compilación, pruebas y despliegue de aplicaciones web o móviles a entornos preferidos. Puedes crear un pipeline desde la consola de Catalyst. Usando los SDKs a continuación, puedes recuperar los detalles de un Catalyst Pipeline y también ejecutar un pipeline incorporando los fragmentos de código en tu aplicación. # Obtener instancia de Pipeline Una instancia del componente es un objeto que se puede usar para acceder a las propiedades específicas de un componente en particular. Puedes crear una instancia del componente para realizar las acciones listadas a continuación en Catalyst Pipelines. La referencia app utilizada en el código a continuación es el objeto Python devuelto como respuesta durante la inicialización del SDK. Puedes crear una nueva instancia de pipelines_service como se muestra a continuación. pipelines_service = app.pipeline() Esta instancia del componente se utilizará para todas las operaciones de Pipeline en el SDK de Python. -------------------------------------------------------------------------------- title: "Obtener detalles del pipeline" description: "Esta página describe el método para obtener todos los detalles de un Catalyst Pipeline existente." last_updated: "2026-07-02T09:34:15.901Z" source: "https://docs.catalyst.zoho.com/es/sdk/python/v1/pipelines/get-pipeline-details/" service: "All Services" related: - Catalyst Pipelines (/es/pipelines/help/pipelines/introduction) - Create a Pipeline (/es/pipelines/help/pipelines/create-a-pipeline) - Java SDK (/es/sdk/java/v1/pipelines/get-pipeline-instance) - NodeJS SDK (/es/sdk/nodejs/v2/pipelines/get-pipeline-instance) - REST API (/es/api/code-reference/pipelines/get-pipeline-details) -------------------------------------------------------------------------------- # Obtener detalles del pipeline Puedes obtener los detalles del Catalyst Pipeline pasando el ID del pipeline como parámetro al método get_pipeline_details(). El nombre del pipeline, los detalles del proyecto Catalyst en el que se ha creado el pipeline, los detalles del usuario que creó el pipeline, la hora de creación, y si se han realizado modificaciones, los detalles del usuario que modificó el pipeline, la hora de modificación, el estado del pipeline y otros detalles como las especificaciones del runner se devuelven como respuesta a este método. La referencia pipelines_service utilizada a continuación ya está definida en esta página de instancia del componente. pipeline_details = pipelines_service.get_pipeline_details("16965000000027475") A continuación se muestra una respuesta de ejemplo: { "status": "success", "data": { "pipeline_id": "16965000000027475", "name": "test1", "project_details": { "project_name": "Project-Rainfall", "id": "5000000000072", "project_type": "Live" }, "created_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "created_time": "Mar 19, 2024 11:28 AM", "modified_by": { "zuid": "20257791", "is_confirmed": false, "email_id": "amelia.burrows@zylker.com", "first_name": "Amelia", "last_name": "Burrows", "user_type": "Admin", "user_id": "5000000000056" }, "modified_time": "Mar 19, 2024 11:28 AM", "git_account_id": "", "mask_regex": [ null ], "pipeline_status": "Active", "config_id": 2, "integ_id": 1 } } -------------------------------------------------------------------------------- title: "Ejecutar pipeline" description: "Esta página describe el método para ejecutar el Catalyst Pipeline manualmente." last_updated: "2026-07-02T09:34:15.902Z" source: "https://docs.catalyst.zoho.com/es/sdk/python/v1/pipelines/execute-pipeline/" service: "All Services" related: - Catalyst Pipelines (/es/pipelines/help/pipelines/introduction) - Create a Pipeline (/es/pipelines/help/pipelines/create-a-pipeline) - Java SDK (/es/sdk/java/v1/pipelines/get-pipeline-instance) - NodeJS SDK (/es/sdk/nodejs/v2/pipelines/get-pipeline-instance) - REST API (/es/api/code-reference/pipelines/get-pipeline-details) -------------------------------------------------------------------------------- # Ejecutar pipeline Puedes iniciar una ejecución de Catalyst Pipeline pasando el ID del pipeline y el nombre de la rama como parámetros al método run_pipeline(). También puedes pasar variables de entorno requeridas para la ejecución del pipeline en un objeto JSON a este método, y es completamente opcional. Este método devuelve los detalles del historial de ejecución del pipeline como respuesta. La referencia pipelines_service utilizada a continuación ya está definida en esta página de instancia del componente. execution_details = pipelines_service.run_pipeline("18014000000023048", "main", {"EVENT": "push","URL":"https://www.google.com"}) A continuación se muestra una respuesta de ejemplo: { "status": "success", "data": { "history_id": "5000000021007", "pipeline_id": "18014000000023048", "event_time": "Mar 20, 2024 02:02 PM", "event_details": { "BRANCH_NAME": "main", "EVENT": "push", "URL": "https://www.google.com" }, "history_status": "Queued" } }