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

Michael Aboagye es un ingeniero de software/seguridad backend residente en Ghana. Está interesado en la creación de servicios backend seguros con Python.

En este tutorial, veremos cómo podemos construir una aplicación web de diario basada en el framework flask con Couchbase como servidor backend.

Al final de este tutorial, serás capaz de construir una aplicación web sencilla con el framework Flask para enviar los datos de los usuarios a un servidor Couchbase. Además, aprenderás a configurar un servidor Couchbase.

Requisitos previos

Necesitas los siguientes paquetes para ejecutar o clonar el proyecto desde GitHub.

Marco Flask (última versión)

Flask framework es un micro framework escrito en Python. Es un micro framework porque no viene con un formulario de validación, mecanismo de autenticación, y así sucesivamente. Te permite personalizar las aplicaciones a tu manera.

Plantilla Jinja (última versión)

Una plantilla Jinja es simplemente un archivo de texto que contiene variables y expresiones, las cuales son reemplazadas cuando una plantilla es renderizada o mostrada.

Servidor Couchbase (edición comunitaria)

Couchbase Server es una base de datos de documentos NoSQL escalable. Utilizaremos el servidor Couchbase para almacenar los datos de los usuarios.

Crear un entorno virtual

En primer lugar, cree un directorio para alojar el entorno virtual utilizando mkdir mando.

El siguiente comando crea un directorio como proyecto web y lo cambia por el proyecto web directorio.

mkdir webproject && cd webproject
Virtualenv diary

1 2	mkdir proyecto web && cd proyecto web Virtualenv diario

A continuación, cambie al directorio para activar el entorno virtual mediante los siguientes comandos:

mkdir webproject && cd webproject

Virtualenv diary

mkdir proyecto web && cd proyecto web

Virtualenv diario

Una vez dentro del entorno virtual, podemos instalar paquetes sin miedo a entrar en conflicto con los paquetes del sistema.

Instalar Flask Framework y otros paquetes

En esta sección, instalaremos el framework Flask escrito en Python y otros paquetes necesarios para el proyecto.

Vamos a instalar los paquetes que necesitamos para este proyecto usando pip y dpkg.

pip install couchbase

pip install jinja 

Pip install flask

pip instale couchbase

pip instale jinja

Pip instale matraz

En este tutorial, vamos a ejecutar Couchbase Server a través de Docker. Necesitas tener Docker en tu localhost o máquina de desarrollo para poder extraiga o descargue imágenes de Couchbase desde dockerhub.

Navegue hasta el terminal y escriba lo siguiente para acceder al repositorio de DockerHub:

docker login

1	docker inicio de sesión

A continuación, se le pedirá que proporcione sus credenciales antes de poder acceder o "extraer" imágenes de DockerHub.

docker pull couchbase/server

1	docker tire de couchbase/servidor

Es necesario ejecutar los comandos Docker como usuario root.

Sin embargo, si prefieres instalar Couchbase Server manualmente, Couchbase proporciona dos formas de instalación para distribuciones basadas en Debian y Redat. Puede consultarlo en Couchbase.

Descargar Python SDK 2.5 para Couchbase Server

Para acceder al servidor Couchbase, necesitamos descargar el cliente Couchbase SDK para acceder a un cluster Couchbase. Couchbase proporciona SDK para lenguajes de programación como Python, .NET y Java. Vamos a descargar e instalar Couchbase SDK para Python usando pip:

pip install couchbase

1	pip instale couchbase

Configurar e iniciar Couchbase Server

Una vez que hayas sacado las imágenes de Couchbase Server de DockerHub, podemos crear y ejecutar un nuevo contenedor usando el siguiente comando:

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

1	docker ejecute -d --nombre db -p 8091-8094:8091-8094 -p 11210:11210 couchbase

docker run: Este comando crea una capa contenedora sobre la imagen de Couchbase y la inicia.

-d : La bandera -d significa que el contenedor se ejecuta como un demonio.

-name : Este es el nombre para el nuevo contenedor

-p : Esta bandera es para la asignación de puertos

Ahora estamos ejecutando el servidor Couchbase en un contenedor.

Dentro de su navegador, visite http://localhost:8091 en su máquina para configurar el servidor Couchbase.

Como puede ver, tenemos opciones para crear un nuevo clúster o unirnos a un clúster existente. Vamos a elegir la opción de crear un nuevo clúster único. Establecer un nombre de Cluster, crear un nombre de usuario para Admin y una contraseña de 6 caracteres como se muestra a continuación:

Vamos con la configuración por defecto. Necesitamos establecer el nombre de host o la dirección IP para nuestro nuevo cluster. No cambiaremos el disco de datos, la ruta del disco de índices y la ruta del disco de análisis para el propósito de este proyecto.

Además, no es necesario modificar las cuotas de memoria a menos que no dispongas de suficiente RAM. Por último, se nos presentan dos opciones: iniciar el servidor Couchbase con la configuración predeterminada o configurar la memoria y los servicios.

Haga clic en el botón que le permite configurar la memoria y los servicios para Couchbase Server.

La sección Nombre de host o dirección IP le permite establecer un nombre de host, por ejemplo localhost o 192.168.15.12. La ruta del disco de datos le permite definir la ruta.

