Tutorial: Configurazione del runtime gestito per Rocket Software (precedentemente Micro Focus)

Apri la console Amazon S3 e scegli Crea bucket.

Nella configurazione generale, scegli la regione AWS in cui desideri creare il AWS Mainframe Modernization Rocket Software Managed Runtime.

Inserisci il nome di un Bucket, ad esempio. yourname-aws-region-carddemo Mantieni le impostazioni predefinite e scegli Crea bucket. In alternativa, puoi anche copiare le impostazioni da un bucket Amazon S3 esistente e quindi scegliere Crea bucket.

Scegli il bucket che hai appena creato, quindi scegli Carica.

Nella sezione Carica, scegli Aggiungi cartella, quindi accedi alla CardDemo_runtime directory dal tuo computer locale.

Scegli Carica per avviare il processo di caricamento. I tempi di caricamento variano in base alla velocità di connessione.

Al termine del caricamento, conferma che tutti i file siano stati caricati correttamente, quindi scegli Chiudi.

Apri la console Amazon RDS.

Scegli la regione AWS in cui desideri creare l'istanza di database.

Nel pannello di navigazione seleziona Databases (Database).

Scegli Crea database, quindi scegli Standard create.

Per Tipo di motore scegli PostgreSQL.

Scegli una versione del motore 15 o superiore.

Nella sezione Modelli, seleziona Piano gratuito.

Cambia l'identificatore dell'istanza DB con qualcosa di significativo, ad esempio. MicroFocus-Tutorial

Evita di gestire le credenziali principali in. AWS Secrets Manager Inserisci invece una password principale e confermala.

In Connettività, scegli il VPC in cui desideri creare l'ambiente di runtime gestito per la modernizzazione del AWS mainframe.

Scegliere Crea database.

Nel riquadro di navigazione della console Amazon RDS, scegli Gruppi di parametri, quindi scegli Crea gruppo di parametri.

Nella finestra Crea gruppo di parametri, per la famiglia di gruppi di parametri, seleziona l'opzione Postgres che corrisponde alla versione del tuo database.

Scegli Create (Crea) .

Scegliete il gruppo di parametri appena creato.

Seleziona Azioni, quindi scegli Modifica.

Filtra max_prepared_transactions e modifica il valore del parametro su 100.

Seleziona Salva modifiche.

Nel riquadro di navigazione della console Amazon RDS, scegli Databases, quindi scegli l'istanza di database che desideri modificare.

Scegliere Modify (Modifica). Viene visualizzata la pagina Modify DB Instance (Modifica istanza database).

Nella pagina Modifica istanza DB, accedi a Configurazione aggiuntiva e modifica il gruppo di parametri DB con il tuo gruppo di parametri. Se il gruppo di parametri non è disponibile nell'elenco, controlla se è stato creato con la versione corretta del database.

Scegli Continua e controlla il riepilogo delle modifiche.

Scegli Applica immediatamente per applicare le modifiche all'istante.

Scegliere Modifica istanza database per salvare le modifiche.

Aprire la console del servizio di gestione delle chiavi.

Scegli Create Key (Crea chiave).

Lascia le impostazioni predefinite di Symmetric per il tipo di chiave e Encrypt and decrypt per l'utilizzo delle chiavi.

Scegli Next (Successivo).

Assegna alla chiave un alias come e una descrizione opzionale. MicroFocus-Tutorial-RDS-Key

Scegli Next (Successivo).

Assegna un amministratore chiave selezionando la casella accanto al tuo utente o ruolo.

Scegli Next (Successivo).

Assegna l'autorizzazione all'utilizzo delle chiavi selezionando la casella accanto al tuo utente o ruolo.

Scegli Next (Successivo).

Nella schermata di revisione, modifica la politica chiave, quindi inserisci quanto segue all'interno dell'array «Statement» esistente:

{
     "Sid" : "Allow access for Mainframe Modernization Service",
     "Effect" : "Allow",
        "Principal" : {
           "Service" : "m2.amazonaws.com"
                 },
      "Action" : "kms:Decrypt",
      "Resource" : "*"
},

Questa politica concede le autorizzazioni di decrittografia di AWS Mainframe Modernization utilizzando questa politica chiave specifica.

Scegli Fine per creare la chiave.

Apri la console Secrets Manager.

Nel riquadro di navigazione, scegli Secrets (Segreti).

In Segreti, scegli Memorizza un nuovo segreto.

Imposta il tipo segreto su Credentials for Amazon RDS database.

Inserisci le credenziali che hai specificato quando hai creato il database.

