Merge pull request #2430 from DougAnsonAustinTX/qc_nodejs_tech_review

GCP Axion nodejs tech review and updates

Author: jasonrandrews

content/learning-paths/servers-and-cloud-computing/node-js-gcp/baseline.md

@@ -28,12 +28,18 @@ You should see an output similar to:
 Hello from Node.js
 undefined
 ```
-This confirms that Node.js can execute JavaScript commands successfully.
+This confirms that Node.js can execute JavaScript commands successfully.   Please now press "Ctrl-D" to exit node. 
 
 ### 2. Test a Basic HTTP Server
 You can now create a small HTTP server to validate that Node.js can handle web requests.
 
-Create `app.js`:
+Create `app.js`.  For example, you can type "vi app.js" in the SSH shell:
+
+```console
+vi app.js
+```
+
+ ...and then insert the following code:
 
 ```javascript
 const http = require('http');
@@ -43,36 +49,28 @@ const server = http.createServer((req, res) => {
   res.end('Baseline test successful!\n');
 });
 
-server.listen(3000, '0.0.0.0', () => {
-  console.log('Server running at http://0.0.0.0:3000/');
+server.listen(80, '0.0.0.0', () => {
+  console.log('Server running at http://0.0.0.0:80/');
 });
 ```
- - This server listens on port 3000.
+ - This server listens on port 80.
  - Binding to 0.0.0.0 allows connections from any IP, not just localhost.
 
-Run the server:
+Save the code and exit your editor. Next, we run the HTTP server in the background via sudo:
 
 ```console
-node app.js
+export MY_NODE=`which node`
+sudo ${MY_NODE} app.js &
 ```
 You should see an output similar to:
 
 ```output
-Server running at http://0.0.0.0:3000/
-```
-{{% notice Note %}}
-Make sure your GCP firewall allows TCP traffic on port 3000. On SUSE Arm64, internal firewalls are usually disabled, so only the GCP firewall needs to be configured.
-
-```console
-sudo zypper install -y firewalld
-sudo firewall-cmd --permanent --add-port=3000/tcp
-sudo firewall-cmd --reload
+Server running at http://0.0.0.0:80/
 ```
-{{% /notice %}}
 #### Test Locally with Curl
 
 ```console
-curl http://localhost:3000
+curl http://localhost:80
 ```
 
 You should see an output similar to:
@@ -85,7 +83,7 @@ Baseline test successful!
 Also, you can access it from the browser with your VM's public IP. Run the following command to print your VM’s public URL, then open it in a browser:
 
 ```console
-echo "http://$(curl -s ifconfig.me):3000/"
+echo "http://$(curl -s ifconfig.me):80/"
 ```
 
 You should see the following message in your browser, confirming that your Node.js HTTP server is running successfully:

content/learning-paths/servers-and-cloud-computing/node-js-gcp/benchmarking.md

@@ -14,53 +14,55 @@ After validating that Node.js is installed and your HTTP server is running, you
 **Autocannon** is a fast HTTP/1.1 benchmarking tool for Node.js, used to measure server throughput, latency, and request handling under concurrent load.
 
 ```console
-sudo npm install -g autocannon
+npm install -g autocannon
 ```
 
 ### Start Your Node.js HTTP Server
 
+If your sample HTTP server is not already running from the last section, you can start it by typing:
 ```console
-node app.js
+export MY_NODE=`which node`
+sudo ${MY_NODE} app.js &
 ```
 
-Server should be listening on port 3000:
+Server should be listening on port 80 in the background:
 
 ```output
-Server running at http://0.0.0.0:3000/
+Server running at http://0.0.0.0:80/
 ```
 
 ### Run a Basic Benchmark (Local)
 
 ```console
-autocannon -c 100 -d 10 http://localhost:3000
+autocannon -c 100 -d 10 http://localhost:80
 ```
 - `-c 100` → 100 concurrent connections
 - `-d 10` → duration 10 seconds
 - URL → endpoint to test
 
 You should see an output similar to:
 ```output
-Running 10s test @ http://localhost:3000
+Running 10s test @ http://localhost:80
 100 connections
 
 
-┌─────────┬──────┬──────┬───────┬──────┬────────┬─────────┬───────┐
-│ Stat    │ 2.5% │ 50%  │ 97.5% │ 99%  │ Avg    │ Stdev   │ Max   │
-├─────────┼──────┼──────┼───────┼──────┼────────┼─────────┼───────┤
-│ Latency │ 1 ms │ 1 ms │ 3 ms  │ 3 ms │ 1.2 ms │ 0.62 ms │ 24 ms │
-└─────────┴──────┴──────┴───────┴──────┴────────┴─────────┴───────┘
-┌───────────┬─────────┬─────────┬─────────┬─────────┬──────────┬──────────┬─────────┐
-│ Stat      │ 1%      │ 2.5%    │ 50%     │ 97.5%   │ Avg      │ Stdev    │ Min     │
-├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼──────────┼─────────┤
-│ Req/Sec   │ 45,279  │ 45,279  │ 54,719  │ 55,199  │ 53,798.4 │ 2,863.96 │ 45,257  │
-├───────────┼─────────┼─────────┼─────────┼─────────┼──────────┼──────────┼─────────┤
-│ Bytes/Sec │ 8.78 MB │ 8.78 MB │ 10.6 MB │ 10.7 MB │ 10.4 MB  │ 557 kB   │ 8.78 MB │
-└───────────┴─────────┴─────────┴─────────┴─────────┴──────────┴──────────┴─────────┘
+┌─────────┬──────┬──────┬───────┬──────┬─────────┬─────────┬───────┐
+│ Stat    │ 2.5% │ 50%  │ 97.5% │ 99%  │ Avg     │ Stdev   │ Max   │
+├─────────┼──────┼──────┼───────┼──────┼─────────┼─────────┼───────┤
+│ Latency │ 1 ms │ 1 ms │ 2 ms  │ 2 ms │ 1.06 ms │ 0.41 ms │ 28 ms │
+└─────────┴──────┴──────┴───────┴──────┴─────────┴─────────┴───────┘
+┌───────────┬─────────┬─────────┬─────────┬────────┬───────────┬──────────┬─────────┐
+│ Stat      │ 1%      │ 2.5%    │ 50%     │ 97.5%  │ Avg       │ Stdev    │ Min     │
+├───────────┼─────────┼─────────┼─────────┼────────┼───────────┼──────────┼─────────┤
+│ Req/Sec   │ 66,175  │ 66,175  │ 70,847  │ 72,191 │ 70,713.61 │ 1,616.86 │ 66,134  │
+├───────────┼─────────┼─────────┼─────────┼────────┼───────────┼──────────┼─────────┤
+│ Bytes/Sec │ 12.8 MB │ 12.8 MB │ 13.7 MB │ 14 MB  │ 13.7 MB   │ 313 kB   │ 12.8 MB │
+└───────────┴─────────┴─────────┴─────────┴────────┴───────────┴──────────┴─────────┘
 
 Req/Bytes counts sampled once per second.
 # of samples: 10
 
-538k requests in 10.03s, 104 MB read
+707k requests in 10.02s, 137 MB read
 ```
 
 ### Understanding Node.js benchmark metrics and results with Autocannon

content/learning-paths/servers-and-cloud-computing/node-js-gcp/images/gcp-shell.png

@@ -1,64 +1,63 @@
 ---
-title: Install Node.js
+title: Install Node.js Using Node Version Manager
 weight: 4
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Install Node.js 
-This guide walks you through installing **Node.js v24.8.0** on a SUSE Arm64 virtual machine using the official tarball package. 
+## Install Node.js with Node Version Manager (NVM)
+This guide walks you through installing **NodeJS** via the Node Version Manager (NVM).  NVM is a powerful tool that allows users to specify which version of **NodeJS** that they want to use. NVM will then download and install the requested vesion using the **NodeJS** official packages. 
 
-### 1. Download Node.js Binary
-First, download the Node.js package (precompiled binaries for Linux Arm64) from the official website.
+### 1. Install Node Version Manager (NVM)
+First, we will run this command to download and install NVM into our VM instance:
 
 ```console
-sudo wget https://nodejs.org/dist/latest/node-v24.8.0-linux-arm64.tar.gz
+curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
 ```
 
-### 2. Extract the Tarball
-Unpack the downloaded file so we can access the Node.js binaries.
+Next, we have to activate NVM in our terminal shell.  We can manually activate our current shell via copy and paste of the following into the shell:
 
 ```console
-sudo tar -xvf node-v24.8.0-linux-arm64.tar.gz
+export NVM_DIR="$HOME/.nvm"
+[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm
+[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  # This loads nvm bash_completion
 ```
 
-### 3. Rename Extracted Directory
-Rename the extracted folder to something shorter such as node-v24.8.01 for easier reference.
+You should be able to confirm that NVM is available by typing:
 
 ```console
-sudo mv node-v24.8.0-linux-arm64 node-v24.8.0
+nvm --version
 ```
 
-### 4. Create a Symlink (Optional)
-This step creates a shortcut (`/usr/local/node`) pointing to your Node.js installation directory.
-
-It makes future upgrades easier — you only need to update the symlink instead of changing paths everywhere.
+### 2. Install NodeJS
+Now that NVM is installed, we simply type the following commands in our shell to download and install **NodeJS**: 
 
 ```console
-sudo ln -s /usr/local/node-v24.8.0 /usr/local/node
+nvm install v24
+nvm use v24
 ```
 
-### 5. Update PATH Environment Variable
-
-Add Node.js binaries to your PATH so you can run `node` and `npm` commands from anywhere in your terminal.
+Additionally, we can add this command to the bottom of our $HOME/.bashrc file:
 
 ```console
-echo 'export PATH=$HOME/node-v24.8.0/bin:$PATH' >> ~/.bashrc
-source ~/.bashrc
+echo 'nvm use v24' >> ~/.bashrc
 ```
 
-### 6. Verify Installation
+### 3. Verify Installation
 Check that Node.js and npm (Node’s package manager) are installed correctly.
 
+You should be able to confirm that **NodeJS** is now installed and available!
+
 ```console
-node -v
-npm -v
+node --version
+npm --version
 ```
+
 You should see an output similar to:
 ```output
-v24.8.0
-11.6.0
+v24.10.0
+11.6.1
 ```
 
 Node.js installation is complete. You can now proceed with the baseline testing.

content/learning-paths/servers-and-cloud-computing/node-js-gcp/images/gcp-ssh.png

@@ -27,6 +27,13 @@ To create a virtual machine based on the C4A instance type:
    ![Create a Google Axion C4A Arm virtual machine in the Google Cloud Console with c4a-standard-4 selected alt-text#center](images/gcp-vm.png "Creating a Google Axion C4A Arm virtual machine in Google Cloud Console")
 
 
-- Under **OS and Storage**, select **Change**, then choose an Arm64-based OS image. For this Learning Path, use **SUSE Linux Enterprise Server**. Pick the preferred version for your Operating System. Ensure you select the **Arm image** variant. Click **Select**.
+- Under **OS and Storage**, select **Change**, then choose an Arm64-based OS image. For this Learning Path, use **SUSE Linux Enterprise Server**. Select "Pay As You Go" for the license type. Click **Select**.
 - Under **Networking**, enable **Allow HTTP traffic**.
 - Click **Create** to launch the instance.
+- Once created, you should see a "SSH" option to the right in your list of VM instances.  Click on this to launch a SSH shell into your VM instance:
+
+![Invoke a SSH session via your browser alt-text#center](images/gcp-ssh.png "Invoke a SSH session into your running VM instance")
+
+- A window from your browser should come up and you should now see a shell into your VM instance:
+
+![Terminal Shell in your VM instance alt-text#center](images/gcp-shell.png "Terminal shell in your VM instance")