Conecte-se ao MongoDB

Nesta página

Pré-requisitos

Cliente Mongo
URI de conexão
Ligar ao MongoDB Atlas
Conecte-se a um sistema local do MongoDB
Conectar a um conjunto de réplicas
Conecte-se a um cluster fragmentado
Opções de conexão
Tutoriais de conexão

Este guia descreve como usar o driver Scala para se conectar ao MongoDB.

Use o método MongoClient() para fazer uma conexão com uma MongoDB deployment em execução.

Importante

Os exemplos seguintes não fornecem uma lista exaustiva de maneiras de instanciar um MongoClient. Para obter uma lista completa dos MongoClient métodos complementares do, consulte a documentação da API do MongoClient do.

Observação

É altamente recomendável que as configurações de manutenção de atividade do sistema sejam configuradas com tempos limite mais curtos.

Consulte O tempo de manutenção de atividade do TCP afeta as implementações do MongoDB ? pergunta e resposta no manual do servidor Perguntas frequentes para obter mais informações.

Pré-requisitos

Você deve configurar os seguintes componentes para executar os exemplos de código neste guia:

Um MongoDB deployment em execução para se conectar. Por exemplo, para se conectar a um autônomo , você deve ter acesso a um sistema autônomo em execução.
Dependência do driver instalada em seu projeto. Para saber como instalar o driver, consulte Instalação.
As seguintes declarações de importação:
```
import org.mongodb.scala._
import scala.collection.JavaConverters._
```

Cliente Mongo

Uma instância do MongoClient representa um grupo de conexões para o banco de dados de dados. Você precisa de apenas uma instância de MongoClient , mesmo ao executar várias operações simultâneas.

Importante

Normalmente, você cria apenas uma instância do MongoClient para uma determinada implantação do MongoDB, como uma implantação independente, um conjunto de réplicas ou um cluster fragmentado, e usa o cliente em seu aplicativo. No entanto, se você criar várias instâncias, tenha em mente o seguinte:

Todos os limites de uso de recursos (por exemplo, conexões máximas) se aplicam a cada instância do MongoClient .
Para descartar uma instância, chame o método MongoClient.close() para limpar recursos.

URI de conexão

O URI de conexão fornece um conjunto de instruções que o driver utiliza para se conectar a uma implantação MongoDB. Ele instrui o driver sobre como deve se conectar ao MongoDB e como deve se comportar enquanto conectado. A figura a seguir explica cada parte de um URI de conexão de amostra:

Um exemplo de uma connection string que demonstra o protocolo, as credenciais, o nome do host ou o IP, a porta e as opções de conexão

Neste exemplo, você se conecta a uma implantação do Atlas MongoDB que tem um registro DNS SRV. Para obter mais detalhes, consulte a documentação do Formato de Conexão da Lista de Sementes DNS . Este formato oferece flexibilidade na implantação e a capacidade de alterar os servidores em rotação sem reconfigurar os clientes.

Observação

Se a sua implantação estiver no MongoDB Atlas, consulte o guia de conexão do driver do Atlas e selecione Scala na lista suspensa de idioma para recuperar sua connection string.

Se você estiver se conectando a uma instância ou conjunto de réplicas que não tenha um endereço SRV DNS, deverá usar mongodb para o protocolo, que especifica o Formato Padrão de Connection String.

Após o protocolo, a connection string contém suas credenciais se você estiver usando um mecanismo de autenticação baseado em senha. Substitua o valor de user pelo seu nome de usuário e pass pela sua senha. Se o mecanismo de autenticação não exigir credenciais, omita esta parte do URI de conexão.

A próxima parte do URI de conexão especifica o nome do host ou endereço IP, seguido pela porta da sua instância do MongoDB. No exemplo, sample.host representa o nome do host e 27017 é o número da porta. Substitua estes valores para consultar a sua instância MongoDB.

A última parte do URI de conexão contém opções de conexão como parâmetros. O exemplo define duas opções de conexão: maxPoolSize=20 e w=majority.

Ligar ao MongoDB Atlas

Você pode utilizar o seguinte trecho de conexão para testar sua conexão com seu MongoDB deployment no Atlas:

import com.mongodb.{ServerApi, ServerApiVersion}
import org.mongodb.scala.{ConnectionString, MongoClient, MongoClientSettings}
import org.mongodb.scala.bson.Document
import scala.concurrent.Await
import scala.concurrent.duration.DurationInt
import scala.util.Using
object MongoClientConnectionExample {
  def main(args: Array[String]): Unit = {
    // Replace the placeholder with your Atlas connection string
    val connectionString = "<connection string>";
    // Construct a ServerApi instance using the ServerApi.builder() method
    val serverApi = ServerApi.builder.version(ServerApiVersion.V1).build()
    val settings = MongoClientSettings
      .builder()
      .applyConnectionString(ConnectionString(connectionString))
      .serverApi(serverApi)
      .build()
    // Create a new client and connect to the server
    Using(MongoClient(settings)) { mongoClient =>
      // Send a ping to confirm a successful connection
      val database = mongoClient.getDatabase("admin")
      val ping = database.runCommand(Document("ping" -> 1)).head()
      Await.result(ping, 10.seconds)
      System.out.println("Pinged your deployment. You successfully connected to MongoDB!")
    }
  }
}

