Crie cópias de backup dos recursos do Data Lake dos provedores de telecomunicações

A camada da função Lambda deve ser armazenada na pasta de backup do catálogo e os códigos a seguir devem ser armazenados no endereço mostrado na imagem.

código backup_catalog.sh

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)

Versão do formato de modelo da AWS: 2010-09-09
Transformar: AWS: :Sem servidor - 31/10/2016
Descrição: “Modelo de plano de backup para fazer backup de todos os recursos”

Parâmetros:
  Peças FactBucket:
    Tipo: Corda
  Nome do aplicativo:
    Tipo: Corda
    Padrão: backup

No geral:
  Função:
    Tempo de execução: python 3.7
    Manipulador: lambda_function.lambda_handler

Recursos:

  Função do evento do CloudWatch:
    Tipo: 'AWS: :IAM: :Role'
    Propriedades:
      Nome da função:! Subfunção do evento $ {pApplicationName}
      Vou assumir o Documento de Política:
        Versão: 2012-10-17
        Declaração:
          - Efeito: Permitir
            Principal:
              Serviço:
                - events.amazonaws.com
            Ação: “STS: AssumeRole”
      Caminho:/
      Políticas:
        - Nome da política:! Sub $ {pApplicationName} -execução
          Documento de política:
            Versão: 2012-10-17
            Declaração:
              - Efeito: Permitir
                Ação:
                  - 'lambda: invokeFunction'
                  - 'lambda: GetFunction'
                Recurso:! Obtenha um catálogo de backup do Lambda. ARN

  Regra de eventos do catálogo do CloudWatch Glue:
    Tipo: 'AWS: :Events: :Rule'
    Propriedades:
      Nome:! Sub $ {pApplicationName} -data-catalog-rule
      Padrão de evento:
        fonte:
          - aws.glue
        tipo de detalhe:
          - Alteração do estado da tabela do catálogo de dados do G
        detalhe:
          Tipo de alteração:
            - qualquer coisa, mas:
                - Criação de partição em lote
                - Excluir partição em lote
                - Partição de atualização em lote
      Alvos:
        - Arma:! Obtenha um catálogo de backup do Lambda. ARN
          ID: Backup-Catalog-Table-Eventbased
      Estado: HABILITADO

  Banco de dados e regra de evento do CloudWatchGlue
    Tipo: 'AWS: :Events: :Rule'
    Propriedades:
      Nome: backup-database-catalog-rule
      Padrão de evento:
        fonte:
          - aws.glue
        tipo de detalhe:
          - Alteração do estado do banco de dados do Glue
      Alvos:
        - Arma:! Obtenha um catálogo de backup do Lambda. ARN
          ID: Catálogo de backup, banco de dados, baseado em eventos
      Estado: HABILITADO

  Permissão para eventos de mesa em Vokelambda:
    Tipo: AWS: :Lambda: :Permissão
    Propriedades:
      Nome da função:! Catálogo de backup do Ref Lambda
      Ação: “Lambda: invokeFunction”
      Página principal: “events.amazonaws.com”
      Fonte: Earn:! Obtenha um catálogo do CloudWatchGlueVentrule.arn

  Permissão para Ford Bevents em Vokelambda:
    Tipo: AWS: :Lambda: :Permissão
    Propriedades:
      Nome da função:! Catálogo de backup do Ref Lambda
      Ação: “Lambda: invokeFunction”
      Página principal: “events.amazonaws.com”
      Fonte: Earn:! Obtenha um EventRule.arn do CloudWatchGlueDatabaseEventRul

  Balde de backup:
    Tipo: AWS: :S3: :Bucket
    Propriedades:
      Nome do bucket:
        ! Subbackup - $ {AWS: :Region} -$ {AWS: :accountId} -glue-catalog
      Configuração de controle de versão:
        Status: Habilitado
      Criptografia de bucket:
        Configuração de criptografia do lado do servidor:
          - Criptografia do lado do servidor por padrão:
              Algoritmo SSE: AES 256
      Configuração do bloco de acesso público:
        Block publica CLS: É verdade
        Política pública de bloqueio: É verdade
        Ignorar Publish CLS: É verdade
        Restrinja compartimentos públicos: É verdade

  Política de bucket:
    Tipo: Política da AWS: :S3: :Bucket
    Propriedades:
      Balde:! Balde de backup Ref
      Documento de política:
        Versão: 2012-10-17
        Declaração:
          - Disse: Permitir somente solicitações de SSL
            Ação: s3: *
            Efeito: Negar
            Recurso:
              -! Subnome: aws:s3: ::$ {backupBucket} /*
              -! Subnome: aws:s3: ::$ {backupBucket}
            Condição:
              Livro:
                AWS: Transporte seguro: Falso
            Principal: “*”

  Administrador do Lake Formation:
    Tipo: Configurações do AWS:: LakeFormation:: Datalake
    Propriedades:
      Administradores:
        - Identificador principal do DataLake:! Obtenha um catálogo de backup do Rolelambda. ARN

  Catálogo de backup do Lambda:
    Tipo: Função AWS: :Serverless::
    Propriedades:
      Códigos URI:.. /lambda/catalog-backup/src
      Nome da função:! Subcatálogo - $ {pApplicationName} -lambda
      Camadas:
        - {Ref.: Camada de catálogo de backup Lambda}
      Meio ambiente:
        Variáveis:
          REGIÃO:! Sub $ {AWS: :Region}
          BALDE:! Balde de backup Ref
      Descrição: Aciona o backup do catálogo
      Tamanho da memória: 256
      Tempo limite: 300
      Função:! Obtenha um catálogo de backup do Rolelambda. ARN
  Grupo de log do RLambdAdDB Streams:
    Tipo: AWS: :LogGroup: :LogGroup
    Propriedades:
      Nome do grupo de log:! Sub/aws/lambda/ $ {lambdaBackupCatalog}
      Retenção em dias: 365

  Camada de catálogo de backup Lambda:
    Tipo: Versão da camada AWS: :Lambda::
    Propriedades:
      Tempos de execução compatíveis:
        - Python 3.7
      Conteúdo:
        Balde S3:! Sub-"$ {partifactBucket}”
        Chave S3: “catalog-backup/awscli-lambda-layer.zip”
      Descrição: “Camada CLI para backup de catálogos”
      Nome da camada: “catalog-backup-libs”

  Catálogo de backup da Rolelambda:
    Tipo: Função da AWS: :IAM::
    Propriedades:
      Nome da função:! Subcatálogo - $ {pApplicationName} -lambda-role
      Vou assumir o Documento de Política:
        Versão: 2012-10-17
        Declaração:
          - Efeito: Permitir
            Principal:
              Serviço: lambda.amazonaws.com
            Ação: STS: Assumir papel
      Caminho:/
      Políticas:
        - Nome da política:! Subcatálogo - $ {pApplicationName} -lambda-policy
          Documento de política:
            Versão: 2012-10-17
            Declaração:
              - Efeito: Permitir
                Ação:
                  - registros: criar grupo de registros
                Recurso:! Subnome: aws:logs: $ {AWS: :Region} :$ {AWS: :accountId} :*
              - Efeito: “Permitir”
                Ação:
                  - “Cola: Get*”
                Recurso:
                  -! 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/*”
              - Efeito: “Permitir”
                Ação:
                  - “Registros: Criar grupo de registros”
                  - “Registros: Criar LogStream”
                  - “registros: colocar eventos de registro”
                Recurso:! Subnome: aws:logs: $ {AWS: :Region} :$ {AWS: :accountId} :*
              - Efeito: “Permitir”
                Ação:
                  - “Formação do lago: lista*”
                  - “Formação do lago: descreva*”
                  - “Formação do lago: Get*”
                  - “Formação do lago: adicione tags LF ao recurso”
                  - “Formação do lago: remova as tags LF do recurso”
                  - “formação do lago: * Filtro de células de dados”
                  - “formação de lago: * etiqueta LF”
                  - “Lake Formation: obtenha acesso aos dados”
                  - “Formação do lago: iniciar o planejamento de consultas”
                  - “formação do lago: *Recurso”
                  - “formação do lago: *Permissões”
                Recurso: “*”
              - Efeito: “Permitir”
                Ação:
                  - “S3: colocar objeto”
                  - “S3: Lista*”
                Recurso:! Unir
                  - ""
                  - -! Obtenha um T T BackupBucket.arn
                    - "*"
              - Efeito: “Permitir”
                Ação:
                  - “S3: GetObject*”
                Recurso:
                  -! Sub-“ arn:aws:s3: ::$ {partifactBucket} /catalog-backup”
                  -! Sub-“ arn:aws:s3: ::$ {partifactBucket} /catalog-backup/ *”
              - Efeito: “Permitir”
                Ação:
                  - “S3: Lista de baldes”
                  - “S3: Obtenha um balde*”
                Recurso:! Sub-“ arn:aws:s3: ::$ {partifactBucket}”

  Buckets SSM de backup do S3:
    Tipo: “AWS: :SSM: :Parâmetro”
    Propriedades:
      Nome:! Sub-"/s3/BackupCatalogBucket”
      Tipo: “Corda”
      Valor:! Balde de backup Ref
      Descrição: “O bucket de backup do S3"

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

DIRNAME= $ (nome de usuário “$0")
STACK_NAME= 'cola e pilha de backup'

uso () {echo "
    -h — Abre esta mensagem de ajuda
    -b — Nome do bucket de artefatos
    -c — Nome do bucket do cloudformation
"; }
opções= ':n:c:b:s:h'
Enquanto getopts, a opção $options
Faça
    Caso “$option” em
        b) bflag=true; S3_BUCKET=$OPTARG;;
        c) cflag=true; CFN_S3_BUCKET=$OPTARG;
        h) uso; saída;
        \? ) echo “Opção desconhecida: -$OPTARG” >&2; exit 1;
        :) echo “Falta o argumento da opção -$OPTARG” >&2; exit 1;;
        *) echo “Opção não implementada: -$OPTARG” >&2; exit 1;
    Esac
Doe

echo “Carregando bibliotecas... ”
sincronização AWS S3. /catalog-backup/ s3://$S3_BUCKET/catalog-backup/

mkdir $dirname/output
pacote aws cloudformation —arquivo de modelo $dirname/stack/template-backup.yaml —s3-bucket $CFN_S3_BUCKET —s3-prefix backup —arquivo de modelo de saída $dirname/output/packaged-template.yaml

echo “Verificando se a pilha $STACK_NAME existe... ”
E se! aws cloudformation describe-stacks —stack-name $STACK_NAME; então
  echo -e “Stack não existe, criando... ”
  aws cloudformation create-stack\
    —nome da pilha $STACK_NAME\
    arquivo —template-body://$dirname/output/packaged-template.yaml\
    —parameters parameterKey=partifactBucket, parameterValue=$S3_bucket\
    —capacidades “CAPABILITY_NAMED_IAM” “CAPABILITY_AUTO_EXPAND”\

  echo “Aguardando a criação da pilha... ”
  aws cloudformation wait stack-create-complete\
    —nome da pilha $STACK_NAME
Senão
  echo -e “A pilha existe, tentando atualizar... ”

  Definir +e
  update_output= $ (aws cloudformation update-stack\
    —nome da pilha $STACK_NAME\
    arquivo —template-body://$dirname/output/packaged-template.yaml\
    —parameters parameterKey=partifactBucket, parameterValue=$S3_bucket\
    —capacidades “CAPABILITY_NAMED_IAM” (“CAPABILITY_AUTO_EXPAND”)
  status=$?
  Definir -e

  echo “$update_output”

  se [$status -ne 0]; então
    # Não falhe na atualização sem operação
    se [[$update_output == * “ValidationError” * && $update_output == * “Sem atualizações” *]]; então
      echo -e “\ nCriação/atualização concluída - nenhuma atualização a ser executada”;
      saída 0;
    Senão
      saia de $status
    Fi
  Fi

  echo “Aguardando a conclusão da atualização da pilha... ”
  aws cloudformation wait stack-update-complete\
    —nome da pilha $STACK_NAME
  echo “Criação/atualização concluída com sucesso! ”
Fi

echo “Obtendo o nome do bucket de backup no armazenamento de parâmetros”
BACKUP_BUCKET= $ (sed -e 's/^”//'-e' s/"$// '<<< “$ (aws ssm get-parameter —name /s3/BackupCatalogBucket —query “Parameter.Value”)”)

echo “Balde obtido $ {BACKUP_BUCKET}”

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

echo “Verificando se o balde está vazio... ”

se [-z $ {bucket_content}]; então
  echo “Obtendo bancos de dados... ”

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

  para banco de dados em “$ {databases [@]}”
  Faça
      echo “[===== Obtendo tabelas para o banco de dados: $ {database} =====]”
      declare -a tabelas =( `aws glue get-tables —database-name $ {database} | jq -r '.tableList [] .Name'`)

      para tabela em $ {tables [@]}
      Faça
        echo “[===== Obtendo a definição da tabela $ {table} =====]”
        aws glue get-table —name $ {table} —database-name $ {database} > “$ {table} .json”
        zipfile= “$ {table} .gz”

        echo “Compactando a tabela e fazendo o upload para o bucket do S3: $ {BACKUP_BUCKET} /$ {database}”

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

        em $zipfile
        rm -rf “$table.json”

      Doe

  Doe
Senão
  echo “O balde já tem conteúdo”;
Fi

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

bucket_backup_glue_catalog_name/database_name/table_name/table_name.gz