Install the Latest Node.js

sudo apt install nodejs

sudo apt install npm

sudo npm install n -g

For the latest stable version of Node JS:

sudo n stable

node --version

Install a Local Python from Source

sudo apt install -y make build-essential libssl-dev zlib1g-dev libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev libncursesw5-dev xz-utils tk-dev

To install dependencies.

What the following does: download source code, unpack it, make directory ~/.localpython to install into, run the configuration file setting install going to install folder, compile, install compilation, create a virtualenv pointing to the install, switch to the virtualenv to use it:

mkdir ~/src

cd ~/src

$ wget http://www.python.org/ftp/python/3.11.0/Python-3.11.0.tgz

$ tar -zxvf Python-3.11.0.tgz

$ cd Python-3.11.0

$ mkdir ~/localpython3110

$ ./configure --prefix=$HOME/localpython3110 --enable-optimizations

https://realpython.com/installing-python/#how-to-build-python-from-source-code

$ make &&make altinstall

Set Up venv

$ ~/localpython3110/bin/python3.11 -m venv py3110_venv

$ source py3110_venv/bin/activate

$ sudo apt install python3-pip -y

$ pip install --upgrade pip

$ pip install tk pillow numpy astropy astroplan pandas pytz matplotlib scikit-learn

$ pip list

$ pip -V

$ which python

$ pip install --upgrade pip

$ pip freeze --local > requirements.txt

$ deactivate

$ rm -rf somename_env

$ pip install -r requirements.txt

Note the venv folder stores neither the Python installation nor your code for your project. It is only used to store version information about the Python installation used for your project.

virtualenv instead of venv

I ran into a not-so-obscure reason to use virtualenv instead of venv. If you ever want to serve a Flask app using Apache or some other production server, virtualenv creates a file called activate_this, which Apache can use to run the Flask app in the appropriate Python environment.

sudo apt install python3-pip -y

pip install virtualenv

python3 -m virtualenv py31012_virtualenv

source py31012_virtualenv/bin/activate

pip install --upgrade pip

Install Packages from Local Folder

pip download package1 package2 -d'~/src/python-packages'

pip install package1 package2 -f ~/src/python-packages --no-index

Python Path

To see the path to the current python installation:

python -c 'import os, sys; print(os.path.dirname(sys.executable))'

To see the path variable in Windows (readable format):

PS > $env:path -split ';'

To login to a linux machine remotely:

ssh username@ipaddress

To see the version of Linux running:

cat /etc/os-release

printenv lists all environment variables

Print working directory:

pwd

Get IP address:

ifconfig or ifconfig | grep inet

See what ports are open:

netstat

List all users:

less /etc/passwd

List groups a user belongs to:

groups username or id username

List groups with their members:

getent group or getent group | grep searchsomething

To get the status, including rules being enforced, of the uncomplicated firewall:

sudo ufw status

To list all processes currently running;

ps aux | grep searchsomething

To find a particular file or directory from among all files:

sudo find / -name "searchsomething"

or for directory name search only:

sudo find / -type d -name "searchsomething"

To search for specific text within the files within the current directory:

grep -nr 'searchsomething*'

• $ is the normal prompt for commands
• # is the system administrator prompt
• in the C shell, the prompt ends with %
• > is used to send the output to a text file. >> is used to append the output to an existing text file without over-writing.
• $VARIABLE_NAME is a variable
• apt combines apt-get and apt-cache and it is newer. Use apt.
• sudo apt update && sudo apt upgrade -y
  • To install Python packages, use apt only if you want to install directly on the machine, otherwise use pip. Pip installs modules slower, but installs the latest versions, and most importantly works within a virtualenv. In the special case of Raspberry Pi, use apt because it knows the unique processor architecture and installs the correct builds of modules.
• script savedcommands.txt
• A .sh file is an executable shell script. # to comment within
• ./ is used to specify the current working directory especially when running something that could be the same as a system command.
• nano is the basic user-friendly text editor.
• To view $PATH, echo "${PATH//:/$'\n'}" or just echo $PATH
• To edit $PATH for the current session, export PATH='/new/directory:$PATH'
• > sends command output to a file. >> appends the output to a file without overwriting existing contents.
• ls -al shows all files in directory including hidden
• whatis is a brief explanation
• man gives a manual
• less is like cat, but one page at a time

Useful Linux Commands

At this point, you are using Linux. Either Raspberry Pi OS or Ubuntu are “flavors” of Linux. Having a list of basic commands is helpful:

40+ most used Ubuntu 22.04 Commands

Set up Firewall

sudo ufw allow OpenSSH

sudo ufw allow 22

sudo ufw allow 3306

sudo ufw default deny incoming

sudo ufw default allow outgoing

sudo ufw allow ssh

sudo ufw allow http or sudo ufw allow 80

sudo ufw allow https or sudo ufw allow 443

sudo ufw allow 'apache full'

sudo ufw show added

sudo ufw enable

Create Non-Root Super-User

This step appears complex and does not appear necessary especially this early in the process. Strictly speaking, it is indeed not necessary. You could skip this step and do everything as the root or default user that already exists. However, it is best to do this now because:

• to do things in the right order
• to highlight an important aspect of the Linux OS: that Linux is very user-specific and permissions-based. This makes Linux less intuitive at first but makes it secure enough to be accessed by many different anonymous people as a server without allowing hackers to access sensitive parts of the server.
• to avoid inevitable frustration later. Using Linux you will see “permission denied” errors periodically throughout your experience and you are better off expecting and troubleshooting them than believing that Linux is just annoying. Permissions are built-in to Linux from the ground up and it’s best to work with it rather than try to ignore it.
• Logging in as a non-root user is safer. For example, some installations of Ubuntu default to external root login disabled, which means for a remote server you would be locked out if this were set and you don’t have another user to login as.

sudo adduser new_username

usermod -aG sudo new_username

Change the password for the current user as desired with:

passwd

Grant all privileges to the user with the command

sudo visudo

and add a line in the /etc/sudoers file below the root user line: new_username ALL=(ALL:ALL)ALL

This only allows the user to give itself privileges. The user does not have all read/write privileges like the root itself. Log in as the new user through SSH.

Non-Root Super-User Gives Itself Read/Write Privileges

This sounds convoluted and it is when you are accustomed to dealing with desktop computers designed for convenience. Linux is designed for security.

Make a new group

sudo addgroup servermanager

and add the new user to the group

sudo adduser new_username servermanager

groups new_username

make the new group the owner of the required directories:

sudo chown -vR :servermanager /var/www/

sudo chown -vR :servermanager /etc/apache2/sites-available/

sudo chown -vR :servermanager /etc/apache2/sites-enabled

then modify the directory permission to be written by the owner group:

sudo chmod -vR g+w /var/www/ (add +x if you want to be able to develop in this directory)

sudo chmod -vR g+w /etc/apache2/sites-available

sudo chmod -vR g+w /etc/apache2/sites-enabled

(Useful Users and Permissions Commands)

Linux has a group and user structure to manage permissions and it is very useful to be able to view the current state:

List all users in the system:

cat /etc/passwd

List all groups on the system:

cat etc/group or less etc/group

or

getent group

for all members of a single group:

getent group group_name

check ownership of a directory, for example:

ls -ld /var/www/

check ownership of a file:

ls -l /var/www/

Find all the files owned by a particular user (may take some time):

sudo find / -user username

Change the active group for the session, possibly not:

newgrp servermanager

delete a group:

sudo groupdel group_name

delete a user (-r removes the user’s directory and mail spool):

sudo userdel -r username

search “linux octal permissions” to understand the numbering system.

Show all currently logged in users on a system:

w