AWS O Mainframe Modernization Service (experiência em Managed Runtime Environment) não está mais aberto a novos clientes. Para recursos semelhantes ao AWS Mainframe Modernization Service (experiência em Managed Runtime Environment), explore o AWS Mainframe Modernization Service (experiência autogerenciada). Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte Alteração na [disponibilidade AWS da modernização do mainframe](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html).
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: Implantar CardDemo aplicativo na NTT DATA
Esta página orienta você pelo step-by-step processo de implantação do aplicativo de CardDemo amostra na replataforma de modernização de AWS mainframe com o tempo de execução do NTT DATA Unikix.
O aplicativo CardDemo de amostra é um aplicativo simplificado de mainframe projetado e desenvolvido para testar e mostrar a tecnologia de parceria para casos de uso de migração AWS e modernização de mainframe.
Para obter mais informações sobre esse aplicativo, consulte [GitHubrepositório para CardDemo](https://github.com/aws-samples/aws-mainframe-modernization-carddemo).
**Topics**
+ [Diagrama do fluxo de implantação](#tutorial-unikix-workflow)
+ [Pré-requisitos](#tutorial-unikix-prerequisites)
+ [Etapa 1: preparar o ambiente](#tutorial-unikix-prepare)
+ [Etapa 2: criar uma região TPE](#tutorial-unikix-tpe)
+ [Etapa 3: criar o nó e o subsistema do BPE](#tutorial-unikix-bpe)
+ [Etapa 4: compilar e implantar CardDemo o aplicativo](#tutorial-unikix-compile)
+ [Etapa 5: importar o catálogo BPE e TPE](#tutorial-unikix-import)
+ [Etapa 6: iniciar e conectar o TPE ao BPE](#unikix-tutorial-connect)
+ [Etapa 7: executar o CardDemo aplicativo](#unikix-tutorial-run-application)
+ [Solução de problemas](#tutorial-unikix-troubleshoot)
## Diagrama do fluxo de implantação
O diagrama a seguir mostra cada etapa do fluxo de trabalho para implantar uma aplicação no tempo de execução do NTT DATA Unikix.
## Pré-requisitos
+ Siga as instruções fornecidas em [AWS Modernização do mainframe e reformulação da plataforma com a NTT DATA](unikix.md) Como usar a [AMI do NTT DATA UniKix Marketplace](https://aws.amazon.com/marketplace/pp/prodview-eg227ymldsnx2).
+ Modifique a opção de metadados da instância **IMDSv2**para **Opcional**, conforme mencionado em [Restaurar o uso do IMDSv1](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-IMDS-existing-instances.html) no guia do *usuário do Amazon EC2*.
+ Baixe os componentes CardDemo de tempo de execução para a NTT DATA UniKix a partir do
[GitHub repositório.](https://github.com/aws-samples/aws-mainframe-modernization-carddemo/blob/main/samples/m2/unikix/UniKix_CardDemo_runtime_v1.zip)
+ Faça login na instância EC2 em tempo de UniKix execução como`ec2-user`.
+ Extraia os componentes CardDemo de tempo de execução baixados usando este link: [UniKix\_ CardDemo \_runtime\_v1.zip](https://github.com/aws-samples/aws-mainframe-modernization-carddemo/blob/main/samples/m2/unikix/UniKix_CardDemo_runtime_v1.zip).
+ O diretório extraído deve conter os diretórios `bin` e `migrated_app`.
+ Mova os diretórios `bin` e `migrated_app` para baixo do diretório `$HOME`. O caminho seria semelhante a `/home/ec2-user`.
+ É necessário ter os seguintes diretórios em `$HOME`:
+ `/home/ec2-user/bin`
+ `/home/ec2-user/migrated_app`
+ Mova todos os arquivos dentro do diretório $HOME/bin com o seguinte comando:
+
+ `chmod +x $HOME/bin/*`
## Etapa 1: preparar o ambiente
Depois de concluir os pré-requisitos, a primeira etapa é preparar o ambiente em que você deseja implantar o aplicativo. CardDemo
1. Faça login na instância EC2 em tempo de UniKix execução como`ec2-user`.
1. Observe a lista de UniKix softwares pré-embalados na AMI, como TPE, BPE e COBOL, junto com outros da localização do UniKix produto NTT DATA, usando o seguinte comando em sua instância do EC2:
```
ls -l /opt/software/
```
1. Examine o CardDemo aplicativo migrado. Você verá todo o código-fonte, incluindo mapas BMS, programas COBOL, COBOL Copybooks e. JCLs Você também encontrará a exportação de catálogos BPE e TPE, definições de recursos do CICS e dados migrados, como arquivos sequenciais e arquivos VSAM, fazendo o seguinte:
```
ls $HOME/migrated_app/*/*
```
1. Crie uma estrutura de pastas executando o script `create_project` com o seguinte comando:
```
sh $HOME/bin/create_project
```
1. Ative o CardDemo ambiente fornecendo o arquivo de `carddemo.env` configuração usando:
```
source $HOME/bin/carddemo.env
```
## Etapa 2: criar uma região TPE
Depois de ativar o ambiente em que você deseja implantar a aplicação, é necessário criar uma região TPE.
1. Crie uma região TPE usando o comando `kixregion createRegion` que requer entradas, como `$KIXSYS`, `$JAVA_HOME` e `$KIXLICDIR`. Essas variáveis de ambiente já estão configuradas no arquivo de configuração `carddemo.env`.
```
kixregion createRegion $KIXSYS $JAVA_HOME $KIXLICDIR
```
1. Configure a região TPE usando o comando `kixregion setAttr`.
```
kixregion setAttr $KIXSYS server.tx.languages.cobol.enabled true
kixregion setAttr $KIXSYS server.tx.languages.cobol.flavor vcobol
kixregion setAttr $KIXSYS server.tx.languages.cobol.home $VCOBOL
kixregion setAttr $KIXSYS maps.location $PROJECT_ROOT/maps
kixregion setAttr $KIXSYS programs.location $PROJECT_ROOT/loadlib
kixregion setAttr $KIXSYS environment.KIXDATA $KIXDATA
kixregion setAttr $KIXSYS td.jobq.submission.node $EBMHOME
kixregion setAttr $KIXSYS td.jobq.submission.subsys $EBMSYS
```
1. Gere o arquivo de ambiente do usuário específico para essa região TPE executando o comando `kixregion createScript`. Esse comando cria ou atualiza `$KIXSYS/bin/userenv` com base na configuração da região TPE.
```
kixregion createScript $KIXSYS
```
1. Ative a região TPE fornecendo o arquivo de ambiente do usuário (`$KIXSYS/bin/userenv`).
```
source $KIXSYS/bin/userenv
```
1. Crie a região TPE executando o comando `kixinstall2`.
```
kixinstall2
```
## Etapa 3: criar o nó e o subsistema do BPE
Depois de criar uma região TPE, você precisa criar o nó e o subsistema BPE seguindo estas etapas.
1. Altere a propriedade e as permissões de `INSTEBM`.
```
sudo chown root $INSTEBM
sudo chmod 4755 $INSTEBM
```
1. Crie um nó BPE usando o comando `INSTEBM`. O diretório do nó do BPE é fornecido como parâmetro de entrada.
```
$INSTEBM $EBMHOME
```
1. Ative o ambiente em lote fornecendo o arquivo `batchenv` do nó do BPE recém-criado.
```
source $EBMHOME/batchenv
```
1. Crie o subsistema BPE dentro desse nó utilizando o Batch Administration Manager (bam). O comando `bam` abrirá a interface do Batch Administration Manager.
```
bam
```
1. Inicie o nó do BPE usando a interface BAM. Escolha a opção 2, **Ambientes do sistema** no menu principal.
1. Escolha a opção 2, **Iniciar/(Parar) Batch Node** para iniciar o nó do BPE.
1. Depois de iniciado, pressione a **tecla Voltar** duas vezes para voltar ao menu principal do BAM.
1. Para criar o subsistema BPE, escolha a opção 3, **Aplicações e subsistemas**.
1. Depois, escolha a opção 3, **Criar um subsistema**.
1. Insira o nome do subsistema como `sys1`.
1. Escolha a opção 3, **Gerenciamento de dados**.
1. Escolha a opção 5, pois o CardDemo aplicativo envolve arquivos sequenciais e VSAM.
1. (Opcional). Pressione “R” para voltar à página **Criar menu** e revise as diferentes opções de configuração disponíveis.
1. Na página **Criar**, digite “C” para criar o subsistema `sys1`.
1. Revise as configurações e digite “C” para continuar com o restante das configurações do ambiente. Essas configurações de ambiente são pré-preenchidas devido às variáveis de ambiente necessárias definidas no arquivo de configuração `carddemo.env` e à existência da estrutura de pastas recomendada.
1. Digite “y” para confirmar e salvar as configurações atuais do ambiente.
1. Digite “y” para exibir o log ao criar o subsistema.
1. Pressione a **tecla Voltar** até voltar ao menu principal e sair da interface BAM selecionando a opção **Sair**.
1. Ative o subsistema BPE fornecendo o `batchenv` com o nome do subsistema `sys1`.
```
source $EBMHOME/batchenv sys1
```
## Etapa 4: compilar e implantar CardDemo o aplicativo
Nesta etapa, você vai compilar os programas COBOL e implantar artefatos de aplicações, como JCL, procedimentos, arquivos de dados e definições de recursos do CICS.
1. Ative o CardDemo ambiente novamente fornecendo o arquivo de `carddemo.env` configuração.
```
source $HOME/bin/carddemo.env
```
1. Navegue até o diretório de origem do COBOL.
```
cd $MIGAPP_DIR/cbl
```
1. Compile o programa Cobol `CBACT01C.cbl` usando o script `compile`.
```
compile CBACT01C.cbl
```
1. Compile todos os programas Cobol usando o script `compile.all`.
```
compile.all
```
1. Navegue até o diretório de origem dos mapas BMS.
```
cd $MIGAPP_DIR/bms
```
1. Compile o mapa BMS `COACTUP.bms` usando o script `compbms`.
```
compbms COACTUP.bms
```
1. Compile todos os mapas BMS usando script `compbms.all`.
```
compbms.all
```
1. Verifique os binários compilados para mapas COBOL e BMS.
```
ls $PROJECT_ROOT/loadlib
ls $PROJECT_ROOT/maps
```
1. Implante outros artefatos da aplicação, como JCL, procedimentos, arquivos de dados e definições de recursos do CICS usando o script `deploy_app`.
```
deploy_app
```
1. Navegue até o diretório JCL do projeto.
```
cd $PROJECT_ROOT/jcl
```
1. Converta JCL ACCTFILE em BPE JCL Macro. Use o comando `mvstrans`, utilizando a opção “-v” para verificação de JCL e a opção “-f” para criar a macro.
```
mvstrans ACCTFILE -v
mvstrans ACCTFILE -f
```
1. Converta o procedimento JCL REPROC na macro do procedimento BPE JCL. Use o comando `mvstrans` com a opção “-p” além da opção “-v” para verificação e a opção “-f” para criar a macro.
```
mvstrans REPROC -v -p
mvstrans REPROC -f -p
```
1. Traduza todos os procedimentos JCLs e JCL.
```
for file in "./jmvs/*"; do mvstrans $file -f; done > jmvs.out
for file in "./mvsp/*"; do mvstrans $file -p -f; done > mvsp.out
```
## Etapa 5: importar o catálogo BPE e TPE
Nesta etapa, você vai importar o catálogo do BPE e TPE usando comandos diferentes.
1. Importe o catálogo do BPE usando o comando `loadcat`.
```
loadcat $MIGAPP_DIR/catlg/bpe/BPECAT*
```
1. Acesse o diretório $KIXSYS.
```
cd $KIXSYS
```
1. Importe o catálogo do TPE usando o comando `kiximpcat`.
```
kiximpcat -c CATALOG -l CATALOG.lst
```
1. Importe as definições de recursos do CICS usando o comando kiximptbl.
```
kiximptbl
```
## Etapa 6: iniciar e conectar o TPE ao BPE
Nesta etapa, você precisa iniciar a região TPE criada anteriormente junto com o gerenciador de BPE e conectá-la para poder executar o aplicativo de amostra CardDemo .
1. Execute o comando `kixverify` em todos os arquivos VSAM para garantir que eles sejam redefinidos e que todos os arquivos abertos anteriormente sejam fechados.
```
kixverify -r ALL
```
1. Inicie a região TPE.
```
kixregion start $KIXSYS
```
1. Certifique-se de que o BPE e o TPE estejam conectados. Isso é essencial, pois os arquivos VSAM são de propriedade do TPE e qualquer operação em lote que acesse o VSAM exigirá uma conexão com o TPE.
```
ebmsys -t
```
## Etapa 7: executar o CardDemo aplicativo
Nesta etapa, você executa o CardDemo aplicativo no emulador de TN3270 terminal.
A AMI UniKix de tempo de execução vem com o emulador de terminal TN3270 que você pode iniciar diretamente da UniKix instância EC2.
**Conecte-se ao TPE usando o emulador de TN3270 terminal**
+ Inicie o TN3270 terminal usando o `kixterm` comando.
```
kixterm
```
(Opcional). Se quiser usar o próprio emulador de terminal:
1. Obtenha o endereço IP da instância de tempo de UniKix execução no console do Amazon EC2.
1. Obtenha o número da porta para se conectar à região do TPE usando o emulador de TN3270 terminal. Você pode encontrar isso no TNServer ListenPort arquivo unikixrc.cfg.
```
cat $KIXSYS/unikixrc.cfg
```
1. Configure seu emulador de TN3270 terminal para usar o endereço IP da instância de UniKix tempo de execução e o número da porta 15440.
**Transações on-line**
Esta seção pressupõe que você tenha se conectado ao emulador de TN3270 terminal usando o `kixterm` comando.
1. Depois de se conectar a partir do emulador de TN3270 terminal, pressione a tecla “Enter” para limpar a tela do TPE e inserir a transação inicial.
1. Na transação inicial CC00 (tela de login), digite o nome `USER001` de usuário e `PASSWORD` a senha.
1. Escolha a opção “01” no **menu principal** para ver as contas.
1. Na tela **Exibir conta**, insira um número de conta (por exemplo, 00000000010). Você deve ver as informações da conta preenchidas a partir dos dados migrados.
1. Pressione a tecla “PF03” duas vezes para voltar à tela de login e saia do TN3270 terminal pressionando “Ctrl\+C” (Windows) ou “Cmd\+C” (Macbook).
**Trabalhos em lote**
1. Navegue até o diretório JCL.
```
cd $MBMSUB
```
1. Envie o trabalho `MFCATGL1` e observe a saída do log do trabalho.
```
BPESUB READCARD
```
1. Também é possível visualizar os logs de trabalhos no diretório `$SUBSYS_OUTDIR`.
```
ls -lrt $SUBSYS_OUTDIR/*
```
Agora você implantou com sucesso o CardDemo aplicativo no tempo de UniKix execução da NTT DATA e verificou o aplicativo em execução navegando por algumas telas on-line do CICS e trabalhos em lote.
## Solução de problemas
A seguir estão alguns erros comuns que você pode encontrar ao configurar o CardDemo aplicativo.
### Erro: erro de licenciamento
Se você receber um erro de falha de licença ao seguir este tutorial, pode ser que o **IMDSv2**esteja habilitado em seu EC2. Você pode resolver esse problema modificando a opção de metadados da instância **IMDSv2**para **Opcional**, conforme mencionado em [Restaurar o uso de IMDSv1 no guia do](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-IMDS-existing-instances.html) usuário do *Amazon EC2*.
### Erro: o TPE não está conectado ao BPE
Se o TPE não estiver conectado ao BPE, verifique se a **tabela de configuração do VSAM** está configurada corretamente com o diretório do BPE Node. Para acessar a tabela de configuração do VSAM, inicie o emulador de TN3270 terminal usando o seguinte comando:
```
kixterm
```
1. Insira o nome da transação como `CTBL`.
1. No menu **Gerenciador de tabelas**, escolha a opção **Tabelas padrão**.
1. Na tela Tabelas padrão, escolha a opção **Tabela de configuração do VSAM**.
1. Confira se **Conectar ao batch node?** está definido como "**S** e o Node Directory está correto.
