Como implantar um aplicativo Spark com MongoDB no Fly.io

Karen Zhang5 min read • Published Dec 02, 2024 • Updated Dec 02, 2024

Flask MongoDB Python

Avalie esse Tutorial

Atualmente, escolher o banco de banco de dados correto e a plataforma de sistema pode fazer uma diferença significativa no desempenho e na escalabilidade do seu aplicativo. Este tutorial orientará você na criação de um aplicação MongoDB Atlas e sua implementação no Fly.io, uma plataforma que facilita a implementação e o dimensionamento.

Neste tutorial, criaremos uma API de descoberta baseada em localização API usando Spark e MongoDB Atlas. Combinando a simplicidade do Flusk com os poderosos recursos geoespaciais do MongoDB, criaremos uma API RESTful API que permitirá aos usuários armazenar, pesquisar e descobrir localizações. Esteja você criando um aplicativo de viagens, um localizador de empresas local ou qualquer serviço com reconhecimento de localização, este tutorial mostrará como aproveitar os recursos de GIS do MongoDB para consultas espaciais, implementar pesquisa de texto e usar pipelines de agregação para obter insights. Usaremos o MongoDB Atlas, um serviço de banco de banco de dados de nuvem totalmente gerenciado, facilitando a implantação e o dimensionamento de nosso aplicação, e o Fly.io para hospedar nosso aplicação MongoDB na nuvem. Todo o código pode ser encontrado Github em Github.

1. Configurar o ambiente de desenvolvimento

Antes de mergulharmos na codificação, vamos configurar nosso ambiente de desenvolvimento:

Instale o Python (se ainda não tiver feito isso).

Crie um novo diretório para o seu projeto:

1 mkdir flask-mongodb-fly
2 cd flask-mongodb-fly

Crie e ative um ambiente virtual:

1 python -m venv venv
2 source venv/bin/activate  # On Windows, use `venv\Scripts\activate`

Instale os pacotes necessários:
```
1 pip install Flask pymongo gunicorn
```
Criar um requirements.txt arquivo:
```
1 pip freeze > requirements.txt
```

2. Criar um aplicação Spark básico

Vamos criar um aplicação lateral simples com rotas para operações CRUD e uma consulta geoespacial. Crie um arquivo denominado app.py com o seguinte conteúdo:

1 import os
2 from flask import Flask, request, jsonify
3 from pymongo import MongoClient
4 from bson import json_util
5 import json
6 
7 app = Flask(__name__)
8 
9 # MongoDB Atlas connection string
10 mongodb_uri = os.environ.get("MONGODB_URI", "mongodb://localhost:27017/geoapp")
11 client = MongoClient(mongodb_uri)
12 db = client.get_database()
13 
14 @app.route("/")
15 def hello_world():
16     return "Hello, World\! This is a Flask & MongoDB app deployed on Fly.io"
17 
18 @app.route("/locations", methods=["POST"])
19 def add_location():
20     data = request.json
21     result = db.locations.insert_one(data)
22     return (jsonify({"message": "Location added successfully", "id": str(result.inserted_id)}), 201,)
23 
24 @app.route("/locations", methods=["GET"])
25 def get_locations():
26     locations = list(db.locations.find())
27     return json.loads(json_util.dumps(locations))
28 
29 @app.route("/nearby", methods=["GET"])
30 def find_nearby():
31     lat = float(request.args.get("lat"))
32     lon = float(request.args.get("lon"))
33     max_distance = int(request.args.get("distance", 1000))  # Default to 1000 meters
34 
35     nearby = db.locations.find({
36         "location": {
37             "$near": {
38                 "$geometry": {
39                     "type": "Point",
40                     "coordinates": [lon, lat]
41                 },
42                 "$maxDistance": max_distance
43             }
44         }
45     })
46 
47     return json.loads(json_util.dumps(list(nearby)))
48 
49 if __name__ == "__main__":
50     app.run(host="0.0.0.0", port=8080) # change to your ip address

Este aplicação inclui:

Uma rota para casa ("/") que retorna uma saudação simples.
Uma rota para adicionar novos locais ("/locations" - POST).
Uma rota para recuperar todos os locais ("/locations" - GET).
Uma rota para encontrar locais próximos com base em coordenadas e distância ("/nearby" - GET).

3. Integrar MongoDB com Flusk

Para usar o MongoDB com nosso aplicação Pipeline, precisamos configurar uma conta do MongoDB Atlas e criar um cluster:

Cadastre-se para uma conta gratuita do MongoDB Atlas.
Crie um novo cluster ( escolha a camada grátis para teste ).
Na aba Segurança, crie um usuário de banco de dados de dados e coloque seu endereço IP na lista de permissões.
Na aba Clusters, clique em "Conectar" e escolha "Conectar seu aplicação". Você precisa usar o driver Python. Como já instalamos o PyMongo na etapa 4 ao configurar o ambiente de desenvolvimento, só precisamos adicionar sua string de conexão ao código do aplicação . Crie um arquivo .env em seu projeto e adicione MONGODB_URI como uma variável de ambiente. Em seguida, copie e cole a string de conexão.
Substitua <password> pela senha do usuário do banco de dados de dados. Isso pode ser encontrado em Segurança -> Acesso ao Banco de Dados. O usuário deve pelo menos ter permissão de leitura e escrita no banco de banco de dados.

