Michael Aboagye é um engenheiro de segurança/software de back-end que mora em Gana. Ele está interessado em criar serviços de back-end seguros com Python.
Neste tutorial, veremos como criar um aplicativo Web de diário com base na estrutura do flask com o Couchbase como servidor de back-end.
Ao final deste tutorial, você será capaz de criar um aplicativo Web simples com a estrutura do Flask para enviar os detalhes dos usuários a um servidor Couchbase. Além disso, você aprenderá a instalar e configurar um servidor Couchbase.
Pré-requisitos
Você precisa dos seguintes pacotes para executar ou clonar o projeto do GitHub.
- Estrutura do Flask (versão mais recente)
A estrutura Flask é uma microestrutura escrita em Python. É uma microestrutura porque não vem com um formulário de validação, mecanismo de autenticação e assim por diante. Ela permite que você personalize os aplicativos à sua maneira.
- Modelo Jinja (versão mais recente)
O modelo Jinja é simplesmente um arquivo de texto que contém variáveis e expressões, que são substituídas quando um modelo é renderizado ou exibido.
- Servidor Couchbase (edição comunitária)
O Couchbase Server é um banco de dados de documentos NoSQL dimensionável. Usaremos o servidor Couchbase para armazenar os dados dos usuários.
Criar um ambiente virtual
Primeiro, crie um diretório para manter o ambiente virtual usando mkdir comando.
O comando abaixo cria um diretório como projeto web e o transforma em projeto web diretório.
|
1 2 |
mkdir webproject && cd webproject Virtualenv diary |
Depois disso, mude para o diretório do diário para ativar o ambiente virtual usando os seguintes comandos:
|
1 2 3 |
mkdir webproject && cd webproject Virtualenv diary |
Quando estivermos dentro do ambiente virtual, poderemos instalar pacotes sem medo de entrar em conflito com os pacotes do sistema.
Instalar a estrutura do Flask e outros pacotes
Nesta seção, instalaremos a estrutura do Flask escrita em Python e outros pacotes necessários para o projeto.
Vamos instalar os pacotes necessários para este projeto usando o pip e o dpkg.
|
1 2 3 4 5 |
pip install couchbase pip install jinja Pip install flask |
Neste tutorial, executaremos o Couchbase Server por meio do Docker. Você precisa ter o Docker em seu host local ou máquina de desenvolvimento para poder extrair ou baixar imagens do Couchbase de dockerhub.
Navegue até o terminal e digite o seguinte para acessar o repositório do DockerHub:
|
1 |
docker login |
Em seguida, será solicitado que você forneça suas credenciais antes de poder acessar ou "extrair" imagens do DockerHub.
|
1 |
docker pull couchbase/server |
Você precisa executar os comandos do Docker como usuário root.
No entanto, se você preferir instalar o Couchbase Server manualmente, o Couchbase oferece duas formas de instalação para distribuições baseadas no Debian e no Redat. Você pode dar uma olhada em Couchbase.
Faça o download do Python SDK 2.5 para o Couchbase Server
Para acessar o servidor do Couchbase, precisamos fazer download do cliente Couchbase SDK para acessar um cluster do Couchbase. O Couchbase fornece SDKs para linguagens de programação como Python, .NET e Java. Vamos baixar e instalar o Couchbase SDK para Python usando o pip:
|
1 |
pip install couchbase |
Configurar e iniciar o servidor Couchbase
Depois de extrair as imagens do Couchbase Server do DockerHub, podemos criar e executar um novo contêiner usando o seguinte comando:
|
1 |
docker run -d --name db -p 8091-8094:8091-8094 -p 11210:11210 couchbase |
execução do docker: Esse comando cria uma camada de contêiner sobre a imagem do Couchbase e a inicia.
-d : O sinalizador -d significa que o contêiner é executado como um daemon
-name : Esse é o nome do novo contêiner
-p : Esse sinalizador é para mapeamento de portas
Agora estamos executando o servidor Couchbase em um contêiner.
Em seu navegador, acesse https://localhost:8091 em seu computador para configurar o servidor Couchbase.
Como você pode ver, temos opções para criar um novo cluster ou ingressar em um cluster existente. Vamos escolher a opção para configurar um novo cluster único. Defina um nome de cluster, crie um nome de usuário para Administrador e uma senha de 6 caracteres, conforme mostrado abaixo:
Vamos usar as configurações padrão. Precisamos definir o nome do host ou o endereço IP do nosso novo cluster. Não alteraremos o disco de dados, o caminho do disco de índices e o caminho do disco do Analytics para os fins deste projeto.
Além disso, não há necessidade de alterar as cotas de memória, a menos que você não tenha RAM suficiente. Por fim, são apresentadas duas opções: iniciar o servidor Couchbase com as configurações padrão ou configurar a memória e os serviços.
Clique no botão que permite que você configure a memória e os serviços do Couchbase Server.
A seção Host Name ou IP Address permite definir um nome de host, como localhost ou 192.168.15.12. O caminho do disco de dados permite que você defina o caminho.
Então criar um balde chamado "users-data" por meio do console da Web do Couchbase.
Escrever código no lado do servidor para o aplicativo Diário
SAté dentro de seu ambiente virtual, crie um arquivo nomeado app.py. Dentro do arquivo app.py, copie e cole o seguinte código:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
from flask import Flask from couchbase import Couchbase client = Couchbase.connect(host = "localhost", Password = “Password_here”, bucket = "Users-data") @app.route('/home', method=['GET']) def home_page(): return render_template('home.html') @app.route('/home/create-memo'), method=['POST']) def create_memo(): if method == “POST”: diary = { "memo" : request.form["memo"], "year" : request.form["year"], "month" : request.form["month"], "day" : request.form["day"] } Key=uuid.uuid1.hex() user_doc=json.dumps(diary) client.set(key, user_doc) return redirect(url_for("index")) return render_view("create.html") |
No código acima, importamos a estrutura Flask e o cliente Couchbase para Python. Em seguida, nos conectamos ao bucket Users-data por meio do método de conexão do cliente Couchbase. Em seguida, criamos uma rota para a página inicial e a página create-memo para os usuários.
Também podemos criar uma rota para a página de mensagens. Essa página exibirá a mensagem enviada por um usuário. Dentro do arquivo "app.py", escreva o seguinte código para recuperar uma mensagem de usuário específica do servidor Couchbase:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
@app.route(‘home/saved-messages‘, method=[‘GET’,‘POST’]) def get saved_messages(): Saved_messages = client.get(key) Saved_event = json.loads(saved_messages) if request.method == “POST”: Saved_event.memo = request.form[“memo”] Saved_event.year = request.form[“year”] Saved_event.month = request.form[“month”] Saved_event.day = request.form[“day”] user_doc = json.dumps(diary) client.set(key, user_doc) return redirect(url_for(home_page)) return render_template(“saved.html”, model=Saved_event) |
Ainda dentro do diretório do projeto, crie um subdiretório usando o comando mkdir, conforme mostrado abaixo:
|
1 |
mkdir templates |
Dentro do diretório de modelos, crie os arquivos home.html, savedmemo.html e postmemo.html com o comando touch:
|
1 |
touch home.html create.html saved.html |
Cole o código a seguir no arquivo home.html:
|
1 2 3 4 5 6 7 8 9 |
<html> <head> <title>Welcome to Daily Memo Book</title> </head> <body> <h1> Remember Your Memorable Events</h1> <p>Welcome to the world of Flask!</p> </body> </html> |
Cole o código a seguir no arquivo memo.html:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
<form action="/home/create-memo" method="post"> <div> <label for="name">Name:</label> <input type="text" id="name" name="name" </div> <div> <label for="month">Month:</label> <input type="text" id="month" name="month"> </div> <div> <label for="year">Year:</label> <input type="text" id="year" name="year"> </div> <div> <label for="memo">Memo:</label> <textarea id="memo" name="memo"></textarea> </div> </form> <div class="button"> <button type="submit">Send your message</button> </div> |
Dentro do arquivo savedmemo.html, cole o seguinte código para renderizar um formulário que exibirá formulários com mensagens salvas:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
<form action=”/home/savedmemo” method=”POST”> <div>Name: <input type=”text” name=”name” values=”{{model.Name}}” /> </div> <div>Month: <input type=”text” name=”month” values=”{{model.Month}}” /> </div> <div>Year: <input type=”text” name=”year” values=”{{model.Year}}” /> </div> <div>Memo: <input type=”text” name=”memo” values=”{{model.Memo}}” /> </div> <div> <input type=”hidden” name=” </form> |
Execute o seguinte comando para iniciar o aplicativo baseado em flask, conforme mostrado abaixo:
|
1 |
python app.py |
Abra seu navegador e navegue até o seguinte URL para exibir a página em que você pode enviar detalhes para o servidor Couchbase:
https://localhost.com/home/create-memo
Além disso, se quiser navegar até a página em que as mensagens dos usuários serão exibidas e poderão ser editadas ou modificadas e salvas antes de serem enviadas ao Couchbase Server, use o seguinte:
https://localhost.com/home/saved-messages/:5000
Conclusão
Neste tutorial, aprendemos a criar um aplicativo de diário simples baseado em Flask com o Couchbase Server como back-end em que os usuários podem enviar dados por meio de um formulário para um servidor Couchbase.
Você pode fazer download ou clonar o projeto inteiro em GitHub se você quiser experimentar.
Esta postagem foi trazida a você pelo Couchbase Programa de Redação Comunitária
