Tutorial: Configurar o tempo de execução gerenciado para a Micro Focus - AWS Modernização do mainframe
Pré-requisitosEtapa 1: criar e carregar um bucket do Amazon S3Etapa 2: criar e configurar um banco de dadosEtapa 3: criar e configurar um AWS KMS keyEtapa 4: criar e configurar um segredo de AWS Secrets Manager banco de dadosEtapa 5: criar um ambiente de tempo de execuçãoEtapa 6: criar um aplicativoEtapa 7: implantar um aplicativoEtapa 8: importar conjuntos de dadosEtapa 9: iniciar um aplicativoEtapa 10: Conecte-se ao CardDemo CICS aplicativoLimpar os recursosPróximas etapas

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

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

Você pode implantar e executar um aplicativo no ambiente de tempo de execução gerenciado de modernização de AWS mainframe com o mecanismo de tempo de execução da Micro Focus. Este tutorial mostra como implantar e executar o aplicativo de CardDemo amostra em um ambiente de tempo de execução gerenciado de modernização de AWS mainframe com o mecanismo de tempo de execução da Micro Focus. O aplicativo CardDemo de amostra é um aplicativo simplificado de cartão de crédito desenvolvido para testar e mostrar a tecnologia de uma parceria para casos AWS de uso de modernização de mainframe.

No tutorial, você cria recursos em outros Serviços da AWS. Isso inclui o Amazon Simple Storage Service, o Amazon Relational Database Service AWS Key Management Service, AWS Secrets Manager e.

Pré-requisitos

  • Verifique se você tem acesso a um emulador 3270 para usar a CICS conexão. Os emuladores 3270 gratuitos e de teste estão disponíveis em sites de terceiros. Como alternativa, você pode iniciar uma instância Micro Focus de Modernização de AWS Mainframe AppStream 2.0 e usar o emulador Rumba 3270 (não disponível gratuitamente).

    Para obter informações sobre AppStream 2.0, consulteTutorial: Configure a AppStream versão 2.0 para uso com o Micro Focus Enterprise Analyzer e o Micro Focus Enterprise Developer.

    nota

    Ao criar a pilha, escolha a opção Enterprise Developer (ED) e não Enterprise Analyzer (EA).

  • Baixe o aplicativo CardDemo de amostra e descompacte o arquivo baixado em qualquer diretório local. Esse diretório conterá um subdiretório intituladoCardDemo.

  • Identifique um VPC em sua conta onde você pode definir os recursos criados neste tutorial. Eles VPC precisarão de sub-redes em pelo menos duas zonas de disponibilidade. Para obter mais informações sobre a AmazonVPC, consulte Como a Amazon VPC funciona.

Etapa 1: criar e carregar um bucket do Amazon S3

Nesta etapa, você cria um bucket do Amazon S3 e carrega CardDemo arquivos para esse bucket. Posteriormente neste tutorial, você usará esses arquivos para implantar e executar o aplicativo de CardDemo amostra em um ambiente Micro Focus Managed Runtime de modernização de AWS mainframe.

nota

Você não precisa criar um novo bucket do S3, mas o bucket escolhido deve estar na mesma região dos outros recursos usados neste tutorial.

Como criar um bucket do Amazon S3

  1. Abra o console do Amazon S3 e escolha Create bucket.

  2. Em Configuração geral, escolha a AWSregião em que você deseja criar o Micro Focus Managed Runtime de Modernização de AWS Mainframe.

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

  4. Escolha o bucket que você acabou de criar e, em seguida, escolha Upload.

  5. Na seção Carregar, escolha Adicionar pasta e, em seguida, navegue até o CardDemo diretório a partir do seu computador local.

  6. Escolha Upload para iniciar o processo de upload. Os tempos de upload variam de acordo com a velocidade da sua conexão.

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

Seu bucket do Amazon S3 agora contém a CardDemo pasta.

A guia CardDemo Objetos mostrando a pasta do CardDemo aplicativo.

Para obter informações sobre buckets do S3, consulte Criação, configuração e trabalho com buckets do Amazon S3.

Etapa 2: criar e configurar um banco de dados

Nesta etapa, você cria um banco de dados Postgre no Amazon Relational SQL Database Service (AmazonRDS). Para o tutorial, esse banco de dados contém os conjuntos de dados que o aplicativo de CardDemo amostra usa para tarefas do cliente relacionadas a transações com cartão de crédito.

