I needed to locally run a PHP project that required PHP 8. By default only PHP 7.x is available in WSL repository. To upgrade your PHP installation to the latest PHP 8.x version within Windows Subsystem for Linux (WSL) read on.

Step 1: Launch Your WSL Environment

Start by opening your Linux distribution through the Start menu or by typing its name into PowerShell or Command Prompt.

Step 2: Prepare Your System

Before proceeding with the PHP upgrade, ensure your system's package list is up to date. In your WSL terminal, run:

sudo apt update && sudo apt upgrade -y

This command updates the package list and upgrades any existing packages to their latest versions.

Step 3: Install PHP 8.x

The default repositories in your Linux distribution may not immediately offer the latest PHP version. To install PHP 8.x, you might first need to add a third-party repository, such as the widely-used Ondřej Surý PPA for Ubuntu and Debian distributions. Here’s how you do it:

Add the PHP Repository: Install the software-properties-common package to manage additional repositories and then add the Ondřej Surý PHP repository.

sudo apt -y install software-properties-common
sudo add-apt-repository ppa:ondrej/php
sudo apt update

Install PHP 8.x: With the repository added, you can now install PHP 8.x. Replace 8.x with the specific minor version you wish to install, I used 8.3.

sudo apt install php8.3

This command installs PHP 8.3 along with common extensions. If you need additional PHP extensions, install them using the sudo apt install php8.3-extension_name format.

Step 4: Verify Your PHP Installation

After installation, verify that PHP 8.3 is correctly installed by checking its version:

php -v

PHP 8.3.3-1+ubuntu20.04.1+deb.sury.org+1 (cli) (built: Feb 15 2024 18:38:21) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.3.3, Copyright (c) Zend Technologies
    with Zend OPcache v8.3.3-1+ubuntu20.04.1+deb.sury.org+1, Copyright (c), by Zend Technologies

This command displays the installed PHP version, confirming that you're now running PHP 8.3 on your WSL environment.

Do you have a few old external USB drives lying around collecting dust? Well, you could put them to good use with a simple and robust NAS (Network-attached storage) using a Rasberry Pi.
Moreover, if you have plenty of old travel photos on that external drive, you could host my open source NodeJS app (GitHub repo here) to display them on an old tablet, just like an interactive smart photo frame.

I've tested this on Rasberry Pi 3 and 4, but really any should work. If your external USB drive has it's own power source, you can connect it to RPi directly, but if it doesn't have it's own power source, you might need an externally powered USB hub to which you'll connect your USB drives. Raspberry might not be able to suply enough current to power more than 2-3 external USB drives.

Prerequisites

I assume you already have Raspberry Pi OS installed, but if not, install it from official source https://www.raspberrypi.com/software/ (make sure you enable SSH during intallation).
If you already have a different Linux distribution installed, this should also work, but you might need to slightly modify some of below commands.

1. ssh to your RPi and update your system

   sudo apt update && sudo apt full-upgrade
   

