Forem: Bogdan Covrig

Code of Conduct Notifier Action: 2021 GitHub Actions Hackathon

Bogdan Covrig — Mon, 06 Dec 2021 19:03:36 +0000

The challenge of managing online communities is continuously growing. Often times the members are spread across multiple platforms, making it harder to get a complete snapshot of its members' interactions and behavior. While platforms employ different tools and methods to moderate (potentially harmful) conversations, the moderators' priority will always be to create a safe and positive community experience for everybody.

This Action aims to help just a little bit the GitHub communities moderators into enforcing their Code of Conduct.

My Workflow

For this year's 2021 GitHub Actions Hackathon, I have built a simple GitHub Action that notifies the members of the community of their Code of Conduct document when this is mentioned. The Action will reply to issues and pull requests comments when the keywords code of conduct are mentioned, helping the maintainers to quickly share the Code of Conduct document without going back and forth copy-pasting URLs. The Action will take care of this part.

Submission Category:

Maintainer Must-Haves

Yaml File or Link to Code

The action is a composite action built on tope of the github-script@v5 action, using its functionality to retrieve and post comments in the GitHub issues and pull requests. The YAML file of the action is available in the repository under action.yml

More information and examples are available in the repository of the action BogDAAAMN/code-of-conduct-notifier-action. If you want to get started and use the action, you can visit the GitHub Marketplace page: Code of Conduct Notifier.

bogdaaamn / code-of-conduct-notifier-action

Simple Action that reminds the members of your community about the Code of Conduct

Additional Resources / Info

The information presented in the description of the action, the inspiration, and the default messages used by the action are shaped from the following sources:

Constellation Report: State of Community Tools 2021 by @Orbit
Mozilla Community Participation Guidelines by Mozilla Corporation
Feedback and conversations with @VirtualCoffee friends

Content Sentiment Analysis: Explore the emotion score of your content with Google API

Bogdan Covrig — Sat, 22 Aug 2020 16:32:22 +0000

My Workflow

I spent a few nights wrapping Google's analyzeSentiment API into a GitHub Action. The Action runs Sentiment Analysis over the content of HTML files and provides an overview of the overall emotion of all (the selected) pages in your project.

The API returns values from -1 to 1, indicating how strong a certain emotion – positive or negative – is. After running the Action, a table with the score per each page is printed in its logs. Read more about Interpreting sentiment analysis values.

Along with other content analysis tools, it might come in handy to maintainers who want to understand the text that is pushed to the project every day. See it in action 🚀

⚠️ Now I got really excited about this and will continue developing along with other automation ideas that I have. This being an early release of the Action, please take a look at the roadmap and submit issues with what kind of features you would like to see in future releases.

Submission Category:

Maintainer Must-Haves

Yaml File or Link to Code

Here is an example of how to use the Action on public .html files.

name: Sentiment analysis on public

on: push

jobs:
  analysis:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2 #Be sure you checkout the files beforehand
    - name: Run sentiment analysis on HTML files
      uses: bogdaaamn/copy-sentiment-analysis@v0.6.1
      with: 
        gcp_key: ${{ secrets.GCP_KEY }} #Google Cloud Platform API key. Read the README for instructions

Along with the code – more examples, requirements and a known issues roadmap are available in the bogdaaamn/copy-sentiment-analysis repository (view it on Marketplace).

bogdaaamn / copy-sentiment-analysis

Run sentiment analysis over the text of your website using Google API.

Copy Sentiment Analysis

This GitHub Action runs Sentiment Analysis over the built text of your GitHub project. It uses Google's analyzeSentiment API, evaluating the overall emotion score (from positive to negative) of a page. The Action provides an overview of the scores of all the pages from your project (more on interpreting the scores).

🚀 Usage

This is a workflow example of using the Action on plain .html files from the public folder (by default).

name: Sentiment analysis on public

on: push

jobs:
  analysis:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2 #Be sure you checkout the files beforehand
    - name: Run sentiment analysis on HTML files
      uses: bogdaaamn/copy-sentiment-analysis@v0.6.1
      with: 
        gcp_key: ${{ secrets.GCP_KEY }} #Google Cloud Platform API key. Read the README for instructions

Although, if you project needs to be built beforehand, be sure you place…

View on GitHub

Additional Resources / Info

Open source use cases

At the moment, the overview table is printed in the Actions tab, after the code is running. But it seems counter-intuitive and having too much friction in between.

I am curious about what the community thinks: How would you see this Action printing the results? A comment to the PR? A table in Action's log? Failing if there are too many negative results?

⚠️ GCP's bias in sentiment analysis

