Menu Docs
Página inicial do Docs
/
Idiomas
/
C++
/
Driver C++

Opções avançadas de configuração e instalação

Nesta página

  • Opções adicionais para integradores
  • Instalar com gerenciadores de pacotes
  • Instruções de instalação do Vpkg
  • Instruções de instalação do Conan
  • Instruções de instalação do Homebrew
  • Instale o driver MongoDB C
  • Configuração avançada (configurações estáticas)
  • Configurando com mongocxx 3.2.x ou mais recente
  • Configurando com mongocxx 3.5.0 ou mais recente
  • Desabilitando testes
  • Instalando em diretórios não padrão
  • Configurando com mongocxx 3.1.x ou 3.0.x
  • Solução de problemas
  • Corrigindo o erro Library not loaded no macOS
  • Corrigindo o erro "não é possível abrir o arquivo de objeto compartilhado" no Linux

Opções adicionais para integradores

Caso você esteja construindo a biblioteca BSON C++ e/ou o driver C++ para incorporar com outros componentes e deseja evitar o potencial de colisão com componentes instalados a partir de uma compilação padrão ou de um gerenciador de pacotes de distribuição, você pode usar as opções BSONCXX_OUTPUT_BASENAME e MONGOCXX_OUTPUT_BASENAME para cmake.

cmake ..                                            \
    -DBSONCXX_OUTPUT_BASENAME=custom_bsoncxx        \
    -DMONGOCXX_OUTPUT_BASENAME=custom_mongocxx

O comando acima produziria bibliotecas denominadas libcustom_bsoncxx.so e libcustom_mongocxx.so (ou com a extensão apropriada para a plataforma de construção). Essas bibliotecas podem ser colocadas em um diretório do sistema padrão ou em um local alternativo e podem ser vinculadas especificando algo como -lcustom_mongocxx -lcustom_bsoncxx na linha de comando do vinculador (possivelmente ajustando os sinalizadores específicos aos exigidos pelo vinculador).

Instalar com gerenciadores de pacotes

Você pode usar os seguintes gerenciadores de pacote para instalar o driver C++ :

  • vspkg

  • Conan

  • Homebrew

Instruções de instalação do Vpkg

Se você ainda não tiver o Vocêpkg instalado, instale-o com o seguinte comando:

$ git clone https://github.com/Microsoft/vcpkg.git
$ cd vcpkg
$ ./bootstrap-vcpkg.sh

Opcionalmente, para instalar com integração do Visual Studio:

vcpkg integrate install

Instale o driver. Talvez seja necessário git pull para obter a versão mais recente do driver.

$ ./vcpkg install mongo-cxx-driver

Você pode usar o arquivo de cadeia de ferramentas, vcpkg.cmake, para instruir o CMake onde encontrar os arquivos de desenvolvimento, por exemplo:

-DCMAKE_TOOLCHAIN_FILE=/<path to vcpkg repo>/vcpkg/scripts/buildsystems/vcpkg.cmake

Você pode encontrar os arquivos de cabeçalho em:

vcpkg/installed/<CPU ARCHITECTURE>-<OPERATING SYSTEM>/include/

Os arquivos da biblioteca estão em:

vcpkg/installed/<CPU ARCHITECTURE>-<OPERATING SYSTEM>/lib/

Instruções de instalação do Conan

Especificador do Pacote: mongo-cxx-driver/3.8.0

Se você ainda não tiver o Conan instalado, instale-o e execute o comando de inicialização do Conan abaixo:

$ pip install conan
$ conan profile detect --force

Adicione o seguinte ao seu conanfile.txt:

[requires]
mongo-cxx-driver/3.8.0
[generators]
CMakeDeps
CMakeToolchain

Instale o driver via Conan e construa seu projeto:

$ conan install conanfile.txt --output-folder=build --build=missing
$ cmake \
  -B build \
  -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake \
  -DCMAKE_BUILD_TYPE=Release
$ cmake --build build

Instruções de instalação do Homebrew

Os usuários do MacOS podem usar o Homebrew para instalar o driver C++ executando o seguinte comando:

brew install mongo-cxx-driver

Para um Apple Silicon Mac

Os cabeçalhos podem ser encontrados em:

/opt/homebrew/include/mongocxx/v_noabi/
/opt/homebrew/include/bsoncxx/v_noabi/

Os arquivos da biblioteca podem ser encontrados em:

/opt/homebrew/lib/