Para criar um banco de dados na Amazon RDS

  1. Abra o RDSconsole da Amazon.

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

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

  4. Escolha Criar banco de dados e, em seguida, escolha Criação padrão.

  5. Para Tipo de motor, escolha Postgre SQL.

  6. Escolha uma versão do Engine de 15 ou superior.

    nota

    Salve a versão do mecanismo porque você precisará dela posteriormente neste tutorial.

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

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

  9. Evite gerenciar credenciais mestras em. AWS Secrets Manager Em vez disso, insira uma senha mestra e confirme-a.

    nota

    Salve o nome de usuário e a senha que você usa para o banco de dados. Você os armazenará com segurança nas próximas etapas deste tutorial.

  10. Em Conectividade, escolha VPConde você deseja criar o ambiente de tempo de execução gerenciado da modernização do AWS mainframe.

  11. Selecione Criar banco de dados.

Para criar um grupo de parâmetros personalizado na Amazon RDS

  1. No painel de navegação do RDS console da Amazon, escolha Parameter groups e, em seguida, escolha Create parameter group.

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

    nota

    Algumas versões do Postgres exigem um Tipo. Selecione DB Parameter Group, se necessário. Insira um nome de grupo e uma descrição para o grupo de parâmetros.

  3. Escolha Criar.

Para configurar o grupo de parâmetros personalizado

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

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

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

  4. Escolha Save Changes (Salvar alterações).

Para associar o grupo de parâmetros personalizados ao banco de dados

  1. No painel de navegação do RDS console da Amazon, escolha Bancos de dados e, em seguida, escolha a instância do banco de dados que você deseja modificar.

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

    nota

    A opção Modificar não está disponível até que o banco de dados termine de criar e fazer backup, o que pode levar alguns minutos.

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

  4. Escolha Continuar e verifique o resumo das modificações.

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

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

Para obter mais informações sobre grupos de parâmetros, consulte Trabalho com grupos de parâmetros.

nota

Você também pode usar um SQL banco de dados Amazon Aurora Postgre com a modernização do AWS mainframe, mas não há opção de nível gratuito. Para obter mais informações, consulte Trabalhando com o Amazon Aurora postgre. SQL

Etapa 3: criar e configurar um AWS KMS key

Para armazenar credenciais com segurança para a RDS instância da Amazon, primeiro crie um. AWS KMS key

Para criar um AWS KMS key

  1. Abra o console do Key Management Service.

  2. Escolha Create Key (Criar chave).

  3. Deixe os padrões de Symmetric para o tipo de chave e Criptografar e descriptografar para o uso da chave.

  4. Escolha Próximo.

  5. Dê à chave um alias, como por exemplo, MicroFocus-Tutorial-RDS-Key e uma descrição opcional.

  6. Escolha Próximo.

  7. Atribua um administrador de chaves marcando a caixa ao lado do seu usuário ou função.

  8. Escolha Avançar e, em seguida, escolha Avançar novamente.

  9. Na tela de revisão, edite a política de chaves 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 decodificação da Modernização do AWS Mainframe usando essa política de chaves específica.

  10. Escolha Concluir para criar a chave.

Para obter mais informações, consulte Criação de chaves no Guia do AWS Key Management Service desenvolvedor.

Etapa 4: criar e configurar um segredo de AWS Secrets Manager banco de dados

Agora, armazene as credenciais do banco de dados com segurança usando e. AWS Secrets Manager AWS KMS key

Para criar e configurar um segredo de AWS Secrets Manager banco de dados

  1. Abra o console do Secrets Manager.

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

  3. Em Segredos, escolha Armazenar um novo segredo.

  4. Defina o tipo de segredo como Credenciais para o RDS banco de dados da Amazon.

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

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

  7. Na seção Banco de dados, selecione o banco de dados que você criou para este tutorial e escolha Avançar.

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

  9. 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" : "*"
        }
    ]
}

  10. Escolha Salvar.

  11. Escolha Avançar para as telas subsequentes e, em seguida, escolha Loja. Atualize a lista de segredos para ver o novo segredo.

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

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

  14. Escolha Editar e, em seguida, escolha Adicionar linha.

  15. Adicione uma chave para sslMode com um valor deverify-full:

    Insira o par chave/valor para o Secrets Manager Secret.

  16. Escolha Salvar.

