Refine PHP on GCP documentation for clarity and consistency

Author: madeline-underwood

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

@@ -4,7 +4,7 @@ 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 software developers migrating 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
@@ -28,7 +28,7 @@ armips:
 
 tools_software_languages:
   - PHP
-  - apache
+  - Apache
   - PHPBench
 
 operatingsystems:

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

@@ -26,4 +26,4 @@ You can embed PHP directly into HTML, making it easy to generate content dynamic
 
 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).
 
-You’re 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 helps you 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,16 +7,16 @@ layout: learningpathall
 ---
 
 
-## Baseline Setup for PHP-FPM
-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, verify FastCGI configuration, connect PHP-FPM to Apache, and confirm that your Arm server is ready for dynamic PHP workloads.
+## Baseline setup for PHP-FPM
+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
+## Configure 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.
 
 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 missing)
 
 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:
 
@@ -25,10 +25,10 @@ sudo cp /etc/php8/fpm/php-fpm.d/www.conf.default /etc/php8/fpm/php-fpm.d/www.con
 sudo cp /etc/php8/fpm/php-fpm.conf.default /etc/php8/fpm/php-fpm.conf
 ```
 These commands:
-- 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.
+- 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 configuration
 
 Open the PHP-FPM pool configuration file in a text editor:
 
@@ -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
 
 After updating the configuration, restart the PHP-FPM service so it picks up the new settings:
 
@@ -109,15 +109,15 @@ Next, you’ll test PHP execution by creating a simple PHP page and verifying th
 ## Test PHP
 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 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
+## Test from inside the VM
 You can verify that PHP and Apache are communicating correctly by testing the web server locally using curl:
 
 ```console
@@ -149,7 +149,7 @@ h2 a:link, h2 a:visited{color: inherit; background: inherit;}
 ```
 This long HTML output represents the PHP configuration page content.
 
-### Test from Your Browser
+## Test 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:
 

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

@@ -7,18 +7,20 @@ layout: learningpathall
 ---
 
 
-## PHP Benchmarking using PHPBench
+## 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. It allows developers to:
-  * Measure the execution time of PHP functions or code blocks.
-  * Identify performance regressions between versions.
-  * Automate performance testing across CI/CD pipelines.
-  * Track results over time to detect optimizations or slowdowns.
+PHPBench is a flexible micro-benchmarking tool designed to measure PHP code performance precisely and repeatably. 
 
-### Download Composer Installer
+It allows developers to do the following:
+  * Measure the execution time of PHP functions or code blocks
+  * Identify performance regressions between versions
+  * Automate performance testing across CI/CD pipelines
+  * Track results over time to detect optimizations or slowdowns
+
+## Download Composer installer
 
 Before installing PHPBench, you need Composer, which is PHP's dependency manager. Composer handles library installations, versioning, and autoloading, ensuring tools like PHPBench run consistently across environments.
 
@@ -29,7 +31,7 @@ sudo php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
 
 This command downloads a PHP script called `composer-setup.php`, which will install Composer.
 
-### Install the phar extension
+## Install the phar extension
 
 Composer requires PHP's phar (PHP Archive) extension to run. This extension allows PHP to execute .phar archive files, self-contained PHP applications like Composer and PHPBench are distributed in this format.
 
@@ -38,7 +40,7 @@ Install the extension with:
 sudo zypper install -y php8-phar
 ```
 
-### Install Composer system-wide
+## Install Composer system-wide
 
 Now, install Composer globally so it is available for all users and can be executed from any directory:
 
@@ -56,7 +58,7 @@ Use it: php /usr/local/bin/composer
 ```
 Composer is now installed system-wide at /usr/local/bin/composer and ready to manage PHP dependencies.
 
-### Remove the installer script
+## Remove the installer script
 
 After successfully installing Composer, remove the installer file to keep your environment clean:
 
@@ -65,7 +67,7 @@ sudo php -r "unlink('composer-setup.php');"
 ```
 Since Composer is now installed system-wide, the installer file is no longer needed.
 