A few years ago, Google API was criticized in the media for producing bias results towards race, gender, and religion. So I had mixed feelings about using a pre-trained model in this Action.

Now, it is hard to understand what is going on with Google's proprietary algorithm and how they fight unwanted bias, but more recent research (see charlescearl, 2019) concluded that GCP seems to be less sensitive to the race or gender of participants than other competitor platforms. The same article recommends that users should proceed with caution and conduct evaluations on their own. The tests that I've done had neutral results, but I am ready to expand my research and pull the plug if needed.

Moreover, there is extraordinary research done towards identifying, analyzing, and diminishing bias in data (see Dixon et al., 2018 from Google Research or Caliskan et al., 2016 and May et al., 2019) and all I hope is that Google (or really any cloud provider out there) is doing better and better. I believe it is really important to enable and support bias and fairness research – especially now, after the recent upbringing of GPT-3 (see Burus, 2020) when the society gets exposed more and more to technology.

Sources

Contribute to Forem 🌱 in Gitpod on your own fork

Bogdan Covrig — Mon, 27 Jul 2020 13:34:30 +0000

To follow-up on @ben's post, Gitpod allows you to spin up Forem's codebase on the cloud and makes it available to you in the browser. Really, a fully working local instance in your browser. Within minutes.

Spin up a "local" instance of DEV in the cloud with GitPod (It's incredibly simple)

Ben Halpern ・ Apr 8 '19

#contributorswanted #gitpod #opensource #docker

If you already tried to spin up Forem on Gitpod as the documentation describes, most probably you couldn't push the changes. That is perfectly normal; contributors are not allowed to (and they shouldn't) push changes directly into the original repo.

remote: Permission to forem/forem.git denied to BogDAAAMN.
fatal: unable to access 'https://github.com/forem/forem/': The requested URL returned error: 403

The solution is to push the changes to your Forem fork instead. The fastest way to do that is to change the origin of the project. Gitpod allows that in a bunch of ways.

Option 1. Good old `git remote`

If you take a quick look at the remote right after Gitpod's initialization, the origin is pointing to the Forem repository. If you push now, naturally, the changes go to the origin.

$ git remote -v
origin  https://github.com/forem/forem.git (fetch)
origin  https://github.com/forem/forem.git (push)

To work this out, fire up a terminal in Gitpod and set the origin to your Forem fork (assuming you already have one).

$ git remote set-url origin https://github.com/<YOUR_USERNAME>/forem
$ git remote -v
origin  https://github.com/<YOUR_USERNAME>/forem.git (fetch)
origin  https://github.com/<YOUR_USERNAME>/forem.git (push)

Cool, from now on you will push your commits to the new origin – your fork.

You still need to add the Forem repository as upstream because you will need to pull and fetch the latest changes from forem/forem.

$ git remote add upstream https://github.com/forem/forem
$ git remote -v
origin    https://github.com/<YOUR_USERNAME>/forem.git (fetch)
origin    https://github.com/<YOUR_USERNAME>/forem.git (push)
upstream  https://github.com/forem/forem.git (fetch)
upstream  https://github.com/forem/forem.git (push)

Option 2. Gitpod UI

A visual approach to changing the origin to your fork is to use the Gitpod UI Git panel (left side toolbar). Click on the Git button. If the remote repository is set to forem/forem and you don't have the right to push changes, a yellow warning will appear stating that You don't have push permissions for forem/forem.

A quick fix is to click on the Fork button.

Gitpod's command palette will pop up, asking you to Switch to existing fork.

If you didn't fork the Forem repo yet, you will have to provide access to Gitpod to create one. Then you will be able to switch to the freshly created one.

Cool, now wait for confirmation. Once the prompt (bottom right-hand side) says that the remote was successfully changed to your fork, you are good to go! Gitpod took care of changing the remote of the repo for you.

Option 3. Your fork instance on Gitpod

As explained in the community forum, Gitpod will fire up any repository URL you provide.

If you already forked Forem, you can simply paste your repo URL into https://gitpod.io/#<URL>. Gitpod will clone your fork and spin up the Forem local instance in your browser.

https://gitpod.io/#https://github.com/<YOUR_USERNAME>/forem

Finale

Comment for #2321

benhalpern commented on Apr 07, 2019

This is absolutely amazing, I've been dreaming of making this happen.

@jankeromnes just sign the CLA and this is good to go.

View on GitHub

I absolutely love Gitpod for removing a lot of friction from running Forem on my machine. Pretty awesome how it makes it possible to fiddle with the code within minutes. It helps a lot if you always mess up trying to install the right Ruby version locally :)

