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 .

Junte-se a nós no Amazon Web Services re:Invent 2024! Saiba como usar o MongoDB para casos de uso de AI .
Desenvolvedor do MongoDB
Central de desenvolvedor do MongoDBchevron-right
Idiomaschevron-right
Pythonchevron-right

Dimensionamento com base na demanda: Implantação de aplicativos Python usando o MongoDB Atlas no Azure App Service

Anaiya Raisinghani12 min read • Published Apr 05, 2023 • Updated Apr 02, 2024
AzureMongoDBPython
Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Gerenciar grandes quantidades de dados localmente pode ser um desafio, especialmente à medida que a quantidade de dados salvos aumenta. Felizmente, existe uma solução eficiente disponível. Ao utilizar os recursos do Flask, do MongoDB Atlas e do Serviço de Aplicativo do Azure, você pode criar e hospedar aplicativos Web poderosos capazes de armazenar e gerenciar toneladas de dados de maneira centralizada, segura e escalonável. Diga adeus aos arquivos locais não confiáveis e olá para uma solução dimensionável.
Este tutorial detalhado aprenderá como criar um aplicativo funcional CRUD (Criar, Ler, Atualizar e Excluir) que se conecta a um banco de dados MongoDB Atlas e é hospedado no Azure App Service. Usar oAzure App Service e oMongoDB juntos pode ser uma ótima maneira de construir e hospedar aplicativos web. O Azure App Service facilita a criação e a implantação de aplicativos web, enquanto o MongoDB é ótimo para armazenar e consultar grandes quantidades de dados. Com essa combinação, você pode se concentrar na criação do seu aplicativo e deixar o Azure tomar conta da infraestrutura subjacente e do dimensionamento.
Este tutorial é destinado a usuários novatos, mas fique à vontade para pular este artigo e focar nos aspectos necessários para o seu projeto.
Vamos fazer uma estante virtual com alguns dos meus livros favoritos. Dentro desta estante, teremos o poder de adicionar um novo livro, ver todos os livros em nossa estante, trocar um livro por outro dos meus favoritos ou remover um livro que gostaria de ler. No final do tutorial, nossa estante de livros será hospedada para que qualquer pessoa com o link do nosso site também possa aproveitar a nossa lista de livros.

Requisitos

Antes de começarmos, precisamos de alguns pré-requisitos:

Configurando um cluster do MongoDB Atlas

Dentro do MongoDB Atlas, precisamos criar um cluster gratuito. Siga as instruções em nosso tutorial do MongoDB Atlas. Após o provisionamento do cluster, crie um banco de dados e uma collection dentro do Atlas. Vamos nomear nosso banco de dados "bookshelf " e nossa collection "books. " Clique em "Insert Document " e adicione em um livro para que tenhamos alguns dados para começar. Sua configuração deve ficar assim:
Texto alternativo: captura de tela da nossa collection "books " mostrando a adição de "The Great Gatsby "
Agora que configuramos nossa estante de livros, estamos prontos para nos conectar a ela e utilizar nossas operações CRUD. Antes de começarmos, vamos nos concentrar em como nos conectar corretamente.

Acesso à segurança do cluster

Agora que temos nosso cluster provisionado e pronto para uso, precisamos garantir que tenhamos acesso adequado ao banco de dados. Por meio doAtlas, podemos fazer isso acessando a seção "Security " no lado esquerdo da tela. Certifique-se de que, em "Database Access, ", você habilitou um usuário com pelo menos "Read and Write'' access. Under “Network Access, ", certifique-se de ter adicionado todo e qualquer endereço IP dos quais você planeja acessar seu banco de dados. Uma maneira fácil de fazer isso é definir o acesso ao endereço IP como "0.0.0.0/0. ". Isso permite que você acesse o cluster de qualquer endereço IP. O Atlas fornece recursos de segurança opcionais adicionais por meio de emparelhamento de rede e conexões privadas, usando todos os principais fornecedores de nuvem. O Azure Private Link faz parte desse recurso de segurança adicional ou, se você tiver provisionado um cluster M10 ou superior, o uso da Azure Virtual Private Connection.

Configuração de um ambiente virtual Python

