Visualize os registros de auditoria do banco de dados MongoDB Atlas

Fuat Sungur11 min read • Published Oct 06, 2022 • Updated Jun 12, 2023

Atlas

Avalie esse Tutorial

O MongoDB Atlas tem recursos avançados de segurança, e os registros de auditoria são um deles. Simplificando, ativar os logs de auditoria em um Atlas cluster permite que você acompanhe o que aconteceu no banco de dados, por quem e quando.

Nesta publicação do blog, mostrará como visualizar os registros de auditoria do banco de dados do MongoDB Atlas com o MongoDB Atlas Charts.

Arquitetura de alto nível

Em Atlas App Services Values, foram definidas chaves públicas e privadas da API do Atlas Admin e ID de chave de acesso e acesso secreto da API do AWS.
O pacote de nó aws-sdk foi adicionado como uma dependência ao Atlas Functions.
O Atlas Data Federation foi configurado para executar query dos dados em um armazenamento em nuvem - Amazon S3 do bucket do Microsoft Blob Storage.
Atlas Function recupera as credenciais da API Atlas Admin e da API AWS .
A função Atlas chama a API Atlas Admin com as credenciais e outros parâmetros relevantes (intervalo de tempo para os logs de auditoria) e obtém os logs de auditoria compactados.
A Atlas Function carrega os logs de auditoria compactados como um arquivo zip em um bucket de armazenamento de objetos na nuvem onde o Atlas tem acesso de leitura.
O Atlas Charts visualiza os dados em S3 por meio do Atlas Data Federation.

Pré-requisitos

Os itens a seguir devem ser concluídos antes de trabalhar nas etapas.

Provisione um Atlas cluster em que o nível seja de pelo menos M10. O motivo para isso é que a auditoria não é suportada por clusters gratuitos (M0) e de camada compartilhada (M2, M5).
Você precisa configurar a auditoria de banco de dados no Atlas cluster em que deseja rastrear as atividades.
- No menu à esquerda do painel principal, na seção Segurança, selecione Avançado. Em seguida, alterne Auditoria de banco de dados e clique em Configurações de filtro de auditoria.
Por uma questão de simplicidade, marque Todas as ações a serem rastreadas em Configuração de auditoria, conforme mostrado na captura de tela abaixo.
Se você não tiver seu próprio gerador de carga para gerar carga no banco de dados e visualizar por meio do MongoDB Charts posteriormente, poderá revisar esse gerador de carga no Github desta postagem do blog.
Crie um aplicativo no Atlas App Services que implementará nossas funções dentro dele. Se você ainda não criou um aplicativo no Atlas App Services, siga este tutorial.
Crie uma conta AWS junto com as seguintes credenciais – AWS Access Key e AWS Secret Access Secret.
Defina um role AWS IAM que tenha privilégios para escrever no bucket de armazenamento de objetos na nuvem.
- Posteriormente, o Atlas assumirá essa função para fazer operações de gravação dentro do bucket S3 .

Etapa 1: configurar credenciais

A API de administração do Atlas permite automatizar seu ambiente do Atlas. Com um cliente REST, você pode executar uma ampla variedade de atividades de gerenciamento, como a recuperação de registros de auditoria.

Para utilizar a API de administração do Atlas, precisamos criar chaves e usar essas chaves posteriormente no Atlas Functions. Siga as instruções para criar uma chave API para seu projeto.

Criação de valores de serviços de aplicativos e segredos de serviços de aplicativos

Depois que você criar com êxito as chaves públicas e privadas para o Atlas, podemos armazenar as chaves da API do Atlas e as credenciais da Amazon Web Services em Valores e segredos do Atlas App Services.

Valores de App Services e Segredos de App Services são constantes estáticas do lado do servidor que você pode acessar ou vincular a partir de outros componentes do seu aplicativo.

Na parte seguinte, criaremos quatro valores do Atlas App Services e dois segredos do Atlas App Services para gerenciar as credenciais MongoDB Atlas da de administração do API e das Amazon Web Services credenciais . Para criar valores e segredos do Atlas App Services, navegue pelo seu App Services App e, no menu à esquerda, selecione Valores. Isso levará você a uma página que mostra os segredos e valores disponíveis em seu aplicativo do App Services.

Configurando credenciais da API Atlas Admin

Nesta seção, criaremos dois valores do Atlas App Services e um segredo do Atlas App Services para armazenar credenciais da API do Atlas Admin.

Valor 1: AtlasAdminAPIPublicKey

Este valor do Atlas App Services mantém o valor da chave pública da API de administrador do Atlas. Os valores devem ser colocados entre aspas duplas, conforme mostrado no exemplo a seguir.

