Building a Simple Blog App with MongoDB and PHP

Thien Tran Duy
Thien Tran Duy


If you want to create a blog using MongoDB and PHP, this article will teach you to:

  • Connect to a MongoDB database
  • Save documents in a collection
  • Query documents in a collection
  • Perform range queries
  • Sort documents, update a document, delete one or more documents from a collection

The reason I chose to build a blog application is because it is a basic CRUD application and it is very suitable for easing into PHP and MongoDB web development. We will build a plain user interface using Bootstrap with simple textboxes and buttons. A MongoDB database will store all the content. You can download full source from github, see a demo frontend here and try the demo app’s backend with the user name and password being duythien.

What is MongoDB

According to the official website MongoDB is a document database that provides high performance, high availability, and easy scalability. MongoDB falls into the group of documents-oriented NoSQL databases. For other subtypes of NoSQL databases, see here.

MongoDB Concepts: Databases, Collections, and Documents

  1. Database: MongoDB groups data into databases in the very same way as most relational databases do. If you have any experience with relational databases, you should think of these the same way. In an RDBMS, a database is a set of tables, stored procedures, views, and so on. In MongoDB, a database is a set of collections. A MongoDB database contains one or more collections. For example, a database for a blogging application named blog may typically have the collections articles, authors, comments, categories, and so on.

  2. Collection: A collection is the equivalent of an RDBMS table. A collection exists within a single database. Collections do not enforce a schema. Documents within a collection can have different fields. Typically, all documents in a collection have a similar or related purpose.

  3. Documents: A record in a MongoDB collection and the basic unit of data in MongoDB. Documents are analogous to JSON objects but exist in the database in a more type-rich format known as BSON. A document contains a set of fields or key-value pairs. The best way to think of a document is as a multidimensional array. In an array, you have a set of keys that map to values (Document == Array). See Documents.

Installing MongoDB

MongoDB runs on most platforms and supports 32-bit and 64-bit architectures. MongoDB is available as a binary, or as a package. In production environments, use 64-bit MongoDB binaries. This section will cover installation on Ubuntu Linux and Windows. For other operating systems, please see their documentation.

This is how Mongo is installed on Ubuntu Linux. Open terminal and execute the following:

sudo apt-key adv --keyserver hkp:// --recv 7F0CEB10
echo 'deb dist 10gen' | sudo tee /etc/apt/sources.list.d/mongodb.list

Now issue the following command to update your repository and install the latest stable version of MongoDB:

sudo apt-get update
sudo apt-get install mongodb-10gen

Done, you have successfully installed MongoDB. Now start and stop service MongoDB via command line below.

sudo service mongodb start
sudo service mongodb stop

In case of start error to try run the following command:

sudo mongod --fork --logpath /var/log/mongodb/mongodb.log
sudo mongod -f /etc/mongodb.conf

The following describes how to install it on Windows:

Head on over to the downloads page on the MongoDB official website. Click on the download link for the latest stable release under Windows.

After the download is finished, extract and move it into C:\ . MongoDB requires a data folder in which to store its files. The default location for the MongoDB data directory is C:\data\db. If it doesn’t exist, create it.

To start MongoDB, execute from the Command Prompt

C:\> cd \mongodb\bin
C:\mongodb\bin> mongod

Done, you have successfully installed MongoDB. Now start and stop service MongoDB via command line below.

net start MongoDB
net stop  MongoDB

Installing the PHP driver for MongoDB

The MongoDB server is built to already work with your current web server, but not PHP. To make PHP talk to the MongoDB server, we are going to need the PHP-MongoDB driver. It is a PHP extension library.

If you use Linux install it easily via:

sudo pecl install mongo

Add the line to your php.ini configuration and you’re good to go:

sudo -i
echo '' >> /etc/php5/apache2/php.ini

Restart your web server and verify via command line:

php -i |grep "mongo"
php --re mongo

Installing the Driver on Windows

