Menu Docs
Página inicial do Docs
/
MongoDB Shell

Escrever scripts

Nesta página

  • Compatibilidade
  • Executar um arquivo JavaScript
  • Execute um script de dentro do mongosh
  • Executar um script a partir da linha de comando
  • Execute um script na linha de comando com autenticação
  • Encerrar um script em caso de erro
  • Executar código de um arquivo de configuração
  • Executar código JavaScript
  • Executar código MongoDB
  • Executar código JavaScript e MongoDB
  • Abrir uma nova conexão
  • Conecte-se a uma instância local do MongoDB
  • Ligar a uma Implementação Atlas
  • Conecte-se a uma instância do MongoDB que impõe controle de acesso
  • Use o connect() para se conectar a uma instância MongoDB
  • Considerações de conexão

Você pode escrever scripts para o MongoDB Shell que modificam dados no MongoDB ou executam operações administrativas. Talvez você também queira empacotar seus scripts comosnippets para facilitar a distribuição e o gerenciamento.

Este tutorial introduz o uso do MongoDB Shell com JavaScript para acessar MongoDB.

Você pode escrever scripts para o MongoDB Shell para implantações hospedadas nos seguintes ambientes:

  • MongoDB Atlas: o serviço totalmente gerenciado para implantações MongoDB na nuvem

  • MongoDB Enterprise: a versão autogerenciada e baseada em assinatura do MongoDB

  • MongoDB Community: uma versão com código disponível, de uso gratuito e autogerenciada do MongoDB

Para saber mais sobre como usar o MongoDB Shell para implantações hospedadas no MongoDB Atlas, consulte Conectar via mongosh.

Você pode executar um arquivo .js a partir do MongoDB Shell utilizando o método load().

O método load() aceita caminhos relativos e absolutos. Se o diretório atual de trabalho do MongoDB Shell for /data/db e connect-and-insert.js estiver no diretório /data/db/scripts, então as seguintes chamadas dentro do MongoDB Shell serão equivalentes:

load( "scripts/connect-and-insert.js" )
load( "/data/db/scripts/connect-and-insert.js" )

O exemplo seguinte cria e executa um script que:

  • Conecta a uma instância local em execução na porta padrão.

  • Conecta-se ao banco de dados myDatabase.

  • Preenche a coleção movies com documentos de amostra.

  1. Crie um arquivo denominado connect-and-insert.js com o seguinte conteúdo:

    db = connect( 'mongodb://localhost/myDatabase' );
    db.movies.insertMany( [
    {
    title: 'Titanic',
    year: 1997,
    genres: [ 'Drama', 'Romance' ]
    },
    {
    title: 'Spirited Away',
    year: 2001,
    genres: [ 'Animation', 'Adventure', 'Family' ]
    },
    {
    title: 'Casablanca',
    genres: [ 'Drama', 'Romance', 'War' ]
    }
    ] )
  2. Para carregar e executar o arquivo connect-and-insert.js, utilize o mongosh para conectar à sua implantação e executar o seguinte comando:

    load( "connect-and-insert.js" )
  3. Para confirmar que os documentos carregados corretamente, utilize a coleção myDatabase e faça query da coleção movies.

    use myDatabase
    db.movies.find()

Observação

Não há caminho de pesquisa para o método load() . Se o script de destino não estiver no diretório de trabalho atual ou no caminho especificado completo, o MongoDB Shell não poderá acessar o arquivo.

Você pode utilizar o mongosh para executar um script a partir da linha de comando sem inserir o console do mongosh.

Para especificar o nome do arquivo, utilize o parâmetro --file ou -f para especificar o nome do arquivo. Você também pode precisar especificar informações de conexão além dos parâmetros do --file ou -f.

Dica

Se você passar um nome de arquivo para mongosh sem utilizar o parâmetro sinaliza que a conexão pode falhar se houver outros argumentos da linha de comando.

Para passar nomes de arquivos, sempre use --file ou -f.

