NuevoProyecto ETAPEProyecto Emuframe Tape Server (ETAPE)
Python

Crear usuario para scripts Python en batch (RACF)

En la entrada pySDSF en z/OS 3.2: vigilar el spool y avisar por Microsoft Teams el script funcionaba desde OMVS, pero no en batch. Mi usuario, IBMUSER, tiene UID 0, el mismo que BPXROOT. En batch, el job acaba con la identidad de BPXROOT: no encuentra mi .profile y JES2 rechaza el $D SPOOL con $HASP690 COMMAND REJECTED - AUTHORIZATION FAILURE.

IBM recomienda no compartir el UID 0, así que la solución limpia es un usuario solo para estos scripts, PYBATCH, con su propio UID y solo los permisos que necesita. Además, con la clase SURROGAT, otros usuarios pueden lanzar jobs como PYBATCH sin conocer ninguna contraseña.

En esta entrada no doy todos los permisos de golpe. Voy lanzando el job, miro qué rechaza RACF en el log del sistema (mensajes ICH408I) y doy solo ese permiso. Así se ve cómo descubrir qué necesita un usuario nuevo, que es lo que sirve para cualquier caso parecido.

Para SDSF y los comandos de consola no voy a crear perfiles nuevos, para no afectar al resto del sistema: uso los perfiles genéricos que ya existen y solo añado a PYBATCH en ellos. Los únicos perfiles nuevos son los del propio PYBATCH: el de SURROGAT y el de sus data sets.

Qué necesita el usuario

  • Un grupo propio, PYGRP, con su GID.
  • El usuario PYBATCH, sin contraseña (solo sirve para batch: nadie puede entrar con él en TSO), con su UID, su HOME (/u/pybatch) y /bin/sh como shell.
  • Su propio ALIAS, que apunte al catálogo de usuario del sistema (CATALOG.VS01.TSO), y un perfil RACF que proteja sus data sets.
  • En su HOME, su .profile, su .teams_webhook y los scripts.
  • Permiso para que IBMUSER lance jobs como PYBATCH (clase SURROGAT).
  • Permiso para usar SDSF y lanzar desde él el comando $D SPOOL (clases SDSF y OPERCMDS).

Cómo está la seguridad en la stock image

Antes de crear nada, miro qué clases de RACF están activas y qué perfiles hay, con un job de consulta (no cambia nada):

//RACFLST  JOB (ACCT),'RACF CHECK',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//* List the RACF options and profiles needed to plan the PYBATCH user
//* (read-only: nothing is changed)
//RACF     EXEC PGM=IKJEFT01
//SYSTSPRT DD SYSOUT=*
//SYSTSIN  DD *
 SETROPTS LIST
 RLIST OPERCMDS JES2.DISPLAY.SPOOL
 RLIST SURROGAT *.SUBMIT
 RLIST FACILITY BPX.NEXT.USER ALL
 RLIST UNIXPRIV SHARED.IDS
 RLIST OPERCMDS JES2.* AUTHUSER