However, there are still issues and bugs that the community encountered while trying to work on Gitpod. Fell free to Pull Request along!

continue button on ¨onboarding welcome message¨ is not working #9195

akhil-naidu posted on Jul 08, 2020

Issue: continue button on ¨onboarding welcome message¨ is not working

Platform: Gitpod Oauth: Github

Did I miss configuring something?

View on GitHub

Incorrect node version used in GitPod #8849

Amorpheuz posted on Jun 23, 2020

Describe the bug Creating a new GitPod instance leads to a bug where under gem install solargraph; bin/setup && bin/startup the bin/setup script fails at yarn install due to incorrect node version being used (which is 12.18.x).

The GitPod Dockerfile does handle the installation of nvm and correct node version, but forgets to switch to the correct node version (12.16.3).

To Reproduce

Create a GitPod Workspace with https://gitpod.io/#https://github.com/thepracticaldev/dev.to
Wait till bundle install finishes in the third workspace/dev.to tab completes.
Yarn throws the error as indicated in screenshot below.

Expected behavior Correct node version is selected in nvm, which allows the yarn install command to complete successfully.

Screenshots

Desktop (please complete the following information):

OS: Windows 10
Browser: Edge
Version: 83

Additional context The nvm use command can be of help.

View on GitHub

Love 🌱🌱

Getting started with Google Cloud Functions on Firebase

Bogdan Covrig — Tue, 26 Feb 2019 00:11:05 +0000

You know what they say. In a world full of serverless, deploy... serverless. So, of course, I will do my part. Working on a small project that requires only static pages, the biggest struggle was to find a way to gather feedback from the users (through a static form). My first thought was to build a small API that gets the data from the form and stores it in a database. But the traffic on the website is not that heavy, so I didn't see a point to serve an API for 24/7 just for a few requests per week.

The most popular solution that I encountered was, of course, serverless. There are plenty of approaches with AWS Lambda or Netlify. But my static pages were already deployed on Firebase Hosting, so I had to give a try to the Google Cloud Functions for Firebase.

Advantages

@adnanrahic does a great job explaining serverless pros and cons (bonus a comparison with containers).

Containers vs. Serverless from a DevOps standpoint

Adnan Rahić ・ Sep 8 '18

#devops #serverless #kubernetes #aws

For this specific project, a serverless architecture is a perfect match: easy to write, deploy and maintain. There is no infrastructure to care about, I can write them in my favorite language using my favorite packages and I can even test them locally. Convenient.

Getting started

There is no need to set up or scale a server, we will just write the functions and deploy them to Firebase. They will be triggered only when the requests are called.

At this very moment, Google Cloud Functions can be written in Node.js (v6 or v8), Python (beta) or Go (beta). I will proceed further with Node.js and some additional resources such as Express and CORS.

1. Install Node.js

Make sure that you have Node.js and npm properly configured before you start because we will write the functions in Node.js.

Some people will recommend you nvm to install and managed Node.js versions.

nvm-sh / nvm

Node Version Manager - POSIX-compliant bash script to manage multiple active node.js versions

Node Version Manager

Intro

nvm allows you to quickly…

View on GitHub

But if you can use the graphical instructions as well.

2. Configure Firebase

Sign up or sign in to the Firebase console and create a new project. Doesn't really matter, but I called mine dev-form-entries.

Now, setup your project locally.

First, install globally Firebase CLI.

npm install -g firebase-tools

Now create a local folder for your project.

mkdir dev-form-entries
cd dev-form-entries

While in the project folder, login to Firebase.

$ firebase login
Success! Logged in as me@tld.com

Let's initialize our first Firebase project (you can actually run firebase init and add the functions later).

firebase init functions

Select a default Firebase project for this directory: dev-form-entries
What language would you like to use? JavaScript
We will use Javascript now. Typescript will work too.
Do you want to use ESLint to catch probable bugs? No
Neat option, but not needed right now.
Do you want to install dependencies with npm now? Yes
Run that npm install to install firebase-functions and firebase-admin for you.

Ok, so let's see what we've got

firebase.json for configuring Firebase Hosting,
.firebaserc for configuring multiple projects,
functions/index.js is the boilerplate provided by Firebase. We will get back to that soon.

3. Configure Realtime Database

Not too much to configure here, because it will be initialized programmatically. But I want to mention them before it's too late.

As I mentioned before, I wanted to store all the data in a database. Firebase has two great out-of-the-box databases that you can use, Realtime Database and Cloud Firestore. Both of them are highly scalable and flexible (I will get to this later) but I choose to use Realtime Database because it doesn't need any sort of pre-configuration, we will just reference it from the code.

