Merge pull request #2279 from madeline-underwood/tune_network_workloads

Tune network workloads_PV to sign off

Author: pareenaverma

content/learning-paths/servers-and-cloud-computing/tune-network-workloads-on-bare-metal/1_setup.md

@@ -6,58 +6,64 @@ weight: 2
 layout: learningpathall
 ---
 
+## Overview
 
-## Overview 
-
-There are numerous client-server and network-based workloads, with Tomcat being a typical example of such applications. Tomcat provides services via HTTP/HTTPS network requests.
-
-In this section, you will set up a benchmark environment using `Apache Tomcat` and `wrk2` to simulate an HTTP load and evaluate performance on an Arm-based bare metal instance. This Learning Path was tested on an AWS `c8g.metal-48xl` instance.
+Tomcat is a common client–server web workload that serves HTTP/HTTPS requests. In this section, you will set up a benchmarking environment using Apache Tomcat (server) and `wrk2` (client) to generate load and measure performance on an Arm-based bare‑metal instance. This Learning Path was validated on an AWS `c8g.metal‑48xl` instance running Ubuntu 24.04.
 
 ## Set up the Tomcat benchmark server
-[Apache Tomcat](https://tomcat.apache.org/) is an open-source Java Servlet container that runs Java web applications, handles HTTP requests, and serves dynamic content. It supports technologies such as Servlet, JSP, and WebSocket.
+
+[Apache Tomcat](https://tomcat.apache.org/) is an open‑source Java Servlet container for running Java web applications, handling HTTP requests, and serving dynamic content. It supports Servlet, JSP, and WebSocket.
 
 ## Install the Java Development Kit (JDK)
 
-Install OpenJDK 21 on your Arm-based Ubuntu 24.04 bare-metal instance: 
+Install OpenJDK 21 on your Arm‑based Ubuntu 24.04 bare‑metal instance:
 
 ```bash
 sudo apt update
 sudo apt install -y openjdk-21-jdk
 ```
 
-## Install Tomcat 
+## Install Tomcat
 
 Download and extract Tomcat:
 
 ```bash
 wget -c https://dlcdn.apache.org/tomcat/tomcat-11/v11.0.10/bin/apache-tomcat-11.0.10.tar.gz
 tar xzf apache-tomcat-11.0.10.tar.gz
 ```
+
 Alternatively, you can build Tomcat [from source](https://github.com/apache/tomcat).
 
 ## Enable access to Tomcat examples
 
-To access the built-in examples from your local network or external IP, use a text editor to modify the `context.xml` file by updating the `RemoteAddrValve` configuration to allow all IP addresses.
+To access the built‑in examples from your local network or external IP, modify the `context.xml` file and update `RemoteAddrValve` to allow your clients.
+
+The file is located at:
 
-The file is at:
 ```bash
 ~/apache-tomcat-11.0.10/webapps/examples/META-INF/context.xml
 ```
 
-Replace the existing allow value as shown:
+Replace the existing value:
+
 ```xml
 <Valve className="org.apache.catalina.valves.RemoteAddrValve" allow="127\.\d+\.\d+\.\d+|::1|0:0:0:0:0:0:0:1" />
 ```
 
 With:
+
 ```xml
 <Valve className="org.apache.catalina.valves.RemoteAddrValve" allow=".*" />
 ```
-Save the changes to your file.
+
+{{% notice Warning %}}
+Allowing `.*` permits access from all IP addresses and should be used only in isolated lab environments. Restrict this setting to trusted CIDR ranges for production or shared networks.
+{{% /notice %}}
 
 ## Start the Tomcat server
+
 {{% notice Note %}}
-To achieve maximum performance of Tomcat, the maximum number of file descriptors that a single process can open simultaneously should be sufficiently large.
+For maximum performance, ensure the per‑process limit for open file descriptors is sufficient.
 {{% /notice %}}
 
 Start the server:
@@ -66,7 +72,7 @@ Start the server:
 ulimit -n 65535 && ~/apache-tomcat-11.0.10/bin/startup.sh
 ```
 
-You should see output like:
+You should see output similar to:
 
 ```output
 Using CATALINA_BASE:   /home/ubuntu/apache-tomcat-11.0.10
@@ -80,24 +86,30 @@ Tomcat started.
 
 ## Confirm server access
 
-In your browser, open: `http://${tomcat_ip}:8080/examples`.
+Replace `${tomcat_ip}` with the public or private IP address of your Arm server and open:
+
+```
+http://${tomcat_ip}:8080/examples
+```
 
 You should see the Tomcat welcome page and examples, as shown below:
 
-![Screenshot of the Tomcat homepage showing version and welcome panel alt-text#center](./_images/lp-tomcat-homepage.png "Apache Tomcat homepage")
+![Screenshot of the Apache Tomcat homepage showing version and welcome panel alt-text#center](./_images/lp-tomcat-homepage.png "Apache Tomcat homepage")
 
 ![Screenshot of the Tomcat examples page showing servlet and JSP demo links alt-text#center](./_images/lp-tomcat-examples.png "Apache Tomcat examples")
 
-{{% notice Note %}}Make sure port 8080 is open in the security group of the IP address for your Arm-based Linux machine.{{% /notice%}}
+{{% notice Note %}}
+Ensure port **8080** is open in the security group or firewall for your Arm‑based Linux machine.
+{{% /notice %}}
 
 ## Set up the benchmarking client using wrk2
 [Wrk2](https://github.com/giltene/wrk2) is a high-performance HTTP benchmarking tool specialized in generating constant throughput loads and measuring latency percentiles for web services. `wrk2` is an enhanced version of `wrk` that provides accurate latency statistics under controlled request rates, ideal for performance testing of HTTP servers.
 
 {{% notice Note %}}
-Currently `wrk2` is only supported on x86 machines. Run the benchmark client steps below on a bare metal `x86_64` server running Ubuntu 24.04
+Currently, `wrk2` is only supported on x86_64 machines. Run the client steps below on a bare‑metal x86_64 server running Ubuntu 24.04.
 {{% /notice %}}
 
-## Install dependencies 
+## Install dependencies
 
 Install the required packages:
 
@@ -111,27 +123,36 @@ sudo apt-get install -y build-essential libssl-dev git zlib1g-dev
 Clone the repository and compile the tool:
 
 ```bash
-sudo git clone https://github.com/giltene/wrk2.git
+git clone https://github.com/giltene/wrk2.git
 cd wrk2
-sudo make
+make
 ```
 
-Move the binary to a directory in your system’s PATH:
- 
+Move the binary to a directory in your system’s `PATH`:
+
 ```bash
 sudo cp wrk /usr/local/bin
 ```
 
 ## Run the benchmark
+
 {{% notice Note %}}
-To achieve maximum performance of wrk2, the maximum number of file descriptors that a single process can open simultaneously should be sufficiently large.
+As with Tomcat, set a high open‑files limit to avoid hitting FD caps during the run.
 {{% /notice %}}
 
-Use the following command to benchmark the HelloWorld servlet running on Tomcat:
+Benchmark the `HelloWorld` servlet running on Tomcat:
 
 ```bash
 ulimit -n 65535 && wrk -c32 -t16 -R50000 -d60 http://${tomcat_ip}:8080/examples/servlets/servlet/HelloWorldExample
 ```
+
+**Flags explained:**
+
+- `-c32` — 32 open connections  
+- `-t16` — 16 threads  
+- `-R50000` — constant 50,000 requests/second  
+- `-d60` — run for 60 seconds
+
 You should see output similar to:
 
 ```console