2. Connect any USB drives you want to make accessible over the network.
   Raspberry Pi OS should automatically detect USB drives when you plug them in. To see what drives it found run:

   sudo blkid
   
   /dev/mmcblk0p1: LABEL_FATBOOT="boot" LABEL="boot" UUID="17B6-FC00" BLOCK_SIZE="512" TYPE="vfat" PARTUUID="834cc527-01"
   /dev/mmcblk0p2: LABEL="rootfs" UUID="b101bb80-3338-4b94-a775-b3844f8f2aa8" BLOCK_SIZE="4096" TYPE="ext4" PARTUUID="834cc527-02"
   /dev/sdc1: LABEL="SAMSUNG" BLOCK_SIZE="512" UUID="8E84B2B084B29A63" TYPE="ntfs" PARTUUID="01022cb5-01"
   /dev/sdd1: LABEL="SAMSUNG" BLOCK_SIZE="512" UUID="1E904FEC904FC8CB" TYPE="ntfs" PARTUUID="d9d225e4-01"
   /dev/sdb1: LABEL="Elements" BLOCK_SIZE="512" UUID="DC74B02074AFFB80" TYPE="ntfs" PARTLABEL="Elements" PARTUUID="ae55a0c1-17a6-41a5-bf6f-c4d86a960b7e"
   /dev/sda1: LABEL="SAMSUNG" BLOCK_SIZE="512" UUID="0C6EBE646EBE466C" TYPE="ntfs" PARTUUID="411e3984-01"
   

   or

   ls -l /dev/disk/by-uuid
   
   lrwxrwxrwx 1 root root 10 Aug 11 20:28 0C6EBE646EBE466C -> ../../sda1
   lrwxrwxrwx 1 root root 15 Aug  9 22:07 17B6-FC00 -> ../../mmcblk0p1
   lrwxrwxrwx 1 root root 10 Aug  9 22:08 1E904FEC904FC8CB -> ../../sdd1
   lrwxrwxrwx 1 root root 10 Aug  9 22:08 8E84B2B084B29A63 -> ../../sdc1
   lrwxrwxrwx 1 root root 15 Aug  9 22:07 b101bb80-3338-4b94-a775-b3844f8f2aa8 -> ../../mmcblk0p2
   lrwxrwxrwx 1 root root 10 Aug 11 20:28 DC74B02074AFFB80 -> ../../sdb1
   

   for a bit more visual representation, try:

   lsblk
   
   NAME        MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
   sda           8:0    0   1.8T  0 disk
   └─sda1        8:1    0   1.8T  0 part /media/pi/SAMSUNG2
   sdb           8:16   0   3.6T  0 disk
   └─sdb1        8:17   0   3.6T  0 part /media/pi/Elements
   sdc           8:32   0 931.5G  0 disk
   └─sdc1        8:33   0 931.5G  0 part /media/pi/SAMSUNG1
   sdd           8:48   0 931.5G  0 disk
   └─sdd1        8:49   0 931.5G  0 part /media/pi/SAMSUNG
   mmcblk0     179:0    0  29.7G  0 disk
   ├─mmcblk0p1 179:1    0   256M  0 part /boot
   └─mmcblk0p2 179:2    0  29.5G  0 part /
   

   We're interested in /dev/sda1, /dev/sdb1, /dev/sdc1 and /dev/sdd1
   Make a note of UUID for each drive you want to use.

3. Create folders for each drive, where you'll see their contents

   sudo mkdir /mnt/nas1
   sudo chown -R pi:pi /mnt/nas1
   

   Repeat above for each drive, you're configuring.

4. Install missing dependiencies
   Make sure your system is able to read NTFS partisions by installing ntfs-3g package It should already be there if you're using original Raspberry Pi OS. If not install it.

   sudo apt install ntfs-3g
   

   You might need to also install Extended FAT package to read FAT partitions.

   sudo apt install exfat-fuse exfat-utils
   

5. Create a user that will access mounted drives
   I'm creating a new user called "nas" for the purpose of accessing NAS resources over network.

   sudo useradd nas
   sudo passwd nas
   
   New password:
   Retype new password:
   passwd: password updated successfully
   

   Find out new user's id and group id.

   id -u nas
   id -g nas
   

   In my case both returned "1001".

6. Automatically mount drives
   Now that we have all the dependencies installed, we need to make sure our drives mount automatically after system restart.

   sudo vim.tiny /etc/fstab
   

   which if unmodified, should look similar to this:

   proc            /proc           proc    defaults          0       0
   PARTUUID=834cc527-01  /boot           vfat    defaults,flush    0       2
   PARTUUID=834cc527-02  /               ext4    defaults,noatime  0       1
   # a swapfile is not a swap partition, no line here
   #   use  dphys-swapfile swap[on|off]  for that
   

   Don't change any of that, just leave it as it is and add your entries below. Remember to change the values of UUID, uid and gid with the values we noted before.

   # Drive 1 - 2T
   UUID=0C6EBE646EBE466C /mnt/nas1 auto nofail,uid=1001,gid=1001,noatime 0 0
   
   # Drive 2 - 1T
   UUID=1E904FEC904FC8CB /mnt/nas2 auto nofail,uid=1001,gid=1001,noatime 0 0
   
   # Drive 3 - 1T
   UUID=8E84B2B084B29A63 /mnt/nas3 auto nofail,uid=1001,gid=1001,noatime 0 0
   
   # Drive 4 - 4T
   UUID=DC74B02074AFFB80 /mnt/nas4 auto nofail,uid=1001,gid=1001,noatime 0 0
   

   Your system might have automatically mounted all the drives or if you're debugging or changing something and you had your drive already mounted, you'll have to unmount it and mount it again for the changes to take effect.

   sudo umount /dev/sda1
   sudo umount /dev/sdb1
   sudo umount /dev/sdc1
   sudo umount /dev/sdd1
   

   Mount defined drives

   sudo mount -av
   
   /proc                    : already mounted
   /boot                    : already mounted
   /                        : ignored
   /mnt/nas1                : successfully mounted
   /mnt/nas2                : successfully mounted
   /mnt/nas3                : successfully mounted
   /mnt/nas4                : successfully mounted
   

   Now we have drives mounted that should persist over system restarts.