Etapa 5: criar um ambiente de tempo de execução

Para criar um ambiente de runtime

  1. Abra o console do AWS Mainframe Modernization.

  2. No painel de navegação, escolha Ambientes. Em seguida, escolha Criar ambiente.

    A página Criar ambiente na guia Ambientes.

  3. Em Especificar informações básicas,

    1. Insira MicroFocus-Environment o nome do ambiente.

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

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

    4. Escolha Próximo.

    Seção de nome, descrição e versão do mecanismo do ambiente de execução.

  4. 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 e o número de instâncias que você deseja. Especifique até duas instâncias.

    3. Em Segurança e rede, escolha Permitir que aplicativos implantados nesse ambiente sejam acessíveis publicamente e escolha pelo menos duas sub-redes públicas.

    4. Escolha Próximo.

    A página Especificar configurações com cluster de alta disponibilidade e um tipo de instância específico selecionado.

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

  6. Na página Programar manutenção, escolha Sem preferência e, em seguida, escolha Avançar.

    O cronograma de manutenção para o meio ambiente.

  7. 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.

    A página Revisar e criar com as seleções anteriores.

Quando você cria seu ambiente, aparece um banner que diz Environment name was created successfully, e o campo Status muda para Disponível. O processo de criação do ambiente leva alguns minutos, mas você pode continuar com as próximas etapas enquanto ele é executado.

A mensagem do ambiente foi criada com sucesso.

Etapa 6: criar um aplicativo

Para criar um aplicativo.

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

    A página Aplicações com o botão Criar aplicação é exibida.

  2. Na página Criar aplicativo, em Especificar informações básicas, insira MicroFocus-CardDemo o nome do aplicativo e, em Tipo de mecanismo, verifique se a opção Micro Focus está selecionada. Em seguida, escolha Próximo.

    A página Criar aplicações com o tipo de mecanismo Micro Focus selecionado.

  3. Em Especificar recursos e configurações, escolha a opção para especificar a definição do aplicativo com seus recursos e configurações usando o editor embutido.

    A página Especificar recursos e configurações com um JSON arquivo exibido no editor on-line.

    Insira a seguinte definição de aplicativo 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"
      }
    ]
  }
}
    nota

    Esse arquivo está sujeito a alterações.

  4. Edite o aplicativo JSON no objeto de propriedades dos locais de origem da seguinte forma:

    1. Substitua o valor s3_bucket de pelo nome do bucket do Amazon S3 que você criou na Etapa 1.

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

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

    JSONdefinição do aplicativo.

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

  5. Escolha Próximo para continuar.

  6. Na página Revisar e criar, revise as informações fornecidas e escolha Criar aplicativo.

A mensagem da aplicação foi criada com sucesso.

Quando você cria seu aplicativo, aparece um banner que dizApplication name was created successfully. E o campo Status muda para Disponível.

Etapa 7: implantar um aplicativo

Para implantar uma aplicação

  1. No painel de navegação, escolha Aplicativos e, em seguida, escolhaMicroFocus-CardDemo.

  2. Em Implantar aplicativo, escolha Implantar.

    A MicroFocus - implantação CardDemo do aplicativo.

  3. Escolha a versão mais recente do aplicativo e do ambiente que você criou anteriormente e, em seguida, escolha Implantar.

    A página Implantar aplicativo e ambiente.

Quando o CardDemo aplicativo é implantado com êxito, o status muda para Pronto.

O aplicativo implantado na página de confirmação do ambiente.

Etapa 8: importar conjuntos de dados

Para importar conjuntos de dados

  1. No painel de navegação, escolha Aplicativos e, em seguida, escolha o aplicativo.

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

  3. Escolha Importar e editar JSON configuração e, em seguida, escolha a opção Copiar e colar sua própria JSON opção.

    Importe o conjunto de dados copiando seu próprio JSON script.

  4. Copie e cole o seguinteJSON, mas não escolha “Enviar” ainda. JSONEle contém todos os conjuntos de dados necessários para o aplicativo 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"
            }
        }
    ]
}

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

    nota

    Para copiar o Amazon S3 URI para a pasta no Amazon S3, selecione a pasta e escolha Copiar Amazon S3. URI

  6. Selecione Enviar.

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

    Importação bem-sucedida do conjunto de dados.