Para um Intel Mac

Os cabeçalhos podem ser encontrados em:

/usr/local/include/mongocxx/v_noabi/
/usr/local/include/bsoncxx/v_noabi/

Os arquivos da biblioteca podem ser encontrados em:

/usr/local/lib/

Instale o driver MongoDB C

O driver mongocxx é baseado no driver MongoDB C.

A compilação do mongocxx-3.9.0 baixa e instala automaticamente o driver C se o driver C não for detectado. Para usar uma instalação existente do driver C, defina CMAKE_PREFIX_PATH como o diretório que contém a instalação do driver C. Para obter informações sobre a libmongoc versão mínima exigida para cada versão do driver C++ , consulte Compatibilidade com a libmongoc.

A menos que você saiba que seu gerenciador de pacote oferece uma versão suficientemente recente, você precisará baixar e construir a partir do código fonte. Obtenha um tarball na página da versão do C Driver.

Siga as instruções para criar a partir de um tarball em Instalando a libmongoc.

As melhores práticas do setor e alguns regulamentos exigem o uso do TLS 1.1 ou mais recente. O MongoDB C Driver suporta TLS 1.1 no Linux se o OpenSSL tiver pelo menos a versão 1.0.1. No macOS e no Windows, o C Driver usa implementações de TLS nativas que suportam TLS 1.1.

Configuração avançada (configurações estáticas)

As subseções a seguir detalham opções avançadas para configurar o driver C++ e/ou suas dependências como bibliotecas estáticas em vez das bibliotecas compartilhadas típicas. Essas opções produzirão artefatos de biblioteca que se comportarão de forma diferente. Certifique-se de ter uma compreensão completa das implicações das várias abordagens de vinculação antes de utilizar essas opções.

Configurando com mongocxx 3.2.x ou mais recente

Os usuários têm a opção de construir o mongocxx como uma biblioteca estática. Isso não é recomendado para usuários novatos. Um usuário pode habilitar este comportamento com a opção -DBUILD_SHARED_LIBS :

cmake ..                                            \
    -DCMAKE_BUILD_TYPE=Release                      \
    -DBUILD_SHARED_LIBS=OFF

Configurando com mongocxx 3.5.0 ou mais recente

Os usuários têm a opção de construir o mongocxx como bibliotecas estáticas e compartilhadas. Um usuário pode habilitar este comportamento com a opção -DBUILD_SHARED_AND_STATIC_LIBS :

cmake ..                                            \
    -DCMAKE_BUILD_TYPE=Release                      \
    -DBUILD_SHARED_AND_STATIC_LIBS=ON

Os usuários têm a opção de construir o mongocxx como uma biblioteca compartilhada que vinculou estaticamente ao libmongoc. Isso não é recomendado para usuários novatos. Um usuário pode habilitar este comportamento com a opção -DBUILD_SHARED_LIBS_WITH_STATIC_MONGOC :

cmake ..                                            \
    -DCMAKE_BUILD_TYPE=Release                      \
    -DBUILD_SHARED_LIBS_WITH_STATIC_MONGOC=ON

Desabilitando testes

Passe o -DENABLE_TESTS=OFF como uma opção cmake para desabilitar a configuração dos destinos de teste.

cmake .. -DENABLE_TESTS=OFF
cmake --build .. --target help
# No test targets are configured.

Instalando em diretórios não padrão

Para instalar o driver C++ em um diretório não padrão, especifique CMAKE_INSTALL_PREFIX para o caminho de instalação desejado:

cmake ..                                            \
    -DCMAKE_BUILD_TYPE=Release                      \
    -DCMAKE_INSTALL_PREFIX=$HOME/mongo-cxx-driver

Considere também especificar a opção -DCMAKE_INSTALL_RPATH= para o diretório lib da instalação. Isto pode permitir que libmongocxx.so localize libbsoncxx.so:

cmake ..                                             \
    -DCMAKE_BUILD_TYPE=Release                       \
    -DCMAKE_INSTALL_PREFIX=$HOME/mongo-cxx-driver    \
    -DCMAKE_INSTALL_RPATH=$HOME/mongo-cxx-driver/lib

Se o driver C estiver instalado em um diretório não padrão, especifique CMAKE_PREFIX_PATH para o caminho de instalação do driver C:

cmake ..                                            \
    -DCMAKE_BUILD_TYPE=Release                      \
    -DCMAKE_PREFIX_PATH=$HOME/mongo-c-driver        \
    -DCMAKE_INSTALL_PREFIX=$HOME/mongo-cxx-driver