Share mounted drives on local network

1. Install Samba
   Samba is a suite of applications that implements the Server Message Block (SMB) protocol. Many operating systems, including Microsoft Windows, use the SMB protocol for client-server networking. Samba enables Linux / Unix machines to communicate with Windows machines in a network, which in our case simply means sharing that mounted drive(s) over network.

   sudo apt install samba samba-common-bin cifs-utils
   

2. Create samba user
   Remember we created a new system user nas, now we need to make it a Samba user. The password we created before for that user was for RPi OS, now you can specify a different password to use when accessing your resources over network. You can keep passwords the same for ease of use.

   sudo smbpasswd -a nas
   New SMB password:
   Retype new SMB password:
   Added user nas.
   

   The -a switch adds user nas to the Samba password list.
   If you need to modify existing Samba user you can do it with:

   sudo smbpasswd nas
   

   To list existing samba users run:

   sudo pdbedit -L -v
   

3. Configure network shareable resource
   Open Samba config file

   sudo vim.tiny /etc/samba/smb.conf
   

   Go to the bottom of the file and add

   [nas1]
   comment = My USB drive 2T
   path = /mnt/nas1
   # you can list multiple users here separated by space
   valid users = nas
   force group = users
   create mask = 0660
   directory mask = 0771
   read only = no
   # if you need unathenticated access (guest users), uncomment below line
   # guest ok = yes
   

   Add a section like this for each of your drives. Changing the group name [nas1] and path accordingly.
   Test if the config is correct

   testparm
   
   Load smb config files from /etc/samba/smb.conf
   Loaded services file OK.
   Weak crypto is allowed
   Server role: ROLE_STANDALONE
   

   If everything is ok, restart Samba to apply new settings

   sudo systemctl restart smbd
   

   In case of any issues or simply if you want to see active connections, run:

   sudo smbstatus
   

Map drive on Windows

1. Open file manager
2. Go to "This PC"
3. At the top in "Computer" tab, click on "Map network drive", not the "Add network location". There's a key difference.
4. Choose a Drive letter you want to assign to this resource.
5. In "Folder" field type in \\RASPBERRYPI\nas1 or whatever location your Raspberry is at
6. Leave "Reconnect at sign-in" ticked.
7. Click Finish

On the credentials popup, Windows will most likely prefil your current user details. If that's the case click "More choices" and then "Use a different account". This will allow you to specify your Samba username and password. For us the user was nas.

Map drive on Linux

If you want to access local drives on Linux (or Mac) it should be very similar to what we've done before.

sudo apt install cifs-utils
sudo mkdir /mnt/nas1
sudo mkdir /mnt/nas2
sudo mkdir /mnt/nas3
sudo mkdir /mnt/nas4
sudo vim /etc/fstab

Add below lines to the bottom of fstab file

//192.168.0.100/nas1  /mnt/nas1 cifs    uid=0,username=nas,password=******,iocharset=utf8,file_mode=0777,dir_mode=0777,sec=ntlmssp  0  0
//192.168.0.100/nas2  /mnt/nas2 cifs    uid=0,username=nas,password=******,iocharset=utf8,file_mode=0777,dir_mode=0777,sec=ntlmssp  0  0
//192.168.0.100/nas3  /mnt/nas3 cifs    uid=0,username=nas,password=******,iocharset=utf8,file_mode=0777,dir_mode=0777,sec=ntlmssp  0  0
//192.168.0.100/nas4  /mnt/nas4 cifs    uid=0,username=nas,password=******,iocharset=utf8,file_mode=0777,dir_mode=0777,sec=ntlmssp  0  0

Remember to change the IP address to whatever your local RPi is using. The username and password should probably be stored in a separate file, but just to keep things simple, I'll leave it inline.
Mount your drives

sudo mount -av

I needed to make some changes to an old PHP (Wordpress) site and wanted to quickly run it locally. I don't actively use PHP anymore therefore I didn't want to install XAMPP or anything big like this. The obvious idea was to use WSL to run the site. First I tried with Apache, but for some reason, despite everything being set up correctly, the site was just not loading in the Windows browser. When I accessed it within WSL it returned the correct HTML. I spent a good part of the day trying to figure it out with no success. Then I thought, screw Apache, let me try nginx and surprise, surprise it all worked just fine without a single issue.
Below are all the steps I made to set up a simple dev site on WSL2 with PHP and nginx.

