Cree copias de seguridad de los recursos de Lago de Datos de proveedores de telecomunicaciones

Por Lesly Reyes, Telco Solutions Architect y
Maddyzeth Ariza, Data Architect

Los lagos de datos otorgan la capacidad de cargar y consultar datos en su forma natural, hoy en día permiten a las organizaciones acelerar su estrategia de datos. El principal desafío para la administración del lago de datos es debido al almacenamiento de datos sin procesar o sin supervisión del contenido. Con el fin de que los datos del lago sean utilizables, se necesitan mecanismos definidos para catalogar y asegurar esos datos, para esto existe el catalogo de datos AWS Glue.

Los metadatos son una parte importante del gobierno y gestión de los datos en una organización. El catálogo de datos de AWS Glue proporciona un repositorio uniforme para almacenar y compartir metadatos. Para un conjunto de datos determinado, el catálogo de datos puede almacenar la definición de la tabla y la ubicación física, agregar atributos y realizar un seguimiento de cómo los datos han cambiado con el tiempo.

El catálogo de datos de AWS Glue es compatible con distintas aplicaciones de big data como Apache Hive Metastore. Además, se integra con el servicio interactivo de consultas Amazon Athena y con la plataforma de big data en la nube Amazon EMR. Una vez que se agregan las tablas al catálogo de datos, estarán disponibles para procesos de ET, consultas con Amazon Athena, Amazon EMR Y Amazon Redshift Spectrum, de esta forma, quedará disponible una vista común de datos entre estos servicios. Cuando ya se tienen catalogados los datos, es importante que se guarden copias de seguridad de los esquemas organizacionales de los datos, para que en caso de fallas se puedan recuperar tanto la información como el esquema en que está estaba almacenada.

En este artículo, demostramos cómo usar AWS Glue para realizar la creación de copias de seguridad de los recursos de lago de datos utilizando los metadatos almacenados en el catálogo de datos.

Solución

La mayoría de las empresas poseen una gran cantidad de información almacenada dentro de su organización, pero que aún no es accesible de manera generalizada para los otros equipos, es por esto que nacen los lagos de datos. No obstante, también la forma en que estos datos serán organizados dentro del lago es importante, por esto se definen estructuras o servicios que conformaran el lago de datos.

Comúnmente se habla del respaldar la información existente dentro de los lagos de datos, pero además es importante respaldar los recursos que lo componen, como lo son los esquemas de las bases de datos que almacén la información. Para los operadores de telecomunicaciones no es la excepción, dado que almacenan grandes cantidades de datos provenientes de distintas fuentes, que van a ser depositados en lagos de datos dentro de su organización, al poseer datos heterogéneos es que estos son almacenados en la mayoría de los casos en distintas bases de datos o tablas, teniendo cada una de estas tablas su propio esquema. Por lo tanto, es importante también contar con el respaldo de los recursos de un lago de datos para en caso de una falla recuperar la información y además la estructura como está estaba almacenada.

En está publicación, vemos cómo podemos usar el Catálogo de datos de AWS Glue para ayudar a los desarrolladores y empresas a realizar copias de seguridad incrementales de los recursos de un lago de datos.

Arquitectura general

Para realizar las copias de seguridad debemos utilizar la interfaz de línea de comandos (AWS CLI) para ejecutar una serie de instrucciones que nos permiten obtener las tablas y bases de datos que componen el lago de datos. El resultado de las instrucciones genera un archivo formato JSON que puede ser almacenado en una cubeta del servicio de Amazon Simple Storage(S3), se generará un archivo JSON por cada base de datos de la cual se hizo respaldo.

