

AWS El servicio de modernización de mainframes (experiencia en entornos de ejecución gestionados) ya no está abierto a nuevos clientes. Para obtener prestaciones similares a las del Servicio de Modernización de AWS Mainframe (experiencia en entornos de ejecución gestionados), explore el Servicio de Modernización de AWS Mainframe (experiencia autogestionada). Los clientes existentes pueden seguir utilizando el servicio con normalidad. Para obtener más información, consulte Cambio en la disponibilidad de la modernización del [AWS mainframe.](https://docs.aws.amazon.com/m2/latest/userguide/mainframe-modernization-availability-change.html)

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Tutorial: Configure el tiempo de ejecución gestionado para Rocket Software (anteriormente Micro Focus)
<a name="tutorial-runtime-mf"></a>

Puede implementar y ejecutar una aplicación en un entorno de tiempo de ejecución gestionado por AWS Mainframe Modernization con el motor de tiempo de ejecución de Rocket Software. Este tutorial muestra cómo implementar y ejecutar la aplicación de CardDemo ejemplo en un entorno de tiempo de ejecución gestionado por AWS Mainframe Modernization con el motor de tiempo de ejecución de Rocket Software. La aplicación CardDemo de ejemplo es una aplicación de tarjetas de crédito simplificada desarrollada para probar y mostrar la tecnología AWS y asociarla a los casos de uso de la modernización de mainframes.

En el tutorial, creará recursos en otros Servicios de AWS. Estos incluyen Amazon Simple Storage Service, Amazon Relational Database Service AWS Key Management Service y. AWS Secrets Manager

**Topics**
+ [Requisitos previos](#tutorial-runtime-mf-prerequisites)
+ [Paso 1: creación y carga de un bucket de Amazon S3](#tutorial-runtime-mf-s3)
+ [Paso 2: creación y configuración de un usuario de base de datos](#tutorial-runtime-mf-db)
+ [Paso 3: creación y configuración de una AWS KMS key](#tutorial-runtime-mf-kms)
+ [Paso 4: creación y configuración de un secreto de base de datos de AWS Secrets Manager](#tutorial-runtime-mf-secret)
+ [Paso 5: Agrega el SSLMode al secreto](#tutorial-runtime-mf-ssl-mode)
+ [Paso 6: Crea un entorno de ejecución](#tutorial-runtime-mf-env)
+ [Paso 7: Crea una aplicación](#tutorial-runtime-mf-app)
+ [Paso 8: Implementar una aplicación](#tutorial-runtime-mf-deploy)
+ [Paso 9: Importar conjuntos de datos](#tutorial-runtime-mf-import)
+ [Paso 10: Iniciar una aplicación](#tutorial-runtime-mf-start)
+ [Paso 11: Conectarse a la CardDemo aplicación CICS](#tutorial-runtime-mf-connect)
+ [Eliminar recursos](#tutorial-runtime-mf-clean)
+ [Siguientes pasos](#tutorial-runtime-mf-next)

## Requisitos previos
<a name="tutorial-runtime-mf-prerequisites"></a>
+ Asegúrese de tener acceso a un emulador 3270 para usar la conexión CICS. Los emuladores 3270 gratuitos y de prueba están disponibles en sitios web de terceros. Como alternativa, puede iniciar una instancia de Rocket Software para WorkSpaces aplicaciones de modernización de AWS mainframe y utilizar el emulador Rumba 3270 (no disponible de forma gratuita).

  Para obtener información sobre WorkSpaces las aplicaciones, consulte. [Tutorial: Configurar WorkSpaces aplicaciones para su uso con Rocket Enterprise Analyzer y Rocket Enterprise Developer](set-up-appstream-mf.md)
**nota**  
Al crear la pila, elija la opción Enterprise Developer (ED) y no Enterprise Analyzer (EA).
+ Descargue la [aplicación CardDemo de ejemplo](https://github.com/aws-samples/aws-mainframe-modernization-carddemo/blob/main/samples/m2/mf/CardDemo_runtime.zip) y descomprima el archivo descargado en cualquier directorio local. Este directorio contendrá un subdirectorio llamado `CardDemo_runtime`.
+ Identifique una VPC en su cuenta en la que pueda definir los recursos creados en este tutorial. La VPC necesitará subredes al menos en dos zonas de disponibilidad. Para obtener más información acerca de Amazon VPC, consulte la [Guía del usuario de Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/how-it-works.html).

## Paso 1: creación y carga de un bucket de Amazon S3
<a name="tutorial-runtime-mf-s3"></a>

En este paso, debe crear un depósito de Amazon S3 y cargar CardDemo archivos en este depósito. Más adelante en este tutorial, utilizará estos archivos para implementar y ejecutar la aplicación de CardDemo ejemplo en un entorno de ejecución gestionado por Rocket Software AWS Mainframe Modernization.

**nota**  
No tiene que crear un bucket de S3 nuevo, pero el bucket que elija debe estar en la misma región que los demás recursos que se utilizan en este tutorial.

**Creación de un bucket de Amazon S3**

1. Abra la [consola de Amazon S3](https://s3.console.aws.amazon.com/s3/home) y elija **Crear bucket**.

1. En **Configuración general**, elija la **región de AWS** en la que desee crear el entorno de ejecución gestionado por software Rocket Modernization de AWS Mainframe.

1. Introduzca un **Nombre del bucket**, por ejemplo, `yourname-aws-region-carddemo`. Conserve la configuración predeterminada y elija **Crear bucket**. Como alternativa, también puede copiar la configuración de un bucket de Amazon S3 existente y, a continuación, elegir **Crear bucket**.

1. Elija el bucket que acaba de crear y, a continuación, elija **Cargar**.

1. En la sección **Cargar**, elija **Agregar carpeta** y, a continuación, busque el directorio `CardDemo_runtime` desde su equipo local.

1. Elija **Cargar **para iniciar el proceso de carga. Los tiempos de carga varían en función de las velocidades de conexión.

1. Cuando se complete la carga, confirme que todos los archivos se han cargado correctamente y, a continuación, seleccione **Cerrar**.

Su bucket de Amazon S3 ahora contiene la carpeta `CardDemo_runtime`.

![\[La pestaña CardDemo Objetos que muestra la carpeta de la CardDemo aplicación.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-carddemo-s3.png)


Para obtener más información sobre buckets de S3, consulte [Creación, configuración y uso de buckets de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html).

## Paso 2: creación y configuración de un usuario de base de datos
<a name="tutorial-runtime-mf-db"></a>

En este paso, va a crear una base de datos PostgreSQL en Amazon Relational Database Service (Amazon RDS). Para el tutorial, esta base de datos contiene los conjuntos de datos que la aplicación de CardDemo ejemplo utiliza para las tareas de los clientes relacionadas con las transacciones con tarjetas de crédito.

**Para crear una nueva base de datos en Amazon RDS.**

1. Abra la [consola de Amazon RDS](https://console.aws.amazon.com/rds/).

1. Elija la región de AWS donde desee crear la instancia de base de datos.

1. Seleccione **Databases** (Bases de datos) en el panel de navegación. 

1. Elija **Crear base de datos** y, a continuación, **Creación estándar**.

1. En **Tipo de motor**, elija **PostgreSQL**.

1. Elija una **Versión del motor** de 15 o superior.
**nota**  
Guarde la versión del motor, ya que la necesitará más adelante en este tutorial.

1. En **Plantillas**, elija **Nivel gratuito**.

1. Cambie el **Identificador de instancias de bases de datos** por algo significativo, por ejemplo, `MicroFocus-Tutorial`.

1. Absténgase de administrar las credenciales maestras en AWS Secrets Manager. En su lugar, introduzca una nueva contraseña *maestra* y confírmela.
**nota**  
Guarde el nombre de usuario y la contraseña que utiliza para la base de datos. Los almacenará de manera segura en los siguientes pasos de este tutorial.

1. En **Conectividad**, elija la **VPC** en la que desee crear el entorno de tiempo de ejecución gestionado por AWS Mainframe Modernization.

1. Elija **Creación de base de datos**.

**Para crear un grupo de parámetros personalizado en Amazon RDS**

1. En el panel de navegación de la consola de Amazon RDS, elija **Grupos de parámetros** y, a continuación, **Crear grupo de parámetros**.

1. En la ventana **Crear grupo de parámetros**, en **Familia de grupos de parámetros**, seleccione la opción **Postgres** que coincida con la versión de su base de datos.
**nota**  
Algunas versiones de Postgres requieren un **Tipo**. Seleccione **Grupo de parámetros de base de datos** si es necesario. Introduzca un **Nombre del grupo** y **Descripción** para el grupo de parámetros.

1. Seleccione **Crear**.

**Configuración del grupo de parámetros personalizado**

1. Elija el grupo de parámetros recién creado.

1. Seleccione **Acciones** y, a continuación, **Editar**.

1. Filtre por `max_prepared_transactions` cambie el valor del parámetro a 100.

1. Elija **Save changes (Guardar cambios)**.

**Asociación del grupo de parámetros personalizado con la base de datos**

1. En el panel de navegación de la consola de Amazon RDS, elija **Bases de datos** y, a continuación, la instancia de base de datos que desee modificar.

1. Elija **Modify** (Modificar). Aparece la página **Modify DB instance (Modificar instancia de base de datos)**. 
**nota**  
La opción **Modificar** no estará disponible hasta que la base de datos haya terminado de crearse y realizar copias de seguridad, lo que puede tardar varios minutos.

1. En la página **Modificar la instancia de base de datos**, vaya a **Configuración adicional** y cambie el **Grupo de parámetros de base de datos** al suyo. Si su grupo de parámetros no está disponible en la lista, compruebe si se creó con la versión de base de datos correcta.

1. Elija **Continuar** y consulte el resumen de las modificaciones.

1. Para aplicar los cambios inmediatamente, elija **Aplicar inmediatamente**.

1. Seleccione **Modificar la instancia de base de datos** para guardar los cambios.

Para obtener más información, consulte [Trabajo con los grupos de parámetros](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_WorkingWithParamGroups.html).

**nota**  
También puede utilizar una base de datos PostgreSQL de Amazon Aurora AWS con la modernización del mainframe, pero no hay ninguna opción de capa gratuita. Para obtener más información, consulte [Uso de Amazon Aurora PostgreSQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Aurora.AuroraPostgreSQL.html).

## Paso 3: creación y configuración de una AWS KMS key
<a name="tutorial-runtime-mf-kms"></a>

Para almacenar de forma segura las credenciales de la instancia de Amazon RDS, cree primero una AWS KMS key.

**Para crear un AWS KMS key**

1. Abra la [Consola de Key Management Service](https://console.aws.amazon.com/kms/home).

1. Elija **Create Key** (Crear clave).

1. Deje los valores predeterminados de **Simétrica** para el tipo de clave y **Cifrado y descifrado** para el uso de clave.

1. Elija **Siguiente**.

1. Proporcione a la clave un **Alias**, como `MicroFocus-Tutorial-RDS-Key`, y una descripción opcional.

1. Elija **Siguiente**.

1. Asigne un administrador clave marcando la casilla situada junto a su usuario o función.

1. Elija **Siguiente**. 

1. Asigna el permiso de uso de claves marcando la casilla situada junto a tu usuario o rol.

1. Elija **Siguiente**.

1. En la pantalla de revisión, edite la **Política de claves** y, a continuación, introduzca lo siguiente **dentro de la matriz de Instrucción existente**:

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

   Esta política otorga a AWS Mainframe Modernization permisos de descifrado mediante esta política clave específica.

1. Elija **Finalizar** para crear la clave.

Para obtener más información, consulte [Creación de claves](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) en la Guía para AWS Key Management Service desarrolladores.

## Paso 4: creación y configuración de un secreto de base de datos de AWS Secrets Manager
<a name="tutorial-runtime-mf-secret"></a>

Ahora guarde las credenciales de la base de datos de forma segura con las AWS Secrets Manager teclas y AWS KMS key.

**Para crear y configurar un secreto de AWS Secrets Manager base de datos**

1. Abra la [consola de Secrets Manager](https://console.aws.amazon.com/secretsmanager/).

1. En el panel de navegación, elija **Secretos**.

1. En **Secretos**, elija **Almacenar un secreto nuevo**.

1. Establezca **Tipo de secreto** en **Credenciales para la base de datos de Amazon RDS**.

1. Introduzca las **Credenciales** que ha especificado al crear la base de datos. 

1. En **Clave de cifrado**, seleccione la clave que ha creado en el paso 3.

1. En la sección **Base de datos**, seleccione la base de datos que ha creado para este tutorial y, a continuación, elija **Siguiente**.

1. En **Nombre del secreto**, introduzca un nombre, como, por ejemplo, `MicroFocus-Tutorial-RDS-Secret` y una descripción opcional.

1. En la sección **Permisos de recursos**, elija **Editar permisos** y, reemplace el contenido por la siguiente política:

------
#### [ JSON ]

****  

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

------

1. Seleccione **Save**.

1. Elija **Siguiente** para las pantallas siguientes y, a continuación, **Almacenar**. 

## Paso 5: Agrega el SSLMode al secreto
<a name="tutorial-runtime-mf-ssl-mode"></a>

**Para añadir el SSLMode al secreto**

1. Actualice la lista de secretos para ver el nuevo secreto.

1. Elige el secreto recién creado en el paso 4 y anótalo `Secret ARN` porque lo necesitarás más adelante en el tutorial.

1. En la pestaña **Información general** del secreto, elija **Recuperar valor del secreto**.

1. Elija **Editar** y, a continuación, **Agregar fila**.

1. Agregue una **Clave** para `sslMode` con un **Valor** de `verify-full`:  
![\[Introduce la key/value pareja para Secrets Manager Secret.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-carddemo-secret.png)

1. Seleccione **Save**.

## Paso 6: Crea un entorno de ejecución
<a name="tutorial-runtime-mf-env"></a>

**Para crear un entorno de tiempo de ejecución**

1. Abra la [consola de AWS Mainframe Modernization](https://us-east-2.console.aws.amazon.com/m2/home?region=us-east-2#/landing).

1. En el panel de navegación, elija **Entornos**. A continuación, elija **Crear entorno**.  
![\[La página Crear entorno en la pestaña Entornos.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-environment.png)

1. En **Especificar información básica**,

   1. Introduzca `MicroFocus-Environment` para el nombre del entorno.

   1. En las opciones del motor, asegúrese de seleccionar **Micro Focus (Rocket)**.

   1. Elija la versión más reciente de **Micro Focus (Rocket)**. 

   1. Elija **Siguiente**.  
![\[Sección de nombre y descripción del entorno de tiempo de ejecución y versión del motor.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-create-env-basic.png)

1. Configure el entorno

   1. En **Disponibilidad**, elija **Clúster de alta disponibilidad**.

   1. En **Recursos**, elija **M2.c5.large** o **M2.m5.large** para el tipo de instancia, así como el número de instancias que desee. Especifique hasta dos instancias.

   1. En **Seguridad y red**, elija **Permitir que las aplicaciones implementadas en este entorno sean de acceso público** y elija al menos dos subredes públicas. 

   1. Elija **Siguiente**.  
![\[Página Especificar configuraciones con clúster de alta capacidad y un tipo de instancia específico seleccionado.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/env-config.png)

1. En la página **Adjuntar almacenamiento**, elija **Paso siguiente**.

1. En **Mantenimiento programado**, elija **Sin preferencia** y, a continuación, **Siguiente**.  
![\[El mantenimiento programado para el entorno.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-env-maintenance.png)

1. En la página **Revisar y crear**, revise todas las configuraciones que ha proporcionado para el entorno de tiempo de ejecución y, a continuación, seleccione **Crear entorno.**  
![\[Página Revisar y crear con las selecciones anteriores.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-env-review.png)

Cuando haya creado su entorno, aparecerá un banner que dice `Environment name was created successfully`y el campo **Estado** cambiará a **Disponible**. El proceso de creación del entorno tarda varios minutos, pero puede continuar con los siguientes pasos mientras se ejecuta.

![\[Mensaje que indica que el entorno se ha creado correctamente.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-env-confirm.png)


## Paso 7: Crea una aplicación
<a name="tutorial-runtime-mf-app"></a>

**Cómo crear una aplicación de**

1. En el panel de navegación, elija **Aplicaciones**. Elija **Crear aplicación**.  
![\[Página Aplicaciones con el botón Crear aplicación.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/app-create.png)

1. En la página **Crear aplicación**, en **Especificar información básica**, introduzca el nombre `MicroFocus-CardDemo` de la aplicación y, en **Tipo de motor**, asegúrese de seleccionar **Micro Focus (Rocket)**. A continuación, elija **Siguiente**.  
![\[La página Crear aplicaciones con el tipo de motor de Rocket Software seleccionado.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-create-app.png)

1. En **Especificar recursos y configuraciones**, elija la opción para especificar la definición de la aplicación con sus recursos y configuraciones mediante el editor integrado.  
![\[Página de especificación de recursos y configuraciones con un archivo JSON que se muestra en el editor en línea.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-app-config.png)

   Introduzca la siguiente definición de aplicación en el 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"
         }
       ]
     }
   }
   ```
**nota**  
Este archivo está sujeto a cambios.

1. Edite el JSON de la aplicación en el objeto **properties** de **source-locations** de la siguiente manera:

   1. Reemplace el valor de `s3_bucket` por el nombre del bucket de Amazon S3 que ha creado en el Paso 1.

   1. Sustituya el valor for por `s3-key-prefix` la carpeta (key prefix) en la que cargó los archivos de CardDemo ejemplo. Si ha cargado el directorio `CardDemo` en un bucket de Amazon S3, no es necesario cambiar `s3-key-prefix`.

   1. Reemplace ambos valores de `secret-manager-arn` por el ARN del secreto de base de datos que ha creado en el Paso 4.  
![\[Definición de aplicación de JSON\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-app-resources.png)

   Para obtener más información sobre la definición de aplicaciones, consulte [Definición de la aplicación Rocket Software (anteriormente Micro Focus)](applications-m2-definition.md#applications-m2-definition-mf).

1. Elija **Siguiente** para continuar.

1. En la página **Revisar y crear**, revise la información que ha proporcionado y, a continuación, elija **Crear aplicación**.

![\[Mensaje que indica que la aplicación se ha creado correctamente.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-app-confirm.png)


Cuando haya creado su entorno, aparecerá un banner que indica `Application name was created successfully`. El campo **Estado** cambia a **Disponible**.

## Paso 8: Implementar una aplicación
<a name="tutorial-runtime-mf-deploy"></a>

**Para implementar una aplicación**

1. En el panel de navegación, elija **Aplicaciones** y, a continuación, `MicroFocus-CardDemo`.

1. En **Implementar aplicación**, elija **Implementar**.  
![\[El despliegue MicroFocus de CardDemo la aplicación.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-app-deploy.png)

1. Elija la versión más reciente de la aplicación y el entorno que ha creado anteriormente y, a continuación, **Implementar**.  
![\[La página de implementación de aplicación y entorno.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-app-env-deploy.png)

Cuando la CardDemo aplicación se implementa correctamente, el estado cambia a **Listo**.

![\[La aplicación implementada en la página de confirmación del entorno.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-app-env-confirm.png)


## Paso 9: Importar conjuntos de datos
<a name="tutorial-runtime-mf-import"></a>

**Importación de conjuntos de datos**

1. En el panel de navegación, elija **Aplicaciones** y, a continuación, elija la aplicación. 

1. Elija la pestaña **Conjuntos de datos**. A continuación, elija **Import**.

1. Elija **Importación y edición de la configuración de JSON** y, a continuación, **Copiar y pegar su propio JSON**.  
![\[Importe el conjunto de datos copiando su propio script de JSON.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-import.png)

1. Copie y pegue el siguiente JSON, pero no elija Enviar todavía. Este JSON contiene todos los conjuntos de datos necesarios para la aplicación de demostración, pero necesita los detalles del bucket de 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"
               }
           }
       ]
   }
   ```

1. Sustituya cada aparición de `<s3-bucket-name>` (hay ocho) por el nombre del bucket de Amazon S3 que contiene la CardDemo carpeta, por ejemplo,`your-name-aws-region-carddemo`.
**nota**  
Para copiar el URI de Amazon S3 de la carpeta de Amazon S3, seleccione la carpeta y, a continuación, elija **Copiar el URI de Amazon S3**. 

1. Elija **Enviar**.

   Cuando finalice la importación, aparecerá un banner con el siguiente mensaje: `Import task with resource identifier name was completed successfully.` Se muestra una lista de los conjuntos de datos importados.  
![\[Importación correcta del conjunto de datos.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-import-success.png)

Para ver el estado de todas las importaciones de conjuntos de datos, también puede seleccionar **Historial de importación** en la pestaña **Conjuntos de datos**.

## Paso 10: Iniciar una aplicación
<a name="tutorial-runtime-mf-start"></a>

**Inicio de una aplicación**

1. En el panel de navegación, elija **Aplicaciones** y, a continuación, elija la aplicación. 

1. Elija **Iniciar aplicación**.  
![\[La página CardDemo de la aplicación.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-app-start.png)

Cuando la CardDemo aplicación comienza a ejecutarse correctamente, aparece un banner con el siguiente mensaje:`Application name was started successfully`. El campo **Estado** cambia a **En ejecución**.

![\[Mensaje que indica que la aplicación se ha iniciado correctamente.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/m2-mf-startapp-confirm.png)


## Paso 11: Conectarse a la CardDemo aplicación CICS
<a name="tutorial-runtime-mf-connect"></a>

Antes de conectarse, asegúrese de que la VPC y el grupo de seguridad que ha especificado para la aplicación son los mismos que los que ha aplicado a la interfaz de red desde la que se conectará.

Para configurar la conexión TN327 0, también necesita el nombre de host DNS y el puerto de la aplicación.

**Configuración y conexión de una aplicación al mainframe mediante un emulador de terminal**

1. Abra la consola de modernización del AWS mainframe, seleccione **Aplicaciones** y, a continuación, elija. `MicroFocus-CardDemo`

1. Elija el icono de copiar para copiar el **Nombre de host DNS**. Asegúrese también de anotar el número de **Puertos**.

1. Inicie un emulador de terminal. En este tutorial se utiliza Micro Focus Rumba\$1.
**nota**  
Los pasos de configuración varían según el emulador.

1. Elija **Visualización de mainframe**.  
![\[Pantalla de bienvenida de Rumba+.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/mf-cics-mainframe.png)

1. Elija **Conexión** y, a continuación, **Configurar**.  
![\[Pantalla de bienvenida de Rumba+.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/mf-cics-configure.png)

1. En **Interfaces instaladas**, elija `TN3270` y, a continuación, seleccione `TN3270` de nuevo en el menú **Conexión**.  
![\[Conéctese a las interfaces instaladas.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/mf-cics-connection.png)

1. Elija **Insertar** y pegue el `DNS Hostname` para la aplicación. Especifique `6000` para el **Puerto Telnet**.  
![\[Especifique el nombre de host y configure el puerto.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/mf-cics-dns-hostname.png)
**nota**  
Si utiliza AWS AppStream 2.0 en un navegador y tiene dificultades para pegar valores, consulte [Solución de problemas de usuario de la AppStream versión 2.0](https://docs.aws.amazon.com/appstream2/latest/developerguide/troubleshooting-user-issues.html#copy-paste-doesnt-work). 

1. En **Conexión**, elija **Avanzado** y, a continuación, elija **Enviar mantenimiento activo** y **Enviar NOP**, e introduzca **180** para el **Intervalo**.
**nota**  
Si configuras el ajuste keep alive en tu terminal TN327 0 en al menos 180 segundos, te asegurarás de que el Network Load Balancer no interrumpa la conexión.  
![\[Pantalla Configuración avanzada.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/mf-cics-advanced.png)

1. Elija **Conectar**.
**nota**  
Si se produce un error en la conexión:   
Si usa AppStream 2.0, confirme que la VPC y el grupo de seguridad especificados para el entorno de la aplicación son los mismos que los de la flota 2.0. AppStream 
Utilice el Analizador de accesibilidad de la VPC para analizar la conexión. Puede acceder al Analizador de accesibilidad a través de la [consola](https://console.aws.amazon.com/networkinsights/home#ReachabilityAnalyzer). 
Como paso de diagnóstico, intente agregar o cambiar las reglas de entrada del grupo de seguridad para que la aplicación permita el tráfico hacia el puerto 6000 desde cualquier lugar (es decir, el bloque CIDR 0.0.0.0/0). Si se conecta correctamente, sabrá que el grupo de seguridad estaba bloqueando el tráfico. Cambie el origen del grupo de seguridad por uno más específico. Para obtener más información sobre los grupos de seguridad, consulte [Conceptos básicos de los grupos de seguridad](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-security-groups.html#security-group-basics).

1. Introduzca `USER0001` para el usuario y `password` para la contraseña.
**nota**  
En Rumba, el valor predeterminado para Borrar es ctrl-r y el predeterminado para Reset es ctrl-shift-z ctrl-r.  
![\[Configura el nombre de usuario y la contraseña para tu aplicación. CardDemo\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/mf-cics-username-password.png)

1. Después de iniciar sesión correctamente, podrá navegar por la CardDemo aplicación.

1. Introduzca `01` para la vista de la cuenta.  
![\[Vea su CardDemo solicitud.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/mf-cics-carddemo.png)

1. Introduzca `00000000010` para el número de cuenta y pulse **Intro** en el teclado.
**nota**  
Otras cuentas válidas son `0000000011` y `00000000020`.  
![\[Administre su CardDemo solicitud.\]](http://docs.aws.amazon.com/es_es/m2/latest/userguide/images/mf-cics-carddemo-account.png)

1. Pulse **F3** para salir del menú y **F3**, para salir de la transacción.

## Eliminar recursos
<a name="tutorial-runtime-mf-clean"></a>

Si ya no necesita los recursos que ha creado para este tutorial, elimínelos para evitar cargos adicionales. Para ello, complete los siguientes pasos.
+ Si es necesario, detenga la aplicación.
+ Elimine la aplicación. Para obtener más información, consulte [Eliminar una AWS Mainframe Modernization aplicación](applications-m2-delete.md).
+ Eliminar un entorno de tiempo de ejecución Para obtener más información, consulte [Elimine un entorno de ejecución AWS de modernización de mainframeEliminar un entorno de tiempo de ejecución](delete-environments-m2.md).
+ Elimine los buckets de Amazon S3 que ha creado para este tutorial. Para obtener más información, consulte [Eliminar un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html) en la *Guía del usuario de Amazon S3*.
+ Elimine el AWS Secrets Manager secreto que creó para este tutorial. Para obtener más información, consulte [Eliminación de un secreto](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_delete-secret.html).
+ Elija la clave de KMS que ha creado para este tutorial. Para obtener más información, consulte [Eliminación de claves de AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/deleting-keys.html).
+ Elija la base de datos de Amazon RDS que ha creado para este tutorial. Para obtener más información, consulte [Eliminar la EC2 instancia y la instancia de base](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.CreatingConnecting.PostgreSQL.html#CHAP_GettingStarted.Deleting.PostgreSQL) de datos en la *Guía del usuario de Amazon RDS*.
+ Si ha agregado una regla de grupo de seguridad para el puerto 6000, elimínela.

## Siguientes pasos
<a name="tutorial-runtime-mf-next"></a>

Para obtener información sobre cómo configurar un entorno de desarrollo para sus aplicaciones modernizadas, consulte el [tutorial: Configurar la AppStream versión 2.0 para su uso con Rocket Enterprise Analyzer y Rocket Enterprise](https://docs.aws.amazon.com/m2/latest/userguide/set-up-appstream-mf.html) Developer.