Build a Diary Web Application with Couchbase as the Back-end

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.

mkdir webproject && cd webproject
Virtualenv diary

1 2	mkdir projeto web && cd projeto web Virtualenv diário

Depois disso, mude para o diretório do diário para ativar o ambiente virtual usando os seguintes comandos:

mkdir webproject && cd webproject

Virtualenv diary

mkdir projeto web && cd projeto web

Virtualenv diário

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.

pip install couchbase

pip install jinja 

Pip install flask

tubulação instalar couchbase

tubulação instalar jinja

Pip instalar frasco

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:

docker login

1	doca login

Em seguida, será solicitado que você forneça suas credenciais antes de poder acessar ou "extrair" imagens do DockerHub.

docker pull couchbase/server

1	doca puxar couchbase/servidor

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:

pip install couchbase

1	tubulação instalar 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:

docker run -d --name db -p 8091-8094:8091-8094 -p 11210:11210 couchbase

1	doca executar -d --nome 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 http://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:

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")

de frasco importação Frasco

de couchbase importação Couchbase

cliente = Couchbase.conectar(hospedeiro = "localhost", Senha = "Senha_aqui", balde = "Usuários-dados")

@aplicativo.rota('/home', método=['GET'])

def página inicial():

retorno render_template('home.html')

@aplicativo.rota('/home/create-memo'), método=['POST'])

def criar_memo():

se método == "POST":

diário = {

"memo" : solicitação.formulário["memo"],

"ano" : solicitação.formulário["ano"],

"mês" : solicitação.formulário["mês"],

"dia" : solicitação.formulário["dia"]

}

Chave=uuid.uuid1.hexadecimal()

documento_do_usuário=json.lixeiras(diário)

cliente.definir(chave, documento_do_usuário)

retorno redirecionar(url_for("índice"))

retorno 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:

@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)

@aplicativo.rota('casa/salvos-mensagens', método=['OBTER','POST'])

def obter mensagens salvas():

Mensagens salvas = cliente.obter(chave)

Evento salvo = json.cargas(mensagens salvas)

se solicitação.método == "POST":

Evento salvo.memorando = solicitação.formulário["memorando"]

Evento salvo.ano = solicitação.formulário["ano"]

Evento salvo.mês = solicitação.formulário["mês"]

Evento salvo.dia = solicitação.formulário["dia"]

documento_do_usuário = json.lixeiras(diário)

cliente.definir(chave, documento_do_usuário)

retorno redirecionar(url_for(página inicial))

retorno render_template("salvos.html", modelo=Evento salvo)

Ainda dentro do diretório do projeto, crie um subdiretório usando o comando mkdir, conforme mostrado abaixo:

mkdir templates

1	mkdir modelos

Dentro do diretório de modelos, crie os arquivos home.html, savedmemo.html e postmemo.html com o comando touch:

touch home.html create.html saved.html

1	toque casa.html criar.html salvos.html

Cole o código a seguir no arquivo home.html:

<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>

<html>

<cabeça>

<título>Bem-vindo para Diariamente Memorando Livro</título>

</cabeça>

<corpo>

<h1> Lembre-se Seu Memorável Eventos</h1>

<p>Bem-vindo para o mundo de Frasco!</p>

</corpo>

</html>

Cole o código a seguir no arquivo memo.html:

<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>

<formulário ação="/home/create-memo" método="post">

<div>

<rótulo para="name" (nome)>Nome:</rótulo>

<entrada tipo="texto" id="name" (nome) nome="name" (nome)

</div>

<div>

<rótulo para="mês">Mês:</rótulo>

</div>

<div>

<rótulo para="ano">Ano:</rótulo>

</div>

<div>

<rótulo para="memo">Memorando:</rótulo>

<área de texto id="memo" nome="memo"></área de texto>

</div>

</formulário>

<botão tipo="submit" (enviar)>Enviar seu mensagem</botão>

</div>

Dentro do arquivo savedmemo.html, cole o seguinte código para renderizar um formulário que exibirá formulários com mensagens salvas:

<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>

<formulário ação="/casa/memorando salvo" método="POST">

<div>Nome:

</div>

<div>Mês:

</div>

<div>Ano:

</div>

<div>Memorando:

</div>

<div>

<entrada tipo="oculto" nome="

</formulário>

Execute o seguinte comando para iniciar o aplicativo baseado em flask, conforme mostrado abaixo:

python app.py

1	python aplicativo.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:

http://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:

http://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

Laura Czajkowski, gerente da comunidade de desenvolvedores, Couchbase

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Todas as publicações

Criar um aplicativo Web de diário com o Couchbase como back-end

Criar um ambiente virtual

Instalar a estrutura do Flask e outros pacotes

Faça o download do Python SDK 2.5 para o Couchbase Server

Configurar e iniciar o servidor Couchbase

Escrever código no lado do servidor para o aplicativo Diário

Conclusão

Autor

Postado por Laura Czajkowski, gerente da comunidade de desenvolvedores, Couchbase

Deixar uma resposta Cancelar resposta