Saltar a contenido

Usar el LaunchPad#

Acceso al entorno de desarrollo#

El LaunchPad es el entorno de desarrollo en la nube (IDE) basado en Jupyter Notebook e integrado con la plataforma, desde el que también puedes desarrollar y probar tu solver.

Accede al LaunchPad a través de esta URL: https://ide.sandbox.qcentroid.com/

Usa tu dirección de correo electrónico y contraseña — las mismas credenciales que usas para acceder a la plataforma QCentroid.

Pantalla de login del LaunchPad

Una vez iniciada la sesión:

  1. Un servidor Jupyter se lanzará automáticamente con un entorno de 16 núcleos y 32 GB de memoria.
  2. Serás redirigido al entorno Jupyter Notebook.
  3. Verás que el IDE ya está conectado a tu repositorio Git con la plantilla de código fuente de tu solver lista para usar.

Entorno Jupyter Notebook

Solvers Fujitsu

Si tu solver está asociado al proveedor Fujitsu, el servidor que se lanza incluye el cliente VPN preconfigurado y establece automáticamente la conexión con la red privada del cluster. Consulta la sección Proveedor: Fujitsu para más detalles.

Apagar el servidor#

Cuando termines de trabajar, es recomendable apagar el servidor del LaunchPad para liberar recursos. El LaunchPad apaga los servidores automáticamente tras 1 hora de inactividad, pero puedes hacerlo manualmente antes:

  1. En el menú superior de JupyterLab, ve a File > Hub Control Panel.
  2. En la página que se abre, haz clic en Stop My Server.

El servidor se detendrá y los recursos quedarán liberados. Tus archivos del volumen persistente no se perderán — estarán disponibles la próxima vez que inicies sesión.

Estructura del repositorio#

Tu repositorio contiene una plantilla de solver con los siguientes archivos principales:

Archivo Descripción
qcentroid.py Archivo principal del solver — aquí va tu algoritmo
Launcher.ipynb Jupyter Notebook para probar el solver en el IDE
requirements.txt Dependencias de Python del solver
README.md Documentación del solver

qcentroid.py#

Este es el archivo más importante. Contiene la función run(), que es el punto de entrada que la plataforma llama al ejecutar un job.

qcentroid.py
import logging
logger = logging.getLogger("qcentroid-user-log")

def run(input_data: dict, solver_params: dict, extra_arguments: dict) -> dict:

    logger.info("Iniciando solver...")

    # Aquí va tu código

    output = {"resultado": "valor de salida"}

    logger.info("Solver finalizado.")
    return output

Los parámetros que recibe son:

  • input_data — datos de entrada del job en formato diccionario (JSON)
  • solver_params — parámetros de configuración del solver definidos en la plataforma
  • extra_arguments — argumentos adicionales de la plataforma

No modifiques la firma de run()

El nombre del archivo (qcentroid.py) y la firma de la función run() deben mantenerse exactamente como están. La plataforma los usa como punto de entrada fijo.

Launcher.ipynb#

Notebook de Jupyter para ejecutar y probar tu solver directamente en el IDE sin necesidad de subirlo a la plataforma. Contiene instrucciones detalladas y todos los pasos necesarios.

requirements.txt#

Lista de dependencias de Python del solver en formato pip:

requirements.txt
ortools
numpy

Incluye aquí todas las librerías que uses, excepto las estándar de Python (json, logging, time, etc.).

README.md#

Documentación del solver. Debe explicar qué hace y describir los parámetros de entrada y salida que usa.

Implementar tu solver#

Modifica qcentroid.py#

Empieza modificando el archivo qcentroid.py para implementar tu algoritmo dentro de la función run().

Añade logs para depuración#

Usa el sistema de logging de QCentroid para ver trazas de ejecución en el dashboard de la plataforma después de cada job:

import logging
logger = logging.getLogger("qcentroid-user-log")

def run(input_data, solver_params, extra_arguments):

    logger.info("Iniciando ejecución...")

    valor = input_data.get("mi_parametro")
    logger.info(f"Parámetro de entrada: {valor}")

    # Tu algoritmo aquí

    logger.info("Ejecución finalizada.")
    return {"resultado": valor}

Los logs aparecen en la pestaña Execution logs de la página de detalles del job en la plataforma.

Mide el tiempo de ejecución#

import time

start = time.time()

# El proceso a medir

elapsed = time.time() - start
logger.info(f"Tiempo de ejecución: {elapsed:.2f} segundos")

Gestión de excepciones#

Importante

No captures excepciones de forma global en tu solver. Las excepciones bloqueantes deben propagarse para que la plataforma las capture, detenga la ejecución y muestre el mensaje de error en el dashboard.

Puedes usar try/except con alcance limitado, pero nunca hagas un except Exception en el nivel raíz del solver.

Prueba el solver en el IDE#

Antes de subir el código a la plataforma, usa el Launcher.ipynb para ejecutar y probar tu solver directamente en el IDE con datos de entrada de prueba.

Push del código al servidor Git#

Cuando tengas una versión estable de tu solver, guárdala en el repositorio desde la barra lateral del IDE:

  1. Haz clic en la pestaña Git de la barra de herramientas izquierda.
  2. Haz clic en el botón + junto a los archivos nuevos o modificados para añadirlos al stage.
  3. Escribe un mensaje de commit descriptivo.
  4. Haz clic en COMMIT.
  5. Haz clic en el botón Push (esquina superior derecha del panel Git) para enviar los cambios al servidor Git.

Push de cambios al servidor Git

Una vez subido el código, puede ser descargado y compilado en la plataforma con el proceso Build. Consulta la sección Usar la Plataforma para los siguientes pasos.

Scripts creados en Windows

Si has editado archivos .sh en Windows, pueden contener saltos de línea en formato Windows (CRLF) que causan errores en el cluster Linux. Conviértelos antes de usarlos: 

sed -i 's/\r//' mi_script.sh
O cambia el formato en VS Code: barra inferior CRLF → LF antes de guardar.