Este trecho de conexão usa o recurso API estável, que você pode habilitar ao usar o driver Scala v. 4,3 e mais recente para se conectar ao servidor MongoDB v. 5,0 e mais recente. Ao usar esse recurso, você pode atualizar seu driver ou servidor sem se preocupar com problemas de compatibilidade com versões anteriores de qualquer comando coberto pela API estável.

Para saber mais sobre a funcionalidade Stable API, consulte Stable API no manual do servidor.

Conecte-se a um sistema local do MongoDB

Você pode se conectar a uma implementação local do MongoDB das seguintes maneiras:

Instancie um objeto MongoClient sem nenhum parâmetro para se conectar a um servidor MongoDB em execução no localhost na porta 27017:
```
val mongoClient = MongoClient()
```
Especifique explicitamente o hostname para se conectar a uma instância do MongoDB em execução no host especificado na porta 27017:
```
val mongoClient = MongoClient("mongodb://host1")
```
Especifique explicitamente o hostname e o port:
```
val mongoClient = MongoClient("mongodb://host1:27017")
```

Conectar a um conjunto de réplicas

Para conectar a um conjunto de réplicas, você deve especificar um ou mais membros para o método de aplicação MongoClient . Para saber mais sobre conjuntos de réplicas, consulte Replicação no manual do servidor.

Observação

O MongoDB descobre automaticamente os nós primários e secundários em um conjunto de réplicas.

Você pode se conectar a um conjunto de réplicas MongoDB especificando os membros em um ConnectionString.

O exemplo a seguir mostra como especificar três membros do conjunto de réplicas:

val mongoClient = MongoClient("mongodb://host1:27017,host2:27017,host3:27017")

O exemplo seguinte mostra como especificar membros do conjunto de réplica e a opção replicaSet com o nome do conjunto de réplica:

val mongoClient = MongoClient("mongodb://host1:27017,host2:27017,host3:27017/?replicaSet=myReplicaSet")

O exemplo a seguir mostra como especificar uma lista de instâncias ServerAddress correspondentes a todos os membros do conjunto de réplicas:

val mongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(
        new ServerAddress("host1", 27017),
        new ServerAddress("host2", 27017),
        new ServerAddress("host3", 27017)).asJava))
    .build())

Conecte-se a um cluster fragmentado

Para conectar a um cluster fragmentado, especifique a instância mongos ou instâncias para o método de aplicação MongoClient . Para saber mais sobre clusters sharded, consulte Sharding no manual do servidor MongoDB.

Você pode se conectar a uma única instância do mongos das seguintes maneiras:

Especifique o nome do host e a porta em um ConnectionString:
```
val mongoClient = MongoClient( "mongodb://localhost:27017" )
```
Exclua a connection string se o mongos estiver sendo executado em localhost:27017:
```
val mongoClient = MongoClient()
```

Você pode se conectar a múltiplas instâncias do mongos das seguintes maneiras:

Especifique ConnectionString para conter seus nomes de host e portas:
```
val mongoClient = MongoClient("mongodb://host1:27017,host2:27017")
```

Especifique uma lista dos objetos ServerAddress correspondentes a cada instância:

val mongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(
        new ServerAddress("host1", 27017),
        new ServerAddress("host2", 27017)).asJava))
    .build())

Opções de conexão

Você pode especificar as configurações de conexão usando os tipos ConnectionString ou MongoClientSettings , ou ambos.

Por exemplo, você pode especificar configurações de autenticação e TLS/SSL na string de conexão:

val mongoClient = MongoClient("mongodb://user1:pwd1@host1/?authSource=db1&ssl=true")

Você também pode usar uma instância MongoClientSettings para especificar TLS/SSL e o tipo MongoCredential para armazenar as informações de autenticação:

val user: String =          // the user name
val source: String =        // the source where the user is defined
val password: Array[Char] = // the password as a character array
// ...
val credential = MongoCredential.createCredential(user, source, password)
val mongoClient: MongoClient = MongoClient(
  MongoClientSettings.builder()
    .applyToSslSettings((builder: SslSettings.Builder) => builder.enabled(true))
    .applyToClusterSettings((builder: ClusterSettings.Builder) => builder.hosts(List(new ServerAddress("host1", 27017)).asJava))
    .credential(credential)
    .build())

Em alguns casos, talvez seja necessário combinar uma string de conexão com configuração programática:

val connectionString = ConnectionString("mongodb://host1:27107,host2:27017/?ssl=true")
val myCommandListener: CommandListener = ???
val mongoClient = MongoClient(
  MongoClientSettings.builder()
    .addCommandListener(myCommandListener)
    .applyConnectionString(connectionString)
    .build())

Tutoriais de conexão

Para saber como implementar outros recursos de conexão, consulte os seguintes tutoriais:

Voltar

Tutorials

TLS/SSL