Systemd Service Setup & Deployment Guide

by Alex Johnson 41 views

Introduction

In this comprehensive guide, we will walk you through setting up a systemd service for a Node.js application, deploying it, and verifying its correct operation. This is crucial for ensuring your application runs reliably in a production environment. We'll cover creating a systemd service file, managing the service, and deploying the application using Vercel. This article aims to help you understand each step clearly, so you can confidently manage your Node.js applications.

Understanding systemd

First, let's understand what systemd is. Systemd is a system and service manager for Linux operating systems. It is designed to be a modern and efficient replacement for the traditional System V init system. Systemd provides a standardized way to manage services, making it easier to automate the startup, shutdown, and management of processes. Understanding systemd is crucial for anyone deploying applications on Linux servers, as it ensures your services can be automatically started at boot time and restarted if they crash. Systemd's features include parallelization of service startup, on-demand activation of processes, and dependency management, all of which contribute to faster boot times and more reliable service management. For our purposes, we'll use systemd to manage our Node.js application, ensuring it runs continuously and restarts automatically if needed. This is a fundamental aspect of ensuring high availability for web applications.

Benefits of using systemd

Using systemd offers several significant benefits for managing your Node.js applications. One of the primary advantages is automatic service management. Systemd can automatically start your application at boot time, ensuring it's always running. Additionally, it can automatically restart your application if it crashes, which is crucial for maintaining uptime. Another key benefit is centralized logging. Systemd integrates with the systemd journal, which provides a centralized and efficient way to manage logs. This makes it easier to troubleshoot issues and monitor your application's performance. Furthermore, systemd's dependency management ensures that your application starts only after its dependencies (like the network) are available. This prevents common startup issues and ensures a smooth and reliable deployment process. Overall, systemd simplifies the management of long-running processes, making it an ideal choice for deploying Node.js applications in production environments.

Step-by-Step Guide

1. Create a systemd Service File

The first step in setting up a systemd service is to create a service file. This file tells systemd how to manage your application. We will create a service file for a Node.js application. The service file should be placed in the /etc/systemd/system/ directory. Let’s create a file named make-listener.service with the following content:

/etc/systemd/system/make-listener.service

[Unit]
Description=TRYONYOU MAKE LISTENER
After=network.target

[Service]
ExecStart=/usr/bin/node /home/ubuntu/TRYONYOU_MASTER/automation/make-listener.js
Restart=always
User=ubuntu

[Install]
WantedBy=multi-user.target

Explanation of the Service File

Let's break down the components of this service file to understand what each section does.

  • [Unit] Section:
    • Description=TRYONYOU MAKE LISTENER: This line provides a human-readable description of the service. It's helpful for identifying the service in systemd's status output.
    • After=network.target: This line specifies that the service should start after the network is up and running. This is crucial for applications that need network connectivity.
  • [Service] Section:
    • ExecStart=/usr/bin/node /home/ubuntu/TRYONYOU_MASTER/automation/make-listener.js: This line defines the command that systemd will execute to start the service. In this case, it runs a Node.js script using the node executable.
    • Restart=always: This line tells systemd to restart the service automatically if it crashes. This ensures high availability for your application.
    • User=ubuntu: This line specifies the user that systemd will use to run the service. It's best practice to run services under a non-root user for security reasons.
  • [Install] Section:
    • WantedBy=multi-user.target: This line indicates that the service should be started when the system enters the multi-user mode, which is the normal operating mode for a Linux server.

2. Reload systemd, Enable, and Start the Service

After creating the service file, you need to tell systemd to reload its configuration, enable the service to start on boot, and then start the service. Use the following commands:

sudo systemctl daemon-reload
sudo systemctl enable make-listener
sudo systemctl start make-listener
  • sudo systemctl daemon-reload: This command tells systemd to reload its configuration files. You need to run this command after creating or modifying a service file.
  • sudo systemctl enable make-listener: This command enables the service to start automatically at boot time. It creates symbolic links in the appropriate directories to ensure the service starts on boot.
  • sudo systemctl start make-listener: This command starts the service immediately. If the service is configured correctly, it will start running in the background.

3. Check the Service Status

To verify that the service is running correctly, you can check its status using the following command:

systemctl status make-listener

This command provides detailed information about the service, including its current status, any recent logs, and more. Look for the line that says Active: active (running) to confirm that the service is running.

4. Set up the Application Directory