-### Verify Composer installation
+## Verify Composer installation
 To confirm that Composer was installed correctly and is accessible globally, run:
 
 ```console
@@ -80,7 +82,7 @@ Run the "diagnose" command to get more detailed diagnostics output.
 
 Composer is now successfully installed and you can proceed to installing PHPBench.
 
-### Install PHPBench globally
+## Install PHPBench globally
 
 PHPBench is a powerful benchmarking tool for measuring the performance of PHP code. Install it globally using Composer so you can access it from any directory:
 
@@ -90,7 +92,7 @@ composer global require phpbench/phpbench
 
 This installs `phpbench` in your user's global Composer directory, typically located under `$HOME/.config/composer/`
 
-### Add Composer global bin to PATH
+## 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:
 ```console
@@ -99,7 +101,7 @@ echo 'export PATH=$HOME/.config/composer/vendor/bin:$PATH' >> ~/.bashrc
 source ~/.bashrc
 ```
 
-### Verify PHPBench installation
+## Verify PHPBench installation
 Once installed, verify that PHPBench is working correctly:
 ```console
 phpbench --version
@@ -111,15 +113,15 @@ phpbench 1.2.14
 ```
 PHPBench is now installed and ready to run.
 
-### Create a Benchmark Directory
+## Create a benchmark directory
 
 Create a new PHP benchmark file using your preferred text editor:
 
 ```console
 mkdir ~/phpbench-tests
 cd ~/phpbench-tests
 ```
-### Create a Benchmark Script
+## Create a benchmark script
 
 Create a new PHP benchmark file using your preferred editor:
 
@@ -163,7 +165,7 @@ This sets up two basic benchmark tests, string concatenation and array push.
 - @Iterations(5): The benchmark runs 5 separate iterations and averages results.
 - `benchStringConcat` and `benchArrayPush`: Sample benchmarks for string and array operations.
 
-### Run the Benchmarks
+## Run the benchmarks
 
 Execute the benchmark suite you created using the `phpbench run` command:
 
@@ -184,7 +186,7 @@ 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 PHP benchmark metrics and results with PHPBench
 
 - **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.
@@ -200,7 +202,7 @@ Subjects: 2, Assertions: 0, Failures: 0, Errors: 0
   - Lower percentage → more stable and reliable benchmark.
 
 
-### Benchmark summary on Arm64
+## Benchmark summary on Arm64
 
 Results from the benchmark suite executed on a Google Cloud c4a-standard-4 (Arm64) instance with 4 vCPUs and 16 GB memory, running SUSE Linux:
 | Benchmark Function   | Iterations | Mode Execution Time (μs)| Variation (%) | Notes                                    |
@@ -209,15 +211,15 @@ Results from the benchmark suite executed on a Google Cloud c4a-standard-4 (Arm6
 | benchArrayPush       | I4          | 8.487 μs          | ±0.51%    | Measures performance of pushing elements to an array|
 
 
-### Benchmark summary on x86_64
+## Benchmark summary on x86_64
 For comparison, the same PHPBench test suite was executed on a Google Cloud c4-standard-4 (x86_64) instance with 4 vCPUs and 15 GB memory, running SUSE Linux:
 
 | Benchmark Function   | Iterations | Mode Execution Time (μs) | Variation (%) | Notes                                           |
 |---------------------|------------|----------------|---------------|------------------------------------------------|
 | benchStringConcat   | I4         | 13.493         | ±1.80%        | Measures performance of string concatenation |
 | benchArrayPush      | I4         | 7.395          | ±1.07%         | Measures performance of pushing elements to an array |
 
-### PHP performance benchmarking comparison on Arm64 and x86_64
+## PHP performance benchmarking comparison on Arm64 and x86_64
 
 When comparing benchmark results between Google Cloud Axion C4A (Arm64) and x86-based C4 (x86_64) instances, you will see:
 

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

@@ -6,44 +6,42 @@ weight: 4
 layout: learningpathall
 ---
 
-## Install PHP 
-In this section, you will install PHP together with the Apache web server and several commonly used PHP extensions on a SUSE Arm-based virtual machine. This forms the foundation for running and serving dynamic PHP applications on Arm-based machines.
+## Install PHP
+In this section, you’ll install PHP, the Apache web server, and several commonly used PHP extensions on a SUSE Arm-based virtual machine. This setup forms the foundation for running and serving dynamic PHP applications on Arm-based machines.
 
-### Update the system
+## Update the system
 Before installing any software, make sure your system has the latest packages and security patches:
 
 ```console
 sudo zypper refresh
 sudo zypper update -y
 ```
 
-### Install PHP, Apache, and common extensions
-Now install PHP, PHP-FPM, Apache web server, and some commonly used PHP extensions by using the following command:
+## Install PHP, Apache, and common extensions
+Install PHP, PHP-FPM, Apache web server, and some commonly used PHP extensions by running:
 
 ```console
 sudo zypper install -y php php-cli php-fpm php-mysql php-xml php-mbstring php-opcache apache2
 ```
-Package breakdown:
-| Package          | Description                                                                                      |
-| ---------------- | ------------------------------------------------------------------------------------------------ |
-| **php**          | Core PHP interpreter used to run web applications.                                               |
-| **php-cli**      | Enables running PHP scripts from the command line. Useful for testing and automation.            |
-| **php-fpm**      | FastCGI Process Manager — manages PHP worker processes and improves concurrency and performance. |
-| **php-mysql**    | Provides MySQL/MariaDB database connectivity for PHP.                                            |
-| **php-xml**      | Adds support for parsing and manipulating XML data.                                              |
-| **php-mbstring** | Adds multi-byte string handling, required by many web frameworks.                                |
-| **php-opcache**  | Boosts performance by caching precompiled PHP bytecode in memory, reducing runtime overhead.     |
-| **apache2**      | Installs the Apache HTTP web server, which will serve PHP files via mod_php or FastCGI.          |
+**Package breakdown:**
+- **php**: Core PHP interpreter used to run web applications.
+- **php-cli**: Enables running PHP scripts from the command line. Useful for testing and automation.
+- **php-fpm**: FastCGI Process Manager—manages PHP worker processes and improves concurrency and performance.
+- **php-mysql**: Provides MySQL/MariaDB database connectivity for PHP.
+- **php-xml**: Adds support for parsing and manipulating XML data.
+- **php-mbstring**: Adds multi-byte string handling, required by many web frameworks.
+- **php-opcache**: Boosts performance by caching precompiled PHP bytecode in memory, reducing runtime overhead.
+- **apache2**: Installs the Apache HTTP web server, which will serve PHP files via mod_php or FastCGI.
 
 
-### Enable and start Apache:
-Once Apache is installed, enable and start the service so that it runs automatically on boot and begins serving HTTP requests immediately:
+## Enable and start Apache
+After installing Apache, enable and start the service so it runs automatically on boot and begins serving HTTP requests:
 ```console
 sudo systemctl enable apache2
 sudo systemctl start apache2
 sudo systemctl status apache2
 ```
-If everything starts correctly, the output should look similar to:
+If everything starts correctly, the output is similar to:
 
 ```output
 ● apache2.service - The Apache Webserver
@@ -65,17 +63,21 @@ Oct 15 18:55:30 pareena-php-test systemd[1]: Starting The Apache Webserver...
 Oct 15 18:55:30 pareena-php-test systemd[1]: Started The Apache Webserver.
 ```
 
-### Verify PHP installation
+## Verify PHP installation
 After installation, verify that PHP is installed correctly and view the installed version:
 
 ```console
 php -v
 ```
-You should see output similar to:
+The output is similar to:
 ```output
 PHP 8.0.30 (cli) (built: Nov 25 2024 12:00:00) ( NTS )
 Copyright (c) The PHP Group
 Zend Engine v4.0.30, Copyright (c) Zend Technologies
 with Zend OPcache v8.0.30, Copyright (c), by Zend Technologies
+
+{{% notice success %}}
+PHP is installed and ready for use on your Arm-based SUSE VM.
+{{% /notice %}}
 ```
 You can now proceed to the baseline testing section, where you’ll create and load a simple PHP web page to confirm that Apache and PHP are working together on your SUSE Arm-based virtual machine.