Orthogonal Thinking

Blog

  • How to move files around with scp

    Picture this: it’s 3 AM, and you’re debugging an issue on a remote server. Logs are piling up, and you need to download a massive file to analyze it locally. Or maybe you’re deploying a quick patch to a production server and need to upload a configuration file. In moments like these, scp (Secure Copy) is your best friend. It’s simple, reliable, and gets the job done without unnecessary complexity. But like any tool, using it effectively requires more than just knowing the basic syntax.

    In this guide, we’ll go beyond the basics of scp. You’ll learn how to securely transfer files, optimize performance, avoid common pitfalls, and even troubleshoot issues when things go sideways. Whether you’re a seasoned sysadmin or a developer just getting started with remote servers, this article will arm you with the knowledge to wield scp like a pro.

    What is scp?

    scp stands for Secure Copy, and it’s a command-line utility that allows you to transfer files between local and remote systems over an SSH connection. It’s built on top of SSH, which means your data is encrypted during transfer, making it a secure choice for moving sensitive files.

    Unlike modern tools like rsync, scp is straightforward and doesn’t require additional setup. If you have SSH access to a remote machine, you can use scp immediately. However, this simplicity comes with trade-offs, which we’ll discuss later in the article.

    Downloading Files from a Remote Server

    Let’s start with the most common use case: downloading a file from a remote server to your local machine. Here’s the basic syntax:

    scp -i conn.pem [email protected]:/home/azureuser/output.gz ./output.gz

    Here’s what’s happening in this command:

    • -i conn.pem: Specifies the private key file for SSH authentication.
    • [email protected]: The username and IP address of the remote server.
    • :/home/azureuser/output.gz: The absolute path to the file on the remote server.
    • ./output.gz: The destination path on your local machine.

    After running this command, the file output.gz will be downloaded to your current working directory.

    💡 Pro Tip: Use absolute paths on the remote server to avoid confusion, especially when dealing with complex directory structures.

    Real-World Example: Downloading Logs

    Imagine you’re troubleshooting an issue on a remote server, and you need to analyze the logs locally:

    scp -i ~/.ssh/id_rsa admin@prod-server:/var/log/nginx/access.log ./access.log

    This command downloads the Nginx access log to your local machine. If the file is large, consider using the -C option to compress it during transfer:

    scp -C -i ~/.ssh/id_rsa admin@prod-server:/var/log/nginx/access.log ./access.log

    Compression can significantly speed up transfers, especially for text-heavy files like logs.

    Uploading Files to a Remote Server

    Uploading files is just as straightforward. The syntax is almost identical, but the source and destination paths are reversed:

    scp -i conn.pem ./config.yaml [email protected]:/etc/myapp/config.yaml

    In this example:

    • ./config.yaml: The file on your local machine that you want to upload.
    • [email protected]:/etc/myapp/config.yaml: The destination path on the remote server.
    ⚠️ Gotcha: Ensure the destination directory on the remote server exists and has the correct permissions. Otherwise, the command will fail.

    Real-World Example: Deploying Configuration Files

    Let’s say you’re deploying a new configuration file to a production server:

    scp -i ~/.ssh/id_rsa ./nginx.conf admin@prod-server:/etc/nginx/nginx.conf

    After uploading, don’t forget to reload or restart the service to apply the changes:

    ssh -i ~/.ssh/id_rsa admin@prod-server "sudo systemctl reload nginx"

    Advanced scp Options

    scp comes with several options that can make your life easier. Here are some of the most useful ones:

    • -C: Compresses files during transfer, which can speed up the process for large files.
    • -P: Specifies the SSH port if it’s not the default port 22.
    • -r: Recursively copies directories and their contents.
    • -p: Preserves the original access and modification times of the files.

    Example: Copying an Entire Directory

    To copy a directory and all its contents, use the -r option:

    scp -r -i conn.pem ./my_project [email protected]:/home/azureuser/

    This command uploads the entire my_project directory to the remote server.

    🔐 Security Note: Avoid using scp with password-based authentication. Always use SSH keys for better security.

    Common Pitfalls and Troubleshooting

    While scp is generally reliable, you may encounter issues. Here are some common problems and how to solve them:

    1. Permission Denied

    If you see a “Permission denied” error, check the following:

    • Ensure your SSH key has the correct permissions: chmod 600 ~/.ssh/id_rsa.
    • Verify that your user account has write permissions on the remote server.

    2. Connection Timeout

    If the connection times out, confirm that:

    • The remote server’s SSH service is running.
    • You’re using the correct IP address and port.

    3. Slow Transfers

    For slow transfers, try enabling compression with the -C option. If the issue persists, consider using rsync, which is more efficient for large or incremental transfers.

    When to Use scp (and When Not To)

    scp is great for quick, one-off file transfers. However, it’s not always the best choice:

    • For large datasets or incremental backups, use rsync.
    • For automated workflows, consider tools like sftp or ansible.

    That said, scp remains a valuable tool in your arsenal, especially for its simplicity and ubiquity.

    Key Takeaways

    • scp is a simple and secure way to transfer files over SSH.
    • Use options like -C, -r, and -p to enhance functionality.
    • Always use SSH keys for authentication to improve security.
    • Be mindful of permissions and directory structures to avoid errors.
    • For large or complex transfers, consider alternatives like rsync.

    Now it’s your turn: What’s your favorite scp trick or tip? Share it in the comments below!

  • How to execute a command(s) or a script via SSH

    Imagine this: you’re sipping coffee at your desk, and you suddenly need to check the status of a remote server. Do you really want to fire up a full-blown remote desktop or wrestle with clunky web dashboards? No way. With SSH, you can execute commands remotely—fast, simple, and scriptable. If you’re not using this technique yet, you’re missing out on one of the best productivity hacks in the sysadmin and developer toolkit.

    Running a Single Command Over SSH

    Want to check the uptime of a remote machine? Just send the command directly and get the output instantly:

    ssh [email protected] 'uptime'

    Tip: The command inside single quotes runs on the remote host, and its output comes right back to your terminal. This is perfect for quick checks or automation scripts.

    Executing Multiple Commands

    Sometimes, you need to run a sequence of commands. You don’t have to SSH in and type them one by one. Use a here document for multi-command execution:

    ssh [email protected] << EOF