In Chiave di crittografia, seleziona la chiave creata nel passaggio 3.

Nella sezione Database, seleziona il database creato per questo tutorial, quindi scegli Avanti.

In Nome segreto, inserisci un nome come MicroFocus-Tutorial-RDS-Secret e una descrizione opzionale.

Nella sezione Autorizzazioni delle risorse, scegli Modifica autorizzazioni e sostituisci il contenuto con la seguente politica:

{
    "Version":"2012-10-17",
    "Statement": [
        {
            "Effect" : "Allow",
            "Principal" : {
                "Service" : "m2.amazonaws.com"
            },
            "Action" : "secretsmanager:GetSecretValue",
            "Resource" : "*"
        }
    ]
}

Seleziona Salva.

Scegli Avanti per le schermate successive, quindi scegli Store.

Aggiorna l'elenco dei segreti per visualizzare il nuovo segreto.

Scegli il segreto appena creato nel passaggio 4 e nota Secret ARN perché ti servirà più avanti nel tutorial.

Nella scheda Panoramica del segreto, scegli Recupera valore segreto.

Scegli Modifica, quindi scegli Aggiungi riga.

Aggiungi una chiave per sslMode con un valore diverify-full:

Seleziona Salva.

Apri la console di modernizzazione AWS del mainframe.

Nel riquadro di navigazione, selezionare Compute environments (Ambienti di calcolo). Quindi scegli Crea ambiente.

In Specificare le informazioni di base,

1. Immettete MicroFocus-Environment il nome dell'ambiente.

2. Nelle opzioni del motore, assicuratevi che Micro Focus (Rocket) sia selezionato.

3. Scegliete la versione più recente di Micro Focus (Rocket).

4. Scegli Next (Successivo).

Configura l'ambiente

1. In Disponibilità, scegli Cluster ad alta disponibilità.

2. In Risorse, scegli M2.C5.large o M2.M5.large per il tipo di istanza e il numero di istanze che desideri. Specificate fino a due istanze.

3. In Sicurezza e rete, scegli Consenti alle applicazioni distribuite in questo ambiente di essere accessibili pubblicamente e scegli almeno due sottoreti pubbliche.

4. Scegli Next (Successivo).

Nella pagina Allega archiviazione, scegli Avanti.

Nella pagina Pianifica manutenzione, scegli Nessuna preferenza, quindi scegli Avanti.

Nella pagina Rivedi e crea, esamina tutte le configurazioni fornite per l'ambiente di runtime, quindi scegli Crea ambiente.

Nel riquadro di navigazione, scegliere Applications (Applicazioni). Quindi scegli Crea applicazione.

Nella pagina Crea applicazione, in Specificare le informazioni di base, immettete MicroFocus-CardDemo il nome dell'applicazione e in Tipo di motore assicuratevi che Micro Focus (Rocket) sia selezionato. Quindi scegli Successivo.

In Specificare risorse e configurazioni, scegli l'opzione per specificare la definizione dell'applicazione con le relative risorse e configurazioni utilizzando l'editor in linea.

Immettete la seguente definizione di applicazione nell'editor:

{
  "template-version": "2.0",
  "source-locations": [
    {
      "source-id": "s3-source",
      "source-type": "s3",
      "properties": {
        "s3-bucket": "yourname-aws-region-carddemo",
        "s3-key-prefix": "CardDemo_runtime"
      }
    }
  ],
  "definition": {
    "listeners": [
      {
        "port": 6000,
        "type": "tn3270"
      }
    ],
    "dataset-location": {
      "db-locations": [
        {
          "name": "Database1",
          "secret-manager-arn": "arn:aws:secretsmanager:Region:123456789012:secret:MicroFocus-Tutorial-RDS-Secret-xxxxxx"
        }
      ]
    },
    "batch-settings": {
      "initiators": [
        {
          "classes": [
               "A",
               "B"
            ],
          "description": "initiator_AB...."
        },
        {
          "classes": [
                "C",
                "D"
             ],
          "description": "initiator_CD...."
        }
      ],
      "jcl-file-location": "${s3-source}/catalog/jcl"
    },
    "cics-settings": {
      "binary-file-location": "${s3-source}/loadlib",
      "csd-file-location": "${s3-source}/rdef",
      "system-initialization-table": "CARDSIT"
    },
    "xa-resources": [
      {
        "name": "XASQL",
        "secret-manager-arn": "arn:aws:secretsmanager:Region:123456789012:secret:MicroFocus-Tutorial-RDS-Secret-xxxxxx",
        "module": "${s3-source}/xa/ESPGSQLXA64.so"
      }
    ]
  }
} 

