DEV Community: Olumide Nwosu

Streamlining Node.js App Deployment with GitHub Actions and Railway

Olumide Nwosu — Mon, 17 Jul 2023 08:44:00 +0000

Deploying Node.js applications efficiently and reliably is crucial for modern development workflows. Thankfully, the process has become much more streamlined with the advent of powerful automation tools and cloud platforms.

By harnessing the capabilities of the combination of GitHub Actions and Railway, developers can not only streamline the deployment of their Node.js applications but also establish a seamless continuous delivery pipeline.

This powerful combination can simplify and automate the deployment of Node.js applications, incorporating Continuous Integration/Continuous Delivery|Deployment (CI/CD) practices. In my last article, I shed more light on Continuous Integration with GitHub Actions in Node.js apps.

Continuous Delivery enables frequent and reliable releases by automating the entire software release process, from code changes to production deployment. Continuous Deployment takes it a step further by automatically deploying the changes to the production environment once they pass the necessary tests and checks.

In this article, we will walk through the step-by-step process of setting up GitHub Actions and Railway for our Node.js application deployments, covering everything from initial setup to defining the deployment workflow and ultimately, deploying our application seamlessly.

Now, let's dive in and explore how GitHub Actions and Railway can help us spend more time on coding and less on infrastructure management.

GitHub Actions: Automate GitHub workflows

GitHub Actions makes it easy to automate, customize, and execute our software development workflows right in our GitHub repositories. It allows developers to create custom workflows that automate various tasks, including building, testing, and deploying code changes. These workflows are defined in YAML files and can be triggered by events such as code pushes, pull requests, and issue comments.

Some of the key features of GitHub Actions include:

Easy integration with GitHub repositories.
Support for a wide range of programming languages and frameworks.
Ability to run workflows on different operating systems and virtual environments.
Support for custom actions and third-party integrations.
Detailed logs and reporting to help diagnose issues and track progress.

Railway: Deploy apps to production effortlessly

Railway is a powerful platform made to make managing and deploying applications easier. It is a platform that offers programmers a quick and effective way to ship their projects. It takes care of the hassles associated with infrastructure setup, freeing developers to concentrate on developing code. With just a few commands or configuration steps, developers may easily launch their apps using Railway. It provides one-click deployments, which makes it simple to distribute programs across various environments. Railway takes away the specifics of the infrastructure, making deployment simple. It seeks to give developers a simple method for quickly deploying their apps to the cloud without having to worry about complex infrastructure arrangements.

Here are a few standout features that make Railway the top choice for hosting applications:

Zero-downtime deploys: Applications can be deployed without any downtime, or according to their Home Page, +99% uptime.
Lightning-fast builds: Railway uses Docker to build applications, so builds are lightning-fast. This means that new code can be shipped quickly and easily.
Real-time logs and metrics: Railway provides real-time logs and metrics for applications, making it easy and quick to troubleshoot problems.
Config as Code: Railway allows for automation of deployments and infrastructure management with code, improving consistency.
Secrets management: Developers have the ability to maintain separate development, staging, and production environments while securely managing secrets.
Usage-based pricing: Resource usage is billed based on actual usage, eliminating the need for over-provisioning and allowing for more efficient cost management.

GitHub Actions + Railway: Control app deployments

Although it is possible to link a GitHub repository directly to a Railway project for automatic deployment whenever changes are pushed, making use of GitHub Actions provides several advantages, such as:

Customization: GitHub Actions and a workflow file offer flexibility and customization options to tailor the CI/CD pipeline to specific requirements. For instance, a workflow could be set up for multiple branches, or different triggers(push or pull request).
Integration with Testing and Build Processes: GitHub Actions seamlessly integrates with testing frameworks and build processes. We can incorporate automated tests, code quality checks, and build steps into our workflow. This integration ensures that all changes are thoroughly tested and validated before deployment.
Extensive Ecosystem of Actions: GitHub Actions has a vast ecosystem of pre-built actions that can be incorporated into workflows. These actions cover a wide range of functionalities, such as deploying to various platforms, running tests in different environments, and interacting with external services. Leveraging these actions simplifies the deployment process and extends the capabilities of our workflow.

