Realize write-backs de banco de dados seguros com o Amazon QuickSight

AmazonQuickSight é uma solução de business intelligence (BI) escalonável, sem servidor e baseada em aprendizado de máquina (ML), que facilita a conexão com seus dados, a criação de painéis interativos, o acesso a insights habilitados para ML e o compartilhamento de recursos visuais e painéis com dezenas de milhares de pessoas de usuários internos e externos, dentro do próprio QuickSight ou incorporado em qualquer aplicativo.

Um write-back é a capacidade de atualizar um data mart, data warehouse ou qualquer outro back-end de banco de dados a partir dos painéis de BI e analisar os dados atualizados quase em tempo real no próprio painel. Nesta postagem, mostramos como realizar write-backs seguros de banco de dados com QuickSight.

Visão geral do caso de uso

Para demonstrar como habilitar um recurso de write-back com QuickSight, vamos considerar uma empresa fictícia, AnyCompany Inc. AnyCompany é uma empresa de serviços profissionais especializada em fornecer soluções de força de trabalho para seus clientes. A AnyCompany determinou que executar cargas de trabalho na nuvem para dar suporte às crescentes necessidades de negócios globais é uma vantagem competitiva e usa a nuvem para hospedar todas as suas cargas de trabalho. A AnyCompany decidiu aprimorar a forma como suas filiais fornecem orçamentos aos seus clientes. Atualmente, as filiais geram cotações de clientes manualmente e, como primeiro passo nesta jornada de inovação, a AnyCompany está procurando desenvolver uma solução empresarial para geração de cotações de clientes com a capacidade de aplicar dinamicamente dados de preços locais no momento da geração de cotações.

AnyCompany usa atualmente Amazon RedShift como plataforma de data warehouse empresarial e QuickSight como solução de BI.

Construir uma nova solução traz os seguintes desafios:

• A AnyCompany deseja uma solução que seja fácil de construir e manter e não quer investir na construção de uma interface de usuário separada.
• AnyCompany deseja estender os recursos de seu painel QuickSight BI existente para também permitir a geração e aceitação de cotações. Isso simplificará a implementação de recursos porque seus funcionários já usam painéis do QuickSight e aproveitam a interface fácil de usar que o QuickSight oferece.
• AnyCompany deseja armazenar o histórico de negociação de cotações que inclui cotações geradas, revisadas e aceitas.
• AnyCompany deseja construir um novo painel com dados históricos de cotações para análise e insights de negócios.

Esta postagem aborda as etapas para habilitar a funcionalidade de write-back do QuickSight para o Amazon Redshift. Observe que as ferramentas tradicionais de BI são somente leitura, com pouca ou nenhuma opção para atualizar os dados de origem.

Visão geral da solução

Esta solução usa os seguintes serviços AWS:

• Gateway de API da Amazon – Hospeda e protege a API REST de write-back que será invocada pelo QuickSight
• AWS Lambda – Executa a função de computação necessária para gerar o hash e uma segunda função para realizar o write-back com segurança
• AmazonQuickSight – Oferece painéis de BI e recursos de geração de cotações
• Amazon RedShift – Armazena cotações, preços e outros conjuntos de dados relevantes
• Gerenciador de segredos da AWS – Armazena e gerencia chaves para assinar hashes (resumo da mensagem)

Embora esta solução use o Amazon Redshift como armazenamento de dados, uma abordagem semelhante pode ser implementada com qualquer banco de dados que ofereça suporte à criação de funções definidas pelo usuário (UDFs) que possam invocar o Lambda.

A figura a seguir mostra o fluxo de trabalho para realizar write-backs do QuickSight.

A primeira etapa da solução é gerar um hash ou um resumo da mensagem do conjunto de atributos no Amazon Redshift invocando uma função Lambda. Esta etapa evita a adulteração da solicitação. Para gerar um hash, o Amazon Redshift invoca um UDF lambda escalar. O mecanismo de hashing usado aqui é o popular BLAKE2 função (disponível na biblioteca Python hashlib). Para proteger ainda mais o hash, é usado hashing com chave, que é uma alternativa mais rápida e simples para código de autenticação de mensagem baseado em hash (HMAC). Essa chave é gerada e armazenada pelo Secrets Manager e deve estar acessível apenas para aplicativos permitidos. Depois que o hash seguro for gerado, ele será retornado ao Amazon Redshift e combinado em uma visualização do Amazon Redshift.

