Vultr

Vultr is another entry in the SSD-Powered VPS market and offers similar features and functionality as the other VPS providers, but for slightly less money. You get 100% SSD Storage, Ultra fast Intel CPUs and 14 low latency locations.

After creating an account and navigating to the Vultr Control Manager, click on the Deploy tab. Leave the server type on Compute Instances and choose a location:

Next select the Operating System from the list available. We have selected Ubuntu 18.04 LTS to be consistent with the other guides and because it's the latests, very popular, reliable, and well supported distribution.

For the Server Size you can pick a size that is appropriate for you but Grav will run great on any of them. For the sake of this guide, we'll use the 1 CPU, 1GB memory option that is currently priced at $8/month.

You can choose any optional features you would like, and then provide a simple Server Label to identify the VPS instance. We'll use Grav. Then click Place Order to create and install the server.

After a minute or so, your server should be ready and you can click the manage link next to your server in the list to get the server details. On this page you will be shown a control panel for the server that lets you control the state, along with the initial root username and password. You can can SSH via the command provided in this tab using the password you entered when you created the distribution instance. Public key authentication is recommended, and Vultur has SSH public key authentication documentation that walks you through the steps required.

Update and Upgrade Packages

At this point, you might want to either setup a local /etc/hosts entry to give the IP provided a nice friendly name such as vultr.dev. That way you can more easily SSH to your server with ssh [email protected].

After successfully SSH'ing to your server as root, the first thing you will want to do is update and upgrade all the installed packages. This will ensure you are running the latest-and-greatest:

# apt update
# apt upgrade

Just answer Y if prompted.

Before we go any further, let's remove Apache2 which we will replace with Nginx:

# apt remove apache2*
# apt autoremove

Next you will want to install some essential packages:

# apt install vim zip unzip nginx git php-fpm php-cli php-gd php-curl php-mbstring php-xml php-zip php-apcu

This will install the complete VIM editor (rather than the mini version that ships with Ubuntu), Nginx web server, GIT commands, and PHP 7.2.

Configure PHP7.2 FPM

Once php-fpm is installed, there is a slight configuration change that needs to take place for a more secure setup.

# vim /etc/php/7.2/fpm/php.ini

Search for cgi.fix_pathinfo. This will be commented out by default and set to '1'.

This is an extremely insecure setting because it tells PHP to attempt to execute the closest file it can find if the requested PHP file cannot be found. This basically would allow users to craft PHP requests in a way that would allow them to execute scripts that they shouldn't be allowed to execute.

Uncomment this line and change '1' to '0' so it looks like this

cgi.fix_pathinfo=0

Save and close the file, and then restart the service.

# systemctl restart php7.2-fpm

Configure Nginx Connection Pool

Nginx has already been installed, but you should configure is so that it uses a user-specific PHP connection pool. This will ensure you are secure and avoid any potential file permissions when working on the files as your user account, and via the web server.

Navigate to the pool directory and create a new grav configuration:

# cd /etc/php/7.2/fpm/pool.d
# mv www.conf www.conf.bak
# vim grav.conf

In Vim, you can paste the following pool configuration:

[grav]

user = grav
group = grav

listen = /var/run/php/php7.2-fpm.sock

listen.owner = www-data
listen.group = www-data

pm = dynamic
pm.max_children = 5
pm.start_servers = 2
pm.min_spare_servers = 1
pm.max_spare_servers = 3

chdir = /

The key things here are the user and group being set to a user called grav, and the listen socket having a unique name from the standard socket. Save and exit this file.

We need to create the dedicated grav user now:

# adduser grav

Provide a strong password, and leave the other values as default. We need to next create an appropriate location for Nginx to serve files from, so let's switch user and create those folder, and create a couple of test files:

# su - grav
$ mkdir -p www/html
$ cd www/html

Create a simple index.html with the contents of:

<h1>Working!</h1>

..and a file called info.php with the contents of:

<?php phpinfo();

Now we can exit out of this user and return to root in order to setup the Nginx server configuration:

$ exit
# cd /etc/nginx/sites-available/
# vim grav

Then simply paste in this configuration:

server {
    #listen 80;
    index index.html index.php;

    ## Begin - Server Info
    root /home/grav/www/html;
    server_name localhost;
    ## End - Server Info

    ## Begin - Index
    # for subfolders, simply adjust:
    # `location /subfolder {`
    # and the rewrite to use `/subfolder/index.php`
    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }
    ## End - Index

    ## Begin - Security
    # deny all direct access for these folders
    location ~* /(\.git|cache|bin|logs|backup|tests)/.*$ { return 403; }
    # deny running scripts inside core system folders
    location ~* /(system|vendor)/.*\.(txt|xml|md|html|yaml|yml|php|pl|py|cgi|twig|sh|bat)$ { return 403; }
    # deny running scripts inside user folder
    location ~* /user/.*\.(txt|md|yaml|yml|php|pl|py|cgi|twig|sh|bat)$ { return 403; }
    # deny access to specific files in the root folder
    location ~ /(LICENSE\.txt|composer\.lock|composer\.json|nginx\.conf|web\.config|htaccess\.txt|\.htaccess) { return 403; }
    ## End - Security

    ## Begin - PHP
    location ~ \.php$ {
        # Choose either a socket or TCP/IP address
        fastcgi_pass unix:/var/run/php/php7.2-fpm.sock;
        # fastcgi_pass unix:/var/run/php5-fpm.sock; #legacy
        # fastcgi_pass 127.0.0.1:9000;

        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root/$fastcgi_script_name;
    }
    ## End - PHP
}

This is the stock nginx.conf file that comes with Grav with 2 changes. 1) the root has been adapted to our user/folder we just created and the fastcgi_pass option has been set to the socket we defined in our grav pool. Now we just need to link this file appropriately so that it's enabled:

# cd ../sites-enabled
# ln -s ../sites-available/grav
# rm default

You can test the configuration with the command nginx -t. It should return the following.

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Now all we have to do is restart Nginx and the php7-fpm process and test to ensure we have configured Nginx and the PHP connection pool correctly:

# systemctl restart nginx 
# systemctl restart php7.2-fpm

Now point your browser at your server: http://vultr.dev and you should see the text: Working!

You can also test to ensure that PHP is installed and working correctly by pointing your browser to: http://vultr.dev/info.php. You should see a standard PHP info page with APCu, Opcache, etc listed.

Installing Grav

This is the easy part! First we need to jump back over to the Grav user, so either SSH as [email protected] or su - grav from the root login. then follow these steps:

$ cd ~/www
$ wget -O grav.zip https://getgrav.org/download/core/grav/latest
$ unzip grav.zip
$ rm -Rf html
$ mv grav html

Now That's done you can confirm Grav is installed by pointing your browser to http://vultr.dev and you should be greeted with the Grav is Running! page.

Because you have followed these instructions diligently, you will also be able to use the Grav CLI and Grav GPM commands such as:

$ cd ~/www/html
$ bin/grav clear

Clearing cache

Cleared:  cache/twig/*
Cleared:  cache/compiled/*

Touched: /home/grav/www/html/user/config/system.yaml

and GPM commands:

$ bin/gpm index