Observação

Se você precisar de vários caminhos em uma variável CMake PATH, separe-os com um ponto e vírgula como este: -DCMAKE_PREFIX_PATH="/your/cdriver/prefix;/some/other/path"

Configurando com mongocxx 3.1.x ou 3.0.x

Em vez da opção -DCMAKE_PREFIX_PATH , os usuários devem especificar o diretório de instalação do libmongoc usando as opções -DLIBMONGOC_DIR e -DLIBBSON_DIR :

cmake ..                                            \
    -DCMAKE_BUILD_TYPE=Release                      \
    -DLIBMONGOC_DIR=$HOME/mongo-c-driver            \
    -DLIBBSON_DIR=$HOME/mongo-c-driver              \
    -DCMAKE_INSTALL_PREFIX=$HOME/mongo-cxx-driver

Solução de problemas

Corrigindo o Library not loaded erro no macOS

Os aplicativos vinculados a uma instalação de diretório não padrão podem encontrar um erro ao carregar o driver C++ no tempo de execução. Exemplo:

# Tell pkg-config where to find C++ driver installation.
export PKG_CONFIG_PATH=$HOME/mongo-cxx-driver/lib/pkgconfig
clang++ app.cpp -std=c++11 $(pkg-config --cflags --libs libmongocxx) -o ./app.out
./app.out
# Prints the following error:
# dyld[3217]: Library not loaded: '@rpath/libmongocxx._noabi.dylib'
#   Referenced from: '/Users/kevin.albertson/code/app.out'
#   Reason: tried: '/usr/local/lib/libmongocxx._noabi.dylib' (no such file), '/usr/lib/libmongocxx._noabi.dylib' (no such file)
# zsh: abort      ./app.out

O install name padrão do driver C++ no macOS inclui @rpath:

otool -D $HOME/mongo-cxx-driver/lib/libmongocxx.dylib
# Prints:
# /Users/kevin.albertson/mongo-cxx-driver/lib/libmongocxx.dylib:
# @rpath/libmongocxx._noabi.dylib

Incluir @rpath no nome de instalação permite vincular aplicativos para controlar a lista de caminhos de pesquisa para a biblioteca.

app.out inclui o comando de carregamento para @rpath/libmongocxx._noabi.dylib. app.out não tem entradas para substituir @rpath.

Há várias maneiras de considerar resolver isso no macOS:

Passe DYLD_FALLBACK_LIBRARY_PATH para o diretório que contém as bibliotecas de drivers C++:

DYLD_FALLBACK_LIBRARY_PATH=$HOME/mongo-cxx-driver/lib ./app.out
# Prints "successfully connected with C++ driver"

Como alternativa, a opção de vinculador -Wl,-rpath pode ser passada para adicionar entradas para substituir @rpath:

# Tell pkg-config where to find C++ driver installation.
export PKG_CONFIG_PATH=$HOME/mongo-cxx-driver/lib/pkgconfig
# Pass the linker option -rpath to set an rpath in the final executable.
clang++ app.cpp -std=c++11 -Wl,-rpath,$HOME/mongo-cxx-driver/lib $(pkg-config --cflags --libs libmongocxx) -o ./app.out
./app.out
# Prints "successfully connected with C++ driver"

Se estiver criando o aplicação com cmake, as configurações padrão de RPATH inclua o RPATH completo para todas as bibliotecas usadas na árvore de construção. No entanto, ao instalar, o cmake limpará o RPATH desses alvos para que eles sejam instalados com um RPATH vazio. Isso pode resultar em um erro Library not loaded após a instalação.

Exemplo:

# Build application ``app`` using the C++ driver from a non-standard install.
cmake \
    -DCMAKE_PREFIX_PATH=$HOME/mongo-cxx-driver \
    -DCMAKE_INSTALL_PREFIX=$HOME/app \
    -DCMAKE_CXX_STANDARD=11 \
    -Bcmake-build -S.
cmake --build cmake-build --target app.out
# Running app.out from build tree includes rpath to C++ driver.
./cmake-build ./cmake-build/app.out
# Prints: "successfully connected with C++ driver"
cmake --build cmake-build --target install
# Running app.out from install tree does not include rpath to C++ driver.
$HOME/app/bin/app.out
# Prints "Library not loaded" error.

