Empowering you with the knowledge to master Linux web hosting, DevOps and Cloud

 Linux Web Hosting, DevOps, and Cloud Solutions

Author: wahab Page 1 of 7

Protecting Critical Packages in YUM to Prevent Unintended Removal

Managing RPM-based systems with tools like YUM (Yellowdog Updater Modified) is an integral part of provisioning and maintaining Linux servers. While YUM simplifies the process of managing package dependencies, it can sometimes lead to unintended consequences, especially when developers remove a package that has critical dependencies. In this blog, we’ll explore a common use case and demonstrate how to safeguard important packages using YUM’s package protection features.

The Problem: Accidental Removal of Critical Packages
Let’s consider a scenario:
You have a custom package called dep-web that automates server provisioning by installing essential components like httpd, mod_ssl, and ingest, along with scripts and cron jobs critical to your environment. When a developer installs dep-web, everything works seamlessly. However, issues arise when they attempt to test a specific version of ingest.

A typical action might be:

yum remove ingest
This operation not only removes ingest but also uninstalls dep-web, since dep-web depends on ingest. Consequently, all the additional configurations, scripts, and cron jobs set up by dep-web are also removed. Even if the developer reinstalls ingest, dep-web and its functionality are not restored, leading to potential operational disruptions.

Developers may not always notice these cascading effects, causing long-term inconsistencies and errors in the environment. Clearly, there is a need to prevent the accidental removal of critical packages like dep-web.

The Solution: Protecting Packages in YUM
YUM includes functionality to prevent the removal of certain packages using the /etc/yum/protected.d directory and the yum-plugin-protect-packages. By default, YUM protects itself and its dependencies (e.g., rpm, python, glibc) from being uninstalled. However, administrators can extend this protection to other packages.

Steps to Protect Critical Packages
Install the YUM Plugin
Ensure the yum-plugin-protect-packages is installed on your system:

yum install yum-plugin-protect-packages
Create a Configuration File
Add your critical package to the protected list by creating a .conf file under /etc/yum/protected.d/. For example, to protect the dep-web package:

vi /etc/yum/protected.d/dep-web.conf
Add the following content:

dep-web
Save and close the file.

Verify the Protection
Attempt to remove the protected package to test the configuration:

yum remove dep-web
YUM will block the operation and display an error message, ensuring the package remains intact:

Error: Trying to remove "dep-web", which is protected
Add Additional Packages (Optional)
If there are other critical packages that need protection, create or edit their respective .conf files under the same directory.

Benefits of Package Protection
By implementing package protection, you can:

Prevent the accidental removal of critical packages and their dependencies.
Ensure that operational scripts, configurations, and cron jobs tied to these packages are preserved.
Enhance the reliability of your environment, especially in shared development and production systems.

Conclusion
Managing dependencies with YUM requires careful oversight, particularly in environments where multiple developers and administrators interact with the system. Protecting critical packages using YUM’s protected.d directory and plugins like yum-plugin-protect-packages provides a robust safeguard against unintended package removal.

In the example of dep-web, protecting the package ensures that its functionality, including the custom scripts and cron jobs, remains intact. This small configuration step can save countless hours of troubleshooting and recovery in large-scale deployments.

Proactively implementing such measures demonstrates a commitment to best practices in system administration, reducing downtime and fostering a more stable infrastructure.

Automating Email Cleanup with doveadm expunge

Managing email storage is a crucial part of maintaining efficient mail servers, especially for administrators using Dovecot. Over time, mailboxes can accumulate a massive number of emails, leading to performance issues and potential storage costs. One effective way to manage this is by automatically deleting emails older than a specific period. In this blog, we’ll discuss how to use doveadm expunge to delete old emails.

Understanding the Basics
Dovecot’s doveadm expunge command is a powerful utility for deleting emails based on specified criteria. Here’s a quick overview of the command syntax:

doveadm expunge -u mailbox ''
-u: Specifies the user mailbox.
mailbox '': Specifies the folder, such as INBOX, INBOX.Spam, etc.
: Defines the filter for emails to be deleted, e.g., before 1w (one week) or before 2w (two weeks).

Use Cases
1. List Existing Mailboxes
Before deleting emails, identify the folders within a specific mailbox. Use the following command:

doveadm mailbox list -u user@example.com
Sample output:

INBOX
INBOX.Spam
INBOX.Drafts
INBOX.Trash
INBOX.Sent

2. Delete Emails Older Than 2 Weeks in All Folders
To remove all emails older than two weeks in all folders for a specific mailbox:

doveadm expunge -u user@example.com mailbox '*' before 2w
3. Exclude INBOX Folder While Deleting
If you want to delete old emails from all folders except INBOX, use:

doveadm expunge -u user@example.com mailbox INBOX.'*' before 2w
4. Delete All Emails in a Mailbox
To delete all emails from all folders within a specific mailbox:

doveadm expunge -u user@example.com mailbox '*' all
Bulk Removal of Old Emails
When managing multiple accounts, you may need to automate the process for all mailboxes on a server. Here’s how to approach this on Plesk and cPanel.

Step 1: Generate a List of Mailboxes
For Plesk:
Run the following command to get a list of all active mailboxes:

plesk db -Ne "select concat(m.mail_name,'@',d.name) as mailbox, m.postbox from domains d, mail m, accounts a where m.dom_id=d.id and m.account_id=a.id and m.postbox='true'" | awk '{print $1}' >mbox.txt
For cPanel:
Generate a list of all mailboxes with:

for i in $(awk '{print $2}' /etc/trueuserdomains); do uapi --user=$i Email list_pops | egrep "\s+email:" ; done | awk '{print $2}' >mbox.txt
Step 2: Automate Deletion with a Script
Create a shell script (mailbox-doveadm-expunge.sh) to process the mailboxes:

#!/bin/bash
# Script to delete emails older than 2 weeks from all mailboxes

MAILBOX_FILE="mbox.txt"

if [ ! -f "$MAILBOX_FILE" ]; then
    echo "Mailbox list file $MAILBOX_FILE not found!"
    exit 1
fi

for mailbox in $(cat $MAILBOX_FILE); do
    echo "Processing mailbox: $mailbox"
    doveadm expunge -u $mailbox mailbox 'INBOX' before 2w
    doveadm expunge -u $mailbox mailbox 'INBOX.*' before 2w
    doveadm expunge -u $mailbox mailbox 'Sent' before 2w
    doveadm expunge -u $mailbox mailbox 'Trash' before 2w
    doveadm expunge -u $mailbox mailbox 'Drafts' before 2w
    doveadm expunge -u $mailbox mailbox 'Spam' before 2w