Você também pode visualizar o status de todas as importações de conjuntos de dados escolhendo Histórico de importação na guia Conjuntos de dados.

Etapa 9: iniciar um aplicativo

Para iniciar um aplicativo

  1. No painel de navegação, escolha Aplicativos e, em seguida, escolha o aplicativo.

  2. Escolha Iniciar aplicativo.

    A página CardDemo do aplicativo.

Quando o CardDemo aplicativo começa a ser executado com sucesso, um banner aparece com a seguinte mensagem:Application name was started successfully. O campo Status muda para Em execução.

A mensagem de início da aplicação foi bem-sucedida.

Etapa 10: Conecte-se ao CardDemo CICS aplicativo

Antes de se conectar, verifique se o grupo de segurança VPC e o grupo de segurança que você especificou para o aplicativo são os mesmos que você aplicou para a interface de rede a partir da qual você se conectará.

Para configurar a conexão TN327 0, você também precisa do DNS nome do host e da porta do aplicativo.

Para configurar e conectar um aplicativo ao mainframe usando o emulador de terminal

  1. Abra o console de modernização do AWS mainframe, escolha Aplicativos e, em seguida, escolha. MicroFocus-CardDemo

  2. Escolha o ícone de cópia para copiar o DNSnome do host. Além disso, certifique-se de anotar o número das portas.

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

    nota

    As etapas de configuração variam de acordo com o emulador.

  4. Escolha Mainframe Display.

    Tela de boas-vindas do Rumba+.

  5. Escolha Conexão e, em seguida, escolha Configurar.

    Tela de boas-vindas do Rumba+.

  6. Em Interfaces instaladas, escolha eTN3270, em seguida, escolha TN3270 novamente no menu Conexão.

    Conecte-se às interfaces instaladas.

  7. Escolha Inserir e cole o DNS Hostname para o aplicativo. Especifique 6000 para a porta Telnet.

    Especifique o nome do host e configure a porta.
    nota

    Se você estiver usando AWS AppStream 2.0 em um navegador e tiver dificuldades em colar valores, consulte Solução de problemas do usuário AppStream 2.0.

  8. Em Conexão, escolha Avançado e, em seguida, escolha Enviar, Manter Ativo e Enviar NOP, e insira 180 para o Intervalo.

    nota

    Configurar a configuração keep alive em seu terminal TN327 0 para pelo menos 180 segundos ajuda a garantir que o Network Load Balancer não interrompa sua conexão.

    Tela de configuração avançada.

  9. Selecione Conectar.

    nota

    Se a conexão falhar:

    • Se você estiver usando AppStream 2.0, confirme se o grupo de segurança VPC e o grupo de segurança especificado para o ambiente do aplicativo são os mesmos da frota AppStream 2.0.

    • Use o VPC Reachability Analyzer para analisar a conexão. Você pode acessar o Reachability Analyzer por meio do console.

    • Como etapa de diagnóstico, tente adicionar ou alterar as regras de entrada do Grupo de Segurança do aplicativo para permitir o tráfego para a porta 6000 de qualquer lugar (ou seja, CIDR Bloco 0.0.0.0/0). Se você se conectar com sucesso, saberá que o grupo de segurança estava bloqueando seu tráfego. Altere a fonte do grupo de segurança para algo mais específico. Para obter mais informações sobre grupos de segurança, consulte Noções básicas sobre grupos de segurança.

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

    nota

    No Rumba, o padrão para Limpar é ctrl-shift-z, e o padrão para Redefinir é ctrl-r.

    Configure o nome de usuário e a senha para seu CardDemo aplicativo.

  11. Depois de fazer login com sucesso, você pode navegar pelo CardDemo aplicativo.

  12. Entre 01 para visualizar a conta.

    Visualize sua CardDemo inscrição.

  13. Digite 00000000010 o número da conta e pressione Enter no teclado.

    nota

    Outras contas válidas são 0000000011 00000000020 e.

    Gerencie seu CardDemo aplicativo.

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

Limpar os recursos

Se você não precisar mais dos recursos que criou para este tutorial, exclua-os para evitar cobranças adicionais. Para fazer isso, realize as etapas a seguir:

Próximas etapas

Para saber como configurar um ambiente de desenvolvimento para seus aplicativos modernizados, consulte o Tutorial: Configurar AppStream 2.0 para uso com o Micro Focus Enterprise Analyzer e o Micro Focus Enterprise Developer.