Setting Up A Raspberry Pi

Executing this command will launch the Raspberry Pi software configuration tool. This tool provides a menu-based interface that allows you to navigate through various configuration options. Follow the prompts and select the desired options to make the necessary changes, such as changing the password, modifying the hostname, enabling or disabling interfaces, and expanding the filesystem.

Please note that you will need to enter your password when prompted for authentication to execute commands with superuser privileges using sudo.

$ sudo raspi-config

Note: When working with the Raspberry Pi, most of the commands you’ll use will be run with sudo, which stands for “superuser do.” By using sudo, you can execute administrative commands and ensure that you have the necessary privileges. The system will prompt you to enter your password whenever you use sudo.

To navigate through the configuration options, you’ll encounter a menu that you can scroll through using the arrow keys. Pressing the Enter key will allow you to select an item from the menu, as illustrated below.

Here are the essential steps you need to take care of:

1. Select “System Options” from the menu.

• If you are still using the default pi/raspberry combination, choose “Change Password” to set a new password following the prompts. If you created a new username with the userconf.txt file, you can skip this step.
• Optionally, you can also choose “Change Hostname” to give your system a meaningful name instead of the default raspberrypi.
• If you want to connect to a wireless network, you can set the SSID and password in this menu. If you are using an enterprise network, follow the steps below.

2. Select “Interfacing Options.”

• If you didn’t create an ssh file on your SD card before booting, enable SSH to allow remote login via SSH.
• If you plan to use a camera or communicate with external hardware using the I2C or SPI buses, enable the corresponding options.

3. Select “Advanced Options” and choose “Expand Filesystem” to make more space available on your SD card for the system. The process will prompt you to reboot your Pi. Select “Yes” to reboot.

From now on, if you are using the Ethernet-over-USB option or logging into your Pi over a network via SSH (which we’ll cover shortly), you will need to log in using [email protected] (replace your-pi-name with the name you chose during the hostname configuration).

Changing Defaults To Increase Security

If you didn’t create a custom user using the userconfig.txt file mentioned earlier, it is recommended to add a new user to enhance the security of your Pi. Replace “username” below with the desired name for your new user:

$ sudo adduser username

Follow the prompts to set a password and provide any additional information for the new user. Make sure to choose a strong password that is not easily guessable.

Once the user is created, you can grant administrative privileges to the new user by adding them to the sudo group:

$ sudo adduser username sudo

Replace “username” with the actual name of your new user.

By creating a new user and assigning administrative privileges, you will reduce the risk associated with using the default username and password.

pi       User-specific group. A group is automatically created for
         each new user; you can ignore this.
adm      Allows access to log files in /var/log and using xconsole
dialout  Allows access to serial ports/modem reconfiguration, etc.
cdrom    Enables access to optical drives.
sudo     Enables sudo access for the user.
audio    Allows access to audio devices like microphones and soundcards
video    Allows access to a video devices, e.g. framebuffer, videocard, webcam
plugdev  Enables access to external storage devices
games    Many games are SETGID to games so they can write their high score files.
users    A Pi-specific group enabling access to
         /opt/vc/src/hello_pi/ directory and contained files.
input    Appears to give access to the /dev/input/mice folder and nothing else.
netdev   Enables access to network interfaces
gpio     Pi-specific group for GPIO pin access.
i2c      Pi-specific group for I2C access.
         Generated after installing i2c-tools.
spi      Pi-specific group for the SPI bus.

You can do this group by group with:

$ sudo adduser username groupname
or you can add many at a time like so:

sudo usermod -a -G adm,dialout,cdrom,sudo,audio,video,plugdev,games,users,input,netdev,gpio,i2c,spi username

For security purposes, it is recommended to assign only the necessary groups to your user. If your project requires access to specific groups like GPIO and SPI, add those groups and avoid adding unnecessary ones.

After adding the new user and granting the appropriate permissions, you can log out of the current session by typing either logout or exit. Then, log back in to the Pi using the newly created user:

$ssh [email protected]

Replace “username” with the name of the user you created, and “your-pi-name” with the custom name you assigned to your Pi during the configuration process.

This will establish a new SSH session with the Pi using your newly created user credentials, enhancing the security of your system.

Now make sure the root account is disabled by locking it like so:

$ sudo passwd -l root

If you need to unlock it later you can do so by typing:

$ sudo passwd -u root

Next delete the default  pi user like so:

$ sudo deluser --remove-home pi