done

Save the script and ensure it has executable permissions:

chmod +x mailbox-doveadm-expunge.sh
Run the script:

./mailbox-doveadm-expunge.sh

Best Practices
1. Backup Emails: Before performing a mass deletion, create a backup of your mail directories.
2. Test on a Single Mailbox: Verify your deletion criteria by testing on a single mailbox before applying changes in bulk.
3. Monitor Logs: After running doveadm expunge, check Dovecot logs for errors or warnings.

Conclusion
Using doveadm expunge simplifies email management and helps prevent mail server overload by automatically removing old emails. Whether you’re working with individual accounts or hundreds of mailboxes, this approach can save significant time and effort. Integrate this cleanup process into your routine server maintenance to keep your mail system optimized.

Tracking File Activity(deletion) with auditd and Process Accounting in Linux

Maintaining a secure system involves monitoring file system activity, especially tracking file deletions, creations, and other modifications. This blog post explores how to leverage two powerful tools, auditd and process accounting with /usr/sbin/accton (provided by the psacct package), to gain a more comprehensive understanding of these events in Linux.

Introduction

Tracking file deletions in a Linux environment can be challenging. Traditional file monitoring tools often lack the capability to provide detailed information about who performed the deletion, when it occurred, and which process was responsible. This gap in visibility can be problematic for system administrators and security professionals who need to maintain a secure and compliant system.

To address this challenge, we can combine auditd, which provides detailed auditing capabilities, with process accounting (psacct), which tracks process activity. By integrating these tools, we can gain a more comprehensive view of file deletions and the processes that cause them.

What We’ll Cover:

1. Understanding auditd and Process Accounting
2. Installing and Configuring psacct
3. Enabling Audit Tracking and Process Accounting
4. Setting Up Audit Rules with auditctl
5. Simulating File Deletion
6. Analyzing Audit Logs with ausearch
7. Linking Process ID to Process Name using psacct
8. Understanding Limitations and Best Practices

Prerequisites:

1. Basic understanding of Linux commands
2. Root or sudo privileges
3. Auditd package installed (installed by default on most of the distros)

1. Understanding the Tools

auditd: The Linux audit daemon logs security-relevant events, including file system modifications. It allows you to track who is accessing the system, what they are doing, and the outcome of their actions.

Process Accounting: Linux keeps track of resource usage for processes. By analyzing process IDs (PIDs) obtained from auditd logs and utilizing tools like /usr/sbin/accton and dump-acct (provided by psacct), we can potentially identify the process responsible for file system activity. However, it’s important to understand that process accounting data itself doesn’t directly track file deletions.

2. Installing and Configuring psacct

First, install the psacct package using your distribution’s package manager if it’s not already present:

# For Debian/Ubuntu based systems
sudo apt install acct

# For Red Hat/CentOS based systems
sudo yum install psacct

3. Enabling Audit Tracking and Process Accounting

Ensure auditd is running by checking its service status:

sudo systemctl status auditd

If not running, enable and start it:

sudo systemctl enable auditd
sudo systemctl start auditd


Next, initiate recording process accounting data:

sudo /usr/sbin/accton /var/log/account/pacct

This will start saving the process information in the log file /var/log/account/pacct.

4. Setting Up Audit Rules with auditctl

To ensure audit rules persist across reboots, add the rule to the audit configuration file. The location of this file may vary based on the distribution:

For Debian/Ubuntu, use /etc/audit/rules.d/audit.rules
For Red Hat/CentOS, use /etc/audit/audit.rules
Open the appropriate file in a text editor with root privileges and add the following line to monitor deletions within a sample directory:

-w /var/tmp -p wa -k sample_file_deletion
Explanation:

-w: Specifies the directory to watch (/path/to/your/sample_directory: /var/tmp)
-p wa: Monitors both write (w) and attribute (a) changes (deletion modifies attributes)
-k sample_file_deletion: Assigns a unique key for easy identification in logs


After adding the rule, restart the auditd service to apply the changes:

sudo systemctl restart auditd

5. Simulating File Deletion

Create a test file in the sample directory and delete it:

touch /var/tmp/test_file
rm /var/tmp/test_file

6. Analyzing Audit Logs with ausearch

Use ausearch to search audit logs for the deletion event:


sudo ausearch -k sample_file_deletion
This command will display audit records related to the deletion you simulated. Look for entries indicating a “delete” operation within your sample directory and not down the the process id for the action.

# ausearch -k sample_file_deletion
...
----
time->Sat Jun 16 04:02:25 2018
type=PROCTITLE msg=audit(1529121745.550:323): proctitle=726D002D69002F7661722F746D702F746573745F66696C65
type=PATH msg=audit(1529121745.550:323): item=1 name="/var/tmp/test_file" inode=16934921 dev=ca:01 mode=0100644 ouid=0 ogid=0 rdev=00:00 obj=unconfined_u:object_r:user_tmp_t:s0 objtype=DELETE cap_fp=0000000000000000 cap_fi=0000000000000000 cap_fe=0 cap_fver=0
type=PATH msg=audit(1529121745.550:323): item=0 name="/var/tmp/" inode=16819564 dev=ca:01 mode=041777 ouid=0 ogid=0 rdev=00:00 obj=system_u:object_r:tmp_t:s0 objtype=PARENT cap_fp=0000000000000000 cap_fi=0000000000000000 cap_fe=0 cap_fver=0
type=CWD msg=audit(1529121745.550:323):  cwd="/root"
type=SYSCALL msg=audit(1529121745.550:323): arch=c000003e syscall=263 success=yes exit=0 a0=ffffffffffffff9c a1=9930c0 a2=0 a3=7ffe9f8f2b20 items=2 ppid=2358 pid=2606 auid=1001 uid=0 gid=0 euid=0 suid=0 fsuid=0 egid=0 sgid=0 fsgid=0 tty=pts1 ses=2 comm="rm" exe="/usr/bin/rm" subj=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023 key="sample_file_deletion"

As you can see in the above log, the user root(uid=0) deleted(exe=”/usr/bin/rm”) the file /var/tmp/test_file. Note down the the ppid=2358 pid=2606 as well. If the file is deleted by a script or cron, you would need these to track the script or cron.

7. Linking Process ID to Process Name using psacct

The audit logs will contain a process ID (PID) associated with the deletion. Utilize this PID to identify the potentially responsible process:

Process Information from dump-acct

After stopping process accounting recording with sudo /usr/sbin/accton off, analyze the captured data:

sudo dump-acct /var/log/account/pacct
This output shows various process details, including PIDs, command names, and timestamps. However, due to the nature of process accounting, it might not directly pinpoint the culprit. Processes might have terminated after the deletion, making it challenging to definitively identify the responsible one. You can grep the ppid or pid we received from audit log against the output of the dump-acct command.

sudo dump-acct /var/log/account/pacct | tail
grotty          |v3|     0.00|     0.00|     2.00|  1000|  1000| 12000.00|     0.00|  321103|  321101|     |       0|pts/1   |Fri Aug 14 13:26:07 2020
groff           |v3|     0.00|     0.00|     2.00|  1000|  1000|  6096.00|     0.00|  321101|  321095|     |       0|pts/1   |Fri Aug 14 13:26:07 2020
nroff           |v3|     0.00|     0.00|     4.00|  1000|  1000|  2608.00|     0.00|  321095|  321087|     |       0|pts/1   |Fri Aug 14 13:26:07 2020
man             |v3|     0.00|     0.00|     4.00|  1000|  1000| 10160.00|     0.00|  321096|  321087| F   |       0|pts/1   |Fri Aug 14 13:26:07 2020
pager           |v3|     0.00|     0.00|  2018.00|  1000|  1000|  8440.00|     0.00|  321097|  321087|     |       0|pts/1   |Fri Aug 14 13:26:07 2020
man             |v3|     2.00|     0.00|  2021.00|  1000|  1000| 10160.00|     0.00|  321087|  318116|     |       0|pts/1   |Fri Aug 14 13:26:07 2020
clear           |v3|     0.00|     0.00|     0.00|  1000|  1000|  2692.00|     0.00|  321104|  318116|     |       0|pts/1   |Fri Aug 14 13:26:30 2020
dump-acct       |v3|     2.00|     0.00|     2.00|  1000|  1000|  4252.00|     0.00|  321105|  318116|     |       0|pts/1   |Fri Aug 14 13:26:35 2020
tail            |v3|     0.00|     0.00|     2.00|  1000|  1000|  8116.00|     0.00|  321106|  318116|     |       0|pts/1   |Fri Aug 14 13:26:35 2020
clear           |v3|     0.00|     0.00|     0.00|  1000|  1000|  2692.00|     0.00|  321107|  318116|     |       0|pts/1   |Fri Aug 14 13:26:45 2020

To better understand what you’re looking at, you may want to add column headings as I have done with these commands:

echo "Command vers runtime systime elapsed UID GID mem_use chars PID PPID ? retcode term date/time" "
sudo dump-acct /var/log/account/pacct | tail -5

Command         vers  runtime   systime   elapsed    UID    GID   mem_use     chars      PID     PPID  ?   retcode   term     date/time
tail            |v3|     0.00|     0.00|     3.00|     0|     0|  8116.00|     0.00|  358190|  358188|     |       0|pts/1   |Sat Aug 15 11:30:05 2020
pacct           |v3|     0.00|     0.00|     3.00|     0|     0|  9624.00|     0.00|  358188|  358187|S    |       0|pts/1   |Sat Aug 15 11:30:05 2020
sudo            |v3|     0.00|     0.00|     4.00|     0|     0| 10984.00|     0.00|  358187|  354579|S    |       0|pts/1   |Sat Aug 15 11:30:05 2020
gmain           |v3|    14.00|     3.00|  1054.00|  1000|  1000|  1159680|     0.00|  358169|    3179|    X|       0|__      |Sat Aug 15 11:30:03 2020
vi              |v3|     0.00|     0.00|   456.00|  1000|  1000| 10976.00|     0.00|  358194|  354579|     |       0|pts/1   |Sat Aug 15 11:30:28 2020

Alternative: lastcomm (Limited Effectiveness)

In some cases, you can try lastcomm to potentially retrieve the command associated with the PID, even if the process has ended. However, its effectiveness depends on system configuration and might not always be reliable.

Important Note

While combining auditd with process accounting can provide insights, it’s crucial to understand the limitations. Process accounting data offers a broader picture of resource usage but doesn’t directly correlate to specific file deletions. Additionally, processes might terminate quickly, making it difficult to trace back to a specific action.

Best Practices

1. Regular Monitoring: Regularly monitor and analyze audit logs to stay ahead of potential security breaches.
2. Comprehensive Logging: Ensure comprehensive logging by setting appropriate audit rules and keeping process accounting enabled.
3. Timely Responses: Respond quickly to any suspicious activity by investigating audit logs and process accounting data promptly.

By combining the capabilities of auditd and process accounting, you can enhance your ability to track and understand file system activity, thereby strengthening your system’s security posture.

Demystifying Containers and Orchestration: A Beginner’s Guide

In today’s fast-paced world of software development, speed and efficiency are crucial. Containerization and container orchestration technologies are revolutionizing how we build, deploy, and manage applications. This blog post will break down these concepts for beginners, starting with the fundamentals of containers and then exploring container orchestration with a focus on Kubernetes, the industry leader.

1. What are Containers?

Imagine a shipping container. It’s a standardized unit that can hold various cargo and be easily transported across different modes of transportation (ships, trucks, trains). Similarly, a software container is a standardized unit of software that packages code and all its dependencies (libraries, runtime environment) into a lightweight, portable package.


