One place for hosting & domains

      Comment

      Create a Laravel and Angular Single Page Comment Application

      Introduction

      Laravel and Angular have both become very well renowned tools in the web development world lately. Laravel for the great things it brings to the PHP community and Angular for the amazing frontend tools and its simplicity. Combining these two great frameworks only seems like the logical next step.

      For our use cases, we will be using Laravel as the RESTful API backend and Angular as the frontend to create a very simple single-page comment application.

      This will be a simple example to show off how to get started using these two technologies so don’t hope for any extra database stuff on how to handle sub-comments or anything like that.

      This will be a simple single-page comment application:

      • RESTful Laravel API to handle getting, creating, and deleting comments
      • Angular frontend to handle showing our creation form and the comments
      • Ability to create a comment and see it added to our list without page refresh
      • Ability to delete a comment and see it removed from our list without page refresh

      Overall, these are very simple concepts. Our focus will be to see the intricacies of how Laravel and Angular can work together.

      Setting Up Laravel

      Go ahead and get your Laravel setup ready. We’ll be doing some basic things to get our backend to do CRUD on comments:

      • Create a database migration
      • Seed our database with sample comments
      • Create our routes for our API
      • Creating a catch-all route to let Angular handle routing
      • Creating a resource controller for comments

      Getting our Database Ready Migrations

      We will need a simple structure for our comments. We just need text and author. Let’s create our Laravel migration to create our comments.

      Let’s run the artisan command that will create our comments migration so that we can create the table in our database:

      1. php artisan migrate:make create_comments_table --create=comments

      We’ll use the Laravel Schema Builder to create the text and author fields that we need. Laravel will also create the id column and the timestamps so that we know how long ago the comment was made. Here is the code for the comments table:

      app/database/migrations/####_##_##_######_create_comments_table.php

          ...
      
              
              public function up()
              {
                  Schema::create('comments', function(Blueprint $table)
                  {
                      $table->increments('id');
      
                      $table->string('text');
                      $table->string('author');
      
                      $table->timestamps();
                  });
              }
      
          ...
      

      Make sure you go adjust your database settings in app/config/database.php with the right credentials. Now we will run the migration so that we create this table with the columns that we need:

      1. php artisan migrate

      With our table made, let’s create an Eloquent model so that we can interact with it.

      We will be using Laravel Eloquent models to interact with our database. This will be very easy to do. Let’s create a model: app/models/Comment.php.

      app/models/Comment.php

          <?php
      
          class Comment extends Eloquent { 
      

      We now have our new table and model. Let’s fill it with some sample data using Laravel Seeding.

      Seeding Our Database

      We will need a few comments so that we can test a few things. Let’s create a seed file and fill our database with 3 sample comments.

      Create a file: app/database/seeds/CommentTableSeeder.php and fill it with this code.

      app/database/seeds/CommentTableSeeder.php

          <?php
      
          class CommentTableSeeder extends Seeder {
      
              public function run()
              {
                  DB::table('comments')->delete();
      
                  Comment::create(array(
                      'author' => 'Chris Sevilleja',
                      'text' => 'Comment by Chris.'
                  ));
      
                  Comment::create(array(
                      'author' => 'Nick Cerminara',
                      'text' => 'Comment by Nick.'
                  ));
      
                  Comment::create(array(
                      'author' => 'Holly Lloyd',
                      'text' => 'Comment by Holly.'
                  ));
              }
      
          }
      

      To call this Seeder file, let’s open app/database/seeds/DatabaseSeeder.php and add the following:

      app/database/seeds/DatabaseSeeder.php

          ...
      
              
              public function run()
              {
                  Eloquent::unguard();
      
                  $this->call('CommentTableSeeder');
                  $this->command->info('Comment table seeded.');
              }
      
          ...
      

      Now let’s run our seeders using artisan.

      1. php artisan db:seed

      Now we have a database with a comment table, an Eloquent model, and samples in our database. Not bad for a day’s work… but we’re not even close to done yet.

      We will use Laravel’s resource controllers to handle our API functions for comments. Since we’ll be using Angular to display a resource and show create and update forms, we’ll create a resource controller with artisan without the create or edit functions.

      Let’s create our controller using artisan.

      1. php artisan controller:make CommentController --only=index,store,destroy

      For our demo app, we’ll only be using these three functions in our resource controller. To expand on this you’d want to include all the functions like update, show, update for a more fully-fledged app.

      Now we’ve created our controller. We don’t need the create and edit functions because Angular will be handling showing those forms, not Laravel. Laravel is just responsible for sending data back to our frontend. We also took out the update function for this demo just because we want to keep things simple. We’ll handle creating, showing, and deleting comments.

      To send data back, we will want to send all our data back as JSON. Let’s go through our newly created controller and fill out our functions accordingly.

      app/controllers/CommentController.php

          <?php
      
          class CommentController extends BaseController {
      
              
              public function index()
              {
                  return Response::json(Comment::get());
              }
      
              
              public function store()
              {
                  Comment::create(array(
                      'author' => Input::get('author'),
                      'text' => Input::get('text')
                  ));
      
                  return Response::json(array('success' => true));
              }
      
              
              public function destroy($id)
              {
                  Comment::destroy($id);
      
                  return Response::json(array('success' => true));
              }
      
          }
      

      You can see how easy it is to handle CRUD with Laravel and Eloquent. It’s incredibly simple to handle all the functions that we need.

      With our controller ready to go, the last thing we need to do for our backend is routing.

      Extra Reading: Simple Laravel CRUD with Resource Controllers

      Our Routes app/routes.php

      With our database ready to rock and roll, let’s handle the routes of our Laravel application. We will need routes to send users to the Angular frontend since that will have its own routing. We will also need routes for our backend API so people can access our comment data.

      Let’s create the Angular pointing routes. We will need one for the home page and a catch-all route to send users to Angular. This ensures that any way a user accesses our site, they will be routed to the Angular frontend.

      We’ll be prefixing our API routes with… (drumroll please)… api. This way, if somebody wants to get all comments, they will use the URL: http://example.com/api/comments. This just makes sense moving forward and is some basic API creation good tactics.

      app/routes.php

          <?php
          
          
          
          
          Route::get('/', function() {
              View::make('index'); 
          });
      
          
          Route::group(array('prefix' => 'api'), function() {
      
              
              
              
              Route::resource('comments', 'CommentController',
                  array('only' => array('index', 'store', 'destroy')));
      
          });
      
          
          
          
          App::missing(function($exception) {
              return View::make('index');
          });
      

      We now have our routes to handle the 3 main things our Laravel backend needs to do.

      Handling Catch-All Routes: In Laravel, you can do this a few ways. Usually, it isn’t ideal to do the above code and have a catch-all for your entire application. The alternative is that you can use Laravel Controller Missing Methods to catch routes.

      Testing All Our Routes Let’s make sure we have all the routes we need. We’ll use artisan and see all our routes:

      1. php artisan routes

      This command will let us see our routes and sort of a top-down view of our application.

      We can see the HTTP verb and the route used to get all comments, get a single comment, create a comment, and destroy a comment. On top of those API routes, we can also see how a user gets routed to our Angular application by the home page route.

      Backend Done

      Finally! Our Laravel API backend is done. We have done so much and yet, there’s still so much to do. We have set up our database and seeded it, created our models and controllers, and created our routes. Let’s move on to the frontend Angular work.

      I’ve seen this question asked a lot. Where exactly should I be putting Angular files and how does Laravel and Angular work together. We did an article on Using Laravel Blade with AngularJS. This article works under the assumption that we aren’t even going to use Blade.

      To let Angular handle the frontend, we will need Laravel to pass our user to our index.php file. We can place this in a few different places. By default, when you use:

      app/routes.php

          Route::get('/', function() {
              return View::make('index');
          });
      

      This will return app/views/index.php. Laravel will by default look in the app/views folder.

      Some people may want to keep Angular files completely separate from Laravel files. They will want their entire application to be housed inside of the public folder. To do this is simple: just change the default View location to the public folder. This can be done in the app/config/view.php file.

      app/config/view.php

          ...
      
              
              'paths' => array(__DIR__.'/../../public/views'),
      
          ...
      

      Now return View::make('index') will look for public/views/index.php. It is all preference on how you’d like to structure your app. Some people see it as a benefit to have the entire Angular application in the public folder so that it is easier to handle routing and if it is needed in the future, to completely separate the backend RESTful API and the Angular frontend.

      For Angular routing, then your partial files will be placed in the public folder, but that’s out of the scope of this article. For more information on that kind of single-page Angular routing, check out Single Page Angular Application Routing.

      Let’s assume we left everything default and our main view file is in our app/views folder and move forward.

      Routing with Laravel and Angular There are a lot of questions about having routing with Laravel and Angular and if they conflict. Laravel will handle the main routing for your application. Angular routing will only happen when Laravel routes our user to the main Angular route (index.php) in this case. This is why we use a Laravel catch-all route. Laravel will handle the API routes and anything it doesn’t know how to route will be sent to Angular. You can then set up all the routing for your Angular application to handle showing different views.

      Getting Our Application Ready

      Everything for our Angular application will be handled in the public folder. This lets us keep a good separation of the backend in the app folder.

      Let’s look at the application structure we will have in our public folder. We’ve created our Angular application to be modular since that is best practice. Now our separated parts of our application will be easy to test and work with.

          - public/
          ----- js/
          ---------- controllers/ // where we will put our angular controllers
          --------------- mainCtrl.js
          ---------- services/ // angular services
          --------------- commentService.js
          ---------- app.js
      

      Our Angular service is going to be the primary place where we will have our HTTP calls to the Laravel API. It is pretty straightforward and we use the Angular $http service.

      public/js/services/commentService.js

          angular.module('commentService', [])
      
          .factory('Comment', function($http) {
      
              return {
                  
                  get : function() {
                      return $http.get('/api/comments');
                  },
      
                  
                  save : function(commentData) {
                      return $http({
                          method: 'POST',
                          url: '/api/comments',
                          headers: { 'Content-Type' : 'application/x-www-form-urlencoded' },
                          data: $.param(commentData)
                      });
                  },
      
                  
                  destroy : function(id) {
                      return $http.delete('/api/comments/' + id);
                  }
              }
      
          });
      

      This is our Angular service with 3 different functions. These are the only functions we need since they will correspond to the API routes we made in our Laravel routes.

      We will be returning the promise object from our service. These will be dealt with in our controllers. The naming convention here also stays the same as the Laravel controller that we have.

      With our Angular Service done, let’s go into our controller and use it.

      Angular Controller public/js/controllers/mainCtrl.js

      The controller is where we will have most of the functionality for our application. This is where we will create functions to handle the submit forms and deleting on our view.

      public/js/controllers/mainCtrl.js

          angular.module('mainCtrl', [])
      
          
          .controller('mainController', function($scope, $http, Comment) {
              
              $scope.commentData = {};
      
              
              $scope.loading = true;
      
              
              
              
              Comment.get()
                  .success(function(data) {
                      $scope.comments = data;
                      $scope.loading = false;
                  });
      
              
              
              $scope.submitComment = function() {
                  $scope.loading = true;
      
                  
                  
                  Comment.save($scope.commentData)
                      .success(function(data) {
      
                          
                          Comment.get()
                              .success(function(getData) {
                                  $scope.comments = getData;
                                  $scope.loading = false;
                              });
      
                      })
                      .error(function(data) {
                          console.log(data);
                      });
              };
      
              
              
              $scope.deleteComment = function(id) {
                  $scope.loading = true;
      
                  
                  Comment.destroy(id)
                      .success(function(data) {
      
                          
                          Comment.get()
                              .success(function(getData) {
                                  $scope.comments = getData;
                                  $scope.loading = false;
                              });
      
                      });
              };
      
          });
      

      As you can see in our controller, we have injected our Comment service and use it for the main functions: get, save, and delete. Using a service like this helps to not pollute our controller with $http gets and puts.

      Connecting Our Application public/js/app.js

      On the Angular side of things, we have created our service and our controller. Now let’s link everything together so that we can apply it to our application using ng-app and ng-controller.

      This will be the code to create our Angular application. We will inject the service and controller into. This is a best practice since it keeps our application modular and each different part can be testable and extendable.

      public/js/app.js

          var commentApp = angular.module('commentApp', ['mainCtrl', 'commentService']);
      

      That’s it! Not much to it. Now we’ll actually get to our view where we can see how all these Angular parts work together.

      Our Main View app/views/index.php

      So far, after everything we’ve done up to this point, we still won’t be able to see anything in our browser. We will need to define our view file since Laravel in our home route and our catch-all route returns return View::make('index');.

      Let’s go ahead and create that view now. We will be using all the Angular parts that we’ve created. The main parts that we’ve created from Angular that we’ll use in index.php are:

      • ng-app and ng-controller: We’ll apply these to our application by attaching them to our body tag
      • ng-repeat: We’ll loop over the comments and display them in our template
      • submitComment(): We’ll attach this function to our form using ng-submit
      • Loading Icons: We’ll create a variable called loading. If it is set to true, we’ll show a loading icon and hide the comments
      • deleteComment(): We’ll attach this function to a delete link so that we can remove the comment

      Now let’s get to the actual code for our view. We’ll comment out the main important parts so we can see how everything works together.

      app/views/index.php

          <!doctype html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Laravel and Angular Comment System</title>
      
              <!-- CSS -->
              <link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.1.0/css/bootstrap.min.css"> <!-- load bootstrap via cdn -->
              <link rel="stylesheet" href="//netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.min.css"> <!-- load fontawesome -->
              <style>
                  body        { padding-top:30px; }
                  form        { padding-bottom:20px; }
                  .comment    { padding-bottom:20px; }
              </style>
      
              <!-- JS -->
              <script src="//ajax.googleapis.com/ajax/libs/jquery/2.0.3/jquery.min.js"></script>
              <script src="//ajax.googleapis.com/ajax/libs/angularjs/1.2.8/angular.min.js"></script> <!-- load angular -->
      
              <!-- ANGULAR -->
              <!-- all angular resources will be loaded from the /public folder -->
                  <script src="js/controllers/mainCtrl.js"></script> <!-- load our controller -->
                  <script src="js/services/commentService.js"></script> <!-- load our service -->
                  <script src="js/app.js"></script> <!-- load our application -->
      
      
          </head>
          <!-- declare our angular app and controller -->
          <body class="container" ng-app="commentApp" ng-controller="mainController"> <div class="col-md-8 col-md-offset-2">
      
              <!-- PAGE TITLE =============================================== -->
              <div class="page-header">
                  <h2>Laravel and Angular Single Page Application</h2>
                  <h4>Commenting System</h4>
              </div>
      
              <!-- NEW COMMENT FORM =============================================== -->
              <form ng-submit="submitComment()"> <!-- ng-submit will disable the default form action and use our function -->
      
                  <!-- AUTHOR -->
                  <div class="form-group">
                      <input type="text" class="form-control input-sm" name="author" ng-model="commentData.author" placeholder="Name">
                  </div>
      
                  <!-- COMMENT TEXT -->
                  <div class="form-group">
                      <input type="text" class="form-control input-lg" name="comment" ng-model="commentData.text" placeholder="Say what you have to say">
                  </div>
      
                  <!-- SUBMIT BUTTON -->
                  <div class="form-group text-right">
                      <button type="submit" class="btn btn-primary btn-lg">Submit</button>
                  </div>
              </form>
      
              <!-- LOADING ICON =============================================== -->
              <!-- show loading icon if the loading variable is set to true -->
              <p class="text-center" ng-show="loading"><span class="fa fa-meh-o fa-5x fa-spin"></span></p>
      
              <!-- THE COMMENTS =============================================== -->
              <!-- hide these comments if the loading variable is true -->
              <div class="comment" ng-hide="loading" ng-repeat="comment in comments">
                  <h3>Comment 
                  <p>{{ comment.text }}</p>
      
                  <p><a href="#" ng-click="deleteComment(comment.id)" class="text-muted">Delete</a></p>
              </div>
      
          </div>
          </body>
          </html>
      

      Now we finally have our view that brings all of the parts we created together. You can go ahead and play around with the application. All the parts should fit together nicely and creating and deleting comments should be done without a page refresh.

      Make sure you take a look at the GitHub repo to test the application. Here are some quick instructions to get you going.

      1. Clone the repo: git clone [email protected]:scotch-io/laravel-angular-comment-app
      2. Install Laravel: composer install --prefer-dist
      3. Change your database settings in app/config/database.php
      4. Migrate your database: php artisan migrate
      5. Seed your database: php artisan db:seed
      6. View your application in the browser!

      Hopefully, this tutorial gives a good overview of how to start an application using Laravel and Angular. You can bring this further and create a full application that can handle multiple API calls on the Laravel side, and even create your own Angular routing for multiple pages.

      Sound off in the comments if you have any questions or would like to see a specific use case. We can also expand on this demo and start adding different things like editing a comment, user profiles, whatever.

      Comment sauvegarder, restaurer et migrer une base de données MongoDB sur Ubuntu 20.04


      L’auteur a choisi le COVID-19 Relief Fund pour recevoir un don dans le cadre du programme Write for DOnations.

      Introduction

      MongoDB est l’un des moteurs de base de données NoSQL les plus populaires. Il doit sa célébrité à son évolutivité, sa robustesse, sa fiabilité et sa facilité d’utilisation. À l’aide de cet article, vous allez sauvegarder, restaurer et migrer un échantillon de base de données MongoDB.

      Lorsque l’on parle d’importation et d’exportation d’une base de données, nous faisons référence à la gestion de données sous un format lisible par l’homme et qui sont compatibles avec d’autres produits logiciels. En revanche, les opérations de sauvegarde et de restauration de MongoDB créent ou utilisent des données binaires spécifiques à MongoDB. Elles préservent non seulement la cohérence et l’intégrité de vos données mais également leurs attributs MongoDB spécifiques. Par conséquent, lors de la migration, il est généralement recommandé d’utiliser la sauvegarde et la restauration dans la mesure où les systèmes source et cible sont compatibles.

      Conditions préalables

      Avant de suivre ce tutoriel, vérifiez si vous répondez bien aux conditions préalables suivantes :

      Sauf indication contraire, toutes les commandes qui nécessitent des privilèges root dans ce tutoriel doivent être exécutées en tant que non-root user avec des privilèges sudo.

      Étape 1 — Utiliser JSON et BSON dans MongoDB

      Avant de poursuivre avec cet article, vous devez avoir quelques connaissances de base sur le sujet. Si vous avez de l’expérience avec d’autres systèmes de base de données NoSQL comme Redis, il se peut que vous trouviez quelques similitudes avec MongoDB.

      MongoDB utilise les formats JSON et BSON (JSON binaire) pour stocker ses informations. JSON est le format lisible par l’homme, idéal pour exporter et éventuellement importer vos données. Vous pouvez également gérer vos données exportées avec tout outil qui prend en charge JSON et notamment un éditeur de texte simple.

      Voici à quoi ressemble un exemple de document JSON :

      Example of JSON Format

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

      Bien que le format JSON soit pratique pour travailler, il ne prend cependant pas en charge tous les types de données disponibles dans BSON. Cela signifie que, si vous utilisez JSON, vous ferez l’expérience de ce que l’on nomme une « perte de fidélité » des informations. Que ce soit pour la sauvegarde ou la restauration, il est donc préférable d’utiliser le format binaire BSON.

      Deuxièmement, vous n’aurez plus à vous soucier de créer explicitement une base de données MongoDB. Si la base de données spécifiée que vous souhaitez importer n’existe pas encore, elle sera automatiquement créée. Cette fonctionnalité est encore plus pratique avec la structure des collections (tables de la base de données). Contrairement à d’autres moteurs de base de données, dans MongoDB, la structure est également créée automatiquement à l’insertion du premier document (ligne de la base de données).

      Troisièmement, dans MongoDB, il se peut que la lecture et l’insertion de grandes quantités de données, (comme les tâches de cet article par exemple) exigent un volume intensif de ressources et consomment une grande partie de votre CPU, de votre mémoire et de votre espace disque. Ce point est crucial, car on utilise fréquemment MongoDB avec de grandes bases de données et les Big Data. Pour palier ce problème, la solution la plus simple consiste à exécuter les exportations et les sauvegardes pendant la nuit ou en-dehors des heures de pointe.

      Quatrièmement, il se peut que la cohérence des informations pose des problèmes si le serveur MongoDB est occupé et si les informations qui s’y trouvent changent pendant le processus d’exportation ou de sauvegarde de la base de données. Il existe une solution possible à ce problème qui est la réplication. Vous pourrez envisager de l’utiliser une fois que vous en saurez davantage sur MongoDB.

      Bien que vous puissiez utiliser les fonctions import et export pour sauvegarder et restaurer vos données, il existe de meilleures façons d’assurer la complète intégrité de vos bases de données MongoDB. Pour sauvegarder vos données, nous vous recommandons d’utiliser la commande mongodump. Pour la restauration, utilisez mongorestore. Voyons comment ces deux commandes fonctionnent.

      Étape 2 — Utiliser mongodump pour sauvegarder une base de données MongoDB

      Examinons tout d’abord de quelle manière sauvegarder votre base de données MongoDB.

      Un des arguments essentiels de mongodump est --db. Il spécifie le nom de la base de données que vous souhaitez sauvegarder. Si vous omettez de spécifier le nom de la base de données, mongodump procédera à la sauvegarde de toutes vos bases de données. Le second argument important est --out. Il permet de définir le répertoire dans lequel les données seront déchargées. Par exemple, sauvegardons la base de données newdb et sauvegardons-la dans le répertoire /var/backups/mongobackups. Idéalement, chacune de nos sauvegardes devraient se trouver dans un répertoire affichant la date du jour comme suit : /var/backups/mongobacackup/10-29-20.

      Créez tout d’abord ce répertoire /var/backups/mongobackups :

      • sudo mkdir /var/backups/mongobackups

      Ensuite, exécutez mongodump :

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

      Vous verrez un résultat similaire à ce qui suit :

      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)

      Notez que, dans le chemin du répertoire ci-dessus, nous avons utilisé date +"%m-%d-%y qui permet d’obtenir la date du jour automatiquement. Nos sauvegardes se trouveront ainsi dans le répertoire nommé de la manière suivante : /var/backups/10-29-20/. Ceci est particulièrement pratique pour automatiser les sauvegardes.

      À ce stade, vous disposez d’une sauvegarde complète de la base de données newdb dans le répertoire /var/backups/mongobackups/10-29-20/newdb/. Cette sauvegarde intègre tout ce dont vous avez besoin pour restaurer la newdb correctement et préserver sa dénommée « fidélité ».

      En règle générale, vous devriez régulièrement procéder à des sauvegardes, de préférence au moment où le serveur est le moins chargé. Par conséquent, vous pouvez configurer la commande mongodump comme un travail cron afin qu’elle s’exécute régulièrement, par exemple, chaque jour à 03:03 du matin.

      Pour cela, ouvrez crontab, l’éditeur de cron :

      Notez que, lorsque vous exécutez sudo crontab, vous allez modifier les tâches cron pour le root user. Cette commande est recommandée. En effet, si vous configurez les crons pour votre utilisateur, ils ne s'exécuteront pas correctement, surtout si votre profil sudo nécessite une vérification du mot de passe.

      Dans l'invite crontab, insérez la commande mongodump suivante :

      crontab

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

      Dans la commande ci-dessus, nous avons omis l'argument --db sur l'objet délibérément, car vous souhaiterez généralement sauvegarder toutes vos bases de données.

      En fonction de la taille de votre base de données MongoDB, vous devriez rapidement manquer d'espace disque à cause du nombre élevé de sauvegardes. C'est pourquoi il est également recommandé de nettoyer ou de compresser régulièrement les anciennes sauvegardes.

      Par exemple, si vous souhaitez supprimer toutes les sauvegardes de plus de sept jours, vous pouvez utiliser la commande bash suivante :

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

      De la même manière que la commande mongodump précédente, vous pouvez également ajouter cette commande en tant que cron. Elle devra être exécutée juste avant de commencer la prochaine sauvegarde, par exemple, à 03:01 du matin. Pour cela, ouvrez à nouveau crontab :

      Ensuite, insérez la ligne suivante :

      crontab

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

      Enregistrez et fermez le fichier.

      En exécutant toutes les tâches de cette étape, vous disposerez d'une solution de sauvegarde adaptée à vos bases de données MongoDB.

      Étape 3 — Utiliser mongorestore pour restaurer et migrer une base de données MongoDB

      Lorsque vous restaurez votre base de données MongoDB à l'aide d'une sauvegarde précédente, vous obtenez la copie exacte de vos informations MongoDB à un moment particulier qui inclut tous les index et les types de données. Ceci est particulièrement utile pour migrer vos bases de données MongoDB. Pour restaurer MongoDB, nous allons utiliser la commande mongorestore qui fonctionne avec les sauvegardes binaires générées par mongodump.

      Continuons à travailler sur nos exemples avec la base de données newdb pour voir de quelle manière nous pouvons la restaurer à partir de la sauvegarde précédemment réalisée. Nous allons tout d'abord spécifier le nom de la base de données en utilisant l'argument --nsInclude. Nous allons ensuite utiliser newdb.* pour restaurer toutes les collections. Pour restaurer une collection unique, comme restaurants, utilisez plutôt newdb.restaurants.

      Puis, en utilisant --drop, nous allons veiller à ce que la base de données cible soit tout d'abord supprimée afin que la sauvegarde puisse être restaurée dans une base de données propre. Pour finir, nous allons spécifier le répertoire de la dernière sauvegarde, dont l'appellation devrait ressembler à ce qui suit : /var/backups/mongobackups/10-29-20/newdb/.

      Une fois que vous disposez d'une sauvegarde horodatée, vous pouvez la restaurer en utilisant la commande suivante :

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

      Vous verrez un résultat similaire à ce qui suit :

      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

      Dans le cas ci-dessus, nous avons restauré les données sur le serveur dans lequel nous avons créé la sauvegarde. Si vous souhaitez migrer les données sur un autre serveur et utiliser la même technique, vous devrez alors copier le répertoire de sauvegarde, c'est-à-dire /var/backups/mongobackups/10-29-20/newdb/ dans notre cas, sur l'autre serveur.

      Conclusion

      Vous avez désormais exécuté quelques-unes des tâches essentielles liées à la sauvegarde, la restauration et la migration de vos bases de données MongoDB. Aucun serveur MongoDB de production ne devrait jamais être exécuté sans une stratégie de sauvegarde fiable, comme celle décrite ici.



      Source link

      Comment importer et exporter une base de données MongoDB sur Ubuntu 20.04


      L’auteur a choisi le COVID-19 Relief Fund pour recevoir un don dans le cadre du programme Write for DOnations.

      Introduction

      MongoDB est l’un des moteurs de base de données NoSQL les plus populaires. Il doit sa célébrité à son évolutivité, sa puissance, sa fiabilité et sa facilité d’utilisation. Dans cet article, nous allons vous montrer de quelle manière importer et exporter vos bases de données MongoDB.

      Notez que par import et export, nous faisons référence aux opérations qui traitent des données sous un format lisible par l’homme, compatibles avec d’autres produits logiciels. En revanche, les opérations de sauvegarde et de restauration créent ou utilisent des données binaires spécifiques à MongoDB, qui préservent la cohérence et l’intégrité de vos données et également ses attributs MongoDB spécifiques. Par conséquent, lors de la migration, il est généralement recommandé d’utiliser la sauvegarde et la restauration dans la mesure où les systèmes source et cible sont compatibles.

      La sauvegarde, la restauration et les tâches de migration ne sont pas traitées dans cet article. Pour plus d’informations à ce sujet, consultez Comment sauvegarder, restaurer et migrer une base de données MongoDB sur Ubuntu 20.04.

      Conditions préalables

      Pour suivre ce tutoriel, vous aurez besoin des éléments suivants :

      Étape 1 — Importer des informations dans MongoDB

      Pour apprendre à importer des informations dans MongoDB, nous allons utiliser un échantillon populaire de base de données MongoDB, les restaurants. Elle est au format .json et peut être téléchargée en utilisant wget de la manière suivante :

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

      Une fois le téléchargement terminé, vous devriez obtenir un fichier nommé primer-dataset.json (de 12 Mo) dans le répertoire actuel. Importons les données de ce fichier dans une nouvelle base de données que nous appellerons newdb et dans une collection nommée restaurants.

      Utilisez la commande mongoimport de la manière suivante :

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

      Le résultat ressemblera à ceci :

      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

      Comme la commande ci-dessus l’indique, nous avons importé 25 359 documents. Étant donné que nous ne disposions pas d’une base de données appelée newdb, MongoDB l’a créée automatiquement.

      Vérifions l’importation.

      Connectez-vous à la base de données newdb nouvellement créée :

      Vous êtes maintenant connecté à l'instance de base de données newdb. Notez que votre invite a changé et indique désormais que vous êtes connecté à la base de données.

      Comptez les documents dans la collection de restaurants en utilisant la commande suivante :

      Le résultat affichera 25359, qui correspond au nombre de documents importés. Pour procéder à une vérification plus approfondie, vous pouvez sélectionner le premier document dans la collection des restaurants de la manière suivante :

      Le résultat ressemblera à ceci :

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

      Une telle vérification détaillée pourrait révéler la présence de problèmes avec les documents comme avec leur contenu, leur encodage, etc. Le format json utilise l'encodage UTF-8 et vos exportations et importations devraient utiliser ce même encodage. Gardez cela à l'esprit lorsque vous modifiez des fichiers json manuellement. Dans le cas contraire, MongoDB gérera cela automatiquement à votre place.

      Pour quitter l'invite MongoDB, tapez exit à l'apparition de l'invite :

      Vous serez renvoyé à l'invite de ligne de commande normale en tant que non-root user.

      Étape 2 — Exporter des informations à partir de MongoDB

      Comme nous l'avons précédemment mentionné, en exportant des informations MongoDB, vous pouvez obtenir un fichier de texte lisible par l'humain. Les informations sont exportées par défaut sous format json, mais vous pouvez les également exporter sous csv (valeur séparée par des virgules).

      Pour exporter des informations de MongoDB, utilisez la commande mongoexport. Elle vous permet de procéder à une exportation très minutieuse afin que vous puissiez spécifier une base de données, une collection, un champ et même utiliser une requête pour l'exportation.

      Par exemple, un mongoexport simple consisterait à exporter la collection de restaurants à partir de la base de données newdb que nous avons précédemment importée. Vous pouvez procéder à cette opération de la manière suivante :

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

      Dans la commande ci-dessus, nous utilisons ---db pour spécifier la base de données, -c pour la collection et --out pour le fichier dans lequel les données seront enregistrées.

      La sortie d'un mongoexport réussie devrait ressembler à ceci :

      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

      La sortie ci-dessus indique que 25 359 documents ont été importés, le même nombre que celui des documents importés.

      Dans certains cas, vous aurez éventuellement besoin d'exporter uniquement une partie de votre collection. En considérant la structure et le contenu du fichier json des restaurants, exportons tous les restaurants qui satisfont aux critères suivants : localisés dans le quartier du Bronx et proposant de la cuisine chinoise. Pour obtenir ces informations directement, tout en étant connecté à MongoDB, connectez-vous à nouveau à la base de données :

      Ensuite, utilisez la requête suivante :

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

      Les résultats s'affichent sur le terminal :

      Output

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

      Pour quitter l'invite MongoDB, tapez exit :

      Si vous souhaitez exporter les données à partir d'une ligne de commande sudo, plutôt que pendant que vous êtes connecté à la base de données, intégrez la requête précédente dans la commande mongoexport, en la spécifiant pour l'argument -q comme ceci :

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

      Notez que nous omettons les guillemets en utilisant backslash () dans la requête. De la même manière, vous devez omettre tout autre caractère spécial dans la requête.

      Si l'exportation est probante, le résultat devrait ressembler à ce qui suit :

      Output

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

      Ce qui précède indique que 323 enregistrements ont été exportés. Vous pouvez les trouver dans le fichier Bronx_Chinese_retaurants.json que nous avons spécifié.

      Utilisez cat et less pour analyser les données :

      • cat Bronx_Chinese_retaurants.json | less

      Utilisez SPACE pour paginer à travers les données :

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

      Appuyez sur q pour fermer. Vous pouvez maintenant importer et exporter une base de données MongoDB.

      Conclusion

      Cet article vous a présenté les éléments essentiels de l'importation et l'exportation d'informations vers et depuis une base de données MongoDB. Vous pouvez approfondir vos connaissances en consultant Comment sauvegarder, restaurer et migrer une base de données MongoDB sur Ubuntu 20.04.

      Vous pouvez également envisager d'utiliser une réplication. La réplication vous permet de continuer à exécuter votre service MongoDB sans interruption à partir d'un serveur MongoDB esclave alors que vous restaurez le maître à partir d'une défaillance. Une partie de la réplication est le operations log (oplog). Il enregistre toutes les opérations qui modifient vos données. Vous pouvez utiliser ce journal, tout comme vous utiliseriez le journal binaire dans MySQL, pour restaurer vos données une fois la dernière sauvegarde effectuée. N'oubliez pas que, étant donné que les sauvegardes se font généralement pendant la nuit, si vous décidez de restaurer une sauvegarde le soir, vous manquerez toutes les mises à jour qui auront lieu depuis la dernière sauvegarde.



      Source link