Monte uma Base de QA Mascarada a partir de uma Amostra da Produção, pela Linha de Comando

· 10 min de leitura · mascaramento de dados · dados de teste · base de qa · sql server para postgresql · linha de comando · api de jobs

Monte uma Base de QA Mascarada a partir de uma Amostra da Produção, pela Linha de Comando

O QA precisa de dado que se pareça com a produção: as mesmas chaves, as mesmas cidades, os mesmos limites de crédito, as mesmas datas de cadastro. Não precisa de nome, CPF, e-mail e telefone reais.

Então você quer uma base de QA pequena no PostgreSQL, preenchida com uma amostra da tabela de clientes da produção (SQL Server), com as colunas pessoais mascaradas. E quer que seja repetível: um comando que refaz a base quando você quiser, no cron ou no CI.

Este texto mostra como fazer, no Linux e no Windows, com o dbSlice by Thinwork. O mesmo arquivo de job roda nos dois. Todas as saídas abaixo vêm de execuções reais.

Os dados de exemplo

É um exemplo de laboratório, e até a "produção" é gerada. Nenhum dado aqui é real.

A tabela crm_customers (SQL Server) tem 10.000 linhas. Os valores só parecem pessoais:

  • os nomes vêm de duas listas curtas (8 nomes, 6 sobrenomes);
  • o documento tem o formato do CPF (000.000.000-00), mas é montado a partir do id, então não é um número válido;
  • os e-mails são @example.com;
  • telefone e data de nascimento são calculados a partir do id.

A tabela de QA qa_customers (PostgreSQL) tem as mesmas colunas e começa vazia. O destino precisa existir: o dbSlice não cria a tabela num sync. Os dois scripts são 01-sqlserver-source.sql e 02-postgres-qa.sql. Todos os arquivos estão num download só: masked-qa-database-from-production-sample.zip, com o arquivo de job e um script pronto para Linux (run-linux.sh) e para Windows (run-windows.ps1). Os comentários dos arquivos estão em inglês.

O arquivo de job

O job é um JSON pequeno com origem, destino, chave, modo e regras de máscara. Ele nunca leva senha: só o nome de um perfil de conexão que você salvou no dbSlice. MASTER e Server-dbPostg são os nomes dos perfis do nosso laboratório. Troque pelos seus.

{
  "nome": "qa-customers-sample",
  "tipo": "sync",
  "mode": "ForceLoad",
  "origem": {
    "environment": "article",
    "db": "MASTER",
    "type": "TABLE",
    "object": "crm_customers",
    "key": "customer_id",
    "where": "customer_id % 17 = 0"
  },
  "destino": {
    "environment": "article",
    "db": "Server-dbPostg",
    "type": "TABLE",
    "object": "qa_customers",
    "key": "customer_id"
  },
  "ofuscar": true,
  "ofuscarCampos": {
    "full_name": "template:Customer {key}",
    "tax_id": "cpf:",
    "email": "email:",
    "phone": "keep:7,*",
    "city": "original",
    "segment": "original",
    "credit_limit": "original",
    "created_at": "original"
  },
  "pageSize": 10000
}

Quatro partes importam.

A amostra. O where é escrito no dialeto da origem (aqui, SQL Server). customer_id % 17 = 0 pega uma linha em 17: 588 das 10.000.

O modo. ForceLoad esvazia o destino (TRUNCATE) e recarrega. É isso que torna a renovação repetível. Também significa que este job apaga tudo em qa_customers. Nunca aponte o destino para a produção.

As regras. "ofuscar": true liga a máscara. ofuscarCampos liga cada coluna a uma regra:

ColunaRegraResultado
full_nametemplate:Customer {key}Customer 17
tax_idcpf:os dígitos viram *, a pontuação fica
emailemail:mantém 2 letras e o domínio
phonekeep:7,*mantém os 7 primeiros caracteres (+55 11 )
birth_datesem regramáscara padrão do tipo
city, segment, credit_limit, created_atoriginalcopiadas como estão

Coluna sem regra recebe a máscara padrão do tipo: data vira 1900-01-01, texto vira ab****, número vira 0. Foi o que aconteceu com birth_date.