@aurelkurtula might give you a glimpse of the Realtime Database's greatness.

Introduction to firebase's real-time database

aurel kurtula ・ Dec 9 '17

#firebase #javascript #database

Deploying to Firebase

Hello from Firebase

Let's start with Firebase's hello world. Edit functions/index.js and keep their example.

const functions = require('firebase-functions');

// Create and Deploy Your First Cloud Functions
// https://firebase.google.com/docs/functions/write-firebase-functions

exports.helloWorld = functions.https.onRequest((request, response) => {
    response.send("Hello from Firebase!");
});

This function will create a route /helloWorld and it will respond with Hello from Firebase! on each request.

Deploy it

Now, your first deployment.

firebase deploy --only functions

Or you can run just firebase deploy since the project contains only one function at this moment.

=== Deploying to 'dev-form-entries'...

i  deploying functions
i  functions: ensuring necessary APIs are enabled...
✔  functions: all necessary APIs are enabled
i  functions: preparing functions directory for uploading...
i  functions: packaged functions (42.53 KB) for uploading
✔  functions: functions folder uploaded successfully
i  functions: updating Node.js 6 function helloWorld(us-central1)...
✔  functions[helloWorld(us-central1)]: Successful update operation. 

✔  Deploy complete!

Now that your deployment is complete, you can go to your Firebase console and find your function.

That's a neat Dashboard. You can check the health and read the logs of your functions. You can get redirected to Google Cloud Platform to see the full details and quotas.

Test it

I will use Postman to test the functions. Postman is a nice tool to test your APIs, I will cover only the super basics today, but you check @harshitrathod's beginner guide or take a deep look into it, by Going beyond with Postman with @jlozovei.

Introduction to Postman REST client

Harshit rathod ・ Nov 13 '17

#tutorial #beginners

As seen in the dashboard, my function's route is https://us-central1-dev-form-entries.cloudfunctions.net/helloWorld. I will paste it in Postman and make a GET request.

Writing the API

Ok, so now you know where to write, deploy and test the code. Let's try to do something real.

Warming up

Express and CORS

As little helpers for our great goal, we will use Express (for the middleware and nicer routes writing) and CORS (for enabling all CORS requests, if you're not familiar with it, take a look at some of the @effingkay's CORS concepts).

Article No Longer Available

First, you will need to install them, so pop into your terminal

npm install --save express cors

and add them at the top of your index.js file.

const express = require('express');
const cors = require('cors');

Right after, create an instance of Express and write the middleware that will accept all the CORS requests.

const app = express();
app.use(cors());

You will use the app instance to write the routes and you will export it as a Google Cloud Function, as you did with the helloWorld one. So write the new one right after the helloWorld exports.

exports.entries = functions.https.onRequest(app);

This will create an /entries function. All the routes that we will write for the app instance will be available in the entries function.

Realtime Database

In order to use the Realtime Databases, you will need to import and initialize it.

const admin = require('firebase-admin');
admin.initializeApp();

POST entries

I would normally start with the GET route, but we need the entries before we can get them. So you will write the POST route to push data to the database.

A basic example of an Express POST / route is

app.post('/', (request, response) {
  // send stuff...
});

The fun thing about Realtime Database is that it is fully flexible, so you don't need to design a whole structure beforehand. Since it stores the data as one JSON tree, we can push a JSON structure and it will be enough. Of course, there needs to be validation involved if all the fields are pushed to the database, but this a nice talk for another time.

So the entry that will be stored in the database will be the body of the request itself.

const entry = request.body;

The way data is pushed to the database is

return admin.database().ref('/entries').push(entry);

/entries being the path to the database reference.

The push function returns a promise that we will use to validate and send the response. On fulfilled, we will return the entry pushed and 200 status code. Otherwise, catch and send the error as an Internal Server Error.

return admin.database().ref('/entries').push(entry)
    .then(() => {
        return response.status(200).send(entry)
    }).catch(error => {
        console.error(error);
        return response.status(500).send('Oh no! Error: ' + error);
    });

At the very core of it, that's it!

After a quick deploy, I take it in Postman and make a POST request to /entries.

name:John Doe
subject:dev.to
message:Hello dev.to!

If you browse to your Firebase console, under Database you will be able to see all the entries.

GET entries

To get all the data for the database, we will use

admin.database(...).ref(...).on(...)

that will return through a callback all the entries that exist.

This is actually a listener function, so each time there is a new entry in the database, it will be called (cool if you have a static page to monitor those entries).

No promises this time, just a callback that returns the value in a snapshot.