/*

Crear usuario para scripts Python en batch (RACF) – captura 1

En mi sistema:

  • OPERCMDS, SURROGAT, SDSF y JESSPOOL están activas y con RACLIST. Por eso, después de cada cambio hay que refrescarlas con SETROPTS RACLIST(...) REFRESH.

Crear usuario para scripts Python en batch (RACF) – captura 2

  • El $D SPOOL lo protege el perfil genérico JES2.*, con UACC NONE. Solo IBMUSER y SYSTEM tienen acceso, con CONTROL.

Crear usuario para scripts Python en batch (RACF) – captura 3

Crear usuario para scripts Python en batch (RACF) – captura 4

Crear usuario para scripts Python en batch (RACF) – captura 5

  • No hay ningún perfil *.SUBMIT en SURROGAT.

Crear usuario para scripts Python en batch (RACF) – captura 6

  • BPX.NEXT.USER existe con los datos 6000/NOAUTO: RACF asigna solo los UID a partir del 6000 (AUTOUID), pero no los GID, así que el del grupo hay que ponerlo a mano.

Crear usuario para scripts Python en batch (RACF) – captura 7

  • SHARED.IDS existe: RACF no deja repetir un UID ni un GID. Si elijo uno que ya está en uso, el comando falla sin romper nada.

Crear usuario para scripts Python en batch (RACF) – captura 8

Crear el usuario con un job

Hago los cambios con un job, que se puede repetir y queda documentado:

//RACFPYB  JOB (ACCT),'RACF PYBATCH',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//* Create the PYBATCH user for Python batch scripts:
//* group with its own GID, user with its own UID and no password,
//* surrogate submit and JES2 display command authority
//RACF     EXEC PGM=IKJEFT01
//SYSTSPRT DD SYSOUT=*
//SYSTSIN  DD *
 ADDGROUP PYGRP SUPGROUP(SYS1) OWNER(SYS1) OMVS(GID(6000))
 ADDUSER PYBATCH DFLTGRP(PYGRP) OWNER(SYS1) NOPASSWORD -
   NAME('PYTHON BATCH') -
   OMVS(AUTOUID HOME('/u/pybatch') PROGRAM('/bin/sh'))
 RDEFINE SURROGAT PYBATCH.SUBMIT UACC(NONE) OWNER(SYS1)
 PERMIT PYBATCH.SUBMIT CLASS(SURROGAT) ID(IBMUSER) ACCESS(READ)
 PERMIT JES2.* CLASS(OPERCMDS) ID(PYBATCH) ACCESS(READ)
 SETROPTS RACLIST(SURROGAT OPERCMDS) REFRESH
 LISTUSER PYBATCH OMVS NORACF
 RLIST OPERCMDS JES2.* AUTHUSER
/*

Paso a paso:

  • ADDGROUP crea el grupo PYGRP con el GID 6000.
  • ADDUSER ... NOPASSWORD crea un usuario protegido: no tiene contraseña, así que no se puede entrar con él en TSO. AUTOUID le da el siguiente UID libre desde el 6000.
  • PYBATCH.SUBMIT en SURROGAT, con READ para IBMUSER: IBMUSER puede lanzar jobs con USER=PYBATCH sin poner contraseña.
  • PERMIT JES2.* con READ: PYBATCH puede lanzar los comandos de JES2 que solo muestran información, como $D SPOOL. Los que cambian algo piden UPDATE o CONTROL, así que no puede lanzarlos.
  • SETROPTS ... REFRESH aplica los cambios en las dos clases, que están en RACLIST.
  • LISTUSER y RLIST muestran el resultado.

Crear usuario para scripts Python en batch (RACF) – captura 9

Crear usuario para scripts Python en batch (RACF) – captura 10

Crear usuario para scripts Python en batch (RACF) – captura 11

El alias y los data sets de PYBATCH

Cuando creamos un usuario, lo adecuado es darle también su ALIAS, que apunte al catálogo de usuario que corresponda en el sistema, y un perfil RACF que proteja sus data sets. Así, todo lo que se cree con su nombre como primer nivel se cataloga en ese catálogo y no en el maestro. Uso el mismo catálogo de usuario que IBMUSER.

Para saber qué catálogo usa IBMUSER:

//LISTALS  JOB (ACCT),'LIST ALIAS',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//* Show which user catalog the IBMUSER alias points to
//LIST     EXEC PGM=IDCAMS
//SYSPRINT DD SYSOUT=*
//SYSIN    DD *
 LISTCAT ENTRIES(IBMUSER) ALL
/*

En ASSOCIATIONS aparece USERCAT--CATALOG.VS01.TSO.

Crear usuario para scripts Python en batch (RACF) – captura 12

Crear usuario para scripts Python en batch (RACF) – captura 13

Creo el alias de PYBATCH, que apunta a ese catálogo, y el perfil de sus data sets:

//PYBALIAS JOB (ACCT),'PYBATCH ALIAS',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//* Define the PYBATCH alias in the TSO user catalog and protect
//* the PYBATCH data sets
//ALIAS    EXEC PGM=IDCAMS
//SYSPRINT DD SYSOUT=*
//SYSIN    DD *
 DEFINE ALIAS (NAME(PYBATCH) RELATE(CATALOG.VS01.TSO)) -
   CATALOG(CATALOG.VS01.MASTER)
 LISTCAT ENTRIES(PYBATCH) ALL
/*
//RACF     EXEC PGM=IKJEFT01
//SYSTSPRT DD SYSOUT=*
//SYSTSIN  DD *
 ADDSD 'PYBATCH.**' OWNER(PYBATCH) UACC(NONE)
 PERMIT 'PYBATCH.**' ID(PYBATCH) ACCESS(ALTER)
 LISTDSD DATASET('PYBATCH.**') ALL
/*
  • DEFINE ALIAS crea el alias en el catálogo maestro y lo relaciona con CATALOG.VS01.TSO: los data sets de PYBATCH se catalogan ahí.
  • ADDSD 'PYBATCH.**' protege sus data sets con UACC NONE y el PERMIT le da ALTER a PYBATCH. Solo pueden acceder los que estén en la lista de acceso del perfil, que muestra el LISTDSD.

Crear usuario para scripts Python en batch (RACF) – captura 14

Crear usuario para scripts Python en batch (RACF) – captura 15

Crear usuario para scripts Python en batch (RACF) – captura 16

El HOME de PYBATCH

Con un job lanzado por IBMUSER creo su HOME con una carpeta para los scripts, copio el .profile, el fichero del webhook y los scripts, y se los doy a PYBATCH:

//PYBHOME  JOB (ACCT),'PYBATCH HOME',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//* Create the PYBATCH home directory with its profile, webhook file
//* and Python scripts, owned by PYBATCH
//SHELL    EXEC PGM=IKJEFT01
//SYSEXEC  DD DSN=SYS1.SBPXEXEC,DISP=SHR
//SYSTSPRT DD SYSOUT=*
//SYSTSIN  DD *
 OSHELL mkdir -p /u/pybatch/scripts
 OSHELL cp /u/ibmuser/.profile /u/pybatch/.profile
 OSHELL cp /u/ibmuser/.teams_webhook /u/pybatch/.teams_webhook
 OSHELL cp /u/ibmuser/scripts/*.py /u/pybatch/scripts/
 OSHELL chtag -tc ISO8859-1 /u/pybatch/scripts/*.py
 OSHELL chown -R PYBATCH:PYGRP /u/pybatch
 OSHELL chmod 750 /u/pybatch /u/pybatch/scripts
 OSHELL chmod 600 /u/pybatch/.teams_webhook
 OSHELL chmod 640 /u/pybatch/.profile /u/pybatch/scripts/*.py
 OSHELL ls -laT /u/pybatch /u/pybatch/scripts
/*

En esta ocasión lo hago con un job (en vez de hacerlo por TSO OMVS), para enseñar distintas formas de hacer lo mismo. Así se puede usar la más adecuada según convenga.

Cada línea OSHELL ejecuta un comando de la shell de z/OS UNIX desde TSO en batch, y su salida sale en SYSTSPRT. OSHELL es un REXX de SYS1.SBPXEXEC; por eso va esa librería en la DD SYSEXEC. Los nombres de ficheros van en minúsculas, así que el JCL se edita con CAPS OFF.

El .profile es el mismo que el mío: pone la Python 3.13 en el PATH, el LIBPATH, la zona horaria y carga $HOME/.teams_webhook. Como ahora $HOME es /u/pybatch, carga el fichero de PYBATCH. La URL del webhook sigue sin estar en ningún JCL.

Crear usuario para scripts Python en batch (RACF) – captura 17

Terminará correctamente.

Crear usuario para scripts Python en batch (RACF) – captura 18

Al final de la salida comprobamos que se han creado los ficheros y tienen los permisos/atributos adecuados.

Crear usuario para scripts Python en batch (RACF) – captura 19

Crear usuario para scripts Python en batch (RACF) – captura 20

Primera prueba: who() como PYBATCH

Lanzo who.py con USER=PYBATCH en la tarjeta JOB. No hace falta contraseña: RACF comprueba que IBMUSER tiene READ en PYBATCH.SUBMIT.

En este caso el NOTIFY=&SYSUID no notifica a nuestro usuario, notifica al usuario PYBATCH.

//PYWHO    JOB (ACCT),'PYBATCH WHO',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID,
//             USER=PYBATCH
//* Run who.py as PYBATCH to check its SDSF identity
//RUN      EXEC PGM=BPXBATCH
//STDOUT   DD SYSOUT=*
//STDERR   DD SYSOUT=*
//STDPARM  DD *
SH python3 /u/pybatch/scripts/who.py
/*

Crear usuario para scripts Python en batch (RACF) – captura 21

Conectarse a SDSF

Aunque el job termina con RC=00, el script no ha hecho nada.

Otro detalle interesante es que, como acabamos de crear el usuario y este es el primer job que ejecutamos, el campo LAST ACCESS del mensaje ICH70001I sale vacío.

Crear usuario para scripts Python en batch (RACF) – captura 22

Al final de la salida aparece:

ISF4000E No host response received.

Crear usuario para scripts Python en batch (RACF) – captura 23

Y en el log del sistema está el motivo: RACF no deja a PYBATCH conectarse a SDSF.

+ISF024I USER PYBATCH  NOT AUTHORIZED TO SDSF, CONNECT NOT AUTHORIZED
ICH408I USER(PYBATCH ) GROUP(PYGRP   ) NAME(PYTHON BATCH        ) 842
  ISF.CONNECT.VS01 CL(SDSF    )
  INSUFFICIENT ACCESS AUTHORITY
  FROM ISF.CONNECT.* (G)
  ACCESS INTENT(READ   )  ACCESS ALLOWED(NONE   )

Crear usuario para scripts Python en batch (RACF) – captura 24

Esto pasa porque who.py captura el error de SDSF y lo imprime, así que Python termina bien aunque la petición haya fallado. El problema está en el log.

Para usar SDSF, un usuario necesita READ en el perfil ISF.CONNECT.sistema de la clase SDSF. En la stock image lo protege el genérico ISF.CONNECT.*, y PYBATCH no tiene acceso. Se lo doy con otro job:

//RACFSDS  JOB (ACCT),'RACF SDSF',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//* Allow PYBATCH to connect to SDSF
//RACF     EXEC PGM=IKJEFT01
//SYSTSPRT DD SYSOUT=*
//SYSTSIN  DD *
 PERMIT ISF.CONNECT.* CLASS(SDSF) ID(PYBATCH) ACCESS(READ)
 SETROPTS RACLIST(SDSF) REFRESH
 RLIST SDSF ISF.CONNECT.* AUTHUSER
/*

Crear usuario para scripts Python en batch (RACF) – captura 25

Crear usuario para scripts Python en batch (RACF) – captura 26

Después vuelvo a lanzar PYWHO. Ahora sí muestra lo esperado.

Crear usuario para scripts Python en batch (RACF) – captura 27

Crear usuario para scripts Python en batch (RACF) – captura 28

El job de vigilancia como PYBATCH

Con su propio UID, la shell de BPXBATCH ya encuentra el HOME de PYBATCH y lee su .profile, así que el job queda sencillo:

//SPOOLCHK JOB (ACCT),'SPOOL CHECK',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID,
//             USER=PYBATCH
//* Check JES2 spool usage with pySDSF and alert Microsoft Teams
//RUN      EXEC PGM=BPXBATCH
//STDOUT   DD SYSOUT=*
//STDERR   DD SYSOUT=*
//STDPARM  DD *
SH python3 /u/pybatch/scripts/spool_alert.py
/*

Crear usuario para scripts Python en batch (RACF) – captura 29

La memoria del job y el alias

La primera vez, el job SPOOLCHK falló con SDSF error: ISF4000E No host response received. En el log del sistema hay dos problemas encadenados. Lo primero que llama la atención es un error de catálogo: SDSF intenta crear el data set PYBATCH.ISF.D261116.T205413.SPOOLCHK.S001 y, como PYBATCH todavía no tenía alias, tocaba catalogarlo en el catálogo maestro:

ICH408I USER(PYBATCH ) GROUP(PYGRP   ) NAME(PYTHON BATCH        ) 945
  CATALOG.VS01.MASTER CL(DATASET ) VOL(OPEVS1)
  INSUFFICIENT ACCESS AUTHORITY
  FROM CATALOG.*.** (G)
  ACCESS INTENT(UPDATE )  ACCESS ALLOWED(READ   )
IKJ56893I DATA SET PYBATCH.ISF.D261116.T205413.SPOOLCHK.S001 NOT
ALLOCATED+
IGD17102I CATALOG ERROR IN DEFINING NONVSAM DATA SET 947
PYBATCH.ISF.D261116.T205413.SPOOLCHK.S001
RETURN CODE IS 56 REASON CODE IS 6 IGG0CLFT

Crear usuario para scripts Python en batch (RACF) – captura 30

Pero ese data set es un volcado: junto a esos mensajes aparecen IEA820I TRANSACTION DUMP REQUESTED BUT NOT TAKEN, ISF035I SDSF SDUMP FAILED y un abend S0C4 en ISFPYTN. Es decir, SDSF ya había fallado e intentaba guardar un volcado del error, y no pudo porque PYBATCH no tenía dónde catalogarlo.

Fue un despiste durante las pruebas: al crear el usuario no le creamos su ALIAS, y lo descubrimos gracias a este error. Por eso, en esta entrada, el alias va justo después de crear el usuario, en el apartado El alias y los data sets de PYBATCH. La solución no es dar UPDATE en el catálogo maestro.

La causa de fondo, la que hizo fallar a SDSF, está al principio del job: se queda sin memoria al cargar el módulo ISFVTBL.

IEF403I SPOOLCHK - STARTED - TIME=21.54.11
IEW4000I FETCH FOR MODULE ISFVTBL  FROM DDNAME *VLF*    FAILED BECAUSE
INSUFFICIENT STORAGE WAS AVAILABLE.
CSV031I LIBRARY ACCESS FAILED FOR MODULE ISFVTBL , RETURN CODE 24,
REASON CODE 26080021, DDNAME *LNKLST*

Crear usuario para scripts Python en batch (RACF) – captura 31

Python y SDSF juntos necesitan memoria, y la REGION por defecto del job no llega. En lugar de quitar el límite con REGION=0M, le pongo uno concreto en la tarjeta JOB, REGION=256M. Es más prudente: el job tiene la memoria que necesita, pero no toda la del sistema.

//SPOOLCHK JOB (ACCT),'SPOOL CHECK',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID,
//             USER=PYBATCH,REGION=256M

Lanzar comandos desde SDSF

Con la REGION resuelta, SDSF ya se ejecuta, pero RACF rechaza el comando de consola:

ICH408I USER(PYBATCH ) GROUP(PYGRP   ) NAME(PYTHON BATCH        )
  ISFOPER.SYSTEM CL(SDSF    )
  INSUFFICIENT ACCESS AUTHORITY
  FROM ISF* (G)
  ACCESS INTENT(READ   )  ACCESS ALLOWED(NONE   )

Crear usuario para scripts Python en batch (RACF) – captura 32

Crear usuario para scripts Python en batch (RACF) – captura 33

ISFOPER.SYSTEM, en la clase SDSF, es el permiso para lanzar comandos del sistema desde SDSF, que es lo que hace el script con $D SPOOL. En la stock image no tiene perfil propio: lo cubre el genérico ISF*. Le doy READ a PYBATCH en ese genérico:

//RACFOPR  JOB (ACCT),'RACF ISF',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//* Give PYBATCH read access to the SDSF generic profile ISF*
//RACF     EXEC PGM=IKJEFT01
//SYSTSPRT DD SYSOUT=*
//SYSTSIN  DD *
 PERMIT ISF* CLASS(SDSF) ID(PYBATCH) ACCESS(READ)
 SETROPTS RACLIST(SDSF) REFRESH
 RLIST SDSF ISF* AUTHUSER
/*

ISF* cubre todos los recursos de SDSF que no tienen un perfil más específico. Además de ISFOPER.SYSTEM, cubre ISFCMD.FILTER.OWNER e ISFCMD.FILTER.PREFIX, los filtros OWNER * y PREFIX * que usa el script para listar los jobs de todos los usuarios. Con un solo permiso, PYBATCH tiene lo que necesita de SDSF. A cambio, tiene READ en todo lo demás que cubre ISF*.

Crear usuario para scripts Python en batch (RACF) – captura 34

Crear usuario para scripts Python en batch (RACF) – captura 35

Activar la consola extendida

Con ISFOPER.SYSTEM ya permitido, el comando sigue sin salir. SDSF no puede activar la consola extendida que usa para lanzarlo, que se llama como el usuario:

ISF032I CONSOLE PYBATCH ACTIVATE FAILED, RETURN CODE 000C, REASON CODE 0000

Y en el log del sistema, justo antes, está el permiso que falta:

ICH408I USER(PYBATCH ) GROUP(PYGRP   ) NAME(PYTHON BATCH        ) 264
  MVS.MCSOPER.PYBATCH CL(OPERCMDS)
  INSUFFICIENT ACCESS AUTHORITY
  FROM MVS.MCSOPER.* (G)
  ACCESS INTENT(READ   )  ACCESS ALLOWED(NONE   )

Crear usuario para scripts Python en batch (RACF) – captura 36

Crear usuario para scripts Python en batch (RACF) – captura 37

Para activar una consola extendida, el usuario necesita READ en MVS.MCSOPER.nombre de la consola, en la clase OPERCMDS. En la stock image lo protege el genérico MVS.MCSOPER.*. Igual que con SDSF, le doy READ a PYBATCH en el genérico:

//RACFMCS  JOB (ACCT),'RACF MCSOPER',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//* Allow PYBATCH to activate its SDSF extended console
//RACF     EXEC PGM=IKJEFT01
//SYSTSPRT DD SYSOUT=*
//SYSTSIN  DD *
 PERMIT MVS.MCSOPER.* CLASS(OPERCMDS) ID(PYBATCH) ACCESS(READ)
 SETROPTS RACLIST(OPERCMDS) REFRESH
 RLIST OPERCMDS MVS.MCSOPER.* AUTHUSER
/*

Crear usuario para scripts Python en batch (RACF) – captura 38

Crear usuario para scripts Python en batch (RACF) – captura 39

Con este permiso, el job SPOOLCHK ya funciona.

Crear usuario para scripts Python en batch (RACF) – captura 40

Muestra el uso del spool, pero no envía la alerta: está por debajo del umbral, que es del 70 % por defecto.

Crear usuario para scripts Python en batch (RACF) – captura 41

Crear usuario para scripts Python en batch (RACF) – captura 42

Para probar la tarjeta, bajo el umbral con la variable SPOOL_THRESHOLD:

//STDPARM  DD *
SH SPOOL_THRESHOLD=20 python3 /u/pybatch/scripts/spool_alert.py
/*

Crear usuario para scripts Python en batch (RACF) – captura 43

Al pasar el umbral, el script lista los jobs que más spool ocupan, de todos los usuarios, y envía la tarjeta a Teams.

Crear usuario para scripts Python en batch (RACF) – captura 44

Crear usuario para scripts Python en batch (RACF) – captura 45

Lo que ha necesitado PYBATCH

Al final, para lanzar el script en batch, PYBATCH necesita:

Los permisos de SDSF y de los comandos de consola los he ido descubriendo con el mismo método: lanzar el job, buscar el ICH408I en el log del sistema y dar READ en el perfil que indica FROM, que es el que protege el recurso.

Resumen

Con un usuario propio para los scripts:

  • El job ya no depende de IBMUSER ni del UID 0, y lee su propio .profile.
  • En SDSF y en los comandos de consola, PYBATCH solo tiene READ: puede lanzar los comandos de JES2 que muestran información, como $D SPOOL, pero no los que cambian algo.
  • Cualquier usuario autorizado en SURROGAT puede lanzar los scripts sin conocer ninguna contraseña.

Referencias

© 2026 Emuframe·🍪 Este sitio solo usa cookies funcionales. Sin rastreo ni recopilación de datos personales.

En esta página