Convierta archivos de mainframe de EBCDIC formato a formato delimitado por caracteres en ASCII Amazon S3 con Lambda AWS

Crear variables de entorno.

Copie las siguientes variables de entorno en un editor de texto y, a continuación, sustituya <placeholder>los valores del siguiente ejemplo por los valores de sus recursos:

bucket=<your_bucket_name>
account=<your_account_number>
region=<your_region_code>

Nota: Más adelante, creará referencias a su bucket, AWS cuenta y AWS región de S3.

Para definir las variables de entorno, abra la CloudShell consola y, a continuación, copie y pegue las variables de entorno actualizadas en la línea de comandos.

Nota: Debe repetir este paso cada vez que se reinicie la CloudShell sesión.

Cree una carpeta de trabajo.

Para simplificar el proceso de limpieza de recursos más adelante, cree una carpeta de trabajo CloudShell ejecutando el siguiente comando:

mkdir workdir; cd workdir

Nota: Debe cambiar el directorio al directorio de trabajo (workdir) cada vez que pierda la conexión con la CloudShell sesión.

Cree una política de confianza para la función de Lambda.

El EBCDIC convertidor se ejecuta en una función Lambda. La función debe tener un IAM rol. Antes de crear el IAM rol, debe definir un documento de política de confianza que permita a los recursos asumir esa política.

Desde la carpeta de CloudShell trabajo, cree un documento de política ejecutando el siguiente comando:

E2ATrustPol=$(cat <<EOF
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Service": "lambda.amazonaws.com"
            },
            "Action": "sts:AssumeRole"
        }
    ]
}
EOF
)
printf "$E2ATrustPol" > E2ATrustPol.json

Cree el IAM rol para la conversión a Lambda.

Para crear un IAM rol, ejecute el siguiente AWS CLI comando desde la carpeta de CloudShell trabajo:

aws iam create-role --role-name E2AConvLambdaRole --assume-role-policy-document file://E2ATrustPol.json

Cree el documento IAM de política para la función Lambda.

La función Lambda debe tener acceso de lectura y escritura al bucket de S3 y permisos de escritura para Amazon Logs. CloudWatch

Para crear una IAM política, ejecute el siguiente comando desde la CloudShell carpeta de trabajo:

E2APolicy=$(cat <<EOF
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "Logs",
            "Effect": "Allow",
            "Action": [
                "logs:PutLogEvents",
                "logs:CreateLogStream",
                "logs:CreateLogGroup"
            ],
            "Resource": [
                "arn:aws:logs:*:*:log-group:*",
                "arn:aws:logs:*:*:log-group:*:log-stream:*"
            ]
        },
        {
            "Sid": "S3",
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:PutObject",
                "s3:GetObjectVersion"
            ],
            "Resource": [
                "arn:aws:s3:::%s/*",
                "arn:aws:s3:::%s"
            ]
        }
    ]
}
EOF
)
printf "$E2APolicy" "$bucket" "$bucket" > E2AConvLambdaPolicy.json

Adjunte el documento de IAM política al IAM puesto.

Para adjuntar la IAM política al IAM rol, ejecute el siguiente comando desde la carpeta de CloudShell trabajo:

aws iam put-role-policy --role-name E2AConvLambdaRole --policy-name E2AConvLambdaPolicy --policy-document file://E2AConvLambdaPolicy.json

Descargue el código fuente EBCDIC de la conversión.

Desde la carpeta de CloudShell trabajo, ejecute el siguiente comando para descargar el código mainframe-data-utilities fuente GitHub:

git clone https://github.com/aws-samples/mainframe-data-utilities.git mdu

Crea el ZIP paquete.

Desde la carpeta de CloudShell trabajo, ejecute el siguiente comando para crear el ZIP paquete que crea la función Lambda para EBCDIC la conversión:

cd mdu; zip ../mdu.zip *.py; cd ..

Crear la función de Lambda.

Desde la carpeta de CloudShell trabajo, ejecute el siguiente comando para crear la función Lambda para EBCDIC la conversión:

aws lambda create-function \
--function-name E2A \
--runtime python3.9 \
--zip-file fileb://mdu.zip \
--handler extract_ebcdic_to_ascii.lambda_handler \
--role arn:aws:iam::$account:role/E2AConvLambdaRole \
--timeout 10 \
--environment "Variables={layout=$bucket/layout/}"

Nota: El diseño de las variables de entorno indica a la función Lambda dónde residen los JSON metadatos.

Crear la política basada en recursos para la función de Lambda.

Desde la carpeta de CloudShell trabajo, ejecute el siguiente comando para permitir que la notificación de eventos de Amazon S3 active la función Lambda para EBCDIC la conversión:

aws lambda add-permission \
--function-name E2A \
--action lambda:InvokeFunction \
--principal s3.amazonaws.com \
--source-arn arn:aws:s3:::$bucket \
--source-account $account \
--statement-id 1

Cree el documento de configuración para la notificación de eventos de Amazon S3.

La notificación de eventos de Amazon S3 inicia la función Lambda de EBCDIC conversión cuando los archivos se colocan en la carpeta de entrada.

Desde la carpeta de CloudShell trabajo, ejecute el siguiente comando para crear el JSON documento para la notificación de eventos de Amazon S3:

{
"LambdaFunctionConfigurations": [
    {
      "Id": "E2A",
      "LambdaFunctionArn": "arn:aws:lambda:%s:%s:function:E2A",
      "Events": [ "s3:ObjectCreated:Put" ],
      "Filter": {
        "Key": {
          "FilterRules": [
            {
              "Name": "prefix",
              "Value": "input/"
            }
          ]
        }
      }
    }
  ]
}
EOF
)
printf "$S3E2AEvent" "$region" "$account" > S3E2AEvent.json

Crear notificaciones de eventos de Amazon S3.

Desde la carpeta de CloudShell trabajo, ejecute el siguiente comando para crear la notificación de eventos de Amazon S3:

aws s3api put-bucket-notification-configuration --bucket $bucket --notification-configuration file://S3E2AEvent.json

Analiza el COBOL cuaderno.

Desde la carpeta de CloudShell trabajo, ejecute el siguiente comando para convertir un COBOL cuaderno de ejemplo en un JSON archivo (que define cómo leer y dividir el archivo de datos correctamente):

python3       mdu/parse_copybook_to_json.py \
-copybook     mdu/LegacyReference/COBKS05.cpy \
-output       CLIENT.json \
-output-s3key CLIENT.ASCII.txt \
-output-s3bkt $bucket \
-output-type  s3 \
-print        25

Añada la regla de transformación.

El archivo de datos de ejemplo y su COBOL cuaderno correspondiente son archivos de varios diseños. Esto significa que la conversión debe dividir los datos en función de determinadas reglas. En este caso, los bytes de las posiciones 3 y 4 de cada fila definen el diseño.

Desde la carpeta de CloudShell trabajo, edite el CLIENT.json archivo y cambie el contenido de la siguiente "transf-rule": [], manera:

"transf-rule": [
{
"offset": 4,
"size": 2,
"hex": "0002",
"transf": "transf1"
},
{
"offset": 4,
"size": 2,
"hex": "0000",
"transf": "transf2"
}
],

Cargue los JSON metadatos en el depósito de S3.

Desde la carpeta de CloudShell trabajo, ejecute el siguiente AWS CLI comando para cargar los JSON metadatos en el depósito de S3:

aws s3 cp CLIENT.json s3://$bucket/layout/CLIENT.json

Envíe el EBCDIC archivo al bucket de S3.

Desde la carpeta de CloudShell trabajo, ejecute el siguiente comando para enviar el EBCDIC archivo al bucket de S3:

aws s3 cp mdu/sample-data/CLIENT.EBCDIC.txt s3://$bucket/input/

Nota: Le recomendamos que configure carpetas diferentes para los archivos de entrada (EBCDIC) y de salida (ASCII) para evitar volver a llamar a la función de conversión Lambda cuando el ASCII archivo se cargue en el bucket de S3.

Comprobar la salida.

Desde la carpeta de CloudShell trabajo, ejecute el siguiente comando para comprobar si el ASCII archivo se ha generado en el bucket de S3:

awss3 ls s3://$bucket/

Nota: La conversión de datos puede tardar varios segundos en realizarse. Le recomendamos que compruebe el ASCII archivo varias veces.

Cuando el ASCII archivo esté disponible, ejecute el siguiente comando para descargar el archivo del bucket de S3 a la carpeta actual:

aws s3 cp s3://$bucket/CLIENT.ASCII.txt .

Compruebe el contenido ASCII del archivo:

head CLIENT.ASCII.txt

(Opcional) Prepare las variables y la carpeta.

Si pierde la conexión con CloudShell, vuelva a conectarse y ejecute el siguiente comando para cambiar el directorio a la carpeta de trabajo:

cd workdir

Asegúrese de que las variables de entorno estén definidas:

bucket=<your_bucket_name>
account=<your_account_number>
region=<your_region_code>

Eliminar la configuración de notificación para el bucket.

Desde la carpeta de CloudShell trabajo, ejecute el siguiente comando para eliminar la configuración de notificaciones de eventos de Amazon S3:

aws s3api put-bucket-notification-configuration \
--bucket=$bucket \
--notification-configuration="{}"

Elimine la función de Lambda.

Desde la carpeta de CloudShell trabajo, ejecute el siguiente comando para eliminar la función Lambda del EBCDIC convertidor:

awslambdadelete-function--function-nameE2A

Elimine el IAM rol y la política.

Desde la carpeta de CloudShell trabajo, ejecute el siguiente comando para eliminar la función y la política del EBCDIC conversor:

aws iam delete-role-policy --role-name
E2AConvLambdaRole --policy-name
E2AConvLambdaPolicy

aws iam delete-role --role-name
E2AConvLambdaRole

Elimine los archivos generados en el bucket de S3.

Desde la carpeta de CloudShell trabajo, ejecute el siguiente comando para eliminar los archivos generados en el bucket de S3:

aws s3 rm s3://$bucket/layout --recursive
aws s3 rm s3://$bucket/input --recursive
aws s3 rm s3://$bucket/CLIENT.ASCII.txt

Elimine la carpeta de trabajo.

Desde la carpeta de CloudShell trabajo, ejecute el siguiente comando para eliminar workdir y su contenido:

cd ..; rm -Rf workdir