Next, ensure the application directory is set up correctly. In this case, the application directory is /home/ubuntu/TRYONYOU_MASTER/. You may need to create directories and files within this directory.

mkdir -p /home/ubuntu/TRYONYOU_MASTER/cap_liveit/

This command creates the directory /home/ubuntu/TRYONYOU_MASTER/cap_liveit/, ensuring that it exists for the next steps.

5. Create Application Files

Now, let’s create the necessary application files. In this example, we need to create a file named pipeline.js inside the /home/ubuntu/TRYONYOU_MASTER/cap_liveit/ directory.

/home/ubuntu/TRYONYOU_MASTER/cap_liveit/pipeline.js

export async function runPipeline(order) {
  return {
    pattern: "PATTERN_GENERATED",
    fabricMap: "FABRIC_PLAN",
    timestamp: Date.now(),
    user: order.user
  };
}

This JavaScript file exports an async function runPipeline that returns an object with some predefined properties. This is a simple example, but it demonstrates how you might set up an endpoint to process incoming requests.

6. Configure API Routes

To expose the functionality of your application, you need to configure API routes. In this case, we are assuming there is an app object (likely an Express.js instance) and we are adding a route to it.

import capRoute from "./api/cap_liveit_route.js";
app.use("/cap", capRoute);

This code snippet imports a route handler from ./api/cap_liveit_route.js and mounts it on the /cap path. This means that any requests to /cap/* will be handled by the capRoute middleware.

7. Install Dependencies and Build the Application

Before deploying the application, you need to install its dependencies and build it. This is typically done using npm.

cd /home/ubuntu/TRYONYOU_MASTER
npm install
npm run build
  • cd /home/ubuntu/TRYONYOU_MASTER: This command changes the current directory to your application’s root directory.
  • npm install: This command installs all the dependencies listed in your package.json file.
  • npm run build: This command runs the build script defined in your package.json file. This script typically compiles your application’s code and prepares it for deployment.

8. Deploy the Application with Vercel

Vercel is a popular platform for deploying web applications. To deploy your application, you can use the Vercel CLI.

vercel deploy --prod --yes
  • vercel deploy: This command initiates the deployment process.
  • --prod: This flag tells Vercel to deploy the application to the production environment.
  • --yes: This flag automatically confirms any prompts during the deployment process.

Verification Steps

After deploying the application, it's essential to verify that everything is working as expected. Here are the key verification steps:

1. Verify MAKE Listener is Active on Port 7070

Ensure that the MAKE listener (your Node.js application) is actively listening on port 7070. You can use tools like netstat or ss to check this.

sudo netstat -tulnp | grep 7070

Or

ss -tulnp | grep 7070

This command will show you if any process is listening on port 7070. You should see your Node.js application listed.

2. Verify the /cap/run Endpoint Returns Correct JSON

Test the /cap/run endpoint to ensure it returns the expected JSON response. You can use tools like curl or Postman to send a request to this endpoint.

curl https://tryonyou.app/cap/run

This command sends a GET request to the /cap/run endpoint and prints the response to the console. Verify that the response is a valid JSON object and contains the expected properties.

3. Verify the Deploy is Updated on https://tryonyou.app

Check your Vercel dashboard to confirm that the latest deployment is live on the specified URL (in this case, https://tryonyou.app). You can also manually browse the website to ensure that the changes are reflected.

4. Verify the Website is Online (200 Status)

Ensure that the website is online and returns a 200 OK status code. You can use tools like curl or online website status checkers to verify this.

curl -I https://tryonyou.app

The -I flag tells curl to only show the headers. Look for the HTTP/2 200 status code in the output.

5. Verify MAKE Can Send Zips Without Error 413

If your application involves uploading files, particularly ZIP files, ensure that the MAKE platform can send these files without encountering a 413 Request Entity Too Large error. This issue was previously solved by using a new endpoint, so verify that the new endpoint is correctly implemented and functioning.

Conclusion

Setting up a systemd service for your Node.js application and deploying it correctly is crucial for ensuring its reliability and availability. By following this guide, you should now have a clear understanding of how to create a systemd service file, manage the service, deploy your application using Vercel, and verify its correct operation. Remember to regularly monitor your application and its logs to ensure it continues to run smoothly. This detailed guide aims to provide you with the knowledge to confidently deploy and manage your Node.js applications in a production environment.

For further reading on systemd and its capabilities, you can refer to the official systemd documentation on the freedesktop.org website. This resource provides in-depth information about systemd's features, configuration options, and best practices.