Automatizacion Operativa

Job scheduler nativo, programas CL para operaciones, analisis de logs, alertas y notificaciones, watchers, scripting con QShell/PASE y herramientas de terceros para automatizar la administracion de IBM i.

Job Scheduler nativo

IBM i incluye un job scheduler integrado en el sistema operativo. Se gestiona con los comandos ADDJOBSCDE, WRKJOBSCDE y sus variantes. Es el equivalente a cron en Linux, pero esta integrado con el sistema de seguridad, job descriptions y message queues del sistema operativo.

Linux / cron

•crontab -e para editar tareas del usuario
•Formato: minuto hora dia mes dia-semana comando
•systemd timers como alternativa moderna
•Logging via syslog o redireccion a archivos
•anacron para jobs que se perdieron
•at para ejecucion unica

IBM i / JOBSCDE

•ADDJOBSCDE / WRKJOBSCDE para gestionar
•FRQ(*WEEKLY) SCDDAY(*MON) SCDTIME('230000')
•Integrado con job descriptions y JOBD
•Logging automatico en job log y QHST
•Calendario de exclusion con OMITDATE
•Ejecucion unica con FRQ(*ONCE) SCDDATE

CL -- Ejemplos de ADDJOBSCDE

/* Backup nocturno de lunes a viernes a las 23:00 */
ADDJOBSCDE JOB(BKPNOCHE)
  CMD(CALL PGM(MILIB/BKPNOCHE))
  FRQ(*WEEKLY)
  SCDDAY(*MON *TUE *WED *THU *FRI)
  SCDTIME('230000')
  USER(QSECOFR)
  JOBD(MILIB/BKPJOBD)
  MSGQ(QSYSOPR)

/* Reporte diario a las 6:00 AM todos los dias */
ADDJOBSCDE JOB(RPTDIARIO)
  CMD(CALL PGM(MILIB/RPTDIARIO))
  FRQ(*WEEKLY) SCDDAY(*ALL)
  SCDTIME('060000')

/* Monitoreo cada 15 minutos */
ADDJOBSCDE JOB(MONITOR15)
  CMD(CALL PGM(MILIB/MONITORSYS))
  FRQ(*MINUTES) SCDMINUTE(15)

/* Cierre mensual el primer dia del mes */
ADDJOBSCDE JOB(CIERREMENS)
  CMD(CALL PGM(MILIB/CIERREMENS))
  FRQ(*MONTHLY)
  SCDDATE(*MONTHSTR)
  SCDTIME('010000')

/* Job unico para una fecha especifica */
ADDJOBSCDE JOB(MIGRA2026)
  CMD(CALL PGM(MILIB/MIGRAR))
  FRQ(*ONCE)
  SCDDATE('03/15/26')
  SCDTIME('220000')

/* Pausar un job (hold) */
CHGJOBSCDE JOB(BKPNOCHE) STATUS(*HLD)

/* Reactivar un job */
CHGJOBSCDE JOB(BKPNOCHE) STATUS(*RLSD)

/* Eliminar un job del scheduler */
RMVJOBSCDE JOB(MIGRA2026)

/* Listar todos los jobs programados */
WRKJOBSCDE

SQL -- Consultar jobs programados via SQL

-- Listar todos los trabajos programados con detalle
SELECT JOB_NAME, SCHEDULED_DATE, SCHEDULED_TIME,
       FREQUENCY, STATUS, NEXT_SUBMISSION_DATE,
       COMMAND
FROM QSYS2.SCHEDULED_JOB_INFO
ORDER BY JOB_NAME;

-- Jobs en estado HELD (pausados)
SELECT JOB_NAME, STATUS, COMMAND
FROM QSYS2.SCHEDULED_JOB_INFO
WHERE STATUS = 'HELD';

-- Proximos jobs a ejecutarse en las proximas 24 horas
SELECT JOB_NAME, NEXT_SUBMISSION_DATE,
       SCHEDULED_TIME, COMMAND
FROM QSYS2.SCHEDULED_JOB_INFO
WHERE STATUS = 'SCHEDULED'
  AND NEXT_SUBMISSION_DATE BETWEEN
    CURRENT_DATE AND CURRENT_DATE + 1 DAY
ORDER BY NEXT_SUBMISSION_DATE, SCHEDULED_TIME;

Buena practica: Siempre asigne una JOBD (job description) especifica a cada job del scheduler. La JOBD controla la cola de ejecucion (JOBQ), el output queue, la library list inicial y el behavior ante mensajes de inquiry. Un job scheduler sin JOBD correcta es la causa numero uno de fallas nocturnas.

CL para automatizacion operativa

Los programas CL (Control Language) son la herramienta principal del administrador de IBM i para automatizar operaciones. Un programa CL es el equivalente a un shell script de bash en Linux -- pero compilado, con acceso directo a todos los comandos del sistema operativo, manejo de errores integrado (MONMSG) y control de flujo.

Estructura basica y compilacion

CL -- Estructura de un programa CL operativo