COMMAND1
COMMAND2
COMMAND3
EOF

    Gotcha: Make sure your EOF delimiter is at the start of the line—no spaces! Also, remember that environment variables and shell settings may differ on the remote host.

    Running a Local Script Remotely

    Have a script on your local machine that you want to run remotely? You don’t need to copy it over first. Just stream it to the remote shell:

    ssh [email protected] 'bash -s' < myscript.sh

    Pro Tip: This pipes your local myscript.sh directly to bash on the remote machine. If your script needs arguments, you can pass them after bash -s like this: 

    ssh [email protected] 'bash -s' -- arg1 arg2 < myscript.sh

    Best Practices and Pitfalls

    • Use SSH keys for authentication—never hardcode passwords in scripts.
    • Quote your commands properly to avoid shell interpretation issues.
    • Test locally before running destructive commands remotely. A misplaced rm -rf can ruin your day.
    • Check exit codes if you’re automating deployments. SSH will return the exit status of the remote command.

    Why This Matters

    SSH command execution is a game-changer for deployment, automation, and troubleshooting. It’s fast, scriptable, and—when used wisely—secure. So next time you need to automate a remote task, skip the manual steps and use these SSH tricks. Your future self will thank you.

  • How to move ZVol or Dataset to another pool

    Imagine this: your ZFS pool is running out of space, or perhaps you’ve just set up a shiny new storage array with faster drives. Now you’re faced with the challenge of migrating your existing ZVols or datasets to the new pool without downtime or data loss. If you’ve been there, you know it’s not just about running a couple of commands—it’s about doing it safely, efficiently, and with a plan. In this guide, we’ll dive deep into the process of moving ZVols and datasets between ZFS pools, with real-world examples, performance tips, and security considerations to help you avoid common pitfalls.

    🔐 Security Note: Before we dive in, remember that ZFS snapshots and transfers do not encrypt data by default. If you’re transferring sensitive data, ensure encryption is enabled on the target pool or use an encrypted transport layer like SSH.

    Understanding the Basics: ZVols, Datasets, and Pools

    Before we get into the nitty-gritty, let’s clarify some terminology:

    • ZVol: A block device created within a ZFS pool. It’s often used for virtual machines or iSCSI targets.
    • Dataset: A filesystem within a ZFS pool, typically used for storing files and directories.
    • Pool: A collection of physical storage devices managed by ZFS, which serves as the foundation for datasets and ZVols.

    When you move a ZVol or dataset, you’re essentially transferring its data from one pool to another. This can be done on the same system or across different systems. The key tools for this operation are zfs snapshot, zfs send, and zfs receive.

    Step 1: Preparing for the Migration

    Preparation is critical. Here’s what you need to do before starting the migration:

    1.1 Verify Available Space

    Ensure the target pool has enough free space to accommodate the ZVol or dataset you’re moving. Use the zfs list command to check the size of the source and target pools:

    # Check the size of the source dataset or ZVol