Configuration

1. Install PHP with some common dependencies. I chose ones I needed for Wordpress. Feel free to remove or add modules as you see fit. Just make sure you install php7.4-fpm.

   sudo apt install php7.4 php7.4-cli php7.4-mysql php7.4-curl php7.4-mcrypt php7.4-json php7.4-mbstring php7.4-fpm
   

2. Install nginx and run the service.

   sudo apt install nginx
   sudo service nginx start
   

3. Check the path for PHP socket and make a note of it.

   sudo grep "listen =" /etc/php/7.4/fpm/pool.d/www.conf
   > listen = /run/php/php7.4-fpm.sock
   

4. Make sure PHP is running.

   sudo service php7.4-fpm status
    * php-fpm7.4 is running
   
   # if it's "not running", start it with below command
   sudo service php7.4-fpm start
   

5. Add nginx config for your local website by creating a config file. The example.local is just the domain I used, you can change it to whatever your domain will be. Just make sure that anywhere I used example.local you change it to your domain.

   sudo vim /etc/nginx/sites-available/example.local.conf
   

   Your config file should look similar to below.

   server {
       listen 80;
   
       access_log /var/log/nginx/example.local-access.log;
       error_log /var/log/nginx/example.local-error.log;
   
       root /mnt/c/Users/kosa/workspace/example-blog;
       index index.php index.html index.htm;
       server_name example.local www.example.local;
   
       location = /favicon.ico { access_log off; log_not_found off; }
       location = /robots.txt  { access_log off; log_not_found off; }
   
       location / {
           try_files $uri $uri/ /index.php?$query_string;
       }
   
       location ~ \.php$ {
           try_files      $uri =404;
           fastcgi_split_path_info ^(.+\.php)(/.+)$;
           fastcgi_pass   unix:/var/run/php/php7.4-fpm.sock;
           fastcgi_index  index.php;
           fastcgi_param  SCRIPT_FILENAME $document_root$fastcgi_script_name;
           include        fastcgi_params;
       }
   
       location ~ /\.ht {
           deny all;
       }
   }
   

   Please note the root directive points to a path on a Windows drive. Essentially it's c:\Users\kosa\workspace\example-blog. Also "kosa" in there is just my username, you should change it to yours.
   Check the value of fastcgi_pass directive and make sure it is the same as the path you got in point 3 above.

6. Symlink your newly created config file to enable your new site on nginx.

   sudo ln -s /etc/nginx/sites-available/example.local.conf /etc/nginx/sites-enabled/
   
   # test new nginx config
   sudo nginx -t
   nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
   nginx: configuration file /etc/nginx/nginx.conf test is successful
   
   # if all is good, restart nginx
   sudo service nginx restart
   

7. Last step of the whole process is to add an entry to your Windows hosts file. We're talking about the Windows hosts file located in c:\Windows\System32\drivers\etc\. You don't need to touch the internal WSL hosts file in /etc/hosts.
   Add the below and we're done.

   127.0.0.1        example.local
   

Now, open your favourite browser on Windows and go to http://example.local/ You should see your website load up.

Troubleshooting

If for some reason the above process did not work for you, see if you get the correct response header from your site within WSL. While in WSL console, run:

curl -I http://example.local
HTTP/1.1 200 OK
Server: nginx/1.18.0 (Ubuntu)
Date: Sun, 01 Nov 2020 15:20:45 GMT
Content-Type: text/html; charset=UTF-8
Connection: keep-alive
Link: <http://example.local/wp-json/>; rel="https://api.w.org/"

# if you get "200 OK", then check the actual HTML returned by the server
curl http://example.local

You should see the full HTML code of your site. If you don't, then it means you made a mistake somewhere in the configuration or maybe simply nginx is not running. You can also use the Linux text based browser lynx, to see your website in text mode.

Another option is to fully restart WSL. Close your WSL console, open PowerShell and run below command:

wsl --shutdown

Then open WSL console again and make sure all services are running before testing in the browser.

It's recommended to download a fresh image of Raspbian Stretch from official Raspbian website, but if for whatever reason you don't want to do that, you can still upgrade from Jessie to Stretch.

1. Disk space

Check available disk space and make sure you have at least 1.5GB of free space.

