Update PHP on GCP learning path content

Author: madeline-underwood

content/learning-paths/servers-and-cloud-computing/php-on-gcp/_index.md

@@ -4,10 +4,10 @@ title:  Deploy PHP on Google Cloud C4A Arm-based Axion VMs
 
 minutes_to_complete: 30
 
-who_is_this_for: This is an introductory topic for software developers migrating PHP workloads from x86_64 to Arm-based servers, specifically on Google Cloud C4A virtual machines (VM) built on Axion processors.
+who_is_this_for: This is an introductory topic for developers migrating Hypertext Preprocesso (PHP) workloads from x86_64 to Arm-based servers, specifically on Google Cloud C4A virtual machines (VM) built on Axion processors.
 
 learning_objectives:
-  - Provision a SUSE SLES virtual machine on a Google Cloud C4A Arm-based Axion virtual machine
+  - Provision a SUSE Linux Enterprise Server (SLES) virtual machine on a Google Cloud C4A Arm-based Axion virtual machine
   - Install PHP on a SUSE Arm64 C4A instance
   - Validate PHP functionality by running baseline HTTP server tests  
   - Benchmark PHP performance using PHPBench on Arm64 architecture 

content/learning-paths/servers-and-cloud-computing/php-on-gcp/background.md

@@ -1,27 +1,22 @@
 ---
-title: Get started with PHP on Google Axion C4A on Arm Neoverse V2
+title: Get started with PHP on Google Cloud Axion C4A Arm VMs
 
 weight: 2
 
 layout: "learningpathall"
 ---
 
-## Google Axion C4A Arm instances in Google Cloud
+## PHP
 