zfs list aaa/myVol

# Check available space in the target pool
zfs list bbb

    

    ⚠️ Gotcha: ZFS does not automatically compress data during transfer unless compression is enabled on the target pool. If your source dataset is compressed, ensure the target pool supports the same compression algorithm, or you may run out of space.
    

    1.2 Create a Snapshot
    

    Snapshots are immutable, point-in-time copies of your ZVol or dataset. They’re essential for ensuring data consistency during the transfer. Use the zfs snapshot command to create a recursive snapshot:
    

    # Create a snapshot of a ZVol
zfs snapshot -r aaa/myVol@relocate

# Create a snapshot of a dataset
zfs snapshot -r aaa/myDS@relocate

    

    💡 Pro Tip: Use descriptive snapshot names that indicate the purpose and timestamp, such as @relocate_20231015. This makes it easier to manage snapshots later.
    

    Step 2: Transferring the Data
    

    With your snapshot ready, it’s time to transfer the data using zfs send and zfs receive. These commands work together to stream the snapshot from the source pool to the target pool.
    

    2.1 Moving a ZVol
    

    To move a ZVol named myVol from pool aaa to pool bbb, run the following commands:
    

    # Send the snapshot to the target pool
zfs send aaa/myVol@relocate | zfs receive -v bbb/myVol

    

    The -v flag in zfs receive provides verbose output, which is helpful for monitoring the transfer progress.
    

    2.2 Moving a Dataset
    

    The process for moving a dataset is identical to moving a ZVol. For example, to move a dataset named myDS from pool aaa to pool bbb:
    

    # Send the snapshot to the target pool
zfs send aaa/myDS@relocate | zfs receive -v bbb/myDS

    

    💡 Pro Tip: If you’re transferring data over a network, use SSH to secure the transfer. For example: zfs send aaa/myDS@relocate | ssh user@remotehost zfs receive -v bbb/myDS.
    

    2.3 Incremental Transfers
    

    If the dataset or ZVol is large, consider using incremental transfers to reduce downtime. First, create an initial snapshot and transfer it. Then, create additional snapshots to capture changes and transfer only the differences:
    

    # Initial transfer
zfs snapshot -r aaa/myDS@initial
zfs send aaa/myDS@initial | zfs receive -v bbb/myDS

# Incremental transfer
zfs snapshot -r aaa/myDS@incremental
zfs send -i aaa/myDS@initial aaa/myDS@incremental | zfs receive -v bbb/myDS

    

    ⚠️ Gotcha: Incremental transfers require all intermediate snapshots to exist on both the source and target pools. Deleting snapshots prematurely can break the chain.
    

    Step 3: Post-Migration Cleanup
    

    Once the transfer is complete, you’ll want to clean up the old snapshots and verify the integrity of the data on the target pool.
    

    3.1 Verify the Data
    

    Use zfs list to confirm that the ZVol or dataset exists on the target pool and matches the expected size:
    

    # Verify the dataset or ZVol on the target pool
zfs list bbb/myVol
zfs list bbb/myDS

    

    3.2 Delete Old Snapshots
    

    If you no longer need the snapshots on the source pool, delete them to free up space:
    

    # Delete the snapshot on the source pool