After deleting the default “pi” user, you may receive a message stating: “Warning: group ‘pi’ has no more members.” This is nothing to worry about. The system will automatically remove the corresponding “pi” group when you delete the “pi” account. By removing the default “pi” user, you reduce the risk of someone guessing the username and gaining unauthorized access to your Pi. This adds an extra layer of security to your system.

Configuring After Changing Users

It’s important to note that many software packages are installed per user, rather than system-wide. Therefore, it’s advisable to ensure that you have the desired user configuration in place before installing firewalls, development software, or any other tools you intend to use. This precaution prevents the unpleasant surprise of installing software under one user and later discovering it’s not accessible when you switch to another user. By setting up your user configuration beforehand, you can ensure a consistent and reliable experience across different user accounts on your system.

Connecting To the Network via WiFi

To verify if the built-in WiFi on your Pi Zero W or Pi 3, Pi 4, or later models is functioning properly, you can execute the following command:

$ iwconfig wlan0

If you get a response that begins like this:

wlan0 IEEE 802.11bgn Nickname:

If the WiFi on your Pi is not working or appears to be blocked, you can try the following steps to unblock it:

1. Open a terminal window on your Pi.
2. Enter the following command to open the configuration file:
   bash

   sudo nano /etc/modprobe.d/raspi-blacklist.conf

3. Look for any lines that contain “blacklist brcmfmac” or “blacklist brcmutil” and add a # at the beginning of those lines to comment them out. It should look like this:
   arduino

   #blacklist brcmfmac
#blacklist brcmutil

4. Press Ctrl+X to exit the nano editor, then press Y and Enter to save the changes.
5. Reboot your Pi by entering the following command:
   sudo reboot


After the reboot, check the WiFi again by running the command:

If you can see a list of available WiFi networks, it means your WiFi should be unblocked and working.

Now try this command to see nearby WiFi hotspots:

$ iwlist wlan0 scan | less

You will get a list of WiFi hotspots nearby and their credentials. It’s piped through  the less utility to paginate it. You should see a list of all nearby WiFi access points, with their details. You can see the listings page by page using the spacebar, and close the list by typing q.

Getting the MAC address of the Pi’s WiFi Radio

To retrieve the MAC address of your Pi’s WiFi, follow these steps:

1. Open a terminal window on your Pi.
2. Enter the following command:
   ip link show wlan0 | awk '/ether/ {print $2}'

3. The output will display the MAC address of your Pi’s WiFi interface.

Make note of the MAC address shown on the screen. You can then use this MAC address for registration or any other required networking configurations.

$ ifconfig wlan0 | grep ether

You’ll get a response like this:

ether b8:27:eb:aa:bb:cc txqueuelen 1000 (Ethernet)

After registering the MAC address of your Pi with your institution, you can proceed to modify the wpa_supplicant.conf file to connect to the institution’s network. Here’s how you can do it:

1. Open the wpa_supplicant.conf file using a text editor. You can use the nano text editor by running the following command in the terminal:
2. In the file, locate the existing network configuration or add a new one for your institution’s network. It should look similar to the following:
3. Replace YOUR_NETWORK_SSID with the name (SSID) of your institution’s network. Replace YOUR_NETWORK_PASSWORD with the corresponding password.
4. Optionally, if your institution uses WPA2 Enterprise security with EAP authentication, you’ll need to provide additional configuration settings. Here’s an example of an entry for WPA2 Enterprise:
   1. Replace YOUR_USERNAME and YOUR_PASSWORD with your login credentials for the institution’s network.
   2. Save the changes and exit the text editor (in nano, press Ctrl + X, then confirm with Y and press Enter).
5. Once you’ve modified the wpa_supplicant.conf file, your Pi should be able to connect to your institution’s network using the provided configuration. Restart your Pi or restart the networking service for the changes to take effect.

   Note: Make sure to handle sensitive information (such as passwords) securely and avoid storing them in plain text files.

Network Configuration by Editing wpa_supplicant.conf

To create or edit the wpa_supplicant.conf file for storing your WiFi configuration, follow these steps:

1. Open the terminal on your Raspberry Pi.
2. Run the following command to open the wpa_supplicant.conf file using a text editor (such as nano):
3. In the text editor, add the following lines to the file:
4. 1. Replace YOUR_COUNTRY_CODE with the appropriate code for your country (e.g., US for the United States, GB for the United Kingdom, etc.).

      Replace YOUR_NETWORK_SSID with the name (SSID) of your WiFi network.

      Replace YOUR_NETWORK_PASSWORD with the corresponding password for your WiFi network.

   2. Save the changes and exit the text editor (in nano, press Ctrl + X, then confirm with Y and press Enter).
   3. Restart the networking service on your Raspberry Pi to apply the changes by running the following command:
      sudo systemctl restart networking.service


   Once you’ve completed these steps, your Raspberry Pi should connect to the specified WiFi network using the provided configuration.

   $ sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

   You should see something like this:

   ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
   update_config=1
   country=GB
   
   network={
           ssid="your_network_name"
           psk="your_password"
   }
   
   

   To generate an encrypted version (hash) of your password, you can use the openssl command-line tool. Follow these steps:

   1. Open the terminal on your Raspberry Pi.
   2. Run the following command, replacing YOUR_PASSWORD with your actual password:This command will generate an encrypted hash of your password.
      1. The output of the command will be a string of characters, which is the encrypted version of your password.
   3. Make sure to keep this encrypted password secure and do not store the actual plaintext password. You can use this encrypted password in configuration files that require password authentication.

      Note that the method of generating encrypted password hashes may vary depending on the specific Linux distribution or version you are using. The above command using openssl should work for most Raspbian distributions.

   $ wpa_passphrase your_network_name your_password

   This will generate a response like this:

   network={
    ssid="your_network_name"
    #psk="your_password"
    psk=6a24edfec4d204601b6e1f409630702...
   }
   
   

   Delete the line with your password in plaintext, then use this in place of the network={…} block in the wpa_supplicant.conf file and you should be good to go. The wpa_supplicant.conf file can contain network blocks for multiple networks, so if you want to add your home network as well, you can. On startup, the Pi will go through the list and try to connect to each one in turn, stopping when it succeeds. So if you have two networks available in one location, then make sure to put the default one first.

   CONFIGURING FOR AN ENTERPRISE NETWORK

   For connecting to an enterprise network using PEAP with MSCHAPv2 authentication, you can configure the wpa_supplicant.conf file as follows:

   1. Open the wpa_supplicant.conf file for editing:
      bash

      sudo nano /etc/wpa_supplicant/wpa_supplicant.conf

   2. Delete any existing network blocks if present.
   3. Add the following configuration for the PEAP network:
      makefile

      network={
ssid="YOUR_NETWORK_SSID"
key_mgmt=WPA-EAP
eap=PEAP
identity="YOUR_USERNAME"
password="YOUR_PASSWORD"
phase1="peaplabel=0"
phase2="auth=MSCHAPV2"
}


      Replace YOUR_NETWORK_SSID with the SSID (name) of the enterprise network, YOUR_USERNAME with your network username, and YOUR_PASSWORD with your network password.

   4. Save the changes and exit the text editor.
   5. Restart the networking service to apply the changes:
      sudo systemctl restart networking.service


      Alternatively, you can reboot the Raspberry Pi.

   With this configuration, the Raspberry Pi will attempt to connect to the enterprise network using PEAP with MSCHAPv2 authentication. Make sure to replace the placeholder values (YOUR_NETWORK_SSID, YOUR_USERNAME, and YOUR_PASSWORD) with your actual network credentials.

   ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
   update_config=1
   country=US
   
   network={
     ssid="network_name"
     key_mgmt=WPA-EAP
     eap=PEAP
     proto=WPA2
     phase2="auth=MSCHAPV2"
     anonymous_identity="your_username"
     identity="your_username"
     password=your_password
   }
   
   

   To generate an encrypted hash for the password in the wpa_supplicant.conf file, follow these steps:

   1. Open a terminal on your Raspberry Pi.
   2. Run the following command to generate the password hash:
   3. Replace YOUR_NETWORK_SSID with the SSID (name) of your network, and YOUR_PASSWORD with your network password. The command will output a block of text that includes the encrypted password hash.
   4. Copy the generated encrypted password hash.
   5. Open the wpa_supplicant.conf file for editing:
   6. Locate the network block for your network, and replace the password line with the encrypted password hash you copied earlier. It should look like this:
      1. Replace YOUR_ENCRYPTED_PASSWORD_HASH with the encrypted password hash generated in step 2.
      2. Save the changes and exit the text editor.
   7. By replacing the password line with the encrypted password hash, you ensure that your password is not stored in plaintext in the wpa_supplicant.conf file.

      Remember to replace YOUR_NETWORK_SSID and YOUR_PASSWORD with your actual network credentials when running the commands.

   Once you have set up the network configuration in the wpa_supplicant.conf file and saved it, your Raspberry Pi should start scanning for networks and attempt to connect. You can check if you are connected by following these steps:

   1. Open a terminal on your Raspberry Pi.
   2. Run the following command to check the network interface configuration:
      ifconfig wlan0


      This command will display the network interface details, including the IP address assigned to your Pi’s wireless interface (wlan0).

   3. Additionally, you can run the following command to check the wireless configuration:
      iwconfig wlan0


      This command will provide information about your wireless interface, including the SSID (network name), signal strength, and other wireless parameters.

   By running these commands, you can verify that your Raspberry Pi is connected to the network using the configured WiFi settings.

   Please note that the specific network interface name (wlan0) may vary depending on your system configuration.

   Connecting Via WiFi and ssh

   To connect to your Raspberry Pi via WiFi and SSH, make sure you have already created the ssh file and the wpa_supplicant.conf file as mentioned earlier. Once your Pi has booted up and connected to the configured network, follow these steps to establish an SSH connection from your personal computer:

   1. Ensure that your personal computer is connected to the same WiFi network as your Raspberry Pi.
   2. Open the command line interface or terminal on your personal computer.
   3. Type the following command to establish an SSH connection to your Raspberry Pi:
      lua

      ssh pi@your-pi-ip-address


      Replace your-pi-ip-address with the IP address assigned to your Raspberry Pi on the WiFi network. If you don’t know the IP address, you can find it by running the ifconfig command on your Pi or checking your router’s DHCP lease table.

   4. Press Enter and enter the password for the user pi (or the custom user you have created) when prompted. Note that while typing the password, no characters will be displayed on the screen for security reasons. Press Enter again to confirm.

   If the IP address and credentials are correct, you should establish an SSH connection to your Raspberry Pi. From there, you can remotely manage and configure your Pi using command-line tools and utilities.

   Note: If you have modified the default SSH port (22) on your Raspberry Pi, you need to specify the port number in the SSH command using the -p option, like this: ssh -p your-ssh-port pi@your-pi-ip-address. Replace your-ssh-port with the actual SSH port number you have configured.

   Please ensure that you have properly set up the SSH and WiFi configurations on your Raspberry Pi before attempting to connect.

   ssh [email protected]

   Alternately, you can use the IP address of your Pi if you know it, instead of raspberrypi.local. You should get a response like this:

   [email protected]'s password:

   Enter your password and you’ll be logged in.

   Testing Your Network Connection with curl

   You can test your network connection by making a web request. The command line program curl is a good way to do this. Type:

   $ curl http://www.example.com
   

   You should get a response that includes a lot of HTML,
   ending with the following:

   <body>
    <div>
    <h1>Example Domain</h1>
    nts. You may use this
    domain in examples without prior coordination or asking
    for permission.</p>
    <p><a href="http://www.iana.org/domains/example">More
    information...</a></p>
    </div>
    </body>
    </html>

   If you got this result, your Raspberry Pi is now connected to the internet.

   Deleting Your History File

   At this point you have entered some sensitive information on the command line (like your passwords) and it gets saved in a file called .bash_history. To see this file, type:

   $ sudo less ~/.bash_history

   You can view and edit the command history file in order to remove any sensitive information. Follow these steps to open the file using the nano text editor and delete specific lines:

   1. In the command line interface, type the following command to open the command history file:
      bash

      nano ~/.bash_history

   2. The nano text editor will open, displaying the contents of the command history file. Scroll through the file using the arrow keys until you locate the line(s) you want to delete.
   3. Move the cursor to the beginning of the line you want to delete and press Ctrl-K to cut the line.
   4. Repeat the previous step for any other lines you want to remove.
   5. Once you have deleted the desired lines, press Ctrl-X to exit nano.
   6. Nano will prompt you to save the changes. Press Y to confirm the change and save the modified file.

   By following these steps, you can remove any sensitive command lines from the command history file to mitigate the risk of exposing sensitive information.

   Note: It’s important to be cautious when deleting lines from the command history file, as it permanently removes them from the record. Make sure you only delete the lines that contain sensitive information and not any necessary or useful commands.

   Updating the Operating System

   To ensure that your operating system is up to date and includes the latest patches, you can perform a system upgrade using the APT package manager. Follow these steps:

   1. Open the command line interface on your Raspberry Pi.
   2. Update the list of available software packages by running the following command:
      sql

      sudo apt-get update


      This command retrieves the latest package information from the Raspbian package repository.

   3. Once the package list is updated, you can proceed with upgrading the installed packages by running the following command:
      arduino

      sudo apt-get upgrade


      This command upgrades all installed packages to their latest versions.

   4. The upgrade process may take some time, depending on the number of packages and the internet speed. Follow the on-screen prompts, if any, to confirm the upgrade and allow the installation to proceed.
   5. Once the upgrade is complete, you can also perform a distribution upgrade to update to the latest version of the operating system by running the following command:
      arduino

      sudo apt-get dist-upgrade


      This command performs a more comprehensive upgrade that takes care of package dependencies and handles major updates.

   By following these steps, you can ensure that your operating system is upgraded to the latest version and has all the necessary patches and updates installed.

   $ sudo apt update

   You should get this message at the end:

   Reading package lists... Done

   If you get an error, check your network connection. The most likely error is that it didn’t get all the updates because it didn’t have a network connection. If it says you don’t have enough disk space, make sure you expanded the filesystem using raspi-config earlier. When you’ve updated the package lists, Type:

   $ sudo apt upgrade

   This will upgrade any installed software packages. This will take even longer than the update, and will ask you to confirm that you want to upgrade all the software. Type y to do so. Once this is complete, you’ll have the latest versions of all the tools in your Raspbian distribution.

   Configuring a Firewall

   When it comes to securing your Raspberry Pi’s network connections, setting up a firewall is a recommended practice. Firewalls help control incoming and outgoing network traffic by specifying rules for allowing or blocking connections on specific ports. Follow the steps below to set up a basic firewall configuration:

   1. Open the command line interface on your Raspberry Pi.
   2. Install the ufw (Uncomplicated Firewall) package by running the following command:
      arduino

      sudo apt-get install ufw

   3. Once ufw is installed, you can start configuring the firewall rules. By default, ufw denies all incoming connections and allows all outgoing connections.
   4. To allow incoming SSH connections on port 22, run the following command:
      sudo ufw allow 22

   5. To allow incoming HTTP connections on ports 80 and 443, run the following command:
      sudo ufw allow 80
