How To Install Express.Js on Rocky Linux 9

Express.js is a minimalist yet powerful web framework for Node.js that helps developers create dynamic and efficient server-side applications. It boasts an approachable learning curve and offers a rich set of features through built-in middleware and a vibrant ecosystem of third-party libraries. Rocky Linux 9 is an excellent platform for hosting Express.js applications because of its stability, enterprise-grade reliability, and strong commitment to open-source development. This guide offers step-by-step instructions to ensure that your Express.js environment is set up correctly and optimized for performance, security, and maintainability, so you can focus on building robust applications with confidence.

System Requirements

Before installing Express.js on Rocky Linux 9, it is crucial to check your system’s requirements to guarantee a smooth setup. At a minimum, run Rocky Linux 9 on a server or local machine equipped with:

• CPU: A modern 64-bit dual-core processor or better
• RAM: 1 GB or more for smaller applications, but 2 GB is recommended for running Node.js applications comfortably
• Disk Space: At least 10 GB of available storage, ensuring enough room for logs and additional packages
• Network Connectivity: An active internet connection to fetch system updates and dependencies

Additionally, confirm that you have sudo privileges or an account with administrative permissions on your Rocky Linux 9 system. Having root access or a user in the sudo group is vital for installing required packages, configuring services, and managing firewall settings.

Preparing the Environment

Proper preparation of your Rocky Linux 9 environment is the bedrock for a successful installation of Express.js. By ensuring that all packages are up to date and the necessary development tools are in place, you lay the groundwork for a stable setup.

Update System Packages

1. Log in to your server using SSH or open a terminal on your local machine.
2. Update the package index to pull in the latest repository metadata:

sudo dnf update -y

Keeping your system up to date not only brings in the latest functionalities but also patches security vulnerabilities that could halt or compromise your Express.js application.

Install Development Tools

Although not strictly required for every use case, essential development tools can streamline compiling modules or libraries needed by Node.js or Express.js. Install them with the following command:

sudo dnf groupinstall 'Development Tools' -y

This command installs useful packages like gcc and make. These tools can prove helpful if you intend to build native Node.js modules or perform other compilation-related tasks.

Configure Firewall Settings

By default, many Rocky Linux 9 systems come with a firewall enabled. While it is an excellent practice to protect your server, you should allow traffic for HTTP (port 80) or HTTPS (port 443) if you rely on them for incoming requests. To permit incoming HTTP and HTTPS traffic, use:

sudo firewall-cmd --permanent --add-service=http
sudo firewall-cmd --permanent --add-service=https
sudo firewall-cmd --reload

Adjust these settings if your Express.js application needs to listen on a non-standard port.

Installing Node.js

Node.js is the runtime environment upon which Express.js depends. By installing Node.js, you gain access to the npm (Node Package Manager) utility, enabling you to install Express.js and thousands of other packages from the Node.js ecosystem. There are two popular methods for installing Node.js on Rocky Linux 9: either via the AppStream repository or through NodeSource repositories.

Installing Node.js via AppStream Repository

Rocky Linux 9 typically includes a stable Node.js release in its official repositories. To see which Node.js versions are available, you may run:

dnf module list nodejs

Choose the desired stream (for example, 16, 18, or 20) and install it using the following:

sudo dnf module enable nodejs:16 -y
sudo dnf install nodejs -y

Adjust accordingly if you prefer a different stream. The above commands will install Node.js along with npm.

Alternative: Installing the Latest Node.js from NodeSource

For developers who require newer versions of Node.js than what the official repositories offer, you can enable NodeSource’s repository. This method grants you access to cutting-edge Node.js releases.

1. Import the NodeSource repository setup script for your selected version (for instance Node 18):

   curl -sL https://rpm.nodesource.com/setup_20.x | sudo bash -
   

2. Install Node.js:

   sudo dnf install nodejs -y
   

After installing, verify the Node.js version:

node -v

You should also confirm that npm is installed:

npm -v

A successful installation ensures that you can proceed to the core step of installing Express.js.

Installing Express.js

Express.js is distributed via the npm registry, making installation straightforward. You can install it globally for system-wide access or locally per project to isolate dependencies. Most developers prefer local installation within a project folder for better project isolation. This setup ensures that each application has its own version of Express.js and required modules, preventing conflicts across different projects on the same server.

Global Installation of Express.js

To install Express.js as a global module, run:

sudo npm install -g express