O exemplo a seguir cria scripts e os executa a partir da linha de comando.

  • loadMovies.js, utiliza o insertMany() para atualizar uma instância local do MongodDB.

  • queryMovies.js utiliza db.collection.find() para verificar a atualização.

  1. Copie este script e salve-o como loadMovies.js.

    db = connect( 'mongodb://localhost/films' );
    db.movies.insertMany( [
    {
    title: 'Titanic',
    year: 1997,
    genres: [ 'Drama', 'Romance' ]
    },
    {
    title: 'Spirited Away',
    year: 2001,
    genres: [ 'Animation', 'Adventure', 'Family' ]
    },
    {
    title: 'Casablanca',
    genres: [ 'Drama', 'Romance', 'War' ]
    }
    ] )

    Dica

    Verifique a connection string na linha realçada. Se sua instância do MongoDB não estiver sendo executada em localhost:27017, você deverá editar a connection string.

    Por exemplo, a seguinte connection string se conecta à porta localhost 27500:

    db = connect( 'mongodb://localhost:27500/films' );
  2. Copie este script e salve-o como queryMovies.js.

    db = connect( 'mongodb://localhost/films' );
    printjson( db.movies.find( {} ) );
  3. Execute os scripts a partir da linha de comando.

    mongosh --file loadMovies.js --file queryMovies.js
  4. Verifique a saída.

    Loading file: loadMovies.js
    Loading file: queryMovies.js
    [
    {
    _id: ObjectId("616f1b8092dbee425b661117"),
    title: 'Titanic',
    year: 1997,
    genres: [ 'Drama', 'Romance' ]
    },
    {
    _id: ObjectId("616f1b8092dbee425b661118"),
    title: 'Spirited Away',
    year: 2001,
    genres: [ 'Animation', 'Adventure', 'Family' ]
    },
    {
    _id: ObjectId("616f1b8092dbee425b661119"),
    title: 'Casablanca',
    genres: [ 'Drama', 'Romance', 'War' ]
    }
    ]

    A saída do comando db.collection.find() mostra que a coleção movies foi atualizada.

    Dica

    Para tornar a saída visível, utilize printjson() para chamar db.collection.find().

    printjson( db.movies.find( {} ) ) ;

Para executar um roteiro em uma instância remota do mongod que exige autenticação, especifique a conexão e detalhes de autenticação além do nome do arquivo.

Por exemplo:

mongosh --host 172.17.0.3 --port 27500 --username filmFan --password superSecret --file loadMovies.js

Você também pode especificar a forma reduzida das opções:

mongosh --host 172.17.0.3 --port 27500 -u filmFan -p superSecret -f loadMovies.js

Dica

Em shells como bash e zsh, se você iniciar um comando com um espaço, ele não será salvo em seu histórico de comandos. Isso minimiza a exposição se você inserir senhas na linha de comando.

Muitas vezes, recomendamos encerrar um roteiro em execução se uma exceção for lançada, ou no caso de resultados inesperados. Sair em um ponto específico do roteiro impede a execução de código desnecessário e resultados potencialmente inesperados.

Para encerrar um roteiro, você pode chamar o método exit(<code>), onde o <code> é qualquer valor especificado pelo usuário.

Como melhor prática, coloque o código em um try - catch, chamando o método exit no bloco catch. Da mesma forma, para verificar os resultados de uma query ou qualquer comando, você pode adicionar uma instrução if - else e chamar o método exit se os resultados não forem os esperados.

Na inicialização, o mongosh verifica seu diretório do HOME para um arquivo JavaScript denominado .mongoshrc.js. Se este arquivo for localizado, o mongosh lê o conteúdo do .mongoshrc.js antes de exibir o prompt pela primeira vez.

Dica

Veja também:

Para atualizar o prompt mongosh para exibir números de linha, adicione o seguinte código a <your-home-directory>/.mongoshrc.js

let cmdCount = 1;
prompt = function() {
return (cmdCount++) + "> ";
}

O prompt terá a seguinte aparência:

1> show collections
2> use test
3>

Para criar um registro de quando seu cliente mongosh se conecta a um banco de dados, adicione o seguinte código a <your-home-directory>/.mongoshrc.js:

db.clientConnections.insertOne( { connectTime: ISODate() } )

Cada vez que você se conecta a um banco de dados, o servidor MongoDB adiciona um documento como o seguinte à coleção clientConnections.

{
_id: ObjectId("61d4bbf0fa4c85f53418070f"),
connectTime: ISODate("2022-01-04T21:28:16.367Z")
}

O nome do banco de dados atual faz parte do prompt mongosh padrão. Para reformatar o prompt para mostrar o nome do banco de dados e do host, use uma função como esta:

{
const hostnameSymbol = Symbol('hostname');
prompt = () => {
if (!db[hostnameSymbol])
db[hostnameSymbol] = db.serverStatus().host;
return `${db.getName()}@${db[hostnameSymbol]}> `;
};
}

O prompt terá a seguinte aparência:

admin@centos0722:27502>

A partir do MongoDB Shell ou de um arquivo JavaScript, você pode instanciar conexões de banco de dados usando o método Mongo():

new Mongo()
new Mongo(<host>)
new Mongo(<host:port>)

Observação

O MongoDB Shell não aceita o documento ClientSideFieldLevelEncryptionOptions com o método Mongo().

Considere uma instância MongoDB em execução no localhost na porta padrão.

O seguinte exemplo:

  • Instancia uma nova conexão com a instância e

  • Define a variável global db como myDatabase utilizando o método Mongo.getDB().

conn = Mongo();
db = conn.getDB("myDatabase");

Para conectar a uma implantação hospedada no MongoDB Atlas, execute o mongosh com sua connection string do Atlas. Por exemplo:

mongosh "mongodb+srv://YOUR_CLUSTER_NAME.YOUR_HASH.mongodb.net/" --apiVersion YOUR_API_VERSION --username YOUR_USERNAME

Depois de estabelecer uma conexão com sua implantação, você pode instanciar conexões de banco de dados diretamente do Shell do MongoDB. O seguinte exemplo:

  • Instancia uma conexão com a implantação atual usando o método db.getMongo().

  • Define a variável global db para myDatabase utilizando o método Mongo.getDB().

conn = db.getMongo()
db = conn.getDB("myDatabase");

Para se conectar a uma instância do MongoDB que impõe controle de acesso, é necessário incluir as credenciais na connection string.

O comando a seguir se conecta a uma instância do MongoDB que é:

  • Executando em localhost na porta padrão e

  • Protegido usando SCRAM.

conn = Mongo("mongodb://<username>:<password>@localhost:27017/<authDB>");

Observação

O Shell do MongoDB edita credenciais do histórico de comandos e dos logs.

Você também pode usar o método connect() para se conectar à instância do MongoDB.

O seguinte comando:

  • Conecta-se à instância MongoDB que está sendo executada no localhost com a porta 27020 não padrão e

  • Define a variável global db.

db = connect("localhost:27020/myDatabase");

Considere a portabilidade e o ambiente operacional ao escrever scripts.

Se os detalhes da conexão forem incluídos no script:

  • Você não precisa especificar informações de conexão na linha de comando.

  • Você deve utilizar o parâmetro --nodb.

Considere uma instância do mongod executando no localhost:27500.

O script a seguir imprime o número de usuários. Copie o código e guarde-o como getUserCount.js.

db = connect( "localhost:27500/admin" );˘
printjson( db.system.users.countDocuments() );

Execute getUserCount.js:

mongosh --nodb --file getUserCount.js
  • mongosh O padrão é a porta 27170.

  • mongod está em execução na porta 27500.

  • O parâmetro --nodb instrui mongosh a executar um roteiro sem primeiro se conectar a uma instância mongod.

A linha destacada está correta, mas getUserCount.js não será executado sem --nodb porque mongosh não pode se conectar à instância local. Com --nodb, o mongosh executa o getUserCount.js e utiliza as informações destacadas para conectar.

É conveniente especificar as informações de conexão em seu script, mas isso também as torna menos portáteis. O script getUserCount.js teria que ser atualizado para ser executado em uma instância remota ou em uma instância executada em uma porta diferente.

Para aumentar a portabilidade, utilize db.getSiblingDB() e especifique as informações de conexão na linha de comando.

O script a seguir é mais portátil do que getUserCount.js porque não tem detalhes de conexão específicos. Copie o código e guarde-o como portableGetUserCount.js.

db = db.getSiblingDB( "admin" );
printjson( db.system.users.countDocuments() );

Para executar o portableGetUserCount.js, especifique o host e a porta na linha de comando:

mongosh --host 172.17.0.3 --port 27500 --file portableGetUserCount.js

Para executar o portableGetUserCount.js em um host ou porta diferente, altere os detalhes da conexão na linha de comando. Ao contrário de getUserCount.js, você não precisa editar o script para executar portableGetUserCount.js.

Voltar

Criptografia no nível de campo do cliente