1 secreto : AtlasAdminAPIPrivateKey

Este segredo do Atlas App Services mantém o valor da chave privada da API de administrador do Atlas. Você não deve envolver o segredo entre aspas.

Valor 2: AtlasAdminAPIPrivateKeyLinkToSecret

Não podemos acessar segredos diretamente em nossas funções do Atlas. É por isso que temos que criar um novo valor e vinculá-lo ao segredo que contém nossa chave privada.

Até agora, definimos os valores necessários do App Services e os segredos do Atlas App Services para acessar a API do Atlas a partir de um App Services App.

Para acessar nosso bucket S3 , precisamos utilizar o AWS SDK. Portanto, precisamos fazer uma configuração semelhante para as chaves do AWS SDK.

Configurando credenciais AWS

Nesta seção, criaremos dois App Services Values e um App Services Secret para armazenar as credenciais do AWS. Saiba como obter suas credenciais do AWS.

Value 3: AWSAccessKeyId

Este valor do Atlas App Services mantém o valor do ID da chave de acesso do AWS SDK.

2 secreto : AWSSecretAccessKey

Este segredo do Atlas App Services mantém o valor da chave de acesso secreta do AWS SDK.

Valor 4: AWSSecretAccessKeyLinkToSecret

Esse valor do Atlas App Services mantém o link do Atlas App Services Secret que mantém a chave secreta do AWS SDK.

E depois de ter todos esses valores e segredos, conforme mostrado abaixo, você pode implantar as alterações para torná-lo permanente.

Etapa 2: adicionando uma dependência externa

Uma dependência externa é uma biblioteca externa que inclui lógica que você prefere não implementar, como análise de string de caracteres, funções de conveniência para manipulações de array e implementações de estrutura de dados ou algoritmo. Você pode carregar dependências externas do repositórionpm para Atlas App Services e, em seguida, importar essas bibliotecas para suas funções com uma declaraçãorequire('external-module').

Para trabalhar com Amazon Web Services S3, adicionaremos o pacote oficial npm do aws-sdk.

Em seu App Services App, no menu do lado esquerdo, navegue até Funções. Em seguida, navegue até o painel Dependências nesta página.

Para trabalhar com o AWS S3, adicionaremos o pacote oficial aws-sdk npm.

Em seu App Services App, no menu do lado esquerdo, navegue até Funções.Em seguida, navegue até o painelDependências nesta página.

Clique em Adicionar dependência.

Forneça aws-sdk como o nome do pacote e mantenha a versão do pacote vazia. Isso instalará a versão mais recente do pacote do nó aws-sdk.

Agora, o pacoteaws-sdk está pronto para ser usado em nosso aplicativo Atlas App Services.

Etapa 3: configurar o Atlas Data Federation para consumir dados de armazenamento de objetos na nuvem por meio da linguagem de query do MongoDB (MQL)

Neste tutorial, não Go todas as etapas para criar uma instância do banco de dados federado no Atlas. Confira nossos recursos do Atlas Data Federation para Go por todas as etapas para criar a Atlas Data Atlas .

Como resultado desta etapa, esperaremos uma Instância de Banco de Dados Federada pronta, conforme mostrado abaixo.

Já adicionei o bucket S3 (o nome do bucket é fuat-sungur-bucket) que possuo a essa Instância do Banco de Dados Federado como fonte de dados e criei a collection auditlogscolection dentro do banco de dados auditlogs nesta Instância do Banco de Dados Federado .

Agora, se eu tiver os arquivos neste bucket S3 (fuat-sungur-bucket), poderei consultá-los usando a estrutura de agregação do MongoDB ou Atlas SQL.

Etapa 4: criar uma função Atlas para recuperar credenciais dos Valores e Segredos do Atlas App Services

Vamos criar uma função do Atlas, dar-lhe o nome de RetrieveAndUploadAuditLogse escolher Sistema para autenticação.

Também fornecemos o seguinte fragmento de código no Editor de funções e executamos a função. Veremos que as credenciais foram impressas no console.

Trecho de código

Etapa 5: recuperando registros de auditoria na Atlas Function

Agora continuamos a aprimorar nossa função Atlas existente, RetrieveAndUploadAuditLogs. Agora, executaremos a solicitação HTTP/S para recuperar logs de auditoria na função Atlas.

O código a seguir gera uma solicitação HTTP GET, chama o recurso relevante da API Atlas Admin para recuperar os registros de auditoria em 1440 minutos e converte esses dados de auditoria compactados na classe Buffer em JavaScript.

Trecho de código