df -h

2. Update current system

Before upgrading, make sure all your packages are up to date.

sudo apt-get update
sudo apt-get upgrade
sudo apt-get dist-upgrade

3. Update package lists

Update your package lists to use Stretch repositories. In both below files, change every occurrence of the word ‘jessie’ to ‘stretch’.

vim.tiny /etc/apt/sources.list
vim.tiny /etc/apt/sources.list.d/raspi.list

4. Update packages

Be aware this may take a while, depending on your internet connection and available resources. I'd say, around two hours.

sudo apt-get update
#sudo apt-get upgrade
sudo apt-get dist-upgrade

During installation, you'll be asked to confirm changes to configuration files. I suggest pressing D to see differences and then following with Y or N to accept or reject changes.
Especially when it comes to configuration file /etc/dhcpcd.conf be sure you don't loose your static IP address configuration if you had one set up.

5. Clean up after yourself

Below will remove no longer needed packages and save you up some disk space. In my case it was 1GB.

sudo apt-get autoremove
sudo apt-get autoclean

Or simply put, easily switch between versions of NodeJS on any Linux based system. There are two most popular Node version managers. One, my personal favourite is n package, the other one is nvm.

n

For me the easiest way is to use n package. Just install whatever Node version your official distribution ships with.

sudo yum install nodejs

or, depending on what Linux you're using.

sudo apt-get install nodejs

Then install n as a global package.

sudo npm install -g n

/usr/local/bin/n -> /usr/local/lib/node_modules/n/bin/n
+ n@6.5.1
added 1 package from 4 contributors in 0.201s

Done, it was that easy. Now install the version of node you want to use:

sudo n lts <--- latest LTS official release
sudo n latest <--- latest official release
sudo n stable <--- stable official release
sudo n 10.16.0 <--- specific version

Execute n on its own to view your downloaded versions, and install the selected one.

n

    node/8.11.2
    node/10.14.2
    node/10.15.0
    node/10.16.0
  ο node/12.18.1

Use up/down arrow keys to select a version, return key to install, d to delete, q to quit

nvm

Run the official install script by executing one of below commands:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash

wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash

Rerun Profile script to start NVM

source ~/.bashrc

Now nvm should be running and you can confirm it by running below

nvm

Node Version Manager (v0.35.3)

If everything went fine, make nvm use your currently installed Node version

nvm use system

Now using system version of node: v8.11.2 (npm v6.9.0)

List available versions using

nvm ls-remote

Install the latest release of node

nvm install node <--- latest version
nvm install 10.16.0 <--- specific version

If after exiting console and logging in again nvm is not a recognised command, you'll need to add source ~/.bashrc to your .profile or .bash_profile file to make sure it's automatically run on every login. A good explanation of what's going on, can be found here.

I couldn't find a clear explanation of how to pass both data and methods from parent component to a child component in VueJS.
Remember, there's always more that one way of doing almost anything. Below is just one of those ways. More detailed, albeint no so clear, explanation and all the other ways of passing props can be found in official documentation.

Parent component

Let's assume you have a child component called Childcomponent. Passing properties down to the child component is as simple as adding :prop="value" multiple times.
You can pass a single value, array :ids="[324, 12, 434]" or an object :name="{ first: 'AAA', last: 'BBB' }". What was a very nice surprise for me, you can pass methods in exactly the same way. Then you can run methods from within your child component that are defined in your parent component. Super handy.

<div id="components-demo">
  <Childcomponent
    :first-name="firstName"
    :status="whatever.path.status"
    :some-method="someMethod"
    :submit="submitForm" />
</div>


<script>
import Childcomponent from '~/components/Childcomponent.vue'

export default {
  components: {
    Childcomponent
  },
  data() {
    return {
      firstName: 'whatever',
      whatever: {
        path: {
          status: true
        }
      }
    }
  },
  methods: {
    someMethod() {
      // do something
    },
    submitForm() {
      // do something else
    }
  }
}
</script>

Child component

In child component, you need to define passed properties. Notice, in parent component prop names should use kebab case first-name, but when defining them in child component, use camel case firstName. Also methods passed from parent need to be defined in the child as a type Function.
Then, you can use your data and methods (from parent) in the child component just as you'd do it normally.

<template>
  <div>
    <div class="col">
      <img :src="loadImage(status)" alt="alt text">
    </div>
    <button
      class="btn btn-sm btn-outline-light"
      @click="submit">
      Submit
    </button>
  </div>