PGM
  DCL VAR(&FECHA) TYPE(*CHAR) LEN(10)
  DCL VAR(&HORA)  TYPE(*CHAR) LEN(8)
  DCL VAR(&ERRORES) TYPE(*DEC) LEN(3 0) VALUE(0)
  DCL VAR(&MSG)   TYPE(*CHAR) LEN(200)

  /* Monitor global de errores -- equivalente a set -e en bash */
  MONMSG MSGID(CPF0000 MCH0000) EXEC(GOTO CMDLBL(ERROR))

  /* Obtener fecha y hora */
  RTVSYSVAL SYSVAL(QDATE) RTNVAR(&FECHA)
  RTVSYSVAL SYSVAL(QTIME) RTNVAR(&HORA)

  /* Ejecutar operaciones con manejo individual */
  SAVLIB LIB(MILIB) DEV(*SAVF) SAVF(QGPL/BKPMILIB)
  MONMSG MSGID(CPF0000) EXEC(DO)
    CHGVAR VAR(&ERRORES) VALUE(&ERRORES + 1)
    SNDMSG MSG('Error en backup de MILIB') TOUSR(QSYSOPR)
  ENDDO

  /* Resultado */
  IF COND(&ERRORES *EQ 0) THEN(DO)
    SNDMSG MSG('Proceso OK - ' *CAT &FECHA) TOUSR(QSYSOPR)
  ENDDO
  ELSE CMD(DO)
    SNDMSG MSG('Proceso con errores - revisar log') TOUSR(QSYSOPR)
  ENDDO

  GOTO CMDLBL(FIN)

ERROR:
  SNDMSG MSG('ERROR CRITICO - revisar job log') TOUSR(QSYSOPR)

FIN:
ENDPGM

CL -- Compilar programa CL

/* ILE CL (moderno - recomendado) */
CRTBNDCL PGM(MILIB/BKPNOCHE)
  SRCFILE(MILIB/QCLSRC)
  SRCMBR(BKPNOCHE)
  DFTACTGRP(*NO) ACTGRP(*CALLER)

/* OPM CL (clasico) */
CRTCLPGM PGM(MILIB/BKPNOCHE)
  SRCFILE(MILIB/QCLSRC)
  SRCMBR(BKPNOCHE)

MONMSG -- Manejo de errores

MONMSG es el equivalente a try/catch. Captura mensajes de error (excepciones) por su ID y ejecuta codigo alternativo. Es la herramienta clave para escribir CL robustos.

CL -- Patrones de MONMSG

PGM
  /* Monitorear error especifico e ignorar */
  DLTF FILE(MILIB/TEMPORAL)
  MONMSG MSGID(CPF2105) /* File not found - ok */

  /* Monitorear cualquier error y actuar */
  SAVLIB LIB(MILIB) DEV(*SAVF) SAVF(QGPL/BKP)
  MONMSG MSGID(CPF0000) EXEC(DO)
    SNDMSG MSG('BACKUP FALLO') TOUSR(QSYSOPR)
    GOTO CMDLBL(ERROR)
  ENDDO

  /* Monitor global (al inicio del PGM) */
  MONMSG MSGID(CPF0000 MCH0000) EXEC(GOTO CMDLBL(ERROR))
ENDPGM

SBMJOB -- Cadenas de trabajos

SBMJOB permite lanzar trabajos batch desde CL. Combinado con data areas como semaforos, permite crear cadenas de trabajos que se ejecutan en secuencia o en paralelo.

CL -- Cadena de trabajos con SBMJOB

PGM
  /* Paso 1: submit jobs en paralelo */
  SBMJOB CMD(CALL PGM(MILIB/ETAPA1A))
    JOB(ETAPA1A) JOBQ(QBATCH)
  SBMJOB CMD(CALL PGM(MILIB/ETAPA1B))
    JOB(ETAPA1B) JOBQ(QBATCH)

  /* Paso 2: esperar a que terminen */
  /* (usando data area como semaforo) */
  CHGDTAARA DTAARA(MILIB/ETAPA1) VALUE('RUNNING')

WAIT:
  DLYJOB DLY(30)  /* esperar 30 segundos */
  /* Verificar si terminaron (cada etapa actualiza
     su data area al finalizar) */
  DCL VAR(&A) TYPE(*CHAR) LEN(10)
  DCL VAR(&B) TYPE(*CHAR) LEN(10)
  RTVDTAARA DTAARA(MILIB/FLAG1A) RTNVAR(&A)
  RTVDTAARA DTAARA(MILIB/FLAG1B) RTNVAR(&B)
  IF COND(&A *NE 'DONE' *OR &B *NE 'DONE') +
    THEN(GOTO CMDLBL(WAIT))

  /* Paso 3: ejecutar etapa siguiente */
  CALL PGM(MILIB/ETAPA2)
ENDPGM

Data areas como semaforos

CL -- Data areas para control de procesos

/* Crear data area flag */
CRTDTAARA DTAARA(MILIB/BKPFLAG) TYPE(*CHAR) LEN(1)
  VALUE('N') TEXT('Flag de backup en progreso')

/* En el programa de backup */
RTVDTAARA DTAARA(MILIB/BKPFLAG) RTNVAR(&FLAG)
IF COND(&FLAG *EQ 'S') THEN(DO)
  SNDMSG MSG('Backup ya en ejecucion') TOUSR(QSYSOPR)
  RETURN
ENDDO
CHGDTAARA DTAARA(MILIB/BKPFLAG) VALUE('S')

/* ... realizar backup ... */

