Pre requisites:

• Docker installed on your environment (Local).
• Docker Compose installed on your environment (Local).
• A Linux SO. (Windows Powershell also). (Local)
• A Ghost Site (Remote) I will use my own Ghost Blog (https://danfercf.info/).
• Access to server (Ghost Site) port 3306 (Remote).
• User and password for your Mysql Server (Remote).

The remote environment:

Hardware:

• AWS Ec2 instance (Micro) Free tier.
• 1 GB RAM
• Security access enabled for incoming requests (port 3306).

Software:

• Ghost Site: 5.12.0-alpine
• MySQL server: 8.0
• Ngnix: 1.15.12-alpine
• SSL: enabled

After that we can start, we will use a repository with a PHPMyAdmin configured using Docker Compose you can fork the repository and then you can clone it or just copy the configuration in your machine. We'll follow the 2nd option. If you choose the 1st option you can find the repository here https://github.com/danfercf1/docker-examples

The configuration that you need is:

version: '3'

services:

  phpmyadmin:
        image: phpmyadmin/phpmyadmin:latest
        container_name: phpmyadmin
        restart: unless-stopped
        ports:
          - 8090:80
        environment:
          PMA_HOST: ${PMA_HOST}

You need to create a file called docker-compose.yml using the above configuration.

For example I'm using a folder called Projects in my home folder:

/home/my_user/Projects/example/phpmyadmin/

I will use that folder to create the file, you can use this command to create the file

touch docker-compose.yml

Then you can put the configuration into the  file you can use vim or nano

vim docker-compose.yml

After you saved the file you can create the .env, it is for save the environment variables for the docker image

PMA_HOST=danfercf.info

This is the configuration explanation:

• PMA_HOST: It is the host where is the Mysql server it should be the same that your ghost site on this case it will be danfercf.info, PHPMyadmin will make the connection to this host automatically.

After saved the .env file we can run our PHPMyadmin container we use:

docker-compose up

After the command execution we can see something like this:

That's mean that your container is up and ready to use

Regarding the configuration we can access to our PHPMyadmin dashboard accessing the URL: http://localhost:8090

If everything is well you can see the login screen of the manager

There you need to fill the inputs with the MySQL user and password to access to your MySQL server for your Ghost Site.

After a successful sign in you can see the PHPMyAdmin dashboard

You will continue selecting the database and doing click in the export link

You can choose the Quick export method and the click to go

And that it's all, you can save the file and you will have a backup for your Ghost blog.

Recently I reviewed the new features on new Ghost version and I decided to jump out to the new features like the native commenting and the new search feature.

On my environment I'm using a docker deployment and I'm using docker compose for the orchestration. I thought that the upgrade was a change like "change MySQL from 5.7 to 8.0", but it was not.

In that moment I had a configuration that I describe below

services:
  db:
      image: mysql:5.7
  ghost:
      image: ghost:5.2.3-alpine

And I was going to upgrade to

services:
  db:
      image: mysql:8.0
  ghost:
      image: ghost:5.12.0-alpine

I tested an upgrade on my local environment I everything runs very well, but I didn't realized that I didn't make a test with a DB with data saved, everything was running well and all the services raised up without any issue, after that I prepared my production deployment and I did it. The process didn't work, my Database crashed without a recover option and I couldn't do a downgrade.

After I read a lot of this problem I tried to revert all the process but my MySQL 5.7 database can't start again, I observed that there were a fatal compilation errors and the service entered in a restart bucle.

I panicked and without any ideas I decided to reinstall all from scratch and I forgot to make a backup for my old DB, and it was all, all my data was gone.

I tried to recover the data using this https://dev.mysql.com/doc/refman/5.7/en/innodb-table-import.html

But on my case it did not work, why?, because I replaced my docker volume with another one, It can be useful for anyone that already have the ".ibd" files and the MySQL server can't start.

After some hours I beginning to think about the google cache, I remembered that I saw some websites with that feature but I didn't remember how can I access it or how I could search it.

After a few turns on the google search engine I found the solution, I searched for my site on the search box, then:

1. Click the three dots link
2. Click the cached button

And you can access all the cached data that google save about your site, I just copied the data to the new blog posts and I recovered all the data that I lost from my DB. Fortunately I didn't have another important data on my DB.

In conclusion:

I committed 3 big mistakes:

• Don't configuring a scheduled database backup.
• Don't making a database backup before the upgrade.
• Don't preserving the docker volume before the downgrade.

Abenity is a platform that offers deals and discounts to a certain group of users that you have in your Abenity account, but they need to sign into the platform and they offer a SSO way to login and register your users automatically.

In this time I will show how you can configure and make the implementation for Abenity library into a WordPress site using a custom short-code for Abenity links.

• Get the API key from https://backoffice.abenity.com/account/info/api
• Generate your ssh public key:

ssh-keygen -t rsa -b 2048 -C "your_email@example.com"

When you finished the execution of the code it should generates a new file called /home/your_user/.ssh/id_rsa.pub. You need to copy the content code into your Abenity account https://backoffice.abenity.com/account/info/api

cat /home/your_user/.ssh/id_rsa.pub

After you copied the public key from the file you can save the configuration

After that your setup is complete and you can implement the Abenity request API, in our case we use the PHP wrapper https://github.com/Abenity/abenity-php

In order to accomplish that we need to install composer if we didn’t install it, just follow the composer installation documentation here: https://getcomposer.org/download/

And then we need to create a new file in the WordPress root directory, I’m supposing that you are using the command line console

touch composer.json

Then add the require library in the file (you can use your prefer text editor, vim or nano to open the file):

{
    "require": {
        "abenity/abenity-php": "^2"
    }
}

Then you can install the library you need to run:

composer install

In this moment we have the Abenity wrapper installed in our vendor folder and we can continue with the implementation but before it we need to obtain our private key from the file /home/your_user/.ssh/id_rsa

cat /home/your_user/.ssh/id_rsa

We can copy the code in another file in order to continue the implementation we use this key in the parameter $privatekey in our implementation

We will create a new file called abenity.php

touch abenity.php

And we use this example code to make the implementation for the file

<?php

$get_params = $_GET;

// Include autoloader (from Composer)
require 'vendor/autoload.php';

// Define Abenity API Credentials. Replace these with your values.
define('ABENITY_API_USERNAME', 'your_API_USERNAME');
define('ABENITY_API_PASSWORD', 'your_API_PASSWORD');
define('ABENITY_API_KEY', 'your_API_KEY');

// Create new Abenity object
$abenity = new \Abenity\ApiClient(ABENITY_API_USERNAME, ABENITY_API_PASSWORD, ABENITY_API_KEY);

// Define your private key, probably read in from a file.
$privatekey = ''; // HERE YOU NEED TO COPY THE PRIVATE KEY THAT WAS GENERATED IN /home/your_user/.ssh/id_rsa

// Set member profile
$member = array(
    'creation_time' => date('c'),
    'salt' => rand(0,100000),
    'send_welcome_email' => 1,
    'client_user_id' => $get_params['id'],
    'email' => $get_params['email'],
    'firstname' => $get_params['first_name'],
    'lastname' => $get_params['last_name'],
    'zip' => $get_params['zip'],
    'country' => 'US'
);

// Attempt to SSO a member
$abenity_response = $abenity->ssoMember($member, $privatekey);

if( isset($abenity_response->status) ){
    if( $abenity_response->status == 'ok' ){
        $abenity_url = $abenity_response->data->token_url;
        $abenity_url_exploded = explode('https://your_subdomain.abenity.com', $get_params['abenity_link']);
        if (isset($abenity_url_exploded[1])) {
            $url = $abenity_url . '&page_request=' .$abenity_url_exploded[1];
            header('Location: '.$url);
        } else {
            echo 'Error in url exploding';
        }
        
    }else{
        // Handle $abenity_response->error ...
        var_dump($abenity_response->error);
    }
}

To finish this part we will create the short-code custom file to do the implementation for the Abenity short-code, we need to go in the console to our current theme folder for example:

cd /var/www/vhosts/abenity/httpdocs/wp-content/themes/current_theme_name

And we will create a new file called custom-shortcodes.php

touch custom-shortcodes.php

We add this code in that file:

<?php

function generate_abenity_link( $atts = [], $content = null, $tag = '' ) {
    // normalize attribute keys, lowercase
    $atts = array_change_key_case( (array) $atts, CASE_LOWER );
    $user = wp_get_current_user();
    $email = $user->data->user_email;
    $user_id = $user->ID;
    $first_name = get_user_meta($user_id, 'first_name', true);
    $last_name = get_user_meta($user_id, 'last_name', true);
    $zip = get_user_meta($user_id, 'zip', true);
    
    // override default attributes with user attributes
    $abenity_atts = shortcode_atts(
        array(
            'link' => 'some default link to an Abenity deal',
        ), $atts, $tag
    );

    $abenity_link = $abenity_atts['link'];

    $params = [
        'id' => $user_id,
        'abenity_link' => $abenity_link,
        'email' => $email,
        'first_name' => $first_name,
        'last_name' => $last_name,
        'zip' => $zip
    ];

    $get_params = http_build_query($params);
    $url = get_site_url().'/abenity.php?'.$get_params;
    return '<div class="div_abenity"><p><a href="'.$url.'" target="_blank" class="button_abenity">Claim Your Benefit</a></p></div>';
}

add_shortcode('abenity-link', 'generate_abenity_link');

We finish this part after the file was saved and will continue inside our WordPress dashboard

On this way we will load the custom short-codes file using the functions.php file, on our browser we go to the theme editor: https://our_wp_url/wp-admin/theme-editor.php

We should add the next code in the last line inside the functions.php file:

/**
 * Include custom shortcodes 
*/
include('custom-shortcodes.php');

Then we upload the file using the button in the bottom part of the screen

With this, we finished the implementation and we can use the short-code opening a new post and we will add the short-code on this way:

[abenity-link link="https://your_subdomain.abenity.com/discounts/offer/604:41189"]

For the explanation of the link parameter, it is a parameter to generate the Abenity link with a specific deal, that will be opened in a new window after the user clicked the Abenity link.

Well it is the end of this post, I hope this will be useful and if you have any questions please let me know in the commentaries.

Best regards.

Sendgrid it's a platform that offers a mail service delivery and the interesting thing it's that we can configure our incoming email service in their platform.

For example: I have my domain danfercf.info and I want to receive my incoming email for the email address support@danfercf.info in my domain and I can do that with Sendgrid, we can receive the emails in Sendgrid's service the service is called "Inbound Parse Webhook".

Before to configure this feature we must configure an authenticated domain, you can follow this:

How to set up domain authentication

Set up sender authentication to improve your deliverability and security of your emails.

.st0{fill:#FFFFFF;} .st1{fill:#FFFFFF;} .st2{fill:#99E1F4;} .st3{fill:#1A82E2;} .st4{fill:#00B2E3;} .st5{fill:#009DD9;} .st6{opacity:0.35;fill:#FFFFFF;} .st7{opacity:0.75;fill:#FFFFFF;}

After that we can continue and we will follow these steps to configure the service:

Add the domain into the settings page:

For this we need to go to:
https://app.sendgrid.com/settings/parse

And then click to "Add Host & URL"

After that we need to configure the input data for our domain

Input description:

* Receiving Domain: It's the subdomain for our site (We can add some one or just receive the emails for our entire domain).

* Domain: It is the authenticated domain that was configured before.

* Destination URL: This the API URL that's accepts a POST request with the data sended by Sendgrid.

* Check incoming emails for spam: A feature from Sendgrid to check the spam for our incoming emails.

* POST the raw, full MIME message: This is the input data that was send by Sendgrid but such a raw information.

Input configuration:

On this part we configure the inputs:

* Receiving Domain: Blank, if we don't have a subdomain.

* Domain: my-domain.info, here we need to add our domain that will receive the incoming emails.

* Destination URL: http://example.com:7000/api/mails, for this input we add our own API url that's receives a multipart/form data and returns a 200 OK status code if everything is going well with the implementation and the data received.

* Check incoming emails for spam: Checked, it's because it useful that Sendgrid checks if we receive spam in our email accounts.

* POST the raw, full MIME message: Unchecked, we don't handle this kind of data.

And that's it, we just click the Add button and our configuration should be saved and we can continue with the implementation for the webhook.

PD: In the next post I will explain how to implement the webhook using NodeJS and MongoDB for save the incoming email.

Best Regards.

This is a tutorial to install JDownloader such a systemd service in a Raspberry PI

Prerequisites:

Install java ffmpeg decoder, vim and unrar:

sudo apt install -y default-jdk ffmpeg vim unrar-free

Then create a new folder and enter to the created folder

mkdir jdownloader && cd jdownloader

Download the JDownloader installer

wget http://installer.jdownloader.org/JDownloader.jar

After that we finished the installation phase and we need to configure our JDownloader, we are start running the JDownloader executable

java -jar JDownloader.jar -norestart

Wait if there are updates, after it finished you can stop it with CTRL+C command an you need to re run it again

java -jar JDownloader.jar -norestart

You should wait if there is another update and then configure MyJDownloader with the credentials that you created in https://my.jdownloader.org/

You need to setup your email and password

Then you can check if your server is online in https://my.jdownloader.org

After that you need to stop the JDownloader headless server pressing CTRL+C in the terminal

In the next phase you can configure your JDownloader server such as SystemD service it is in order to have an unattended service and you can manage it using the services commands.

Run in the terminal

sudo touch /etc/systemd/system/jdownloader.service && sudo vim /etc/systemd/system/jdownloader.service

You should copy this configuration to the opened vim terminal, keep in mind that the ExecStart needs to point to the JDownloader executable

[Unit]
Description=JDownloader
Wants=network.target
After=network.target

[Service]
Type=simple
ExecStart=java -jar /home/pi/jdownloader/JDownloader.jar -norestart
PIDFile=/home/pi/bin/jdownloader/JDownloader.pid
User=pi
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target

And that's it you can finish the configuration reloading the SystemD Daemon

sudo systemctl daemon-reload

Start the service

sudo systemctl start jdownloader.service

And at the end you need to enable the service

sudo systemctl enable jdownloader.service

You can check the service status using

sudo service jdownloader status

And that's it you have your JDownloader server in your Raspberry Pi and you can queue downloads using MyJDownloader from everywhere.

On this time we create a script using a cronjob to free up RAM in our Raspberry PI, it will run every 5 hours. I made this script because I realized that Raspberry PI freezes sometimes and it's because the device it's ran out of memory.

In your home folder or where you want to create the script, you start creating the file, in the terminal we use

touch free-ram.sh && chmod +x free-ram.sh

Open the file using vim or whatever you use to edit files

vim free-ram.sh

We add this script into the file, this script generates a log file also, it's in order to check the free RAM after runs the script

#!/bin/bash
FILE=/var/log/free-ram.log
sync
echo 3 > /proc/sys/vm/drop_caches

if test -f "$FILE"; then
    echo -e "$(date) \n$(egrep 'MemFree|MemAvailable' /proc/meminfo)"  >> /var/log/free-ram.log
else
    touch /var/log/free-ram.log
    echo -e "$(date) \n$(egrep 'MemFree|MemAvailable' /proc/meminfo)" >> /var/log/free-ram.log
fi

You can test the script using

sudo ./free-ram.sh

After the script running process is finished you can check the results inside the log file created on "/var/log/free-ram.log"

tail /var/log/free-ram.log

You can see the results

Fri 26 Aug 11:17:18 -04 2022 
MemFree:          539644 kB
MemAvailable:     656820 kB

After that we can procede to add the new task on the cronjob list

First you need to switch the user to the root user

sudo su

Then open the crontab editor with

crontab -e

You can something like this

# Edit this file to introduce tasks to be run by cron.
# 
# Each task to run has to be defined through a single line
# indicating with different fields when the task will be run
# and what command to run for the task
# 
# To define the time you can provide concrete values for
# minute (m), hour (h), day of month (dom), month (mon),
# and day of week (dow) or use '*' in these fields (for 'any').
# 
# Notice that tasks will be started based on the cron's system
# daemon's notion of time and timezones.
# 
# Output of the crontab jobs (including errors) is sent through
# email to the user the crontab file belongs to (unless redirected).
# 
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
# 
# For more information see the manual pages of crontab(5) and cron(8)
# 
# m h  dom mon dow   command

At the end of the file you will add the cronjob task using the absolute path of your script in my case my script is on my home folder "/home/pi/projects/scripts/free-ram.sh"

The file will look like this after the modification

# Edit this file to introduce tasks to be run by cron.
# 
# Each task to run has to be defined through a single line
# indicating with different fields when the task will be run
# and what command to run for the task
# 
# To define the time you can provide concrete values for
# minute (m), hour (h), day of month (dom), month (mon),
# and day of week (dow) or use '*' in these fields (for 'any').
# 
# Notice that tasks will be started based on the cron's system
# daemon's notion of time and timezones.
# 
# Output of the crontab jobs (including errors) is sent through
# email to the user the crontab file belongs to (unless redirected).
# 
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
# 
# For more information see the manual pages of crontab(5) and cron(8)
# 
# m h  dom mon dow   command
0 */5 * * * /home/pi/projects/scripts/free-ram.sh

And that's it, the script will free up ram every 5 hours and you can check the logs inside the logs folder.