Prerequisites

To follow through in this article, the following have to be put in place:

A GitHub Account
A Node.js Repository
A Railway Account

Creating a Project on Railway

After creating a Railway account, we need to create a project.

First, click on the New Project button.

Next, create an empty template.

Getting an Authentication Token

After creating our project, we need to obtain a token with which will communicate to Railway from GitHub. To do that we need to follow these steps:

Navigate to the project settings.
Click on the Tokens tab.
Create a new token. We can call it whatever we want. Here, it's called GITHUB_TOKEN .
Copy the newly created token.

Adding Authentication Key to GitHub

For the purpose of this article, we will be making use of this repository: gh-actions-demo. This was the project that was used for this article: Implementing Continuous Integration for Node.js Apps with GitHub Actions. We will also be adopting the workflow file of this project.

Now, to add the authentication token we got from the previous section to GitHUb we need to follow the following steps:

Go over to the repository's settings.
Click on Secrets and variables, and then on Actions.
Next, click on the New repository secret button.
Add the authentication token and set the name as RAILWAY_TOKEN.

It should show the newly added token as one of the repository's secrets.

Adding Our Workflow File

Now that we've put our Railway token in place, we can now create the workflow that triggers the deployment of changes to the server. Currently, our main.yml file looks like this:

`main.yml`



name: Node.js CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v3
    - name: Use Node.js 14
      uses: actions/setup-node@v3
      with:
        node-version: 14
        cache: 'npm'

    - run: npm install
    - run: npm test

At this stage, all this workflow basically does is to install our app's dependencies and to test the app. To account for the deployment process as well, we'll be adding the following snippet to our workflow file:



- name: Install Railway # 1
  run: npm i -g @railway/cli

- name: Deploy # 2
  run: railway up
  env:
    RAILWAY_TOKEN: ${{ secrets.RAILWAY_TOKEN }} # 3

The first command is responsible for installing the railway CLI which will be used to carry out the deployment.
The second command is the one that actually initiates the deployment.
For the whole deployment process, Railway needs to know that we have authorization and so it checks for the RAILWAY_TOKEN . This is why we needed to add it as a repository secret.

NOTE: Railway CLI works with Node.js 16+, so we'll be changing that as well.

After making these, our workflow file should now look like this:

`main.yml`



name: Node.js CI/CD

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v3
    - name: Use Node.js 16
      uses: actions/setup-node@v3
      with:
        node-version: 16
        cache: 'npm'

    - run: npm install
    - run: npm test

    - name: Install Railway
      run: npm i -g @railway/cli

    - name: Deploy
      run: railway up
      env:
        RAILWAY_TOKEN: ${{ secrets.RAILWAY_TOKEN }}

Now we will commit these changes and push them to GitHub to trigger the deployment workflow. After pushing the changes, a green checkmark should be visible on the repository which denotes that our workflow ran successfully.

Similarly, when we navigate to our project on Railway, we should see that the deployment was successful.

Making our App Public

At this juncture, the app has been deployed but it is still not visible to everybody. This means that we need to generate a domain for it so that anybody with a link can visit our app. This can be done by following these steps:

Click on Settings to go the project's settings.
Click on Generate Domain.

A link should be generated.

Click on the link and it should return the expected response.

Conclusion

In conclusion, the combination of GitHub Actions and Railway offers a powerful solution for streamlining the deployment of Node.js applications. By integrating these two platforms, developers can automate the entire CI/CD pipeline, reduce manual effort, and ensure consistent and reliable deployments.

With GitHub Actions, developers have the flexibility to define custom workflows, automate build and test processes, and seamlessly integrate with various tools and services.

