Merge pull request #2447 from madeline-underwood/phpgc

Phpgc_JA to review

Author: jasonrandrews

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

@@ -1,19 +1,15 @@
 ---
-title:  Deploy PHP on Google Cloud C4A (Arm-based Axion VMs)
+title:  Deploy PHP on Google Cloud C4A Arm-based Axion VMs
 
-draft: true
-cascade:
-    draft: true
-    
+  
 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 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 Google Cloud C4A (Arm-based Axion VM)
-  - Install PHP on a SUSE Arm64 (C4A) instance
-  - Validate PHP functionality with baseline HTTP server tests  
+  - 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 
 
 
@@ -32,7 +28,7 @@ armips:
 
 tools_software_languages:
   - PHP
-  - apache
+  - Apache
   - PHPBench
 
 operatingsystems:

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

@@ -1,23 +1,22 @@
 ---
-title: Get started with PHP on Google Axion C4A (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 built on Google’s custom Axion CPU, which is based on Arm Neoverse V2 cores. Designed for high-performance and energy-efficient computing, these virtual machines offer strong performance for modern cloud workloads such as CI/CD pipelines, microservices, media processing, and general-purpose applications.
+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).
 
-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.
 
-To learn more about Google Axion, refer to the [Introducing Google Axion Processors, our new Arm-based CPUs](https://cloud.google.com/blog/products/compute/introducing-googles-new-arm-based-cpu) blog.
+## Google Axion C4A
 
-## 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.  
+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).
 
-It allows developers to create dynamic web pages, interact with databases, handle forms, and build web applications. PHP can be embedded directly into HTML, making it easy to generate content dynamically on the server before sending it to the browser.  
+## What's next?
 
-PHP is widely used for websites, web applications, content management systems (CMS), and APIs. Learn more from the [PHP official website](https://www.php.net/) and its [official documentation](https://www.php.net/docs.php).
+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

@@ -1,35 +1,34 @@
 ---
-title: PHP baseline testing on Google Axion C4A Arm Virtual Machine
+title: Validate PHP baseline on Google Cloud Axion C4A Arm VM
 weight: 5
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
 
-## Baseline Setup for PHP-FPM
-This section guides you through configuring PHP-FPM (FastCGI Process Manager) on a SUSE Arm-based Google Cloud C4A virtual machine. You will prepare the PHP-FPM pool configuration, verify PHP's FastCGI setup, and later connect it to Apache to confirm end-to-end functionality.
+## 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 that are independent of the web server.
-This design improves performance, security, and fault isolation — especially useful on multi-core Arm-based processors like Google Cloud’s 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 defines a group of PHP worker processes, each serving incoming FastCGI requests. Different applications or virtual hosts can use separate pools for better resource control.
+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:
-Create a default pool configuration (www.conf) that controls how PHP-FPM spawns and manages worker processes.
-Restore the main FPM service configuration (php-fpm.conf) if it's missing.
+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:
 
@@ -51,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. |
@@ -60,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:
 
@@ -91,11 +90,11 @@ 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).
-Next, you will configure Apache to communicate with PHP-FPM, allowing your server to process and serve dynamic PHP pages.
+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
-If you prefer to have Apache handle PHP execution directly (instead of using PHP-FPM), you can install the Apache PHP 8 module, which integrates PHP into Apache using the `mod_php` interface:
+If you want Apache to handle PHP execution directly (instead of using PHP-FPM), install the Apache PHP 8 module, which integrates PHP into Apache using the `mod_php` interface:
 
 ```console
 sudo zypper install apache2-mod_php8
@@ -105,28 +104,26 @@ Once the module is installed, restart Apache to load the new configuration:
 ```console
 sudo systemctl restart apache2
 ```
-Next, you will test PHP execution by creating a simple PHP page and verifying that Apache can correctly render dynamic content.
+Next, you’ll test PHP execution by creating a simple PHP page and verifying that Apache can correctly render dynamic content.
 
-## Test PHP
-Now that PHP and Apache are installed, you can verify that everything is working correctly.
+## 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 will display the PHP configuration page.
+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 will 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:
 
@@ -148,20 +145,25 @@ h1 {font-size: 150%;}
 h2 {font-size: 125%;}
 h2 a:link, h2 a:visited{color: inherit; background: inherit;}
 ```
-This long HTML output represents the PHP configuration page content. 
+This long HTML output represents the PHP configuration page content.
 
-### Test from Your Browser
-Now, let's verify that your PHP setup works correctly from outside the VM.
+## 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 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 will 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 C4A is configured and functioning properly.
-You are now ready to proceed to the benchmarking and performance testing phase.
+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.