zfs destroy aaa/myVol@relocate
zfs destroy aaa/myDS@relocate

    

    💡 Pro Tip: Keep the snapshots on the target pool for a few days to ensure everything is working as expected before deleting them.
    

    Performance Considerations
    

    Transferring large datasets or ZVols can be time-consuming, especially if you’re working with spinning disks or a slow network. Here are some tips to optimize performance:
    

      

    • Enable Compression: Use the -c flag with zfs send to compress the data during transfer.
      • 

    • Use Parallel Streams: For very large datasets, split the transfer into multiple streams using tools like mbuffer.
      • 

    • Monitor Resource Usage: Use zpool iostat to monitor disk activity and adjust the transfer rate if necessary.
      • 

    

    Conclusion
    

    Moving ZVols and datasets between ZFS pools is a powerful feature that allows you to reorganize your storage, upgrade hardware, or migrate to a new system with minimal hassle. By following the steps outlined in this guide, you can ensure a smooth and secure migration process.
    

    Key Takeaways:
    

      

    • Always create snapshots before transferring data to ensure consistency.
      • 

    • Verify available space on the target pool before starting the migration.
      • 

    • Use incremental transfers for large datasets to minimize downtime.
      • 

    • Secure your data during network transfers with SSH or encryption.
      • 

    • Clean up old snapshots only after verifying the migration was successful.
      • 

    

    Have you encountered any challenges while migrating ZFS datasets or ZVols? Share your experiences in the comments below, or let us know if there’s a specific topic you’d like us to cover next!

  • Setup k3s on CentOS 7

    Imagine this: you need a lightweight Kubernetes cluster up and running today—no drama, no endless YAML, no “what did I forget?” moments. That’s where k3s shines, especially on CentOS 7. I’ll walk you through the setup, toss in some hard-earned tips, and call out gotchas that can trip up even seasoned pros.

    Step 1: Prerequisites—Get Your House in Order

    Before you touch k3s, make sure your CentOS 7 box is ready. Trust me, skipping this step leads to pain later.

    • Set a static IP and hostname (don’t rely on DHCP for servers!):

      vi /etc/sysconfig/network-scripts/ifcfg-eth0
vi /etc/hostname

      Tip: After editing, restart networking or reboot to apply changes.

    • Optional: Disable the firewall (for labs or trusted networks only):

      systemctl disable firewalld --now

      Gotcha: If you keep the firewall, open ports 6443 (Kubernetes API), 10250, and 8472 (Flannel VXLAN).

    Step 2: (Optional) Install Rancher RKE2

    If you want Rancher’s full power, set up RKE2 first. Otherwise, skip to k3s install.

    1. Create config directory:

      mkdir -p /etc/rancher/rke2
    2. Edit config.yaml:

      token: somestringforrancher
tls-san:
  - 192.168.1.128

      Tip: Replace 192.168.1.128 with your server’s IP. The tls-san entry is critical for SSL and HA setups.

    3. Install Rancher:

      curl -sfL https://get.rancher.io | sh -
    4. Enable and start the Rancher service:

      systemctl enable rancherd-server.service