Implementing Continuous Integration for Node.js Apps with GitHub Actions

Olumide Nwosu — Mon, 29 May 2023 13:34:45 +0000

Have you been building and deploying apps without putting Continuous Integration(CI) in place? Well, this is a sign to turn a new leaf.

As a developer, it is important to make sure that high-quality code is shipped at all times. As a result, CI is a must-have practice. It may drastically shorten the time it takes to deploy new features and updates while also boosting the software's integrity and stability.

In this article, we'll explore how to add Continuous Integration to a Node.js project with GitHub Actions.

What exactly is Continuous Integration?

Continuous integration (CI) is the process of automatically building and testing code changes as soon as they are committed to the repository. This helps catch errors and bugs early on in the development process before they can cause bigger issues down the line.
Gitlab's Article on CI/CD sheds more light on this topic.

The following are some reasons why it's essential to use CI in software applications:

It provides faster feedback on code changes, allowing for issues to be caught and fixed earlier in the development process.
It improves the reliability of products by catching errors and bugs before they reach production.
It improves security by automatically running security tests and scans as part of the development process.

What is GitHub Actions?

GitHub Actions provides a platform for automating software workflows, including Continuous Integration. It allows developers to create custom workflows that automate various tasks, including building, testing, and deploying code changes. These workflows are defined in YAML files and can be triggered by events such as code pushes, pull requests, and issue comments.

Some of the key features of GitHub Actions include:

Easy integration with GitHub repositories
Support for a wide range of programming languages and frameworks
Ability to run workflows on different operating systems and virtual environments
Support for custom actions and third-party integrations
Detailed logs and reporting to help diagnose issues and track progress

Prerequisites

To follow through in this article, we need the following installed on our computer:

Creating our Node.js App

To demonstrate how to add Continuous Integration with GitHub Actions, we'll create a simple Node.js application. To do this, we'll follow these steps:

Initialize a Node.js project locally.

$ mkdir gh-actions-demo
$ cd gh-actions-demo

Initialize as a Node.js project and add necessary .dependencies

$ npm init
$ npm i express
$ npm i --save-dev jest supertest

Add/replace the following snippet in the package.json file.

  "scripts": {
    "test": "jest",
    "start": "node src/index.js"
  },
  "jest": {
    "testEnvironment": "node",
    "coveragePathIgnorePatterns": [
      "/node_modules/"
    ]
  },

Create a repository on GitHub.
Link the local project to the GitHub repository

$ echo "# <REPOSITORY_NAME>" >> README.md
git init
git add README.md
git commit -m "first commit"
git branch -M main
git remote add origin https://github.com/<USERNAME>/<REPOSITORY_NAME>.git
git push -u origin main

Next, we'll be adding the following four files to the project.

`src/app.js`

This is the app object. We have separated it to be able to test it properly.

'use strict';
const express = require('express');

// App
const app = express();
app.get('/hello', (req, res) => {
  res.status(200).json({
    message: "Hello World!"
  });
});

module.exports = { app };

`src/index.js`

This is the entry point of the app. The server will be housed here.

const { app } = require('./app');

const PORT = 8080;
app.listen(PORT, () => {
  console.log(`Running on http://localhost:${PORT}`);
});

`src/index.test.ts`

This file contains a test. The purpose of this test is to make sure that our app works as it should.

const request = require('supertest');
const { app } = require('./app');

describe('/hello', () => {
  it('returns `Hello World!`', async () => {
    const data = await request(app).get('/hello');
    expect(data.statusCode).toBe(200);
    expect(data.body.message).toBe('Hello World!');
  });
});

`.gitignore`

Now we don't want to spend the whole day uploading node_modules to GitHub, do we? I didn't think so.

node_modules

We can also test that the app works by running npm start and/or npm test.

Setting up GitHub Actions for our Node.js project