A gravação da cotação gerada de volta no Amazon Redshift é executada pela função de write-back do Lambda, e um endpoint da API REST do API Gateway é criado para proteger e transmitir solicitações para a função de write-back. A função write-back executa as seguintes ações:

1. Gere o hash com base nos parâmetros de entrada da API recebidos do QuickSight.
2. Assine o hash aplicando a chave do Secrets Manager.
3. Compare o hash gerado com o hash recebido dos parâmetros de entrada usando o método compare_digest disponível no HMAC módulo.
4. Após a validação bem-sucedida, grave o registro na tabela de envio de cotações no Amazon Redshift.

A seção a seguir fornece etapas detalhadas com exemplos de cargas e trechos de código.

Gere o hash

O hash é gerado usando um Lambda UDF no Amazon Redshift. Além disso, uma chave do Secrets Manager é usada para assinar o hash. Para criar o hash, conclua as seguintes etapas:

1. Crie a chave do Secrets Manager a partir do Interface de linha de comando da AWS (AWS CLI):

aws secretsmanager create-secret --name “name_of_secret” --description "Secret key to sign hash" --secret-string '{" name_of_key ":"value"}' --region us-east-1

2. Crie um Lambda UDF para gerar um hash para criptografia:

import boto3 import base64
import json
from hashlib import blake2b
from botocore.exceptions import ClientError def get_secret(): #This key is used by the Lambda function to further secure the hash. secret_name = "<name_of_secret>" region_name = "<aws_region_name>" # Create a Secrets Manager client session = boto3.session.Session() client = session.client(service_name='secretsmanager', region_name=<aws_region_name> ) # In this sample we only handle the specific exceptions for the 'GetSecretValue' API. # See https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html # We rethrow the exception by default. try: get_secret_value_response = client.get_secret_value(SecretId=secret_name) except Exception as e: raise e if "SecretString" in get_secret_value_response: access_token = get_secret_value_response["SecretString"] else: access_token = get_secret_value_response["SecretBinary"] return json.loads(access_token)[<token key name>] SECRET_KEY = get_secret()
AUTH_SIZE = 16 def sign(payload): h = blake2b(digest_size=AUTH_SIZE, key=SECRET_KEY) h.update(payload) return h.hexdigest().encode('utf-8') def lambda_handler(event, context):
ret = dict() try: res = [] for argument in event['arguments']: try: msg = json.dumps(argument) signed_key = sign(str.encode(msg)) res.append(signed_key.decode('utf-8')) except: res.append(None) ret['success'] = True ret['results'] = res except Exception as e: ret['success'] = False ret['error_msg'] = str(e) return json.dumps(ret)

3. Defina uma UDF do Amazon Redshift para chamar a função Lambda para criar um hash:

CREATE OR REPLACE EXTERNAL FUNCTION udf_get_digest (par1 varchar)
RETURNS varchar STABLE
LAMBDA 'redshift_get_digest'
IAM_ROLE 'arn:aws:iam::<AWSACCOUNTID>role/service-role/<role_name>';

A Gerenciamento de acesso e identidade da AWS (IAM) na etapa anterior deve ter a seguinte política anexada para poder invocar a função Lambda:

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "lambda:InvokeFunction", "Resource": "arn:aws:lambda:us-east-1:<AWSACCOUNTID>1:function:redshift_get_digest" }
}

4. Obtenha a chave do Secrets Manager.

Essa chave é usada pela função Lambda para proteger ainda mais o hash. Isto está indicado no get_secret função na Etapa 2.

Configurar conjuntos de dados do Amazon Redshift no QuickSight

O painel de geração de cotação usa a seguinte visualização do Amazon Redshift.