Entonces crear un cubo llamado "users-data" a través de la consola web de Couchbase.

Escribir código del lado del servidor para la aplicación Agenda

Still dentro de su entorno virtual, cree un archivo llamado app.py. Dentro del archivo app.py, copia y pega el siguiente 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 matraz importar Frasco

de couchbase importar Couchbase

cliente = Couchbase.conecte(host = "localhost", Contraseña = "Contraseña_aquí", cubo = "Usuarios-datos")

@aplicación.ruta(/home, método=[GET])

def página_de_inicio():

devolver render_template(Inicio.html)

@aplicación.ruta(/home/crear-memo), método=[POST])

def crear_memo():

si método == "POST":

diario = {

"memo" : solicitar.formulario["memo"],

"año" : solicitar.formulario["año"],

"mes" : solicitar.formulario["mes"],

"día" : solicitar.formulario["día"]

}

Clave=uuid.uuid1.hex()

usuario_doc=json.vuelca(diario)

cliente.configure(clave, usuario_doc)

devolver redirigir(url_para("índice"))

devolver render_view("crear.html")

En el código anterior, hemos importado el framework Flask, y el cliente Couchbase para Python. A continuación, nos conectamos al bucket Users-data a través del método Couchbase client connect. A continuación, creamos una ruta para la página de inicio y la página create-memo para los usuarios.

También podemos crear una ruta para la página de mensajes. Esta página mostrará los mensajes enviados por un usuario. Dentro del archivo "app.py", escribe el siguiente código para recuperar un mensaje de usuario específico del 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)

@aplicación.ruta('Inicio/guardado-mensajes', método=['GET','POST'])

def consiga mensajes_guardados():

Mensajes_guardados = cliente.consiga(clave)

Evento_guardado = json.cargas(mensajes_guardados)

si solicitar.método == "POST":

Evento_guardado.memo = solicitar.formulario["memo"]

Evento_guardado.año = solicitar.formulario["año"]

Evento_guardado.mes = solicitar.formulario["mes"]

Evento_guardado.día = solicitar.formulario["día"]

usuario_doc = json.vuelca(diario)

cliente.configure(clave, usuario_doc)

devolver redirigir(url_para(página_de_inicio))

devolver render_template("guardado.html", modelo=Evento_guardado)

Dentro del directorio de su proyecto, cree un subdirectorio utilizando el comando mkdir como se muestra a continuación:

mkdir templates

1	mkdir plantillas

Dentro del directorio templates, crea los archivos home.html, savedmemo.html, y postmemo.html con el comando touch:

touch home.html create.html saved.html

1	toque Inicio.html crear.html guardado.html

Pegue el siguiente código dentro del archivo 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>

<título>Bienvenido a Diario Memo Reserve</título>

</cabeza>

<h1> Recuerde Su Memorable Eventos</h1>

<p>Bienvenido a el mundo de Frasco!</p>

</cuerpo>

</html>

Pegue el siguiente código dentro del archivo 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>

<div>

<etiqueta para="nombre">Nombre:</etiqueta>

<entrada tipo="texto" id="nombre" nombre="nombre"

</div>

<div>

</div>

<div>

</div>

<div>

</div>

</formulario>

<botón tipo="enviar">Enviar su mensaje</botón>

</div>

Dentro del archivo savedmemo.html, pegue el siguiente código para generar un formulario que mostrará formularios con mensajes guardados:

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

<div>Nombre:

</div>

<div>Mes:

</div>

<div>Año:

</div>

<div>Memo:

</div>

<div>

<entrada tipo="oculto" nombre="

</formulario>

Ejecute el siguiente comando para iniciar la aplicación basada en flask como se muestra a continuación:

python app.py

1	python aplicación.py

Abra su navegador y navegue hasta la siguiente url para visualizar la página donde puede enviar los detalles al servidor Couchbase:

http://localhost.com/home/create-memo

Además, si quieres navegar a la página donde se mostrarán los mensajes de los usuarios y pueden ser editados o modificados y guardados antes de enviarlos al Servidor Couchbase, utiliza lo siguiente:

http://localhost.com/home/saved-messages/:5000

Conclusión

En este tutorial, aprendimos a construir una aplicación simple de diario basada en Flask con Couchbase Server como backend. donde los usuarios pueden enviar datos a través de un formulario a un servidor Couchbase.

Puede descargar o clonar el proyecto completo desde GitHub si quieres probarlo.

Este artículo ha sido publicado por Couchbase Programa de escritura comunitaria

Laura Czajkowski, Directora de la Comunidad de Desarrolladores, Couchbase

Comparte este artículo

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

Crear una aplicación web de agenda con Couchbase como back-end

Crear un entorno virtual

Instalar Flask Framework y otros paquetes

Descargar Python SDK 2.5 para Couchbase Server

Configurar e iniciar Couchbase Server

Escribir código del lado del servidor para la aplicación Agenda

Conclusión

Recibe actualizaciones del blog de Couchbase en tu bandeja de entrada

Autor

Publicado por Laura Czajkowski, Directora de la Comunidad de Desarrolladores, Couchbase

Deja un comentario Cancelar respuesta

¿Listo para empezar con Couchbase Capella?

Empezar a construir

Utilizar Capella gratis

Póngase en contacto