Tutorial: Configurar o tempo de execução gerenciado para Micro Focus

Abra o Console do Amazon S3 e escolha Criar bucket.

Em Configuração geral, escolha a região da AWS em que você deseja criar o tempo de execução do Micro Focus gerenciado pelo AWS Mainframe Modernization.

Insira o Nome do bucket, por exemplo, yourname-aws-region-carddemo. Mantenha as configurações padrão e escolha Criar bucket. Como alternativa, você também pode copiar as configurações de um bucket do Amazon S3 existente e, depois, escolher Criar bucket.

Escolha o bucket que você acabou de criar e, depois, escolha Fazer Upload.

Na seção Fazer upload, escolha Adicionar pasta e, depois, acesse o diretório CardDemo no computador local.

Escolha Fazer upload para iniciar o processo de upload. Os tempos de upload variam de acordo com a velocidade de conexão.

Quando o upload for concluído, confirme se todos os arquivos foram carregados com êxito e escolha Fechar.

Abra o console do Amazon RDS.

Escolha a região da AWS na qual você deseja criar a instância de banco de dados.

Escolha Databases (Bancos de dados) no painel de navegação.

Escolha Criar banco de dados e Criação padrão.

Em Tipo de mecanismo, escolha PostgreSQL.

Escolha a versão do mecanismo 15 ou posterior.

Na seção Modelos, escolha Nível gratuito.

Altere o identificador da instância de banco de dados para algo significativo, por exemplo, MicroFocus-Tutorial.

Evite gerenciar credenciais principais no AWS Secrets Manager. Insira uma senha principal e confirme-a.

Em Conectividade, escolha a VPC em que você deseja criar o ambiente de tempo de execução gerenciado pelo AWS Mainframe Modernization.

Selecione Criar banco de dados.

No painel de navegação do console do Amazon RDS, selecione Grupos de parâmetros e, depois, Criar grupo de parâmetros.

Na janela Criar grupo de parâmetros, em Família de grupos de parâmetros, selecione a opção Postgres correspondente à versão do banco de dados.

Escolha Criar.

Escolha o grupo de parâmetros recém-criado.

Escolha Ações e, em seguida, escolha Editar.

Filtre max_prepared_transactions e altere o valor de parâmetro para 100.

Escolha Save Changes (Salvar alterações).

No painel de navegação do console do Amazon RDS, escolha Bancos de dados e a instância de banco de dados a ser modificada.

Selecione Modify. A página Modify DB instance (Modificar instância de banco de dados) será exibida.

Na página Modificar instância de banco de dados, acesse Configuração adicional e altere o grupo de parâmetros do banco de dados para o grupo de parâmetros. Se o grupo de parâmetros não estiver disponível na lista, confira se ele foi criado com a versão correta do banco de dados.

Escolha Continuar e confira o resumo de modificações.

Escolha Aplicar imediatamente para aplicar as alterações imediatamente.

Selecione Modificar instância de banco de dados para salvar as alterações.

Abra o Console do Key Management Service.

Escolha Create Key (Criar chave).

Deixe os padrões de Simétrico para o tipo de chave e Criptografar e descriptografar para o uso da chave.

Escolha Próximo.

Atribua à chave um Alias, como MicroFocus-Tutorial-RDS-Key e uma descrição opcional.

Escolha Próximo.

Atribua um administrador de chaves marcando a caixa ao lado do usuário ou do perfil.

Escolha Próximo e, depois, Próximo novamente.

Na tela de revisão, edite a política de chave e insira o seguinte na matriz “Declaração” existente:

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

Essa política concede permissões de descriptografia do AWS Mainframe Modernization usando essa política de chave específica.

Escolha Concluir para criar a chave.

Abra o console do Secrets Manager.

No painel de navegação, escolha Secrets (Segredos).

Em Segredos, escolha Armazenar um novo segredo.

Em Tipo de segredo, escolha Credenciais para um banco de dados do Amazon RDS.

Insira as credenciais que você especificou ao criar o banco de dados.

Em Chave de criptografia, selecione a chave que você criou na etapa 3.

Na seção Banco de dados, selecione o banco de dados que você criou para este tutorial e escolha Próximo.

Em Nome do segredo, insira um nome, como MicroFocus-Tutorial-RDS-Secret, e uma descrição opcional.

Na seção Permissões de recursos, escolha Editar permissões e substitua o conteúdo pela seguinte política:

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

Escolha Salvar.

Escolha Próximo para as telas subsequentes e, depois, escolha Armazenar. Atualize a lista de segredos para ver o novo segredo.

Escolha o segredo recém-criado e anote o Secret ARN porque você precisará dele posteriormente no tutorial.

Na guia Visão geral do segredo, escolha Recuperar o valor do segredo.

Escolha Editar e Adicionar linha.

Adicione uma chave para sslMode com um valor de verify-full:

Escolha Salvar.

Abra o console do AWS Mainframe Modernization.