Crie uma visualização do Amazon Redshift que use todas as colunas anteriores junto com a coluna hash:

create view quote_gen_vw as select *, udf_get_digest ( customername || BGCheckRequired || Skill|| Shift ||State ||Cost ) from billing_input_tbl

Os registros serão parecidos com a imagem a seguir.

A visualização anterior será usada como conjunto de dados QuickSight para gerar cotações. Uma análise QuickSight será criada usando o conjunto de dados. Para análise quase em tempo real, você pode usar o modo de consulta direta QuickSight.

Criar recursos do API Gateway

A operação de write-back é iniciada pelo QuickSight invocando um recurso do API Gateway, que invoca a função de write-back do Lambda. Como pré-requisito para criar o campo calculado no QuickSight para chamar a API de write-back, você deve primeiro criar esses recursos.

O API Gateway protege e invoca a função de write-back do Lambda com os parâmetros criados como parâmetros de string de consulta de URL com modelos de mapeamento. Os parâmetros de mapeamento podem ser evitados usando a integração do proxy Lambda.

Crie um recurso de API REST do tipo de método GET que usa funções Lambda (criadas na próxima etapa) como tipo de integração. Para obter instruções, consulte Criando uma API REST no Amazon API Gateway e Configurar integrações do Lambda no API Gateway.

A captura de tela a seguir mostra os detalhes para criar um parâmetro de string de consulta para cada parâmetro passado ao API Gateway.

A captura de tela a seguir mostra os detalhes para criar um parâmetro de modelo de mapeamento para cada parâmetro passado ao API Gateway.

Criar a função Lambda

Crie uma nova função do Lambda para ser invocada pelo API Gateway. A função Lambda executa as seguintes etapas:

1. Receba parâmetros do QuickSight por meio do API Gateway e faça hash dos parâmetros concatenados.