CHGDTAARA DTAARA(MILIB/BKPFLAG) VALUE('N')

/* Ver valor actual */
DSPDTAARA DTAARA(MILIB/BKPFLAG)

Analisis de QHST y logs

El history log (QHST) registra eventos significativos del sistema: IPLs, inicio y fin de subsistemas, cambios de system values, errores de hardware y software, y mas. Es el equivalente combinado de /var/log/syslog + journalctl en Linux. Desde V7R3 se puede consultar directamente con SQL via QSYS2.HISTORY_LOG_INFO.

CL -- Comandos del history log

DSPLOG LOG(QHST)                     Ver el history log completo
DSPLOG LOG(QHST) PERIOD(('08:00:00' '03/12/26') +
  ('17:00:00' '03/12/26'))
  Ver solo las entradas de un rango horario

/* Copiar a archivo para analisis */
CPYF FROMFILE(QSYS/QHST) TOFILE(MILIB/HISTCOPY) +
  MBROPT(*ADD)

/* Job log del trabajo actual */
DSPJOBLOG                             Ver job log en pantalla
DSPJOBLOG OUTPUT(*PRINT)              Enviar job log a spool

SQL -- Consultar QHST con SQL (QSYS2.HISTORY_LOG_INFO)

-- Eventos de las ultimas 24 horas
SELECT MESSAGE_TIMESTAMP, FROM_USER,
       MESSAGE_ID, MESSAGE_TYPE,
       MESSAGE_TEXT
FROM QSYS2.HISTORY_LOG_INFO
WHERE MESSAGE_TIMESTAMP > CURRENT_TIMESTAMP - 24 HOURS
ORDER BY MESSAGE_TIMESTAMP DESC
FETCH FIRST 50 ROWS ONLY;

-- Buscar errores especificos (CPF=error, CPI=informativo)
SELECT MESSAGE_TIMESTAMP, MESSAGE_ID,
       SEVERITY, MESSAGE_TEXT
FROM QSYS2.HISTORY_LOG_INFO
WHERE SEVERITY > 30
  AND MESSAGE_TIMESTAMP > CURRENT_TIMESTAMP - 7 DAYS
ORDER BY SEVERITY DESC, MESSAGE_TIMESTAMP DESC;

-- Ver IPLs recientes del sistema
SELECT MESSAGE_TIMESTAMP, MESSAGE_TEXT
FROM QSYS2.HISTORY_LOG_INFO
WHERE MESSAGE_ID = 'CPC1239'
ORDER BY MESSAGE_TIMESTAMP DESC;

-- Buscar cambios de system values (auditoria)
SELECT MESSAGE_TIMESTAMP, FROM_USER,
       MESSAGE_ID, MESSAGE_TEXT
FROM QSYS2.HISTORY_LOG_INFO
WHERE MESSAGE_ID IN ('CPD0912', 'CPC1224')
ORDER BY MESSAGE_TIMESTAMP DESC;

-- Actividad de un usuario especifico
SELECT MESSAGE_TIMESTAMP, MESSAGE_ID,
       MESSAGE_TYPE, MESSAGE_TEXT
FROM QSYS2.HISTORY_LOG_INFO
WHERE FROM_USER = 'FERNANDO'
  AND MESSAGE_TIMESTAMP > CURRENT_TIMESTAMP - 48 HOURS
ORDER BY MESSAGE_TIMESTAMP DESC;

QHST (History Log)

Registro del sistema. IPLs, errores de hardware, cambios de sysvals, inicios de subsistemas. Es global al LPAR.

Job Log

Registro de cada trabajo individual. Contiene todos los mensajes generados durante la ejecucion del job. Se ve con DSPJOBLOG.

QSYSOPR Message Queue

Cola del operador. Recibe mensajes de inquiry (requieren respuesta), alertas de cintas, errores que necesitan atencion humana.

Audit Journal (QAUDJRN)

Diario de auditoria de seguridad. Registra sign-on, acceso a objetos, cambios de autoridad. Se activa con CHGSYSVAL QAUDCTL.

Alertas y notificaciones

IBM i ofrece multiples mecanismos para enviar alertas: mensajes al operador (SNDPGMMSG), emails via SMTP (SNDSMTPEMM), y la funcion SQL QSYS2.SEND_MAIL. Combinados con CL y el job scheduler, permiten construir un sistema de alertas completo.

CL -- Enviar mensajes y notificaciones

/* Mensaje al operador (aparece en DSPMSG QSYSOPR) */
SNDMSG MSG('Backup completado OK') TOUSR(QSYSOPR)

/* Mensaje a un usuario especifico */
SNDMSG MSG('Tu reporte esta listo') TOUSR(FERNANDO)

/* Mensaje programatico a una message queue */
SNDPGMMSG MSGID(CPF9898) MSGF(QCPFMSG)
  MSGDTA('Proceso de cierre finalizado')
  MSGTYPE(*INFO) TOMSGQ(MILIB/ALERTAS)

/* Mensaje de inquiry (requiere respuesta) */
SNDPGMMSG MSGID(CPA9801) MSGF(QCPFMSG)
  MSGDTA('Continuar con el proceso?')
  MSGTYPE(*INQ) TOMSGQ(QSYSOPR)