Modifica l'applicazione JSON nell'oggetto properties di source-locations come segue:

1. Sostituisci il valore per s3_bucket con il nome del bucket Amazon S3 che hai creato nella fase 1.

2. Sostituisci il valore per s3-key-prefix con la cartella (key prefix) in cui hai caricato i file di CardDemo esempio. Se hai caricato la CardDemo directory direttamente in un bucket Amazon S3, s3-key-prefix non è necessario modificarla.

3. Sostituisci entrambi secret-manager-arn i valori con l'ARN per il segreto del database creato nel passaggio 4.

Per ulteriori informazioni sulla definizione dell'applicazione, vedereDefinizione dell'applicazione Rocket Software (precedentemente Micro Focus).

Seleziona Successivo per continuare.

Nella pagina Rivedi e crea, esamina le informazioni che hai fornito, quindi scegli Crea applicazione.

Nel riquadro di navigazione, scegli Applicazioni, quindi scegliMicroFocus-CardDemo.

In Distribuisci applicazione, scegli Distribuisci.

Scegli la versione più recente dell'applicazione e dell'ambiente che hai creato in precedenza, quindi scegli Deploy.

Nel riquadro di navigazione, scegli Applicazioni, quindi scegli l'applicazione.

Scegli la scheda Set di dati. Scegliere quindi Import (Importa).

Scegli Importa e modifica la configurazione JSON, quindi scegli l'opzione Copia e incolla il tuo JSON.

Copia e incolla il seguente codice JSON ma non scegli ancora «Invia». Questo JSON contiene tutti i set di dati richiesti per l'applicazione demo, ma richiede i dettagli del bucket Amazon S3.