systemctl start rancherd-server.service
    5. Check startup status:

      journalctl -eu rancherd-server.service -f

      Tip: Look for “Ready” messages. Errors here usually mean a misconfigured config.yaml or missing ports.

    6. Reset Rancher admin password (for UI login):

      rancherd reset-admin

    Step 3: Install k3s—The Main Event

    Master Node Setup

    curl -sfL https://get.k3s.io | K3S_KUBECONFIG_MODE="644" sh -
    • Tip: K3S_KUBECONFIG_MODE="644" makes /etc/rancher/k3s/k3s.yaml world-readable. Good for quick access, but not for production security!
    • Get your cluster token (needed for workers):

      sudo cat /var/lib/rancher/k3s/server/node-token

    Worker Node Setup

    curl -sfL https://get.k3s.io | \
  K3S_URL="https://<MASTER_IP>:6443" \
  K3S_TOKEN="<TOKEN>" \
  K3S_NODE_NAME="<NODE_NAME>" \
  sh -
    • Replace <MASTER_IP> with your master’s IP, <TOKEN> with the value from node-token, and <NODE_NAME> with a unique name for the node.
    • Gotcha: If you see “permission denied” or “failed to connect,” double-check your firewall and SELinux settings. CentOS 7 can be picky.

    Final Thoughts: What’s Next?

    You’ve got a blazing-fast Kubernetes cluster. Next, try kubectl get nodes (grab the kubeconfig from /etc/rancher/k3s/k3s.yaml), deploy a test workload, and—if you’re feeling brave—secure your setup for production. If you hit a snag, don’t waste time: check logs, verify IPs, and make sure your token matches.

    I’m Max L, and I never trust a cluster until I’ve rebooted every node at least once. Happy hacking!

  • Setup a used Aruba S2500 switch and remove stacking ports

    Imagine this: You’ve just scored a used Aruba S2500 switch for a fraction of its original price. It’s sitting on your desk, promising enterprise-grade performance for your home network. But as you power it on, you realize it’s not as plug-and-play as your typical consumer-grade hardware. What now? This guide will walk you through setting up the Aruba S2500, repurposing its stacking ports, and unlocking its full potential—all without breaking the bank.

    Why Consider Enterprise Hardware for Your Home Network?

    Unmanaged Gigabit Ethernet switches are sufficient for most households. They’re simple, reliable, and affordable. But if you’re looking to upgrade to multi-Gigabit speeds—perhaps for a home lab, 4K video editing, or a NAS—you’ll quickly find that consumer-grade options with 10Gbps capabilities are eye-wateringly expensive.

    That’s where used enterprise hardware like the Aruba S2500 comes in. These switches, often retired from corporate environments, offer robust performance and advanced features at a fraction of the cost of new consumer-grade alternatives. For instance, I picked up an Aruba S2500 48P-4SFP+POE for just $115 on eBay. This model includes four SFP+ ports, each capable of 10Gbps, making it perfect for high-speed setups.

    💡 Pro Tip: When buying used enterprise hardware, always check the seller’s reviews and confirm that the device is in working condition. Look for terms like “tested” or “fully functional” in the listing.

    Before We Begin: A Word on Security

    Before diving into the setup, let’s address the elephant in the room: security. Enterprise-grade switches like the Aruba S2500 are designed for managed environments, meaning they often come with default configurations that are not secure for home use. For example, default admin credentials like admin/admin123 are a hacker’s dream. Additionally, outdated firmware can leave your network exposed to vulnerabilities.

    🔐 Security Note: Always update the firmware and change default credentials during setup. Leaving these unchanged is akin to leaving your front door unlocked.

    Step 1: Perform a Factory Reset

    If you’ve purchased a used switch, it’s crucial to start with a clean slate. The previous owner’s configuration could interfere with your setup or, worse, leave security holes.

    To perform a factory reset on the Aruba S2500:

    1. Power on the switch and wait for it to boot up.
    2. Use the front-panel menu to navigate to the reset option.
    3. Confirm the reset and wait for the switch to reboot.

    Once the reset is complete, the switch will return to its default configuration, including default credentials and IP settings.

    Step 2: Access the Management Interface

    After the reset, the switch’s management interface will be accessible at its default IP address: 172.16.0.254. Here’s how to connect:

    1. Connect your computer to one of the switch’s Ethernet ports.
    2. Ensure your computer is set to obtain an IP address via DHCP.
    3. Open a web browser and navigate to http://172.16.0.254.
    4. Log in using the default credentials: admin / admin123.

    If everything is set up correctly, you should see the Aruba S2500’s web-based management interface.

    ⚠️ Gotcha: If you can’t connect to the management interface, double-check your computer’s IP settings and ensure the switch is properly reset.

    Step 3: Configure the Switch

    Now that you’re logged in, it’s time to configure the switch. Follow these steps:

    1. Complete the setup wizard to assign a static IP address for management. This ensures you can easily access the switch in the future.
    2. Update the firmware to the latest version. Aruba provides firmware updates on their support site, but you’ll need to create an account to download them.

    To update the firmware:

    # Example of updating firmware via CLI
copy tftp://<TFTP_SERVER_IP>/<FIRMWARE_FILE> system:partition0
reload
    

    Replace <TFTP_SERVER_IP> and <FIRMWARE_FILE> with the appropriate values for your setup.
    

    
