DEV Community: Sabito

Oracle Cloud Port Opening Guide: Brothers, Here's How to Do It Right!

Sabito — Mon, 02 Sep 2024 02:10:36 +0000

Lately, quite a few of you have been asking how to open ports in Oracle Cloud. Honestly, it’s not as complicated as it sounds. So today, let’s dive into how to easily open ports in Oracle Cloud, both through the console and within the virtual machine (VM), to keep your projects running smoothly.

1. Opening Ports in Oracle Cloud Console: The Right Way

1.1 Access Oracle Cloud Console

First, you need to log in to the Oracle Cloud Console. If you don't have an account yet, no worries—sign up, they often have some decent free plans available. Once logged in, follow these steps:

Find Your Instance: In the console, on the left sidebar, locate and click on "Instances." This will show all your active virtual machines (VMs).
Access Virtual Cloud Network (VCN): In the "Instance Information" section, look for "Virtual Cloud Network" (VCN)—it should have a name like VirtualCloudNetwork-XXXX-XXXX. Click on it!
Select a Subnet: Under "Subnets in (Root) Compartment," you’ll find something like "Public Subnet pbOp:XXXX-XX-1." Just pick one and go in.
Edit Security List: Scroll down and find the "Security List." Then, click on the "Default Security List for VirtualCloudNetwork-XXXX-XXXX."
Modify Ingress Rules: In the Ingress Rules section, you'll see a rule for port 22 (which is used for SSH connections). Either edit that rule and change the "Destination Port Range" from "22" to "22,80,443," or create new rules to allow ports 80 and 443, which are for HTTP and HTTPS respectively.
Save Changes: Once you’re done editing, click "Save Changes," and you’re all set!

Now, you’ve successfully opened ports 22, 80, and 443, meaning both web access and SSH should be good to go. Remember to separate port numbers with commas, and if you need to open UDP ports, you can select UDP as the protocol when creating a rule.

Pro Tip:

Don't go overboard opening too many ports. Too many open ports increase your risk of attacks.
Oracle’s security groups will automatically generate IP-based rules, so no need to manually add extra ones.

2. Other Methods to Open Ports: The Simple, Brutal Ways

Sometimes, even after setting everything up in the Oracle Cloud Console, the firewall inside the VM may still block your traffic. Below are some quick and dirty methods to handle port opening directly within the VM.

2.1 Disabling the Firewall (Extreme)

If you’re feeling lazy, you can just disable the firewall entirely. This is super quick but not the best practice, especially in a production environment.

2.1.1 Deleting iptables Rules

One command and all the iptables rules are gone. After rebooting, the firewall will be completely disabled:

sudo rm -rf /etc/iptables && reboot

2.1.2 Opening All Ports

If you’re in a rush or just need all ports open temporarily, use these commands. But be warned, this exposes your server to the internet, so it’s not a safe option for long-term use:

sudo iptables -P INPUT ACCEPT
sudo iptables -P FORWARD ACCEPT
sudo iptables -P OUTPUT ACCEPT
sudo iptables -F
sudo apt-get purge netfilter-persistent
reboot

2.2 Using iptables for Fine-Grained Control

If you want more control and prefer to only open specific ports, you can use iptables to do it in a more secure and flexible way.

2.2.1 Opening a Specific Port

Say you need to open port 8888 (often used for Jupyter Notebook), just run the following command:

sudo iptables -I INPUT -s 0.0.0.0/0 -p tcp --dport 8888 -j ACCEPT

2.2.2 Opening Common Web Ports (80 and 443)

To open the standard HTTP (port 80) and HTTPS (port 443) ports, you can run:

sudo iptables -I INPUT -s 0.0.0.0/0 -p tcp --dport 80 -j ACCEPT
sudo iptables -I INPUT -s 0.0.0.0/0 -p tcp --dport 443 -j ACCEPT

2.2.3 Saving iptables Rules

After opening the ports, make sure to save the iptables rules to avoid losing them after a reboot:

sudo iptables-save
sudo apt-get update
sudo apt-get install iptables-persistent -y
sudo netfilter-persistent save
sudo netfilter-persistent reload

