One place for hosting & domains

      datos

      Cómo hacer una copia de seguridad, restablecer y migrar una base de datos de MongoDB en Ubuntu 20.04


      El autor seleccionó COVID-19 Relief Fund para que reciba una donación como parte del programa Write for DOnations.

      Introducción

      MongoDB es uno de los motores de base de datos más populares de NoSQL. Es famoso por ser escalable, sólido, confiable y fácil de usar. En este artículo, respaldará, restaurará y migrará una base de datos de MongoDB de muestra.

      Importar y exportar una base de datos implica gestionar los datos en un formato legible por el ser humano y compatible con otros productos de software. Por el contrario, las operaciones de copia de seguridad y restauración de MongoDB crean o utilizan datos binarios específicos de MongoDB, que preservan no solo la uniformidad y la integridad de sus datos, sino también sus atributos específicos de MongoDB. Por lo tanto, para migrar, generalmente es preferible usar la copia de seguridad y la restauración siempre que los sistemas de origen y destino sean compatibles.

      Requisitos previos

      Antes de seguir este tutorial, asegúrese de completar los siguientes requisitos previos:

      Salvo que se indique lo contrario, todos los comandos que requieren privilegios root en este tutorial deben ejecutarse como usuario no root con privilegios sudo.

      Paso 1: Usar JSON y BSON en MongoDB

      Antes de continuar con este artículo, es necesario tener algunos conocimientos básicos sobre la materia. Si tiene experiencia con otros sistemas de base de datos NoSQL como Redis, es posible que encuentre algunas similitudes cuando trabaje con MongoDB.

      MongoDB utiliza los formatos JSON y BSON (JSON binario) para almacenar su información. JSON es el formato legible por el ser humano perfecto para exportar y, finalmente, importar sus datos. Además, puede administrar los datos exportados con cualquier herramienta que sea compatible con JSON, incluyendo un editor de texto simple.

      Un ejemplo de documento JSON tiene el siguiente aspecto:

      Example of JSON Format

      {"address":[
          {"building":"1007", "street":"Park Ave"},
          {"building":"1008", "street":"New Ave"},
      ]}
      

      Es conveniente trabajar con JSON, pero no es compatible con todos los tipos de datos disponibles en BSON. Eso significa que habrá la llamada “pérdida de fidelidad” de la información si utiliza JSON. Para respaldar y restaurar, es mejor usar el BSON binario.

      En segundo lugar, no tiene que preocuparse por crear explícitamente una base de datos de MongoDB. Si la base de datos que especifica para la importación no existe todavía, se creará automáticamente. Aún mejor es el caso de la estructura de las colecciones (tablas de base de datos). A diferencia de otros motores de bases de datos, en MongoDB, la estructura se crea de nuevo automáticamente al insertar el primer documento (fila de la base de datos).

      En tercer lugar, en MongoDB, leer o insertar grandes cantidades de datos, como las tareas de este artículo, puede requerir de muchos recursos y utilizar gran parte de su CPU, memoria y espacio de disco. Eso es crucial teniendo en cuenta que MongoDB se suele utilizar para las grandes bases de datos y los macrodatos. La solución más sencilla a este problema es ejecutar las exportaciones y las copias de seguridad durante la noche o en horas no pico.

      En cuarto lugar, la consistencia de la información podría ser un problema si tiene un servidor MongoDB ocupado en el que la información cambia durante el proceso de exportación o respaldo de la base de datos. Una posible solución para este problema es la replicación, que puede considerar cuando avance en el tema de MongoDB.

      Aunque puede usar las funciones de importación y exportación para respaldar y restaurar los datos, hay mejores formas de garantizar la integridad total de sus bases de datos de MongoDB. Para respaldar sus datos, debe usar el comando mongodump. Para restaurar, utilice mongorestore. Veamos cómo funcionan.

      Paso 2: Utilizar mongodump para respaldar una base de datos de MongoDB

      Primero, vamos a respaldar su base de datos de MongoDB.

      Un argumento esencial para mongodump es --db, que especifica el nombre de la base de datos que desea respaldar. Si no se especifica el nombre de la base de datos, mongodump hace una copia de seguridad de todas las bases de datos. El segundo argumento importante es --out, que define el directorio en el que se verterán los datos. Por ejemplo, vamos a respaldar la base de datos newdb y vamos a almacenarla en el directorio /var/backups/mongobackups. Lo ideal es que tengamos cada una de nuestras copias de seguridad en un directorio con la fecha actual como /var/backup/mongobackups/10-29-20.

      Primero, cree el directorio /var/backup/mongobackups:

      • sudo mkdir /var/backups/mongobackups

      Luego, ejecute mongodump:

      • sudo mongodump --db newdb --out /var/backups/mongobackups/`date +"%m-%d-%y"`

      Verá un resultado similar a este:

      Output

      2020-10-29T19:22:36.886+0000 writing newdb.restaurants to 2020-10-29T19:22:36.969+0000 done dumping newdb.restaurants (25359 documents)

      Tenga en cuenta que en la ruta del directorio anterior, hemos usado date +"%m-%d-%y", que obtiene automáticamente la fecha actual. Eso nos permitirá tener copias de seguridad dentro del directorio, como /var/backup/10-29-20/. Esto es especialmente conveniente cuando automatizamos las copias de seguridad.

      En este punto, tenemos una copia de seguridad competa de la base de datos newdb en el directorio /var/backup/mongobackups/10-29-20/newdb/. Esta copia de seguridad tiene todo lo necesario para restaurar el newdb de forma adecuada y preservar la llamada “fidelidad”.

      Como regla general, debe realizar copias de seguridad con regularidad y preferiblemente cuando el servidor está menos cargado. Por lo tanto, puede configurar el comando mongodump como tarea de cron para que se ejecute regularmente, por ejemplo, cada día a la 03:03 a.m.

      Para ello, abra crontab, el editor de Cron:

      Tenga en cuenta que cuando ejecute sudo crontab, editará las tareas de cron para el usuario root. Esto se recomienda porque si establece los crones de su usuario, podrían no ejecutarse correctamente, especialmente si su perfil sudo requiere verificación de contraseña.

      Dentro de la línea de comandos de crontab, inserte el siguiente comando mongodump:

      crontab

      3 3 * * * mongodump --out /var/backups/mongobackups/`date +"%m-%d-%y"`
      

      En el comando anterior, omitimos el argumento --db a propósito porque normalmente querrá tener todas las bases de datos respaldadas.

      Dependiendo del tamaño de su base de datos de MongoDB, es posible que pronto se quede sin espacio en el disco con demasiadas copias de seguridad. Es por eso que también se recomienda limpiar las copias de seguridad antiguas con regularidad o comprimirlas.

      Por ejemplo, para eliminar todas las copias de seguridad de más de siete días, puede usar el siguiente comando bash:

      • find /var/backups/mongobackups/ -mtime +7 -exec rm -rf {} ;

      De forma similar al comando mongodump anterior, también puede añadirlo como tarea de cron. Debe ejecutarse justo antes de iniciar la siguiente copia de seguridad, por ejemplo, a las 03:01 a.m. Para ello, abra crontab de nuevo:

      Después de eso, inserte la siguiente línea:

      crontab

      1 3 * * * find /var/backups/mongobackups/ -mtime +7 -exec rm -rf {} ;
      

      Guarde y cierre el archivo.

      Completar todas las tareas en este paso garantizará una solución de respaldo adecuada para sus bases de datos de MongoDB.

      Paso 3: Usar mongorestore para restaurar y migrar una base de datos de MongoDB

      Cuando restaura su base de datos de MongoDB desde una copia de seguridad anterior, tiene la copia exacta de su información de MongoDB en un momento determinado, incluyendo todos los índices y los tipos de datos. Esto es especialmente útil cuando desea migrar sus bases de datos de MongoDB. Para restaurar MongoDB, usaremos el comando mongorestore, que funciona con las copias de seguridad binarias que produce mongodump.

      Continuemos nuestros ejemplos con la base de datos newdb y veremos cómo podemos restaurarla desde la copia de seguridad tomada anterior. Primero, especificaremos el nombre de la base de datos con el argumento --nsInclude Usaremos newdb* para restaurar todas las colecciones. Para restaurar una colección única como los restaurantes, utilice newdb.restaurants en su lugar.

      Luego, con --drop, nos aseguraremos de que la base de datos de destino se elimine primero para que la copia de seguridad se restaure en una base de datos limpia. Como argumento final, especificaremos el directorio de la última copia de seguridad, que tendrá un aspecto similar a este: /var/backup/mongobackups/10-29-20/newdb/.

      Una vez que tenga una copia de seguridad con marca de tiempo, puede restaurarla usando este comando:

      • sudo mongorestore --db newdb --drop /var/backups/mongobackups/10-29-20/newdb/

      Verá un resultado similar a este:

      Output

      2020-10-29T19:25:45.825+0000 the --db and --collection args should only be used when restoring from a BSON file. Other uses are deprecated and will not exist in the future; use --nsInclude instead 2020-10-29T19:25:45.826+0000 building a list of collections to restore from /var/backups/mongobackups/10-29-20/newdb dir 2020-10-29T19:25:45.829+0000 reading metadata for newdb.restaurants from /var/backups/mongobackups/10-29-20/newdb/restaurants.metadata.json 2020-10-29T19:25:45.834+0000 restoring newdb.restaurants from /var/backups/mongobackups/10-29-20/newdb/restaurants.bson 2020-10-29T19:25:46.130+0000 no indexes to restore 2020-10-29T19:25:46.130+0000 finished restoring newdb.restaurants (25359 documents) 2020-10-29T19:25:46.130+0000 done

      En el caso anterior, estamos restaurando los datos en el mismo servidor donde creamos la copia de seguridad. Si desea migrar los datos a otro servidor y usar la misma técnica, deberá copiar el directorio de la copia de seguridad, que es /var/backups/mongobackups/10-29-20/newdb/ en nuestro caso, al otro servidor.

      Conclusión

      Ahora, ha realizado algunas tareas esenciales relacionadas con el respaldo, la restauración y la migración de sus bases de datos de MongoDB. Ningún servidor MongoDB de producción debería funcionar sin una estrategia de respaldo fiable, como la que se describe aquí.



      Source link

      Cómo importar y exportar una base de datos de MongoDB en Ubuntu 20.04


      El autor seleccionó COVID-19 Relief Fund para que reciba una donación como parte del programa Write for DOnations.

      Introducción

      MongoDB es uno de los motores de base de datos más populares de NoSQL. Es famoso por ser escalable, potente, confiable y fácil de usar. En este artículo, le mostraremos cómo importar y exportar sus bases de datos de MongoDB.

      Debemos aclarar que importar y exportar se refiere a aquellas operaciones que manejan los datos en un formato legible por el ser humano, compatible con otros productos de software. Por el contrario, las operaciones de copia de seguridad y restauración crean o utilizan datos binarios específicos de MongoDB, que preservan la uniformidad y la integridad de sus datos, y también sus atributos específicos de MongoDB. Por lo tanto, para migrar, generalmente es preferible usar la copia de seguridad y la restauración siempre que los sistemas de origen y destino sean compatibles.

      Las tareas de copia de seguridad, restauración y migración están fuera del alcance de este artículo. Para obtener más información, consulte Cómo respaldar, restaurar y migrar una base de datos de MongoDB en Ubuntu 20.04.

      Requisitos previos

      Para completar este tutorial, necesitará lo siguiente:

      Paso 1: Importar la información a MongoDB

      Para aprender cómo funciona la importación de información a MongoDB vamos a utilizar una base de datos popular de MongoDB de muestra sobre restaurantes. Está en formato .json y se puede descargar con wget de esta manera:

      • wget https://raw.githubusercontent.com/mongodb/docs-assets/primer-dataset/primer-dataset.json

      Una vez completada la descarga, debería tener un archivo llamado primer-dataset.json (12 MB de tamaño) en el directorio actual. Importaremos los datos de este archivo a una nueva base de datos llamada newdb y a una colección llamada restaurants.

      Utilice el comando mongoimport de esta manera:

      • sudo mongoimport --db newdb --collection restaurants --file primer-dataset.json

      El resultado tendrá el siguiente aspecto:

      Output

      2020-11-11T19:37:55.607+0000 connected to: mongodb://localhost/ 2020-11-11T19:37:57.841+0000 25359 document(s) imported successfully. 0 document(s) failed to import

      Como muestra el comando anterior, se han importado 25359 documentos. Dado que no teníamos una base de datos llamada newdb, MongoDB la creó de forma automática.

      Vamos a verificar la importación.

      Conéctese a la base de datos newdb recientemente creada:

      Ahora está conectado a la instancia de la base de datos newdb. Observe que la línea de comandos ha cambiado, indicando que está conectado a la base de datos.

      Cuente los documentos de la colección de restaurantes con el comando:

      El resultado mostrará 25359, que es el número de documentos importados. Para obtener una comprobación aún mejor, puede seleccionar el primer documento de la colección de restaurantes de esta manera:

      El resultado tendrá el siguiente aspecto:

      [secondary label Output]
      {
          "_id" : ObjectId("5fac3d937f12c471b3f26733"),
          "address" : {
              "building" : "1007",
              "coord" : [
                  -73.856077,
                  40.848447
              ],
              "street" : "Morris Park Ave",
              "zipcode" : "10462"
          },
          "borough" : "Bronx",
          "cuisine" : "Bakery",
          "grades" : [
              {
                  "date" : ISODate("2014-03-03T00:00:00Z"),
                  "grade" : "A",
                  "score" : 2
              },
      ...
          ],
          "name" : "Morris Park Bake Shop",
          "restaurant_id" : "30075445"
      }
      

      Una comprobación tan detallada podría revelar problemas con los documentos, tales como el contenido, la codificación, etc. El formato json utiliza la codificación UTF-8 sus exportaciones e importaciones deberían estar en dicha codificación. Tenga esto en cuenta si edita los archivos json de forma manual. De lo contrario, MongoDB se encargará de ello automáticamente.

      Para salir de la línea de comandos de MongoDB, escriba exit en la línea de comandos:

      Volverá a la línea de comandos normal como usuario no root.

      Paso 2: Exportar información desde MongoDB

      Como mencionamos antes, cuando exporta la información de MongoDB, puede obtener un archivo de texto legible por el ser humano con sus datos. De manera predeterminada, la información se exportará en formato json, pero también puede exportar a csv (valor separado por comas).

      Para exportar información desde MongoDB, utilice el comando mongoexport. Le permite exportar de forma muy detallada, de modo que puede especificar una base de datos, una colección, un campo e incluso utilizar una consulta para la exportación.

      Un ejemplo simple de mongoexport sería exportar la colección de restaurantes desde la base de datos newdb que hemos importado anteriormente. Puede hacerse de esta manera:

      • sudo mongoexport --db newdb -c restaurants --out newdbexport.json

      En el comando anterior, se utilizó --db para especificar la base de datos, -c para la colección y --out, para el archivo en el que se guardarán los datos.

      El resultado de una exitosa exportación de mongoexport debe tener el siguiente aspecto:

      Output

      2020-11-11T19:39:57.595+0000 connected to: mongodb://localhost/ 2020-11-11T19:39:58.619+0000 [###############.........] newdb.restaurants 16000/25359 (63.1%) 2020-11-11T19:39:58.871+0000 [########################] newdb.restaurants 25359/25359 (100.0%) 2020-11-11T19:39:58.871+0000 exported 25359 records

      El resultado anterior muestra que se han importado 25359 documentos, el mismo número que de los documentos importados.

      En algunos casos, es posible que necesite exportar solo una parte de su colección. Teniendo en cuenta la estructura y el contenido del archivo json de los restaurantes, vamos a exportar todos los restaurantes que cumplen los criterios de estar situados en el barrio del Bronx y de tener cocina china. Si queremos obtener esta información directamente mientras estamos conectados a MongoDB, vuelva a conectarse a la base de datos:

      Luego, utilice esta consulta:

      • db.restaurants.find( { "borough": "Bronx", "cuisine": "Chinese" } )

      Los resultados se muestran en el terminal:

      Output

      • 2020-12-03T01:35:25.366+0000 connected to: mongodb://localhost/
      • 2020-12-03T01:35:25.410+0000 exported 323 records

      Para salir de la línea de comandos de MongoDB, escriba exit:

      Si desea exportar los datos de una línea de comandos sudo en lugar de mientras está conectado a la base de datos, haga que la consulta anterior forme parte del comando mongoexport especificándolo para el argumento -q de esta manera:

      • sudo mongoexport --db newdb -c restaurants -q "{"borough": "Bronx", "cuisine": "Chinese"}" --out Bronx_Chinese_retaurants.json

      Tenga en cuenta que estamos evitando las comillas dobles con una barra oblicua inversa () en la consulta. De manera similar, tiene que evitar cualquier otro carácter especial en la consulta.

      Si la exportación se realizó de forma correcta, el resultado debería tener el siguiente aspecto:

      Output

      2020-11-11T19:49:21.727+0000 connected to: mongodb://localhost/ 2020-11-11T19:49:21.765+0000 exported 323 records

      Lo anterior muestra que se han exportado 323 registros y puede encontrarlos en el archivo Bronx_Chinese_retaurants.json que especificamos.

      Utilice cat y less para escanear los datos:

      • cat Bronx_Chinese_retaurants.json | less

      Utilice SPACE para navegar por los datos:

      Output

      • date":{"$date":"2015-01-14T00:00:00Z"},"grade":"Z","score":36}],"na{"_id":{"$oid":"5fc8402d141f5e54f9054f8d"},"address":{"building":"1236","coord":[-73.8893654,40.81376179999999],"street":"238 Spofford Ave","zipcode":"10474"},"borough":"Bronx","cuisine":"Chinese","grades":[{"date":{"$date":"2013-12-30T00:00:00Z"},"grade":"A","score":8},{"date":{"$date":"2013-01-08T00:00:00Z"},"grade":"A","score":10},{"date":{"$date":"2012-06-12T00:00:00Z"},"grade":"B","score":15}],
      • . . .

      Presione q para salir. Ahora puede importar y exportar una base de datos de MongoDB.

      Conclusión

      Este artículo le ha presentado los aspectos esenciales de importación y exportación de información desde y hacia una base de datos de MongoDB. Puede continuar leyendo sobre Cómo hacer una copia de seguridad, restaurar y migrar una base de datos de MongoDB en Ubuntu 20.04.

      También puede considerar usar la replicación. La replicación le permite continuar ejecutando su servicio de MongoDB sin interrupción desde un servidor de MongoDB esclavo mientras restaura el maestro tras un fallo. Parte de la replicación es el registro de operaciones (oplog), que registra todas las operaciones que modifican sus datos. Puede usar este registro, igual que usaría el registro binario en MySQL, para restaurar sus datos después de haber realizado la última copia de seguridad. Recuerde que las copias de seguridad suelen realizarse durante la noche, y si decide restaurar una copia de seguridad en la noche, se perderá todas las actualizaciones desde la última copia de seguridad.



      Source link

      Cómo procesar los datos de solicitud entrantes en Flask


      Introducción

      Las aplicaciones web requieren con frecuencia el procesamiento de los datos de las solicitudes entrantes de los usuarios. Esta carga útil puede tener la forma de cadenas de consulta, datos de formulario y objetos JSON. Flask, como cualquier otro marco web, le permite acceder a los datos de la solicitud.

      En este tutorial, se creará una aplicación Flask con tres rutas que aceptan cadenas de consulta, datos de formulario u objetos JSON.

      Requisitos previos

      Para completar este tutorial, necesitará lo siguiente:

      • Este proyecto requerirá que Python se instale en un entorno local.
      • Este proyecto usará Pipenv, una herramienta preparada para la producción que pretende traer lo mejor de todos los mundos de empaquetado al mundo de Python. Aprovecha Pipfile, pip, y virtualenv en un solo comando.
      • Se requerirá descargar e instalar una herramienta como Postman para probar los puntos finales de API.

      Este tutorial se verificó con Pipenv v2020.11.15, Python v3.9.0 y Flask v1.1.2.

      Configuración del proyecto

      Para demostrar las diferentes formas de usar solicitudes, deberá crear una aplicación Flask. Aunque la aplicación de ejemplo utiliza una estructura simplificada para las funciones y las rutas de vista, lo que se aprende en este tutorial puede aplicarse a cualquier método de organización de las vistas, como las vistas basadas en clases, los planos o una extensión como Flask-Via.

      Primero, deberá crear un directorio de proyecto. Abra su terminal y ejecute el siguiente comando:

      • mkdir flask_request_example

      Luego, diríjase al nuevo directorio:

      Luego, instale Flask. Abra su terminal y ejecute el siguiente comando:

      El comando pipenv creará un virtualenv para este proyecto, un Pipfile, para instalar flask y un Pipfile.lock.

      Para activar el virtualenv del proyecto, ejecute el siguiente comando:

      Para acceder a los datos entrantes en Flask, tiene que usar el objeto request. El objeto request contiene todos los datos entrantes de la solicitud, que incluye el mimetype, recomendante, dirección IP, datos sin procesar, HTTP y encabezados, entre otras cosas.

      Aunque toda la información que contiene el objeto de solicitud puede ser útil, para los propósitos de este artículo, se centrará en los datos que normalmente son suministrados directamente por la persona que llama al punto final.

      Para obtener acceso al objeto de solicitud en Flask, deberá importarlo desde la biblioteca Flask:

      from flask import request
      

      Luego, podrá usarlo en cualquiera de sus funciones de vista.

      Utilice su editor de código para crear un archivo app.py. Importe Flask y el objeto request. Y también establezca rutas para query-example, form-example, y json-example:

      app.py

      # import main Flask class and request object
      from flask import Flask, request
      
      # create the Flask app
      app = Flask(__name__)
      
      @app.route('/query-example')
      def query_example():
          return 'Query String Example'
      
      @app.route('/form-example')
      def form_example():
          return 'Form Data Example'
      
      @app.route('/json-example')
      def json_example():
          return 'JSON Object Example'
      
      if __name__ == '__main__':
          # run app in debug mode on port 5000
          app.run(debug=True, port=5000)
      

      Luego, abra su terminal e inicie la aplicación con el siguiente comando:

      La aplicación se iniciará en el puerto 5000, por lo que puede ver cada ruta en su navegador con los siguientes enlaces:

      http://127.0.0.1:5000/query-example (or localhost:5000/query-example)
      http://127.0.0.1:5000/form-example (or localhost:5000/form-example)
      http://127.0.0.1:5000/json-example (or localhost:5000/json-example)
      

      El código establece tres rutas y visitar cada una de ellas mostrará los mensajes de "Query String Example", "Form Data Example" y "JSON Object Example", respectivamente.

      Uso de argumentos Query

      Los argumentos de URL que se añaden a una cadena de consulta son una forma común de pasar los datos a una aplicación web. Al navegar por la web, es probable que haya encontrado alguna vez una cadena de consulta.

      Una cadena de consulta se parece a lo siguiente:

      example.com?arg1=value1&arg2=value2
      

      La cadena de consulta comienza después del carácter de signo de interrogación (?) :

      example.com?arg1=value1&arg2=value2
      

      Y tiene pares clave-valor separados por un carácter de “y” comercial (&):

      example.com?arg1=value1&arg2=value2
      

      Para cada par, la clave va seguida por un signo de igualdad (=) y, a continuación, el valor.

      arg1 : value1
      arg2 : value2
      

      Las cadenas de consulta son útiles para pasar datos que no requieren que el usuario realice ninguna acción. Puede generar una cadena de consulta en algún lugar de su aplicación y añadirla a una URL para que cuando un usuario realice una solicitud, los datos se pasen automáticamente para ellos. Una cadena de consulta también puede generarse a través de formularios que tienen GET como método.

      Vamos a añadir una cadena de consulta a la ruta query-example. En este ejemplo hipotético, se proporcionará el nombre de un lenguaje de programación que se mostrará en la pantalla. Cree una clave de "language" y un valor de "Python":

      http://127.0.0.1:5000/query-example?language=Python
      

      Si ejecuta la aplicación y navega a esa URL, verá que sigue mostrando un mensaje de "Query String Example".

      Tendrá que programar la parte que maneja los argumentos de la consulta. Este código leerá la clave de language usando request.args.get('language') o request.args['language'].

      Al invocar request.args.get('language'), la aplicación continuará ejecutándose si la clave de language no existe en la URL. En ese caso, el resultado del método será None.

      Al invocar request.args['language'], la aplicación mostrará un error 400 si la clave de language no existe en la URL.

      Cuando se trata de cadenas de consulta, se recomienda usar request.args.get() para evitar que la aplicación falle.

      Vamos a leer la clave language y mostrarla como resultado.

      Modifique la ruta query-example en app.py con el siguiente código:

      app.py

      @app.route('/query-example')
      def query_example():
          # if key doesn't exist, returns None
          language = request.args.get('language')
      
          return '''<h1>The language value is: {}</h1>'''.format(language)
      

      Luego, ejecute la aplicación y diríjase a la URL:

      http://127.0.0.1:5000/query-example?language=Python
      

      El navegador debe mostrar el siguiente mensaje:

      Output

      The language value is: Python

      El argumento de la URL se asigna a la variable language y luego se devuelve al navegador.

      Para añadir más parámetros de cadena de consulta, puede añadir ampersands y los nuevos pares clave-valor al final de la URL. Cree una clave de "framework" y un valor de "Flask":

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask
      

      Y si desea más, continúe añadiendo ampersands y pares clave-valor. Cree una clave de "website" y un valor de "DigitalOcean":

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask&website=DigitalOcean
      

      Para obtener acceso a esos valores, seguirá usando request.args.get() o request.args[]. Vamos a usar ambos para demostrar lo que sucede cuando falta una clave. Modifique la ruta query_example para asignar el valor de los resultados a variables y luego mostrarlos:

      @app.route('/query-example')
      def query_example():
          # if key doesn't exist, returns None
          language = request.args.get('language')
      
          # if key doesn't exist, returns a 400, bad request error
          framework = request.args['framework']
      
          # if key doesn't exist, returns None
          website = request.args.get('website')
      
          return '''
                    <h1>The language value is: {}</h1>
                    <h1>The framework value is: {}</h1>
                    <h1>The website value is: {}'''.format(language, framework, website)
      

      Luego, ejecute la aplicación y diríjase a la URL:

      http://127.0.0.1:5000/query-example?language=Python&framework=Flask&website=DigitalOcean
      

      El navegador debe mostrar el siguiente mensaje:

      Output

      The language value is: Python The framework value is: Flask The website value is: DigitalOcean

      Elimine la clave de language de la URL:

      http://127.0.0.1:5000/query-example?framework=Flask&website=DigitalOcean
      

      El navegador debe mostrar el siguiente mensaje con None cuando no se proporciona un valor para language:

      Output

      The language value is: None The framework value is: Flask The website value is: DigitalOcean

      Elimine la clave de framework de la URL:

      http://127.0.0.1:5000/query-example?language=Python&website=DigitalOcean
      

      El navegador debería encontrar un error porque está esperando un valor para framework:

      Output

      werkzeug.exceptions.BadRequestKeyError werkzeug.exceptions.BadRequestKeyError: 400 Bad Request: The browser (or proxy) sent a request that this server could not understand. KeyError: 'framework'

      Ahora, ya comprende cómo se manejan las cadenas de consulta. Continuemos con el siguiente tipo de datos entrantes.

      Uso de datos de formulario

      Los datos de formulario provienen de un formulario que ha sido enviado como solicitud POST a una ruta. Por lo tanto, en lugar de ver los datos en la URL (excepto en los casos en que el formulario se envía con una solicitud GET), los datos del formulario pasarán a la aplicación entre bastidores. Aunque no se pueden ver fácilmente los datos del formulario que se pasan, su aplicación puede leerlos.

      Para demostrarlo, modifique la ruta de form-example en app.py para aceptar las solicitudes GET y POST, y devolver un formulario:

      app.py

      # allow both GET and POST requests
      @app.route('/form-example', methods=['GET', 'POST'])
      def form_example():
          return '''
                    <form method="POST">
                        <div><label>Language: <input type="text" name="language"></label></div>
                        <div><label>Framework: <input type="text" name="framework"></label></div>
                        <input type="submit" value="Submit">
                    </form>'''
      

      Luego, ejecute la aplicación y diríjase a la URL:

      http://127.0.0.1:5000/form-example
      

      El navegador debe mostrar un formulario con dos campos de entrada, uno para language y otro para framework, así como para un botón de envío.

      Lo más importante que hay que saber sobre este formulario es que realiza una solicitud POST a la misma ruta que generó el formulario. Las claves que se leerán en la aplicación provienen de los atributos de nombre de las entradas de nuestro formulario. En este caso, language y framework son los nombres de las entradas, por lo que tendrá acceso a ellos en la aplicación.

      Dentro de la función de vista, deberá verificar si el método de solicitud es GET o POST. Si es una solicitud GET, puede mostrar el formulario. De lo contrario, si se trata de una solicitud POST, entonces querrá procesar los datos entrantes.

      Modifique la ruta de form-example en app.py con el siguiente código:

      app.py

      # allow both GET and POST requests
      @app.route('/form-example', methods=['GET', 'POST'])
      def form_example():
          # handle the POST request
          if request.method == 'POST':
              language = request.form.get('language')
              framework = request.form.get('framework')
              return '''
                        <h1>The language value is: {}</h1>
                        <h1>The framework value is: {}</h1>'''.format(language, framework)
      
          # otherwise handle the GET request
          return '''
                 <form method="POST">
                     <div><label>Language: <input type="text" name="language"></label></div>
                     <div><label>Framework: <input type="text" name="framework"></label></div>
                     <input type="submit" value="Submit">
                 </form>'''
      

      Luego, ejecute la aplicación y diríjase a la URL:

      http://127.0.0.1:5000/form-example
      

      Complete el campo de language con el valor de Python y el campo de framework con el valor de Flask. Luego, presione Submit (Enviar).

      El navegador debe mostrar el siguiente mensaje:

      Output

      The language value is: Python The framework value is: Flask

      Ahora, entiende cómo manejar los datos del formulario. Continuaremos con el siguiente tipo de datos entrantes.

      Uso de datos JSON

      Los datos JSON generalmente se construye a través de un proceso que invoca la ruta.

      Un ejemplo de objeto JSON tiene el siguiente aspecto:

      {
        "language": "Python",
        "framework": "Flask",
        "website": "Scotch",
        "version_info": {
          "python": "3.9.0",
          "flask": "1.1.2"
        },
        "examples": ["query", "form", "json"],
        "boolean_test": true
      }
      

      Esta estructura puede permitir que se pasen datos mucho más complicados en lugar de las cadenas de consulta y los datos del formulario. En el ejemplo, se ve los objetos JSON anidados y una matriz de elementos. Flask puede gestionar este formato de datos.

      Modifique la ruta de form-example en app.py para aceptar las solicitudes POST e ignore otras solicitudes como GET:

      app.py

      @app.route('/json-example', methods=['POST'])
      def json_example():
          return 'JSON Object Example'
      

      A diferencia del navegador web que se utiliza para las cadenas de consulta y los datos de formulario, para los fines de este artículo, para enviar un objeto JSON, se utilizará Postman para enviar solicitudes personalizadas a las URL.

      Nota: Si necesita ayuda para navegar por la interfaz de Postman para las solicitudes, consulte la documentación oficial.

      En Postman, añada la URL y cambie el tipo a POST. En la pestaña de cuerpo, cambie a raw y seleccione JSON en el menú desplegable.

      Estos ajustes son necesarios para que Postman pueda enviar datos JSON correctamente, y para que su aplicación Flask comprenda que está recibiendo JSON:

      POST http://127.0.0.1:5000/json-example
      Body
      raw JSON
      

      Luego, copie el ejemplo JSON anterior en la entrada de texto.

      Envíe la solicitud y debería obtener "JSON Object Example" como respuesta. Eso es bastante decepcionante, pero es de esperar porque el código para gestionar la respuesta de los datos JSON aún no se ha escrito.

      Para leer los datos, debe entender cómo Flask traduce los datos JSON en las estructuras de datos de Python:

      • Cualquier cosa que sea un objeto se convierte en una dictadura de Python. {"key" : "value"} en JSON corresponde a somedict['key'], que devuelve un valor en Python.
      • Una matriz en JSON se convierte en una lista en Python. Dado que la sintaxis es la misma, aquí hay un ejemplo de una lista: [1,2,3,4,5].
      • Los valores dentro de las comillas en el objeto JSON se convierten en cadenas en Python.
      • Los booleanos true y false se convierten en True y False en Python.
      • Por último, los números sin comillas se convierten en números en Python.

      Ahora vamos a trabajar en el código para leer los datos JSON entrantes.

      Primero, vamos a asignar todo desde el objeto JSON a una variable usando request.get_json().

      request.get_json() convierte el objeto JSON en datos de Python. Asignemos los datos de la solicitud entrante a las variables y devolvámoslos haciendo los siguientes cambios en la ruta json-example:

      app.py

      # GET requests will be blocked
      @app.route('/json-example', methods=['POST'])
      def json_example():
          request_data = request.get_json()
      
          language = request_data['language']
          framework = request_data['framework']
      
          # two keys are needed because of the nested object
          python_version = request_data['version_info']['python']
      
          # an index is needed because of the array
          example = request_data['examples'][0]
      
          boolean_test = request_data['boolean_test']
      
          return '''
                 The language value is: {}
                 The framework value is: {}
                 The Python version is: {}
                 The item at index 0 in the example list is: {}
                 The boolean value is: {}'''.format(language, framework, python_version, example, boolean_test)
      

      Tenga en cuenta cómo se accede a los elementos que no están en el nivel superior. Se utiliza ['version']['python'] porque se está entrando en un objeto anidado. Y ['examples'][0] se utiliza para acceder al índice 0 en la matriz de ejemplos.

      Si el objeto JSON enviado con la solicitud no tiene una clave a la que se accede en su función de vista, entonces la solicitud fallará. Si no quiere que la solicitud falle cuando no existe una clave, tendrá que verificar si la clave existe antes de intentar ingresarla.

      app.py

      # GET requests will be blocked
      @app.route('/json-example', methods=['POST'])
      def json_example():
          request_data = request.get_json()
      
          language = None
          framework = None
          python_version = None
          example = None
          boolean_test = None
      
          if request_data:
              if 'language' in request_data:
                  language = request_data['language']
      
              if 'framework' in request_data:
                  framework = request_data['framework']
      
              if 'version_info' in request_data:
                  if 'python' in request_data['version_info']:
                      python_version = request_data['version_info']['python']
      
              if 'examples' in request_data:
                  if (type(request_data['examples']) == list) and (len(request_data['examples']) > 0):
                      example = request_data['examples'][0]
      
              if 'boolean_test' in request_data:
                  boolean_test = request_data['boolean_test']
      
          return '''
                 The language value is: {}
                 The framework value is: {}
                 The Python version is: {}
                 The item at index 0 in the example list is: {}
                 The boolean value is: {}'''.format(language, framework, python_version, example, boolean_test)
      

      Ejecute la aplicación y envíe la solicitud JSON de ejemplo usando Postman. En la respuesta, obtendrá el siguiente resultado:

      Output

      The language value is: Python The framework value is: Flask The Python version is: 3.9 The item at index 0 in the example list is: query The boolean value is: false

      Ahora comprende cómo se manejan los objetos JSON.

      Conclusión

      En este artículo, se creó una aplicación Flask con tres rutas que aceptan cadenas de consulta, datos de formulario u objetos JSON.

      Además, recuerde que todos los enfoques tuvieron que abordar la consideración recurrente de fallar con gracia cuando falta una clave.

      Advertencia: Un tema que no se cubrió en este artículo fue cómo desinfectar la entrada de los usuarios. La sanitización de la entrada de lo usuario garantizaría que los datos leídos por la aplicación no causen un fallo inesperado o que se salten las medidas de seguridad.

      Si desea obtener más información sobre Flask, consulte nuestra página del tema Flask para consultar ejercicios y proyectos de programación.



      Source link