One place for hosting & domains

      Como fazer backup, restaurar e migrar um banco de dados MongoDB no Ubuntu 20.04


      O autor selecionou a COVID-19 Relief Fund​​​​​ para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O MongoDB é um dos mecanismos de banco de dados NoSQL mais populares. Ele é famoso por ser escalonável, robusto, confiável e fácil de usar. Neste artigo, você vai fazer backup, reiniciar e migrar um banco de dados MongoDB de exemplo.

      Importar e exportar um banco de dados significa lidar com dados em um formato legível para humanos que seja compatível com outros produtos de software. Em contrapartida, o backup e as operações de restauração do MongoDB criam ou usam dados binários específicos do MongoDB, que preservam não apenas a consistência e integridade dos seus dados, mas também seus atributos específicos do MongoDB. Assim, para a migração, geralmente é preferível usar o backup e restauração, desde que o sistema de origem e de destino sejam compatíveis.

      Pré-requisitos

      Antes de seguir este tutorial, certifique-se de completar os seguintes pré-requisitos:

      Exceto se explicitamente dito, todos os comandos que exigem privilégios root neste tutorial devem ser executados como um usuário não root com privilégios sudo.

      Passo 1 — Usando o JSON e BSON no MongoDB

      Antes de ir adiante com este artigo, é necessária uma compreensão básica sobre o assunto. Se você tiver experiência com outros sistemas de banco de dados NoSQL como o Redis, pode encontrar algumas similaridades ao trabalhar com o MongoDB.

      O MongoDB usa os formatos JSON e BSON (JSON binário) para armazenar suas informações. O JSON é o formato legível para humanos que é perfeito para exportar e, eventualmente, importar seus dados. Você pode gerenciar ainda mais seus dados exportados com qualquer ferramenta compatível com JSON, incluindo um editor de texto simples.

      Um documento json de exemplo se parece com este:

      Example of JSON Format

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

      É conveniente se trabalhar com o JSON, mas ele não suporta todos os tipos de dados disponíveis em BSON. Isso significa que haverá a chamada “perda de fidelidade” das informações se usar o JSON. Para fazer backup e restaurar, é melhor usar o binário BSON.

      Em segundo lugar, você não precisa se preocupar com a criação explícita de um banco de dados MongoDB. Se o banco de dados especificado para importar ainda não existir, ele é criado automaticamente. O caso com a estrutura das coleções (tabelas de bancos de dados) é ainda melhor. Diferentemente de outros mecanismos de bancos de dados, no MongoDB, a estrutura é também criada automaticamente no momento da inserção do primeiro documento (linha do banco de dados).

      Em terceiro lugar, no MongoDB, ler ou inserir grandes quantidades de dados, como as tarefas deste artigo, pode gerar um uso intensivo de recursos e consumir grande parte do seu CPU, memória e espaço em disco. Isso deve ser considerado, já que o MongoDB é frequentemente usado para grandes bancos de dados e Big Data. A solução mais simples para esse problema é executar as exportações e backups durante a noite ou horários fora do pico.

      Em quarto lugar, a consistência das informações pode ser problemática se você tiver um servidor MongoDB ocupado, no qual as informações mudam durante a exportação do banco de dados ou o processo de backup. Uma solução possível para esse problema é a replicação, que você pode considerar quando avançar no tópico do MongoDB.

      Embora você possa usar as funções de importação e exportação para fazer backup e restaurar seus dados, há melhores maneiras de garantir a integridade total dos seus bancos de dados MongoDB. Para fazer backup dos seus dados, você deve usar o comando mongodump. Para restaurar, use o mongorestore. Vamos ver como eles funcionam.

      Passo 2 — Usando o mongodump para fazer backup de um banco de dados MongoDB

      Vamos mostrar primeiro como fazer backup do seu banco de dados MongoDB.

      Um argumento essencial para o mongodump é o --db, que especifica o nome do banco de dados do qual você deseja fazer backup. Se você não especificar um nome de banco de dados, o mongodump faz backup de todos os seus bancos de dados. O segundo argumento importante é o --out, que define o diretório no qual os dados serão despejados. Por exemplo, vamos fazer backup do banco de dados newdb e armazená-lo no diretório /var/backups/mongobackups. Idealmente, teremos cada um dos nossos backups em um diretório com a data atual como /var/backups/mongobackups/10-29-20.

      Primeiramente, crie o diretório /var/backups/mongobackups:

      • sudo mkdir /var/backups/mongobackups

      Em seguida, execute o mongodump:

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

      Você verá uma saída como esta:

      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)

      Note que no caminho de diretório acima, usamos date +"%m-%d-%y" que obtém automaticamente a data atual. Isso permitirá que tenhamos backups dentro de um diretório como /var/backups/10-29-20/. Isso é ainda mais conveniente quando automatizamos os backups.

      Neste ponto, você possui um backup completo do banco de dados newdb no diretório /var/backups/mongobackups/10-29-20/newdb/. Esse backup possui todo o necessário para restaurar o newdb corretamente e preservar sua chamada “fidelidade”.

      Como uma regra geral, você deve fazer backups regulares e, de preferência, quando o servidor estiver menos carregado. Assim, você pode definir o comando mongodump como uma tarefa cron para que ele seja executado regularmente, por exemplo, todos os dias às 03:03.

      Para fazer isso, abra o crontab, o editor do cron:

      Note que quando executa sudo crontab, você estará editando as tarefas cron para o usuário root. Isso é recomendado, porque se você definir os crons para seu usuário, eles podem não ser executados corretamente, especialmente se seu perfil sudo exigir uma verificação por senha.

      Dentro do prompt do crontab, insira o seguinte comando mongodump:

      crontab

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

      No comando acima, omitimos o argumento --db de propósito, porque geralmente é interessante fazer backup de todos os nossos bancos de dados.

      Dependendo dos tamanhos dos seus bancos de dados MongoDB, é possível esgotar rapidamente o espaço em disco com muitos backups. É por isso que é recomendável limpar os backups antigos regularmente ou compactá-los.

      Por exemplo, para excluir todos os backups com idade maior que sete dias, use o seguinte comando bash:

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

      De maneira similar ao comando mongodump anterior, também é possível adicionar isso como uma tarefa cron. Ele deve ser executado pouco antes de iniciar o próximo backup, por exemplo, às 03:01. Para esse fim, abra novamente o crontab:

      Em seguida, insira a linha a seguir:

      crontab

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

      Salve e feche o arquivo.

      A realização de todas as tarefas neste passo garantirá uma solução de backup adequada para seus bancos de dados MongoDB.

      Passo 3 — Usando o mongorestore para restaurar e migrar um banco de dados MongoDB

      Ao restaurar seu banco de dados MongoDB de um backup anterior, você obtém uma cópia exata das suas informações do MongoDB obtidas em um momento específico, incluindo todos os índices e tipos de dados. Isso é especialmente útil quando quiser migrar seus bancos de dados MongoDB. Para restaurar o MongoDB, usaremos o comando mongorestore, que funciona com os backups binários que o mongodump produz.

      Vamos continuar nossos exemplos com o banco de dados newdb e ver como podemos restaurá-lo a partir do backup obtido anteriormente. Primeiramente, vamos especificar o nome do banco de dados com o argumento --nsInclude. Vamos usar o newdb.* para restaurar todas as coleções. Para restaurar uma única coleção como restaurants, use o newdb.restaurants ao invés disso.

      Em seguida, usando o --drop, vamos garantir que o banco de dados de destino seja primeiro descartado, para que depois o backup seja restaurado em um banco de dados limpo. Como um argumento final, vamos especificar o diretório do último backup, que será parecido com isto: /var/backups/mongobackups/10-29-20/newdb/.

      Assim que tiver um backup com carimbo de data/hora, restaure-o usando este comando:

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

      Você verá uma saída como esta:

      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

      No caso acima, estamos restaurando os dados no mesmo servidor onde criamos o backup. Se quiser migrar os dados para outro servidor e usar a mesma técnica, você deve copiar o diretório de backup — em nosso caso, /var/backups/mongobackups/10-29-20/newdb/ — para o outro servidor.

      Conclusão

      Agora, você terminou de realizar algumas tarefas essenciais relacionadas ao backup, restauração e migração dos seus bancos de dados MongoDB. Nenhum servidor MongoDB de produção deve ser executado sem uma estratégia de backup confiável, como aquela descrita aqui.



      Source link

      Como importar e exportar um banco de dados MongoDB no Ubuntu 20.04


      O autor selecionou a COVID-19 Relief Fund​​​​​ para receber uma doação como parte do programa Write for DOnations.

      Introdução

      O MongoDB é um dos mecanismos de banco de dados NoSQL mais populares. Ele é famoso por ser escalável, poderoso, confiável e fácil de usar. Neste artigo, vamos mostrar como importar e exportar seus bancos de dados MongoDB.

      Devemos deixar claro que ao dizer importação e exportação, estamos nos referindo àquelas operações que lidam com dados em um formato legível para humanos e compatível com outros produtos de software. Em contrapartida, as operações de backup e restauração criam ou usam dados binários específicos do MongoDB, que preservam a consistência e integridade dos seus dados, além de seus atributos específicos do MongoDB. Assim, para a migração, geralmente é preferível usar o backup e restauração, desde que os sistemas de origem e de destino sejam compatíveis.

      As tarefas de backup, reinicialização e migração estão além do escopo deste artigo. Para obter mais informações, consulte Como fazer backup, restaurar e migrar um banco de dados MongoDB no Ubuntu 20.04.

      Pré-requisitos

      Para concluir este tutorial, você precisará do seguinte:

      Passo 1 — Importando informações para o MongoDB

      Para aprender como funciona a importação de informações para o MongoDB, vamos usar como exemplo um banco de dados MongoDB popular sobre restaurantes. Ele está no formato .json e pode ser baixado usando o wget desta forma:

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

      Assim que o download terminar, você terá um arquivo chamado primer-dataset.json (com tamanho de 12 MB) no diretório atual. Vamos importar os dados desse arquivo para um novo banco de dados chamado newdb e para uma coleção chamada restaurants.

      Use o comando mongoimport desta forma:

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

      O resultado ficará parecido com este:

      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 o comando acima mostra, 25359 documentos foram importados. Como não tínhamos um banco de dados chamado newdb, o MongoDB o criou automaticamente.

      Vamos verificar a importação.

      Conecte-se ao banco de dados newdb recém-criado:

      Agora, você está conectado à instância de banco de dados newdb. Note que seu prompt mudou, indicando que você está conectado ao banco de dados.

      Conte os documentos na coleção de restaurantes com o comando:

      O resultado mostrará 25359, que é o número de documentos importados. Para uma verificação ainda melhor, selecione o primeiro documento da coleção de restaurantes desta forma:

      O resultado ficará parecido com este:

      [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"
      }
      

      Uma verificação detalhada como essa poderia revelar problemas com os documentos, como seu conteúdo, codificação, etc. O formato json usa a codificação UTF-8 e suas exportações e importações devem estar naquela codificação. Tenha isso em mente se for editar manualmente algum arquivo json. Caso contrário, o MongoDB manuseará ele automaticamente para você.

      Para sair do prompt do MongoDB, digite exit no prompt:

      Você será enviado de volta ao prompt de linha de comando normal como seu usuário não raiz.

      Passo 2 — Exportando informações do MongoDB

      Como mencionado anteriormente, ao exportar informações do MongoDB, é possível adquirir um arquivo de texto legível para humanos com seus dados. Por padrão, as informações são exportadas no formato json, mas também é possível exportar para csv (valores separados por vírgula).

      Para exportar informações do MongoDB, use o comando mongoexport. Ele permite fazer uma exportação bastante refinada, sendo possível especificar um banco de dados, uma coleção, um campo e até mesmo usar uma consulta para a exportação.

      Um exemplo de mongoexport simples seria exportar a coleção de restaurantes do banco de dados newdb que importamos anteriormente. Isso pode ser feito desta forma:

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

      No comando acima, usamos o --db para especificar o banco de dados, -c para a coleção e --out para o arquivo no qual os dados serão salvos.

      O resultado de um mongoexport executado com sucesso deve ser parecido com este:

      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

      O resultado acima mostra que 25359 documentos foram importados — o mesmo número dos importados.

      Em alguns casos, pode ser necessário exportar apenas uma parte da sua coleção. Considerando a estrutura e o conteúdo do arquivo json de restaurantes, vamos exportar todos os restaurantes que satisfaçam os critérios de estar localizado no bairro do Bronx e ser de cozinha chinesa. Se quisermos obter essas informações diretamente enquanto conectados ao MongoDB, conecte-se novamente ao banco de dados:

      Então, use esta consulta:

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

      Os resultados são exibidos no terminal:

      Output

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

      Para sair do prompt do MongoDB, digite exit:

      Se quiser exportar os dados de uma linha de comando sudo sem estar conectado ao banco de dados, incorpore a consulta anterior no comando mongoexport especificando-a no argumento -q desta forma:

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

      Note que estamos adicionando o caractere de escape de barra invertida () nas aspas duplas da consulta. De maneira similar, é necessário adicionar o caractere de escape a qualquer outro caractere especial na consulta.

      Se a exportação tiver sido bem-sucedida, o resultado se parecerá com este:

      Output

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

      O exemplo acima mostra que 323 registros foram exportados, e é possível encontrá-los no arquivo Bronx_Chinese_retaurants.json que especificamos.

      Use o cat e less para analisar os dados:

      • cat Bronx_Chinese_retaurants.json | less

      Use o SPACE para paginar os dados:

      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}],
      • . . .

      Pressione q para sair. Agora, é possível importar e exportar um banco de dados MongoDB.

      Conclusão

      Este artigo introduziu as informações essenciais sobre a importação e exportação de e para um banco de dados MongoDB. Continue a leitura com Como fazer backup, restaurar e migrar um banco de dados MongoDB no Ubuntu 20.04.

      Considere também o uso da replicação. A replicação permite continuar executando seu serviço MongoDB ininterruptamente a partir de um servidor MongoDB subordinado enquanto estiver restaurando o mestre depois de uma falha. Parte da replicação é o registro de operações (oplog), que registra todas as operações que modificam seus dados. É possível usar esse registro, assim como usaria o registro binário no MySQL, para restaurar seus dados depois que o último backup tiver sido realizado. Lembre-se que os backups geralmente são realizados durante a noite, e se quiser restaurar um backup durante a tarde, você estará perdendo todas as atualizações desde o último backup.



      Source link

      Como processar dados de solicitação de entrada no Flask


      Introdução

      Muitas vezes, os aplicativos Web necessitam do processamento dos dados de solicitação da entrada de usuários. Essa carga pode existir na forma de strings de consulta, dados de formulário e objetos JSON. O Flask, assim como qualquer outro framework Web, permite acessar os dados de solicitação.

      Neste tutorial, será construído um aplicativo Flask com três rotas que aceitam strings de consulta, dados de formulário ou objetos JSON.

      Pré-requisitos

      Para completar este tutorial, você precisará de:

      • Este projeto exigirá o Python instalado em um ambiente local.
      • Este projeto usará o Pipenv, uma ferramenta pronta para a produção que visa trazer o melhor de todos os mundos do empacotamento ao mundo do Python. Ele tira proveito do Pipfile, pip e o virtualenv em um único comando.
      • Baixar e instalar uma ferramenta como o Postman será necessário para testar os pontos de extremidade da API.

      Este tutorial foi verificado com o Pipenv v2020.11.15, Python v3.9.0 e o Flask v1.1.2.

      Configurando o projeto

      Para demonstrar as diferentes formas de usar solicitações, será necessário criar um aplicativo Flask. Embora o aplicativo de exemplo use uma estrutura simplificada para as funções de visualização e rotas, o que você aprenderá neste tutorial pode ser aplicado a qualquer método para organizar suas visualizações, como as visualizações baseadas em classe, blueprints, ou uma extensão como o Flask-Via.

      Primeiramente, será necessário criar um diretório de projeto. Abra seu terminal e execute o seguinte comando:

      • mkdir flask_request_example

      Em seguida, navegue até o novo diretório:

      Em seguida, instale o Flask. Abra seu terminal e execute o seguinte comando:

      O comando pipenv criará um virtualenv para este projeto, um Pipfile, e também instalará o flask e um Pipfile.lock.

      Para ativar o virtualenv do projeto, execute o seguinte comando:

      Para acessar os dados de entrada no Flask, é necessário usar o objeto request (solicitação). O objeto request contém todos os dados de entrada da solicitação, que inclui o tipomime, referenciador, endereço IP, dados brutos, método HTTP, cabeçalhos, entre outras coisas.

      Embora todas as informações contidas no objeto request possam ser úteis, para os fins deste artigo, você se concentrará nos dados que são normalmente fornecidos diretamente pelo chamador do ponto de extremidade.

      Para ter acesso ao objeto request no Flask, será necessário importá-lo da biblioteca do Flask:

      from flask import request
      

      Depois disso, você pode usá-lo em qualquer uma das suas funções de visualização.

      Use seu editor de código para criar um arquivo app.py. Importe o Flask e o objeto request. Além disso, estabeleça rotas para query-example, form-example e 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)
      

      Em seguida, abra seu terminal e inicie o aplicativo com o seguinte comando:

      O aplicativo será iniciado na porta 5000. Sendo assim, você pode visualizar cada rota no seu navegador com os seguintes links:

      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)
      

      O código estabelece três rotas e visitar cada rota exibirá as mensagens de "Query String Example", "Form Data Example" e "JSON Object Example", respectivamente.

      Usando argumentos de consulta

      Os argumentos de URL que você adiciona a uma string de consulta representam uma maneira comum de passar dados para um aplicativo Web. Enquanto navegava na Web, você provavelmente já se deparou com uma string de consulta antes.

      Uma string de consulta se assemelha ao seguinte:

      example.com?arg1=value1&arg2=value2
      

      A string de consulta começa após o caractere de ponto de interrogação (?):

      example.com?arg1=value1&arg2=value2
      

      E possui pares de chave-valor separados por um caractere de E comercial (&):

      example.com?arg1=value1&arg2=value2
      

      Para cada par, a chave é seguida de um caractere de sinal igual (=) e então o valor.

      arg1 : value1
      arg2 : value2
      

      As strings de consulta são úteis para passar dados que não exigem que o usuário tome nenhuma ação. Se quiser, é possível gerar uma string de consulta em algum lugar do seu aplicativo e adicioná-la a uma URL para que quando um usuário fizer uma solicitação, os dados sejam automaticamente passados a eles. Uma string de consulta também pode ser gerada por formulários que têm o GET como método.

      Vamos adicionar uma string de consulta à rota query-example. Neste exemplo hipotético, você adicionará o nome de uma linguagem de programação que será exibido na tela. Crie uma chave "language" e um valor de "Python":

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

      Se executar o aplicativo e navegar até essa URL, você verá que ele ainda exibe uma mensagem de "Query String Example".

      Será necessário programar a parte que lida com os argumentos de consulta. Esse código lerá a chave language usando o request.args.get('language') ou request.args['language'].

      Se chamarmos o request.args.get('language'), o aplicativo continuará em execução se a chave language não existir na URL. Neste caso, o resultado do método será None.

      Se chamarmos o request.args['language'], o aplicativo retornará um erro 400 se a chave language não existir na URL.

      Ao lidar com strings de consulta, é recomendável usar o request.args.get() para evitar que o aplicativo falhe.

      Vamos ler a chave language e exibi-la como um resultado.

      Modifique a rota query-example no app.py com o seguinte 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)
      

      Em seguida, execute o aplicativo e navegue até a URL:

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

      O navegador exibirá a seguinte mensagem:

      Output

      The language value is: Python

      O argumento da URL é atribuído à variável language e então é retornado ao navegador.

      Para adicionar mais parâmetros à string de consulta, adicione caracteres & e os novos pares de chave-valor no final da URL. Crie uma chave “framework” e um valor de ”Flask”:

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

      E se quiser ainda mais, continue adicionando caracteres & e pares de chave-valor. Crie uma chave “website” e um valor de ”DigitalOcean”:

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

      Para ter acesso a esses valores, você ainda usará o request.args.get() ou request.args[]. Vamos usar ambos para demonstrar o que acontece quando uma chave estiver faltando. Modifique a rota query_example para atribuir o valor dos resultados às variáveis e então exibi-las:

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

      Em seguida, execute o aplicativo e navegue até a URL:

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

      O navegador exibirá a seguinte mensagem:

      Output

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

      Remova a chave language da URL:

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

      O navegador exibirá a mensagem a seguir. O valor None é utilizado se um valor não for fornecido para language:

      Output

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

      Remova a chave framework da URL:

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

      O navegador deve encontrar um erro porque está esperando um 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'

      Agora, você sabe como manusear strings de consulta. Vamos continuar para o próximo tipo de dados de entrada.

      Usando dados de formulários

      Os dados de formulário vêm de um formulário que foi enviado como uma solicitação POST para uma rota. Assim, ao invés de ver os dados na URL (exceto para casos quando o formulário for enviado com uma solicitação GET), os dados do formulário serão passados para o aplicativo em segundo plano. Embora os dados de formulário que são passados não possam ser facilmente vistos, seu aplicativo ainda pode lê-los.

      Para demonstrar isso, modifique a rota form-example no app.py para aceitar tanto as solicitações GET quanto POST e retornar um formulário:

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

      Em seguida, execute o aplicativo e navegue até a URL:

      http://127.0.0.1:5000/form-example
      

      O navegador exibirá um formulário com dois campos de entrada — um para language e um para framework — e um para o botão de enviar.

      A coisa mais importante para saber sobre este formulário é que ele executa uma solicitação POST na mesma rota que gerou o formulário. Todas as chaves que serão lidas no aplicativo vêm dos atributos name em nossas entradas de formulários. Neste caso, language e framework são os nomes das entradas. Sendo assim, você terá acesso a eles no aplicativo.

      Dentro da função de visualização, será necessário verificar se o método de solicitação é o GET ou POST. Se for uma solicitação GET, você pode exibir o formulário. Caso contrário, se for uma solicitação POST, então será preciso processar os dados de entrada.

      Modifique a rota form-example no app.py com o seguinte 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>'''
      

      Em seguida, execute o aplicativo e navegue até a URL:

      http://127.0.0.1:5000/form-example
      

      Preencha o campo language com o valor de Python e o campo framework com o valor de Flask. Em seguida, pressione Submit.

      O navegador exibirá a seguinte mensagem:

      Output

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

      Agora, você sabe como manusear dados de formulários. Vamos continuar para o próximo tipo de dados de entrada.

      Usando dados de JSON

      Os dados de JSON são normalmente construídos por um processo que chama a rota.

      Um objeto JSON de exemplo se parece com este:

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

      Essa estrutura permite que dados muito mais complicados sejam passados se comparada a strings de consulta e dados de formulários. No exemplo, podemos ver objetos JSON aninhados e uma matriz de itens. O Flask é capaz de manipular este formato de dados.

      Modifique a rota form-example no app.py para aceitar solicitações POST e ignorar outras solicitações, como GET:

      app.py

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

      Diferentemente do navegador Web usado para strings de consulta e dados de formulários, para os fins deste artigo, um Postman será usado para enviar solicitações personalizadas para URLs de forma a enviar um objeto JSON.

      Nota: se precisar de ajuda para navegar pela interface do Postman para as solicitações, consulte a documentação oficial.

      No Postman, adicione a URL e altere o tipo para POST. Na guia de corpo, mude para raw e selecione JSON na lista suspensa.

      Essas configurações são necessárias para que o Postman consiga enviar dados de JSON corretamente e para que seu aplicativo Flask compreenda que está recebendo JSON:

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

      Em seguida, copie o exemplo de JSON anterior na entrada de texto.

      Envie a solicitação e você deve obter uma resposta “JSON Object Example”. Isso pode ser um tanto decepcionante, mas é de se esperar, porque o código para manusear a resposta dos dados de JSON ainda não está escrito.

      Para ler os dados, é necessário entender como o Flask traduz dados de JSON para estruturas de dados do Python:

      • Qualquer coisa que seja um objeto é convertida para um dict do Python. {“key” : ”value”} em JSON corresponde a somedict['key'], que retorna um valor em Python.
      • Uma matriz em JSON é convertida para uma lista no Python. Como a sintaxe é a mesma, aqui está uma lista de exemplo: [1,2,3,4,5]
      • Os valores dentro de aspas no objeto JSON se tornam strings no Python.
      • Os booleanos true e false se tornam True e False no Python.
      • Por fim, os números sem aspas em sua volta se tornam números no Python.

      Agora, vamos trabalhar com o código para que leia os dados de JSON de entrada.

      Primeiramente, vamos atribuir tudo do objeto JSON a uma variável usando o request.get_json().

      O request.get_json() converte o objeto JSON para dados do Python. Vamos atribuir os dados de solicitação de entrada às variáveis e retorná-las fazendo as seguintes alterações na rota 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)
      

      Note como os elementos que não estão no nível superior são acessados. O ['version']['python'] é usado porque você está entrando em um objeto aninhado. E o ['examples'][0] é usado para acessar o índice 0 na matriz de exemplos.

      Se o objeto JSON enviado com a solicitação não tiver uma chave que seja acessada na sua função de visualização, então a solicitação falhará. Se não quiser que ela falhe quando uma chave não existir, será necessário verificar se a chave existe antes de tentar acessá-la.

      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)
      

      Execute o aplicativo e envie a solicitação JSON de exemplo usando o Postman. Na resposta, o seguinte resultado será exibido:

      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

      Agora, você sabe como processar objetos JSON.

      Conclusão

      Neste tutorial, você construiu um aplicativo Flask com três rotas que aceitam strings de consulta, dados de formulário ou objetos JSON.

      Além disso, lembre-se de que todas as abordagens precisaram lidar com o fato recorrente de falharem graciosamente quando uma chave está faltando.

      Aviso: um tópico que não foi abordado neste artigo é a limpeza das entradas de usuário. A limpeza das entradas de usuário garante que os dados lidos pelo aplicativo não façam com que algo falhe de maneira inesperada ou contorne medidas de segurança.

      Se quiser aprender mais sobre o Flask, confira nossa página de tópico do Flask para exercícios e projetos de programação.



      Source link