Explore o novo chatbot do Developer Center! O MongoDB AI chatbot pode ser acessado na parte superior da sua navegação para responder a todas as suas perguntas sobre o MongoDB .

Desenvolvedor do MongoDB
Central de desenvolvedor do MongoDBchevron-right
Produtoschevron-right
Atlaschevron-right

Tutorial do MongoDB Atlas Data Federation: consultas federadas e $out para AWS S3

Maxime Beugnet, Stanimira Vlaeva7 min read • Published Feb 07, 2022 • Updated Jan 23, 2024
AWSAtlasFederação de Dados
Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
A Atlas Data Federation é uma funcionalidade do MongoDB Atlas que permite fazer query de dados de fontes diversas, como:
  • Atlas databases.
  • Atlas Data Lake.
  • HTTP APIs.
  • Baldes AWS S3.
Neste tutorial, mostrarei como acessar seus documentos arquivados no S3 e seus documentos no MongoDB Atlas cluster com uma única query MQL.
MongoDB Atlas Data Federation
Esse recurso é realmente surpreendente porque permite que você tenha acesso fácil aos seus dados arquivados no S3 junto com seus dados "quentes" no Atlas cluster. Isso pode ajudá-lo a impedir que seus Atlas clusters aumentem de tamanho indefinidamente e reduzir drasticamente seus custos. Também facilita a obtenção de novos insights consultando facilmente os dados que residem no S3 e expondo-os ao seu aplicativo em tempo real.
Por fim, mostrarei como usar a nova versão do estágio do pipeline de agregação$out para escrever documentos de um cluster MongoDB Atlas em um bucket3 do AWS S.

Pré-requisitos

Para acompanhar este tutorial, você precisa:
  • Criar um MongoDB Atlas cluster. ✅ Já tem uma conta AWS? O Atlas oferece suporte ao pagamento por uso por meio do AWS Marketplace (AWS MP) sem qualquer compromisso inicial - simplesmente
    Inscreva-se no MongoDB Atlas por meio do AWS Marketplace.
  • Crie um usuário no menuAcesso ao banco de dados.
  • Adicione seu endereço IP na lista de acesso à rede no menuAcesso à rede.
  • Tenha o Python 3 com pymongo e dnspython libs instalados.

Configure seu bucket S3 e sua conta AWS

Faça login em sua conta da AWS e crie um bucket S3 . Escolha uma região próxima à sua implantação do Atlas para minimizar a latência de dados. Os scripts neste tutorial usam um bucket chamado cold-data-mongodb na região eu-west-1. Se você usar um nome diferente ou selecionar outra região, certifique-se de refletir isso no código Python que verá no tutorial.
Em seguida, instale a CLI da AWS e configure-a para acessar sua conta da AWS. Se precisar de ajuda para configurá-lo, consulte a documentação da AWS.

Prepare o conjunto de dados

Para ilustrar como $out e as queries federadas funcionam, usarei um conjunto de dados excessivamente simples para manter as coisas o mais fácil possível de entender. Nosso banco de dados "test " terá uma única coleção, "orders, " representando pedidos feitos em uma loja online. Cada documento de pedido terá um campo "created " do tipo "Date. " Usaremos esse campo para arquivar pedidos mais antigos, movendo-os do Atlas cluster para S3.
Escrevi um script Python que insere os dados necessários no Atlas cluster. Você pode obter o script, junto com o restante do código que usaremos no tutorial, no GitHub:
1git clone https://github.com/mongodb-developer/data-lake-tutorial.git
Em seguida, volte ao Atlas para localizar a connection string do seu cluster. Clique em "Connect " e depois em "Connect your application. ". Copie a connection string e cole-a no scriptinsert_data.py que você acabou de baixar do Github. Não se esquecer de substituir os placeholders<username> e <password> pelas credenciais do seu utilizador de banco de dados:
insert_data.py
1from pymongo import MongoClient
2from datetime import datetime
3
4client = MongoClient('mongodb+srv://<username>:<password>@m0.lbtrerw.mongodb.net/')
5
Por fim, instale as bibliotecas necessárias e execute o script:
1pip3 install -r requirements.txt
2python3 insert_data.py
Agora que temos uma "collection" de pedidos "massive", podemos considerar arquivar os pedidos mais antigos em um bucket de3 S. Vamos imaginar que uma vez terminado o mês, podemos arquivar todos os pedidos do mês anterior. Criaremos um arquivo JSON no S3 para todos os pedidos criados durante o mês anterior.
Transferiremos esses pedidos para S3 usando o aggregation pipeline stage $out.
Mas primeiro, precisamos configurar o Atlas Data Federation corretamente.