exports = async function(){
    const atlasAdminAPIPublicKey = context.values.get("AtlasAdminAPIPublicKey");
    const atlasAdminAPIPrivateKey = context.values.get("AtlasAdminAPIPrivateKeyLinkToSecret");
  
   const awsAccessKeyID = context.values.get("AWSAccessKeyID")
   const awsSecretAccessKey = context.values.get("AWSSecretAccessKeyLinkToSecret")
  
   console.log(`Atlas Public + Private Keys: ${atlasAdminAPIPublicKey}, ${atlasAdminAPIPrivateKey}`)
   console.log(`AWS Access Key ID + Secret Access Key: ${awsAccessKeyID}, ${awsSecretAccessKey}`)
  
    //////////////////////////////////////////////////////////////////////////////////////////////////
  
   // Atlas Cluster information
   const groupId = '5ca48430014b76f34448bbcf';
   const host = "exchangedata-shard-00-01.5tka5.mongodb.net";
   const logType = "mongodb-audit-log"; // the other option is "mongodb" -> that allows you to download database logs
    // defining startDate and endDate of Audit Logs
   const endDate = new Date();
   const durationInMinutes = 20;
   const durationInMilliSeconds = durationInMinutes * 60 * 1000
   const startDate = new Date(endDate.getTime()-durationInMilliSeconds)
  
   const auditLogsArguments = {
     scheme: 'https',
     host: 'cloud.mongodb.com',
     path: `api/atlas/v1.0/groups/${groupId}/clusters/${host}/logs/${logType}.gz`,
     username: atlasAdminAPIPublicKey,
     password: atlasAdminAPIPrivateKey,
     headers: {'Content-Type': ['application/json'], 'Accept-Encoding': ['application/gzip']},
     digestAuth:true,
     query: {
     "startDate": [Math.round(startDate / 1000).toString()],
     "endDate": [Math.round(endDate / 1000).toString()]
   }
   };
  
   console.log(`Arguments:${JSON.stringify(auditLogsArguments)}`)
  
   const response = await context.http.get(auditLogsArguments)
   auditData = response.body;
   console.log("AuditData:"+(auditData))
   console.log("JS Type:" + typeof auditData)
    // convert it to base64 and then Buffer
   var bufferAuditData = Buffer.from(auditData.toBase64(),'base64')
   console.log("Buffered Audit Data" + bufferAuditData)
 }

Etapa 6: carregando dados de auditoria no bucket S3

Até agora, em nossa Atlas Function, recuperamos os registros de auditoria com base no intervalo determinado e agora enviaremos esses dados para o bucket S3 como um arquivo zip.

Primeiro, importamos a bibliotecaaws-sdk NodeJS e, em seguida, configuramos as credenciais para o AWS S3. Já recuperamos as credenciais da AWS de Atlas App Services e Atlas App Services e as atribuímos a variáveis de função.

Depois disso, configuramos parâmetros relacionados ao S3 , nome do bucket, chave (pasta e nome do arquivo) e corpo (carga útil real que é nosso arquivo zip de auditoria armazenado em um tipo de dados Buffer Javascript). E, finalmente, executamos nosso comando de upload (S3.putObject()).

Aqui você pode encontrar todo o código da função:

Trecho de código