Antes de abrirmos o Visual Studio Code, use o terminal para criar um diretório no qual o projeto da estante de livros ficará.
Depois de criarmos nosso diretório, abra-o no VSCode e acesse o terminal dentro do VSCode. Vamos configurar nosso ambiente virtual Python. Fazemos isso para que todos os nossos arquivos tenham um local legal para ficar, onde nada mais baixado possa incomodá-los.
Configure seu ambiente com:
1python3 -m venv venv
Ative seu ambiente com:
1source venv/bin/activate
Você saberá que está em seu ambiente virtual quando vir o pequeno (venv) no início do nome do host na linha de comando.
Uma vez em nosso ambiente virtual, estamos prontos para configurar nossos requisitos de projeto. Um arquivo 'requirements.txt' é usado para especificar as dependências (vários pacotes e suas versões) necessárias para a execução do projeto. Ele ajuda a garantir que as versões corretas dos pacotes estejam instaladas ao distribuir o projeto em um novo ambiente. Isso facilita muito a reprodução do ambiente de desenvolvimento e evita problemas de compatibilidade que possam surgir ao usar diferentes versões de dependências.

Configurando nosso 'requirements.txt' arquivo

Nosso arquivo 'requirements.txt' consistirá em quatro dependências diferentes que este projeto exige. O primeiro é o Flask. O Flask é uma microestrutura web para Python. Ele fornece as ferramentas básicas para criar aplicativos da web, como roteamento e tratamento de solicitações. O Flask permite uma fácil integração com outras bibliotecas e estruturas e permite flexibilidade e personalização. Se você nunca trabalhou com o Flask antes, não se preocupe. Ao final deste tutorial, você terá uma compreensão clara de como o Flask pode ser útil .
A segunda dependência que temos é o PyMongo. PyMongo é uma biblioteca Python para trabalhar com MongoDB. Ele fornece uma maneira conveniente de interagir com bancos de dados e coleções MongoDB. Nós o usaremos para se conectar ao nosso banco de dados.
A terceira dependência que temos é Python-dotenv. Esta é uma ferramenta utilizada para armazenar e acessar informações importantes, como senhas e chaves secretas, de forma segura. Em vez de codificar essas informações, Python-dotenv nos permite manter essas informações em uma variável de ambiente em um arquivo separado que não é compartilhado com mais ninguém. Posteriormente neste tutorial, entraremos em mais detalhes sobre como configurar corretamente as variáveis de ambiente em nosso projeto.
A última dependência que temos em nosso arquivo é Black. Black é um formatador de código para Python e impõe um estilo de codificação consistente, facilitando a leitura e a manutenção do código para os desenvolvedores. Ao usar um estilo de código comum, ele pode melhorar a legibilidade e a manutenção.
Inclua estas quatro dependências em seu 'requirements.txt' Migrator.
1Flask==2.2.2
2pymongo==4.3.3
3python-dotenv==0.21.1
4black==22.12.0
Desta forma, podemos instalar todas as nossas dependências em uma única etapa:
1pip install -r requirements.txt
Soluçãode problemas: depois de instalar o PyMongo com êxito, provavelmente será exibida uma linha em seu terminal com os dizeres dnspython has been installed. É importante notar que, sem o dnspython baixado corretamente, nosso próximo pacote dotenv não funcionará. Se, ao tentar executar nosso script mais tarde, você estiver obtendo ModuleNotFoundError: No module named dotenv, inclua dnspython==2.2.1 em seu arquivo "requirements.txt" e execute novamente o comando acima.

Configurando nosso 'app.py' arquivo

O nosso 'app.py' file é o arquivo principal em que nosso código para nosso projeto bookshelf ficará. Crie um novo arquivo dentro de nosso diretório “azuredemo” e nomeie-o de 'app.py'. É hora de incluir nossas importações:
1import bson
2import os
3from dotenv import load_dotenv
4from flask import Flask, render_template, request
5from pymongo import MongoClient
6from pymongo.collection import Collection
7from pymongo.database import Database
Aqui temos nossas importações de variáveis de ambiente, nossas importações de Flask, nossas importações de PyMongo e a importação de BSON que precisamos para trabalhar com dados JSON binários.
Depois de configurarmos nossas importações, estaremos prontos para nos conectar ao nosso cluster MongoDB Atlas e implementar nossas funções CRUD, mas primeiro vamos testar e garantir que o Flask esteja instalado corretamente.
Execute este aplicativo Flask muito simples:
1app: Flask = Flask(__name__)
2# our initial form page
3@app.route(‘/’)
4def index():
5 return “Hi!”
Aqui, continuamos criando um novo objeto de aplicativo Spark, que nomeamos de "app " e demos a ele o nome do nosso arquivo atual. Em seguida, criamos uma nova rota para o aplicativo. Isso informa ao servidor qual URL escutar e qual função executar quando essa URL for solicitada. Neste exemplo específico, a rota é a página inicial e a função que é executada retorna a string "Hi! ".
Execute seu aplicativo mantendo o uso de:
1flask run
Isso abre a porta 5000, que é a porta padrão do Flask, mas você sempre pode alternar a porta que está usando executando o comando:
1flask run -p [port number]
Quando acessamos http://127.0.0.1:5000, vemos: captura de tela da nossa porta 5000 mostrando "Hi! " na tela
Então, nosso aplicativo Incrívelmente simples funciona! Incrível. Vamos agora conectá-lo ao nosso banco de dados.