O exemplo de código a seguir recupera parâmetros da chamada do API Gateway usando o objeto de evento da função Lambda:

 customer= event['customer’]) bgc = event['bgc']

A função executa a lógica de hash conforme mostrado no criar hash etapa anterior usando os parâmetros concatenados passados ​​pelo QuickSight.

2. Compare a saída hash com o parâmetro hash.

Se não corresponderem, o write-back não acontecerá.

3. Se os hashes corresponderem, execute um write-back. Verifique a presença de um registro na tabela de geração de cotação gerando uma consulta na tabela usando os parâmetros passados ​​do QuickSight:

query_str = "select * From tbquote where cust = '" + cust + "' and bgc = '" + bgc +"'" +" and skilledtrades = '" + skilledtrades + "' and shift = '" +shift + "' and jobdutydescription ='" + jobdutydescription + "'"

4. Conclua a seguinte ação com base nos resultados da consulta:
   1. Se não existir nenhum registro para a combinação anterior, gere e execute uma consulta de inserção usando todos os parâmetros com o status gerado.
   2. Se existir um registro para a combinação anterior, gere e execute uma consulta de inserção com o status em revisão. O quote_Id da combinação existente será reutilizado.

Crie um visual do QuickSight

Esta etapa envolve a criação de um visual de tabela que usa um campo calculado para passar parâmetros ao API Gateway e invocar a função Lambda anterior.

1. Adicione um campo calculado do QuickSight chamado Gerar cotação para armazenar o URL hospedado no API Gateway que será acionado para gravar o histórico de cotações no Amazon Redshift:

concat("https://xxxxx.execute-api.us-east-1.amazonaws.com/stage_name/apiresourcename/?cust=",customername,"&bgc=",bgcheckrequired,"&billrate=",toString(billrate),"&skilledtrades=",skilledtrades,"&shift=",shift,"&jobdutydescription=",jobdutydescription,"&hash=",hashvalue)

2. Crie um visual de tabela QuickSight.
3. Adicione campos obrigatórios, como Cliente, Habilidade e Custo.
4. Adicione o campo calculado Gerar cotação e estilize-o como um hiperlink.

Escolher este link gravará o registro no Amazon Redshift. Isso depende do mesmo valor de hash retornado quando a função Lambda executa o hash nos parâmetros.

A captura de tela a seguir mostra um exemplo de visual de tabela.

Grave no banco de dados do Amazon Redshift

A chave do Secrets Manager é buscada e usada pela função Lambda para gerar o hash para comparação. O write-back será realizado somente se o hash corresponder ao hash passado no parâmetro.

A tabela do Amazon Redshift a seguir capturará o histórico de cotações preenchido pela função Lambda. Os registros em verde representam os registros mais recentes da cotação.

Considerações e próximos passos

O uso de hashes seguros evita a violação de parâmetros de carga visíveis na janela do navegador quando o URL de write-back é invocado. Para proteger ainda mais o URL de write-back, você pode empregar as seguintes técnicas:

• Implante a API REST em uma VPC privada acessível apenas para usuários do QuickSight.
• Para evitar ataques de repetição, um carimbo de data/hora pode ser gerado juntamente com a função de hashing e passado como um parâmetro adicional no URL de write-back. A função Lambda de back-end pode então ser modificada para permitir write-backs apenas dentro de um determinado limite baseado em tempo.
• Siga o API Gateway controle de acesso e segurança Melhores Práticas.
• Mitigar potencial negação de serviço para APIs voltadas ao público.

Você pode aprimorar ainda mais essa solução para renderizar um formulário baseado na Web quando o URL de write-back for aberto. Isso poderia ser implementado gerando dinamicamente um formulário HTML na função Lambda de backend para suportar a entrada de informações adicionais. Se sua carga de trabalho exigir um grande número de write-backs que exijam maior rendimento ou simultaneidade, um armazenamento de dados criado especificamente, como Edição compatível com Amazon Aurora PostgreSQL pode ser uma escolha melhor. Para obter mais informações, consulte Invocar uma função AWS Lambda de um cluster de banco de dados Aurora PostgreSQL. Essas atualizações podem então ser sincronizadas em tabelas do Amazon Redshift usando consultas federadas.

Conclusão

Esta postagem mostrou como usar o QuickSight junto com Lambda, API Gateway, Secrets Manager e Amazon Redshift para capturar dados de entrada do usuário e atualizar com segurança seu data warehouse do Amazon Redshift sem sair do ambiente QuickSight BI. Esta solução elimina a necessidade de criar um aplicativo externo ou interface de usuário para atualização de banco de dados ou operações de inserção e reduz a sobrecarga de desenvolvimento e manutenção relacionada. A chamada do API Gateway também pode ser protegida usando uma chave ou token para garantir que apenas as chamadas originadas do QuickSight sejam aceitas pelo API Gateway. Isso será abordado em postagens subsequentes.

Sobre os autores

Srikanth Baheti é arquiteto de soluções principais especializado em todo o mundo para Amazon QuickSight. Ele começou sua carreira como consultor e trabalhou para diversas organizações privadas e governamentais. Mais tarde, ele trabalhou na PerkinElmer Health and Sciences & eResearch Technology Inc, onde foi responsável por projetar e desenvolver aplicações web de alto tráfego, pipelines de dados altamente escaláveis ​​e de fácil manutenção para plataformas de relatórios usando serviços AWS e computação sem servidor.

Raji Sivasubramaniam é Arquiteto de Soluções Sênior na AWS, com foco em Analytics. Raji é especializado na arquitetura de soluções completas de Gerenciamento de Dados Corporativos, Business Intelligence e Analytics para empresas da Fortune 500 e Fortune 100 em todo o mundo. Ela tem uma experiência profunda em dados e análises de saúde integrados com uma ampla variedade de conjuntos de dados de saúde, incluindo mercado gerenciado, segmentação de médicos e análise de pacientes.

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoAiStream. Inteligência de Dados Web3. Conhecimento Amplificado. Acesse aqui.
• Cunhando o Futuro com Adryenn Ashley. Acesse aqui.
• Compre e venda ações em empresas PRE-IPO com PREIPO®. Acesse aqui.
• Fonte: https://aws.amazon.com/blogs/big-data/perform-secure-database-write-backs-with-amazon-quicksight/