</template>

<script>
export default {
  name: 'Childcomponent',
  props: {
    firstName: {
      type: String,
      default() {
        return 'My name'
      }
    },
    status: {
      type: Boolean,
      default() {
        return false
      }
    },
    loadImage: {
      type: Function,
      default() {
        return {}
      }
    },
    submit: {
      type: Function,
      default() {
        return {}
      }
    }
  }
}
</script>

NuxtJS is a fantastic framework for creating VueJS applications. It comes bundled with Vue Router, Vuex, Vue Server Renderer and many more. All configured for you out of the box.
The problem I have with it, it comes with linting options set to force 2 spaces as indentation. I'm a "tab" guy, so making me use spaces for indentation drove me crazy. It took me a while to make eslint understand I want different rules in my project. Below is a version of .eslintrc.js file that worked for me.

Obviously, I assume you've selected eslint while installing NuxtJS, so you have all the necessary modules installed. Below config has been tested with (at the time of writing this post) latest version of NuxtJS 2.8.1

module.exports = {
	root: true,
	env: {
		browser: true,
		node: true
	},
	parserOptions: {
		parser: 'babel-eslint'
	},
	extends: [
		'@nuxtjs',
		'plugin:nuxt/recommended'
	],
	// add your custom rules here
	rules: {
		'nuxt/no-cjs-in-config': 'off',
		'no-console': process.env.NODE_ENV === 'production' ? 'error' : 'off',
		'no-debugger': process.env.NODE_ENV === 'production' ? 'error' : 'off',
		'vue/html-indent': ['error', 'tab'],
		'vue/html-closing-bracket-newline': 'off',
		'indent': [2, 'tab'],
		'no-tabs': 'off'
	}
}

Go to official eslint VueJS plugin page for documentation on other rules that might suite your taste.

Have you noticed other sites hotlinking to your images or other assets? Are they eating up your bandtwitch? Or you just want to proactively prevent that? If so, there's a very easy way to do so with a simple configuration on nginx.
Open up nginx config file for your site and add another location block like this:

server {
    # your normal site configuration is here

    location ~* \.(gif|png|jpe?g)$ {
        valid_referers none blocked server_names ~\.google\. ~\.bing\. ~\.yahoo\. ~\.facebook\. ~\.yoursite.com;
        if ($invalid_referer) {
            return 403;
        }
    }
}

With above, we're sending 403 Forbidden error status code whenver an image is requested from a referer that is not in our approved list.
valid_referers lists sites which we want to allow hotlinking our images. Remember to change ~\.yoursite.com to your actual site domain.
If you want to block other file types, just add an extra pipe "|" and file extension, like this (gif|png|jpe?g|bmp|tiff|pdf)

Going one step further, you can serve one specific image every time a not approved sites tries to hotlink to your assets. To do that add below config:

server {
    # your normal site configuration is here

    location ~* \.(gif|png|jpe?g)$ {
        valid_referers none blocked server_names ~\.google\. ~\.bing\. ~\.yahoo\. ~\.facebook\. ~\.yoursite.com;
        if ($invalid_referer) {
            rewrite (.*) /path/to/image/hotlinking-denied.jpg redirect;
        }
    }
    # prevent redirect loop
    location = /path/to/image/hotlinking-denied.jpg { }
}

Having your site configured on nginx with

server_name example.com www.example.com;

is a good thing as it'll allow your visitors to access your site on both example.com and www.example.com, but they'll stay on the version of the domain they used to access your site in the first place. In your analytics, you may start seeing traffic separated into example.com and www.example.com which definitely does not help you get a clear view of your visitors. It's good practice to decide on one version of the domain and stick to it. I prefer the non-www version, but it's entirely up to you.

Redirect www to non-www

To redirect all traffic from www.example.com to just plain example.com, add another server {} block to your nginx config file with just two lines:

# new block
server {
    server_name www.example.com;
    return 301 $scheme://example.com$request_uri;
}
# your normal config
server {
    ...
    server_name example.com; # notice, this has just the non-www version
    ...
}

Restart nginx to apply above changes

sudo systemctl restart nginx

Redirect non-www to www

To redirect your users from non-www to a www version of your domain add below:

# new block
server {
    server_name example.com;
    return 301 $scheme://www.example.com$request_uri;
}
# your normal config
server {
    ...
    server_name www.example.com;
    ...
}

Restart nginx to apply above changes

sudo systemctl restart nginx