💡 Pro Tip: Always update both firmware partitions to ensure you have a fallback in case of a failed upgrade.

    

    Step 4: Repurpose Stacking Ports
    

    The Aruba S2500 includes two dedicated stacking ports, which are typically used to connect multiple switches in a stack. However, in a home setup, you’re unlikely to need this feature. Instead, you can repurpose these ports for regular network traffic.
    

    To repurpose the stacking ports:
    

      

    1. Connect to the switch via SSH or a serial console. You can use tools like PuTTY or the built-in terminal on macOS/Linux.
      2. 

    2. Enter enable mode by typing en and providing your enable password.
      3. 

    3. Delete the stacking interfaces:
      4. 

    

    # Commands to repurpose stacking ports
delete stacking interface stack 1/2
delete stacking interface stack 1/3
    

    After running these commands, the stacking ports will function as standard SFP+ ports, capable of 10Gbps speeds.
    

    
⚠️ Gotcha: Repurposing stacking ports may require a reboot to take effect. Save your configuration before rebooting to avoid losing changes.

    

    Step 5: Test Your Setup
    

    With the configuration complete, it’s time to test your setup. Connect devices to the switch and verify that they can communicate with each other. Use tools like iperf to measure network performance and ensure you’re getting the expected speeds.
    

    # Example iperf command to test bandwidth