Conectando nosso aplicativo Flask ao MongoDB

Como mencionado acima, usaremos uma variável de ambiente de banco de dados para conectar nosso banco de dados. Para fazer isso, precisamos configurar um arquivo .env. Adicione este arquivo no mesmo diretório com o qual estamos trabalhando e inclua sua connection string do MongoDB. Sua connection string é uma string semelhante a uma URL usada para se conectar a um servidor MongoDB. Ele inclui todos os detalhes necessários para se conectar ao seu cluster específico. É assim que sua configuração deve ficar:
captura de tela da árvore de arquivos e da connection string do MongoDB
Altere username e password para você. Certifique-se de ter definido os pontos de acesso de rede adequados no número acima.
Queremos usar variáveis de ambiente para poder mantê-las separadas do nosso código. Dessa forma, há privacidade, pois o CONNECTION_STRING contém informações confidenciais. É crucial para fins de segurança e manutenção.
Depois de fazer suas importações, precisamos adicionar algumas linhas de código acima da instanciação do Flask para que possamos nos conectar ao nosso arquivo .env que contém nosso CONNECTION_STRING e nos conectar ao nosso banco de dados Atlas. Nesse ponto, seu app.py deve ter a seguinte aparência:
1import bson
2import os
3from dotenv import load_dotenv
4from flask import Flask, render_template, request
5from pymongo import MongoClient
6from pymongo.collection import Collection
7from pymongo.database import Database
8# access your MongoDB Atlas cluster
9load_dotenv()
10connection_string: str = os.environ.get(“CONNECTION_STRING”)
11mongo_client: MongoClient = MongoClient(connection_string)
12
13# add in your database and collection from Atlas
14database: Database = mongo_client.get_database(“bookshelf”)
15collection: Collection = database.get_collection(“books”)
16# instantiating new object with “name”
17app: Flask = Flask(__name__)
18
19# our initial form page
20@app.route(‘/’)
21def index():
22 return “Hi!”
Vamos testar app.py e garantir que a conexão com o cluster esteja em vigor. Adicione estas duas linhas após a linhacollection = database[“books”] e antes da linha #instantiating new object with name para verificar e garantir que o aplicativo Frask esteja realmente conectado ao seu banco de dados:
1book = {“title”: “The Great Gatsby”, “author”: “F. Scott Fitzgerald”, “year”: 1925}
2collection.insert_one(book)
Execute seu aplicativo, acesse o Atlas e você deverá ver a cópia adicional de "The Great Gatsby " adicionada.
captura de tela da nossa collection "books " mostrando ambas as cópias de "The Great Gatsby "
Incrível! Conectamos com sucesso nosso aplicativo MongoDB ao MongoDB. Vamos começar a configurar nossas funções CRUD (Create, Read, Update, Delete).
Sinta-se à vontade para excluir essas duas linhas de código adicionadas e remover manualmente os dois documentos de Gatsby do Atlas. Isso foi para fins de teste!

Criando funções CRUD

