---
title: "Iniciar un shell para Functions"
url: https://docs.catalyst.zoho.com/es/cli/v1/working-with-functions/functions-shell/
description: "Catalyst CLI te permite configurar el componente Functions incluso después de que el proyecto esté inicializado, agregar múltiples funciones en tu proyecto, configurar su memoria, probar funciones en un shell de Node, y eliminarlas."
last_updated: 2026-08-17T12:16:04Z
service: All Services
type: general
---

# Iniciar un shell para Functions

### Introducción

El shell de Functions te ofrece las capacidades de una consola de shell de Node combinadas con la eficiencia del
Catalyst CLI, para probar y depurar tus funciones.

Usando el shell de Functions del Catalyst CLI, puedes probar y depurar los siguientes [tipos de funciones](https://docs.catalyst.zoho.com/es/serverless/help/functions/basic-io/) de las plataformas Java, Node.js o Python en tu proyecto: **Basic I/O**, **Cron**, **Event** e **Integration**.

> **Nota:** No podrás probar funciones Advanced I/O usando el shell de Node. Sin embargo, puedes servir funciones Advanced I/O, e incluso funciones Basic I/O y el Client, desde un host local y probar su rendimiento usando el comando [`catalyst serve`](https://docs.catalyst.zoho.com/es/cli/v1/serve-resources/introduction/).

La salida de la ejecución de una función se obtiene y muestra en el CLI en formato JSON. Para una función
Basic I/O, la salida String se genera en el CLI, y para los otros tipos de funciones, se obtienen las respuestas
apropiadas.

Mientras pruebas una función Basic I/O de los stacks Java o Node.js, también puedes adjuntar un depurador al endpoint de la función y probar su código a través de un servidor local, o habilitar el modo HTTP para ella en el shell. Esto no es compatible con funciones Python, pero puedes depurar una función Python de forma independiente. 

Catalyst CLI también proporciona varias otras opciones para el shell de Functions que discutiremos más adelante en esta sección.

### Ejecución del comando del shell de Functions

Para iniciar un shell para probar una función, navega al directorio del proyecto de la función y ejecuta el
siguiente comando:

```sh
 catalyst functions:shell 
```

Esto abre el shell en el CLI. Puedes probar cualquier función en tu proyecto que no sea Advanced I/O,
pasar entradas y ejecutarla en el caso de una función Basic I/O, y realizar otras operaciones de shell de Node sobre ella.

![Functions Shell](https://catalyst-docs-development.zohostratus.in/images/cli/working-with-functions/catalyst_cli_shell.webp)

Puedes pasar entradas a una función Basic I/O en el shell de dos maneras:

* Pasar valores a las variables de la función y ejecutar la función.
* Declarar una variable en el CLI, asignarla a una variable de la función, y pasar los valores de entrada a través de
la variable declarada. Luego puedes vincular la variable declarada a esa función y ejecutarla.

#### Ejemplo para pasar entrada directa

Probemos una función simple llamada _EMI_ , que te permite pasar un valor de entrada para una variable llamada
_principal_ . Esta función luego calcula el monto de EMI para un servicio de envío, basándose en algunos valores
constantes predefinidos.

Pasamos un valor para la variable de entrada y ejecutamos la función _EMI_ en el shell ingresando la siguiente
declaración:

```sh
 EMI({"principal":"10000"}) 
```

Esto invoca la función _EMI_ y pasa la entrada a su variable. Una vez que la ejecución de la función se completa,
la salida se obtiene del servidor como una respuesta JSON. El CLI muestra la salida de la función junto con el
código de estado HTTP enviado por el servidor.

![Functions Shell](https://catalyst-docs-development.zohostratus.in/images/cli/working-with-functions/catalyst_cli_functions_shell_pass_value.webp)

#### Ejemplo para declarar una variable y vincularla

También puedes declarar una variable en el CLI y asignarla a la variable en la función. Esto te permitirá usar la variable declarada en lugar de la variable de la función y pasar valores de entrada fácilmente.

Declaremos una variable 'P', asignémosla a la variable _principal_ en la función _EMI_ , y pasemos un valor de entrada. Esto se puede hacer ejecutando el siguiente comando en el shell:

```sh
 var P={"principal":"3000"}  
```

Esto asigna _P_ a _principal_ y pasa el valor de entrada de 3000 a P. Puedes verificar si la variable fue asignada imprimiendo el valor de P en la consola.

Esto se puede hacer usando la función de Node.js `console.log()` de la siguiente manera:

```sh
 console.log(P) 
```

Si la variable fue asignada y el valor fue pasado exitosamente, el shell imprimirá el valor de _principal_ que fue pasado.

![Functions Shell](https://catalyst-docs-development.zohostratus.in/images/cli/working-with-functions/catalyst_cli_functions_shell_variable_declaration.webp)

Ahora puedes vincular la variable declarada a la función y ejecutarla de la siguiente manera:

```sh
 EMI(P) 
```

Esto invoca la función y pasa la entrada a su variable a través de _P_ . Una vez que la ejecución de la función se completa, el CLI mostrará la salida junto con el código de estado HTTP enviado por el servidor.

![Functions Shell](https://catalyst-docs-development.zohostratus.in/images/cli/working-with-functions/catalyst_cli_functions_shell_variable_bind.webp)

El CLI devolverá los códigos de respuesta HTTP apropiados del servidor si ocurren errores en tiempo de ejecución.

#### Salir del shell

Puedes salir del shell de Functions matando el comando de terminal según tu entorno local o ejecutando el siguiente comando:

```sh
 .exit 
```

Una vez que tu función ha sido probada exhaustivamente, puedes [desplegar la función](https://docs.catalyst.zoho.com/es/cli/v1/deploy-resources/introduction/) desde el entorno local a la consola remota.

### Opciones del shell de Functions

Hay cuatro opciones que puedes usar con el comando de inicio del shell de Functions.

#### \--http \[port\]

La opción `-\\-http` invoca tu función Basic I/O en el modo HTTP. El CLI sirve tu función a través de un host local, y te proporciona acceso a su endpoint local. El servidor estará escuchando en el puerto donde la función se aloja localmente, y el CLI mostrará un log en vivo de las actividades en el puerto. El CLI luego abrirá el shell de Functions donde puedes probar tu función.

> **Nota:** La opción `-\\-http` solo es aplicable a funciones Basic I/O, ya que los endpoints de las funciones Cron, Event e Integration no se pueden acceder directamente.

Esta opción es similar a la funcionalidad del comando [ `catalyst serve` ](https://docs.catalyst.zoho.com/es/cli/v1/serve-resources/introduction/) que sirve funciones Basic I/O, funciones Advanced I/O y los componentes Client localmente.

Puedes iniciar un shell de Functions en modo HTTP y probar todas las funciones Basic I/O en un proyecto, ejecutando el siguiente comando desde el directorio del proyecto:

```sh
 catalyst functions:shell --http 
```

Esto alojará todas las funciones Basic I/O en el directorio de Functions del proyecto localmente, en el **puerto predeterminado 8080** . El CLI mostrará las URLs de los endpoints de todas las funciones. Puedes acceder a estas funciones abriendo las URLs en tu navegador en cualquier momento mientras realizas las operaciones del shell.

![Functions Shell- HTTP Port](https://catalyst-docs-development.zohostratus.in/images/cli/working-with-functions/catalyst_cli_functions_shell_http.webp)

Ahora puedes probar y ejecutar tus funciones como se discutió en la sección anterior usando el shell, y verlas en modo HTTP accediendo a sus URLs.

También puedes iniciar el servidor en un puerto diferente, si lo necesitas, mientras ejecutas este comando y anular el puerto predeterminado 8080. Esto se puede hacer especificando el número de puerto con la opción `-\\-http`.

Por ejemplo, si prefieres usar el puerto 7000, ejecuta este comando desde el directorio del proyecto:

```sh
 catalyst serve --http 7000 
```

#### \--debug \[port\]

Catalyst te permite probar tus funciones Java y Node.js localmente con un depurador remoto adjunto al servidor localhost en vivo. 

> **Nota:** El comando `catalyst functions:shell --debug` no es compatible con funciones Python. Para conocer los pasos para depurar una función Python, consulta [esta sección](https://docs.catalyst.zoho.com/es/cli/v1/working-with-functions/functions-shell/#debugging-python-functions).

Cuando usas la opción `-\\-debug` e inicias el shell de Functions, Catalyst escuchará el transporte `dt\_socket` en el puerto predeterminado o personalizado y esperará la conexión del depurador después de invocar la función. Una vez que la conexión se establece, el depurador adjunto depurará la ejecución de tu función e identificará cualquier error y problema en su código.

Puedes iniciar tu shell de Functions e iniciar la conexión al depurador ejecutando el siguiente comando desde el directorio del proyecto:

```sh
 catalyst functions:shell --debug 
```

Esto abrirá el shell de Functions de la misma manera que antes. Cuando invoques la función en el shell, Catalyst establecerá la conexión con el depurador. Catalyst CLI asignará el **puerto 8000** para el depurador por defecto.

![Functions Shell- Debug](https://catalyst-docs-development.zohostratus.in/images/cli/working-with-functions/catalyst_cli_functions_shell_debug.webp)

Una vez que el depurador esté adjunto, el CLI mostrará un mensaje para indicar este hecho. Catalyst luego ejecutará tu función en el modo de depuración y mostrará la respuesta del servidor.

Puedes anular el puerto predeterminado 8000 e iniciar el depurador en un puerto diferente, si es necesario. Esto se puede hacer especificando el número de puerto con la opción `-\\-debug`.

Por ejemplo, si prefieres usar el puerto 7000, ejecuta el siguiente comando desde el directorio del proyecto:

```sh
 catalyst serve --debug 7000 
```

#### \--ignore-scripts

Esta opción te permite indicar a Catalyst que ignore los [scripts de ciclo de vida pre y post](https://docs.catalyst.zoho.com/es/cli/v1/scripts/introduction/) escritos en el archivo [ `catalyst.json` ](https://docs.catalyst.zoho.com/es/cli/v1/project-directory-structure/catalyst-json/) para una función particular.

Dado que puedes alojar y acceder a los endpoints de funciones Basic I/O usando la opción `-\\-http` en el shell de Functions, los scripts `preserve` y `postserve` se ejecutan automáticamente cuando se alojan. El script `preserve` se ejecuta antes de que la función sea servida, y el script `postserve` se ejecuta después de que salgas del serve local, si están disponibles.

Puedes indicar a Catalyst que ignore estos scripts de ciclo de vida pre y post cuando las funciones son servidas usando la opción `-\\-ignore-scripts`.

Por ejemplo, configuremos el archivo `catalyst.json` de un proyecto para incluir los siguientes scripts `preserve` y `postserve` para una función.

![Functions Shell- Ignore Scripts](https://catalyst-docs-development.zohostratus.in/images/cli/working-with-functions/catalyst_cli_functions_ignore_scripts_code.webp)

Si inicias el shell de Functions sin usar la opción `\--ignore-scripts`, los scripts se ejecutarán antes de que el shell se abra y después de que salgas del shell respectivamente, como se muestra a continuación.

![Functions Shell- Ignore Scripts](https://catalyst-docs-development.zohostratus.in/images/cli/working-with-functions/catalyst_cli_functions_ignore_scripts_without.webp)

Para ignorar los scripts `preserve` y `postserve`, inicia el shell de Functions ejecutando el siguiente comando desde el directorio de tu proyecto:

```sh
 catalyst functions:shell --ignore-scripts 
```

Esto ignorará los scripts y ejecutará el shell de la manera estándar.

![Functions Shell- Ignore Scripts](https://catalyst-docs-development.zohostratus.in/images/cli/working-with-functions/catalyst_cli_functions_ignore_scripts.webp)

#### \--no-watch

Catalyst CLI habilita un modo de observación en vivo en el shell de Functions por defecto. Este modo observa activamente los cambios realizados en el archivo de la función o en el directorio de la función después de que el shell se abra. Cuando detecta cambios confirmados en el archivo de la función o el directorio de la función, habilita una recarga en caliente del shell de Functions para reflejar las actualizaciones en vivo. Por lo tanto, podrás acceder a la versión actualizada de la función en el shell en vivo inmediatamente después de que los cambios se guarden, sin tener que recompilar o re-servir el código.

Puedes deshabilitar este modo de observación predeterminado iniciando el shell de Functions usando la opción `-\\-no-watch`, como se muestra a continuación:

```sh
 catalyst functions:shell --no-watch 
```

Ahora, si haces algún cambio en el archivo de la función después de haberlo iniciado en el shell, las actualizaciones no se reflejarán en la función compilada abierta en el shell. Puedes trabajar con la versión actualizada de la función ya sea reinvocando la función después de que se hayan hecho los cambios, o saliendo del shell y reabriéndolo.

Por ejemplo, consideremos una función que contiene el código de ejemplo predeterminado de una función Basic I/O de Node.js. Imprime el mensaje "Hello from index.js" cuando se invoca en el shell de Functions.

![Functions Shell- No Watch](https://catalyst-docs-development.zohostratus.in/images/cli/working-with-functions/catalyst_cli_serve_no_watch_1.webp)

Si haces cambios en el código de la función como se muestra a continuación, estas actualizaciones no se reflejan en vivo en el CLI mientras la función aún está abierta en el shell.

![Functions Shell- No Watch](https://catalyst-docs-development.zohostratus.in/images/cli/working-with-functions/catalyst_cli_serve_no_watch_2.webp)

Necesitarás invocar la función de nuevo para obtener la salida del código actualizado.

![Functions Shell- No Watch](https://catalyst-docs-development.zohostratus.in/images/cli/working-with-functions/catalyst_cli_serve_no_watch_3.webp)

Sin embargo, si no usas la opción `-\\-no-watch` e inicias el shell de Functions con el modo de observación predeterminado habilitado, el shell detectará los cambios realizados en el código en vivo y realizará una recarga en caliente de la función automáticamente, como se muestra a continuación.

![Functions Shell- No Watch](https://catalyst-docs-development.zohostratus.in/images/cli/working-with-functions/catalyst_cli_serve_no_watch_4.webp)

### Depuración de funciones Python

Para depurar una función Python, necesitarás usar un IDE de Python de forma independiente, ya que Catalyst actualmente no ofrece soporte del CLI para depurarlas. Puedes adjuntar un depurador local con un IDE de tu elección, como Visual Studio Code o PyCharm. El depurador escuchará en el puerto donde la función se aloja localmente y el IDE mostrará un log en vivo de las actividades en el puerto.
	
Los pasos para depurar una función Python usando VS Code se indican a continuación:

1. Para depurar una función Python particular alojada en un servidor local desde un IDE directamente, necesitarás un paquete de depuración para establecer la conexión entre el servidor local y el IDE. En este caso, usaremos el paquete de Python debugpy.

Abre el directorio de tu proyecto de Catalyst en VS Code. En el archivo `main.py`, incluye las líneas de código indicadas a continuación. 

```python
import debugpy
debugpy.listen(<<"Enter port number here">>)
debugpy.wait_for_client()

```

> **Nota:** El puerto predeterminado para adjuntar en las configuraciones de debug de VS Code es 5678. Este es el puerto donde la función Python será servida. Puedes anular el puerto predeterminado y cambiarlo mientras ejecutas el comando serve, si es necesario, usando la opción especificada a continuación:

```sh
catalyst serve --http &lt;Port number&gt;
```

2. Navega a tu directorio de Functions y, para instalar el paquete `debugpy`, ejecuta este comando en la terminal de tu IDE:

```sh
python -m pip install --upgrade debugpy

```

3. Crea un archivo `launch.json` en el directorio raíz de tu proyecto de Catalyst, si no existe uno ya. Puedes consultar [ esta página de ayuda](https://code.visualstudio.com/docs/python/debugging#_initialize-configurations) para los pasos para crear un archivo `launch.json`. Agrega el siguiente código en el archivo y guárdalo.

```json
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python: Remote Attach",
            "type": "python",
            "request": "attach",
            "connect": {
                "host": "localhost",
                "port": <<Enter port number here>>
            },
            "pathMappings": [
                {
                    "localRoot": "${workspaceFolder}",
                    "remoteRoot": "${workspaceFolder}/.build/"
                }
            ],
            "justMyCode": true
        }
    ]
}

```

4. Ahora, cambia a la vista Run and Debug en VS Code e inicia el depurador. Ahora puedes ejecutar el comando CLI serve para ver los detalles de ejecución de la función en la terminal de tu IDE.

> **Nota:** Debes asegurarte de especificar el mismo número de puerto mencionado en los archivos de configuración mientras ejecutas el comando.

![](https://catalyst-docs-development.zohostratus.in/images/cli/working-with-functions/catalyst_cli_vscode_debug.webp)

Puedes consultar [esta página de ayuda](https://code.visualstudio.com/docs/python/debugging#_debugging-by-attaching-over-a-network-connection) para pasos más detallados sobre la depuración de scripts locales de funciones Python en VS Code.

> **Nota:** Si eres usuario de **Visual Studio Code IDE**, puedes instalar la extensión **Catalyst Tools** y realizar operaciones del CLI usando tu IDE en lugar del CLI. Los pasos para ejecutar y depurar funciones de Catalyst usando Visual Studio Code IDE se pueden encontrar [aquí](https://docs.catalyst.zoho.com/es/catalyst-extensions/vs-code-extension/implementation/#run-or-debug-a-function)