iperf3 -c <TARGET_IP> -P 4
    

    Replace <TARGET_IP> with the IP address of another device on your network.
    

    Alternative: Consider a Newer Model
    

    If the idea of configuring used enterprise hardware feels daunting, you might consider a newer model like the Aruba Instant On 1930. While more expensive, it offers similar performance with a more user-friendly interface.
    

    For example, the Aruba Instant On 1930 24-Port Gb Ethernet switch (JL683A#ABA) is currently available for $434.99. It includes 24 PoE ports and four SFP+ ports, making it a solid choice for small business or advanced home setups.
    

    Conclusion
    

    Setting up a used Aruba S2500 switch might seem intimidating at first, but with a little effort, you can unlock enterprise-grade networking at a fraction of the cost. Here are the key takeaways:
    

      

    • Enterprise hardware offers excellent value for high-performance home networks.
      • 

    • Always perform a factory reset and update firmware to secure your switch.
      • 

    • Repurposing stacking ports can maximize the utility of your hardware.
      • 

    • Testing your setup ensures you’re getting the performance you expect.
      • 

    

    Have you set up a used enterprise switch for your home network? Share your experiences and tips in the comments below!

  • How to convert an async function to promise in javascript

    Why Would You Ever Need to Convert an Async Function to a Promise?

    Picture this: you’re working on a complex JavaScript project with multiple APIs, third-party libraries, and custom modules. Somewhere in the chaos, you encounter a library that only works with traditional Promises, but your codebase is built around modern async/await syntax. You’re stuck trying to bridge the gap between these two paradigms. What do you do?

    This is where converting an async function to a Promise comes in handy. While async functions are essentially syntactic sugar over Promises, there are scenarios where you need explicit control over the Promise lifecycle. For example:

    • Interfacing with libraries or frameworks that don’t support async/await.
    • Creating custom wrappers for async functions to add retries, timeouts, or logging.
    • Debugging or instrumenting asynchronous code with more granular control.

    In this article, we’ll explore how to convert an async function to a Promise, why you might need to do it, and how to avoid common pitfalls. By the end, you’ll have a deeper understanding of both async functions and Promises, along with practical techniques to make your code more robust.

    Understanding Async Functions and Promises

    Before diving into the conversion process, let’s clarify what async functions and Promises are and how they relate to each other.

    Async Functions

    An async function is a special type of function in JavaScript that always returns a Promise. It allows you to write asynchronous code that looks and behaves like synchronous code, thanks to the await keyword. Here’s a simple example:

    // An async function that fetches data from an API
async function fetchData() {
  const response = await fetch('https://example.com/data.json');
  const data = await response.json();
  return data;
}

// Calling the async function
fetchData().then(data => console.log(data)).catch(err => console.error(err));

    

    In this example, fetchData is an async function that uses await to pause execution until the fetch and response.json() Promises are resolved. The function returns a Promise that resolves with the parsed JSON data.
    

    Promises
    

    A Promise is a JavaScript object that represents the eventual completion (or failure) of an asynchronous operation. It has three states:
    

      

    • Pending: The operation is still in progress.
      • 

    • Fulfilled: The operation completed successfully.
      • 

    • Rejected: The operation failed.
      • 

    

    Promises have methods like then, catch, and finally to handle these states. Here’s a basic example:
    

    // A Promise that resolves after 2 seconds
const delay = new Promise((resolve, reject) => {
  setTimeout(() => resolve('Done!'), 2000);
});

// Handling the Promise
delay.then(message => console.log(message)).catch(err => console.error(err));

    

    How to Convert an Async Function to a Promise
    

    Now that we understand the basics, let’s look at how to convert an async function to a Promise. The key is to wrap the async function in a new Promise constructor. Here’s the general pattern:
    

    // Original async function
async function asyncFunction() {
  // Perform some asynchronous operation
  return 'Result';
}

// Convert to a Promise
const promise = new Promise((resolve, reject) => {
  asyncFunction()
    .then(result => resolve(result))
    .catch(error => reject(error));
});

    

    Let’s break this down:
    

      

    • The asyncFunction is called inside the executor callback of the Promise constructor.
      • 

    • The then method resolves the new Promise with the result of the async function.
      • 

    • The catch method rejects the new Promise if the async function throws an error.
      • 

    

    Real-World Example: Fetching Data with Error Handling
    

    Here’s a more practical example that fetches data from an API and includes error handling:
    

    // Async function to fetch data
async function fetchData() {
  const response = await fetch('https://example.com/data.json');
  if (!response.ok) {
    throw new Error('Network response was not ok');
  }
  return await response.json();
}

// Convert to a Promise
const fetchDataPromise = new Promise((resolve, reject) => {
  fetchData()
    .then(data => resolve(data))
    .catch(error => reject(error));
});

// Using the Promise
fetchDataPromise
  .then(data => console.log('Data:', data))
  .catch(error => console.error('Error:', error));

    

    💡 Pro Tip: Always include error handling when working with async functions or Promises. Use try/catch blocks in async functions and catch methods for Promises.
    

    When to Avoid Wrapping Async Functions in Promises
    

    While converting async functions to Promises can be useful, it’s not always necessary. In fact, doing so can sometimes lead to redundant or overly complex code. Here are some scenarios where you should avoid this pattern:
    

      

    • Unnecessary Wrapping: Async functions already return Promises, so wrapping them in another Promise is redundant unless you need additional control.
      • 

    • Performance Concerns: Adding extra layers of Promises can introduce slight performance overhead, especially in high-frequency operations.
      • 

    • Readability: Overusing this pattern can make your code harder to read and maintain.
      • 

    

    ⚠️ Gotcha: Avoid wrapping async functions in Promises unless you have a specific reason to do so. Redundant wrapping can lead to confusing code and potential bugs.
    

    Security Implications
    

    Before we wrap up, let’s talk about security. When working with async functions and Promises, you need to be mindful of potential vulnerabilities:
    

      

    • Untrusted Data: Always validate and sanitize data fetched from external APIs to prevent injection attacks.
      • 

    • Error Handling: Ensure that all Promises have proper error handling to avoid unhandled rejections, which can crash your application in Node.js.
      • 

    • Timeouts: Use timeouts for network requests to prevent your application from hanging indefinitely.
      • 

    

    🔐 Security Note: Never trust external APIs blindly. Always validate responses and handle errors gracefully to secure your application.
    

    Conclusion
    

    Converting an async function to a Promise in JavaScript is a powerful technique that can help you bridge the gap between modern async/await syntax and traditional Promise-based APIs. Here are the key takeaways:
    

      

    • Async functions always return Promises, so wrapping them is only necessary for additional control.
      • 

    • Use the new Promise constructor to wrap async functions and control their lifecycle.
      • 

    • Always include error handling to make your code more robust and secure.
      • 

    • Avoid redundant wrapping to keep your code clean and maintainable.
      • 

    • Be mindful of security implications when working with external APIs and Promises.
      • 

    

    Now it’s your turn: have you ever needed to convert an async function to a Promise? What challenges did you face, and how did you solve them? Share your thoughts in the comments below!
Home · About · Privacy Policy · Terms of Service
© 2026 Orthogonal Info. All rights reserved.