/* Enviar email via SMTP (requiere SMTP configurado) */
SNDSMTPEMM RCP(('admin@empresa.com'))
  SUBJECT('Alerta IBM i')
  NOTE('El disco ASP1 supero el 85%')

/* Enviar email via SNDDST */
SNDDST TYPE(*LMSG) TOINTNET(('admin@empresa.com'))
  DSTD('Alerta IBM i') LONGMSG('Disco al 85%')

SQL -- Enviar email desde SQL (QSYS2.SEND_MAIL)

-- Enviar email directamente desde SQL
CALL QSYS2.SEND_MAIL(
  MAIL_FROM: 'ibmi@empresa.com',
  MAIL_TO:   'admin@empresa.com',
  SUBJECT:   'Alerta: Disco IBM i al 90%',
  MAIL_TEXT: 'El ASP1 del sistema IBMI01 alcanzo el 90%
de uso. Se requiere accion inmediata para liberar espacio
o agregar discos.'
);

-- Enviar con copia y formato HTML
CALL QSYS2.SEND_MAIL(
  MAIL_FROM:    'ibmi@empresa.com',
  MAIL_TO:      'admin@empresa.com',
  CC:           'jefe@empresa.com',
  SUBJECT:      'Reporte diario IBM i',
  CONTENT_TYPE: 'text/html',
  MAIL_TEXT:    '<h2>Reporte del sistema</h2>
<p>Estado: <b>Normal</b></p>
<p>Disco: 72%</p>'
);

Reply lists -- Respuestas automaticas

Las reply lists permiten que el sistema responda automaticamente a mensajes de inquiry sin intervencion humana. Son fundamentales para que los batch nocturnos no se queden bloqueados esperando respuesta del operador.

CL -- Reply list para respuestas automaticas

/* Agregar entrada a la reply list del sistema */
ADDRPYLE SEQNBR(10) MSGID(CPA4070) RPY('G')
  Responder G al mensaje "Object already exists"
  (durante RSTLIB)

ADDRPYLE SEQNBR(20) MSGID(CPA3708) RPY('I')
  Responder I (Ignore) a errores de dispositivo

ADDRPYLE SEQNBR(30) MSGID(CPA32B2) RPY('G')
  Responder G a "SAVACT might not complete"

/* Activar reply list para un job */
CHGJOB JOB(*) INQMSGRPY(*SYSRPYL)

/* Usar en JOBD para jobs batch */
CHGJOBD JOBD(MILIB/BATCHJOBD) INQMSGRPY(*SYSRPYL)

/* Ver la reply list actual */
WRKRPYLE

Buena practica: Todos los jobs batch que corren de noche deben usar INQMSGRPY(*SYSRPYL) en su JOBD. Un mensaje de inquiry no respondido puede dejar un trabajo batch bloqueado toda la noche hasta que el operador lo atienda al dia siguiente.

Watchers y message monitors

Los watchers son procesos del sistema que monitorean events en tiempo real y ejecutan programas cuando se cumplen condiciones especificas. IBM i soporta message watchers (monitorean message queues), log watchers (monitorean el PAL/product activity log) y object watchers.

Message Watcher

Monitorea una message queue en tiempo real. Cuando llega un mensaje que coincide con el filtro, ejecuta un programa CL.

Log Watcher

Monitorea el Product Activity Log (PAL) por errores de hardware, predicciones de falla de disco y eventos de I/O.

Object Watcher

Monitorea cambios en objetos (archivos, data areas). Ejecuta un programa cuando detecta una modificacion.

CL -- Configurar watchers

/* Crear y arrancar un message watcher en QSYSOPR */
ADDWCH WCHPGM(MILIB/WCHHANDLER)
  WCHMSG((CPF0907) (CPI0955) (CPC1239))
  WCHMSGQ(QSYS/QSYSOPR)
  WCH(MIWATCHER)
  Monitorea QSYSOPR por mensajes CPF0907
  (disco lleno), CPI0955, CPC1239 (IPL)
  y ejecuta WCHHANDLER cuando llegan

/* Arrancar el watcher */
STRWCH WCHNAME(MIWATCHER)
  WCHTYPE(*MSGQ)
  WCHPGM(MILIB/WCHHANDLER)
  WCHMSGQ(QSYS/QSYSOPR)
  WCHMSG((CPF0907) (CPI0955))

/* Detener un watcher */
ENDWCH WCHNAME(MIWATCHER)

/* Ver watchers activos */
WRKWCH

Programa handler para watcher

CL -- Programa handler de un message watcher

PGM PARM(&MSGINFO)
  /* Este programa se invoca automaticamente cuando
     el watcher detecta un mensaje monitoreado */
  DCL VAR(&MSGINFO) TYPE(*CHAR) LEN(1000)
  DCL VAR(&MSGID)   TYPE(*CHAR) LEN(7)
  DCL VAR(&MSGTXT)  TYPE(*CHAR) LEN(200)

  /* Extraer datos del mensaje */
  CHGVAR VAR(&MSGID) VALUE(%SST(&MSGINFO 1 7))

  /* Tomar accion segun el mensaje */
  IF COND(&MSGID *EQ 'CPF0907') THEN(DO)
    /* Disco lleno - alerta critica */
    SNDSMTPEMM RCP(('admin@empresa.com'))
      SUBJECT('CRITICO: Disco lleno en IBM i')
      NOTE('El ASP del sistema esta lleno')
  ENDDO

  IF COND(&MSGID *EQ 'CPC1239') THEN(DO)
    /* IPL detectado - notificar */
    SNDSMTPEMM RCP(('admin@empresa.com'))
      SUBJECT('INFO: IPL realizado en IBM i')
      NOTE('El sistema fue reiniciado')
  ENDDO