Now that we have our Node.js app, we can add GitHub Actions to our project. We'll create a new YAML file in the .github/workflows directory to define our workflow. Our workflow will consist of two jobs: building and testing our code and deploying our app to a staging environment.
To set up CI/CD for a Node.js project using GitHub Actions, follow these steps:

Create a .github/workflows directory in the project's root directory.

$ mkdir .github/workflows

Next, create main.yaml, a YAML file in the workflows directory to define the workflow. This workflow will specify the steps for building, testing, and deploying our code changes.

`main.yml`

name: Node.js CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v3
    - name: Use Node.js 14
      uses: actions/setup-node@v3
      with:
        node-version: 14
        cache: 'npm'

    - run: npm install
    - run: npm test

This workflow gets initiated whenever pull requests or commits are made to the main branch. It could also be modified to include more branches, or if the workflows for other branches are different, then we can create separate YAML files.

Push changes to GitHub to trigger the workflow. If all goes well, the workflow should run successfully. A green checkmark should appear beside the commit message on GitHub as shown below:

Adding a workflow status badge

The next course of action is to add a workflow status badge to our repository. This can be done by adding the following link to our README.md:

![Main Workflow](https://github.com/<OWNER>/<REPOSITORY>/actions/workflows/<WORKFLOW_FILE>/badge.svg)

In this case, the URL is:

![Main Workflow](https://github.com/olumidayy/gh-actions-demo/actions/workflows/main.yml/badge.svg)

If done properly, this adds a little badge to our README.md, like the one below:

Conclusion

Implementing Continuous Integration for Node.js apps with GitHub Actions can help streamline development workflows, reduce errors, and increase efficiency.

With the steps outlined in this article, we can easily set up a basic CI pipeline for our Node.js app, automating our testing process and ensuring that our code is always up to par.

By using GitHub Actions, we can focus on writing high-quality code while the platform takes care of the rest. I hope I've been able to convince you to turn a new leaf today! ;)

Automated Deployments for Node.js Apps with Github Actions and Railway

Olumide Nwosu — Tue, 23 May 2023 23:59:56 +0000

What I built

I built a task manager that helps keep track of your tasks. It helps to:

Users can create, edit, and delete tasks.
Users can assign tasks to themselves or to other users.
Users can view a list of all their tasks.
Users can view a list of all their tasks that are due today.
Users can view a list of all their tasks that are overdue.

Category Submission: DIY Deployments

App Link: Live Link

Screenshots

Link to Documentation

Description

A Task Manager for keeping track of pending, in-progress, or completed tasks.

Link to Source Code

Code on GitHub

Permissive License

Link To License

Background (What made you decide to build this particular app? What inspired you?)

I recently started working with GitHub actions for continuous integration and I stumbled upon this hackathon. I saw this as opportunity to work on using Gihub Actions for Automatic deployments.

How I built it (How did you utilize GitHub Actions or GitHub Codespaces? Did you learn something new along the way? Pick up a new skill?)

I used GitHub for both Continuous Integration and Deployment/Delivery. As can be seen in the workflow file, main.yml, Github Actions helps to install dependencies, test the code, and push changes to the remote server. This saves developers the hassle of manual deployments and cuts delivery time considerably. It also helped me learn a new way to utilize Github actions the right way.

name: Node.js CI

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3
      - name: Use Node.js 16
        uses: actions/setup-node@v3
        with:
          node-version: 16
          cache: 'npm'

      - name: Install Dependencies
        run: npm i

      - name: Run Tests
        run: npm t

      - name: Fix Linting Issues
        run: npm run lint:fix

      - name: Install Railway
        run: npm i -g @railway/cli

      - name: Deploy
        run: railway up
        env:
          RAILWAY_TOKEN: ${{ secrets.RAILWAY_TOKEN }}

A few reasons why this is helpful and should be normal practice are:

It provides faster feedback on code changes, allowing for issues to be caught and fixed earlier in the development process.
It improves the reliability of products by catching errors and bugs before they reach production.
It encourages collaboration between developers, testers, and other stakeholders, leading to a more effective development process.
It improves security by automatically running security tests and scans as part of the development process.
It increases agility by allowing developers to quickly make code changes and deploy them to production.

Building a Console Word Game with Python

Olumide Nwosu — Tue, 04 May 2021 17:04:22 +0000

A while back, during the time I started learning to code with Python, I wrote a program for a game that is quite similar to Hangman. A particular number of guesses is given and then the user tries to guess the letters of the secret word. The user loses one guess for each incorrect try and the game ends either when the user has guessed all the letters of the word completely or when they run out of guesses.

Getting into it

There are probably a million ways to go about writing this game but since this is my article, we will be doing it my way😁.

We want our game to look like what we have below:

You've chosen a/an 9-letter word!
Guess a letter: e
Good guess!
Guesses left:  9
Available letters:  a b c d f g h i j k l m n o p q r s t u v w x y z
---E--E--
Guess a letter: l
Good guess!
Guesses left:  9
Available letters:  a b c d f g h i j k m n o p q r s t u v w x y z
---E-LE--
Guess a letter: l
You have already guessed this letter!
Guess a letter:
...........................................

So now let's think about the structure.

We need a secret word which the user tries to guess. We could easily do this by picking a random word from a list of words.
The user has 9 guesses or tries which only decrease when a user guesses wrongly.
When a user enters a guess, we have to check if the letter is in our secret word. If the letter has been guessed already, we let the user know, and as the kind developers that we are, we don't reduce their guesses😉.
After each guess, the user is told how many guesses they have left and the letters that haven't been tried yet. They're also shown the word with the letters that have been guessed correctly and the rest of the letters are replaced with dashes i.e. if the word is BANANA and only 'A' has been guessed correctly, -A-A-A is shown.
We should also always check if the user has run out of guesses so that the guesses don't start counting in negatives😅.
The game ends either when the user has been able to successfully guess the secret word, or when they run out of guesses.
Some edge cases to consider are; when a user enters an invalid guess, e.g. a number, or when they enter more than one character at once.

Having considered all these, the code for our game will be split into five separate functions/methods.

play_game
check_guess
can_be_formed_from
display_info
format_word

play_game

This is the entry point of our game. This is where the user is prompted for their guess. The necessary checks are then carried out. To ensure that our game is bug-less.

import random as r

guesses = 9
letters = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')


def format_word(guessed_letters, word):
    pass


def display_info(guessed_letters, word):
    pass


def check_guess(guess, word, guessed_letters):
    pass


def can_be_formed_from(letters, word):
    pass


def play_game():
    word_list = ['programmer', 'python', 'defenestrate']
    secret_word = r.choice(word_list)
    word_length = len(secret_word)
    guessed = []
    print(f'You have chosen a/an {word_length}-letter word.')
    while guesses > 0:
        guess = input('Enter a letter: ')
        guess = guess.upper()
        check_guess(guess, secret_word, guessed)
        if can_be_formed_from(guessed, secret_word):
            return print('YOU WON!')
    print('You ran out of guesses.\nYOU LOST!')

As we can see from above, a random word is chosen from a list of words(you can extend your list or fetch a bunch of words online), and then we do the user the courtesy of telling them how long it is. Then as long as the number of guesses is greater than zero, we keep prompting the user for a guess. The check_guess function(which we'll get to in a moment) is then called to validate our guess and add it to guessed which contains all the letters that have been tried. The can_be_formed_from function is also called to check if the secret_word can be formed from all the guessed letters. If it can, the user wins🎉. On the other hand, if the user runs out of guesses the game is ended. It would mean the user has lost, sadly😔. But as Nelson Mandela once said:

You never lose, you either win or learn.

check_guess

This function takes in the guessed letters, the
secret word and the new guess. It checks if the
guess is valid and prints the appropriate message if it's not. The display_info function is then called.

def check_guess(guess, word, guessed_letters):
    global guesses
    if guess in letters and len(guess) == 1 and guess not in guessed_letters:
        guessed_letters.append(guess)
        if guess in word:
            print('Good guess!')
        else:
            print('Bad guess!')
            guesses -= 1
    else:
        if len(guess) != 1:
            print('You must enter one letter, no more, no less!')
        elif guess.upper() not in letters:
            print('Your guess has to be a letter!')
        elif guess in guessed_letters:
            print('This letter has been tried already!')
    display_info(guessed_letters, word)

A seen above, the following checks are performed:

If the guess is valid i.e. a letter of the English alphabet(This game can be tweaked to work with any language).
If the guess contains exactly one letter.
If the guess is present in our secret word.
If the letter entered has been tried already.

can_be_formed_from

As the name implies, this function accepts two strings and returns True if the second string can be formed from the letters of the first else False.

def can_be_formed_from(letters, word):
    for letter in word:
        if letter not in letters:
            return False
    return True

display_info

This function takes in the guessed letters and the secret word and generates the required data i.e. the number of guesses left, the letters that haven't been
tried yet etc. from the provided data.

def display_info(guessed_letters, word):
    available_letters = ' '.join([
        letter for letter in letters if letter not in guessed_letters
    ])
    print(format_word(guessed_letters, word))
    print(f'Guesses left: {guesses}.')
    print(f'Available letters: {available_letters}.')

format_word

This function helps to format our secret word with the letters that have been guessed correctly. For example, if the secret word is PYTHON and only 'n', 'o' and 'p' have been guessed correctly, P---ON is displayed.

def format_word(guessed_letters, word):
    formatted_string = ''
    for letter in word:
        if letter in guessed_letters:
            formatted_string += letter
        else:
            formatted_string += '-'
    return formatted_string

Putting all this together, we have:

word_game.py

import random as r

guesses = 9
letters = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')


def format_word(guessed_letters, word):
    formatted_string = ''
    for letter in word:
        if letter in guessed_letters:
            formatted_string += letter
        else:
            formatted_string += '-'
    return formatted_string


def display_info(guessed_letters, word):
    available_letters = ' '.join([
        letter for letter in letters if letter not in guessed_letters
    ])
    print(format_word(guessed_letters, word))
    print(f'Guesses left: {guesses}.')
    print(f'Available letters: {available_letters}.')


def check_guess(guess, word, guessed_letters):
    global guesses
    if guess in letters and len(guess) == 1 and guess not in guessed_letters:
        guessed_letters.append(guess)
        if guess in word:
            print('Good guess!')
        else:
            print('Bad guess!')
            guesses -= 1
    else:
        if len(guess) != 1:
            print('You must enter one letter, no more, no less!')
        elif guess.upper() not in letters:
            print('Your guess has to be a letter!')
        elif guess in guessed_letters:
            print('This letter has been tried already!')
    display_info(guessed_letters, word)


def can_be_formed_from(letters, word):
    for letter in word:
        if letter not in letters:
            return False
    return True


def play_game():
    word_list = ['programmer', 'python', 'defenestrate']
    secret_word = r.choice(word_list).upper()
    word_length = len(secret_word)
    guessed = []
    print(f'You have chosen a/an {word_length}-letter word.')
    while guesses > 0:
        guess = input('Enter a letter: ')
        guess = guess.upper()
        check_guess(guess, secret_word, guessed)
        if can_be_formed_from(guessed, secret_word):
            return print('YOU WON!')
    print('You ran out of guesses.\nYOU LOST!')


if __name__ == '__main__':
    play_game()

Conclusion

By separating our code into small functions, it made building our game feel like a walk in the park. I hope this read was helpful to you😊. The full source code can be found here. Also, the OOP approach for our game can be found here. Feel free to ask questions here or reach on Twitter @OlumideNwosu.