Mezzanine CMS (content management system) is a powerful and easy-to-use solution for content management and blogging, which is build on top of Django – Python-powered web-development framework. This BSD-licensed open-source platform is free and easy-customizable. The most required and widely-used CMS functionality is provided by default, so it can cover the majority of common needs. At the same time, there exist a huge number of third-party extensions, widgets, modules, themes etc, which can be used to broaden Mezzanine possibilities.
Both developers and content managers can be pleased with such pretty advantages of this platform as:
- WYSIWYG editor with the Drag-and-Drop page ordering and visual content editing
- scheduled publishing
- huge amount of ready-to-use themes
- rich API
- out-of-the-box Django internationalization, Twitter Bootstrap, Disqus, Akismet spam filter, Twitter feed and Google Analytics support, as well as embedded integration with social networks, search engines, SEO functionality and, huge amount of modules
So, today we’ll consider how such a great application can be easily hosted at Jelastic PaaS&CaaS – the step-by-step instruction below will pass you through the Mezzanine CMS deployment process inside Jelastic Cloud.
Create Python Environment
To start with, you need to create an environment with the appropriate application and DB server. In our case, the Apache Python server is needed (with the Python 2.7 engine version as recommended).
1. To create such, log in to your dashboard and press the New environment button.
2. Switch to the Python tab. Here, with the appropriate application server being already chosen, you need to state the suitable Python version. Then, define the needed environment region (in case of using the multi-region cloud) and adjust the domain name.
Finally, click Create at the bottom right corner of the frame.
3. Just in a minute your environment will appear at the dashboard.
Now, you are ready to proceed to the actual Mezzanine CMS application deployment.
Build and Deploy Mezzanine CMS
1. In order to install Mezzanine CMS from the scratch, you need to access your application server via the Jelastic SSH Gateway first.
2. After entering the Apache Python server by means of terminal, you will find yourself in the jelastic user home directory. Now, to run the Python web application, the isolated virtual environment needs to be created.
So, in order to create such an environment, simply run the following command via your console:
3. To be used, the newly created virtual environment needs to be activated by executing the next command:
4. Now, the Mezzanine CMS installer can be downloaded with the help of the Python package manager (pip):
pip install mezzanine
Wait for a couple of minutes before this operation is completed.
5. Since we are going to install our application to the ROOT context, the existing ROOT folder with the default application should be preliminary removed:
rm -rf ROOT
After that, you can run the installer:
The next required action is creation of the application database schema.
Mezzanine CMS, as all Django-based applications, supports different SQL DBs. You can choose the one according to your purposes and preferences, so within the instruction below we’ll reveal how to configure our app to work with:
- inbuilt SQLite database
- a separate SQL server (either MySQL-based or PostgreSQL)
For the Embedded SQLite DB
Being fast, simple and lightweight, SQLite represents a great solution for development and testing purposes.
1. The DB connection settings can be seen within the local_settings.py file inside the ~/ROOT/ROOT folder. Here, you’ll find the dedicated DATABASE configuration section with the parameters being stated for the SQLite DB engine usage by default, so you can leave them unchanged in this case.
2. After you’ve reviewed the settings, execute the following line from inside the ~/ROOT directory (i.e. one level above the local_settings.py script location) in order to create a new SQLite database:
python manage.py createdb --noinput
The DB itself will be stored in ~/ROOT/dev.db.
3. After the DB is created, you can proceed to the Configuring Apache section of this article a little bit below.
For a Separate SQL Server
At Jelastic, Mezzanine can be configured to work with any of the provided MySQL-based servers (i.e. MySQL itself, MariaDB or PerconaDB – the settings are completely the same for all of them). Also, you can use PostgreSQL as an option.
Here, we’ll consider the required configuration with the example of PerconaDB 5.6, whilst providing the corresponding settings for Postgres alongside if they differ.
1. So, if you prefer to use a separate DB server – navigate back to Jelastic dashboard, choose the Change environment topology option for your Mezzanine environment, pick up the desired node within the SQL wizard section and click on Apply.
2. After the node is successfully added to your environment, select Open in browser next to it for the PhpMyAdmin page to be opened. Log in with the credentials you’ve received via email during server installation:
3. Once you’re inside, navigate to the Users tab in order to create a separate account for interaction with Mezzanine CMS database. In the opened frame, click on Add user and specify the appropriate username and password.
Also, tick the Create database with the same name and grant all privileges and Grant all privileges on wildcard name (username\_%) options to get a DB with the required privileges. Then press the Go button
4. After the successful DB creation, return to your console with the opened SSH connection to the Apache Python server and navigate to the local_settings.py file inside the ~/ROOT/ROOT folder. Here, you need to specify the following configurations:
- ENGINE – django.db.backends.mysql (or django.db.backends.postgresql_psycopg2 for PostgreSQL database)
- NAME – type the name of the previously created database (mezzanine in our case)
- USER and PASSWORD – enter the ones you’ve specified during the DB creation (or state the default credentials if using PostgreSQL)
- HOST – internal IP of the chosen DB server
- PORT – specify the 3306 port number (or 5432nd one if working with PostgreSQL)
As a result, the DATABASES section should look similar to the following:
5. Then, in order to make the server to work with MySQL-based DB, the appropriate connector needs to be installed via pip:
pip install mysql
6. Once the required SQL module is installed, you can proceed with DB schema creation:
python manage.py createdb --noinput
After the DB is created, let’s ensure the application is operable and apply some additional application server configurations.
Running Mezzanine Application
So, the main steps of Mezzanine CMS application installation are completed now. In order to quickly make sure that everything was accomplished successfully, just stop the default Apache Python process:
sudo service cartridge stop
and then start the app itself (from inside the ~/ROOT folder):
python manage.py runserver 0.0.0.0:8080
Now, you can Open your environment in browser via Jelastic dashboard to access the application start page:
Such kind of application running is suitable for development and testing purposes. However, for production environments with a big number of concurrent users, it’s more preferable to launch Apache web server (which will be used for the static content serving) in a bundle with mod_wsgi module (required for hosting of Python web applications with the WSGI specification support and for implementing interaction with Python backend).
So, to handle the Mezzanine application with mod_wsgi, do the following:
1. First of all, you need to generate a WSGI handler. For that, enter the ~/ROOT/ROOT directory via console (upon SSH protocol) and create the wsgi.py file there with such content:
import os,sys virtenv = os.path.expanduser('~') + '/virtenv/' virtualenv = os.path.join(virtenv, 'bin/activate_this.py') try: if sys.version.split(' ').split('.') == '3': exec(compile(open(virtualenv, "rb").read(), virtualenv, 'exec'), dict(__file__=virtualenv)) else: execfile(virtualenv, dict(__file__=virtualenv)) except IOError: pass sys.path.append(os.path.expanduser('~')) sys.path.append(os.path.expanduser('~') + '/ROOT/') sys.path.append(os.path.expanduser('~') + '/ROOT/ROOT/') os.environ['DJANGO_SETTINGS_MODULE'] = 'ROOT.ROOT.settings' from django.core.wsgi import get_wsgi_application from mezzanine.utils.conf import real_project_name application = get_wsgi_application()
Save the newly created file.
2. Then, set the symlink, which will point to the file we’ve modified above, by executing the following line:
ln -sfT ~/ROOT/ROOT/wsgi.py ~/ROOT/application
3. Also, as we are going to serve static content with the help of Apache, the appropriate data needs to be collected beforehand (the command should be run under the ~/ROOT directory):
python manage.py collectstatic
As a result, all of the static content for current app will be stored in the ~/ROOT/static directory.
4. In addition, there are a couple of small issues, which are needed to be adjusted within the ~/ROOT/ROOT/settings.py config before we can start the app, namely:
- state the ROOT_URLCONF parameter to ROOT.ROOT.urls
- substitute the ALLOWED_HOSTS setting value with your Jelastic environment domain name (which can be seen within the dashboard)
5. After that, run the Apache process by:
sudo service cartridge start
6. That’s all! Now, you can return to the dashboard and press Open in browser button next to your environment with Mezzanine CMS (similarly to the way you’ve done this while checking its operability). As a result, you’ll see the application’s welcome page.
Here, you can login to admin panel using your credentials (i.e. admin/default in case of the –noinput option usage, or your custom ones otherwise)
Once inside, you are able to proceed with modifying your site and filling it with the required content.
Deploying Pre-Configured Mezzanine CMS Archive
For the case you have a trial-type account and/or do not have the possibility to access your environment via SSH, the archive with pre-configured Mezzanine CMS application can be deployed directly via the Jelastic dashboard. As an example, you can use our ready-to-go Mezzanine 4.1 package.
With our package, SQLite is used for serving data storing by default, so only app server is needed to be comprised within an environment. And the whole deployment procedure can be performed just in a few steps, described below:
1. Upload the package with your Mezzanine CMS application to the Jelastic dashboard via Deployment manager.
2. Press the Deploy to button and choose the target environment.
3. Once this operation is finished, select the Open in browser button next to your environment.
4. That’s all! Now you can enjoy working with your Mezzanine CMS application.
As you can see, it’s quite easy to deploy Mezzanine CMS (as well as any other Django-based application) with Jelastic Python hosting. Nevertheless, in case you face any issues with this instruction, feel free to appeal for our technical experts’ assistance at Stackoverflow.
And don’t forget to keep an eye on new articles within our blog – here you can find the variety of instructions and solutions you can benefit on with your own account at any of Jelastic Cloud installations. So stay tuned!