ENDPGM

Nota: Los watchers son mas eficientes que el polling periodico porque reaccionan en tiempo real. En lugar de consultar cada N minutos si algo cambio, el sistema notifica al watcher inmediatamente cuando ocurre el evento.

Scripts QShell, PASE y Python

Ademas de CL, IBM i soporta scripting mediante QShell (shell POSIX nativo), PASE (AIX binary compatibility layer que corre bash) y Python (via el paquetepython3 de yum). Esto permite usar herramientas modernas para automatizacion sin perder acceso al sistema nativo.

QShell (nativo)

•Shell POSIX integrado en IBM i
•Acceso a IFS y CL via system()
•Sintaxis similar a ksh/sh
•Se invoca con STRQSH o QSH CMD()
•Ideal para scripts simples de IFS

PASE (bash + open source)

•Runtime AIX que corre bash real
•yum para instalar paquetes RPM
•Python 3, Node.js, git, curl, etc.
•Se invoca con CALL QP2TERM o ssh
•Ideal para integracion con ecosistema moderno

QShell -- Script basico de QShell

#!/QOpenSys/usr/bin/sh
# Script QShell para limpiar archivos IFS viejos

# Buscar y eliminar archivos .log con mas de 30 dias
find /home/miapp/logs -name "*.log" -mtime +30 -exec rm {} ;

# Llamar comando CL desde QShell
system "SAVLIB LIB(MILIB) DEV(*SAVF) SAVF(QGPL/BKP)"

# Verificar resultado
if [ $? -eq 0 ]; then
  system "SNDMSG MSG('Backup OK') TOUSR(QSYSOPR)"
else
  system "SNDMSG MSG('Backup FALLO') TOUSR(QSYSOPR)"
fi

CL -- Invocar QShell y PASE desde CL

/* Ejecutar script QShell desde CL */
QSH CMD('/home/admin/scripts/limpieza.sh')

/* Ejecutar bash script en PASE */
QSH CMD('/QOpenSys/usr/bin/bash /home/admin/scripts/deploy.sh')

/* Ejecutar Python desde CL */
QSH CMD('/QOpenSys/pkgs/bin/python3 /home/admin/scripts/reporte.py')

/* Ejecutar comando PASE directo */
CALL PGM(QP2SHELL) PARM('/QOpenSys/usr/bin/bash' '-c'
  'df -k /home && echo "Disco OK"')

Python -- Script de automatizacion con itoolkit

#!/QOpenSys/pkgs/bin/python3
"""
Script Python para IBM i usando itoolkit
Instalar: pip3 install itoolkit
"""
import itoolkit
from itoolkit.transport import DatabaseTransport

# Conectar al sistema
conn = DatabaseTransport()
tk = itoolkit.iToolKit()

# Ejecutar comando CL
tk.add(itoolkit.iCmd('dsplib', 'DSPLIB LIB(MILIB)'))

# Ejecutar SQL
tk.add(itoolkit.iSql('diskcheck',
  """SELECT SYSTEM_ASP_USED
     FROM QSYS2.SYSTEM_STATUS"""))

tk.call(conn)

# Procesar resultado
result = tk.dict_out()
asp_used = float(result['diskcheck']['row']['SYSTEM_ASP_USED'])

if asp_used > 85:
    # Enviar alerta
    import smtplib
    from email.message import EmailMessage
    msg = EmailMessage()
    msg['Subject'] = f'Alerta: Disco IBM i al {asp_used}%'
    msg['From'] = 'ibmi@empresa.com'
    msg['To'] = 'admin@empresa.com'
    msg.set_content(f'ASP1 al {asp_used}%')
    with smtplib.SMTP('smtp.empresa.com') as s:
        s.send_message(msg)

PASE -- Instalar paquetes open source

# Instalar paquetes en PASE con yum
yum install python3 python3-pip
yum install nodejs18
yum install git
yum install bash coreutils

# Instalar paquetes Python para IBM i
pip3 install itoolkit     # API para CL y SQL
pip3 install ibm_db       # Conector DB2
pip3 install pyodbc       # ODBC alternativo

# Verificar instalacion
python3 --version
node --version

Management Central y Navigator

IBM Navigator for i (accesible via browser en el puerto 2001/2002) y Management Central proporcionan una interfaz web para administrar uno o multiples sistemas IBM i. Incluyen monitors de sistema, gestion de tareas programadas, inventarios y la posibilidad de ejecutar acciones en multiples endpoints simultaneamente.

System Monitors

Monitores graficos de CPU, disco, memoria pool, trabajos activos y comunicaciones. Permiten configurar umbrales y acciones automaticas.

Task Scheduler

Interfaz grafica para WRKJOBSCDE. Permite crear, editar y eliminar tareas programadas con calendario visual.

Inventarios