Considere configurar o -DCMAKE_INSTALL_RPATH_USE_LINK_PATH=TRUE para que o rpath do executável seja mantido no destino da instalação.

# Build application ``app`` using the C++ driver from a non-standard install.
# Use CMAKE_INSTALL_RPATH_USE_LINK_PATH=TRUE to keep rpath entry on installed app.
cmake \
    -DCMAKE_PREFIX_PATH=$HOME/mongo-cxx-driver \
    -DCMAKE_INSTALL_PREFIX=$HOME/app \
    -DCMAKE_INSTALL_RPATH_USE_LINK_PATH=TRUE \
    -DCMAKE_CXX_STANDARD=11 \
    -Bcmake-build -S.
cmake --build cmake-build --target install
$HOME/app/bin/app.out
# Prints "successfully connected with C++ driver"

Consulte a documentação do cmake para tratamento de RPATH para mais informações.

Corrigindo o erro "não é possível abrir o arquivo de objeto compartilhado" no Linux

Os aplicativos vinculados a uma instalação de diretório não padrão podem encontrar um erro ao carregar o driver C++ no tempo de execução. Exemplo:

# Tell pkg-config where to find C++ driver installation.
export PKG_CONFIG_PATH=$HOME/mongo-cxx-driver/lib/pkgconfig
g++ -std=c++11 app.cpp $(pkg-config --cflags --libs libmongocxx) -o ./app.out
./app.out
# Prints the following error:
# ./app.out: error while loading shared libraries: libmongocxx.so._noabi: cannot open shared object file: No such file or directory

Existem várias maneiras de considerar resolver isso no Linux:

Passe LD_LIBRARY_PATH para o diretório que contém as bibliotecas de drivers C++:

LD_LIBRARY_PATH=$HOME/mongo-cxx-driver/lib ./app.out
# Prints "successfully connected with C++ driver"

Como alternativa, a opção do vinculador -Wl,-rpath pode ser passada para adicionar entradas do rpath :

# Tell pkg-config where to find C++ driver installation.
export PKG_CONFIG_PATH=$HOME/mongo-cxx-driver/lib/pkgconfig
# Pass the linker option -rpath to set an rpath in the final executable.
g++ app.cpp -std=c++11 -Wl,-rpath,$HOME/mongo-cxx-driver/lib $(pkg-config --cflags --libs libmongocxx) -o ./app.out
./app.out
# Prints "successfully connected with C++ driver"

Se estiver criando o aplicação com cmake, as configurações padrão de RPATH inclua o RPATH completo para todas as bibliotecas usadas na árvore de construção. No entanto, ao instalar, o cmake limpará o RPATH desses alvos para que eles sejam instalados com um RPATH vazio. Isso pode resultar em um erro Library not loaded após a instalação.

Exemplo:

# Build application ``app`` using the C++ driver from a non-standard install.
cmake \
    -DCMAKE_PREFIX_PATH=$HOME/mongo-cxx-driver \
    -DCMAKE_INSTALL_PREFIX=$HOME/app \
    -DCMAKE_CXX_STANDARD=11 \
    -Bcmake-build -S.
cmake --build cmake-build --target app.out
# Running app.out from build tree includes rpath to C++ driver.
./cmake-build ./cmake-build/app.out
# Prints: "successfully connected with C++ driver"
cmake --build cmake-build --target install
# Running app.out from install tree does not include rpath to C++ driver.
$HOME/app/bin/app.out
# Prints "cannot open shared object file" error.

Considere configurar o -DCMAKE_INSTALL_RPATH_USE_LINK_PATH=TRUE para que o rpath do executável seja mantido no destino da instalação.

# Build application ``app`` using the C++ driver from a non-standard install.
# Use CMAKE_INSTALL_RPATH_USE_LINK_PATH=TRUE to keep rpath entry on installed app.
cmake \
    -DCMAKE_PREFIX_PATH=$HOME/mongo-cxx-driver \
    -DCMAKE_INSTALL_PREFIX=$HOME/app \
    -DCMAKE_INSTALL_RPATH_USE_LINK_PATH=TRUE \
    -DCMAKE_CXX_STANDARD=11 \
    -Bcmake-build -S.
cmake --build cmake-build --target install
$HOME/app/bin/app.out
# Prints "successfully connected with C++ driver"

Consulte a documentação do cmake para tratamento de RPATH para mais informações.

Voltar

BSON

Próximo

Segurança de rosca e bifurcação