sudo ufw allow 443

   6. If you need to allow incoming connections on port 8080 (common for node.js servers), run the following command:
      yaml

      sudo ufw allow 8080

   7. Once you have added the necessary rules, enable the firewall by running:
      bash

      sudo ufw enable


      This command will activate the firewall and start enforcing the configured rules.

   8. To verify the status of the firewall and check the rules, you can use the command:
      lua

      sudo ufw status


      This will display the current firewall status and list the allowed ports.

   By following these steps, you can set up a basic firewall configuration that allows specific incoming connections on selected ports while blocking all other incoming traffic. Remember to adjust the firewall rules according to your specific requirements, adding or removing ports as needed.

   First you need to install ufw. Assuming you’ve updated your package manager, start by installing ufw:

   $ sudo apt install ufw

   Once it’s installed, you can set defaults to allow outgoing traffic and deny incoming:

   $ sudo ufw default allow outgoing
   $ sudo ufw default deny incoming

   This would disconnect your ssh connection if you enabled it now, so you might want to enable ssh connections before you enable the firewall. The following line will enable TCP connections on port 22, the default ssh port:

   $ sudo ufw allow ssh

   If you’re planning to run an HTTP server, or an HTTPS server, you’ll need to enable them as well. You can specify not only the application (http, https), but also the transport protocol, like so:

   $ sudo ufw allow http/tcp
   $ sudo ufw allow https/tcp

   More specific rules ensure that someone won’t try a sneaky attack like flooding UDP packets through your open HTTP ports. If you’re planning to do custom server development, you might want to enable the ports you’ll use for that as well. These settings are typical for node.js development. 

   $ sudo ufw allow 8080/tcp
   $ sudo ufw allow 8081/tcp

   Port 8081 is used by the p5.serialserver, which is common at ITP.

   If you plan to use VNC to connect to the Pi desktop remotely, you’ll need to enable port 5900 as well.

   Once you’ve configured your firewall, you enable it like so:

   $ sudo ufw enable

   You should reboot once you do this, to check that everything is in order. Once enabled, you can get a status report from ufw like so:

   $ sudo ufw status

   You should get a reply like this:

   Status: active
   
   To                         Action      From
   --                         ------      ----
   22/tcp                     ALLOW       Anywhere                  
   80/tcp                     ALLOW       Anywhere                  
   443/tcp                    ALLOW       Anywhere                  
   8080/tcp                   ALLOW       Anywhere                  
   8081/tcp                   ALLOW       Anywhere                  
   22/tcp (v6)                ALLOW       Anywhere (v6)             
   80/tcp (v6)                ALLOW       Anywhere (v6)             
   443/tcp (v6)               ALLOW       Anywhere (v6)             
   8080/tcp (v6)              ALLOW       Anywhere (v6)             
   8081/tcp (v6)              ALLOW       Anywhere (v6)  
   

   Now you’ve got a reasonably secure setup for a networked device.

   Updating your Programming Environment

   To ensure you have the necessary programming tools installed on your Raspberry Pi, follow the steps below:

   1. Open the command line interface on your Raspberry Pi.
   2. Install Node.js by running the following command:
      arduino

      sudo apt-get install nodejs


      This command will install Node.js, a popular development environment for networked applications.

   3. Install npm (Node Package Manager), which is bundled with Node.js, by running the following command:
      arduino

      sudo apt-get install npm


      npm allows you to easily manage and install additional Node.js packages and libraries.

   4. Install Git, a version control system, by running the following command:
      arduino

      sudo apt-get install git


      Git is widely used for software version management and collaboration.

   5. Once the installations are complete, you can verify that Node.js and Git were installed successfully by checking their versions. Run the following commands:
      css

      node -v