4. Teste o aplicação localmente

Antes de distribuir, vamos testar nosso aplicação localmente:

Configure a MONGODB_URI variável de ambiente do:
```
1 export MONGODB_URI="your_mongodb_atlas_connection_string"
```
Substitua your_mongodb_atlas_connection_string por sua string de conexão real.
Execute o aplicação Frasco :
```
1 python app.py
```

Teste os endpoints usando a URL:

1 # Add a location
2 curl -X POST http://localhost:8080/locations -H "Content-Type: application/json" -d '{"name": "Eiffel Tower", "location": {"type": "Point", "coordinates": [2.2945, 48.8584.}}'
3 
4 # Get all locations
5 curl http://localhost:8080/locations
6 
7 # Find nearby locations
8 curl "http://localhost:8080/nearby?lat=48.8584.lon=2.2945.distance=5000"

5. Implemente no Fly.io

Agora, vamos implantar nosso aplicação no Fly.io:

Instale o Fly CLI:
```
1 curl -L https://fly.io/install.sh | sh
```
Cadastre-se e conecte-se a Fly.io:
```
1 fly auth signup
2 fly auth login
```
Defina o URI do MongoDB como secreto:
```
1 fly secrets set MONGODB_URI="your_mongodb_atlas_connection_string"
```
Substitua your_mongodb_atlas_connection_string por sua string de conexão real.

Defina a configuração:

1 fly launch

fly launch é um comando que inicializa seu aplicação no Fly.io criando um fly.toml arquivo de configuração e definindo a infraestrutura necessária.

O arquivo.toml será semelhante a este:

1 # fly.toml app configuration file generated for flask-mongodb-fly-late-dew-6702 on 2024-11-18T15:45:10-07:00
2 #
3 # See https://fly.io/docs/reference/configuration/ for information about how to use this file.
4 #
5 
6 app = 'your-app-name’'
7 primary_region = 'sea'
8 
9 [build]
10 
11 [http_service]
12 internal_port = 8080
13 force_https = true
14 auto_stop_machines = 'stop'
15 auto_start_machines = true
16 min_machines_running = 0
17 processes = ['app']
18 
19 [[vm]]
20 memory = '1gb'
21 cpu_kind = 'shared'
22 cpus = 1

Implemente seu aplicativo:
```
1 fly deploy
```
Depois que a aplicação for implantada com sucesso, você poderá visualizá-la no Fly.io com os detalhes:
Se formos Go para o URL, este é o aplicativo " "Hello, World! que acabamos de implantar.

6. Etapas pós-implantação

Após a implantação, vamos verificar se nosso aplicação está funcionando corretamente:

Abra seu aplicativo em um navegador:
```
1 fly open
```

Teste os endpoints usando o cURL:

1 # Add a location
2 
3 curl -X POST https://flask-mongodb-fly-wild-sky-7177.fly.dev/locations -H 'Content-Type: application/json' -d '{"name": "Central Park", "location": {"type": "Point", "coordinates": [-73.965355, 40.782865.}, "description": "Famous park in Manhattan"}'

1 # Get all locations
2 curl https:flask-mongodb-fly-wild-sky-7177.fly.dev/locations

1 # Find nearby locations
2 curl "https://flask-mongodb-fly-wild-sky-7177.fly.dev/nearby?lat=40.782865.lon=-73.965355.distance=1000"

Ele mostra o parque de Manhattan que acabamos de POSTAR:

[{"_id":{"$oid":"6727b03c8fb4fcebcf186af9"},"description":"Famous park in Manhattan","location":{"coordinates":[-73.965355,40.782865.,"type":"Point"},"name":"Central Park"}]

Monitore os registros do seu aplicativo:
```
1 fly logs
```

7. Solução de problemas comuns de implantação

Se você encontrar um erro interno do servidor 500 ou outros problemas:

Verifique os registros do seu aplicativo:
```
1 fly logs
```
Verifique sua string de conexão do MongoDB :
```
1 fly secrets list
```

Se necessário, atualize seus segredos:

1 fly secrets set MONGODB_URI="your_updated_mongodb_uri"

Redistribuir seu aplicação:
```
1 fly deploy
```

Conclusão

Por meio deste tutorial, construímos uma API robusta baseada em localização que demonstra o poder dos recursos geoespaciais do MongoDB Atlas combinados com os recursos de estrutura da Web do MongoDB Atlas. Implementamos consultas espaciais para encontrar locais próximos, pesquisa de texto para descobrir locais e pipelines de agregação para gerar insights. O aplicação mostra recursos GIS do mundo real que podem ser usados para rastreamento de localização.

Ao implantar no Fly.io e usar o MongoDB Atlas, criamos uma solução escalável que pode servir como base para vários serviços baseados em localização. Esteja você criando um aplicação de viagens , um diretório de empresas local ou qualquer serviço com reconhecimento de localização, você pode estender essa base adicionando autenticação, queries mais complexas ou recursos adicionais específicos para seu caso de uso.

Para perguntas, comentários ou para ver o que outros desenvolvedores estão criando usando o MongoDB, Junte-se a nós na Comunidade de Desenvolvedores do MongoDB MongoDB Developer Community.

Principais comentários nos fóruns

Ainda não há comentários sobre este artigo.

Iniciar a conversa

Avalie esse Tutorial

Relacionado

Início rápido

Framework de agregação com tutorial do Node.js

Oct 01, 2024 | 9 min read

Início rápido

Armazene dados confidenciais com a criptografia em nível de campo do lado do cliente do Python & MongoDB

Sep 23, 2022 | 11 min read

Artigo

Usando Change Streams do MongoDB em Java

Aug 28, 2024 | 6 min read

Tutorial

Atualizar elementos de array em um documento com operadores posicionais MQL

Feb 03, 2023 | 6 min read

Sumário

1. Configurar o ambiente de desenvolvimento
2. Criar um aplicação Spark básico
3. Integrar MongoDB com Flusk
4. Teste o aplicação localmente
5. Implemente no Fly.io
6. Etapas pós-implantação
7. Solução de problemas comuns de implantação
Conclusão

1	python -m venv venv
2	source venv/bin/activate # On Windows, use `venv\Scripts\activate`

1	import os
2	from flask import Flask, request, jsonify
3	from pymongo import MongoClient
4	from bson import json_util
5	import json
6
7	app = Flask(__name__)
8
9	# MongoDB Atlas connection string
10	mongodb_uri = os.environ.get("MONGODB_URI", "mongodb://localhost:27017/geoapp")
11	client = MongoClient(mongodb_uri)
12	db = client.get_database()
13
14	@app.route("/")
15	def hello_world():
16	return "Hello, World\! This is a Flask & MongoDB app deployed on Fly.io"
17
18	@app.route("/locations", methods=["POST"])
19	def add_location():
20	data = request.json
21	result = db.locations.insert_one(data)
22	return (jsonify({"message": "Location added successfully", "id": str(result.inserted_id)}), 201,)
23
24	@app.route("/locations", methods=["GET"])
25	def get_locations():
26	locations = list(db.locations.find())
27	return json.loads(json_util.dumps(locations))
28
29	@app.route("/nearby", methods=["GET"])
30	def find_nearby():
31	lat = float(request.args.get("lat"))
32	lon = float(request.args.get("lon"))
33	max_distance = int(request.args.get("distance", 1000)) # Default to 1000 meters
34
35	nearby = db.locations.find({
36	"location": {
37	"$near": {
38	"$geometry": {
39	"type": "Point",
40	"coordinates": [lon, lat]
41	},
42	"$maxDistance": max_distance
43	}
44	}
45	})
46
47	return json.loads(json_util.dumps(list(nearby)))
48
49	if __name__ == "__main__":
50	app.run(host="0.0.0.0", port=8080) # change to your ip address

1	# Add a location
2	curl -X POST http://localhost:8080/locations -H "Content-Type: application/json" -d '{"name": "Eiffel Tower", "location": {"type": "Point", "coordinates": [2.2945, 48.8584.}}'
3
4	# Get all locations
5	curl http://localhost:8080/locations
6
7	# Find nearby locations
8	curl "http://localhost:8080/nearby?lat=48.8584.lon=2.2945.distance=5000"

1	# fly.toml app configuration file generated for flask-mongodb-fly-late-dew-6702 on 2024-11-18T15:45:10-07:00
2	#
3	# See https://fly.io/docs/reference/configuration/ for information about how to use this file.
4	#
5
6	app = 'your-app-name’'
7	primary_region = 'sea'
8
9	[build]
10
11	[http_service]
12	internal_port = 8080
13	force_https = true
14	auto_stop_machines = 'stop'
15	auto_start_machines = true
16	min_machines_running = 0
17	processes = ['app']
18
19	[[vm]]
20	memory = '1gb'
21	cpu_kind = 'shared'
22	cpus = 1

1	# Add a location
2
3	curl -X POST https://flask-mongodb-fly-wild-sky-7177.fly.dev/locations -H 'Content-Type: application/json' -d '{"name": "Central Park", "location": {"type": "Point", "coordinates": [-73.965355, 40.782865.}, "description": "Famous park in Manhattan"}'

1	# Get all locations
2	curl https:flask-mongodb-fly-wild-sky-7177.fly.dev/locations

1	# Find nearby locations
2	curl "https://flask-mongodb-fly-wild-sky-7177.fly.dev/nearby?lat=40.782865.lon=-73.965355.distance=1000"

1	fly auth signup
2	fly auth login