exports = async function(){
    const atlasAdminAPIPublicKey = context.values.get("AtlasAdminAPIPublicKey");
   const atlasAdminAPIPrivateKey = context.values.get("AtlasAdminAPIPrivateKeyLinkToSecret");
  
   const awsAccessKeyID = context.values.get("AWSAccessKeyID")
   const awsSecretAccessKey = context.values.get("AWSSecretAccessKeyLinkToSecret")
  
   console.log(`Atlas Public + Private Keys: ${atlasAdminAPIPublicKey}, ${atlasAdminAPIPrivateKey}`)
   console.log(`AWS Access Key ID + Secret Access Key: ${awsAccessKeyID}, ${awsSecretAccessKey}`)
  
    //////////////////////////////////////////////////////////////////////////////////////////////////
  
   // Atlas Cluster information
   const groupId = '5ca48430014b76f34448bbcf';
   const host = "exchangedata-shard-00-01.5tka5.mongodb.net";
   const logType = "mongodb-audit-log"; // the other option is "mongodb" -> that allows you to download database logs
    // defining startDate and endDate of Audit Logs
   const endDate = new Date();
   const durationInMinutes = 20;
   const durationInMilliSeconds = durationInMinutes * 60 * 1000
   const startDate = new Date(endDate.getTime()-durationInMilliSeconds)
  
   const auditLogsArguments = {
     scheme: 'https',
     host: 'cloud.mongodb.com',
     path: `api/atlas/v1.0/groups/${groupId}/clusters/${host}/logs/${logType}.gz`,
     username: atlasAdminAPIPublicKey,
     password: atlasAdminAPIPrivateKey,
     headers: {'Content-Type': ['application/json'], 'Accept-Encoding': ['application/gzip']},
     digestAuth:true,
     query: {
     "startDate": [Math.round(startDate / 1000).toString()],
     "endDate": [Math.round(endDate / 1000).toString()]
   }
   };
  
   console.log(`Arguments:${JSON.stringify(auditLogsArguments)}`)
  
   const response = await context.http.get(auditLogsArguments)
   auditData = response.body;
   console.log("AuditData:"+(auditData))
   console.log("JS Type:" + typeof auditData)
    // convert it to base64 and then Buffer
   var bufferAuditData = Buffer.from(auditData.toBase64(),'base64')
   console.log("Buffered Audit Data" + bufferAuditData)
    // uploading into S3 
  
   const AWS = require('aws-sdk');
  
   // configure AWS credentials
   const config = {
     accessKeyId: awsAccessKeyID,
     secretAccessKey: awsSecretAccessKey
   };
  
   // configure S3 parameters 
   const fileName= `auditlogs/auditlog-${new Date().getTime()}.gz`
   const S3params = {
     Bucket: "fuat-sungur-bucket",
     Key: fileName,
     Body: bufferAuditData
   };
   const S3 = new AWS.S3(config);
    // create the promise object
   const s3Promise = S3.putObject(S3params).promise();
  
   s3Promise.then(function(data) {
     console.log('Put Object Success');
     return { success: true }
   }).catch(function(err) {
     console.log(err);
     return { success: false, failure: err }
   });
  };

Depois de executarmos a Atlas Function, podemos conferir o bucket S3 e verificar se o arquivo de auditoria compactado foi carregado.

Você pode encontrar todo o código das funções do Atlas no repositório dedicado do Github.

Etapa 7: visualizando dados de auditoria no MongoDB Charts

Primeiro, precisamos adicionar nossa Instância de banco de dados federado que criamos na Etapa 4 ao nosso aplicativo Atlas Charts que criamos na seção de pré-requisitos como uma fonte de dados. Essa Instância de banco de dados federado nos permite executar consultas com a estrutura de agregação do MongoDB nos dados que estão no armazenamento de objetos na cloud (que é S3, neste caso).

Antes de fazer qualquer coisa com o Atlas Charts, vamos nos conectar à instância de banco de dados federado e consultar os registros de auditoria para garantir que já tenhamos estabelecido o pipeline de dados corretamente.

Trecho de código

Agora podemos obter um registro do auditlogscollection.

Trecho de código

AtlasDataFederation auditlogs> db.auditlogscollection.findOne()
{
  atype: 'authCheck',
  ts: ISODate("2022-08-24T17:42:44.435Z"),
  uuid: UUID("f5fb1c0a-399b-4308-b67e-732254828d17"),
  local: { ip: '192.168.248.180', port: 27017 },
  remote: { ip: '192.168.248.180', port: 44072 },
  users: [ { user: 'mms-automation', db: 'admin' } ],
  roles: [
    { role: 'backup', db: 'admin' },
    { role: 'clusterAdmin', db: 'admin' },
    { role: 'dbAdminAnyDatabase', db: 'admin' },
    { role: 'readWriteAnyDatabase', db: 'admin' },
    { role: 'restore', db: 'admin' },
    { role: 'userAdminAnyDatabase', db: 'admin' }
  ],
  param: {
    command: 'find',
    ns: 'local.clustermanager',
    args: {
      find: 'clustermanager',
      filter: {},
      limit: Long("1"),
      singleBatch: true,
      sort: {},
      lsid: { id: UUID("f49d243f-9c09-4a37-bd81-9ff5a2994f05") },
      '$clusterTime': {
        clusterTime: Timestamp({ t: 1661362964, i: 1 }),
        signature: {
          hash: Binary(Buffer.from("1168fff7240bc852e17c04e9b10ceb78c63cd398", "hex"), 0),
          keyId: Long("7083075402444308485")
        }
      },
      '$db': 'local',
      '$readPreference': { mode: 'primaryPreferred' }
    }
  },
  result: 0
}
AtlasDataFederation auditlogs>

Vamos verificar o registro de auditoria de uma operação de atualização.

Trecho de código