Configurar Federação de Dados

Navegue até “Data Federation” no menu lateral do Atlas e clique em “set up manually” no menu suspenso "criar novo banco de dados federado" no canto superior direito da interface do usuário.
À esquerda, vemos um painel com as fontes de dados (ainda não temos nenhuma) e, à direita, os bancos de dados e collection “virtual” da instância federada.

Configurar o cluster do Atlas como uma fonte de dados

Vamos adicionar a primeira fonte de dados — os pedidos do nosso cluster do Atlas. Clique em "Add Data Sources, ", selecione "Atlas Cluster, " e selecione seu cluster e banco de dados.
Clique em "Next " e você verá a coleção "test.orders " como uma fonte de dados. Clique na linha "test.orders", arraste-a para baixo da "VirtualCollection0," e solte-a lá como fonte de dados.

Configurar o bucket S3 como fonte de dados

Em seguida, conectaremos nosso bucket S3 . Clique em "Add Data Sources " novamente e, desta vez, selecione Amazon S3. Clique em "Next " e siga as instruções para criar e autorizar uma nova função do AWS IAM. Precisamos executar alguns comandos com a AWS CLI. Certifique-se de ter instalado e vinculado a CLI à sua conta da AWS antes disso. Se você estiver enfrentando algum problema, consulte a página de solução de problemas da AWS CLI.
Depois de autorizar a função do IAM, você será solicitado a fornecer o nome do bucket do S3 e a política de acesso. Como gravaremos arquivos em nosso bucket, precisamos escolher "Read and write. "
Você também pode configurar um prefixo. Se você fizer isso, o Data Federation procurará apenas arquivos em diretórios começando com o prefixo especificado. Neste tutorial, queremos acessar arquivos no diretório raiz do bucket, portanto, deixaremos esse campo vazio.
Configuração de bucket S3 no Atlas Data Federation
Depois disso, precisamos executar mais alguns comandos da AWS CLI para garantir que a função do IAM tenha permissões para o bloco S3 . Quando terminar, clique em “Next.”
Por fim, seremos solicitados a definir um caminho para os dados que queremos acessar no bucket. Para manter as coisas simples, usaremos uma configuração curinga que nos permitirá acessar todos os arquivos. Defina s3://cold-data-mongodb/* como o caminho e any value (*) como o tipo de dados do arquivo.
Configuração do caminho do arquivo no bucket frio-data-mongodb
A Atlas Data Federation também permite criar partições e analisar campos a partir dos nomes de arquivos em seu bucket. Isso pode otimizar o desempenho de suas consultas, percorrendo apenas arquivos e diretórios relevantes. Para saber mais, confira a Docs da Atlas Data Federation.
Depois de adicionar os dados do bucket do3 S, podemos arrastá-los para a coleção virtual como uma fonte de dados.

Renomeie o banco de dados virtual e a collection

Os nomes "VirtualDatabase0 " e "VirtualCollection0 " não parecem apropriados para nossos dados. Vamos renomeá-los para "test " e "orders ", respectivamente, para corresponder aos dados no Atlas cluster.
Configuração da instância federada

Verificar a configuração JSON.

