Merge pull request #2619 from madeline-underwood/puppet

Puppet_JA to sign off

Author: jasonrandrews

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

@@ -1,26 +1,21 @@
 ---
-title: Deploy Puppet on Google Cloud C4A (Arm-based Axion VMs)
-
-draft: true
-cascade:
-    draft: true
+title: Deploy Puppet on Google Cloud C4A 
 
 minutes_to_complete: 30
 
-who_is_this_for: This is an introductory topic for software developers deploying and optimizing Puppet workloads on Arm Linux environments, specifically using Google Cloud C4A virtual machines powered by Axion processors. 
+who_is_this_for: This is an introductory topic for developers deploying and optimizing Puppet workloads on Arm Linux environments, specifically using Google Cloud C4A virtual machines powered by Axion processors. 
 
 learning_objectives:
-  - Provision an Arm-based SUSE SLES virtual machine on Google Cloud (C4A with Axion processors)
-  - Install Puppet on a SUSE Arm64 (C4A) instance
+  - Provision an Arm-based SUSE SLES (SUSE Linux Enterprise Server) virtual machine (VM) on Google Cloud C4A with Axion processors
+  - Install Puppet on a SUSE Arm64 C4A instance
   - Verify Puppet by applying a test manifest and confirming successful resource creation on Arm64  
   - Benchmark Puppet by measuring catalog compile time, apply speed, and resource usage on Arm64
+author: Pareena Verma
 
 prerequisites:
   - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled  
   - Basic familiarity with [Puppet](https://www.puppet.com/)
 
-author: Pareena Verma
-
 ##### Tags
 skilllevels: Introductory
 subjects: Performance and Architecture

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

@@ -1,27 +1,30 @@
 ---
-title: Getting started with Puppet on Google Axion C4A (Arm Neoverse-V2)
+title: Get started with Arm-based Google Axion and Puppet
 
 weight: 2
 
 layout: "learningpathall"
 ---
 
-## Google Axion C4A Arm instances in Google Cloud
+## Automate and optimize cloud deployments on Arm
+
+Modern cloud workloads demand scalable, efficient, and automated infrastructure management. By combining Arm-based Google Axion C4A instances with Puppet, you can take advantage of high-performance, energy-efficient virtual machines and powerful configuration management tools. This section introduces the key technologies you'll use to automate and optimize your cloud deployments on Arm in Google Cloud.
+
+## Explore Google Axion C4A Arm instances on Google Cloud
 
 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.
 
 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.
-
-## Puppet
+To learn more about 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).
 