Recolectar informacion de PTFs, software instalado, hardware y configuracion de multiples sistemas en un reporte consolidado.

Endpoint Management

Administrar multiples LPARs desde un sistema central. Distribuir PTFs, ejecutar comandos y comparar configuraciones.

CL -- Acceso a Navigator y Management Central

/* Verificar que el servidor HTTP Admin esta activo */
WRKACTJOB SBS(QHTTPSVR) JOB(ADMIN*)

/* Iniciar IBM Navigator for i (puerto 2001/2002) */
STRTCPSVR SERVER(*HTTP) HTTPSVR(ADMIN)

/* Ver la URL de acceso */
/* http://ibmi-hostname:2001/   (HTTP)  */
/* https://ibmi-hostname:2002/  (HTTPS) */

/* Management Central - agregar endpoint */
/* Se configura desde Navigator > Management Central */
/* > Endpoint Systems > New Endpoint */

/* Ejecutar comando en multiples sistemas */
/* Navigator > Management Central > Run Command */
/* Seleccionar sistemas destino */
/* Comando: WRKSYSSTS  (se ejecuta en todos) */

SQL -- IBM i Services para monitoreo

-- System status (CPU, disco, trabajos activos)
SELECT CURRENT_TEMPORARY_STORAGE,
       TOTAL_AUXILIARY_STORAGE,
       SYSTEM_ASP_USED,
       NUMBER_OF_JOBS,
       ELAPSED_CPU_USED
FROM QSYS2.SYSTEM_STATUS;

-- Pool de memoria
SELECT POOL_NAME, POOL_SIZE, RESERVED_SIZE,
       DEFINED_SIZE
FROM QSYS2.MEMORY_POOL_INFO;

-- Subsistemas activos
SELECT SUBSYSTEM_DESCRIPTION_LIBRARY,
       SUBSYSTEM_DESCRIPTION, STATUS,
       NUMBER_OF_JOBS
FROM QSYS2.ACTIVE_SUBSYSTEM_INFO;

-- Servidores TCP activos
SELECT SERVER_TYPE, SERVER_NAME,
       SERVER_JOB_NAME, WHEN_STARTED
FROM QSYS2.TCP_SERVER_INFO
WHERE SERVER_STATUS = 'ACTIVE';

Herramientas de terceros

Para entornos con requerimientos avanzados de automatizacion, existen soluciones de terceros que extienden las capacidades nativas de IBM i con interfaces graficas, calendarios complejos, dependencias entre jobs y reportes de ejecucion.

Robot/HELP (Fortra)

La solucion de automatizacion mas popular para IBM i. Incluye job scheduler avanzado con dependencias, calendarios de exclusion, balanceo de carga y consola web. Robot/CONSOLE extiende con monitoreo de mensajes y respuesta automatica.

Automate (Precisely)

Scheduler avanzado con workflows visuales, integracion multi-plataforma (IBM i + Windows + Linux), API REST para integracion con CI/CD y monitoreo centralizado.

Halcyon

Suite de monitoreo y automatizacion con dashboards web, alertas por email/SMS/Slack/Teams, analisis predictivo de jobs y reportes de compliance.

Ansible para IBM i

Red Hat Ansible incluye modulos especificos para IBM i que permiten automatizar configuracion, PTFs, usuarios y operaciones usando playbooks YAML estandar.

YAML -- Ejemplo de Ansible playbook para IBM i

# ansible-playbook ibmi-maintenance.yml
---
- name: Mantenimiento IBM i
  hosts: ibmi_prod
  gather_facts: no
  tasks:
    - name: Verificar espacio en disco
      ibmi_sql_execute:
        sql: "SELECT SYSTEM_ASP_USED FROM QSYS2.SYSTEM_STATUS"
      register: disk_result

    - name: Aplicar PTFs pendientes
      ibmi_fix:
        product_id: "*ALL"
        fix_list: ["SI12345", "SI67890"]
        operation: "apply"

    - name: Reiniciar servidor HTTP
      ibmi_cl_command:
        cmd: "ENDTCPSVR SERVER(*HTTP) INSTANCE(ADMIN)"
    - ibmi_cl_command:
        cmd: "STRTCPSVR SERVER(*HTTP) HTTPSVR(ADMIN)"

Patrones comunes de automatizacion

Los siguientes son patrones probados que todo administrador de IBM i deberia implementar. Son ejemplos completos listos para adaptar a cada entorno.

Limpieza nocturna

CL -- Programa de limpieza nocturna

