Grupos de jobs JES2 na prática

Um JOBGROUP torna visíveis ao JES2 um conjunto de jobs relacionados e as respetivas regras de sequenciamento como um único objeto de orquestração. Em vez de pedir a cada job que descubra as suas próprias dependências, define-se primeiro a orquestração e depois associam-se os jobs reais a esse grupo.

Este artigo é deliberadamente prático. Define um pequeno JOBGROUP, submete os jobs associados no mesmo input stream e valida um fluxo simples:

• JGA executa primeiro
• JGB e JGC executam depois de JGA
• JGD executa apenas depois de JGB e JGC

1. Objetivos do laboratório

No fim do laboratório deverá ser capaz de:

• Explicar o que é um JOBGROUP JES2
• Distinguir JOBGROUP de SCHEDULE AFTER/BEFORE/DELAY=YES
• Definir um grupo de jobs nativo com GJOB e AFTER
• Associar jobs ao grupo com SCHEDULE JOBGROUP=...
• Compreender as principais restrições do bloco de definição do grupo

2. Ambiente necessário

Para este laboratório, necessita:

• z/OS 2.2 ou posterior
• JES2
• Acesso TSO/ISPF com permissão para submeter jobs encadeados
• Acesso SDSF, ou um monitor equivalente para estados de jobs e de grupos de jobs JES2

Pré-requisitos importantes:

• Os grupos de jobs JES2 têm de estar configurados e ativos ao nível do sistema (JES2 GRPDEF)
• A instalação tem de estar no modo de ativação JES2 exigido para grupos de jobs. Todos os membros têm de estar a executar z/OS 2.2 ou posterior para o modo de ativação exigido

Se o laboratório falhar logo no momento da submissão com erros JES2 de grupo de jobs, peça ao programador de sistema para verificar a ativação dos grupos de jobs antes de continuar.

3. O que JOBGROUP lhe dá

Um grupo de jobs JES2 é uma definição nativa de orquestração dentro do input stream submetido. Descreve:

• Os jobs que pertencem ao grupo
• As regras de dependência entre eles
• O objeto global de orquestração que o JES2 monitoriza

As instruções principais são:

Para associar um job submetido a um grupo de jobs, o próprio job usa:

//         SCHEDULE JOBGROUP=group-name

4. Porque é que JOBGROUP é mais forte do que o sequenciamento dinâmico leve

No modelo SCHEDULE AFTER/BEFORE/DELAY=YES, cada job descobre dinamicamente as suas dependências à medida que jobs entram e saem do JES2. Isso é útil, mas há que ter alguns cuidados operacionais devido à forma como é implementado pelo JES2 (a dependência é resolvida de forma distribuída e dinâmica, job a job, com base no estado corrente das filas JES2).

JOBGROUP altera o modelo:

• O objeto de orquestração é criado primeiro
• Os jobs registam-se nesse grupo
• O JES2 controla o fluxo a partir da própria definição do grupo

É por isso que a IBM refere explicitamente que JOBGROUP evita os problemas observados no sequenciamento dinâmico leve (modelo SCHEDULE AFTER/BEFORE/DELAY=YES).

5. Restrições importantes antes de codificar o laboratório

O bloco do grupo de jobs não é JCL comum. Existem várias restrições:

• Apenas são permitidas instruções de controlo de execução JES2 entre JOBGROUP e ENDGROUP
• Não são permitidas instruções JECL como /*...
• Não são permitidos dados instream
• Não são permitidos símbolos
• Não são permitidas instruções normais JOB, EXEC ou DD dentro do próprio bloco de definição do grupo

Os jobs batch reais vêm depois da definição do grupo e são associados ao mesmo com SCHEDULE JOBGROUP=....

6. A orquestração que vamos construir

Este laboratório usa o seguinte grafo nativo de dependências:

JGA
├── JGB
└── JGC
    └──
     JGD

Mais precisamente:

• JGB executa depois de JGA
• JGC executa depois de JGA
• JGD executa depois de JGB e JGC

Os próprios jobs vão executar ações simples sobre data sets para que possa validar que a sequência aconteceu realmente.

7. Criar o input stream completo

Crie um membro como JGLAB com o seguinte conteúdo:

//MYJG     JOBGROUP
//JGA      GJOB
//JGB      GJOB
//         AFTER NAME=JGA,WHEN=(RC=0)
//JGC      GJOB
//         AFTER NAME=JGA,WHEN=(RC=0)
//JGD      GJOB
//         AFTER NAME=(JGB,JGC)
//MYJGD    ENDGROUP
//*
//JGA      JOB ,'JOBGROUP LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//         SCHEDULE JOBGROUP=MYJG
//STEP1    EXEC PGM=IEFBR14
//OUTA     DD  DSN=&SYSUID..JGDEMO.A,
//             DISP=(NEW,CATLG,DELETE),
//             SPACE=(TRK,(1,1)),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)
//*
//JGB      JOB ,'JOBGROUP LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//         SCHEDULE JOBGROUP=MYJG
//STEP1    EXEC PGM=IEFBR14
//OUTB     DD  DSN=&SYSUID..JGDEMO.B,
//             DISP=(NEW,CATLG,DELETE),
//             SPACE=(TRK,(1,1)),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)
//*
//JGC      JOB ,'JOBGROUP LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//         SCHEDULE JOBGROUP=MYJG
//STEP1    EXEC PGM=IEFBR14
//OUTC     DD  DSN=&SYSUID..JGDEMO.C,
//             DISP=(NEW,CATLG,DELETE),
//             SPACE=(TRK,(1,1)),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)
//*
//JGD      JOB ,'JOBGROUP LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//         SCHEDULE JOBGROUP=MYJG
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  DELETE '&SYSUID..JGDEMO.A'
  IF LASTCC = 8 THEN SET MAXCC = 0
  DELETE '&SYSUID..JGDEMO.B'
  IF LASTCC = 8 THEN SET MAXCC = 0
  DELETE '&SYSUID..JGDEMO.C'
  IF LASTCC = 8 THEN SET MAXCC = 0
/*

Submeta o membro uma única vez para que a definição do grupo de jobs e os jobs associados entrem no JES2 em conjunto.

8. O que observar após a submissão

No SDSF, ou no seu monitor JES2 equivalente, procure:

• Os quatro jobs JGA, JGB, JGC e JGD
• A objeto de grupo de jobs JGDEMO
• A ordem de execução

Comportamento esperado:

• JGA torna-se elegível primeiro
• JGB e JGC mantêm-se dependentes de JGA
• JGD mantém-se dependente de JGB e JGC
• Depois de JGA terminar com RC=0, JGB e JGC tornam-se elegíveis
• Depois de ambos terminarem, JGD torna-se elegível

Resultado funcional esperado:

• JGA, JGB, JGC e JGD terminam normalmente
• JGD elimina os três data sets criados pelos jobs anteriores

Isto confirma que o sequenciamento do grupo foi imposto corretamente.

9. Porque é que a condição WHEN=(RC=0) é importante

A dependência de JGA para JGB e JGC não é apenas “depois de JGA”. É:

AFTER NAME=JGA,WHEN=(RC=0)

Isto significa que a dependência só fica satisfeita quando JGA termina com RC=0.

Este é o valor prático:

• Pode construir regras de orquestração baseadas na qualidade da conclusão
• Um job pai que termina mal não tem de libertar o resto do fluxo

Em desenhos de grupos maiores, é aqui que WHEN=, ACTION= e OTHERWISE= se tornam operacionalmente importantes.

10. Onde entra JOBSET

Este laboratório usa apenas GJOB porque é a forma mais simples de introduzir a função, mas JOBSET é a próxima capacidade a aprender quando o grafo começa a crescer.

O objetivo de JOBSET é permitir tratar vários jobs como uma única unidade de orquestração nomeada dentro do grupo de jobs. Em vez de escrever dependências contra jobs individuais um a um, define-se um conjunto e depois refere-se esse conjunto pelo seu nome.

Na prática, JOBSET é útil quando:

• Vários jobs pertencem à mesma fase lógica do fluxo
• Um sucessor deve esperar por um conjunto completo de jobs, e não apenas por um único job
• Quer que o modelo de dependências descreva fases de negócio e não apenas jobs isolados
• Quer que o comportamento de flush seja controlado ao nível do conjunto com FLUSHTYP

Pense na distinção desta forma:

10.1 Que problema JOBSET resolve

Suponha que tem três jobs de extração:

• EXTA
• EXTB
• EXTC

e depois um job de consolidação:

• LOAD1

Sem JOBSET, a dependência é expressa job a job:

//LOAD1    GJOB
//         AFTER NAME=(EXTA,EXTB,EXTC)

Isto continua a ser válido, mas a intenção fica apenas implícita. O JES2 vê três jobs pais individuais, não uma fase nomeada.

Com JOBSET, pode modelar essa fase explicitamente:

//EXTRSET  JOBSET
//EXTA     SJOB
//EXTB     SJOB
//EXTC     SJOB
//EXTRSET  ENDSET
//LOAD1    GJOB
//         AFTER NAME=EXTRSET

Agora a dependência lê-se de forma mais natural:

• Primeiro o conjunto de extração
• Depois o job de carga

Esse é o principal valor de JOBSET: uma estrutura de orquestração mais clara.

10.2 Quando JOBSET é mais útil do que GJOB

JOBSET torna-se útil quando o grafo deixa de ser “apenas alguns jobs” e começa a ter fases reutilizáveis ou reconhecíveis.

Exemplos típicos:

• Uma fase de extração paralela seguida por uma fase de merge
• Vários jobs de validação seguidos por um job de publicação
• Uma família de jobs regionais seguida por um resumo global
• Um conjunto de jobs preparatórios que têm todos de terminar antes de a fase seguinte começar

Nesse ponto, JOBSET melhora a legibilidade porque:

• A lista de dependências fica mais curta
• A definição do grupo começa a refletir melhor as fases reais do processo
• A manutenção posterior fica mais fácil quando é necessário acrescentar um novo job ao conjunto

10.3 Porque é que FLUSHTYP importa

JOBSET também introduz uma capacidade importante que GJOB simples não oferece de forma tão limpa: semântica de flush ao nível do conjunto.

A IBM documenta FLUSHTYP em JOBSET como:

• ALLFLUSH
• ANYFLUSH

Isto controla o que acontece aos jobs do conjunto quando os jobs pais são flushed.

Significado prático:

• ALLFLUSH: faz flush a um job do conjunto apenas se todos os jobs pais forem flushed
• ANYFLUSH: faz flush a um job do conjunto se qualquer job pai for flushed

Isto importa quando o conjunto representa uma fase real e precisa de comportamento coerente de falha ou bypass para toda a fase.

10.4 Regra prática de bolso

Use GJOB quando:

• O grafo é pequeno
• As dependências job a job continuam fáceis de ler
• Está a introduzir a função pela primeira vez

Use JOBSET quando:

• Vários jobs formam uma única fase lógica
• Um job posterior depende da fase como um todo
• Precisa de comportamento de flush ao nível do conjunto
• A orquestração começa a ficar difícil de ler como uma lista plana de nomes GJOB

11. Como isto difere das capacidades básicas de scheduling

As capacidades básicas de scheduling cobrem:

• HOLDUNTL
• AFTER
• BEFORE
• DELAY=YES

Continuam a ser úteis, mas funcionam como controlos mais leves de scheduling por job.

Os grupos de jobs são diferentes:

• O objeto de orquestração existe primeiro como JOBGROUP
• Os jobs associam-se depois com SCHEDULE JOBGROUP=...
• O JES2 gere a rede de dependências a partir dessa definição nativa do grupo

11. Cleanup

Nesta versão do laboratório não é necessário um job adicional de cleanup. O job final JGD já remove os três data sets criados por JGA, JGB e JGC.

Se quiser repetir o laboratório imediatamente após uma execução bem-sucedida, é mais seguro criar uma segunda variante do membro com um nome JOBGROUP diferente e nomes de job diferentes, porque o JES2 pode ainda reter durante algum tempo os metadados do grupo anterior.

Resumo

Se precisar de orquestração nativa dentro do JES2, JOBGROUP é a resposta mais forte.

O padrão prático é:

1. definir primeiro a orquestração com JOBGROUP, GJOB, AFTER e instruções relacionadas 2. submeter os jobs reais com:

//         SCHEDULE JOBGROUP=group-name

Isto dá ao JES2 um grafo nativo de dependências em vez de pedir a cada job que descubra dinamicamente as suas próprias dependências.

Documentação IBM útil

• Instruções de controlo de execução JES2
• Exemplos de um JOBGROUP e jobs associados
• Instrução JOBGROUP
• Instrução GJOB
• Instrução JOBSET
• Instrução SJOB
• Instrução AFTER
• Instrução CONCURRENT
• Configurar e ativar grupos de jobs
• JOBGROUP logging job