Para desplegar la solución de copias de seguridad de los recursos del lago de datos es necesario contar con los siguientes recursos, la cubeta donde se guardarán los respaldos de seguridad, los roles y permisos para ejecutar los respaldos, también acceso al proyecto de AWS CodeBuild asociado. Utilizando una función Lambda, se verificará si la cubeta se encuentra vacía, en cuyo caso se ejecutará un script que pedirá obtener los datos de todas las bases de datos existentes. Luego por cada base de datos el mismo script iterará en cada base de datos buscando las tablas de cada una. El resultado del script es un archivo formato JSON con la definición de cada tabla de la base de datos. El archivo JSON obtenido se empaquetará en formato GNUZIP y este se almacenará en la cubeta de Amazon S3 dentro de una subcarpeta con el nombre de la tabla, que a su vez se encontrará en una carpeta con el nombre de la base de datos.

Requisitos

Para comenzar a crear las copias de seguridad se deben cumplir con los siguientes requisitos.

Cuenta de AWS
Clave de acceso programático
Permisos
Recursos función Lambda

En las siguientes secciones se demostrará como crear e instalar cada componente requerido en el ambiente de la nube de AWS.

Clave de acceso programático

Una clave de acceso concede acceso programático a sus recursos. El acceso programático es un tipo de acceso desde la interfaz de línea de comandos de AWS utilizado por los desarrolladores. Además, como prática recomendada, utilice claves temporales (roles de IAM) en vez de claves de acceso, para obtener más información, consulte Prácticas recomendadas para administrar claves de acceso.

Para crear la clave de acceso debe iniciar sesión en la consola de IAM, en la barra de navegación se debe seleccionar Usuarios y crear nuevo usuario. Cuando cree el par de claves de acceso Glue_developer, guarde el ID de clave de acceso y la clave de acceso secreta en un lugar seguro. La clave de acceso secreta solo está disponible en el momento de su creación. Si pierde su clave de acceso secreta, debe eliminar la clave de acceso y crear una nueva.

Permisos

Para realizar los respaldos es necesario contar con una serie de roles del servicio de IAM; el primero es AWSBackupDefaultServiceRole, él cual contará con las políticas manejadas necesarias para realizar el backup. A continuación, se listan las políticas.

AWSBackupServiceRolePolicyForBackup: le otorga a AWS Backup el permiso para realizar copias de seguridad a través de los servicios de AWS.
AWSBackupServiceRolePolicyForRestores: le otorga a AWS Backup el permiso para restaurar estados de los servicios de AWS. Como por ejemplo eliminar o crear un volumen de EBS, instancias de RDS, entre otros.
AWSBackupServiceRolePolicyForS3Backup: le otorga a AWS Backup el permiso para realizar copias de seguridad de los datos almacenados en una cubeta de Amazon S3.
AWSBackupServiceRolePolicyForS3Restores: le otorga a AWS Backup el permiso para realizar restaurar cubetas de S3.

Además, como parte de esta solución es necesario contar con roles para ejecutar los diferentes pasos de la copia de seguridad. Los roles creados por la solución son los siguientes.

RoleLambaBackupCatalog: el rol proporciona permisos a la función Lambda sobre el Catálogo de Datos.
sdfl-catalog-backup-lambda-role: le otorga permisos a la función Lamba sobre el Serveless Datalake Framework(SDLF).
sdfl-backup-event-role: el rol le proporciona al servicio de Amazon EventBridge permisos sobre el SDLF.

Recursos función Lambda

Antes de lanzar la plantilla del servicio de AWS CloudFormation es necesario contar con el código y la layer de la función Lambda, para que la plantilla funcione sin modificaciones los archivos deben estar almacenados de la siguiente forma.

En la carpeta catalog-backup debe estar almacenada la layer de la función Lambda, y en la dirección que se muestra en la imagen deben estar almacenados los siguientes códigos.

DATABASE_NAME=${1}
TABLE_NAME=${2}
BACKUP_BUCKET=${3}

echo "Getting table definition..."
cd /tmp/

/opt/aws glue get-table --name ${TABLE_NAME} --database-name ${DATABASE_NAME} > "${TABLE_NAME}.json"
zipfile="${TABLE_NAME}.gz"