Benefits of Containers:

  • Portability: Containers run consistently across different environments (physical machines, virtual machines, cloud platforms) due to their standardized nature.
  • Isolation: Each container runs in isolation, sharing resources with the operating system but not with other containers, promoting security and stability.
  • Lightweight: Containers are much smaller than virtual machines, allowing for faster startup times and efficient resource utilization.

    2. What is Docker?

    Docker is a free and open-source platform that provides developers with the tools to build, ship, and run applications in standardized units called containers. Think of Docker as a giant toolbox containing everything you need to construct and manage these containers.

    Here’s how Docker is involved in containerization:

  • Building Images: Docker allows you to create instructions (Dockerfile) defining the environment and dependencies needed for your application. These instructions are used to build lightweight, portable container images that encapsulate your code.
  • Running Containers: Once you have an image, Docker can run it as a container instance. This instance includes the application code, libraries, and runtime environment, all packaged together.
  • Sharing Images: Docker Hub, a public registry, allows you to share and discover container images built by others. This promotes code reuse and simplifies development.



    Benefits of Using Docker:

  • Faster Development: Docker simplifies the development process by ensuring a consistent environment across development, testing, and production.
  • Portability: Containerized applications run consistently on any system with Docker installed, regardless of the underlying operating system.
  • Efficiency: Containers are lightweight and share the host operating system kernel, leading to efficient resource utilization.

    3. What is Container Orchestration?
    As the number of containers in an application grows, managing them individually becomes cumbersome. Container orchestration tools automate the deployment, scaling, and management of containerized applications. They act as a conductor for your containerized orchestra.

    Key Features of Container Orchestration:

  • Scheduling: Orchestrators like Kubernetes determine where to run containers across available resources.
  • Scaling: They can automatically scale applications up or down based on demand.
  • Load Balancing: Orchestrators distribute incoming traffic across multiple container instances for an application, ensuring stability and high availability.
  • Health Monitoring: They monitor the health of containers and can restart them if they fail.

    4. What is Kubernetes?

    Kubernetes, often shortened to K8s, is an open-source system for automating container deployment, scaling, and management. It’s the most popular container orchestration platform globally due to its scalability, flexibility, and vibrant community.

    Thinking of Kubernetes as a City (Continued):

    Imagine Kubernetes as a city that manages tiny houses (containers) where different microservices reside. Kubernetes takes care of:

  • Zoning: Deciding where to place each tiny house (container) based on resource needs.
  • Traffic Management: Routing requests to the appropriate houses (containers).
  • Utilities: Providing shared resources (like storage) for the houses (containers).
  • Maintenance: Ensuring the houses (containers) are healthy and restarting them if needed.

    Example with a Simple Web App:

    Let’s say you have a simple web application with a front-end written in Node.js and a back-end written in Python (commonly used for web development). You can containerize each component (front-end and back-end) and deploy them on Kubernetes. Kubernetes will manage the deployment, scaling, and communication between these containers.

    Benefits of Kubernetes:

  • Scalability: Easily scale applications up or down to meet changing demands.
  • Portability: Deploy applications across different environments (on-premise, cloud) with minimal changes.
  • High Availability: Kubernetes ensures your application remains available even if individual containers fail.
  • Rich Ecosystem: A vast ecosystem of tools and integrations exists for Kubernetes.

    5. How Docker Relates to Container Orchestration and Kubernetes
    Docker focuses on building, sharing, and running individual containers. While Docker can be used to manage a small number of containers, container orchestration tools like Kubernetes become essential when you have a complex application with many containers that need to be deployed, scaled, and managed efficiently.

    Think of Docker as the tool that builds the tiny houses (containers), and Kubernetes as the city planner and manager that oversees their placement, operations, and overall well-being.

    Getting Started with Docker and Kubernetes:
    There are several resources available to get started with Docker and Kubernetes:

    Docker: https://docs.docker.com/guides/getting-started/ offers tutorials and documentation for beginners.
    Kubernetes: https://kubernetes.io/docs/home/ provides comprehensive documentation and getting started guides.
    Online Courses: Many platforms like Udemy and Coursera offer beginner-friendly courses on Docker and Kubernetes.

    Conclusion

    Containers and container orchestration offer a powerful approach to building, deploying, and managing applications. By understanding Docker, containers, and orchestration tools like Kubernetes,

  • Securing Your Connections: A Guide to SSH Key authentication

    Securing Your Connections: A Guide to SSH Keys

    SSH (Secure Shell) is a fundamental tool for securely connecting to remote servers. While traditional password authentication works, it can be vulnerable to brute-force attacks. SSH keys offer a more robust and convenient solution for secure access.
    SSH authentication using SSH keys

    This blog post will guide you through the world of SSH keys, explaining their types, generation process, and how to manage them for secure remote connections and how to configure SSH key authentication.

    Understanding SSH Keys: An Analogy
    Imagine your home has two locks:

  • Combination Lock (Password): Anyone can access your home if they guess the correct combination.
  • High-Security Lock (SSH Key): Only someone with a specific physical key (your private key) can unlock the door.

    Similarly, SSH keys work in pairs:

  • Private Key: A securely stored key on your local machine. You never share this.
  • Public Key: A unique identifier you share with the server you want to access.
    The server verifies the public key against your private key when you attempt to connect. This verification ensures only authorized users with the matching private key can access the server.

    Types of SSH Keys
    There are many types of SSH keys, we are discussing the two main ones:

    RSA (Rivest–Shamir–Adleman): The traditional and widely supported option. It offers a good balance of security and performance.
    Ed25519 (Edwards-curve Digital Signature Algorithm): A newer, faster, and potentially more secure option gaining popularity.

    RSA vs. Ed25519 Keys:

  • Security: Both are considered secure, but Ed25519 might offer slightly better theoretical resistance against certain attacks.
  • Performance: Ed25519 is generally faster for both key generation and signing/verification compared to RSA. This can be beneficial for slower connections or resource-constrained devices.
  • Key Size: RSA keys are typically 2048 or 4096 bits, while Ed25519 keys are 256 bits. Despite the smaller size, Ed25519 offers comparable security due to the underlying mathematical concepts.
  • Compatibility: RSA is widely supported by all SSH servers. Ed25519 is gaining popularity but might not be universally supported on older servers.

    Choosing Between RSA and Ed25519:

    For most users, Ed25519 is a great choice due to its speed and security. However, if compatibility with older servers is a critical concern, RSA remains a reliable option.

    Generating SSH Keys with ssh-keygen
    Here’s how to generate your SSH key pair using the ssh-keygen command:

    Open your terminal.

    Run the following command, replacing with your desired name for the key pair:

    ssh-keygen -t <key_type> -b 4096 -C "<your_email@example.com>"
  • <key_type>: Choose either rsa or ed25519.
  • -b 4096: Specifies the key size (4096 bits is recommended for strong security).
  • -C “<your_email@example.com”>: Adds a comment to your key (optional).

    You’ll be prompted to enter a secure passphrase for your private key. Choose a strong passphrase and remember it well (it’s not mandatory, but highly recommended for added security).

    The command will generate two files:

    <key_name>>.pub: The public key file (you’ll add this to the server).
    <key_name>>: The private key file (keep this secure on your local machine).

    Important Note: Never share your private key with anyone!

    Adding Your Public Key to the Server’s authorized_keys File

    1. Access the remote server you want to connect to (through a different method if you haven’t set up key-based authentication yet).
    2. Locate the ~/.ssh/authorized_keys file on the server (the ~ represents your home directory). You might need to create the .ssh directory if it doesn’t exist.
    3. Open the authorized_keys file with a text editor.
    4. Paste the contents of your public key file (.pub) into the authorized_keys file on the server.
    5. Save the authorized_keys file on the server.

    Permissions:

    Ensure the authorized_keys file has permissions set to 600 (read and write access only for the owner).

    Connecting with SSH Keys
    Once you’ve added your public key to the server, you can connect using your private key:

    ssh <username>@<server_address>

    You’ll be prompted for your private key passphrase (if you set one) during the connection. That’s it! You’re now securely connected to the server without needing a password.

    Benefits of SSH Keys:

  • Enhanced Security: More secure than password authentication, making brute-force attacks ineffective.
  • Convenience: No need to remember complex passwords for multiple servers.
  • Faster Logins: SSH key-based authentication is often faster than password authentication.

    By implementing SSH keys, you can significantly improve the security and convenience of your remote server connections. Remember to choose strong passwords and keep your private key secure for optimal protection.

  • Install the free SSL Certificate on the server’s hostname – cPanel WHM server


    cPanel and WHM (WebHost Manager) is a popular web hosting control panels that allow server administrators to manage web hosting services efficiently. Among their many features, cPanel offers a handy tool called AutoSSL, which provides free SSL certificates for added security. In this guide, I will show you how to use AutoSSL to secure your server’s hostname.

    Step 1: The checkallsslcerts Script

    The checkallsslcerts Script is used by cPanel to issue SSL certificates for server hostname. It’s important to note that checkallsslcerts
    runs as part of the nightly update checks performed on your system. These updates include cPanel’s own update script, upcp (cPanel update script).

    Step 2: When to Manually Run AutoSSL

    In most cases, checkallsslcerts will take care of securing your server’s hostname during the nightly updates. However, there may be instances when you want to update the SSL certificate manually. This is especially useful if you’ve recently changed your server’s hostname and want to ensure the SSL certificate is updated immediately.

    Step 3: Understanding the checkallsslcerts Script

    The `/usr/local/cpanel/bin/checkallsslcerts` script is responsible for checking and installing SSL certificates for your server’s hostname. Here’s what the script does:

    – It creates a Domain Control Validation (DCV) file.
    – It performs a DNS lookup for your hostname’s IP address.
    – It checks the DCV file using HTTP validation (for cPanel & WHM servers).
    – If needed, it sends a request to Sectigo to issue a new SSL certificate.
    – It logs the Sectigo requests for validation.

    You can learn more about the checkallsslcerts script and it’s usage in this article from cPanel:

    Step 4: How to Manually Execute the Script

    To manually run the script, use the following command:

    /usr/local/cpanel/bin/checkallsslcerts [options]

    You can use options like `–allow-retry` and `–verbose` as needed.

    Step 5: Troubleshooting and Tips

    If you encounter issues with the SSL certificate installation, the script will provide helpful output to troubleshoot the problem. Ensure that your server’s firewall allows access from Sectigo’s IP addresses mentioned in the guide.

    Common Issue: Unable to obtain a free hostname certificate due to 404 when DCV check runs in /usr/local/cpanel/bin/checkallsslcerts

    After running the /usr/local/cpanel/bin/checkallsslcerts script via SSH, you may see errors similar to the following:

    FAILED: Cpanel::Exception/(XID bj6m2k) The system queried for a temporary file at “http://hostname.domain.tld/.well-known/pki-validation/B65E7F11E8FBB1F598817B68746BCDDC.txt”, but the web server responded with the following error: 404 (Not Found). A DNS (Domain Name System) or web server misconfiguration may exist.
    [WARN] The system failed to acquire a signed certificate from the cPanel Store because of the following error: Neither HTTP nor DNS DCV preflight checks succeeded!

    Description:
    Encountering errors like “404 Not Found” during the DCV check when running /usr/local/cpanel/bin/checkallsslcerts via SSH? This issue typically arises when the shared IP address doesn’t match the main IP. To resolve it, ensure both IPs match and that the A record for the server’s hostname points to the main/shared IP. Here’s a workaround:

    Workaround:

    1. Confirm that the main IP and shared IP are identical.
    2. Make sure the A record for the server’s hostname points to the main/shared IP.
    3. To change the shared IP:
    Log in to WHM as the ‘root’ user.

  • Navigate to “Home » Server Configuration » Basic WebHost Manager® Setup.”
  • Update “The IPv4 address (only one address) to use to set up shared IPv4 virtual hosts” to match the main IP.
  • Click “Save Changes” and then execute the following via SSH or Terminal in WHM:
    /scripts/rebuildhttpdconf
    /scripts/restartsrv_httpd --hard

    This will help resolve issues with obtaining a free hostname certificate in cPanel/WHM.

    Conclusion

    Securing your cPanel/WHM server’s hostname with a free SSL certificate from AutoSSL is essential for a secure web hosting environment. By following these steps, you can ensure that your server’s hostname is protected with a valid SSL certificate.

    Remember to regularly check your SSL certificates to ensure they remain up-to-date and secure.

  • How to Install nopCommerce on Ubuntu Linux with Nginx Reverse Proxy and SSL: Step-by-Step Guide

    nopCommerce is an open-source e-commerce platform that allows users to create and manage their online stores. It is built on the ASP.NET Core framework and supports multiple database systems, including MySQL, Microsoft SQL Server, and PostgreSQL as it’s backend. The platform is highly customizable and offers a wide range of features, including product management, order processing, shipping, payment integration, and customer management. nopCommerce is a popular choice for businesses of all sizes because of its flexibility, scalability, and user-friendly interface.
    In this tutorial, we will guide you through the process of installing nopCommerce on Ubuntu Linux with Nginx reverse proxy and SSL.

    Register Microsoft key and feed
    To register the Microsoft key and feed, launch the terminal and execute these commands:

    1. Download the packages-microsoft-prod.deb file by running the command:

    wget https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb

    2. Install the packages-microsoft-prod.deb package by running the command:

    sudo dpkg -i packages-microsoft-prod.deb

    Install the .NET Core Runtime
    To install the .NET Core Runtime, perform the following steps:

    1. Update the available product listings for installation by running the command:

    sudo apt-get update

    2. Install the .NET runtime by running the command:

    sudo apt-get install -y apt-transport-https aspnetcore-runtime-7.0

    To determine the appropriate version of the .NET runtime to install, you should refer to the documentation provided by nopCommerce, which takes into account both the version of nopCommerce you are using and the Ubuntu OS version. Refer to the link below:

    https://learn.microsoft.com/en-us/dotnet/core/install/linux-ubuntu
    https://learn.microsoft.com/en-us/dotnet/core/install/linux-ubuntu#supported-distributions

    3. Verify the installed .Net Core runtimes by running the command:

    dotnet --list-runtimes


    4. Install the libgdiplus library:

    sudo apt-get install libgdiplus

    libgdiplus is an open-source implementation of the GDI+ API that provides access to graphic-related functions in nopCommerce and is required for running nopCommerce on Linux.

    Install MySql Server
    Latest nopCommerce support latest MySQL and MariaDB versions. We will install the latest MariaDB 10.6.

    1. To install mariadb-server for nopCommerce, execute the following command in the terminal:

    sudo apt-get install mariadb-server

    2. After installing MariaDB Server, you need to set the root password. Execute the following command in the terminal to set the root password:

    sudo /usr/bin/mysql_secure_installation

    This will start a prompt to guide you through the process of securing your MySQL installation and setting the root password.

    3. Create a database and User. We will use these details while installing nopCommerce. Replace the names of the database and the database user accordingly.

    mysql -u root -p
    create database  nopCommerceDB;
    grant all on nopCommerceDB.* to nopCommerceuser@localhost identified by 'P@ssW0rD';

    Please replace the database name, username and password accordingly.

    4. Reload privilege tables and exit the database.

    flush privileges;
    quit;

    Install nginx

    1. To install Nginx, run the following command:

    sudo apt-get install nginx

    2. After installing Nginx, start the service by running:

    sudo systemctl start nginx

    3. You can verify the status of the service using the following command:

    sudo systemctl status nginx


    4. Nginx Reverse proxy configuration
    To configure Nginx as a reverse proxy for your nopCommerce application, you’ll need to modify the default Nginx configuration file located at /etc/nginx/sites-available/nopcommerce.linuxwebhostingsupport.in. Open the file in a text editor and replace its contents with the following:

    server {
    
        server_name nopcommerce.linuxwebhostingsupport.in;
    
    	listen 80;
        listen [::]:80;
    
    
      location / {
        proxy_pass         http://localhost:5000;
        proxy_http_version 1.1;
        proxy_set_header   Upgrade $http_upgrade;
        proxy_set_header   Connection keep-alive;
        proxy_set_header   Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header   X-Forwarded-Proto $scheme;
        }
    
    }
    

    You need to replace nopcommerce.linuxwebhostingsupport.in with your domain name
    5. Enable the virtual host configuration file:
    Enable the server block by creating a symbolic link in the /etc/nginx/sites-enabled directory:
    sudo ln -s /etc/nginx/sites-available/nopcommerce.linuxwebhostingsupport.in /etc/nginx/sites-enabled/

    6. Reload Nginx for the changes to take effect:

    sudo systemctl reload Nginx

    Install NopCommerce

    In this example, we’ll use /var/www/nopCommerce for storing the files.

    1. Create a directory:

    sudo mkdir /var/www/nopCommerce

    2. Navigate to the directory where you want to store the nopCommerce files, Download and unpack nopCommerce:

    cd /var/www/nopCommerce
    sudo wget https://github.com/nopSolutions/nopCommerce/releases/download/release-4.60.2/nopCommerce_4.60.2_NoSource_linux_x64.zip
    sudo apt-get install unzip
    sudo unzip nopCommerce_4.60.2_NoSource_linux_x64.zip

    3. Create two directories that nopCommerce needs to run properly:

    sudo mkdir bin
    sudo mkdir logs

    4. Change the ownership of the nopCommerce directory and its contents to the www-data group:

    sudo chown -R www-data.www-data  /var/www/nopCommerce/

    www-data is the user Nginx webserver runs.

    Create the nopCommerce service

    1. Create a file named nopCommerce.service in the /etc/systemd/system directory with the following content:

    [Unit]
    Description=Example nopCommerce app running on Xubuntu
    
    [Service]
    WorkingDirectory=/var/www/nopCommerce
    ExecStart=/usr/bin/dotnet /var/www/nopCommerce/Nop.Web.dll
    Restart=always
    # Restart service after 10 seconds if the dotnet service crashes:
    RestartSec=10
    KillSignal=SIGINT
    SyslogIdentifier=nopCommerce-example
    User=www-data
    Environment=ASPNETCORE_ENVIRONMENT=Production
    Environment=DOTNET_PRINT_TELEMETRY_MESSAGE=false
    
    [Install]
    WantedBy=multi-user.target

    2. Start the nopCommerce service by running:

    sudo systemctl start nopCommerce.service

    3. To check the status of the nopCommerce service, use the following command:

    sudo systemctl status nopCommerce.service

    Also, check if the service is running on port 5000

    sudo lsof -i:5000

    4. After that, restart the nginx server:

    sudo systemctl restart nginx

    Now that the prerequisites are installed and configured, you can proceed to install and set up your nopCommerce store.

    Install nopCommerce
    After completing the previous steps, you can access the website through the following URL: http://nopcommerce.linuxwebhostingsupport.in. Upon visiting the site for the first time, you will be automatically redirected to the installation page as shown below:

    Provide the following information in the Store Information panel:

  • Admin user email: This is the email address of the first administrator for the website.
  • Admin user password: You must create a password for the administrator account.
  • Confirm password: Confirm the admin user password.
  • Country: Choose your country from the dropdown list. By selecting a country, you can configure your store with preinstalled language packs, preconfigured settings, shipping details, VAT settings, currencies, measures, and more.
  • Create sample data: Check this box if you want sample products to be created. It is recommended so that you can start working with your website before adding your own products. You can always delete or unpublish these items later.

    In the Database Information panel, you will need to provide the following details:

  • Database: Select either Microsoft SQL Server, MySQL, or PostgreSQL. Since, we are installing nopCommerce on Linux and MariaDB, choose the MySQL.
  • Create database if it doesn’t exist: We recommend creating your database and database user ahead of time to ensure a successful installation. Simply create a database instance and add the database user to it. The installation process will create all the tables, stored procedures, and more. Uncheck this option since we can use the database and database user we created earlier.
  • Enter raw connection string (advanced): Select this option if you prefer to enter a Connection string instead of filling the connection fields. For now, leave this unchecked
  • Server name: This is the IP, URL, or server name of your database. Use “localhost”.
  • Database name: This is the name of the database used by nopCommerce. Use the database we created earlier.
  • Use integrated Windows authentication: Leave it unchecked
  • SQL Username: Enter your database user name we created earlier.
  • SQL Password: Use your database user password we used earlier.
  • Specify custom collation: Leave this advanced setting empty.

    Click on the Install button to initiate the installation process. Once the installation is complete, the home page of your new site will be displayed. Access your site from the following URL: http://nopcommerce.linuxwebhostingsupport.in.


    Note:
    You can reset a nopCommerce website to its default settings by deleting the appsettings.json file located in the App_Data folder.

    Adding and Securing the nopCommerce
    We will be using Let’s Encrypt to add free and secure SSL certificate.
    Let’s Encrypt is a free, automated, and open certificate authority that allows you to obtain SSL/TLS certificates for your website. Certbot is a command-line tool that automates the process of obtaining and renewing these certificates, making it easier to secure your website with HTTPS.

    Here are the steps to install SSL with Certbot Nginx plugins:

    1.Install Certbot: First, make sure you have Certbot installed on your server. You can do this by running the following command:

    sudo apt-get update
    sudo apt-get install certbot python3-certbot-nginx

    2. Obtain SSL Certificate: Next, you need to obtain an SSL certificate for your domain. You can do this by running the following command:
    sudo certbot –nginx -d yourdomain.com

    Replace yourdomain.com with your own domain name. This command will automatically configure Nginx to use SSL, obtain a Let’s Encrypt SSL certificate and set an automatic redirect from http to https.

    3.Verify SSL Certificate: Once the certificate is installed, you can verify it by visiting your website using the https protocol. If the SSL certificate is valid, you should see a padlock icon in your browser’s address bar.

    4. Automatic Renewal: Certbot SSL certificates are valid for 90 days. To automatically renew your SSL certificate before it expires, you can set up a cron job to run the following command:

    sudo certbot renew --quiet

    This will check if your SSL certificate is due for renewal and automatically renew it if necessary.

    5. nopCommerce also recommend turning “UseProxy setting to true in the appsettings.json file located in the App_Data folder if we are using SSL. So change this value too.


    nopCommerce is a popular open-source e-commerce platform that offers users a flexible and scalable solution for creating and managing online stores. In this tutorial, we provided a step-by-step guide for installing and configuring nopCommerce on Ubuntu Linux with Nginx reverse proxy and SSL. We covered the installation of Microsoft key and feed, .NET Core Runtime, MySQL server, and Nginx reverse proxy. We also discussed how to configure Nginx as a reverse proxy for the nopCommerce application. By following this tutorial, you can set up a secure and reliable nopCommerce e-commerce store on Ubuntu Linux.

  • How to Share Files Between a Hyper-V Windows Host and Ubuntu guest VM

    Introduction

    Sharing files between a Windows host and Ubuntu virtual machine (VM) can be essential when you need to transfer data or collaborate between different environments. While the Hyper-V virtualization platform makes it easy to create Ubuntu VMs on a Windows host, the process of sharing files between the two systems can be a bit more complex. This is because Windows and Ubuntu use different file systems and protocols to access shared resources.

    In this blog post, we will walk you through the steps required to share files between a Hyper-V Windows host and Ubuntu VM using the Common Internet File System (CIFS) protocol. This method allows you to mount a Windows shared folder on Ubuntu, giving you access to files on the Windows host as if they were on the Ubuntu machine itself. We will also cover the process of setting up a new Windows local user for authentication, creating a shared folder, and enabling network settings in Hyper-V. By the end of this guide, you will have a fully functional file sharing system that works seamlessly between Windows and Ubuntu.

    1. Create a new Windows local user for sharing and authentication
    To access a Windows shared folder from Ubuntu, you need to provide valid credentials for a user account that has permissions to access the shared folder. For security reasons, it’s not recommended to use your Windows user account for this purpose, as it could potentially expose your system to security risks. Instead, it’s best to create a new local user account that’s dedicated solely to file sharing.

    Step-by-step guide for creating a new user in Windows
    1. Press “Windows Key + R” on your keyboard to open the Run dialog box.
    2. Type “netplwiz” in the box and click on “OK.”
    3. In the User Accounts window that appears, click on the “Add” button.

    4. Select “Sign in without a Microsoft account (not recommended)” at the bottom of the screen.
    5. Click on “Local account” and then click on “Next.”
    6. Enter a username and password for the new user and then click on “Next.”
    7. You can choose whether to set a password hint for the new user account or not. Click on “Next” to proceed.
    8. Click on “Finish” to complete the process.

    I have created a user called “shareuser” with password as 123456. But please always use stronger password. Mine is just a test environment.

    2. Create a Windows folder and enable sharing
    In this step, we will create a new folder in Windows and enable sharing so that it can be accessed from our Ubuntu VM.

    1. Open File Explorer and navigate to the location where you want to create a new folder.
    2. Right-click on the empty space and select “New” > “Folder”.
    3. Name the folder and press “Enter” on your keyboard.
    4. Right-click on the newly created folder and select “Properties”.
    5. In the Properties window, click on the “Sharing” tab.
    6. Click on the “Share” button.
    7. In the “Choose People to Share With” window, enter the name of the user you created earlier (e.g. “shareuser”).

    8. Click on “Add” and then click on the “Share” button.
    9. The folder should now be shared with the user you specified.

    Note: If you don’t see the “Sharing” tab in the folder properties window, you may need to enable file and printer sharing in Windows by going to “Control Panel” > “Network and Sharing Center” > “Change advanced sharing settings” and selecting “Turn on file and printer sharing”. And I will be replacing the hostname “WAHAB” with an IP address in later stages.

    Once you have shared the folder with the user, you can access it from your Ubuntu VM using the SMB protocol.

    3. Enable default or external type network for VMs in Hyper-V
    By default, the virtual machines are connected to the “Default Switch”. To communicate between the host and guest VM, you need to either use this default switch or external type virtual switch. If Private network type switch are used the Windows host will not be able to communicate or transfer files with guest VMs.

    1. Open the Hyper-V Manager on the Windows host machine.
    2. Select the virtual machine you want to connect to the network.
    3. In the right-hand pane, click on “Settings”.
    4. Click on “Network Adapter” and select “Virtual Switch” as the connection type.
    5. Select either the “Default Switch” or an “External” virtual switch that you have previously created.
    6. Click “OK” to save changes.
    7. Start the virtual machine.

    4. Find the private IP of Windows HyperV host
    The private IP of the Windows host is needed to establish a connection between the Windows host and the Ubuntu VM. In order for the Ubuntu VM to access files on the Windows host, it needs to know the private IP address of the host so that it can connect to it over the network

    1. Open the Command Prompt on the Windows host machine by pressing the Windows key + R and then typing “cmd” in the Run dialog box.
    2. In the Command Prompt, type “ipconfig” and press Enter.
    3. Look for the IPv4 Address entry. The number listed next to this entry is the private IP address of the Windows host.
    Note: The private IP address is usually in the format of “192.168.x.x” or “172.x.x.x”.

    5. Check folder shared is accessible using smbclient from Ubuntu VM

    smbclient is a command-line tool used to connect to Windows and Samba file servers. It allows us to browse and manipulate files and directories on remote servers using the Server Message Block (SMB) protocol.

    In this step, we will use smbclient to verify if the shared folder is accessible from the Ubuntu VM.

    Step-by-step guide for checking if the share is accessible using smbclient:

    1. Open the terminal on Ubuntu VM.
    2. Install smbclient if it’s not installed using the following command:

    sudo apt-get install smbclient

    3. Connect to the shared folder using the following command:

    smbclient -U shareuser //172.30.96.1/FolderToShare

    Note: Replace “shareuser” with the username of the Windows local user you created and “FolderToShare” with the name of the shared folder you created
    4. Enter the password for the Windows local user when prompted.
    5. If the connection is successful, you should see a prompt like this:

    6. Mount the Windows share using cifs
    CIFS (Common Internet File System) is a network protocol that allows Linux systems to access and share files and directories with Windows operating systems. It is needed to mount the Windows share on the Ubuntu VM so that the Ubuntu user can access the shared files and directories.

    Here are the step-by-step instructions for mounting the Windows share using cifs:

    Create a directory where you want to mount the Windows share. For example, let’s create a directory called “windows_share” under the home directory:

    mkdir ~/windows_share

    Install the cifs-utils package if it’s not already installed on the Ubuntu VM:

    sudo apt-get update
    sudo apt-get install cifs-utils

    Create a file and add the Windows user credentials in it.

    nano /home/wahab/.smbcredentials
    
    username=shareuser
    password=123456

    Replace “shareuser” with the username you created for file sharing on your Windows host.
    Replace “123456” with the password you set for the user.

    Open the “/etc/fstab” file using a text editor with root privileges, such as nano:

    sudo nano /etc/fstab

    Add the following line at the end of the file:

    //172.30.96.1/FolderToShare /home/wahab/windows_share cifs credentials=/home/wahab/.smbcredentials,uid=wahab,gid=wahab 0 0

    Replace “172.30.96.1” with your Windows host IP address.
    Replace “FolderToShare” with the name of the shared folder on your Windows host.
    “/home/wahab/windows_share” will be the folder you mounting your Windows share. So you may choose different one as per your need.
    The “uid” and “gid” options set the ownership of the mounted directory to the Ubuntu user “wahab”, replace them with yours.
    The “0 0” options indicate that the filesystem should be dumped and checked by default.
    Save and close the file.

    Here’s how to mount and unmount the Windows share as the Ubuntu user “wahab”:

    To mount the share:

    sudo mount ~/windows_share

    Check if the Windows share is mounted by running a “df -h” command

    To unmount the share:

    sudo umount ~/windows_share

    In conclusion, sharing files between a Windows host and Ubuntu VM can be accomplished through the use of the Common Internet File System (CIFS) protocol. The process involves creating a new Windows local user for sharing and authentication, creating a Windows folder and enabling sharing, and configuring the network settings in Hyper-V. Once these steps are completed, you can easily access the shared folder from your Ubuntu VM as if it were on the local machine. It’s important to ensure that you follow security best practices by using a dedicated user account for file sharing and setting a strong password. With these steps, you can establish a seamless and secure file sharing system between Windows and Ubuntu.

    Installing PHP GEOS module on a RunCloud Server

    PHP GEOS is a PHP extension for geographic objects support, while RunCloud is a cloud server control panel designed for PHP applications. With PHP GEOS module installed on RunCloud, PHP applications can take advantage of geographic data and use the GEOS (Geometry Engine – Open Source) library to perform spatial operations.

    In this blog post, I will show you how to install PHP GEOS module on RunCloud module.

    Steps
    1. Install the required development tools

    Before installing the PHP GEOS module, make sure that the required development tools are installed on your Ubuntu server. You can install them by running the following command:

    apt-get install autoconf

    2. Install GEOS library
    Next, download and install the latest GEOS (Geometry Engine – Open Source)

    wget http://download.osgeo.org/geos/geos-3.9.4.tar.bz2
    tar xvf geos-3.9.4.tar.bz2
    cd geos-3.9.4/
    ./configure
    make
    make install

    3. Install PHP GEOS module

    Now, it’s time to install the PHP GEOS module. Follow the steps below to install it for PHP 8.2:

    # Set module name
    MODULE_NAME="geos"

    Download the latest module files

    git clone https://git.osgeo.org/gitea/geos/php-geos.git
    mv php-geos/ php-geos_PHP82

    # make clean will always fail if you never compile it before
    make clean
    /RunCloud/Packages/php82rc/bin/phpize --clean
    /RunCloud/Packages/php82rc/bin/phpize
    ./configure --with-php-config=/RunCloud/Packages/php82rc/bin/php-config
    make && make install

    This will install geos.so in the correct php extension directory

    4. Add the module to PHP.ini file
    echo "extension=$MODULE_NAME.so" > /etc/php82rc/conf.d/$MODULE_NAME.ini

    And finally restart the PHP FPM service
    systemctl restart php82rc-fpm

    It’s important to note that the above steps are specific to PHP 8.2. If you wish to install the module for a different version, you will need to modify the commands accordingly. For instance, you can replace PHP 8.2 with 8.1 with below changes:
    Replace /RunCloud/Packages/php82rc/bin/phpize with /RunCloud/Packages/php81rc/bin/phpize, replace ./configure –with-php-config=/RunCloud/Packages/php82rc/bin/php-config with ./configure –with-php-config=/RunCloud/Packages/php81rc/bin/php-config, replace /etc/php82rc/conf.d/$MODULE_NAME.ini with /etc/php81rc/conf.d/$MODULE_NAME.ini, and replace systemctl restart php82rc-fpm with systemctl restart php81rc-fpm.

    You can contact me if you need help with installing any custom modules on RunCloud control panel.

    Page 1 of 7

    Powered by WordPress & Theme by Anders Norén