AtlasDataFederation auditlogs> db.auditlogscollection.findOne({atype:"authCheck", "param.command":"update", "param.ns": "audit_test.orders"})
{
  atype: 'authCheck',
  ts: ISODate("2022-08-24T17:42:44.757Z"),
  uuid: UUID("b7115a0a-c44c-4d6d-b007-a67d887eaea6"),
  local: { ip: '192.168.248.180', port: 27017 },
  remote: { ip: '91.75.0.56', port: 22787 },
  users: [ { user: 'main_user', db: 'admin' } ],
  roles: [
    { role: 'atlasAdmin', db: 'admin' },
    { role: 'backup', db: 'admin' },
    { role: 'clusterMonitor', db: 'admin' },
    { role: 'dbAdminAnyDatabase', db: 'admin' },
    { role: 'enableSharding', db: 'admin' },
    { role: 'readWriteAnyDatabase', db: 'admin' }
  ],
  param: {
    command: 'update',
    ns: 'audit_test.orders',
    args: {
      update: 'orders',
      updates: [
        { q: { _id: 3757 }, u: { '$set': { location: '7186a' } } }
      ],
      ordered: true,
      writeConcern: { w: 'majority' },
      lsid: { id: UUID("a3ace80b-5907-4bf4-a917-be5944ec5a83") },
      txnNumber: Long("509"),
      '$clusterTime': {
        clusterTime: Timestamp({ t: 1661362964, i: 2 }),
        signature: {
          hash: Binary(Buffer.from("1168fff7240bc852e17c04e9b10ceb78c63cd398", "hex"), 0),
          keyId: Long("7083075402444308485")
        }
      },
      '$db': 'audit_test'
    }
  },
  result: 0
}

Se pudermos ver alguns registros, isso será ótimo. Agora podemos construir nosso painel no Atlas Charts.

Você pode importar esse dashboard para seu aplicativo Atlas Charts. Talvez seja necessário configurar o nome da fonte de dados para o Atlas Charts para sua conveniência. No painel fornecido, a fonte de dados era uma collection com o nome auditlogcollection nos auditlogs de banco de dados na Atlas Federated Database Instance com o nome FederatedDatabaseInstance0, conforme mostrado abaixo.

Caveats

Os tópicos a seguir podem ser considerados para uma análise de log de auditoria mais eficaz e eficiente.

Você pode recuperar registros de todos os hosts em vez de um nó.
- Portanto, você pode rastrear as modificações de dados mesmo no caso de falhas no nó primário.
Considere rastrear apenas as atividades relevantes em vez de rastrear todas as atividades no banco de dados. O rastreamento de todas as atividades no banco de dados pode afetar o desempenho.
Você pode agendar seus triggers.
- A Atlas Function no exemplo é executada uma vez manualmente, mas pode ser agendada por meio dos scheduled triggers do Atlas.
  - Em seguida, os intervalos de datas (hora de início e término) para os logs de auditoria de cada execução precisam ser calculados corretamente.
Você pode melhorar a eficiência de leitura.
- Você pode considerar o particionamento no bucket S3 pelos campos filtrados com mais frequência. Para obter mais informações, verifique a documentação sobre como otimizar o desempenho da query.

Resumo

O MongoDB Atlas não é apenas uma plataforma de banco de dados como serviço para executar suas cargas de trabalho do MongoDB. Ele também fornece uma grande variedade de componentes para criar soluções de ponta a ponta. Neste blog post, exploramos alguns dos recursos do Atlas, como App Services, Atlas Charts e Atlas Data Federation, e observamos como os utilizamos para criar um cenário do mundo real.

Dúvidas sobre este tutorial? Considerações, comentários? Participe da conversa nos fóruns daMongoDB Community !

Avalie esse Tutorial

Relacionado

Tutorial

Desenvolvimento sem servidor com Kotlin, AWS Lambda e MongoDB Atlas

Aug 01, 2023 | 6 min read

Tutorial

Consulta flexível com Atlas Search

Jul 12, 2024 | 3 min read

exemplo de código

myLeG

Jul 07, 2022 | 1 min read

Artigo

Modelagem de dados e design de esquema para o Atlas Search

Sep 04, 2024 | 23 min read

Sumário

Arquitetura de alto nível
Pré-requisitos
Etapa 1: configurar credenciais
Etapa 2: adicionando uma dependência externa
Etapa 3: configurar o Atlas Data Federation para consumir dados de armazenamento de objetos na nuvem por meio da linguagem de query do MongoDB (MQL)
Etapa 4: criar uma função Atlas para recuperar credenciais dos Valores e Segredos do Atlas App Services
Etapa 5: recuperando registros de auditoria na Atlas Function
Etapa 6: carregando dados de auditoria no bucket S3
Etapa 7: visualizando dados de auditoria no MongoDB Charts
Caveats
Resumo