app.get("/", (request, response) => {
    return admin.database().ref('/entries').on("value", snapshot => {
        return response.status(200).send(snapshot.val());
    }, error => {
        console.error(error);
        return response.status(500).send('Oh no! Error: ' + error);
    });
});

Calling it in Postman I got a JSON with all the entries.

{
    "-LZadZujD5Qb1MrQvAd_": {
        "message": "Hello, dev.to!!!",
        "name": "John Doe",
        "subject": "dev.to"
    },
    "-LZaeMZYJjQ2weey6k7H": {
        "message": "Hello dev.to!",
        "name": "Jess Doe",
        "subject": "dev.to"
    },
    "-LZaeQc8DAOn0A6B1Gzc": {
        "message": "Hello dev.to!",
        "name": "Jane Doe",
        "subject": "dev.to"
    }
}

Sticking everything together

If you deploy them, you can monitor the functions from the dashboard.

But note that you will not be able to see the quotas for each route if you write them for the same instance of an Express app.

Testing the functions locally

It would be a pain in the ass to deploy to Firebase all the small changes just to test them. Firebase allows you to test all these functions locally.

firebase serve --only functions

This will serve your functions locally, just use the links generated in your terminal.

✔  functions: entries: http://localhost:5000/dev-form-entries/us-central1/entries
✔  functions: helloWorld: http://localhost:5000/dev-form-entries/us-central1/helloWorld

Finale

That's really not much at all. This is just a glimpse of the greatness of Serverless APIs, Google Cloud Functions and Realtime Databases on Firebase. There are other ways to deal with data (such as deleting or updating it). There is a lot of validation and security layers that you should add on top of these.

That's the basics that I want to share, I am actually considering writing a whole series about Serverless APIs on Firebase, while I document myself on the topic. Please let me know how are you using Firebase and what fancy stuff are you doing with all the features.

Love!

Run your Node.js application on a headless Raspberry Pi

Bogdan Covrig — Sun, 17 Feb 2019 18:41:48 +0000

Recently I've got a little piece of hardware (Raspberry Pi 2 Model B) on my desk. Rather than have it sit on its ass all day, I got a little Node.js application up and running through Nginx.

Get that Raspberry Pi up and running

A headless install doesn't require any kind of extra hardware (such as screens or keyboard), so everything that you need is the Raspberry Pi itself, a microSD (or SD, depending on your hardware) card and an internet connection (wired or wireless, again depending on your Raspberry).

1. Get the Raspbian Stretch image

Raspbian is the most optimized OS for Raspberries and I use it when I need a minimum and fast setup. Just go the official website and download the latest version of Raspbian Stretch Lite.

2. Burn that image

Insert your card in your PC and burn the Raspbian image on it.

I followed these instructions (Linux/Windows also available) because I prefer using my terminal, but Etcher (a graphical alternative on steroids) is also available on all platforms.

3. Enable headless SSH connections

SSH is not enabled by default in Raspbian, so you will have to do it before you boot the card for the first time.

After the installation, go to boot/ and create a file called ssh (no extension).



touch ssh

4. Boot that Raspberry Pi

Insert the card, the power source, and the network cable. After the green LEDs stop blinking, your Raspberry Pi is good to go!

5. Find that Raspberry Pi

So you have power, network and an OS, no keyboard, no screen. How do you connect to the Raspberry Pi?

In order to SSH into it, you will have to find it in your network first. Supposing that you connected the Raspberry to your home network, you can see all the devices (MAC and IP addresses) in your LAN from the ARP table. Simply run in your terminal (working on all platforms)



arp -a

and you will find your Raspberry Pi right there.



fritz.box (192.168.178.1) on en1 ifscope [ethernet]
raspberrypi.fritz.box (192.168.178.73) on en1 ifscope [ethernet]

In my case, fritz.box is my router and right after is my Raspberry Pi. So from now on, I will connect to it through 192.168.178.73 address.

More about ARP tables and how you should find your devices there.

Understanding ARP at the MAC layer

Khoa Pham ・ Sep 21 '18

#arp #mac #ip

6. Finally SSH into that Raspberry Pi

The default credentials are



username: pi
password: raspberry

SSH into the Raspberry Pi. On Mac or Linux you can just simply run


 bash
ssh pi@192.168.178.73

while on Windows are a few alternatives such as Putty or the default config on Cmder.

Get your Node.js application up and running

You are in! You should get your Node.js application up, so the following steps are run through SSH, on your Raspberry Pi.

1. Install Node.js on Raspbian

There are a lot of ways to install Node.js on a Linux machine, but I always follow NodeSource's instructions, being the safest way I ever did.