-[Puppet](https://puppet.com/) is an **open-source configuration management and automation tool** designed to help system administrators and DevOps teams **manage infrastructure as code**. Developed by [Puppet Labs](https://puppet.com/company/), it automates the provisioning, configuration, and management of servers and services across large-scale environments.
+## Explore Puppet
+[Puppet](https://puppet.com/) is an open-source configuration management and automation tool designed to help system administrators and DevOps teams manage infrastructure as code. Developed by [Puppet Labs](https://puppet.com/company/), it automates the provisioning, configuration, and management of servers and services across large-scale environments.
 
-Puppet uses a **declarative language** to define system configurations, ensuring that every machine’s state matches the desired setup described in its manifests. It supports both **agent-based** and **agentless** architectures, making it flexible for diverse deployment needs.
+Puppet uses a declarative language to define system configurations, ensuring that every machine’s state matches the desired setup described in its manifests. It supports both agent-based and agentless architectures, making it flexible for diverse deployment needs.
 
-Known for its **scalability**, **reliability**, and **idempotent behavior**, Puppet continuously enforces configurations, reducing manual effort and configuration drift. It integrates well with major platforms like **Linux**, **Windows**, **macOS**, and cloud providers such as **AWS**, **Azure**, and **GCP**.
+Known for its scalability, reliability, and idempotent behavior, Puppet continuously enforces configurations, reducing manual effort and configuration drift. It integrates well with major platforms like Linux, Windows, macOS, and cloud providers such as AWS, Azure, and GCP.
 
-Common use cases include **automating server configuration**, **applying security policies**, **software installation**, and **infrastructure auditing**. Puppet is widely used in enterprises for managing **hybrid and multi-cloud environments** efficiently.
+Common use cases include automating server configuration, applying security policies, software installation, and infrastructure auditing. Puppet is widely used in enterprises for managing hybrid and multi-cloud environments efficiently.
 
 To learn more, visit the [official Puppet website](https://puppet.com/).

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

@@ -1,16 +1,15 @@
 ---
-title: Puppet Baseline Testing on Google Axion C4A Arm Virtual Machine
+title: Perform Puppet baseline testing 
 weight: 5
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Puppet baseline testing on GCP SUSE VMs
+## Overview
+You can perform baseline testing of Puppet on a GCP SUSE Arm64 VM to make sure your installation works as expected. In this Learning Path, you'll verify Puppet and Facter versions, run basic Puppet commands, apply a simple manifest, and confirm that system facts are collected correctly. These steps help you validate your setup before moving on to advanced Puppet tasks.
 
-You can perform baseline testing of Puppet on a GCP SUSE Arm64 VM to verify that the installation works correctly. You will check Puppet and Facter versions, run basic Puppet commands, apply a simple manifest, and confirm that system facts are collected accurately.
-
-### Verify the Puppet installation
+## Verify the Puppet installation
 
 Verify that Puppet and Facter are correctly installed and respond to version checks.
 
@@ -49,7 +48,7 @@ The output confirms the Ruby version and architecture:
 ruby 3.1.4p223 (2023-03-30 revision 957bb7cb81) [aarch64-linux]
 ```
 
-### Run a simple Puppet command
+## Run a simple Puppet command
 
 Check that Puppet responds to commands by running `puppet help`. If the help menu appears, Puppet is working correctly.
 
@@ -96,9 +95,9 @@ See 'puppet help <subcommand>' for help on a specific subcommand.
 Puppet v8.10.0
 ```
 
-### Test a Simple Puppet Manifest
+## Test a simple Puppet manifest
 
-Create a basic Puppet script to make sure Puppet can apply configurations. If it successfully creates the test file, your Puppet agent functions as expected.
+Create a basic Puppet script to make sure Puppet can apply configurations. The purpose of this script is to verify that Puppet can successfully apply configurations on your system. If the script runs and creates the specified test file, it confirms that your Puppet agent is functioning correctly:
 
 ```bash
 cd ~
@@ -124,7 +123,7 @@ Notice: /Stage[main]/Main/File[/tmp/puppet_test.txt]/ensure: defined content as
 Notice: Applied catalog in 0.01 seconds
 ```
 
-Open the file created by Puppet to confirm the content matches your script. This step validates that Puppet executed your manifest correctly.
+Open the file created by Puppet to confirm the content matches your script. This step validates that Puppet executed your manifest correctly:
 
 ```console
 cat /tmp/puppet_test.txt
@@ -135,7 +134,7 @@ Output:
 Hello from Puppet on SUSE ARM64!
 ```
 
-### Check Facter integration
+## Check Facter integration
 
 Run `facter` commands to verify that it collects accurate system details, such as the OS and CPU type. This ensures Puppet can gather the facts it needs for automation decisions.
 
@@ -207,4 +206,13 @@ The output is similar to the following:
 }
 ```
 
-With these checks complete, proceed to the Puppet benchmarking section to run workload-focused tests on the GCP SUSE VMs.
+## What you've accomplished and what's next
+
+You've completed the essential baseline checks for Puppet on your GCP SUSE Arm64 VM. At this point, you've:
+
+- Verified that Puppet, Facter, and Ruby are installed and working
+- Confirmed Puppet responds to commands and applies manifests
+- Validated that Facter collects accurate system facts
+
+This progress means your environment is ready for more advanced testing. Next, you'll move on to Puppet benchmarking, where you'll run workload-focused tests to measure performance on your GCP SUSE VM.
+

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

@@ -1,19 +1,18 @@
 ---
-title: Puppet Benchmarking
+title: Benchmark Puppet
 weight: 6
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
 
-##  Puppet Benchmark on GCP SUSE Arm64 VM
+##  Benchmark Puppet on a GCP SUSE Arm64 VM
 
-This guide explains how to perform a **Puppet standalone benchmark** on a **Google Cloud Platform (GCP) SUSE Linux Arm64 VM**.  
-It measures Puppet’s local execution performance without requiring a Puppet Master.
+This section walks you through how to perform a Puppet standalone benchmark on a Google Cloud Platform (GCP) SUSE Linux Arm64 VM. It measures Puppet’s local execution performance without requiring a Puppet Master.
 
 
-### Prerequisites
+## Prerequisites
 Ensure that Puppet is installed and functioning correctly:
 
 ```console
@@ -24,7 +23,7 @@ Output:
 8.10.0
 ```
 
-### Create a Benchmark Manifest
+## Create a benchmark manifest
 Create a directory and a simple manifest file:
 
 ```console
@@ -41,11 +40,16 @@ notify { 'Benchmark Test':
 }
 ```
 
-- **notify** is a built-in Puppet resource type that displays a message during catalog application (like a print or log message).
-- **'Benchmark Test'** is the title of the resource — a unique identifier for this notify action.
-- **message => 'Running Puppet standalone benchmark.'** specifies the text message Puppet will print when applying the manifest.
+## Explore the code 
 
-### Run the Benchmark Command
+Here is a breakdown of the key elements in the `benchmark.pp` manifest to help you understand how Puppet processes and displays information during the benchmark:
+
+- `notify` is a built-in Puppet resource type that displays a message during catalog application (like a print or log message).
+- `Benchmark Test` is the title of the resource. It's a unique identifier for this notify action.
+- `message => 'Running Puppet standalone benchmark.'` specifies the text message Puppet prints when applying the manifest.
+
+
+## Run the benchmark command
 This step runs Puppet in standalone mode using the `apply` command to execute the benchmark manifest locally while measuring execution time and performance statistics.
 
 ```console
@@ -67,30 +71,40 @@ user    0m0.676s
 sys     0m0.367s
 ```
 
-### Benchmark Metrics Explanation
-
-- **Compiled catalog** → Puppet compiled your manifest into an execution plan.  
-- **Applied catalog** → Puppet executed the plan on your system.  
-- **real** → Total elapsed wall time (includes CPU + I/O).  
-- **user** → CPU time spent in user-space.  
-- **sys** → CPU time spent in system calls.  
-
-### Benchmark results
-The above results were executed on a `c4a-standard-4` (4 vCPU, 16 GB memory) Axiom Arm64 VM in GCP running SuSE:
-
-| **Metric / Log** | **Output** |
-|-------------------|------------|
-| Compiled catalog | 0.01 seconds |
-| Environment | production |
-| Applied catalog | 0.01 seconds |
-| real | 0m1.054s |
-| user | 0m0.676s |
-| sys | 0m0.367s |
-
-### Puppet benchmarking summary
-
-- **Catalog compilation:** Completed in just **0.01 seconds**, showing excellent processing speed on **Arm64**.
-- **Environment:** Executed smoothly under the **production** environment.
-- **Configuration version:** Recorded as **1763407825**, confirming successful version tracking.
-- **Catalog application:** Finished in **0.01 seconds**, demonstrating very low execution latency.
-- **Real time:** Total runtime of **1.054 seconds**, reflecting efficient end.
+## Interpret the benchmark metrics
+Here is a breakdown of the key benchmark metrics you will see in the output:
+
+- `Compiled catalog`: Puppet parsed your manifest and generated a catalog, which is an execution plan describing the desired system state. This metric shows how quickly Puppet can process and prepare your configuration for application. Fast compilation times indicate efficient manifest design and good platform performance.
+- `Applied catalog`: Puppet applied the compiled catalog to your VM, making the necessary changes to reach the desired state. This value reflects how quickly Puppet can enforce configuration changes on your Arm64 system. Low application times suggest minimal system overhead and effective resource management.
+- `real`: This is the total elapsed wall-clock time from start to finish of the `puppet apply` command. It includes all time spent running the process, waiting for I/O, and any other delays. Lower real times mean faster end-to-end execution, which is important for automation and scaling.
+- `user`: This measures the amount of CPU time spent executing user-space code (Puppet and Ruby processes) during the benchmark. High user time relative to real time can indicate CPU-bound workloads, while lower values suggest efficient code execution.
+- `sys`: This is the CPU time spent in system (kernel) calls, such as file operations or network access. Lower sys times are typical for lightweight manifests, while higher values may indicate more intensive system interactions or I/O operations.
+
+## Benchmark results
+
+The following table summarizes the benchmark metrics collected from running Puppet on a `c4a-standard-4` (4 vCPU, 16 GB memory) Axiom Arm64 VM in Google Cloud Platform (GCP) with SUSE Linux. These results provide a baseline for evaluating Puppet’s performance on Arm64 infrastructure. Use this data to compare against other VM types or architectures, and to identify areas for further optimization.
+
+| Metric / Log   | Output    |
+|--------------------|--------------|
+| Compiled catalog   | 0.01 seconds |
+| Environment        | production   |
+| Applied catalog    | 0.01 seconds |
+| real               | 0m1.054s     |
+| user               | 0m0.676s     |
+| sys                | 0m0.367s     |
+
+These metrics reflect efficient catalog compilation and application times, as well as low system overhead, demonstrating the strong performance of Puppet on Arm64-based GCP VMs.
+
+## Review Puppet benchmarking results
+
+Confirm that your benchmark output matches the expected metrics for catalog compilation, application, and system resource usage. If your results differ significantly, investigate VM resource allocation, manifest complexity, or system load. Use these metrics to validate Puppet performance on Arm64 and identify opportunities for further optimization.
+
+These benchmark results demonstrate that catalog compilation completed in only 0.01 seconds, highlighting the processing speed of the Arm64 platform. The benchmark ran smoothly in the production environment, and the configuration version was successfully recorded as 1763407825. Catalog application also finished in 0.01 seconds, indicating very low execution latency. The total runtime was 1.054 seconds, which reflects efficient overall performance for Puppet on an Arm64 SUSE VM in Google Cloud Platform.
+
+This benchmarking method is useful for validating Puppet performance after migration to Arm64, or when optimizing infrastructure for cost and speed. For more advanced benchmarking, consider automating multiple runs, collecting metrics over time, and comparing results with x86-based VMs to quantify the benefits of Arm64 on GCP.
+
+## Summary and next steps
+
+You’ve successfully benchmarked Puppet on an Arm64-based SUSE VM in Google Cloud Platform. You created and applied a simple manifest, measured key performance metrics, and interpreted the results to validate Puppet’s efficiency on Arm infrastructure. These steps help ensure your configuration management setup is optimized for speed and reliability on modern cloud platforms.
+
+Well done - completing this benchmark gives you a solid foundation for further automation and optimization with Puppet on Arm.