Conclusion

That's it. Your users will now be able to access your site on both www and non-www versions and will be permanently redirected to one version you chose.

Mailgun is a fantastic, free service which allows you to send, receive and track emails effortlessly. It's dead easy to integrate with your self hosted Ghost blog.

Mailgun configuration

1. Log in to your Mailgun account.
2. Go to "Domains" section.
3. Click on "Add New Domain" and add a subdomain you want to send emails from.
4. Follow on page instructions to add all the DNS entries.
5. Once DNS changes propagate, verify your domain within Mailgun.

Ghost configuration

1. SSH to your server and edit config.production.json file in your Ghost root directory.
   Your "mail" section should look like this:

     "mail": {
       "transport": "SMTP",
       "options": {
         "service": "Mailgun",
         "host": "smtp.eu.mailgun.org",
         "auth": {
           "user": "postmaster@your_domain.com",
           "pass": "1234567890"
         }
       }
     }
   

   Notice host entry within options. Official Ghost documentation does not mention it. If your Mailgun domain is set up in the US region, you don't need that line. However, if you've set up your domain in the EU region, you'll need to add it in. Otherwise you'll get an error that your username and password were not recognised.
2. Save changes and restart Ghost.

   ghost restart
   

3. Log in to your Ghost admin.
4. Go to "Labs".
5. Click "Send" in "Test email configuration" section.
   The "Send" button should turn green and you should receive a test email confirming your configuration works.

It's highly recommended to update your Raspbian as often as possible to make sure you always have the latest security patches and updates.

Manual update

Open Pi's console and update package list by running the following command:

sudo apt update

Then upgrade your packages to their latest versions with below command:

sudo apt full-upgrade

This should keep you up to date and away from trouble.

Automatic updates

If you don't like to this this manually, or simply forget about it, I suggest you set up an automatic update and never have to think about it again.
There's a number of ways you can do that. There are programs that take care of that for you and have lots of options and configurations. I'll focus here on the easiest and most basic option, which is a simple cron job.
Switch to root and open crontab:

sudo su
crontab -e

If this is the first time you run crontab as root, you'll be asked to choose your preffered editor.

root@raspberrypi:/home/pi# crontab -e
no crontab for root - using an empty one

Select an editor.  To change later, run 'select-editor'.
  1. /bin/ed
  2. /bin/nano
  3. /usr/bin/mcedit
  4. /usr/bin/vim.tiny  <---- my favourite

Choose 1-4 [4]:

Once you choose your editor, enter below line at the bottom of your crontab:

0 4 * * 1 apt update && apt -y full-upgrade

Above will run update every Monday at 4am. If you prefer a different time but don't know how cron settings work, here's a very helpful site.

I wanted to write a simple script that would convert multiple files from one encoding to another. I didn't want anything big or running in the browser. Command line script seemed like the right approach. Coming from a web developer background my first thought was a script written in PHP and converted to a command line app. Just saying that sounds awful. After a bit of googling, it turned out NodeJS is surprisingly easy and straightforward to write command line apps.

Initiate the app

Running npm init will ask you a few basic questions about your app and result in creating package.json file.

$ npm init

name: cldemo
version: 0.0.1
description: Simple command line script
entry point: index.js
test command:
git repository:
keywords:
author: SixBytesUnder
license: (ISC)

Edit the newly created package.json and add "bin" section. The property key will be the command you'll type in to run your app. In our case cldemo. The value is a relative path to the entry point file. That's the file our code will reside in.

...
"author": "SixBytesUnder",
"license": "ISC",
"bin": {
  "cldemo": "./index.js"
}

Next, create index.js file or any other file you have provided as an "entry point" above. Paste example code show below.

#!/usr/bin/env node
'use strict';

// your whole code goes here
console.log('Hello World!')

The most basic command line script is done.

Register your script

Next command will register your app as a shell command. Note, on Windows you need to open command prompt as an admin, navigate to the home directory of your app and run below.

$ npm install -g

That's it, it's a simple as that. Now you should be able to run your script from command line globally.

$ cldemo
Hello World!

If you make any changes to your source files, remember to register your app again, so that latest version is copied to the global path.

To uninstall your script just type:

$ npm uninstall -g cldemo