No painel de navegação, escolha Ambientes. Depois, escolha Criar ambiente.

Em Especificar informações básicas,

1. Insira MicroFocus-Environment para o nome do ambiente.

2. Nas opções do mecanismo, verifique se a opção Micro Focus está selecionada.

3. Escolha a versão mais recente do Micro Focus.

4. Escolha Próximo.

Configure o ambiente.

1. Em Disponibilidade, escolha Cluster de alta disponibilidade.

2. Em Recursos, escolha M2.c5.large ou M2.m5.large para o tipo de instância, bem como o número de instâncias desejado. Especifique até duas instâncias.

3. Em Segurança e rede, escolha Permitir que as aplicações implantadas nesse ambiente sejam acessíveis ao público e escolha, pelo menos, duas sub-redes públicas.

4. Escolha Próximo.

Na página Anexar armazenamento, escolha Próximo.

Na página Programar manutenção, escolha Sem preferência e, depois, escolha Próximo.

Na página Revisar e criar, revise todas as configurações que você forneceu para o ambiente de tempo de execução e escolha Criar ambiente.

No painel de navegação, escolha Aplicativos. Escolha Criar aplicação.

Na página Criar aplicação, em Especificar informações básicas, insira MicroFocus-CardDemo para o nome da aplicação e, em Tipo de mecanismo, garanta que Micro Focus esteja selecionado. Em seguida, escolha Próximo.

Em Especificar recursos e configurações, escolha a opção para especificar a definição da aplicação com os recursos e as configurações usando o editor em linha.

Insira a seguinte definição de aplicação no 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"
      }
    }
  ],
  "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"
      }
    ]
  }
} 

Edite a aplicação JSON no objeto propriedades dos locais de origem da seguinte maneira:

1. Substitua o valor de s3_bucket pelo nome do bucket do Amazon S3 criado na Etapa 1.

2. Substitua o valor de s3-key-prefix pela pasta (prefixo de chave) na você fez upload dos arquivos de exemplo do CardDemo. Se você fez upload do diretório CardDemo diretamente em um bucket do Amazon S3, o s3-key-prefix não precisará ser alterado.

3. Substitua os dois valores secret-manager-arn pelo ARN do segredo do banco de dados que você criou na Etapa 4.

Para obter mais informações sobre a definição da aplicação, consulte Definição de aplicação da Micro Focus.

Escolha Próximo para continuar.

Na página Revisar e criar, analise as informações fornecidas e escolha Criar aplicação.

No painel de navegação, escolha Aplicações e, depois, MicroFocus-CardDemo.

Em Implantar aplicação, escolha Implantar.

Escolha a versão mais recente da aplicação e o ambiente do que você criou anteriormente e escolha Implantar.

No painel de navegação, escolha Aplicações e, depois, escolha a aplicação.

Escolha a guia Conjuntos de dados. Selecione Import (Importar).

Escolha Importar e editar configuração JSON e, depois, escolha a opção Copiar e colar o próprio JSON.

Copie e cole o JSON a seguir, mas não escolha “Enviar” ainda. Esse JSON contém todos os conjuntos de dados necessários para a aplicação de demonstração, mas precisa dos detalhes do bucket do 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/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/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/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/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/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/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/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/catalog/data/AWS.M2.CARDDEMO.USRSEC.VSAM.KSDS.DAT"
            }
        }
    ]
}

Substitua cada ocorrência de <s3-bucket-name> (há oito) pelo nome do bucket do Amazon S3 que contém a pasta CardDemo, por exemplo, your-name-aws-region-carddemo.

Selecione Enviar.

Quando a importação é concluída, um banner é exibido com a seguinte mensagem: Import task with resource identifier name was completed successfully. Uma lista dos conjuntos de dados importados é exibida.

No painel de navegação, escolha Aplicações e, depois, escolha a aplicação.

Escolha Iniciar aplicação.

Abra o console do AWS Mainframe Modernization e escolha Aplicações e depois MicroFocus-CardDemo.

Escolha o ícone de cópia para copiar o Nome do host do DNS. Além disso, anote o número das portas.

Inicie um emulador de terminal. Este tutorial usa o Micro Focus Rumba+.

Escolha Exibição do mainframe.

Escolha Conexão e Configurar.

Em Interfaces instaladas, escolha TN3270 e TN3270 novamente no menu Conexão.

Escolha Inserir e cole o DNS Hostname para a aplicação. Especifique 6000 para a porta Telnet.

Em Conexão, escolha Avançado, Enviar Keep Alive e Enviar NOP e insira 180 para o Intervalo.

Selecione Conectar.

Digite USER0001 para o nome de usuário e password para a senha.

Depois de fazer login com êxito, é possível navegar pela aplicação CardDemo.

Insira 01 para visualizar a conta.

Digite 00000000010 para o Número da conta e pressione Enter no teclado.

Pressione F3 para sair do menu e F3 para sair da transação.