No momento, codificamos nosso “Hi!” na tela. Em vez disso, é mais fácil renderizar um modelo para nossa página inicial. Para fazer isso, crie uma nova pasta chamada “templates” em seu diretório. Dentro desta pasta, crie um arquivo chamado: index.html. É aqui que irão todo o HTML e CSS da nossa página inicial. Isso é altamente personalizável e não é o foco do tutorial, então acesse este código no meu Github (ou faça o seu próprio!).
Assim que nosso arquivoindex.htmlestiver concluído, vamos vinculá-lo ao nosso arquivoapp.py para que possamos ler tudo corretamente. É aqui que entra a adição da importaçãorender_template . Vincule seu arquivoindex.htmlem sua função de página de formulário inicial da seguinte forma:
1# our initial form page
2@app.route(‘/’)
3def index():
4 return render_template(“index.html”)
Quando você executá-lo, esta deve ser sua nova página inicial ao acessar http://127.0.0.1:5000/:
captura de tela da página inicial atualizada
Estamos prontos para passar para nossas funções CRUD.

Criar e ler funções

Estamos combinando nossas duas funções Criar e Ler. Isso nos permitirá adicionar um novo livro à nossa estante e ver todos os livros que temos em nossa estante, dependendo do método de solicitação que escolhermos.
1# CREATE and READ
2@app.route('/books', methods=["GET", "POST"])
3def books():
4 if request.method == 'POST':
5 # CREATE
6 book: str = request.json['book']
7 pages: str = request.json['pages']
8
9 # insert new book into books collection in MongoDB
10 collection.insert_one({"book": book, "pages": pages})
11
12 return f"CREATE: Your book {book} ({pages} pages) has been added to your bookshelf.\n "
13
14 elif request.method == 'GET':
15 # READ
16 bookshelf = list(collection.find())
17 novels = []
18
19 for titles in bookshelf:
20 book = titles['book']
21 pages = titles['pages']
22 shelf = {'book': book, 'pages': pages}
23 novels.insert(0,shelf)
24
25 return novels
Essa função está conectada à nossa rota '/books' e, dependendo do método de solicitação que enviamos, podemos adicionar um novo livro ou ver todos os livros que já temos em nosso banco de dados. Não validaremos nenhum dos dados neste exemplo porque ele está fora do escopo, mas use Postman, cURL ou uma ferramenta semelhante para verificar se a função está implementada corretamente. Para esta função, inseri:
1{
2 “book”: “The Odyssey”,
3 “pages”: 384
4}
Se formos ao nosso portal do Atlas, atualizarmos e verificarmos nosso banco de dados "bookshelf " e a collection "books ", é isso que vamos ver:
captura de tela da nossa collection “books " mostrando "The Odyssey "
Vamos inserir mais um livro de nossa escolha apenas para adicionar mais alguns dados ao nosso banco de dados. Vou acrescentar "The Perks of Being a Wallflower."
Incrível! Leia a collection do banco de dados de volta e você deverá ver os dois livros.
Vamos para a função UPDATE.

Atualização

Para esta função, queremos trocar um livro atual em nossa estante por um livro diferente.
1# UPDATE
2@app.route("/books/<string:book_id>", methods = ['PUT'])
3def update_book(book_id: str):
4 new_book: str = request.json['book']
5 new_pages: str = request.json['pages']
6 collection.update_one({"_id": bson.ObjectId(book_id)}, {"$set": {"book": new_book, "pages": new_pages}})
7
8 return f"UPDATE: Your book has been updated to: {new_book} ({new_pages} pages).\n"
Esta função nos permite trocar um livro que temos atualmente em nosso banco de dados por um novo livro. A troca ocorre por meio do ID do livro. Para fazer isso, acesse o Atlas e copie o ID que deseja usar e inclua-o no final do URL. Para isso, gostaria de trocar "The Odyssey " por "The Stranger ". Use sua ferramenta de teste para se comunicar com o endpoint de atualização e visualizar os resultados no Atlas.
Depois de clicar em enviar e atualizar seu banco de dados do Atlas, você verá: captura de tela da nossa collection "books " com "The Stranger " e "The Perks of Being a Wallflower "
“The Odyssey " foi trocado por "The Stranger "!
Agora, vamos para a nossa última função: a função DELETE.

Excluir

