Rocky Linux was finally release today (5/1/2021) and I’ve decided to try it in my lab. I’ve downloaded the minimal ISO (Rocky-8.3-x86_64-minimal) and installed it under my vCenter version 6.x.
I chose CentOS 8 as a base OS and after I mounted the ISO, I got an error saying ERROR Verification failed: (0x1A) Security Violation. If this is the case, shut down the guest, go to Settings | VM Options and if you expand Boot Options, change the Firmware from EFI to BIOS. This should do the trick.

What you’ll see next is pretty much the same as any other CentOS 7/8 installation.

NOTE: The current version is not considered for production.
Do the same as you do with any other CentOS install. Partition the hard drive, change the root password, configure the network and add a user.

Once the server is up, you’ll see the login prompt.

Check the kernel version and the release.

uname -a
Linux rocky.andreev.local 4.18.0-240.22.1.el8.x86_64 #1 SMP Mon Apr 12 04:29:16 UTC 2021 x86_64 x86_64 x86_64 GNU/Linux
cat /etc/redhat-release
Rocky Linux release 8.3

By default, both the firewall and SELinux are enabled.

systemctl status firewalld
sestatus

You can use dnf, yum or rpm to manage the packages. If you need to change the network settings, use nmtui.
Let’s install WordPress now. As root or using sudo, install Apache, PHP and MariaDB.

dnf install httpd php php-mysqlnd mariadb-server wget php-json

Start the Apache and MariaDB and enable them on both to start on reboot.

systemctl enable httpd --now
systemctl enable mariadb --now

Open port 80 on the firewall for the Apache.

firewall-cmd --permanent --zone=public --add-service=http --permanent
firewall-cmd --reload

Do the initian MariaDB configuration and specify the new root password for the SQL server.

mysql_secure_installation

Log as the SQL root user to MariaDB.

mysql -u root -p

Create the database and the WordPress user.

CREATE DATABASE wordpress;
GRANT ALL ON wordpress.* TO 'wpadmin'@'localhost' IDENTIFIED BY 'supersecret';
FLUSH PRIVILEGES;

Get the latest WordPress release under /tmp, unzip it and copy it where it belongs (root Apache data directory).