Existem outras regras: fixed:texto grava um valor fixo, null: grava NULL e hash: grava um código SHA-256. Com hash:, o mesmo valor gera sempre o mesmo código, então os relacionamentos entre tabelas continuam funcionando. Dá para acrescentar um segredo HMAC opcional (ofuscarSegredoProtegido), protegido no Windows com dbSlice --protect, para que ninguém refaça os códigos testando palpites.

As chaves. Chaves primárias e estrangeiras nunca são alteradas. O log diz isso: ofuscar: 5 colunas (PK/FK preservadas).

Rode: Linux e Windows

Linux (edição Docker, API de jobs)Windows (CLI)
Precisa de curl e jq. Crie um token de API na aba API da edição web. Escopos: jobs:run e runs:read. Escolha quais jobs ele pode rodar e uma validade. Salve em um arquivo. Copie o arquivo de job para a pasta jobs/ do volume de dados da instância. A API roda o job pelo nome.Salve os dois perfis no dbSlice. Mais nada a configurar.
O token vai só no cabeçalho Authorization: Bearer.O job não leva token nem senha.

Windows:

dbSlice.exe qa-customers-sample.json sample.log

Linux:

URL=http://127.0.0.1:8098
TOKEN="$(cat ./token)"   # dbs_xxxxxxxx_...
curl -sS -X POST "$URL/api/v1/jobs/qa-customers-sample/run" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"runLabel": "qa-refresh"}'

A API responde com um runId. Consulte GET /api/v1/runs/<runId> até status sair de queued e running, e leia GET /api/v1/runs/<runId>/log. Nos dois sistemas o código de saída diz se a execução funcionou. No Linux, faça o script sair com código diferente de zero quando a execução não terminar como succeeded.

O que a execução diz

Saída do Linux (a instância do laboratório roda em português):

[05:29:58] INFO origem : MASTER [SQL Server]  ·  crm_customers  ·  chave: customer_id
[05:29:58] INFO ofuscar: 5 colunas (PK/FK preservadas)
[05:29:58] INFO mapa de campos: 4 com regra própria, 4 mantidos como na origem
[05:29:58] INFO destino: Server-dbPostg [PostgreSQL]  ·  qa_customers  ·  modo: ForceLoad
[05:29:58] INFO impacto: APAGA o destino (TRUNCATE) e recarrega
[05:29:58] INFO Página 1: 588/588 processados
[05:29:58] INFO OK  Concluído: 588 lidos, 588 inseridos, 0 upsert/update em 0,2s  ·  read 0,0s / transform 0,0s / write 0,1s

Leia o log antes de confiar nos dados. 5 colunas são mascaradas, 4 têm regra própria, 4 ficam como na origem. E a linha impacto avisa que o destino é apagado primeiro.

A máscara acontece na leitura, antes da gravação. O valor original nunca chega à base de QA.

O Windows devolve as mesmas contagens: 588 lidos, 588 inseridos.

Os mesmos cinco clientes, antes e depois

SQL Server, o lado da produção:

customer_id|full_name|tax_id|email|phone|birth_date|city|segment|credit_limit|created_at
17|Bruno Rocha|000.017.803-93|bruno.rocha17@example.com|+55 11 90629-1547|1950-08-10|Santos|corporate|1401.00|2024-01-01 08:47:00
34|Carla Almeida|000.035.607-86|carla.almeida34@example.com|+55 11 91258-3094|1951-03-19|Recife|smb|2302.00|2024-01-01 17:34:00
51|Diego Pereira|000.053.411-79|diego.pereira51@example.com|+55 11 91887-4641|1951-10-26|Campinas|retail|3203.00|2024-01-02 02:21:00
68|Elisa Costa|000.071.215-72|elisa.costa68@example.com|+55 11 92516-6188|1952-06-03|Curitiba|corporate|4104.00|2024-01-02 11:08:00
85|Fabio Lima|000.089.019-65|fabio.lima85@example.com|+55 11 93145-7735|1953-01-10|Sao Paulo|smb|5005.00|2024-01-02 19:55:00