Finalmente, para garantir que nossa configuração esteja correta, podemos mudar para a visualização JSON no canto superior direito, ao lado do botão “Save”. Sua configuração, exceto o ID do projeto e o nome do cluster, deve ser idêntica a esta:
1{
2 "databases": [
3 {
4 "name": "test",
5 "collections": [
6 {
7 "name": "orders",
8 "dataSources": [
9 {
10 "storeName": "M0",
11 "database": "test",
12 "collection": "orders"
13 },
14 {
15 "storeName": "cold-data-mongodb",
16 "path": "/*"
17 }
18 ]
19 }
20 ],
21 "views": []
22 }
23 ],
24 "stores": [
25 {
26 "name": "M0",
27 "provider": "atlas",
28 "clusterName": "M0",
29 "projectId": "<your-project-id>"
30 },
31 {
32 "name": "cold-data-mongodb",
33 "provider": "s3",
34 "bucket": "cold-data-mongodb",
35 "prefix": "",
36 "delimiter": "/"
37 }
38 ]
39}
Depois de verificar se tudo está bem, clique no botão “Save”. Se a sua função AWS IAM estiver configurada corretamente, você verá sua instância federada recém-configurada. Agora estamos prontos para nos conectar a ele!

Arquivar dados frios em S3 com $out

Vamos agora coletar o URI que vamos usar para nos conectar ao Atlas Data Federation.
Clique no botão "Connect" e, em seguida, "Connect your application." Copie a string de conexão, pois precisaremos dela em apenas um minuto.
Agora vamos usar o Python para executar nosso pipeline de agregação e arquivar os dois pedidos de 2020 de maio em nosso bucket S3 .
1from datetime import datetime
2
3from pymongo import MongoClient
4
5client = MongoClient('<YOUR_FEDERATED_INSTANCE_URI>')
6db = client.get_database('test')
7coll = db.get_collection('orders')
8
9start_date = datetime(2020, 5, 1) # May 1st
10end_date = datetime(2020, 6, 1) # June 1st
11
12pipeline = [
13 {
14 '$match': {
15 'created': {
16 '$gte': start_date,
17 '$lt': end_date
18 }
19 }
20 },
21 {
22 '$out': {
23 's3': {
24 'bucket': 'cold-data-mongodb',
25 'region': 'eu-west-1',
26 'filename': start_date.isoformat('T', 'milliseconds') + 'Z-' + end_date.isoformat('T', 'milliseconds') + 'Z',
27 'format': {'name': 'json', 'maxFileSize': '200MiB'}
28 }
29 }
30 }
31]
32
33coll.aggregate(pipeline)
34print('Archive created!')
Depois de substituir a connection string pela sua, execute o script:
1python3 archive.py
E agora podemos confirmar que nosso arquivo foi criado corretamente em nosso bucket S3:
"arquivo no bucket S3 "

Exclua os dados "cold " do Atlas

Agora que nossos pedidos estão seguros em S3, posso excluir esses dois pedidos do meu cluster Atlas. Vamos usar Python novamente. Desta vez, precisamos usar o URI do nosso Atlas cluster porque o URI do Atlas Data Federation não permite esse tipo de operação.
1from datetime import datetime
2
3from pymongo import MongoClient
4
5client = MongoClient('<YOUR_ATLAS_URI>')
6db = client.get_database('test')
7coll = db.get_collection('orders')
8
9start_date = datetime(2020, 5, 1) # May 1st
10end_date = datetime(2020, 6, 1) # June 1st
11query = {
12 'created': {
13 '$gte': start_date,
14 '$lt': end_date
15 }
16}
17
18result = coll.delete_many(query)
19print('Deleted', result.deleted_count, 'orders.')
Vamos executar este código:
1python3 remove.py
Agora vamos verificar novamente o que temos em S3. Aqui está o conteúdo do arquivo S3 que baixei:
1{"_id":{"$numberDouble":"1.0"},"created":{"$date":{"$numberLong":"1590796800000"}},"items":[{"$numberDouble":"1.0"},{"$numberDouble":"3.0"}],"price":{"$numberDouble":"20.0"}}
2{"_id":{"$numberDouble":"2.0"},"created":{"$date":{"$numberLong":"1590883200000"}},"items":[{"$numberDouble":"2.0"},{"$numberDouble":"3.0"}],"price":{"$numberDouble":"25.0"}}
E aqui está o que sobrou no meu cluster MongoDB Atlas.
Documentos restantes no cluster do MongoDB Atlas