PGM
  /* NIGHTCLEAN - Limpieza nocturna del sistema */
  MONMSG MSGID(CPF0000 MCH0000) EXEC(GOTO CMDLBL(ERROR))

  /* 1. Limpiar spool files viejos (mas de 7 dias) */
  DLTOLDSPLF DAYS(7)
  MONMSG MSGID(CPF0000)

  /* 2. Borrar archivos temporales en QTEMP de cada job */
  /* (se limpian automaticamente, pero verificar) */

  /* 3. Limpiar save files de backups anteriores */
  DLTF FILE(QGPL/BKP*) /* Borrar save files BKP* */
  MONMSG MSGID(CPF2105 CPF0000)

  /* 4. Limpiar logs del IFS */
  QSH CMD('find /home/miapp/logs -name "*.log" +
    -mtime +30 -delete')
  MONMSG MSGID(QSH0000)

  /* 5. Purgar history log viejo */
  /* (se hace automaticamente segun QHSTLOGSIZ) */

  /* 6. Reorganizar archivos fisicos fragmentados */
  RGZPFM FILE(MILIB/TRANSACCIONES)
  MONMSG MSGID(CPF0000)

  SNDMSG MSG('NIGHTCLEAN completado OK') TOUSR(QSYSOPR)
  GOTO CMDLBL(FIN)

ERROR:
  SNDMSG MSG('NIGHTCLEAN fallo - ver job log')
    TOUSR(QSYSOPR)
FIN:
ENDPGM

Monitoreo de disco con alerta

SQL -- Monitor de disco con envio de email

-- Monitoreo completo de disco con alertas
SELECT
  CASE
    WHEN SYSTEM_ASP_USED > 90 THEN 'CRITICO'
    WHEN SYSTEM_ASP_USED > 85 THEN 'ALERTA'
    WHEN SYSTEM_ASP_USED > 75 THEN 'ATENCION'
    ELSE 'NORMAL'
  END AS estado,
  SYSTEM_ASP_USED AS porcentaje_usado,
  TOTAL_AUXILIARY_STORAGE AS total_gb,
  INT(TOTAL_AUXILIARY_STORAGE * SYSTEM_ASP_USED / 100)
    AS usado_gb,
  INT(TOTAL_AUXILIARY_STORAGE *
    (100 - SYSTEM_ASP_USED) / 100) AS libre_gb
FROM QSYS2.SYSTEM_STATUS;

-- Top 10 bibliotecas mas grandes
SELECT OBJNAME AS biblioteca,
       INT(OBJSIZE / 1024 / 1024) AS tamano_mb
FROM TABLE(QSYS2.OBJECT_STATISTICS('QSYS', '*LIB'))
ORDER BY OBJSIZE DESC
FETCH FIRST 10 ROWS ONLY;

-- Archivos mas grandes dentro de una biblioteca
SELECT OBJNAME AS archivo, OBJTYPE,
       INT(OBJSIZE / 1024 / 1024) AS tamano_mb
FROM TABLE(QSYS2.OBJECT_STATISTICS('MILIB', '*ALL'))
WHERE OBJSIZE > 100000000  /* > 100 MB */
ORDER BY OBJSIZE DESC;

Gestion de sesiones activas

SQL -- Monitoreo de sesiones y trabajos problematicos

-- Trabajos en estado MSGW (esperando respuesta)
SELECT JOB_NAME, JOB_NAME_SHORT,
       AUTHORIZATION_NAME AS usuario,
       SUBSYSTEM, FUNCTION_TYPE, FUNCTION,
       JOB_STATUS
FROM QSYS2.ACTIVE_JOB_INFO
WHERE JOB_STATUS = 'MSGW';

-- Trabajos que consumen mas CPU
SELECT JOB_NAME, AUTHORIZATION_NAME,
       SUBSYSTEM, ELAPSED_CPU_PERCENTAGE,
       TEMPORARY_STORAGE AS temp_mb
FROM QSYS2.ACTIVE_JOB_INFO
WHERE JOB_TYPE = 'INTERACTIVE'
ORDER BY ELAPSED_CPU_PERCENTAGE DESC
FETCH FIRST 10 ROWS ONLY;

-- Sesiones interactivas inactivas (mas de 2 horas)
SELECT JOB_NAME, AUTHORIZATION_NAME,
       ELAPSED_INTERACTION_COUNT,
       TIMESTAMPDIFF(4,
         CAST(CURRENT_TIMESTAMP -
           JOB_ACTIVE_TIME AS CHAR(22)))
         AS minutos_activo
FROM QSYS2.ACTIVE_JOB_INFO
WHERE JOB_TYPE = 'INTERACTIVE'
  AND ELAPSED_INTERACTION_COUNT = 0
  AND TIMESTAMPDIFF(4,
    CAST(CURRENT_TIMESTAMP -
      JOB_ACTIVE_TIME AS CHAR(22))) > 120;

Programa de arranque del sistema (QSTRUPPGM)

CL -- Startup program ejecutado en cada IPL

PGM
  /* QSTRUPPGM - Se ejecuta en cada IPL */

  /* Arrancar subsistemas */
  STRSBS SBSD(QINTER)
  MONMSG MSGID(CPF0000)
  STRSBS SBSD(QBATCH)
  MONMSG MSGID(CPF0000)
  STRSBS SBSD(QCMN)
  MONMSG MSGID(CPF0000)
  STRSBS SBSD(QSERVER)
  MONMSG MSGID(CPF0000)
  STRSBS SBSD(QUSRWRK)
  MONMSG MSGID(CPF0000)
  STRSBS SBSD(MILIB/MIAPPSBS)
  MONMSG MSGID(CPF0000)

  /* Iniciar TCP/IP */
  STRTCP
  MONMSG MSGID(CPF0000)

  /* Iniciar servidores */
  STRTCPSVR SERVER(*HTTP *SSHD *FTP)
  MONMSG MSGID(CPF0000)

  /* Iniciar servidor HTTP Admin (Navigator) */
  STRTCPSVR SERVER(*HTTP) HTTPSVR(ADMIN)
  MONMSG MSGID(CPF0000)

  /* Notificar */
  SNDMSG MSG('Sistema IBMI01 - IPL completado, +
    todos los subsistemas activos') TOUSR(QSYSOPR)

  /* Enviar email de notificacion */
  SNDSMTPEMM RCP(('admin@empresa.com'))
    SUBJECT('IBM i - IPL completado')
    NOTE('El sistema fue reiniciado exitosamente')
  MONMSG MSGID(CPF0000)

ENDPGM

Resumen de comandos

Tabla rapida de referencia con los comandos de automatizacion mas usados en IBM i y sus equivalentes en Linux.

Tarea	IBM i	Linux equivalente
Programar tarea	`ADDJOBSCDE`	`crontab -e`
Ver tareas programadas	`WRKJOBSCDE`	`crontab -l`
Pausar tarea	`CHGJOBSCDE STATUS(*HLD)`	`comentar linea en cron`
Compilar programa CL	`CRTBNDCL PGM()`	`chmod +x script.sh`
Submit job batch	`SBMJOB CMD(CALL PGM())`	`nohup ./script.sh &`
Delay / sleep	`DLYJOB DLY(60)`	`sleep 60`
Monitorear error	`MONMSG MSGID(CPF0000)`	`trap / set -e`
Enviar mensaje	`SNDMSG TOUSR(QSYSOPR)`	`echo msg \| mail -s`
Enviar email	`SNDSMTPEMM RCP(())`	`sendmail / mailx`
Ver history log	`DSPLOG LOG(QHST)`	`journalctl / dmesg`
Consultar log SQL	`QSYS2.HISTORY_LOG_INFO`	`journalctl --output json`
Respuesta automatica	`ADDRPYLE / WRKRPYLE`	`expect / yes \|`
Data area (flag)	`CRTDTAARA / CHGDTAARA`	`touch /tmp/flag`
Watcher	`STRWCH WCHTYPE(*MSGQ)`	`inotifywait / systemd path`
QShell script	`QSH CMD('/path/script.sh')`	`bash script.sh`
Python script	`QSH CMD('python3 script.py')`	`python3 script.py`
Startup program	`QSTRUPPGM system value`	`/etc/rc.local o systemd`
Autostart job	`ADDAJE SBSD()`	`systemd WantedBy=`
Exit program	`ADDEXITPGM EXITPNT()`	`PAM / NSS modules`
Trigger de base de datos	`ADDPFTRG / CREATE TRIGGER`	`CREATE TRIGGER (SQL)`

Siguiente paso: Practica creando un programa CL que combine ADDJOBSCDE para programar la ejecucion, MONMSG para manejo de errores y SNDSMTPEMM para enviar una notificacion de resultado. Esos tres elementos son la base de toda automatizacion en IBM i.

Administration Runtime Expert (7.6)

IBM Administration Runtime Expert for i (ARE, 5733-ARE) es un LPP sin costo incluido con IBM i que permite verificar la configuracion consistente de sistemas y aplicaciones. Se esta migrando a Navigator for i con interfaz grafica.

Como funciona

Recolectar: se recopila informacion del sistema, valores del sistema, atributos y configuraciones
Compilar template: se genera un template que representa el estado "correcto" del sistema
Verificar: se ejecuta el template contra el mismo sistema u otro, generando reportes de diferencias
Corregir: con plugins custom, se pueden aplicar correcciones automaticas

Ventajas

Corre en un solo sistema y puede verificar otros remotamente
Templates reutilizables entre sistemas sin instalar componentes adicionales
Soporte de scheduler y notificaciones por email
Plugins personalizados para checks especificos y remediacion automatica
No requiere skills adicionales para un admin de IBM i

Futuro: IBM planea integrar todas las funciones de 5733-ARE directamente en Navigator for i, eliminando la necesidad de instalar ARE como producto separado.

Advanced Job Scheduler (7.6)

IBM Advanced Job Scheduler for i (5770-JS1) es un LPP incluido sin costo con IBM i 7.6 que ofrece capacidades significativamente superiores al job scheduler nativo (ADDJOBSCDE).

Ventajas sobre ADDJOBSCDE

ADDJOBSCDE (nativo)

•Programacion basica por fecha/hora/dia
•Sin dependencias entre jobs
•Sin notificaciones integradas
•Sin calendario de feriados
•Sin interfaz grafica
•Sin historial de ejecucion detallado

Advanced Job Scheduler (5770-JS1)

•Calendarios con feriados y excepciones
•Dependencias entre jobs (predecesor/sucesor)
•Notificaciones por email y message queue
•Grupos de jobs con secuencia definida
•Interfaz web via Navigator for i
•Historial completo de ejecucion y logs

Empezar con AJS

Viene preinstalado con IBM i 7.6 — no requiere licencia separada
Se gestiona desde Navigator for i o desde la linea de comandos
Ideal para reemplazar schedulers manuales o de terceros costosos
Soporta envio de notificaciones ante fallos de jobs

Consejo: Si tu organizacion usa ADDJOBSCDE para tareas con dependencias complejas o necesita calendarios de feriados, AJS resuelve todo esto sin costo adicional en IBM i 7.6.

Alta Disponibilidad Volver al path