PostgreSQL, o lado do QA:

 customer_id |  full_name  |     tax_id     |            email            |       phone       | birth_date |   city    |  segment  | credit_limit |     created_at
-------------+-------------+----------------+-----------------------------+-------------------+------------+-----------+-----------+--------------+---------------------
          17 | Customer 17 | ***.***.***-** | br***********@example.com   | +55 11 ********** | 1900-01-01 | Santos    | corporate |      1401.00 | 2024-01-01 08:47:00
          34 | Customer 34 | ***.***.***-** | ca*************@example.com | +55 11 ********** | 1900-01-01 | Recife    | smb       |      2302.00 | 2024-01-01 17:34:00
          51 | Customer 51 | ***.***.***-** | di*************@example.com | +55 11 ********** | 1900-01-01 | Campinas  | retail    |      3203.00 | 2024-01-02 02:21:00
          68 | Customer 68 | ***.***.***-** | el***********@example.com   | +55 11 ********** | 1900-01-01 | Curitiba  | corporate |      4104.00 | 2024-01-02 11:08:00
          85 | Customer 85 | ***.***.***-** | fa**********@example.com    | +55 11 ********** | 1900-01-01 | Sao Paulo | smb       |      5005.00 | 2024-01-02 19:55:00

Mesmas chaves, cidades, segmentos, limites e datas de cadastro. Nome, documento, e-mail, telefone e data de nascimento sumiram. Um teste que filtra por cidade, agrupa por segmento ou soma limites de crédito dá a mesma resposta no QA e na amostra da origem.

Renovando a base

Rodamos o job uma segunda vez:

[05:29:59] INFO OK  Concluído: 588 lidos, 588 inseridos, 0 upsert/update em 0,2s  ·  read 0,0s / transform 0,0s / write 0,1s

As mesmas 588 linhas e os mesmos valores mascarados. A amostra não cresce: o ForceLoad esvazia a tabela antes. Isso torna a renovação repetível, então dá para agendar.

Agende

Linux (cron), todo domingo às 03:00. Guarde a chamada da API e a espera em um script que sai com código diferente de zero em caso de falha:

0 3 * * 0 /opt/jobs/qa-refresh.sh >> /var/log/qa-refresh.log 2>&1

Windows (Agendador de Tarefas): crie uma tarefa que roda dbSlice.exe qa-customers-sample.json sample.log. O Agendador lê o código de saída, então uma execução com falha aparece como tarefa com falha.

O que saber antes de usar

  • O ForceLoad apaga o destino. Aponte só para a tabela de QA. Confira a linha impacto no log.
  • O destino precisa existir. O dbSlice não cria a tabela num sync.
  • email: e keep: mantêm o tamanho do texto. Os * mostram o comprimento do original. Se isso importa para você, use template: ou hash:.
  • Máscara não é garantia legal. Ela reduz a exposição de dado pessoal no QA. Se atende a LGPD, GDPR ou à sua política interna, é decisão sua e do seu jurídico.

A série

"dbSlice CLI no dia a dia", quatro casos pela linha de comando:

  1. Conferir e Completar uma Migração Grande do SQL Server para o PostgreSQL pela Linha de Comando
  2. Colocar em Dia uma Réplica PostgreSQL Depois de uma Queda de Rede, pela Linha de Comando
  3. Corrigir Chaves Estrangeiras Quebradas Depois de Mensagens Perdidas na Fila, pela Linha de Comando
  4. Monte uma Base de QA Mascarada a partir de uma Amostra da Produção, pela Linha de Comando (este texto)

Também pela linha de comando: Copiar Só as Linhas que Faltam do SQL Server para o PostgreSQL pela Linha de Comando.

Fechando

Um JSON pequeno monta uma tabela de QA a partir de uma amostra da produção, com as colunas pessoais mascaradas e as chaves e colunas de negócio mantidas. A máscara roda na leitura, então o original nunca chega ao QA. O mesmo job renova a base, no terminal, no cron, no Agendador de Tarefas ou pela API. O job nunca leva senha.

O dbSlice é produto nosso, então leia com isso em mente. Experimente:

Experimente grátis na Microsoft Store ↗ Ver preços

← Voltar ao blog