For Node.js v11.x I ran



sudo apt-get update
curl -sL https://deb.nodesource.com/setup_11.x | bash -
sudo apt-get install -y nodejs

Anyways, curl -sL https://deb.nodesource.com/setup_11.x | bash - will provide more instructions if you need more tools or add-ons.

Check if Node.js and npm are installed properly.



$ node -v
v11.10.0

$ npm -v
6.7.0

For other versions or troubleshooting take a look to NodeSource's comprehensive docs. Raspbian is a Debian based OS, so look for Debian instructions.

nodesource / distributions

NodeSource Node.js Binary Distributions

NodeSource N|Solid & Node.js Binary Distributions

This repository contains the instructions to install the NodeSource N|solid and Node.js Binary Distributions via .rpm and .deb as well as their setup and support scripts.

If you're looking for more information on NodeSource's low-impact Node.js performance monitoring platform, Learn more here.

New Update ⚠️

We'd like to inform you of important changes to our distribution repository nodesource/distributions.

What's New:

Package Changes: DEB and RPM packages are now available under the nodistro codename. We no longer package the installer coupled to specific versions. This means you can install Node.js on almost any distro that meets the minimum requirements.
Installation Scripts: Back by popular demand, the installation scripts have returned and are better than ever. See the installation instructions below for details on how to use them.
RPM Package Signing Key: The key used to sign RPM packages has changed. We now sign…

View on GitHub

If you choose to write or paste the code, quickly install vim, it will make our lives easier and later I will walk you through, don't worry.



sudo apt-get update
sudo apt-get install vim -y

2. Get your Node.js app

Write, copy-paste or clone the Node.js application. For testing purposes, I created app.js file.



cd ~
vim app.js

I pasted the following boilerplate



const http = require('http');

const PORT = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello dev.to!\n');
});

server.listen(PORT, () => {
  console.log(`Server running on port ${PORT}.`);
});

If vim is too overwhelming you can try to use other ways as nano. But just to be sure, this is a really quick follow-up:

Open (or create) the file with vim app.js.
Now, vim is in the normal mode and it's waiting for your command. Press i to go in the insert mode, this will allow you write code.
Type or paste your code now, exactly how you'd do it in your editor.
If you're done writing, press esc so you go back to the normal mode so you can command vim to save and exit.
Usually, vim commands start with :. Gently press : followed by w for writing and q for quitting. You can actually see the commands that you're typing on the bottom of your terminal. Press enter to acknowledge the commands.
Taa-daaaaa. app.js is saved.

If you want to do more crazy tricks with vim, follow-up this beginner guide and you will see that vim is not that bad.

Vim for starters - the minimum you need to know

Hamza Tamenaoul ・ Dec 25 '17

#vim #linux #terminal #beginners

3. Finally run the Node.js application

Run



$ node app
Server running at 127.0.0.1 on port 3000.

and your Node.js app will run on localhost:3000/.

Because none of the ports are opened by default, you can test the app only from your Raspberry Pi. Open a new tab of the SSH connection and run



curl localhost:3000

and you should get



Hello dev.to!

4. Install PM2

Of course that you want your application daemonized (in background) and of course that you want your application to start when the system is restarting. PM2 will provide all of this.

Stop your Node.js application (ctrl + C) and proceed to installation.

We will use npm to install PM2 globally -g.



sudo npm install -g pm2

Start the application with PM2

To start app.js with PM2 run


 bash
pm2 start app.js

and you should see



[PM2] Starting /home/pi/app.js in fork_mode (1 instance)
[PM2] Done.
┌──────────┬────┬─────────┬──────┬─────┬────────┬─────────┬────────┬─────┬───────────┬──────┬──────────┐
│ App name │ id │ version │ mode │ pid │ status │ restart │ uptime │ cpu │ mem       │ user │ watching │
├──────────┼────┼─────────┼──────┼─────┼────────┼─────────┼────────┼─────┼───────────┼──────┼──────────┤
│ app      │ 0  │ N/A     │ fork │ 738 │ online │ 0       │ 0s     │ 0%  │ 21.8 MB   │ pi   │ disabled │
└──────────┴────┴─────────┴──────┴─────┴────────┴─────────┴────────┴─────┴───────────┴──────┴──────────┘

Now app.js is daemonized running. You can test it as we did before with curl localhost:3000.

Bonus: if the app crashes, PM2 will restart it.

PM2 startup

The pm2 startup command will generate a script that will lunch PM2 on boot together with the applications that you configure to start.



pm2 startup systemd

will generate