Let us try installing the driver on a Windows machine running PHP 5.4 on Apache (XAMPP):

  1. Download the ZIP archive on your machine and extract it.
  2. Copy the php_mongo.dll file from the extracted folder to the PHP extension directory(C:\xampp\php\ext).
  3. Open the php.ini file inside your PHP installation and add the following line: extension=php_mongo.dll
  4. Save the file and close it. Restart the XAMP.
  5. Open up your text editor and add the following code to a new file:<?php phpinfo();?>, save the file as phpinfo.php inside the DocumentRoot of the Apache web server (htdocs) and open the PHP script in the browser. If you see mongo in the PHP info, the installation was successful.

Mongo Web Development with PHP

Connecting to a MongoDB Database Server

Connecting to MongoDB from PHP is very similar to connecting to any other database. The default host is localhost, and the default port is 27017.

$connection = new Mongo();

Connecting to a remote host with optional custom port and auth:

$connecting_string =  sprintf('mongodb://%s:%d/%s', $hosts, $port,$database),
$connection=  new Mongo($connecting_string,array('username'=>$username,'password'=>$password));

Selecting a Database

Once the database server connection is established, we will use it to access a database. The defined way to do this is:

$dbname = $connection->selectDB('dbname');

The Basics (CRUD Operations)

MongoDB provides rich semantics for reading and manipulating data. CRUD stands for create, read, update, and delete. These terms are the foundation for all interactions with the database.

Creating/Selecting a Collection

Selecting and creating a collection is very similar to accessing and creating a database. If a collection does not exist, it is created:

$collection = $dbname->collection;
$collection = $dbname->selectCollection('collection');

For example, this creates the collection “posts” in my blog:

$posts = $dbname->posts

Creating a Document

Creating a document in MongoDB could not be easier. Create an array. Pass it into the insert method on the collection object