Google's reCAPTCHA is great for getting rid of those pesky bots spamming your contact forms. Implementing reCAPTCHA on your site is very easy, albeit somewhat confusing if you try to follow official documentation.
Below example assumes you're using NodeJS with ExpressJS for back-end and Pug (formerly Jade) templating engine on the front-end. General principle is the same regardless of languages used.
I'll assume you've already set up your reCAPTCHA API keys. If you haven't just go to https://www.google.com/recaptcha/ and follow onscreen instructions.

Template files

Open up your template file where you want to use reCAPTCHA, in my case index.pug. Add reference to reCAPTCHA JavaScript file as mentioned in official documentation.

script(src='https://www.google.com/recaptcha/api.js')

Then copy the submit button code from official docs and paste it in your template, or in case of Pug, make it similar to below.

button.btn.btn-default.g-recaptcha(data-sitekey="your_site_key", data-callback="contactSubmit") Submit

Remember to change your_site_key to your actual Site Key. If you're copying and pasting code from reCAPTCHA website, it should have your key already filled in.

JavaScript to submit the form

Notice data-callback="contactSubmit" in the above code for the button. Copying code for the button directly from documentation may have a different callback function name. I called mine contactSubmit.
All you need to do is create a function in your JS file to handle form submission, making sure you pass the token value to it as an agrument and then pass it down the line to the server. Below is a pretty standard AJAX form submission example. I kept it to minimum to illustrate just the reCAPTCHA variable.

function contactSubmit(token) {
	var name = $('#contactForm #name'),
		email = $('#contactForm #email'),
		message = $('#contactForm #message');
	
	// check if the form fields are not empty
	if (name.val() !== '' && email.val() !== '' && message.val() !== '') {
		$.ajax({
			type: 'POST',
			url: '/handlecontact',
			data: {
				name: name.val(),
				email: email.val(),
				message: message.val(),
				recaptcha: token
			},
			dataType: 'json',
			error: function (data) {
				$('#contactForm #formFeedback')
                    .removeClass()
                    .addClass('alert alert-danger')
                    .html('Something went wrong, please try again')
                    .fadeIn('slow')
                    .delay(10000)
                    .fadeOut('slow');
				return false;
			},
			success : function (data, res) {
				if (data.success === true) {
					$('#contactForm #formFeedback')
                        .removeClass()
                        .addClass('alert alert-success')
                        .html(data.msg)
                        .fadeIn('slow')
                        .delay(5000)
                        .fadeOut('slow');
					// clean up form fields
					name.val('');
					email.val('');
					message.val('');
					return true;
				} else {
					$('#contactForm #formFeedback')
                        .removeClass()
                        .addClass('alert alert-danger')
                        .html(data.msg)
                        .fadeIn('slow')
                        .delay(10000)
                        .fadeOut('slow');
					return false;
				}
			}
		});
	} else {
		$('#contactForm #formFeedback')
            .removeClass()
            .addClass('alert alert-warning')
            .html('Please fill in all fields')
            .fadeIn('slow')
            .delay(10000)
            .fadeOut('slow');
		return false;
	}
}

ExpressJS - server side

Open ExpressJS file in which you handle your form data on the server side. In my case it's index.js, and add https module at the top to handle captcha verification request.

var https = require('https');

Then in the method handling your form data verify if user has passed captcha verification.
All you really need to do is send the reCAPTCHA token back to Google for verification. That's what we need https module for.

app.post('/handlecontact', function (req, res) {
	// verify recaptcha
	if (req.body.recaptcha === undefined || req.body.recaptcha === '' || req.body.recaptcha === null) {
		res.send({success: false, msg: 'Please select captcha first'});
		return;
	}
	const secretKey = 'your_secret_key';
	const verificationURL = `https://www.google.com/recaptcha/api/siteverify?secret=${secretKey}&response=${req.body.recaptcha}&remoteip=${req.connection.remoteAddress}`;
	
	https.get(verificationURL, (resG) => {
		let rawData = '';
		resG.on('data', (chunk) => { rawData += chunk })
		resG.on('end', function() {
			try {
				var parsedData = JSON.parse(rawData);
				if (parsedData.success === true) {
					// All good, send contact email or perform other actions that required successful validation
					res.send({success: true, msg: 'Your message has been sent. Thank you.'});
					return;
				} else {
					res.send({success: false, msg: 'Failed captcha verification'});
					return;
				}
			} catch (e) {
				res.send({success: false, msg: 'Failed captcha verification from Google'});
				return;
			}
		});
	});
});

When testing reCAPTCHA make sure you refresh the page between "submit" button clicks. Otherwise Google may think you're a bot for clicking too many times and not submit the form at all.