[PM2] Init System found: systemd
[PM2] To setup the Startup Script, copy/paste the following command:
sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u pi --hp /home/pi

Copy the generated command and run it.



sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u pi --hp /home/p

This created a system unit that will start PM2 on boot. When the system will boot PM2 will resurrect from a dump file that is not created yet. To create it run



pm2 save

This will save the current state of PM2 (with app.js running) in a dump file that will be used when resurrecting PM2.

That's it! Your application is currently running and in case of a restart, it will start when the system boots.

PM2 daemon

You will be able to check anytime the status of your application with pm2 list, pm2 status or pm2 show.



$ pm2 list
┌──────────┬────┬─────────┬──────┬─────┬────────┬─────────┬────────┬──────┬───────────┬──────┬──────────┐
│ App name │ id │ version │ mode │ pid │ status │ restart │ uptime │ cpu  │ mem       │ user │ watching │
├──────────┼────┼─────────┼──────┼─────┼────────┼─────────┼────────┼──────┼───────────┼──────┼──────────┤
│ app      │ 0  │ N/A     │ fork │ 451 │ online │ 0       │ 96m    │ 0.2% │ 31.8 MB   │ pi   │ disabled │
└──────────┴────┴─────────┴──────┴─────┴────────┴─────────┴────────┴──────┴───────────┴──────┴──────────┘



$ pm2 show app
┌───────────────────┬──────────────────────────────────┐
│ status            │ online                           │
│ name              │ app                              │
│ version           │ N/A                              │
│ restarts          │ 0                                │
│ uptime            │ 97m                              │
│ script path       │ /home/pi/app.js                  │
│ script args       │ N/A                              │
│ error log path    │ /home/pi/.pm2/logs/app-error.log │
│ out log path      │ /home/pi/.pm2/logs/app-out.log   │
│ pid path          │ /home/pi/.pm2/pids/app-0.pid     │
│ interpreter       │ node                             │
│ interpreter args  │ N/A                              │
│ script id         │ 0                                │
│ exec cwd          │ /home/pi                         │
│ exec mode         │ fork_mode                        │
│ node.js version   │ 11.10.0                          │
│ node env          │ N/A                              │
│ watch & reload    │ ✘                                │
│ unstable restarts │ 0                                │
│ created at        │ 2019-02-17T14:14:35.027Z         │
└───────────────────┴──────────────────────────────────┘

There is a lot of greatness within PM2 that you can use, read more about logs and processes below.

Running PM2 & Node.js in Production Environments

Nick Parsons ・ Aug 6 '18

#pm2 #node #processmanagement

Make use of a Reverse Proxy

As I mentioned before, none of the ports on your devices are publicly open yet, so you cannot access your Raspberry Pi from the outer world. There are a ton of reason why you should or shouldn't use a reverse proxy for your Node.js application. Because of scalability and security reasons (and also is really simple to setup and manage), I will use Nginx as a Reverse Proxy Server for this application.

0. Don't use a Reverse Proxy :(

If you plan to use a Reverse Proxy don't follow this step otherwise you will mess up the ports (like having 80 and 3000 opened at the same time).

An uncomplicated way to go without a Reverse Proxy is to use ufw to allow some of the ports to allow incoming traffic. But note that this might be a big security flaw.

Install it by running



sudo apt-get install ufw

A quick sudo ufw status verbose will show us that ufw is currently inactive. Before you enable it, you should allow all the SSH traffic to your device, so the connection is not disturbed.



$ sudo ufw allow ssh
Rules updated
Rules updated (v6)

Now you can enable it.



sudo ufw enable

Another quick sudo ufw status verbose will show that all incoming SSH traffic is allowed. All the outgoing traffic is allowed, so don't worry about it. Now just go on and allow connections on 3000, the port of your application.



sudo ufw allow 3000

Now you can access from the outside of the world! You can type your device's address followed by the port in your browser.

1. Install NGINX

I used Nginx as a Reverse Proxy Server to redirect all the traffic to/from port 80 to my application, on port 3000. Install Nginx running



sudo apt update
sudo apt install nginx

After the installation, Nginx will be running right away. The default port opened is 80 and you can test it by browsing to your Raspberry's address.

2. Configure the Reverse Proxy Server

There is a lot to say about Reverse Proxies, but we will stick to basics now.

You will edit the default configuration (that serves the HTML page that you saw in your browser) to make the proper redirects.



sudo vim /etc/nginx/sites-available/default

If you are not familiar to Nginx, /etc/nginx/sites-available/default is a long, confusing file. I will get rid of all the comments so you can see it better.