{
    "dataSets": [
        {
            "dataSet": {
                "storageType": "Database",
                "datasetName": "AWS.M2.CARDDEMO.ACCTDATA.VSAM.KSDS",
                "relativePath": "DATA",
                "datasetOrg": {
                    "vsam": {
                        "format": "KS",
                        "encoding": "A",
                        "primaryKey": {
                            "length": 11,
                            "offset": 0
                        }
                    }
                },
                "recordLength": {
                    "min": 300,
                    "max": 300
                }
            },
            "externalLocation": {
                "s3Location": "s3://<s3-bucket-name>/CardDemo_runtime/catalog/data/AWS.M2.CARDDEMO.ACCTDATA.VSAM.KSDS.DAT"
            }
        },
        {
            "dataSet": {
                "storageType": "Database",
                "datasetName": "AWS.M2.CARDDEMO.CARDDATA.VSAM.AIX.PATH",
                "relativePath": "DATA",
                "datasetOrg": {
                    "vsam": {
                        "format": "KS",
                        "encoding": "A",
                        "primaryKey": {
                            "length": 11,
                            "offset": 16
                        }
                    }
                },
                "recordLength": {
                    "min": 150,
                    "max": 150
                }
            },
            "externalLocation": {
                "s3Location": "s3://<s3-bucket-name>/CardDemo_runtime/catalog/data/AWS.M2.CARDDEMO.CARDDATA.VSAM.KSDS.DAT"
            }
        },
        {
            "dataSet": {
                "storageType": "Database",
                "datasetName": "AWS.M2.CARDDEMO.CARDDATA.VSAM.KSDS",
                "relativePath": "DATA",
                "datasetOrg": {
                    "vsam": {
                        "format": "KS",
                        "encoding": "A",
                        "primaryKey": {
                            "length": 16,
                            "offset": 0
                        }
                    }
                },
                "recordLength": {
                    "min": 150,
                    "max": 150
                }
            },
            "externalLocation": {
                "s3Location": "s3://<s3-bucket-name>/CardDemo_runtime/catalog/data/AWS.M2.CARDDEMO.CARDDATA.VSAM.KSDS.DAT"
            }
        },
        {
            "dataSet": {
                "storageType": "Database",
                "datasetName": "AWS.M2.CARDDEMO.CARDXREF.VSAM.KSDS",
                "relativePath": "DATA",
                "datasetOrg": {
                    "vsam": {
                        "format": "KS",
                        "encoding": "A",
                        "primaryKey": {
                            "length": 16,
                            "offset": 0
                        }
                    }
                },
                "recordLength": {
                    "min": 50,
                    "max": 50
                }
            },
            "externalLocation": {
                "s3Location": "s3://<s3-bucket-name>/CardDemo_runtime/catalog/data/AWS.M2.CARDDEMO.CARDXREF.VSAM.KSDS.DAT"
            }
        },
        {
            "dataSet": {
                "storageType": "Database",
                "datasetName": "AWS.M2.CARDDEMO.CUSTDATA.VSAM.KSDS",
                "relativePath": "DATA",
                "datasetOrg": {
                    "vsam": {
                        "format": "KS",
                        "encoding": "A",
                        "primaryKey": {
                            "length": 9,
                            "offset": 0
                        }
                    }
                },
                "recordLength": {
                    "min": 500,
                    "max": 500
                }
            },
            "externalLocation": {
                "s3Location": "s3://<s3-bucket-name>/CardDemo_runtime/catalog/data/AWS.M2.CARDDEMO.CUSTDATA.VSAM.KSDS.DAT"
            }
        },
        {
            "dataSet": {
                "storageType": "Database",
                "datasetName": "AWS.M2.CARDDEMO.CARDXREF.VSAM.AIX.PATH",
                "relativePath": "DATA",
                "datasetOrg": {
                    "vsam": {
                        "format": "KS",
                        "encoding": "A",
                        "primaryKey": {
                            "length": 11,
                            "offset": 25
                        }
                    }
                },
                "recordLength": {
                    "min": 50,
                    "max": 50
                }
            },
            "externalLocation": {
                "s3Location": "s3://<s3-bucket-name>/CardDemo_runtime/catalog/data/AWS.M2.CARDDEMO.CARDXREF.VSAM.KSDS.DAT"
            }
        },
        {
            "dataSet": {
                "storageType": "Database",
                "datasetName": "AWS.M2.CARDDEMO.TRANSACT.VSAM.KSDS",
                "relativePath": "DATA",
                "datasetOrg": {
                    "vsam": {
                        "format": "KS",
                        "encoding": "A",
                        "primaryKey": {
                            "length": 16,
                            "offset": 0
                        }
                    }
                },
                "recordLength": {
                    "min": 350,
                    "max": 350
                }
            },
            "externalLocation": {
                "s3Location": "s3://<s3-bucket-name>/CardDemo_runtime/catalog/data/AWS.M2.CARDDEMO.TRANSACT.VSAM.KSDS.DAT"
            }
        },
        {
            "dataSet": {
                "storageType": "Database",
                "datasetName": "AWS.M2.CARDDEMO.USRSEC.VSAM.KSDS",
                "relativePath": "DATA",
                "datasetOrg": {
                    "vsam": {
                        "format": "KS",
                        "encoding": "A",
                        "primaryKey": {
                            "length": 8,
                            "offset": 0
                        }
                    }
                },
                "recordLength": {
                    "min": 80,
                    "max": 80
                }
            },
            "externalLocation": {
                "s3Location": "s3://<s3-bucket-name>/CardDemo_runtime/catalog/data/AWS.M2.CARDDEMO.USRSEC.VSAM.KSDS.DAT"
            }
        }
    ]
}

Sostituisci ogni occorrenza di <s3-bucket-name> (ce ne sono otto) con il nome del bucket Amazon S3 che contiene la CardDemo cartella, ad esempio. your-name-aws-region-carddemo

Scegli Invia.

Al termine dell'importazione, viene visualizzato un banner con il seguente messaggio: Viene visualizzato Import task with resource identifier name was completed successfully. un elenco dei set di dati importati.

Nel riquadro di navigazione, scegli Applicazioni, quindi scegli l'applicazione.

Scegli Avvia applicazione.

Apri la console di modernizzazione del AWS mainframe e scegli Applicazioni, quindi scegli. MicroFocus-CardDemo

Scegli l'icona di copia per copiare il nome host DNS. Assicurati anche di annotare il numero di porte.

Avvia un emulatore di terminale. Questo tutorial utilizza Micro Focus Rumba+.

Scegli Mainframe Display.

Scegli Connessione, quindi scegli Configura.

In Interfacce installate, sceglieteTN3270, quindi scegliete TN3270 nuovamente nel menu Connessione.

Scegliete Inserisci e incollate il file DNS Hostname per l'applicazione. 6000Specificate la porta Telnet.

In Connessione, scegli Advanced, quindi scegli Send Keep Alive e Send NOP e inserisci 180 per l'intervallo.

Scegli Connetti.

Inserisci USER0001 il nome utente e password la password.

Dopo aver effettuato correttamente l'accesso, puoi navigare nell' CardDemoapplicazione.

Accedi 01 alla visualizzazione dell'account.

Inserisci 00000000010 il numero di conto e premi Invio sulla tastiera.

Premi F3 per uscire dal menu e F3 per uscire dalla transazione.