cd /tmp
wget https://www.wordpress.org/latest.zip
unzip latest.zip
mv wordpress/* /var/www/html/
chown -R apache:apache /var/www/html

Change the SELinux context for the root Apache data directory.

chcon -t httpd_sys_rw_content_t /var/www/html -R

At this point, you can access your WordPress install at http://your_IP_or_hostname.

In this post, I’ll describe how to create a Chef cookbook for deploying WordPress. The blog engine will run on CentOS 7 using MariaDB and PHP. The website will be created as a virtual host and you can leave the firewall and SELinux as is. There are probably better WordPress cookbooks at the Chef Supermarket, but I decided to go with my own. Before you go further, make sure that you have a Chef server/workstation environment ready, otherwise you won’t be able to deploy the code. Check my other post on how to do that. Also, make sure you have a CentOS 7 client powered up and that you are able to log in with some username and that the DNS/hostnames is already in place. In my case, I’ll have a CentOS 7 server named centostest.andreev.local and a username klimenta that’s able to login.

Chef

OK, so log to your Chef workstation and go to your cookbooks directory. Create the wordpress cookbook.

chef generate cookbook wordpress

The directory structure looks like this.

Edit the metadata.rb file in the root directory and change it so it suit your needs. This is completely optional. You don’t have to change anything here.

name 'wordpress'
maintainer 'Kliment Andreev'
maintainer_email 'klimenta@iandreev.com'
license 'Simplified BSD License'
description 'Installs/Configures wordpress'
long_description 'Installs/Configures wordpress'
version '0.1.0'
chef_version '>= 12.1' if respond_to?(:chef_version)

# The `issues_url` points to the location where issues for this cookbook are
# tracked.  A `View Issues` link will be displayed on this cookbook's page when
# uploaded to a Supermarket.
#
# issues_url 'https://github.com/<insert_org_here>/wordpress/issues'

# The `source_url` points to the development repository for this cookbook.  A
# `View Source` link will be displayed on this cookbook's page when uploaded to
# a Supermarket.
#
# source_url 'https://github.com/<insert_org_here>/wordpress'

Our next step is to create the default attributes. These are the values that we can change and modify the behavior of the installed packages or change the usernames, passwords, directory locations etc.

cd wordpress
chef generate attribute default

The commands above will create a new directory called attributes and a file called default.rb. Copy and paste the following into that file. As you can see, my blog will be reachable as http://centostest.andreev.local, the WordPress files will be under /var/www/centostest.andreev.local folder, the default httpd file is /etc/httpd/conf/httpd.conf etc…

# The name of your site
default['wordpress']['server_name'] ='centostest.andreev.local'
# The root directory of your site, it will be /var/www/yoursitename.com
default['wordpress']['document_root'] = "/var/www/#{node['wordpress']['server_name']}"
# The default config file
default['wordpress']['default_conf'] = '/etc/httpd/conf/httpd.conf'
# e-mail for the server admin
default['wordpress']['server_admin'] ='klimenta@iandreev.com'
# log dir for the site
default['wordpress']['log_dir'] = '/var/log/www'
# Error log for the site, it will be /var/log/wwwyoursitename-error.log
default['wordpress']['error_log'] = "#{node['wordpress']['log_dir']}/""#{node['wordpress']['server_name']}-error.log"
# Access log for the site, it will be /var/log/wwwyoursitename-access.log
default['wordpress']['custom_log'] = "#{node['wordpress']['log_dir']}/""#{node['wordpress']['server_name']}-access.log"
# The root password for MySQL
default['wordpress']['mysql_password'] = 'MySQLP4ssw0rd$'
# The name of the WordPress database
default['wordpress']['wordpress_database'] = 'wordpress'
# The default username for the WordPress database
default['wordpress']['wordpress_username'] = 'wp_user'
# The default password for the WordPress database
default['wordpress']['wordpress_password'] = 'W0rdPr3$$PWD'

Now, let’s move to the recipes. In order to install WordPress, we’ll have to install Apache web-server, install PHP and its modules so WordPress as a PHP program can run, then install MySQL database server and finally download WordPress and extract it under the Apache root directory that we specified in the default attributes. We’ll create a recipe for each of these steps.

Apache recipe

Create the recipe first. This will create a file apache.rb under the recipes directory.

chef generate recipe apache

This is how to recipe looks like. You can see from the comments what each block does. It’s very simple and straightforward. We install the Apache server, create the document root and the logs directory, we’ll copy the httpd.config file from a template, make sure that Apache starts on boot and we’ll poke a hole in the firewall so the HTTP port is allowed inbound.

# Install Apache server
package 'httpd' do
  action :install
end

# Create the root directory and set the permissions and owners
directory node['wordpress']['document_root'] do
  owner 'apache'
  group 'apache'
  mode '0755'
  recursive true
end

# Create the Apache log directory
directory node['wordpress']['log_dir'] do
  recursive true
end

# Create the default httpd.conf file
template node['wordpress']['default_conf'] do
  source "httpd.conf.erb"
end

# Enable start on boot and start Apache
service 'httpd' do
  action [:enable, :start]
end

# Allow HTTP to pass on the firewall
execute 'httpd_firewall' do
  command '/usr/bin/firewall-cmd  --permanent --zone public --add-service http'
  ignore_failure true
end

# Reload the firewall rules
execute 'reload_firewall' do
  command '/usr/bin/firewall-cmd --reload'
  ignore_failure true
end

One of the steps here says to create the default config file for the Apache web server and that the template for that is a file called httpd.conf.erb. So, let’s create that template. This command will create a directory called templates and a file httpd.conf.erb.

chef generate template httpd.conf

This is how our default config looks like. Copy and paste the following into the httpd.conf.erb file.

Listen 80
Include conf.modules.d/*.conf
User apache
Group apache
<IfModule mime_module>
    TypesConfig /etc/mime.types
    AddType application/x-compress .Z
    AddType application/x-gzip .gz .tgz
    AddType text/html .shtml
    AddOutputFilter INCLUDES .shtml
</IfModule>

<VirtualHost *:80>
  ServerName <%= node['wordpress']['server_name'] %>
  ServerAdmin <%= node['wordpress']['server_admin'] %>
  DocumentRoot <%= node['wordpress']['document_root'] %>
  <Directory "/">
          Options FollowSymLinks
          AllowOverride None
  </Directory>
  <Directory <%= node['wordpress']['document_root'] %> >
          Options Indexes FollowSymLinks MultiViews
          AllowOverride None
          Require all granted
  </Directory>
  ErrorLog <%= node['wordpress']['error_log'] %>
  CustomLog <%= node['wordpress']['custom_log'] %> combined
  AddType application/x-httpd-php .php
  AddType application/x-httpd-php-source .phps
  DirectoryIndex index.php index.html
</VirtualHost>

PHP

Same as with the Apache recipe, we’ll have to generate a recipe for PHP and it’s modules.

chef generate recipe php

Edit the newly created file php.rb and copy and paste the following.

# Install PHP and its modules
%w{php php-fpm php-mysql php-xmlrpc php-gd php-pear php-pspell}.each do |pkg|
  package pkg do
    action :install
    notifies :reload, 'service[httpd]', :immediately
  end
end

MySQL

Same here, let’s generate a recipe for the installation of MySQL.

chef generate recipe mysql

This is the recipe to install MySQL.

# Install MySQL client and server<strong>
%w{mariadb mariadb-server}.each do |pkg|
  package pkg do
    action :install
  end
end

# Enable start on boot and start the MySQL server
service 'mariadb' do
  action [:enable, :start]
end

# Location of the initial MySQL script
template '/tmp/mysql.sql' do
  source "mysql.conf.erb"
end

# Execute the initial setup of MySQL
execute 'mysql_server' do
  command '/usr/bin/mysql -sfu root < /tmp/mysql.sql && ls /tmp/mysql.sql'
  ignore_failure true
end

As you can see from the recipe, we need a template with some SQL commands to run before we can use MySQL. This is equivalent of running mysql_secure_installation when you first install MySQL. In addition, I’ll use the SQL script to create the wordpress database as well.

chef generate template mysql.conf

This template contains what we need for an initial installation. Any subsequent runs will fail because we changed the MySQL password which is good. That means that we won’t mess up anything if we run this recipe more than once. So, edit the newly create file under templates called mysql.conf and copy and paste the following.

UPDATE mysql.user SET Password=PASSWORD('<%= node['wordpress']['mysql_password'] %>') WHERE User='root';
DELETE FROM mysql.user WHERE User='';
DELETE FROM mysql.user WHERE User='root' AND Host NOT IN ('localhost', '127.0.0.1', '::1');
DROP DATABASE IF EXISTS test;
DELETE FROM mysql.db WHERE Db='test' OR Db='test\\_%';
FLUSH PRIVILEGES;
CREATE DATABASE <%= node['wordpress']['wordpress_database'] %>;
GRANT ALL PRIVILEGES ON <%= node['wordpress']['wordpress_database'] %>.*
TO "<%= node['wordpress']['wordpress_username'] %>"@"localhost"
IDENTIFIED BY "<%= node['wordpress']['wordpress_password'] %>";
FLUSH PRIVILEGES;

Download WordPress

We have to create a recipe to download and extract WordPress.

chef generate recipe download

Edit the file and copy and paste the following. Pretty much it executes a bunch of bash commands to download the tarball, unzip it under the root directory and change the ownership. The recipe will stop if wp-settings.php exists, this means that WordPress is already installed.

ruby_block "download_wordpress" do
  block do
    require 'fileutils'
    FileUtils.cd node['wordpress']['document_root']
    system 'curl -o latest.tar.gz https://wordpress.org/latest.tar.gz'
    system 'tar xzvf latest.tar.gz --strip-components=1 && rm latest.tar.gz'
    system 'chown -R apache:apache *'
  end
  not_if { ::File.exist?(File.join(node['wordpress']['document_root'], 'wp-settings.php')) }
  action :create
end

Wrap up

Now that we have all recipes in place, we can tell Chef in what order to execute them. Edit the default recipe (default.rb file under recipes) and add these lines.

include_recipe 'wordpress::apache'
include_recipe 'wordpress::php'
include_recipe 'wordpress::mysql'
include_recipe 'wordpress::download'

The best practice is to create a role for each cookbook, so let’s create one.

knife role create wordpress

Edit the json file so it looks like this.

{
  "name": "wordpress",
  "description": "Role to install WordPress (apache, php, mysql)",
  "json_class": "Chef::Role",
  "default_attributes": {

  },
  "override_attributes": {

  },
  "chef_type": "role",
  "run_list": [
    "recipe[wordpress::apache]",
    "recipe[wordpress::php]",
    "recipe[wordpress::mysql]",
    "recipe[wordpress::download]"
  ],
  "env_run_lists": {

  }
}

Upload the cookbook to the server and execute it against a node.

knife cookbook upload wordpress
knife bootstrap centostest --ssh-user klimenta --sudo -N centostest.andreev.local -r 'role[wordpress]'

In my home lab it took about 1m to install everything on a 1 CPU, 1GB RAM virtual CentOS. Once completed go to your website (http://centostest.andreev.local in my case). If you have SELinux, you’ll have to manually create the config as per WordPress instructions, otherwise – you are all set.

I’ve decided to play with nginx to see how different is from Apache. The best way to experiment is to have an end goal, e.g. a working WordPress site. I will be using FreeBSD 11.0 and for that I’ve created a public server in AWS cloud. The hostname for my server is test.iandreev.com and I also have 4 different hostnames that point to the same IP (test1, test2, test3 and test4).

Installation

To install nginx, type:

pkg install nginx

Make sure it starts at boot by adding nginx_enable=”YES” in /etc/rc.conf.
To see the version, type:

nginx -v
nginx version: nginx/1.10.2

To see the modules that were installed with the package, type:

nginx -V

You can start and stop the service with the standard service command. When making changes in the config file, use reload, e.g. service nginx reload.
By default, nginx creates the log files under /var/log/nginx. There are two files, access.log and error.log. The config files are under /usr/local/etc/nginx. The main config file is nginx.conf.
Let’s start the nginx.

service nginx start
Performing sanity check on nginx configuration:
nginx: the configuration file /usr/local/etc/nginx/nginx.conf syntax is ok
nginx: configuration file /usr/local/etc/nginx/nginx.conf test is successful
Starting nginx.

If everything is OK, you can telnet localhost 80. Type something and hit ENTER and you’ll see a response.

telnet localhost 80
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
asdf
HTTP/1.1 400 Bad Request
Server: nginx/1.10.2
Date: Sun, 29 Jan 2017 13:56:04 GMT
Content-Type: text/html
Content-Length: 173
Connection: close

<html>
<head><title>400 Bad Request</title></head>
<body bgcolor="white">
<center><h1>400 Bad Request</h1></center>
<hr><center>nginx/1.10.2</center>
</body>
</html>
Connection closed by foreign host.

Check the nginx process.

ps -waux | grep nginx
root     778   0.0  0.7 29640 6984  -  Is   13:55    0:00.00 nginx: master process /usr/local/sbin/nginx
www      779   0.0  0.7 29640 7452  -  I    13:55    0:00.00 nginx: worker process (nginx)

As you can see the master process runs as root, but then it forks the connections to the www user.

Single host

This is the easiest setup. You don’t have to do anything except the steps above. nginx works right out of the box with the default configuration. Go to http://server_IP_or_hostname and you’ll see the welcome page.

But, this scenario has no real use, so we’ll create two virtual hosts, test1 and test2.

Virtual hosts

First, we’ll create the two directories for the virtual hosts and put some index files there. I use the same root directory as Apache. Make sure that the locations of the virtual hosts are owned by the user www and group www.

cd /usr/local/www
mkdir test1.iandreev.com
mkdir test2.iandreev.com
echo "test1" > test1.iandreev.com/index.htm
echo "test2" > test2.iandreev.com/index.htm
chown -R www:www test*

Now, we have to edit the main config file and tell nginx where to look for these sites.
Go to /usr/local/etc/nginx/ and edit nginx.conf. Change the values for worker_processes from 1 to auto and uncomment gzip on directive. See what worker_processes mean here. By uncommenting gzip directive, you are enabling compression on the pages. To test if your web server serves compressed pages, check this website.
Next, we have to add our two virtual hosts. Scroll all the way down, just before the last accolade “}” and add these lines.

    server {
        access_log /var/log/nginx/test1.iandreev.access.log;
        error_log  /var/log/nginx/test1.iandreev.error.log;
        listen 80;
        server_name     test1.iandreev.com;
        location / {
            root /usr/local/www/test1.iandreev.com;
            index index.htm index.html;
        }
    }
    server {
        access_log /var/log/nginx/test2.iandreev.access.log;
        error_log  /var/log/nginx/test2.iandreev.error.log;
        listen 80;
        server_name test2.iandreev.com;
        location / {
            root /usr/local/www/test2.iandreev.com;
            index index.htm index.html;
        }
    }

Reload the config with:

service nginx reload
Performing sanity check on nginx configuration:
nginx: the configuration file /usr/local/etc/nginx/nginx.conf syntax is ok
nginx: configuration file /usr/local/etc/nginx/nginx.conf test is successful

and make sure everything is OK.
If everything is OK, you should be able to browse to your virtual sites.

If you check one of the error logs, you’ll see an error that favicon.ico is missing for the site. You can ignore this as it’s not an error, it’s just a warning that you don’t have a favicon for your site.

tail test2.iandreev.error.log
2017/01/29 14:18:59 [error] 838#100084: *4 open() "/usr/local/www/test2.iandreev.com/favicon.ico" failed (2: No such file or directory), client: 240.14.17.24, server: test2.iandreev.com, request: "GET /favicon.ico HTTP/1.1", host: "test2.iandreev.com"

You can get a favicon icon from this website or you can generate one from this one.

nginx and PHP

Unlike Apache and the php module, nginx is using PHP-FPM as a proxy to requests PHP dynamic code over FCGI protocol. PHP-FPM comes bundled with PHP, so let’s install php 5.6.

pkg install php56

Add this line in /etc/rc.conf so PHP-FPM starts on boot.

php_fpm_enable="YES"

Create the php.ini file from php.ini-production.

cp /usr/local/etc/php.ini-production /usr/local/etc/php.ini

Now, edit /usr/local/etc/php-fpm.conf and make these changes. Replace listen = 127.0.0.1:9000 with listen = /var/run/php-fpm.sock. In addition, uncomment these three lines.

listen.owner = www
listen.group = www
listen.mode = 0660

Finally, start the php-fpm service.

service php-fpm start
Performing sanity check on php-fpm configuration:
[28-Jan-2017 23:41:31] NOTICE: configuration file /usr/local/etc/php-fpm.conf test is successful

Let’s create a test website that will serve PHP content.

cd /usr/local/www
mkdir test3.iandreev.com
echo "<?php phpinfo(); ?>" > test3.iandreev.com/index.php
chown -R www:www test3.iandreev.com

Add a new virtual host in nginx.

server {
        access_log /var/log/nginx/test3.iandreev.access.log;
        error_log  /var/log/nginx/test3.iandreev.error.log;
        listen       80;
        server_name  test3.iandreev.com;
        root /usr/local/www/test3.iandreev.com;
        index index.php index.html index.htm;
        location / {
            try_files $uri $uri/ =404;
        }
        error_page      500 502 503 504  /50x.html;
        location = /50x.html {
            root /usr/local/www/nginx-dist;
        }
        location ~ \.php$ {
                try_files $uri =404;
                fastcgi_split_path_info ^(.+\.php)(/.+)$;
                fastcgi_pass unix:/var/run/php-fpm.sock;
                fastcgi_index index.php;
                fastcgi_param SCRIPT_FILENAME $request_filename;
                include fastcgi_params;
        }
    }

and reload the config changes.

service nginx reload

Go to your new virtual host, in my case http://test3.iandreev.com and you should see this.

nginx and WordPress

Now that we have PHP support we can create a WordPress site. We’ll use MySQL as a DB backend. Please see my other post on how to install MySQL first.
Once you have the MySQL installed, create the database. Replace the values of wordpress, wpuser and secret to suit your needs.

CREATE DATABASE wordpress;
GRANT ALL PRIVILEGES ON wordpress.* TO "wpuser"@"localhost" IDENTIFIED BY "secret";
FLUSH PRIVILEGES;
QUIT;

Install the following php modules, otherwise when you start WordPress you’ll be presented with a blank page.

pkg install php56-extensions php56-mysql php56-mysqli php56-xml php56-hash php56-gd php56-curl php56-tokenizer php56-zlib php56-zip

Download the latest WordPress install. If you don’t have wget, install it first with pkg install wget.

cd /usr/local/www
wget www.wordpress.org/latest.zip --no-check-certificate
unzip latest.zip
mv wordpress test4.iandreev.com
chown -R www:www test4.iandreev.com
rm latest.zip

Add the following in nginx.conf to create the virtual host for the WordPress site.

server {
        access_log /var/log/nginx/test4.iandreev.access.log;
        error_log  /var/log/nginx/test4.iandreev.error.log;
        listen       80;
        server_name  test4.iandreev.com;
        root /usr/local/www/test4.iandreev.com;
        index index.php index.html index.htm;
        location / {
            try_files $uri $uri/ =404;
        }
        error_page      500 502 503 504  /50x.html;
        location = /50x.html {
            root /usr/local/www/nginx-dist;
        }
        location ~ \.php$ {
                try_files $uri =404;
                fastcgi_split_path_info ^(.+\.php)(/.+)$;
                fastcgi_pass unix:/var/run/php-fpm.sock;
                fastcgi_index index.php;
                fastcgi_param SCRIPT_FILENAME $request_filename;
                include fastcgi_params;
        }
    }

Reload the config and restart php-fpm service.

service nginx reload
service php-fpm restart

Go to your website and you’ll be presented with the WordPress install page.

I wanted to run a custom code from a WordPress post and I was looking around. I’ve found a nice plugin but it was running PHP only. It’s not that I needed more, but I stumbled when I tried to combine HTML elements and the PHP script with this plugin. So, at the end I’ve found a much more elegant solution, that pretty much runs any code. All I had to do is to embed the HTML page as an object.

So, let’s say I have a custom code in a PHP page called test.php that’s in the root of my WordPress installation. All is needed is this code in WordPress (use the Text tab, not Visual).

<object data="https://blog.andreev.it/test.php" width="800" height="600"></object>

And this is how my test.php page looks like. I won’t comment the code, but it has an input label and a button. Type a hostname and it will ping it and then render the output as an HTML array.

<!DOCTYPE HTML>
<html>
<head>
<style>
.error {color: #FF0000;}
</style>
</head>
<body>

<?php
// define variables and set to empty values
$hostErr = "";
$host = "";

if ($_SERVER["REQUEST_METHOD"] == "POST") {
  if (empty($_POST["host"])) {
    $host = "Host is required";
  } else {
    $host = test_input($_POST["host"]);
    // only letters and numbers are allowed
    if (!preg_match("/^[a-zA-Z0-9.]*$/",$host)) {
      $hostErr = "Only letters and numbers allowed";
    }
  }
}

function test_input($data) {
  $data = trim($data);
  $data = stripslashes($data);
  $data = htmlspecialchars($data);
  return $data;
}
?>

<h2>Online ping (ICMP) probe</h2>
<p><span class="error">* required field.</span></p>
<form method="post" action="<?php echo htmlspecialchars($_SERVER["PHP_SELF"]);?>
">
  Host: <input type="text" name="host" value="<?php echo $host;?>">
  <span class="error">* <?php echo $hostErr;?></span>
  <br><br>
  <input type="submit" name="submit" value="Submit">
</form>

<?php
        if(isset($_POST['submit']))
        {
                echo "<h2>Output:</h2>";
                echo $host;
                echo "<br>";
                exec("ping -c 3 $host", $output, $status);
                echo '<pre>';
                print_r($output);
                echo '<pre>';

        }
?>

</body>
</html>

The code in action. Type some host on the internet (e.g www.whatever.com), click the button and see the result.

First, make sure that you have Apache, PHP and MySQL (MariaDB) installed and properly configured. In order to avoid any problems down the road, make sure that you have the same version of the software. There are some WordPress plugins that allow you to backup/restore the database and the content, but we’ll do this manually.

Let’s say that I want to migrate www.iandreev.com from one server to another. First, change the DNS so the hostname points to the new IP. Create a test HTML file and see that you can actually browse to the new web site. Once completed, stop the Apache web server and MySQL database on the old server. Go to the root folder where your WordPress installation is and open the wp-config.php file. These are the values that you will need.

 
/** The name of the database for WordPress */ 
define('DB_NAME', 'wwwiandreevcom'); 
/** MySQL database username */ 
define('DB_USER', 'username); 
/** MySQL database password */ 
define('DB_PASSWORD', 'password'); 
/** MySQL hostname */ 
define('DB_HOST', 'localhost'); 

Backup this database with:

mysqldump -u <username>  -p <password> databasename > /somewhere/dbname.sql 

Note: Don’t leave a space between “-p” and the password.

Once you have the database backed up, transfer it to the new server using scp or whatever you use to transfer files between servers. In my case I typed this command on the old server.

scp wwwiandreevcom.sql myusername@www.iandreev.com: 

Where wwwiandreevcom.sql is the backup file, myusername is the username that I use on both servers and www.iandreev.com is the new server hostname.

Create the database on the new server and grant necessary rights.

create database wwwiandreevcom; 
grant all privileges on wwwiandreevcom.* to "username"@"localhost" identified by "password"; 
flush privileges; 

Make sure that the database name, username, password and host are the same as on the old server.
Now, restore the database.

mysql -u username -p wwwiandreevcom < wwwiandreevcom.sql 

Where wwwiandreevcom is the database being restored and wwwiandreevcom.sql is the dump file of the database that we transferred from the old server.

There is no need to install WordPress from scratch on the new server, so go back to the old server and compress the WordPress installation folder.

tar czvf zipfile.tgz www.iandreev.com 

Where www.iandreev.com is my WordPress installation directory. Transfer the tarball to the new server.

scp zipfile.tgz myusername@www.iandreev.com: 

Move the file where your new installation will be and unpack it.

tar xvf zipfile.tgz 

Make sure to change the owner to the user that runs Apache if needed. In my case I had to do:

chown -R www:www www.iandreev.com 

That’s it. Go to www.whatever.com and you’ll see your website/blog back in action.
Note: If you receive the following error:

Your PHP installation appears to be missing the MySQL extension which is required by WordPress.

Then install the following Apache modules and restart Apache.

pkg install php5-pdo_mysql
apachectl graceful