server {
        listen 80 default_server;
        listen [::]:80 default_server;

        root /var/www/html;

        index index.html index.htm index.nginx-debian.html;

        server_name _;

        location / {
            # First attempt to serve request as file, then
            # as directory, then fall back to displaying a 404.
            try_files $uri $uri/ =404;
            # proxy_pass http://localhost:8080;
            # proxy_http_version 1.1;
            # proxy_set_header Upgrade $http_upgrade;
            # proxy_set_header Connection 'upgrade';
            # proxy_set_header Host $host;
            # proxy_cache_bypass $http_upgrade;
        }
}

You will need the basic configuration, therefore leave it be. You will make changes to location / { block.

Uncomment the commented section inside that block, change the port to 3000, get rid of the first lines and that exact configuration is a Reverse Proxy (or just copy the following code).



server {
        listen 80 default_server;
        listen [::]:80 default_server;

        root /var/www/html;

        index index.html index.htm index.nginx-debian.html;

        server_name _;

        location / {
            proxy_pass http://localhost:3000;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection 'upgrade';
            proxy_set_header Host $host;
            proxy_cache_bypass $http_upgrade;
        }
}

Check for syntax errors in Nginx with



sudo nginx -t

and finally restart the Nginx server.



sudo systemctl restart nginx

Test it out by browsing to your Raspberry's address.

Done! All the requests to your Raspberry's address will be redirected to your Node.js application.

Note that this is a basic configuration of Nginx, you can discover more about other features here.

Understanding nginx (proxying, reverse proxying, load balancing)

Osita Chibuike for Legobox ・ May 23 '18

#devops #showdev #linux #learning

Finale

Now you are done! So you got a Node.js application running (daemonized) on a headless Raspberry Pi that deals with requests through an Nginx Reverse Proxy Server.

Hopefully, this was a comprehensive enough guide, but I am open to discussions and questions below. Let us know what you've experienced or what other alternatives you found on the way.

Forem: Bogdan Covrig

Code of Conduct Notifier Action: 2021 GitHub Actions Hackathon

My Workflow

Submission Category:

Yaml File or Link to Code

bogdaaamn / code-of-conduct-notifier-action

Simple Action that reminds the members of your community about the Code of Conduct

Additional Resources / Info

Content Sentiment Analysis: Explore the emotion score of your content with Google API

My Workflow

Submission Category:

Yaml File or Link to Code

bogdaaamn / copy-sentiment-analysis

Run sentiment analysis over the text of your website using Google API.

Copy Sentiment Analysis

🚀 Usage

Additional Resources / Info

Open source use cases

⚠️ GCP's bias in sentiment analysis

Sources

Contribute to Forem 🌱 in Gitpod on your own fork

Spin up a "local" instance of DEV in the cloud with GitPod (It's incredibly simple)

Ben Halpern ・ Apr 8 '19

Option 1. Good old git remote

Option 2. Gitpod UI

Option 3. Your fork instance on Gitpod

Finale

Comment for #2321

continue button on ¨onboarding welcome message¨ is not working #9195

Incorrect node version used in GitPod #8849

Getting started with Google Cloud Functions on Firebase

Advantages

Containers vs. Serverless from a DevOps standpoint

Adnan Rahić ・ Sep 8 '18

Getting started

1. Install Node.js

nvm-sh / nvm

Node Version Manager - POSIX-compliant bash script to manage multiple active node.js versions

Node Version Manager

Table of Contents

Intro

2. Configure Firebase

3. Configure Realtime Database

Introduction to firebase's real-time database

aurel kurtula ・ Dec 9 '17

Deploying to Firebase

Hello from Firebase

Deploy it

Test it

Introduction to Postman REST client

Harshit rathod ・ Nov 13 '17

Writing the API

Warming up

Express and CORS

Article No Longer Available

Realtime Database

POST entries

GET entries

Sticking everything together

Testing the functions locally

Finale

Run your Node.js application on a headless Raspberry Pi

Get that Raspberry Pi up and running

1. Get the Raspbian Stretch image

2. Burn that image

3. Enable headless SSH connections

4. Boot that Raspberry Pi

5. Find that Raspberry Pi

Understanding ARP at the MAC layer

Khoa Pham ・ Sep 21 '18

6. Finally SSH into that Raspberry Pi

Get your Node.js application up and running

1. Install Node.js on Raspbian

nodesource / distributions

NodeSource Node.js Binary Distributions

NodeSource N|Solid & Node.js Binary Distributions

New Update ⚠️

2. Get your Node.js app

Vim for starters - the minimum you need to know

Hamza Tamenaoul ・ Dec 25 '17

Option 1. Good old `git remote`