git --version


      These commands will display the installed versions of Node.js and Git, respectively.

   By following these steps, you will have installed Node.js, npm, and Git on your Raspberry Pi, providing you with the necessary programming tools for developing networked applications. Remember to perform these installations using the appropriate user account you have created to ensure proper configuration and access rights.

   To check if any software tool is already installed, you can use the which command like so:

   $ which git

   You’ll get a reply like so:

   /usr/bin/git

   If you get no reply, then the software is not installed. You can check if the software is listed in the package repository like so:

   $ sudo apt-cache show packageName

   Replace packageName with the name of the package you’re looking for. If it’s there, you’ll get all the details on it, and you can install it using apt-get, like you’ll do for git next.  Install git like so:

   $ sudo apt install git

   This will automatically install the version of git that’s listed in the Raspbian package list.

   Upgrading node.js

   In this section, you’ll remove the installed version of node.js from the Rasbpian distribution and upgrade  to a more modern version. First, remove all node and npm files already on your Pi. These instructions come from this gitHub repo. Note that node.js stopped support for the processor on the Pi Zero as of version 12.0.0, so you’ll use an older version:

   $ wget -O - https://raw.githubusercontent.com/sdesalas/node-pi-zero/master/install-node-v16.3.0.sh | bash

   Check the version of node.js that you installed like so:

   $ node --version

   You should get this reply:

   v16.3.0

   Now you’ve got a working, reasonably secure Pi, and a programming environment with which to program it. Congratulations! Finally, reboot or shutdown:

   $ sudo reboot

   or

   $ sudo poweroff

   Back Up Your Custom Installation

   At this point you may want to make a copy of the SD card using Etcher as you did at the beginning. Then you’ll have a customized image on which you can build other things. Since you’ll likely customize your system further for each application, it’s helpful to have a base installation from which to start. The ApplePiBaker app makes it easy for MacOS users to do backups simply.

   Remote File Access

   Remote file editing can be a pain on a Pi. If you’re using Visual Studio Code, here’s a set of instructions for the remote VSCode plugin that works well on the Pi. They have to be on the same network, but it can make editing much easier. Here’s the summary version:

   • Install Visual Studio Code on your personal computer and run it
   • Click the Extensions icon in the right side toolbar and search for Remote VSCode. Install it and relaunch VS Code.
   • On your Pi, install rmate like so:

   $ sudo wget -O /usr/local/bin/rmate https://raw.github.com/aurora/rmate/master/rmate
   
   $ sudo chmod a+x /usr/local/bin/rmate

   • In VS Code, Open the command palette (CTRL+P for Windows, CMD+P for MacOS) and type

   >Remote: Start Server

   • This will start the VSCode live share server.
   • Get your Pi’s IP address.
   • Now open the terminal pane in VS code (CTRL+` for MacOS and Windows) and type (replace PI_IP_ADDR with the Pi’s IP address):

   $ ssh -R 52698:localhost:52698 PI_IP_ADDR
   

   • This will log your computer into your Pi. You can then use rmate to open and edit files. For example, if there’s a file called myFile.txt, you can edit it by typing

   $ rmate myFile.txt

   • The file will open in VSCode, and you can edit and save, and it’ll automatically get saved on the Pi. Simple!