-Google Axion C4A is a family of Arm-based virtual machines powered by Google's Axion CPU, built with Arm Neoverse V2 cores. They deliver high performance and energy efficiency for cloud workloads such as CI/CD pipelines, microservices, media processing, and general-purpose applications. The C4A series provides a cost-effective alternative to x86 virtual machines while leveraging the scalability and performance benefits of the Arm architecture in Google Cloud.
+PHP (Hypertext Preprocessor) is an open-source, server-side scripting language designed for web development. You can embed PHP directly into HTML, making it easy to generate content dynamically on the server before sending it to the browser. PHP is widely used for websites, web applications, content management systems (CMS), and APIs. For more information, see the [PHP website](https://www.php.net/) and the [PHP documentation](https://www.php.net/docs.php).
 
-For more information on Google Axion, see the Google blog [Introducing Google Axion Processors, our new Arm-based CPUs](https://cloud.google.com/blog/products/compute/introducing-googles-new-arm-based-cpu).
 
-## PHP
+## Google Axion C4A
 
-PHP (Hypertext Preprocessor) is an open-source, server-side scripting language designed for web development. 
+Google Axion C4A is a family of Arm-based virtual machines powered by Google's Axion CPU, built with Arm Neoverse V2 cores. They deliver high performance and energy efficiency for cloud workloads such as CI/CD pipelines, microservices, media processing, and general-purpose applications. The C4A series provides a cost-effective alternative to x86 virtual machines while leveraging the scalability and performance benefits of the Arm architecture in Google Cloud.
 
-You use PHP to:
-- Create dynamic web pages
-- Interact with databases
-- Handle forms
-- Build web applications and APIs
+For more information on Google Axion, see the Google blog [Introducing Google Axion Processors, our new Arm-based CPUs](https://cloud.google.com/blog/products/compute/introducing-googles-new-arm-based-cpu).
 
-You can embed PHP directly into HTML, making it easy to generate content dynamically on the server before sending it to the browser. PHP is widely used for websites, web applications, content management systems (CMS), and APIs. For more information, see the [PHP website](https://www.php.net/) and the [PHP documentation](https://www.php.net/docs.php).
+## What's next?
 
-You’re now ready to begin deploying PHP workloads on Arm-based Google Cloud Axion C4A VMs. This Learning Path helps you optimize PHP for Arm servers, benchmark performance, and migrate from x86 to Arm with confidence.
+You’re now ready to begin deploying PHP workloads on Arm-based Google Cloud Axion C4A VMs. This Learning Path shows you how to optimize PHP for Arm servers, benchmark performance, and migrate from x86 to Arm with confidence.

content/learning-paths/servers-and-cloud-computing/php-on-gcp/baseline.md

@@ -7,28 +7,28 @@ layout: learningpathall
 ---
 
 
-## Baseline setup for PHP-FPM
+## Configure PHP-FPM baseline
 In this section, you’ll configure PHP-FPM (FastCGI Process Manager) on a SUSE Linux Arm-based Google Cloud Axion C4A virtual machine. You’ll set up the PHP-FPM pool and verify the FastCGI configuration. Next, you’ll connect PHP-FPM to Apache. These steps confirm that your Arm server is ready for dynamic PHP workloads.
 
-## Configure the PHP-FPM pool
+## Set up the PHP-FPM pool
 
-PHP-FPM (FastCGI Process Manager) runs PHP scripts in dedicated worker processes, independent of the web server. This design improves performance, security, and fault isolation—especially on multi-core Arm-based processors like Google Cloud Axion C4A VMs.
+PHP-FPM (FastCGI Process Manager) runs PHP scripts in dedicated worker processes, independent of the web server. You’ll notice better performance, stronger security, and improved fault isolation when you use multi-core Arm-based processors like Google Cloud Axion C4A VMs.
 
 A pool is a group of PHP worker processes that serve FastCGI requests. You can use separate pools for different applications or virtual hosts to control resources more effectively.
 
-## Copy the default configuration (if missing)
+## Copy the default configuration
 
 If your PHP-FPM configuration files don't exist yet (for example, after a minimal installation in this Learning Path), copy the defaults into place using the commands below:
 
 ```console
 sudo cp /etc/php8/fpm/php-fpm.d/www.conf.default /etc/php8/fpm/php-fpm.d/www.conf
 sudo cp /etc/php8/fpm/php-fpm.conf.default /etc/php8/fpm/php-fpm.conf
 ```
-These commands:
+These commands do the following:
 - Create a default pool configuration (`www.conf`) to control how PHP-FPM spawns and manages worker processes
 - Restore the main FPM service configuration (`php-fpm.conf`) if it’s missing
 
-## Edit the configuration
+## Edit the PHP-FPM configuration
 
 Open the PHP-FPM pool configuration file in a text editor:
 
@@ -50,7 +50,7 @@ listen.group = www
 listen.mode = 0660
 ```
 
-Explanation of each directive:
+This table gives you an explanation of each directive:
 | Directive                                             | Description                                                                                                                                                                   |
 | ----------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | listen = /run/php-fpm/[www.sock](http://www.sock) | Configures PHP-FPM to communicate with Apache using a local Unix socket instead of a TCP port (`127.0.0.1:9000`). This reduces network overhead and improves performance. |
@@ -59,7 +59,7 @@ Explanation of each directive:
 | listen.mode = 0660                                | Defines file permissions so that both the owner (`wwwrun`) and group (`www`) can read and write to the socket. This enables smooth communication between Apache and PHP-FPM.  |
 
 
-## Start and enable PHP-FPM
+## Start and enable PHP-FPM service
 
 After updating the configuration, restart the PHP-FPM service so it picks up the new settings:
 
@@ -90,7 +90,7 @@ You should see output similar to:
 Oct 16 13:56:44 pareena-php-test systemd[1]: Starting The PHP FastCGI Process Manager...
 Oct 16 13:56:44 pareena-php-test systemd[1]: Started The PHP FastCGI Process Manager.
 ```
-PHP-FPM is now active and ready to process requests via its Unix socket (`/run/php-fpm/www.sock`).
+PHP-FPM is now active and ready to process requests using its Unix socket (`/run/php-fpm/www.sock`).
 Next, you’ll configure Apache to communicate with PHP-FPM, allowing your Arm server to process and serve dynamic PHP pages.
 
 ## Install the Apache PHP8 module
@@ -106,26 +106,24 @@ sudo systemctl restart apache2
 ```
 Next, you’ll test PHP execution by creating a simple PHP page and verifying that Apache can correctly render dynamic content.
 
-## Test PHP
+## Test PHP functionality
 Now that PHP and Apache are installed, you can verify that everything is working correctly on your Arm-based VM.
 
-## Create a test page
+## Create a PHP test page
 Create a simple PHP file that displays detailed information about your PHP installation:
 
 ```console
 echo "<?php phpinfo(); ?>" | sudo tee /srv/www/htdocs/info.php
 ```
 This creates a file named `info.php` inside Apache’s web root directory (`/srv/www/htdocs/`). When you open this file in a browser, it displays the PHP configuration page.
 
-## Test from inside the VM
+## Verify PHP from inside the VM
 You can verify that PHP and Apache are communicating correctly by testing the web server locally using curl:
 
 ```console
 curl http://localhost/info.php
 ```
-- `curl` fetches the page from the local Apache server.
-- If PHP is working, you’ll see a large block of HTML code as output. This is the rendered output of the `phpinfo()` function.
-- This confirms that Apache successfully passed the request to the PHP interpreter and returned the generated HTML response.
+When you run the `curl` command, it fetches the PHP test page from the local Apache server. If PHP is configured correctly, you'll see a large block of HTML code in the output, which is the result of the `phpinfo()` function. This confirms that Apache is successfully passing requests to the PHP interpreter and returning the generated HTML response.
 
 You should see output similar to:
 
@@ -149,19 +147,23 @@ h2 a:link, h2 a:visited{color: inherit; background: inherit;}
 ```
 This long HTML output represents the PHP configuration page content.
 
-## Test from your browser
+## Verify PHP from your browser
 Now, verify that your PHP setup works correctly from outside the VM.
 Open a web browser on your local machine (such as Chrome, Firefox, or Edge) and enter the following URL in the address bar:
 
 ```console
 http://<YOUR_VM_PUBLIC_IP>/info.php
 ```
-- Replace `<YOUR_VM_PUBLIC_IP>` with the public IP of your Google Cloud Axion C4A Arm VM.
+Replace `<YOUR_VM_PUBLIC_IP>` with the public IP of your Google Cloud Axion C4A Arm VM.
 
-If everything is set up correctly, you’ll see a PHP Info page in your browser. It looks like this:
+If your configuration is correct, your browser displays the PHP Info page. This page shows detailed information about your PHP environment, including version, build options, and loaded modules, as shown below:
 
-![PHP-info page alt-text#center](images/php-web.png "Figure 1: PHP info")
+![Screenshot of PHP info page in browser showing PHP configuration details on Google Cloud Axion C4A Arm VM. alt-text#center](images/php-web.png "PHP info page in browser on Google Cloud Axion C4A Arm VM")
 
 Successfully loading the PHP Info page in your browser confirms that your PHP and Apache environment on Google Cloud Axion C4A Arm is configured and functioning properly.
 
+## What's next?
+
 You’ve validated your PHP baseline setup on an Arm-based Google Cloud VM. You’re ready to move on to benchmarking and performance testing for your PHP workloads on Arm.
+
+Next, you’ll learn how to measure PHP performance on Google Cloud Axion C4A Arm VMs. You’ll use benchmarking tools to evaluate throughput, latency, and resource utilization. This helps you optimize your PHP environment for production workloads and identify areas for improvement.

content/learning-paths/servers-and-cloud-computing/php-on-gcp/benchmarking.md

@@ -8,9 +8,7 @@ layout: learningpathall
 
 ## PHP benchmarking using PHPBench
 
-In this section, you will learn how to benchmark PHP performance using PHPBench, a modern and extensible benchmarking framework for PHP applications. You will install PHPBench, run sample tests, and interpret key metrics such as mode time, variance, and throughput. You will then analyze the results to understand how your Google Cloud C4A (Axion Arm64) virtual machine performs on common operations like string manipulation and array processing.
-
-PHPBench is a flexible micro-benchmarking tool designed to measure PHP code performance precisely and repeatably. 
+In this section, you will learn how to benchmark PHP performance using PHPBench, a modern and extensible benchmarking framework for PHP applications. You will install PHPBench, run sample tests, and interpret key metrics such as mode time, variance, and throughput. You will then analyze the results to understand how your Google Cloud C4A (Axion Arm64) virtual machine performs on common operations like string manipulation and array processing. PHPBench is a flexible micro-benchmarking tool designed to measure PHP code performance precisely and repeatably. 
 
 With PHPBench, you can:
   * Measure the execution time of PHP functions or code blocks
@@ -93,7 +91,7 @@ This installs `phpbench` in your user's global Composer directory, typically loc
 
 ## Add Composer global bin to PATH
 
-To make `phpbench` accessible from any terminal session, add Composer's global binary path to your system's environment PATH:
+To make `phpbench` accessible from any terminal session, add Composer's global binary path to your system's environment `PATH`:
 ```console
 export PATH="$HOME/.config/composer/vendor/bin:$PATH"
 echo 'export PATH=$HOME/.config/composer/vendor/bin:$PATH' >> ~/.bashrc
@@ -160,9 +158,7 @@ class ExampleBenchmark
 ```
 This sets up two basic benchmark tests, string concatenation and array push.
 
-- @Revs(1000): Each benchmark repeats 1000 times per iteration.
-- @Iterations(5): The benchmark runs 5 separate iterations and averages results.
-- `benchStringConcat` and `benchArrayPush`: Sample benchmarks for string and array operations.
+The `@Revs(1000)` annotation ensures each benchmark function is executed 1,000 times per iteration, while `@Iterations(5)` means the benchmark runs five separate iterations and averages the results for greater accuracy. The sample benchmarks, `benchStringConcat` and `benchArrayPush`, measure the performance of string concatenation and array operations, respectively.
 
 ## Run the benchmarks
 
@@ -185,20 +181,19 @@ with PHP version 8.0.30, xdebug ❌, opcache ❌
 Subjects: 2, Assertions: 0, Failures: 0, Errors: 0
 ```
 
-## Understanding PHP benchmark metrics and results with PHPBench
+## Understanding PHPBench metrics and results
+
+PHPBench reports several key metrics to help you understand your code's performance, as defined in the table below:
 
-- **benchStringConcat** → Name of the benchmark function; in this case, it measures string concatenation performance.
-- **benchArrayPush** → Name of another benchmark function; here, measuring array push performance.
-- **xdebug ❌** → Xdebug extension is disabled, which is good because Xdebug slows down execution.
-- **opcache ❌** → Opcache is disabled, so you’re measuring raw execution without caching optimizations.
-- **I4** → Number of iterations per measurement.  
-  - `I4` means 4 iterations of this benchmark were executed for one measurement.
-- **Mo13.438μs** → Mode (or mean) execution time for the benchmark.  
-  - `Mo` = Mode, showing the most common measured execution time across iterations.  
-  - `13.438 μs` = 13.438 microseconds per iteration.
-- **(±0.82%)** → Variation or coefficient of variation in the measurements.  
-  - Shows consistency of results.  
-  - Lower percentage → more stable and reliable benchmark.
+| Metric/Term         | Meaning                                                                                                   |
+|---------------------|-----------------------------------------------------------------------------------------------------------|
+| **benchStringConcat** | Name of the benchmark function; measures string concatenation performance.                               |
+| **benchArrayPush**    | Name of the benchmark function; measures array push performance.                                         |
+| **xdebug ❌**          | Xdebug extension is disabled, which is good because Xdebug slows down execution.                        |
+| **opcache ❌**         | Opcache is disabled, so you’re measuring raw execution without caching optimizations.                   |
+| **I4**                | Number of iterations per measurement. `I4` means 4 iterations of this benchmark were executed per run.  |
+| **Mo13.438μs**        | Mode (most common) execution time for the benchmark. `13.438 μs` = 13.438 microseconds per iteration.   |
+| **(±0.82%)**          | Variation or coefficient of variation in the measurements. Lower percentage means more stable results.   |
 
 
 ## Benchmark summary on Arm64
@@ -222,10 +217,13 @@ For comparison, the same PHPBench test suite was executed on a Google Cloud c4-s
 
 When comparing benchmark results between Google Cloud Axion C4A (Arm64) and x86-based C4 (x86_64) instances, you will see:
 
-The results show that both architectures deliver nearly identical execution times for typical PHP operations, with Arm64 showing slightly lower variation (more stable performance). The Arm64 instance performs within ~15% of x86_64, showing strong memory throughput and cache performance for dynamic array allocation workloads.
-Low variance (±0.82% / ±0.51: Indicates that the Axion-based Arm cores on C4A provide stable, repeatable performance, ideal for predictable PHP application behavior in production.
+- The results show that both architectures deliver nearly identical execution times for typical PHP operations, with Arm64 showing a slightly lower level of variation which indicates more stable performance. 
+- The Arm64 instance performs within ~15% of x86_64, showing strong memory throughput and cache performance for dynamic array allocation workloads.
+- Low variance (±0.82% / ±0.51) indicates that the Axion-based Arm cores on C4A provide stable, repeatable performance, ideal for predictable PHP application behavior in production.
+
+## Summary
 
-These results show that PHP performs consistently across both architectures, and that Google Cloud Axion C4A Arm64 VMs deliver competitive, reliable performance for PHP-based web and backend applications.
+These results show that PHP performs consistently across both architectures, and that Google Cloud Axion C4A Arm64 VMs deliver competitive, reliable performance for PHP-based web and backend applications. You can confidently deploy PHP workloads on Arm64 instances, knowing that performance is stable and comparable to x86_64 systems. This benchmarking process helps you identify areas for optimization and ensures your applications run efficiently on Arm platforms. As you continue developing and scaling PHP solutions, regularly benchmarking on Arm64 will help you maintain high performance and take advantage of the cost and energy efficiency benefits offered by Arm-based cloud infrastructure.