Queries federadas

Como mencionado acima, com o Data Federation, você pode consultar os dados armazenados no Atlas e S3 simultaneamente. Isso permite que você mantenha o acesso fácil a 100% dos seus dados. Na verdade, já fizemos isso quando executamos o pipeline de agregação com o estágio$out.
Vamos verificar isso uma última vez com Python:
1from pymongo import MongoClient
2
3client = MongoClient('<YOUR_FEDERATED_INSTANCE_URI>')
4db = client.get_database('test')
5coll = db.get_collection('orders')
6
7print('All the docs from S3 + Atlas:')
8docs = coll.find()
9for d in docs:
10 print(d)
11
12pipeline = [
13 {
14 '$group': {
15 '_id': None,
16 'total_price': {
17 '$sum': '$price'
18 }
19 }
20 }, {
21 '$project': {
22 '_id': 0
23 }
24 }
25]
26
27print('\nI can also run an aggregation.')
28print(coll.aggregate(pipeline).next())
Execute o script com:
1python3 federated_queries.py
Aqui está o resultado:
1All the docs from S3 + Atlas:
2{'_id': 1.0, 'created': datetime.datetime(2020, 5, 30, 0, 0), 'items': [1.0, 3.0], 'price': 20.0}
3{'_id': 2.0, 'created': datetime.datetime(2020, 5, 31, 0, 0), 'items': [2.0, 3.0], 'price': 25.0}
4{'_id': 3.0, 'created': datetime.datetime(2020, 6, 1, 0, 0), 'items': [1.0, 3.0], 'price': 20.0}
5{'_id': 4.0, 'created': datetime.datetime(2020, 6, 2, 0, 0), 'items': [1.0, 2.0], 'price': 15.0}
6
7I can also run an aggregation:
8{'total_price': 80.0}

Resumo

Se você tem muitos dados acessados com pouca frequência em seu Atlas, mas ainda precisa ser capaz de consultá-los e acessá-los facilmente depois de arquivá-los no S3, criar uma instância federada ajudará você a economizar muito tempo . Se você estiver procurando uma maneira automatizada de arquivar seus dados dos Atlas no armazenamento S3 totalmente gerenciado, confira nosso novo Atlas Online Archive!
O armazenamento no S3 é muito mais barato do que ampliar seu cluster MongoDB Atlas porque seu cluster está cheio de dados frios e precisa de mais RAM e tamanho de armazenamento para operar corretamente.
Todo o código Python está disponível neste repositório do Github.
Por favor, deixe-nos saber no Twitter se você gostou desta postagem do blog: @MBeugnet e @StanimiraVlaeva.
Se tiver dúvidas, acesse o website da MongoDB Community de desenvolvedores, onde os engenheiros do MongoDB e a MongoDB Community ajudarão você.

Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Relacionado
Tutorial

Otimizando a relevância usando MongoDB Atlas e LlamaIndex


Oct 02, 2024 | 13 min read
Tutorial

MongoDB Atlas com Terraform - Políticas de cluster e backup


Sep 11, 2024 | 22 min read
Tutorial

​​Reinventando a pesquisa multimodal com MongoDB e Anyscale


Sep 18, 2024 | 20 min read
Tutorial

Criação de um agente de AI aprimorado para memória com o laudo do Aconnection no Amazon Cama do MongoDB Atlas


Oct 29, 2024 | 8 min read
Sumário