$post = array(
        'title'     => 'What is MongoDB',
        'content'   => 'MongoDB is a document database that provides high performance...',
        'saved_at'  => new MongoDate() 

The insert() method stores the data in the collection. The $post array automatically receives a field named _id, which is the autogenerated unique ObjectId of the inserted BSON document. You could also use the save() method, which upserts – updates an existing record, or creates a new one if it doesn’t exist.

Reading a Document

To get data from a collection, I use the find() method, which gets all the data in a collection. findOne() returns only one document that satisfies the specified query criteria. The following examples will show you how to query one or more records.

    // all records
    $result = $posts::find();
    // one record
    $id = '52d68c93cf5dc944128b4567';
    $results = $posts::findOne(array('_id' => new MongoId($id)));

Updating a Document

Modifies an existing document or documents in a collection. By default, the update() method updates a single document. If the multi option is set to true, the method updates all documents that match the query criteria.

    $id = '52d68c93cf5dc944128b4567';
        array('_id'     => new MongoId($id)),
    array('$set'    => array(title'   => 'What is phalcon'))

The update() method takes two parameters. The first is criteria to describe the objects to update and the second the object with which to update the matching records. There is also a third optional parameter whereby you can pass in an array of options.

Mini blog

The structure of the project we’ll be building:

            |------index.php                    # This is dashboard
                    |-------create.view.php     #form create article
            |------layout.php       #This is main layout it will be shown for every  action executed within the app
            |------single.view.php              # This is view for a single article
    |-------config.php                          # Define paramater database, url
    |-------app.php                             # Include multi-php files
    |-------db.php                        # Container class db 
    |-------static                              # Container css,js...
                |----markdown                   # Library converts markdown into html

Before we start with our actual PHP code we need to create our files and folders like above.


This is your configuration file that tells our app how to connect to the database. This is where you have defined the database name, username and password of the user to access that database:

        define('URL', '');
        define('UserAuth', 'duythien');
        define('PasswordAuth', 'duythien');

        $config = array(
            'username' => 'duythien',
            'password' => 'qazwsx2013@',
            'dbname'   => 'blog',
            'connection_string'=> sprintf('mongodb://%s:%d/%s','','27017','blog')

where we define paramaters UserAuth and PasswordAuth to protect the admin folder via HTTP authentication. We’re using HTTP auth for simplicity here, seeing as the central theme of the article is connecting to MongoDB – you would usually use some sort of decent framework with ACL to build in access control.


    include 'config.php';
    include 'layout.php';
    include 'db.php';

    use Blog\DB,

    // Constructor to the db
    $db = new DB\DB($config);

    // Constructor to layout view
    $layout = new Layout\Layout();


This is the folder that contains the CRUD code.

require_once 'auth.php';
require_once '../app.php';
require_once '../vendor/markdown/';
use \Michelf\MarkdownExtra,

if ((is_array($_SESSION) && $_SESSION['username'] == UserAuth)) {
    $data = array();
    $status = (empty($_GET['status'])) ? 'dashboard' : $_GET['status'];
    switch ($status) {
        //create post
        case 'create':
        //edit post
        case 'edit':
        //delete post
        case 'delete':
            //display all post in dashboard
            $currentPage = (isset($_GET['page'])) ? (int)$_GET['page'] : 1;
            $data = $db->get($currentPage, 'posts');

            $layout->view('admin/dashboard', array(
                'currentPage' => $data[0],
                'totalPages' => $data[1],
                'cursor' => $data[2]

For the full file index.php see here. Above I used the view function in the class layout.php which will automatically load dashboard.view.php.

<?php namespace Blog\Layout;

Class Layout

     * @var array
    public $data;

    public function view($path, $data)
        if (isset($data)) {
        $path .= '.view.php';
        include "views/layout.php";

The GET parameter status corresponds to a CRUD action. For example, when status is “create”:


    $article = array();
    $article['title'] = $_POST['title'];
    $article['content'] = Markdown::defaultTransform($_POST['content']);
    $article['saved_at'] = new MongoDate();

    if (empty($article['title']) || empty($article['content'])) {
        $data['status'] = 'Please fill out both inputs.';
    } else {

// then create a new row in the collection posts
        $db->create('posts', $article);
        $data['status'] = 'Row has successfully been inserted.';
$layout->view('admin/create', $data);

Function view(‘admin/create’, $data) shows an HTML form where the user can write the title/content of a new blog post, or it saves the user-submitted data to MongoDB. By default the script displays the following HTML form:

<form action="" method="post">
    <div><label for="Title">Title</label>
        <input type="text" name="title" id="title" required="required"/>
    <label for="content">Content</label>

    <p><textarea name="content" id="content" cols="40" rows="8" class="span10"></textarea></p>

    <div class="submit"><input type="submit" name="btn_submit" value="Save"/></div>

create post

Next let’s look at db.php, which can be found in full here


namespace Blog\DB;

class DB

     * Return db
     * @var object
    private $db;

     * Results limit.
     * @var integer
    public $limit = 5;

    public function __construct($config)


    //connecting mongodb
    private function connect($config)

    //get all data
    public function get($page, $collection)

    //get one data by id
    public function getById($id, $collection)

    //create article
    public function create($collection, $article)

    //delete article by id
    public function delete($id, $collection)

    //update article
    public function update($id, $collection, $acticle)

    //create and update comment
    public function commentId($id, $collection, $comment)

The MongoDB cursor makes pagination easy. These cursor methods can be chained off of the cursor object that find returns and each other. Combining limit with skip makes pagination easy. These can also be combined with order. For example.

    public function get($page,$collection){

        $currentPage = $page;
        $articlesPerPage = $this->limit;

        //number of article to skip from beginning
        $skip = ($currentPage - 1) * $articlesPerPage; 

        $table = $this->db->selectCollection($collection);
    $cursor = $table->find();

        //total number of articles in database
        $totalArticles = $cursor->count(); 

        //total number of pages to display
        $totalPages = (int) ceil($totalArticles / $articlesPerPage); 

        $cursor->sort(array('saved_at' => -1))->skip($skip)->limit($articlesPerPage);


    return $data;

index.php: template files can be found in the view folder; such as index.view.php. Here is an example of index.php:

require 'app.php';

try {
    $currentPage = (isset($_GET['page'])) ? (int)$_GET['page'] : 1; //current page number

    $data = $db->get($currentPage, 'posts');
    $layout->view('index', array(
        'currentPage' => $data[0],
        'totalPages' => $data[1],
        'cursor' => $data[2],
        'name' => 'Duy Thien'
} catch (Exception $e) {
    echo 'Caught exception: ', $e->getMessage(), "\n";

Open your browser and navigate to It lists all the current articles in the blog:

index all posts

single.php: When you view a single post page (click Read more on a post), you are looking at single.view.php in the views folder. Here is the logic of single.php:


require 'app.php';
// Fetch the entire post
$post = $db->getById($_GET['id'], 'posts');
if ($post) {
    $layout->view('single', array(
        'article' => $post

This file receives the _id of the article as an HTTP GET parameter. We invoke the findOne() method on the articles collection, sending the _id value as a parameter to the method. The findOne() method is used to retrieve a single document. See function getById() in file db.php

single posts

Enter an arbitrary Name and Email in the input boxes under the comments section, put some text in the textarea as well. Then click on the Save button and the page will reload with the comment you just posted. This is what comment.php looks like:


require 'app.php';


    $id = $_POST['article_id'];
    $comment = array(
        'name' => $_POST['fName'],
        'email' => $_POST['fEmail'],
        'comment' => $_POST['fComment'],
        'posted_at' => new MongoDate()
    $status = $db->commentId($id, 'posts', $comment);

    if ($status == TRUE) {
        header('Location: single.php?id=' . $id);

Comments for an article are stored in an array field of the document name comments. Each element of a comment is an embedded document that contains several fields.


In this article, we covered a basic CRUD introduction into PhP with MongoDB. We’ve even created a sort of very primitive MVC in the process (see full app on Github). It’s up to you to use a proper framework, implement authentication beyond the simple HTTP auth used here, and add more functionality, but the basics are in place and you can hack away at this demo application to your heart’s content.

For more information on MongoDB check out the online documentation. Did you enjoy this article? Let us know your thoughts!

Frequently Asked Questions (FAQs) about Building a Simple Blog App with MongoDB and PHP

What is MongoDB and why is it used in building a blog app?

MongoDB is a source-available cross-platform document-oriented database program. It is classified as a NoSQL database program because it uses JSON-like documents with optional schemas. MongoDB is used in building a blog app because of its high performance, high availability, and easy scalability. It works on the concept of collections and documents, making it easier to organize and manage data.

How does PHP integrate with MongoDB in creating a blog app?

PHP is a popular general-purpose scripting language that is especially suited to web development. It integrates with MongoDB through a PHP driver, which is a client-side library that provides a high-level API abstraction for some of the features of MongoDB. This allows PHP scripts to communicate with MongoDB servers and perform operations like querying and updating data.

What are the prerequisites for building a blog app with MongoDB and PHP?

To build a blog app with MongoDB and PHP, you need to have a basic understanding of PHP and MongoDB. You also need to have PHP and MongoDB installed on your system. Additionally, you need a text editor for writing your code and a web server for hosting your app.

How can I handle user authentication in my blog app?

User authentication in a blog app can be handled using sessions in PHP. When a user logs in, a session is started, and the user’s information is stored in session variables. These variables can be accessed throughout the user’s session, allowing you to restrict access to certain pages based on the user’s authentication status.

How can I implement CRUD operations in my blog app?

CRUD operations (Create, Read, Update, Delete) can be implemented in a blog app using PHP and MongoDB. PHP provides functions for interacting with MongoDB, allowing you to create documents (posts), read documents, update documents, and delete documents. The MongoDB PHP driver provides a simple API for these operations.

How can I handle errors in my blog app?

Error handling in a blog app can be done using PHP’s built-in error handling functions. These functions allow you to define custom error handling rules, create custom error handlers, and report errors. You can also log errors for debugging purposes.

How can I improve the performance of my blog app?

The performance of a blog app can be improved by optimizing your MongoDB queries, using indexes, and caching data. You can also improve performance by optimizing your PHP code, for example by using efficient loops and functions, and by minimizing the use of global variables.

How can I secure my blog app?

Security in a blog app can be achieved by implementing user authentication, sanitizing user input to prevent SQL injection attacks, and using secure connections (HTTPS). You should also keep your PHP and MongoDB installations up to date to benefit from the latest security patches.

How can I deploy my blog app?

A blog app can be deployed by uploading the PHP files and MongoDB database to a web server. You can use FTP or a version control system like Git for uploading files. You also need to configure your web server to handle PHP scripts and connect to your MongoDB database.

How can I add features like comments and likes to my blog app?

Features like comments and likes can be added to a blog app by creating additional collections in your MongoDB database for storing comments and likes. You can then use PHP to create, read, update, and delete comments and likes, and to associate them with specific posts.