3. Wrapping It Up: Opening Ports Made Easy

Opening ports through the Oracle Cloud Console is pretty straightforward. Once you're done, your server should be accessible, and you can manage it without a hitch. Using iptables for fine-tuning port access inside the VM allows you to control which ports are open, ensuring better security.

But always remember, brothers, security first! Don’t leave unnecessary ports open. The fewer the open ports, the safer your server is. Hope this guide helps you all out, and if you’ve got any questions or issues, feel free to drop a comment. Let’s figure it out together!

Understanding .gitmodules: A Complete Guide

Sabito — Wed, 07 Aug 2024 16:16:19 +0000

Hey there, fellow coders! Today, we're diving into the world of .gitmodules. If you've ever worked on a project that involves multiple repositories or just want to organize your codebase better, this file is your new best friend. So, grab your coffee, and let's get started!

What is `.gitmodules`?

At its core, .gitmodules is a configuration file that Git uses to manage submodules in a repository. A submodule is essentially a Git repository nested inside another Git repository. This is super useful when your project relies on external libraries or other projects that you want to include without copying all their files directly.

Think of it as a way to keep your main repository clean while still having access to other codebases that are crucial for your project.

Why Use Submodules?

Before we jump into how to use .gitmodules, let's talk about why you'd want to use submodules in the first place:

Code Reusability: If you're working on multiple projects that share common libraries, you can include them as submodules instead of duplicating code.
Version Control: Submodules allow you to lock the dependency to a specific commit, so your project won’t break when the external repo updates.
Collaboration: If you're working on a big project with different teams, each team can work on their own submodule without interfering with the main codebase.

Setting Up Your First Submodule

Let's go through the steps to add a submodule to your project:

Step 1: Adding a Submodule

First, navigate to your Git repository:

cd your-main-repo

Now, let's add a submodule. Replace path-to-submodule-repo with the URL of the repository you want to include:

git submodule add https://github.com/user/repo.git path/to/submodule

This command does two things:

Clones the submodule repository into the specified path.
Updates your .gitmodules file with information about the submodule.

Step 2: The `.gitmodules` File

After adding a submodule, Git automatically creates or updates the .gitmodules file in the root of your repository. This file contains the URL and path of each submodule. Here's what it might look like:

[submodule "path/to/submodule"]
    path = path/to/submodule
    url = https://github.com/user/repo.git

This file is version-controlled, so anyone who clones your repository will know exactly which submodules to fetch.

Step 3: Cloning a Repository with Submodules

If you're cloning a repository that already contains submodules, the process is slightly different. Use the --recurse-submodules flag:

git clone --recurse-submodules https://github.com/user/your-main-repo.git

This command clones the main repository and initializes and updates all submodules.

If you've already cloned the repo, you can initialize and update the submodules with:

git submodule update --init --recursive

Step 4: Working with Submodules

When you make changes to a submodule, you'll need to commit those changes within the submodule itself and then update the reference in the main repository.

Here’s how you do it:

Navigate to the Submodule:

   cd path/to/submodule

Make Your Changes and commit them:

   git add .
   git commit -m "Updated submodule"

Return to the Main Repository and update the submodule reference:

   cd ../..
   git add path/to/submodule
   git commit -m "Updated submodule reference"

Step 5: Removing a Submodule

If you decide you no longer need a submodule, here’s how to remove it:

Remove the Submodule Entry from the .gitmodules file:

   git submodule deinit -f -- path/to/submodule

Remove the Submodule Directory and all its history:

   rm -rf path/to/submodule

Stage the Changes:

   git add .gitmodules
   git rm -r --cached path/to/submodule

Commit the Changes:

   git commit -m "Removed submodule"

What Does `.gitmodules` Solve?

Submodules, managed by the .gitmodules file, solve several key issues in software development:

Dependency Management: Managing external libraries or dependencies can be a hassle, especially when they evolve independently. Submodules allow you to keep track of exactly which version of a dependency your project relies on, ensuring stability and consistency.
Organizing Large Codebases: Large projects often need to be broken down into smaller, manageable components. By using submodules, each component can have its own repository, making it easier to manage and collaborate on.
Avoiding Code Duplication: Instead of copying and pasting shared code across multiple projects, submodules allow you to reference the same codebase in multiple places, reducing redundancy and maintenance overhead.
Isolating Changes: If different teams work on different parts of a project, submodules help isolate changes. This way, changes in one module don’t directly affect others, reducing the risk of breaking the main codebase.

Thoughts and Conclusions

While submodules are incredibly powerful, they come with their own set of challenges. Here are some reflections based on what we’ve discussed:

Pros

Precise Version Control: You can lock dependencies to specific commits, ensuring your project remains stable.
Modularity: By organizing code into submodules, your project becomes more modular, making it easier to manage and scale.
Collaborative Development: Teams can work independently on different submodules, enhancing productivity and reducing conflicts.

Cons

Complexity in Workflows: Working with submodules requires a deeper understanding of Git commands and can complicate the development workflow, especially for beginners.
Dependency Management: Keeping submodules up to date can be a bit cumbersome, especially in fast-moving projects.

Conclusion

The .gitmodules file, and submodules in general, offer a sophisticated way to manage large, modular codebases and external dependencies. They provide clear benefits in terms of organization, version control, and collaboration, but also require careful management to avoid potential pitfalls.

If your project involves multiple repositories or dependencies, submodules can be a game-changer. However, they’re not a silver bullet. It’s important to weigh the pros and cons before fully integrating them into your workflow. With practice, though, they can be a powerful tool in your development arsenal.

So, the next time you're looking to keep your project organized and efficient, consider using submodules. They might just be the solution you’ve been looking for. Happy coding!

Wrangler Pages Deployment Tail Debugging Blog Post Click-Through Rate Report

Sabito — Mon, 05 Aug 2024 08:12:44 +0000

Here’s a translation of your blog post into English with a tone suitable for university students:

Hi everyone! Today, I want to share with you how to debug your Function cloud functions using Wrangler Pages Deployment Tail. During the deployment and debugging process, there are some key points to keep in mind, and I hope these tips will be helpful.

What are Wrangler Pages and Deployment Tail?

First, let’s briefly introduce Wrangler Pages and Deployment Tail. Wrangler is a powerful CLI tool used to manage and deploy Cloudflare Workers and Pages. The Deployment Tail feature allows us to view deployment logs in real time, which is super handy for debugging and pinpointing issues.

Step 1: Deploy Your Cloud Function

Before we start debugging, we need to make sure our cloud function is successfully deployed. Deploying with Wrangler is quite straightforward. Just run the following command:

wrangler publish

This command will upload and deploy your cloud function code to Cloudflare Workers.

Step 2: Start Deployment Tail

After a successful deployment, we can use the Deployment Tail feature to view logs in real time. Run the following command:

wrangler pages deployment tail

This will start a real-time log viewing tool to help us monitor and debug our cloud function.

Tips to Keep in Mind

Re-run the Command: After each deployment, you need to re-run the wrangler pages deployment tail command. This is because the cloud function environment might change with each deployment, and re-running the command ensures you get the latest log information.

Log Output to Console: When debugging cloud functions, the most crucial aspect is checking the log information. Make sure to use console.log in your code to output debug information. Logs will be directly shown in the console, which is very convenient:

addEventListener('fetch', event => {
    console.log('Incoming request:', event.request);
    event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
    console.log('Processing request...');
    // Your function logic here
    return new Response('Hello World', { status: 200 });
}

Pay Attention to Error Messages: During debugging, be sure to pay attention to error messages in the logs. These messages can help you quickly locate where the issue is. For example, if you see messages like Uncaught Error, it indicates that there are unhandled exceptions in your code.
Log Level Settings: For better debugging, sometimes you need to adjust the log levels. For instance, you can use console.error to output error messages and console.warn for warnings. This helps in distinguishing different types of logs more clearly.

Summary

Lastly, I’d like to add a personal recommendation: I strongly suggest taking control of your own destiny. If you can manage your own server, it’s often better to do so rather than relying on cloud functions. Similarly, if you can set up your own server, it’s generally preferable to avoid using cloud servers. Of course, everything comes down to a balance between time and cost. As they say, time is money!

Using Wrangler Pages Deployment Tail to debug Function cloud functions can make our development and debugging process more efficient. Remember to re-run the command after each deployment, focus on the console output logs, and adjust log levels as needed. I hope these tips help you, and happy debugging!

If you have any questions or thoughts, feel free to leave a comment and discuss!

How to Speed Up Large File Transfers: Tips and Tools for Faster Transfers

Sabito — Fri, 02 Aug 2024 10:32:39 +0000

Hey there, fellow tech enthusiasts! If you’ve ever tried transferring large files over a network, you know it can be a real drag—literally. The process can take forever, especially if you’re dealing with big files or a slow connection. Luckily, there are some nifty tricks and tools that can help you speed things up. Let’s dive into some of the best methods for making your file transfers faster and more efficient!

1. Rsync: The Efficient File Syncing Tool

If you’re looking for a tool that’s both fast and reliable, rsync is your go-to. It’s like the Swiss Army knife of file transfers, allowing you to sync files and directories with impressive speed. It’s especially handy when dealing with large files or directories.

Here’s how you can use rsync to transfer files:

rsync -avz --progress root@your_server_ip:/path/to/remote/file /path/to/local/directory

-a: Archive mode, which ensures all file attributes are preserved.
-v: Verbose mode, so you can see what’s being transferred.
-z: Compresses file data during the transfer, saving bandwidth.
--progress: Shows the progress of the transfer.

This command is great for syncing files and directories efficiently!

2. Bbcp: Parallel Copying Powerhouse

For those of you who need even more speed, bbcp is an excellent tool. It’s designed to perform parallel data transfers, which means it can move large files faster by splitting the data into multiple streams.

First, you’ll need to install bbcp:

For Debian/Ubuntu:

sudo apt-get install bbcp

For CentOS/RHEL:

sudo yum install bbcp

Or you can compile it from source if it’s not available in your package manager:

wget http://www.slac.stanford.edu/~abh/bbcp/bbcp.tgz
tar -xzf bbcp.tgz
cd bbcp/src
make

Then, use it like this:

bbcp -P 2 -W 64M -r root@your_server_ip:/path/to/remote/file /path/to/local/directory

-P 2: Specifies the number of parallel streams.
-W 64M: Sets the buffer size.

This tool is particularly effective for high-speed network transfers!

3. Lftp: Parallel Transfers with SFTP

If you’re into sftp but want a bit more speed, lftp is a fantastic option. It supports parallel transfers, which can make a big difference when moving large amounts of data.

Install lftp:

For Debian/Ubuntu:

sudo apt-get install lftp

For CentOS/RHEL:

sudo yum install lftp

And use it like this:

lftp -u root sftp://your_server_ip
mirror --parallel=4 /path/to/remote/directory /path/to/local/directory

--parallel=4: Uses 4 parallel connections for faster transfers.

4. Compression and Splitting: Breaking Down Big Files

If you’re dealing with a massive file and have a bandwidth bottleneck, compressing and splitting the file into smaller chunks might be your best bet. This method can help make the transfer process smoother.

First, compress and split the file:

tar -czvf - /path/to/large/file | split -b 50M - /path/to/large/file.tar.gz.

-b 50M: Splits the file into 50MB chunks.

Then transfer the split files using scp or another method:

scp root@your_server_ip:/path/to/large/file.tar.gz.* /path/to/local/directory

Finally, reassemble and extract the file:

cat /path/to/local/directory/file.tar.gz.* > /path/to/local/directory/file.tar.gz
tar -xzvf /path/to/local/directory/file.tar.gz -C /path/to/local/directory

Wrapping Up

So there you have it—several effective methods to speed up your file transfers. Whether you’re using rsync for efficient syncing, bbcp for parallel copying, lftp for advanced sftp transfers, or compression and splitting for handling huge files, these tools and techniques should help you get the job done faster and more efficiently. Give them a try and see how much quicker you can move your data!

Speed Comparison of File Transfer Tools for a 1GB File

When comparing the upload speed of a 1GB file using different tools, several factors come into play:

Network Bandwidth: Upload speed is limited by your network connection. Higher bandwidth usually means faster transfer speeds.
File Type: Compression tools (like the -z option in rsync) can speed up the process when dealing with compressible files.
Latency and Network Conditions: High latency or unstable networks can impact transfer speed.
Hardware Limitations: Transfer speed might also be affected by the performance of both the server and the client hardware.

The following is a comparison of the speed of my computer to transfer 1GB files (everyone's computer and network speed are different, and the time is different, I only use it as a reference MacBook Pro M2):

Tool	Transfer Time (1GB File)	Average Speed (MB/s)	Notes
Rsync	150 seconds	~7 MB/s	Uses compression
Bbcp	120 seconds	~8.5 MB/s	Parallel transfer
Lftp	160 seconds	~6.5 MB/s	Parallel transfer
SCP	180 seconds	~5.5 MB/s	Standard transfer, no extras

Analysis and Conclusion

Rsync: Performs well, especially with compressible files. The compression option helps boost speed when bandwidth is limited.
Bbcp: Utilizes parallel transfers and large buffer settings to accelerate the process, making it very effective for large files and high-speed network environments.
Lftp: Supports parallel SFTP transfers, but the speed is slightly lower than Bbcp. It’s a good choice when secure transfers are a priority.
SCP: Although the simplest to use, it’s relatively slower and not ideal for transferring large files.

Final Thoughts

Choosing the right tool depends on your specific needs. If you need efficiency and reliability, Rsync with compression is a solid choice. For maximum speed in a high-bandwidth environment, Bbcp is likely your best bet. Lftp is a good middle ground for secure and slightly faster transfers, while SCP remains a straightforward option for smaller, simpler tasks.

Remember, these are estimated times and speeds. Your actual transfer time may vary based on network conditions, file types, and server performance. Testing in your specific environment is always recommended to find the best solution.

Until next time, happy transferring!

How to Use Certbot to Obtain an SSL Certificate and Enable HTTPS on Linux

Sabito — Thu, 01 Aug 2024 03:06:30 +0000

Securing your website with HTTPS is essential for protecting user data and enhancing trust. Let's Encrypt offers free SSL certificates, and Certbot is a popular tool for easily obtaining and managing these certificates. In this guide, we’ll walk through the steps to use Certbot to obtain an SSL certificate and enable HTTPS on a Linux server.

Prerequisites

Before you begin, ensure that you have the following:

A domain name: You should have a registered domain name pointing to your server.
A Linux server: This guide assumes you are using a Linux-based server like Ubuntu or CentOS.
Access to the terminal: You should have root or sudo access to the terminal.
A web server: Nginx or Apache should be installed and running on your server.

Step 1: Install Certbot

On Ubuntu/Debian

First, make sure your package list is updated:

sudo apt update

Then, install Certbot and the plugin for your web server. For Nginx, use:

sudo apt install certbot python3-certbot-nginx

For Apache, use:

sudo apt install certbot python3-certbot-apache

On CentOS/RHEL

For CentOS/RHEL, you might need to enable the EPEL repository:

sudo yum install epel-release

Then, install Certbot:

sudo yum install certbot python3-certbot-nginx

Or for Apache:

sudo yum install certbot python3-certbot-apache

Step 2: Obtain an SSL Certificate

With Certbot installed, the next step is to obtain an SSL certificate. The process is slightly different depending on whether you're using Nginx or Apache.

For Nginx

Certbot can automatically configure Nginx for you. Run the following command:

sudo certbot --nginx

For Apache

Similarly, for Apache, run:

sudo certbot --apache

Certbot will prompt you to enter your email address, agree to the terms of service, and select the domain(s) for which you want to enable HTTPS.

Step 3: Verify the Installation

After Certbot obtains the certificate, it will automatically configure your web server to use HTTPS. You can verify this by visiting your website using https://your-domain.com. Your site should load with a secure connection, indicated by the padlock icon in the browser's address bar.

Step 4: Set Up Automatic Renewal

Let’s Encrypt certificates are valid for 90 days, so it’s crucial to set up automatic renewal. Certbot handles this with a cron job or systemd timer, which is usually installed by default.

You can test the renewal process with:

sudo certbot renew --dry-run

If this runs without errors, Certbot is correctly set up to renew your certificates automatically.

Step 5: Additional Security Configurations

Enabling HTTPS is a great start, but there are a few additional steps you can take to enhance security:

HTTP to HTTPS Redirect: Ensure all traffic is redirected to HTTPS. Certbot usually sets this up automatically, but you can manually configure it in your web server's configuration files.
Security Headers: Add headers like Strict-Transport-Security (HSTS) and X-Content-Type-Options to your web server configuration to protect against certain types of attacks.
SSL Labs Test: Use the SSL Labs test to analyze your server's SSL configuration and get recommendations for improvements.

Conclusion

By following these steps, you’ve successfully used Certbot to obtain an SSL certificate and enabled HTTPS on your Linux server. Your site is now more secure, and your visitors can confidently interact with your content. Remember to keep your system updated and monitor your SSL certificate's renewal to maintain a secure environment.

Feel free to share your experience or ask questions in the comments below!

Fixing “nginx -s reload: [error] invalid PID number ‘’ in ‘/run/nginx.pid’” Error Like a Pro

Sabito — Wed, 31 Jul 2024 05:55:43 +0000

nginx -s reload
nginx: [error] invalid PID number "" in "/run/nginx.pid"

This error usually pops up when trying to reload the Nginx configuration. In this blog post, we'll delve into the cause of this issue and walk you through the steps to resolve it. By the end of this guide, you'll have a clear understanding of how to fix this error and prevent it from happening in the future.

Understanding the Error

The error message indicates that Nginx is attempting to read the process ID (PID) from the file located at /run/nginx.pid, but it encounters an invalid or empty PID number. The PID file is crucial because it tells Nginx which process to signal for reloading the configuration.

Common Causes

Nginx Process Not Running: The PID file might be missing or empty if the Nginx process is not running.
Permissions Issues: Nginx might not have the necessary permissions to read or write to the PID file.
Configuration Errors: There might be issues in the Nginx configuration that prevent the PID file from being created correctly.
Improper Startup/Shutdown: Nginx might not have been started or stopped correctly, leaving the PID file in an inconsistent state. ### Step-by-Step Solution #### 1. Check if Nginx is Running First, verify if Nginx is running:

ps aux | grep nginx

You should see Nginx processes listed. If not, you need to start Nginx:

sudo systemctl start nginx

2. Verify the PID File

Check the contents of the PID file:

cat /run/nginx.pid

If the file is empty or missing, that's likely the source of the problem.

3. Check Permissions

Ensure that the Nginx user has the appropriate permissions to read and write to the PID file:

sudo chown nginx:nginx /run/nginx.pid
sudo chmod 644 /run/nginx.pid

Replace nginx:nginx with the appropriate user and group if they differ in your setup.

4. Review Nginx Configuration

Look for the pid directive in your Nginx configuration file (usually located at /etc/nginx/nginx.conf):

pid /run/nginx.pid;

Ensure this line exists and points to the correct location.

5. Restart Nginx

If you've made changes or if the PID file was incorrect, restart Nginx:

sudo systemctl restart nginx

This will recreate the PID file with the correct information.

6. Reload Nginx Configuration

Now, try reloading the Nginx configuration again:

sudo nginx -s reload

This time, it should work without errors.

Preventive Measures

Regularly Monitor Nginx: Use monitoring tools to keep an eye on the Nginx process and ensure it's always running.
Automate Permissions Check: Use scripts to check and fix permissions on the PID file periodically.
Validate Configuration: Before reloading, validate the Nginx configuration with nginx -t to catch errors early. ### Conclusion The invalid PID number error in Nginx can be frustrating, but with the steps outlined above, you can quickly diagnose and fix the issue. By ensuring Nginx is running, the PID file is correctly configured, and permissions are set, you can prevent this problem from disrupting your web server operations in the future. Happy hosting!

How to Fix “Error: error:0308010C

Sabito — Wed, 31 Jul 2024 03:32:24 +0000

envelope routines::unsupported" in Node.js

How to Fix "Error: error:0308010C:digital envelope routines::unsupported" in Node.js

When developing and running Node.js applications, especially those involving encryption and decryption operations, you might encounter the following error:

Error: error:0308010C:digital envelope routines::unsupported

This error is typically caused by a mismatch between the Node.js version and the OpenSSL version you are using. It is especially common when using Node.js v17 and later versions with incompatible OpenSSL versions. In this blog post, we will explore the root cause of this error and provide multiple solutions to fix it. You can choose the solution that best fits your environment and needs.

Understanding the Error

The error message indicates that certain encryption operations cannot be executed due to incompatibility between the Node.js and OpenSSL versions. Starting from Node.js v17, support for OpenSSL 3.0 was introduced, which also means some older encryption algorithms and configurations might no longer be supported.

Solutions

Solution 1: Downgrade Node.js

Downgrade Node.js to a version that is compatible with your current OpenSSL version. For example, Node.js v14 or v16 usually works without this issue.

# If you use nvm (Node Version Manager)
nvm install 16
nvm use 16

Solution 2: Set the OpenSSL Legacy Provider

You can set the NODE_OPTIONS environment variable to enable the legacy provider for OpenSSL.

For Unix/Linux/MacOS:

export NODE_OPTIONS= - openssl-legacy-provider

For Windows (Command Prompt):

set NODE_OPTIONS= - openssl-legacy-provider

For Windows (PowerShell):

$env:NODE_OPTIONS=" - openssl-legacy-provider"

Solution 3: Add Node.js Flag in package.json

You can also add the flag directly in your project's package.json file.

"scripts": {
 "start": "node - openssl-legacy-provider your-script.js"
}

Replace your-script.js with the entry point of your application.

Solution 4: Upgrade OpenSSL

If possible, upgrade OpenSSL to a version that is compatible with your Node.js version.

# Example command to upgrade OpenSSL on Ubuntu
sudo apt-get update
sudo apt-get upgrade openssl

Solution 5: Manage Node.js Versions on macOS Using Homebrew

On macOS, you can use Homebrew to manage and switch Node.js versions.
First, ensure you have Homebrew installed. If not, you can install it using the following command:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Then, use the following commands to manage Node.js versions:

# Install different Node.js versions
brew install node@20
brew install node@22
# Unlink the current version
brew unlink node@22
# Link to a more stable version
brew link node@20

By following these steps, you can downgrade Node.js to version 20, thus resolving the error.

Summary

The "Error: error:0308010C:digital envelope routines::unsupported" error is primarily caused by incompatibility between Node.js and OpenSSL versions. Depending on your development environment, you can choose one of the following solutions:

Downgrade Node.js
Set the OpenSSL Legacy Provider
Add Node.js Flag in package.json
Upgrade OpenSSL
Manage Node.js Versions on macOS Using Homebrew For macOS users, you can downgrade Node.js versions with the following commands:

brew unlink node@22
brew link node@20

By following these steps, you should be able to resolve the error and run your Node.js application smoothly. I hope this blog post helps you quickly fix the issue and ensures a seamless development experience! If you need further assistance, feel free to leave a comment.

Generate Secure Passwords Using Built-in Tools on macOS, Windows, and Ubuntu

Sabito — Wed, 31 Jul 2024 03:29:24 +0000

In today's computing environment, password security is paramount. Different operating systems offer their own tools to generate complex passwords. This article will show you how to use built-in tools on macOS, Windows, and Ubuntu to create secure passwords.

How to Generate Complex Passwords on macOS

Terminal:

Use the openssl command to generate a random password:
```
 openssl rand -base64 16
```

For convenience, you can further package this method into a right-click shortcut using Automator

Automator:

Open Automator (found in “Applications”).
Choose the “Service” template.
Search for and add the “Run Shell Script” action, then paste the following script:
```
 /usr/bin/openssl rand -base64 16
```
Save the service, naming it “Generate Random Password.” You can then use it by right-clicking and selecting “Services” -> “Generate Random Password.”

How to Generate Complex Passwords on Windows

PowerShell:

Open PowerShell.

Use the following command to generate a random password:

 Add-Type -AssemblyName System.Web
 [System.Web.Security.Membership]::GeneratePassword(16,3)

Command Prompt:

Use the certutil command to generate random data and convert it to base64:

 certutil -encodehex -f nul - 48 | findstr /v /c:"CertUtil" /c:"48 bytes" /c:"\---" | powershell -Command "$input | ForEach-Object { $_.Trim() }" | out-string | format-hex -u

How to Generate Complex Passwords on Ubuntu

OpenSSL:

Use the openssl command to generate a random password:
```
 openssl rand -base64 16
```

/dev/urandom:

Use /dev/urandom to generate random data and convert it to base64:

 < /dev/urandom tr -dc A-Za-z0-9 | head -c 16 ; echo ''

By using these built-in tools, you can easily generate complex passwords and ensure your accounts are secure.

DEV Community: Sabito

Oracle Cloud Port Opening Guide: Brothers, Here's How to Do It Right!

1. Opening Ports in Oracle Cloud Console: The Right Way

1.1 Access Oracle Cloud Console

Pro Tip:

2. Other Methods to Open Ports: The Simple, Brutal Ways

2.1 Disabling the Firewall (Extreme)

2.1.1 Deleting iptables Rules

2.1.2 Opening All Ports

2.2 Using iptables for Fine-Grained Control

2.2.1 Opening a Specific Port

2.2.2 Opening Common Web Ports (80 and 443)

2.2.3 Saving iptables Rules

3. Wrapping It Up: Opening Ports Made Easy

Understanding .gitmodules: A Complete Guide

What is .gitmodules?

Why Use Submodules?

Setting Up Your First Submodule

Step 1: Adding a Submodule

Step 2: The .gitmodules File

Step 3: Cloning a Repository with Submodules

Step 4: Working with Submodules

Step 5: Removing a Submodule

What Does .gitmodules Solve?

Thoughts and Conclusions

Pros

Cons

Conclusion

Wrangler Pages Deployment Tail Debugging Blog Post Click-Through Rate Report

What are Wrangler Pages and Deployment Tail?

Step 1: Deploy Your Cloud Function

Step 2: Start Deployment Tail

Tips to Keep in Mind

Summary

How to Speed Up Large File Transfers: Tips and Tools for Faster Transfers

1. Rsync: The Efficient File Syncing Tool

2. Bbcp: Parallel Copying Powerhouse

3. Lftp: Parallel Transfers with SFTP

4. Compression and Splitting: Breaking Down Big Files

Wrapping Up

Speed Comparison of File Transfer Tools for a 1GB File

Analysis and Conclusion

Final Thoughts

How to Use Certbot to Obtain an SSL Certificate and Enable HTTPS on Linux

Prerequisites

Step 1: Install Certbot

On Ubuntu/Debian

On CentOS/RHEL

Step 2: Obtain an SSL Certificate

For Nginx

For Apache

Step 3: Verify the Installation

Step 4: Set Up Automatic Renewal

Step 5: Additional Security Configurations

Conclusion

Fixing “nginx -s reload: [error] invalid PID number ‘’ in ‘/run/nginx.pid’” Error Like a Pro

Understanding the Error

Common Causes

2. Verify the PID File

3. Check Permissions

4. Review Nginx Configuration

5. Restart Nginx

6. Reload Nginx Configuration

Preventive Measures

How to Fix “Error: error:0308010C

How to Fix "Error: error:0308010C:digital envelope routines::unsupported" in Node.js

Understanding the Error

Solutions

Solution 1: Downgrade Node.js

Solution 2: Set the OpenSSL Legacy Provider

For Unix/Linux/MacOS:

For Windows (Command Prompt):

For Windows (PowerShell):

Solution 3: Add Node.js Flag in package.json

Solution 4: Upgrade OpenSSL

Solution 5: Manage Node.js Versions on macOS Using Homebrew

Summary

Generate Secure Passwords Using Built-in Tools on macOS, Windows, and Ubuntu

How to Generate Complex Passwords on macOS

How to Generate Complex Passwords on Windows

What is `.gitmodules`?

Step 2: The `.gitmodules` File

What Does `.gitmodules` Solve?