Following a global install, you can quickly scaffold new applications using various CLI tools. However, a global install can intermix dependencies for multiple projects, so weigh the convenience against potential versioning pitfalls.

Local (Project-Specific) Installation

A local installation is recommended if you want to ensure your Express.js version remains consistent across deployments:

1. Create a new folder for your application and navigate to it:

   mkdir my-express-app
   cd my-express-app
   

2. Initialize a package.json file:

   npm init -y
   

   This command generates a new package.json with default settings.

3. Install Express.js locally:

   npm install express
   

Once installed, you will see an express folder under the node_modules directory, and dependencies listed in your package.json file.

Verifying the Installation

To confirm your setup, run the npm list express or npm list --depth=0 command in your application folder. You should see express listed, indicating that everything was installed properly.

Creating a Sample Express.js Application

A sample Express.js application is an invaluable way to verify your installation and explore the framework’s fundamental concepts. By constructing a basic server, you can test that your framework is functioning as expected and seamlessly responds to requests.

Set Up Your Project Directory

Begin by navigating to the folder you created earlier (my-express-app) or create a new directory for this demonstration. This workspace will hold your application files and any related assets.

Initialize package.json

If you haven’t already, ensure a package.json file exists by running:

npm init -y

This file keeps track of your application’s dependencies, scripts, and essential metadata like version and author.

Create a Basic Express.js Server

Add a new file named server.js:

vi server.js

Paste the following content into server.js:

const express = require('express');
const app = express();
const PORT = 3000; // You can change this to any port you prefer

app.get('/', (req, res) => {
  res.send('Hello from Express.js on Rocky Linux 9!');
});

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

This simple application creates a route for the root URL (/) and returns a greeting message. Adjust the port number to suit your environment or preferences.

Test the Express.js Application

1. From your project folder, start the server via:

node server.js

2. In your web browser or using a tool like curl, navigate to http://your-server-ip:3000 (or http://localhost:3000 if running locally). You should see the message “Hello from Express.js on Rocky Linux 9!”

Configuration and Optimization

A well-configured Express.js environment helps ensure smooth integration with your server, better performance, and maximum uptime. Below are some tips and strategies to consider.

Environment Variables Setup

Use environment variables to handle sensitive or environment-specific configuration, like API keys, database credentials, or third-party service tokens. Tools such as dotenv can help manage these variables:

npm install dotenv

Then, create a .env file in your project directory and load it in your application. This keeps your sensitive data out of the codebase and simplifies environment-based configurations.

Security Best Practices

To secure your Express.js application:

• Use Helmet, an npm package that sets HTTP headers to protect against well-known vulnerabilities.
• Keep all packages updated to patch security holes.
• Limit request payload size with built-in middleware, preventing denial-of-service or memory exhaustion attacks.

Performance Optimization

Consider these best practices for higher performance:

• Enable gzip compression with the compression middleware.
• Leverage caching strategies such as Redis or Memcached for frequently-read data.
• Pool database connections to reduce overhead.

Error Handling

Custom error-handling middleware can centralize error-logging and user-friendly response messages in your Express.js application. This approach keeps your code tidy and makes diagnosing issues simpler.

Production Deployment Setup

Upon completing your development workflow, you may want to deploy your application in a production environment. This often involves implementing process management, a reverse proxy, and SSL/TLS to handle secure requests.

Install a Process Manager: PM2

PM2 is a popular Node.js process management library that ensures your application remains live indefinitely, handles automatic restarts, and supports load balancing. Install PM2 globally to manage your Express.js application in production:

sudo npm install -g pm2

Use commands like pm2 start server.js to launch your application. You can create a startup script to ensure PM2 runs at boot:

pm2 startup systemd
pm2 save

Setting Up a Reverse Proxy

Running Express.js on ports 80 or 443 with direct public access can be done, but it is generally considered better to place a reverse proxy server like Nginx or Apache in front of your Node.js application for better performance, security handling, and easy SSL termination.

Below is a simple example using Nginx:

1. Install Nginx:

   sudo dnf install nginx -y
   

2. Enable and start Nginx:

   sudo systemctl enable nginx
   sudo systemctl start nginx
   

3. Configure server block (for instance, modify /etc/nginx/conf.d/myapp.conf):

   server {
       listen 80;
       server_name myapp.example.com;
   
       location / {
           proxy_pass http://127.0.0.1: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;
       }
   }
   

After making these changes, test your configuration:

sudo nginx -t
sudo systemctl reload nginx

Your Express.js application will now be available on http://myapp.example.com, gracefully served by Nginx.

Enabling SSL/TLS

Securing your Express.js application with HTTPS is both practical and essential, especially when handling user data or sensitive information. Obtain an SSL certificate from a reputable certificate authority (or generate a Let’s Encrypt certificate for free). Configure Nginx to serve your application via HTTPS by adding:

listen 443 ssl;
ssl_certificate /etc/letsencrypt/live/myapp.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/myapp.example.com/privkey.pem;

Update the file paths and domain to match your environment, then enable automatic renewal if you are using Let’s Encrypt.

Troubleshooting Common Issues

Even the most carefully prepared environment can encounter occasional hiccups. Below are some of the most common problems you may face while installing or running Express.js on Rocky Linux 9, along with potential fixes.

Permission-Related Problems

Express.js might encounter permission issues when writing into certain directories. Run commands that require administrative privileges using sudo and ensure the directories your application writes to are owned or writable by the correct user. Avoid running your entire application as root, as doing so poses significant security risks.

Dependency Conflicts

Conflicts may emerge if your system has older versions of Node.js modules. Make sure you update them or remove conflicting packages before installing fresh copies:

npm update
npm install

Port Binding Issues

If another process occupies the same port as your Express.js app, your application may fail to start or crash upon initialization. Identify conflicting processes by checking open ports:

sudo lsof -i:3000

Adjust the port in server.js or terminate the conflicting process.

Common Error Resolutions

Monitor your application logs using PM2 or built-in logging to gather clues about exceptions or unhandled rejections. Ensure your Node.js and npm versions match your application’s requirements.

Maintenance and Updates

Your Express.js application will benefit greatly from regular and proactive maintenance, which not only improves performance but also reduces security exposures.

Regular Updates

Keep packages like Express.js, middleware libraries, and Node.js up to date. Updating packages typically resolves performance inefficiencies, bug fixes, and vulnerabilities. Run:

npm update

Occasionally, some packagers might release major versions with breaking changes. Review their release notes or changelogs before upgrading to avoid disruptions.

Backup Strategies

Regular backups are a non-negotiable practice. Automated backups are especially critical if your application stores user-generated content or interacts with databases. You can use:

• tar and gzip to compress project folders
• Database-specific tools like mysqldump, pg_dump, or mongodump
• Cloud-based backups for further redundancy

Monitoring Setup

Set up monitoring solutions like New Relic, PM2 Monitoring, or Prometheus for real-time insights into resource use and system performance. Timely alerts help you detect and resolve issues before they escalate into critical bottlenecks or service failures.

Security Patches

Stay alert to security advisories and best practices. Apply Rocky Linux 9 patches regularly:

sudo dnf update --security

Set a maintenance window to avoid downtime, and always test updates in a staging environment before implementing them in production.

Best Practices and Security Considerations

Designing your Express.js application with security and best practices top of mind significantly elevates your service’s reliability. Below are some approaches to consider for a production-grade environment.

Security Hardening Tips

• Use HTTP headers for improved security. Tools like helmet set an assortment of protective headers automatically.
• Implement rate-limiting or captcha solutions to stop automated bots and prevent brute force attacks.
• Utilize libraries such as express-validator to validate and sanitize user inputs, reducing risks associated with SQL injection or Cross-Site Scripting.

Performance Optimization

Enhance the user experience by tapping into Node.js cluster mode if you have multiple CPU cores. The cluster module allows your application to distribute incoming connections across multiple worker processes efficiently. Coupled with robust caching strategies, your Express.js application can scale to handle a sizable volume of traffic without major slowdowns.

Logging and Monitoring

Well-structured logs simplify diagnosing issues. Libraries like winston or morgan offer comprehensive logging features, from simple console output to advanced logging levels. Combine logs with monitoring stacks to gain end-to-end visibility into your application, including CPU, memory usage, and API call latencies.

Scalability Considerations

Your deployment strategy should be flexible. When your user base expands or service demands spike, you can replicate your application using containers (Docker) and orchestrate them with solutions like Kubernetes. Moreover, hosting providers such as AWS, DigitalOcean, or self-hosted VMware provide ways to dynamically scale resources.

Congratulations! You have successfully installed Express.js. Thanks for using this tutorial for installing the Express.js web application framework on Rocky Linux 9 system. For additional help or useful information, we recommend you check the official ExpressJS website.