1# DELETE
2@app.route("/books/<string:book_id>", methods = ['DELETE'])
3def remove_book(book_id: str):
4 collection.delete_one({"_id": bson.ObjectId(book_id)})
5
6 return f"DELETE: Your book (id = {book_id}) has been removed from your bookshelf.\n"
Essa função nos permite remover um livro específico da nossa estante. Da mesma forma que a função UPDATE, precisamos especificar qual livro queremos excluir através da rota URL usando o ID dos romances. Vamos retirar nosso último livro da estante para ler, “The Stranger”.
Comunique-se com o endpoint de exclusão e execute a função.
No Atlas, nossos resultados são exibidos:
captura de tela da coleção "books " mostrando "The Perks of Being a Wallflower "
O “The Stranger” foi removido!
Parabéns, você criou com sucesso um aplicativo Flask que pode utilizar as funcionalidades CRUD, enquanto usa o MongoDB Atlas como seu banco de dados. Isso é muita coisa. Mas... mais alguém pode usar a sua estante de livros! É hospedado apenas localmente. O Microsoft Azure App Service pode nos ajudar com isso. Vamos hospedar nosso aplicativo Flask no App Service.

Hospede seu aplicativo no Microsoft Azure App Service

Estamos usando o Visual Studio Code para esta demonstração, portanto, certifique-se de ter instalado a extensão do Azure e de ter assinado sua assinatura. Há outras maneiras de trabalhar com o Azure App Service, e usar o Visual Studio Code é uma preferência pessoal.
captura de tela do app.py e do painel Azure Resource no VSCode
Se você estiver conectado corretamente, verá sua assinatura do Azure no lado esquerdo.
Clique no sinal (+) ao lado de Recursos: Captura de tela de onde clicar no sinal (+) para criar um novo recurso no VSCode
Clique em “Create App Service Web App”: captura de tela de como selecionar o recurso adequado para este projeto
Insira um novo nome. Isso servirá como o URL do seu site, portanto, certifique-se de que não seja muito dinâmico: captura de tela de como inserir um nome exclusivo para a nova aplicação da web
Selecione sua pilha de tempo de execução. O meu é Python 3.9: captura de tela de qual pilha de tempo de execução selecionar para este projeto
Selecione sua camada de preços. O nível gratuito funcionará para esta demonstração. captura de tela de qual nível de preço selecionar para este projeto
No Registro de atividades do Azure, você verá o aplicativo web sendo criado.  captura de tela da saída depois que seu aplicativo web for criado
Você será solicitado a implantar seu aplicativo da web e, em seguida, escolher a pasta que deseja implantar: captura de tela de qual pasta escolher para implantar seu aplicativo da web
Ele começará a ser implantado, como você verá através do "Output Window " no registro do Azure App Service.
Quando terminar, você verá um botão que diz "Browse Website. " Clique nele. captura de tela da saída depois que seu projeto for implementado e como visualizá-lo
Como você pode ver, nosso aplicativo agora está hospedado em um local diferente! Ele agora tem seu próprio URL. captura de tela do nosso projeto hospedado em um servidor Azure diferente
Vamos garantir que ainda possamos utilizar nossas operações CRUD com nosso novo URL. Teste novamente para cada função.
Em cada etapa, se atualizarmos nosso banco de dados do MongoDB Atlas, verão essas alterações ocorrerem também lá. ótimo trabalho!

Conclusão

Parabéns! Criamos com sucesso um aplicativo Flask do zero, o conectamos ao nosso MongoDB database e o hospedamos no Azure App Service. Essas habilidades continuarão a ser úteis e espero que você tenha gostado da jornada. Separadamente, o Azure App Service e o MongoDB hospedam uma variedade de benefícios. Juntos, eles são imbatíveis! Combinados, eles fornecem uma plataforma poderosa para criar e dimensionar aplicativos web que podem lidar com grandes quantidades de dados. O Azure App Service facilita a implantação e a escalabilidade de aplicativos web, enquanto o MongoDB fornece uma solução de armazenamento de dados flexível e escalável.
Obtenha informações sobre MongoDB Atlas, Azure App Servicee Pipeline.
Se você leu este tutorial e gostaria de mergulhar ainda mais no MongoDB Atlas e nas funcionalidades disponíveis, assista ao meu vídeo no YouTube.

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

Usar a Atlas Vector Search do MongoDB com LangChain


Sep 18, 2024 | 6 min read
Início rápido

Primeiros passos no MongoDB e Starlette


Jul 12, 2024 | 5 min read
Tutorial

Introdução ao MongoDB e ao AWS Codewhisperer


Sep 26, 2024 | 3 min read
Tutorial

Como otimizar aplicativos LLM com compactação de prompts usando LLMLingua e LangChain


Jun 18, 2024 | 13 min read
Sumário