echo "Compressing table and uploading to S3 bucket: ${BACKUP_BUCKET}/${DATABASE_NAME}"

tar -zcvf "${zipfile}" "${TABLE_NAME}.json"
/opt/aws s3 cp "${zipfile}" "s3://${BACKUP_BUCKET}/${DATABASE_NAME}/${TABLE_NAME}/${TABLE_NAME}.gz" --region $AWS_DEFAULT_REGION

rm "$zipfile"
rm -rf "$TABLE_NAME.json"

import os
import logging
import boto3
import subprocess

region = os.getenv('REGION')
bucket = os.getenv('BUCKET')

logger = logging.getLogger()
logger.setLevel(logging.INFO)

def lambda_handler(event, context):
    database_event = 'Glue Data Catalog Database State Change'
    table_event = 'Glue Data Catalog Table State Change'

    try:
        logger.info('Getting bucket Catalog Backup')
        logger.info(f"Event: {event}")
        detail_event = event['detail-type']
        database_name = event['detail']['databaseName']
        if detail_event == database_event:
            logger.info(f'Type of event: {database_event}')
            tables = event['detail']['changedTables']
            for table in tables:
                logger.info(f'Processing for table: {table}')
                subprocess.call(['./backup_catalog.sh', database_name, table, bucket], stderr=subprocess.STDOUT)
        elif detail_event == table_event:
            change = event['detail']['typeOfChange']
            logger.info(f'Type of event: {table_event} with change {change}')
            table = event['detail']['tableName']
            logger.info(f'Processing for table: {table}')
            subprocess.call(['./backup_catalog.sh', database_name, table, bucket], stderr=subprocess.STDOUT)
        else:
            logger.error('Event not identified!')

    except Exception as e:
        logger.error(e)

Por último, en la siguiente liga se puede descargar el código de la layer de la función lambda.

Solución detallada

En la solución se desplegarán recursos como roles de IAM, una función Lambda para realizar la copia de seguridad y reglas del Servicio Amazon EventBridge. Los recursos de AWS como las cubetas de Amazon S3 y la función Lambda se crearán de forma automática utilizando la plantilla del servicio de CloudFormation. Los permisos necesarios fueron listados en la sección anterior. Los recursos y reglas que se lanzarán en la cuenta son los siguientes:

backup-catalog-bucket: Esta es la cubeta de Amazon S3 que almacenará las copias de seguridad. El nombre debe ser único, se autogenera utilizando la región y el id de la cuenta.
lambdaBackupCatalog: Es la función Lambda que realizará las copias de seguridad verificando el estado de las bases de datos.
lambdaBackupCatalogLayer: Es la capa de librerías que requiere la función Lambda.
layers-lambda-backup-catalog-bucket: Es la cubeta donde se almacenará el código de la función Lambda y la capa de librerías necesarias.
cf-template-catalog-backup-bucket: Es la cubeta donde se almacenará la plantilla de CloudFormation.
cloudWatchGlueCatalogEventRule: Es la regla que monitoreará los cambios del catálogo de AWS Glue.
cloudWatchGlueDatabaseEventRule: Es la regla que monitoreará los cambios de las bases de

A continuación, se incluye el código de la plantilla para crear los recursos necesarios. Antes de lanzarlo es necesario reemplazar el AccountId por el id de la cuenta que se utilizará. El nombre que debe llevar la plantilla es template-backup.yaml.

AWSTemplateFormatVersion: 2010-09-09
Transform: AWS::Serverless-2016-10-31
Description: "Backup Plan template to back up all resources"

Parameters:
  pArtifactBucket:
    Type: String
  pApplicationName:
    Type: String
    Default: backup

Globals:
  Function:
    Runtime: python3.7
    Handler: lambda_function.lambda_handler

