Pausar automaticamente clusters inativos

Brian Leonard10 min read • Published Jan 19, 2022 • Updated Sep 09, 2024

Atlas

Avalie esse Artigo

Some features mentioned below will be deprecated on Sep. 30, 2025. Learn more.

A couple of years ago I wrote an article on how to pause and/or scale clusters using scheduled triggers. This article represents a twist on that concept, adding a wrinkle that will pause clusters across an entire organization based on inactivity. Specifically, I’m looking at the Database Access History to determine activity.

É importante observar esta limitação de registro:

Se um cluster experimentar um pico de atividade e gerar uma quantidade extremamente grande de mensagens de log, o Atlas poderá parar de coletar e armazenar novos logs por um período de tempo.

Portanto, esse script pode dar um falso positivo de que um cluster está inativo quando, na verdade, acontece exatamente o oposto. Dado, no entanto, que a intenção desse script é gerenciar ambientes inferiores, que não são de produção, não vejo os falsos positivos como uma grande preocupação.

Arquitetura

A implementação usa um trigger. O trigger chama uma série de Atlas App Services, que usam as Atlas API para iterar sobre os projetos da organização e seus clusters associados, testando a inatividade do cluster (conforme explicado na introdução) e, finalmente, pausando o cluster se ele estiver realmente inativo.

Chaves de API

Para chamar as API Administrativas do Atlas, primeiro você precisará de uma API Key com o roleProprietário da Organização. As API Keys são criadas no Access Manager, que você encontrará no menu Organização à esquerda:

ou na barra de menu na parte superior:

Clique em Criar chave de API. Dê uma descrição à chave e certifique-se de definir as permissões para Proprietário da organização:

Ao clicar em Avançar, você verá suas chaves Públicas e Privadas. Salve sua chave privada , pois o Atlas nunca mais a mostrará a você.

Como uma camada adicional de segurança, você também tem a opção de definir uma lista de acesso IP para essas chaves. Estou pulando esta etapa, para que minha chave funcione de qualquer lugar.

Implantação

Crie um projeto para automação

Como essa solução funciona em toda a sua organização do Atlas, eu gosto de hospedá-la em seu próprio projeto do Atlas dedicado.

Criar um aplicativo do App Services.

O Atlas App Services fornece um poderoso backend de desenvolvimento de aplicativos como serviço. Para começar a usá-lo, basta clicar na aba App Services.

Você verá que o App Services oferece vários modelos para você começar. Para esse caso de uso, basta selecionar a primeira opção para Criar seu próprio aplicativo:

Em seguida, você verá opções para vincular uma fonte de dados, nomear seu aplicativo e escolher um modelo de implantação. A iteração atual desse utilitário não usa uma fonte de dados, então você pode ignorar essa etapa (o App Services criará um cluster gratuito para você). Você também pode deixar o modelo de implantação como padrão (Global), a menos que queira limitar o aplicativo a uma região específica.

Dei o nome de Atlas Cluster Automation ao aplicativo:

Nessa situação, você tem duas opções:

Basta importar o aplicativo App Services e ajustar qualquer uma das funções para atender às suas necessidades.
Crie o aplicativo do zero (pule para a próxima seção).

Importar opção

Etapa 1: armazene a chave secreta da API.

A extração depende da chave secreta da API, portanto, a importação falhará se ela não for configurada previamente.

Use o menuValues à esquerda para Criar um Segredo chamado AtlasPrivateKeySecret contendo a chave privada que você criou anteriormente (o segredo não está entre aspas):

Etapa 1: Instale a CLI do Atlas App Services (realm-cli)

O Realm CLI está disponível em npm. Para instalar a versão 2 da Realm CLI no seu sistema, verifique se o Node.jsestá instalado e execute o seguinte comando no shell:

npm install -g mongodb-realm-cli

Etapa 2: extraia o arquivo do aplicativo

Baixe e extraia o AtlasClusterAutomation.zip.

Etapa 3: faça login no Atlas

Para configurar seu aplicativo com o realm-cli, você deve se conectar ao Atlas usando suas chaves de API:

Trecho de código

Etapa 4: Obtenha a IDdo aplicativo Atlas App Services

Selecione o App Settings e copie o ID do seu aplicativo:

ID do aplicativo

Etapa 5: importe o aplicativo

Execute o seguinte realm-cli push comando no diretório em que você extraiu a exportação:

Trecho de código

Após a importação, substitua o `AtlasPublicKey' pelo valor da chave pública da sua API.

Revise o aplicativo importado

O aplicativo importado inclui 5 Atlas Functions:

E o Trigger Agendado que chama a funçãopausaInactiveClusters:

O trigger está programado para disparar a cada 30 minutos. Observe que a funçãopausaClusters que o trigger chama atualmente apenas registra a atividade do cluster. Isso é para que você possa monitorar e verificar se a função se comporta conforme o desejado. Quando estiver pronto, descomente a linha que chama a funçãopausaCluster:

Trecho de código

Além disso, a funçãopauseClusters pode ser configurada para excluir projetos (como os dedicados a cargas de trabalho de produção):

Trecho de código

Agora que você revisou o rascunho, como etapa final, implante o aplicativo do App Services.

Revisar rascunho e implantar

Opção "construa você mesmo"

Para entender o que está incluído no aplicativo, estas são as etapas para criá-lo do zero.

Etapa 1: armazene as chaves de API

As funções que precisamos criar chamarão a API de administração do Atlas, portanto, precisamos armazenar nossas chaves públicas e privadas de API, o que vamos fazer usando Valores e segredos. O código de amostra que forneço referência a esses valores como AtlasPublicKey e AtlasPrivateKey, portanto, use esses mesmos nomes, a menos que queira alterar o código em que eles são referenciados.

Você encontrará Values no menu Build:

Primeiro, crie um Valor, AtlasPublicKey, para sua chave pública (observe que a chave está entre aspas):

Crie um Segredo, AtlasPrivateKeySecret, contendo sua chave privada (o segredo não está entre aspas):

O Segredo não pode ser acessado diretamente, portanto, crie um segundo Valor, AtlasPrivateKey, que se vincule ao segredo:

Etapa 2: crie as funções

As quatro funções que precisam ser criadas são auto-explicativas, então não vamos fornecer um monte de explicações adicionais aqui.

getProjects

Essa função autônoma pode ser testada no console do App Services para ver a lista de todos os projetos da sua organização.

Trecho de código

/*
 * Returns an array of the projects in the organization
 * See https://docs.atlas.mongodb.com/reference/api/project-get-all/
 *
 * Returns an array of objects, e.g.
 *
 * {
 * "clusterCount": {
 *      "$numberInt": "1"
 *    },
 *    "created": "2021-05-11T18:24:48Z",
 *    "id": "609acbef1b76b53fcd37c8e1",
 *    "links": [
 *      {
 *        "href": "https://cloud.mongodb.com/api/atlas/v1.0/groups/609acbef1b76b53fcd37c8e1",
 *        "rel": "self"
 *      }
 *    ],
 *    "name": "mg-training-sample",
 *    "orgId": "5b4e2d803b34b965050f1835"
 *  }
  *
 */
exports = async function() {
  
  // Get stored credentials...
  const username = await context.values.get("AtlasPublicKey");
  const password = await context.values.get("AtlasPrivateKey");
  
  const arg = { 
    scheme: 'https', 
    host: 'cloud.mongodb.com', 
    path: 'api/atlas/v1.0/groups', 
    username: username, 
    password: password,
    headers: {'Content-Type': ['application/json'], 'Accept-Encoding': ['bzip, deflate']}, 
    digestAuth:true,
  };
  
  // The response body is a BSON.Binary object. Parse it and return.
  response = await context.http.get(arg);

return EJSON.parse(response.body.text()).results; 
};

getProjectClusters

Depois quegetProjects é chamado, o trigger itera sobre os resultados, passando o projectId para essa funçãogetProjectClusters.

Para testar essa função, você precisa fornecer um projectId. Por padrão, o console fornece "Hello world!", portanto, testo essa entrada e forneço alguns valores padrão para facilitar o teste.

Trecho de código

/*
 * Returns an array of the clusters for the supplied project ID.
 * See https://docs.atlas.mongodb.com/reference/api/clusters-get-all/
 *
 * Returns an array of objects. See the API documentation for details.
 * 
 */
exports = async function(project_id) {
  
  if (project_id == "Hello world!") { // Easy testing from the console
    project_id = "5e8f8268d896f55ac04969a1"
  }
  
  // Get stored credentials...
  const username = await context.values.get("AtlasPublicKey");
  const password = await context.values.get("AtlasPrivateKey");
  
  const arg = { 
    scheme: 'https', 
    host: 'cloud.mongodb.com', 
    path: `api/atlas/v1.0/groups/${project_id}/clusters`, 
    username: username, 
    password: password,
    headers: {'Content-Type': ['application/json'], 'Accept-Encoding': ['bzip, deflate']}, 
    digestAuth:true,
  };
  
  // The response body is a BSON.Binary object. Parse it and return.
  response = await context.http.get(arg);

return EJSON.parse(response.body.text()).results; 
};

clusterIsActive

Essa função contém a lógica que determina se o cluster pode ser pausado.

A maior parte do trabalho nessa função é manipular o carimbo de data/hora no log de acesso ao banco de dados para que ele possa ser comparado com a hora atual e a janela de lookback.

Além de retornar verdadeiro (ativo) ou falso (inativo), a função registra suas descobertas, por exemplo:

Checking if cluster 'SA-SHARED-DEMO' has been active in the last 60 minutes

Trecho de código

Como getClusterProjects, há um bloco que você pode usar para fornecer alguns ID de projeto de teste e nomes de cluster para facilitar o teste no console do App Services.

Trecho de código

/*
 * Used the database access history to determine if the cluster is in active use.
 * See https://docs.atlas.mongodb.com/reference/api/access-tracking-get-database-history-clustername/
 * 
 * Returns true (active) or false (inactive)
 * 
 */
exports = async function(project_id, clusterName, minutes) {
  
  if (project_id == 'Hello world!') { // We're testing from the console
    project_id = "5e8f8268d896f55ac04969a1";
    clusterName = "SA-SHARED-DEMO";
    minutes = 60;
  } /*else {
    console.log (`project_id: ${project_id}, clusterName: ${clusterName}, minutes: ${minutes}`)
  }*/
  
  // Get stored credentials...
  const username = await context.values.get("AtlasPublicKey");
  const password = await context.values.get("AtlasPrivateKey");
  
  const arg = { 
    scheme: 'https', 
    host: 'cloud.mongodb.com', 
    path: `api/atlas/v1.0/groups/${project_id}/dbAccessHistory/clusters/${clusterName}`, 
    //query: {'authResult': "true"},
    username: username, 
    password: password,
    headers: {'Content-Type': ['application/json'], 'Accept-Encoding': ['bzip, deflate']}, 
    digestAuth:true,
  };
  
  // The response body is a BSON.Binary object. Parse it and return.
  response = await context.http.get(arg);
  
  accessLogs = EJSON.parse(response.body.text()).accessLogs;

now = Date.now();
  const MS_PER_MINUTE = 60000;
  var durationInMinutes = (minutes < 30, 30, minutes);   // The log granularity is 30 minutes.
  var idleStartTime = now - (durationInMinutes * MS_PER_MINUTE);
  
  nowString = new Date(now).toString();
  idleStartTimeString = new Date(idleStartTime).toString();
  console.log(`Checking if cluster '${clusterName}' has been active in the last ${durationInMinutes} minutes`)
  console.log(`   ${nowString} - job is being run`);
  console.log(`   ${idleStartTimeString} - cluster inactivity before this time will be reported inactive`);
  
  clusterIsActive = false;
  
  accessLogs.every(log => {
    if (log.username != 'mms-automation' && log.username != 'mms-monitoring-agent') {
      
      // Convert string log date to milliseconds 
      logTime = Date.parse(log.timestamp);

logTimeString = new Date(logTime);
      console.log(`   ${logTimeString} - last logged database access`);
      
      var elapsedTimeMins = Math.round((now - logTime)/MS_PER_MINUTE, 0);
      
      if (logTime > idleStartTime ) {
        console.log(`Cluster is Active: Username '${log.username}' was active in cluster '${clusterName}' ${elapsedTimeMins} minutes ago.`);
        clusterIsActive = true;
        return false;
      } else {
        // The first log entry is older than our inactive window
        console.log(`Cluster is Inactive: Username '${log.username}' was active in cluster '${clusterName}' ${elapsedTimeMins} minutes ago.`);
        clusterIsActive = false;
        return false;
      }
    }
    return true;

});

return clusterIsActive;

};

pauseCluster

Por fim, se o cluster estiver inativo, passamos o ID do projeto e o nome do cluster para pauseCluster. Essa função também pode retomar um cluster, embora esse recurso não seja utilizado neste caso de uso.

Trecho de código

pauseInactiveClusters

Esta função será chamada por um trigger. Como não é possível passar um parâmetro para um gatilho agendado, ele usa uma janela de retrospectiva codificada de 60 minutos que você pode alterar para atender às suas necessidades. Você pode até armazenar o valor em um banco de dados do Atlas e construir uma interface do usuário para gerenciar sua configuração :-).

A função avaliará todos os projetos e clusters na organização em que está hospedada. Entendendo que há prováveis projetos ou clusters que você nunca quer pausado, a função também inclui uma array excludeProjects, onde você pode especificar uma lista de nomes de projetos a serem excluídos da avaliação.

Por fim, você notará que a chamada para pauseCluster foi comentada. Sugiro que você execute essa função por alguns dias e analise os logs do Trigger para verificar se ela se comporta como esperado.

Trecho de código

/*
 * Iterates over the organizations projects and clusters, 
 * pausing clusters inactive for the configured minutes.
 */
exports = async function() {
  
  minutesInactive = 60;
  
  /*
   * These project names are just an example. 
   * The same concept could be used to exclude clusters or even 
   * configure different inactivity intervals by project or cluster.
   * These configuration options could also be stored and read from 
   * and Atlas database.
   */
  excludeProjects = ['PROD1', 'PROD2'];   
  
  const projects = await context.functions.execute("getProjects");
  
  projects.forEach(async project => {
    
    if (excludeProjects.includes(project.name)) {
      console.log(`Project '${project.name}' has been excluded from pause.`)
    } else {
      
      console.log(`Checking project '${project.name}'s clusters for inactivity...`);

return true;
};

Etapa 3: Criar o gatilho programado

Sim, ainda estamos usando um scheduled trigger, mas desta vez o trigger será executado periodicamente para verificar se há inatividade do cluster. Agora, seus desenvolvedores que trabalham tarde da noite não terão mais o cluster pausado abaixo deles.

Etapa 4: Implementar

Como uma etapa final, você precisa implantar o aplicativo Atlas App Services.

Resumo

A gênese deste artigo foi que um cliente, quando apresentado meu artigo anterior sobre agendamento de pausas de cluster, perguntou se o mesmo poderia ser alcançado com base na inatividade. É minha confiança que, com as APIs do Atlas, tudo pode ser alcançado. A única questão era o que constitui inatividade? Dado o batimento cardíaco e a replicação que ocorrem naturalmente, sempre há algum "activity" no cluster. Por fim, decidi pelo acesso ao banco de dados como guia. Com o tempo, essa métrica pode ser combinada com algumas métricas adicionais ou alterada para algo completamente diferente, mas os ossos do processo estão aqui.

Avalie esse Artigo

Relacionado

Podcast

Série de automação de banco de dados – Índices automatizados

Sep 05, 2023 | 23 min

Início rápido

Começando com o Atlas e a API de consulta do MongoDB

Feb 13, 2023 | 11 min read

Tutorial

MongoDB Charts incorporando SDK com React

Sep 09, 2024 | 5 min read

Tutorial

Chamando a API de administração do MongoDB Atlas: como fazer isso usando Node, Python e Ruby

Jun 18, 2024 | 4 min read