Resources:

  CloudWatchEventRole:
    Type: 'AWS::IAM::Role'
    Properties:
      RoleName: !Sub ${pApplicationName}-event-role
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - events.amazonaws.com
            Action: 'sts:AssumeRole'
      Path: /
      Policies:
        - PolicyName: !Sub ${pApplicationName}-execution
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - 'lambda:InvokeFunction'
                  - 'lambda:GetFunction'
                Resource: !GetAtt LambdaBackupCatalog.Arn

  CloudWatchGlueCatalogEventRule:
    Type: 'AWS::Events::Rule'
    Properties:
      Name: !Sub ${pApplicationName}-data-catalog-rule
      EventPattern:
        source:
          - aws.glue
        detail-type:
          - Glue Data Catalog Table State Change
        detail:
          typeOfChange:
            - anything-but:
                - BatchCreatePartition
                - BatchDeletePartition
                - BatchUpdatePartition
      Targets:
        - Arn: !GetAtt LambdaBackupCatalog.Arn
          Id: backup-catalog-table-EventBased
      State: ENABLED

  CloudWatchGlueDatabaseEventRule:
    Type: 'AWS::Events::Rule'
    Properties:
      Name: backup-database-catalog-rule
      EventPattern:
        source:
          - aws.glue
        detail-type:
          - Glue Data Catalog Database State Change
      Targets:
        - Arn: !GetAtt LambdaBackupCatalog.Arn
          Id: backup-catalog-database-EventBased
      State: ENABLED

  PermissionForTableEventsInvokeLambda:
    Type: AWS::Lambda::Permission
    Properties:
      FunctionName: !Ref LambdaBackupCatalog
      Action: "lambda:InvokeFunction"
      Principal: "events.amazonaws.com"
      SourceArn: !GetAtt CloudWatchGlueCatalogEventRule.Arn

  PermissionForDBEventsInvokeLambda:
    Type: AWS::Lambda::Permission
    Properties:
      FunctionName: !Ref LambdaBackupCatalog
      Action: "lambda:InvokeFunction"
      Principal: "events.amazonaws.com"
      SourceArn: !GetAtt CloudWatchGlueDatabaseEventRule.Arn

  BackUpBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName:
        !Sub backup-${AWS::Region}-${AWS::AccountId}-glue-catalog
      VersioningConfiguration:
        Status: Enabled
      BucketEncryption:
        ServerSideEncryptionConfiguration:
          - ServerSideEncryptionByDefault:
              SSEAlgorithm: AES256
      PublicAccessBlockConfiguration:
        BlockPublicAcls: True
        BlockPublicPolicy: True
        IgnorePublicAcls: True
        RestrictPublicBuckets: True

  BucketPolicy:
    Type: AWS::S3::BucketPolicy
    Properties:
      Bucket: !Ref BackUpBucket
      PolicyDocument:
        Version: 2012-10-17
        Statement:
          - Sid: AllowSSLRequestsOnly
            Action: s3:*
            Effect: Deny
            Resource:
              - !Sub arn:aws:s3:::${BackUpBucket}/*
              - !Sub arn:aws:s3:::${BackUpBucket}
            Condition:
              Bool:
                aws:SecureTransport: False
            Principal: "*"

  LakeFormationAdmin:
    Type: AWS::LakeFormation::DataLakeSettings
    Properties:
      Admins:
        - DataLakePrincipalIdentifier: !GetAtt RoleLambdaBackupCatalog.Arn

  LambdaBackupCatalog:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: ../lambda/catalog-backup/src
      FunctionName: !Sub catalog-${pApplicationName}-lambda
      Layers:
        - { Ref: LambdaBackupCatalogLayer }
      Environment:
        Variables:
          REGION: !Sub ${AWS::Region}
          BUCKET: !Ref BackUpBucket
      Description: Triggers the catalog backup
      MemorySize: 256
      Timeout: 300
      Role: !GetAtt RoleLambdaBackupCatalog.Arn
  rLambdaDDBStreamsLogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      LogGroupName: !Sub /aws/lambda/${LambdaBackupCatalog}
      RetentionInDays: 365

  LambdaBackupCatalogLayer:
    Type: AWS::Lambda::LayerVersion
    Properties:
      CompatibleRuntimes:
        - python3.7
      Content:
        S3Bucket: !Sub "${pArtifactBucket}"
        S3Key: "catalog-backup/awscli-lambda-layer.zip"
      Description: "CLI layer for catalog backup"
      LayerName: "catalog-backup-libs"

  RoleLambdaBackupCatalog:
    Type: AWS::IAM::Role
    Properties:
      RoleName: !Sub catalog-${pApplicationName}-lambda-role
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      Path: /
      Policies:
        - PolicyName: !Sub catalog-${pApplicationName}-lambda-policy
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - logs:CreateLogGroup
                Resource: !Sub arn:aws:logs:${AWS::Region}:${AWS::AccountId}:*
              - Effect: "Allow"
                Action:
                  - "glue:Get*"
                Resource:
                  - !Sub "arn:aws:glue:${AWS::Region}:${AWS::AccountId}:catalog"
                  - !Sub "arn:aws:glue:${AWS::Region}:${AWS::AccountId}:database/*"
                  - !Sub "arn:aws:glue:${AWS::Region}:${AWS::AccountId}:table/*"
              - Effect: "Allow"
                Action:
                  - "logs:CreateLogGroup"
                  - "logs:CreateLogStream"
                  - "logs:PutLogEvents"
                Resource: !Sub arn:aws:logs:${AWS::Region}:${AWS::AccountId}:*
              - Effect: "Allow"
                Action:
                  - "lakeformation:List*"
                  - "lakeformation:Describe*"
                  - "lakeformation:Get*"
                  - "lakeformation:AddLFTagsToResource"
                  - "lakeformation:RemoveLFTagsFromResource"
                  - "lakeformation:*DataCellsFilter"
                  - "lakeformation:*LFTag"
                  - "lakeformation:GetDataAccess"
                  - "lakeformation:StartQueryPlanning"
                  - "lakeformation:*Resource"
                  - "lakeformation:*Permissions"
                Resource: "*"
              - Effect: "Allow"
                Action:
                  - "s3:PutObject"
                  - "s3:List*"
                Resource: !Join
                  - ""
                  - - !GetAtt BackUpBucket.Arn
                    - "*"
              - Effect: "Allow"
                Action:
                  - "s3:GetObject*"
                Resource:
                  - !Sub "arn:aws:s3:::${pArtifactBucket}/catalog-backup"
                  - !Sub "arn:aws:s3:::${pArtifactBucket}/catalog-backup/*"
              - Effect: "Allow"
                Action:
                  - "s3:ListBucket"
                  - "s3:GetBucket*"
                Resource: !Sub "arn:aws:s3:::${pArtifactBucket}"

  S3BackupBucketSsm:
    Type: "AWS::SSM::Parameter"
    Properties:
      Name: !Sub "/S3/BackupCatalogBucket"
      Type: "String"
      Value: !Ref BackUpBucket
      Description: "The S3 Backup Bucket"

Antes de lanzar la solución también es necesario copiar el código deploy_backup.sh que desplegará la plantilla e ingresará los parámetros requeridos por esta que son los nombres de los buckets. Recordar que los archivos deben estar almacenados en subcarpetas como se muestra en la siguiente imagen.

#!/bin/bash
bflag=false
cflag=false

DIRNAME=$(dirname "$0")
STACK_NAME='glue-backup-stack'

usage () { echo "
    -h -- Opens up this help message
    -b -- Name of the artifacts bucket
    -c -- Name of the cloudformation bucket
"; }
options=':n:c:b:s:h'
while getopts $options option
do
    case "$option" in
        b  ) bflag=true; S3_BUCKET=$OPTARG;;
        c  ) cflag=true; CFN_S3_BUCKET=$OPTARG;;
        h  ) usage; exit;;
        \? ) echo "Unknown option: -$OPTARG" >&2; exit 1;;
        :  ) echo "Missing option argument for -$OPTARG" >&2; exit 1;;
        *  ) echo "Unimplemented option: -$OPTARG" >&2; exit 1;;
    esac
done

echo "Loading libraries ..."
aws s3 sync ./catalog-backup/ s3://$S3_BUCKET/catalog-backup/

mkdir $DIRNAME/output
aws cloudformation package --template-file $DIRNAME/stack/template-backup.yaml --s3-bucket $CFN_S3_BUCKET --s3-prefix backup --output-template-file $DIRNAME/output/packaged-template.yaml

echo "Checking if $STACK_NAME stack exists ..."
if ! aws cloudformation describe-stacks --stack-name $STACK_NAME; then
  echo -e "Stack does not exist, creating ..."
  aws cloudformation create-stack \
    --stack-name $STACK_NAME \
    --template-body file://$DIRNAME/output/packaged-template.yaml \
    --parameters ParameterKey=pArtifactBucket,ParameterValue=$S3_BUCKET \
    --capabilities "CAPABILITY_NAMED_IAM" "CAPABILITY_AUTO_EXPAND" \

  echo "Waiting for stack to be created ..."
  aws cloudformation wait stack-create-complete \
    --stack-name $STACK_NAME
else
  echo -e "Stack exists, attempting update ..."

  set +e
  update_output=$( aws cloudformation update-stack \
    --stack-name $STACK_NAME \
    --template-body file://$DIRNAME/output/packaged-template.yaml \
    --parameters ParameterKey=pArtifactBucket,ParameterValue=$S3_BUCKET \
    --capabilities "CAPABILITY_NAMED_IAM" "CAPABILITY_AUTO_EXPAND" )
  status=$?
  set -e

  echo "$update_output"

  if [ $status -ne 0 ] ; then
    # Don't fail for no-op update
    if [[ $update_output == *"ValidationError"* && $update_output == *"No updates"* ]] ; then
      echo -e "\nFinished create/update - no updates to be performed";
      exit 0;
    else
      exit $status
    fi
  fi

  echo "Waiting for stack update to complete ..."
  aws cloudformation wait stack-update-complete \
    --stack-name $STACK_NAME
  echo "Finished create/update successfully!"
fi

echo "Getting the Backup bucket name from parameter store"
BACKUP_BUCKET=$(sed -e 's/^"//' -e 's/"$//' <<<"$(aws ssm get-parameter --name /S3/BackupCatalogBucket --query "Parameter.Value")")

echo "Bucket obtained ${BACKUP_BUCKET}"

bucket_content=(`aws s3 ls s3://$BACKUP_BUCKET`)

echo "Checking if the bucket is empty..."

if [ -z ${bucket_content} ];then
  echo "Getting databases..."

  declare -a databases=(`aws glue get-databases | jq -r '.DatabaseList[].Name'`)

  for database in "${databases[@]}"
  do
      echo "[===== Getting tables for database: ${database} =====]"
      declare -a tables=(`aws glue get-tables --database-name ${database} | jq -r '.TableList[].Name'`)

      for table in ${tables[@]}
      do
        echo "[===== Getting table ${table} definition =====]"
        aws glue get-table --name ${table} --database-name ${database} > "${table}.json"
        zipfile="${table}.gz"

        echo "Compressing table and uploading to S3 bucket: ${BACKUP_BUCKET}/${database}"

        tar -zcvf "${zipfile}" "${table}.json"
        aws s3 cp "${zipfile}" "s3://${BACKUP_BUCKET}/${database}/${table}/${zipfile}"

        rm $zipfile
        rm -rf "$table.json"

      done

  done
else
  echo "The bucket already has content";
fi

Para lanzar la solución se debe correr el siguiente comando en la consola estando en la misma carpeta donde se encuentra el archivo deploy_backup.sh.

./deploy_backup.sh -b layers-lambda-backup-catalog-bucket -c cf-template-catalog-backup-bucket

En la siguiente imagen se pueden apreciar los recursos, permisos y reglas que serán creados por la pila de CloudFormation.

La siguiente imagen muestra secuencialmente lo que hará el código del archivo deploy_backup.sh. Primero, creará los eventos en el servicio de Amazon EventBridge para monitorear los cambios en el catálogo de datos, por ejemplo, si se agregó o eliminó una columna en una base de datos. Segundo, lanzará la plantilla de AWS CloudFormation, recordar que este servicio despliega con código .yaml infraestructura en la nube, la plantilla recibirá como parámetros los nombres de las cubetas de Amazon S3 que usará para almacenar la layer de la función Lambda y la plantilla, también creará la cubeta donde almacenará los respaldos de seguridad, además creará la función Lambda con todos sus códigos respectivos para realizar los respaldos incrementales. Tercero ejecutará el primer respaldo de seguridad.

A continuación, se muestra cómo debería verse en consola la función Lambda creada y los eventos de Amazon EventBridge asociados.

Además, debería ser visible en el código de la función los siguientes archivos:

backup_catalog.sh: Este código iterará por cada tabla de la base de datos y conseguirá el esquema en formato JSON y luego lo empaquetará en formato GNUZIP para después ir almacenarlo en la subcarpeta correspondiente.
Lambda_function.py: Este archivo contiene el código que ejecutará la función Lambda, el cual consultará por la región y la cubeta de Amazon S3 bucket donde se guardan las copias de seguridad, también buscará los nombres de las bases de datos y por cada base de datos ejecutará el script backup_catalog.sh.

Finalmente, se correrá por primera vez la función lambda que consultará al servicio de AWS Glue por el esquema que tienen las bases de datos, luego el esquema que corresponde a la definición de cada tabla se guardará en una subcarpeta con el nombre de la tabla dentro de la carpeta con el nombre de la base de datos. A continuación, un ejemplo de la ruta de una copia de seguridad de una tabla.

bucket_backup_glue_catalog_name/database_name/table_name/table_name.gz

Copias de seguridad incrementales

Las copias de seguridad incrementales se realizarán de forma automática. Cada vez que se detecten cambios en los esquemas de las bases de datos el servicio de Amazon EventBridge invocará la función Lambda que escaneará cada tabla de la base de datos y guardará el esquema en la cubeta correspondiente a la base de datos como table_name.gz. Estas copias de seguridad además cuentan con versionamiento dado que las cubetas de Amazon S3 creadas por la plantilla se encuentran con está opción habilitada.

Conclusión

En está publicación hemos demostrado que con la ayuda de los servicios de AWS Glue y Amazon Lambda, el respaldo de los recursos de un lago de datos puede automatizarse en minutos. El servicio de AWS Glue es capaz de realizar un mapeo de las bases de datos y tablas existentes en un lago datos utilizando los metadatos almacenados en el catálogo de datos. Además, gracias a que las cubetas de Amazon S3 cuentan con versionamiento, se podrán tener distintas versiones de las tablas de las bases de datos en caso que se necesite recuperar un esquema anterior. Si deseas profundizar más sobre la gobernanza de los datos o como organizar data, este artículo te proporcionará más información, además puedes seguir aprendiendo consultando los blogs de AWS.

Puede probar el despliegue de está solución en las región US-East (Virginia del Norte). Para obtener más información, consulte la página de AWS Glue o la guía de usuario de AWS Glue.

Sobre las autoras

Lesly Reyes es Arquitecta de Soluciones en Amazon Web Services para la vertical de telecomunicaciones con experiencia en Inteligencia Artificial y aprendizaje de máquinas.

Maddyzeth Ariza es Arquitecta de datos en Amazon Web Services para el equipo de Intelligence Latam con experiencia en Lagos de Datos y Analítica.

Blog de Amazon Web Services (AWS)