Jenkins LP tech review

content/learning-paths/servers-and-cloud-computing/jenkins/_index.md

@@ -1,27 +1,27 @@
 ---
-title: Deploy Jenkins on Arm64 Cloud Platforms (Azure & GCP)
+title: Deploy Jenkins on Arm cloud platforms
 
 draft: true
 cascade:
     draft: true
 
 minutes_to_complete: 30   
 
-who_is_this_for: This learning path is intended for software developers deploying and optimizing Jenkins workloads on Linux/Arm64 environments, specifically on Microsoft Azure Cobalt 100 Arm processors and Google Cloud C4A virtual machines powered by Axion processors.
+who_is_this_for: This Learning Path is for software developers deploying and optimizing Jenkins workloads on Arm Linux environments, specifically on Microsoft Azure Cobalt 100 processors and Google Cloud C4A virtual machines powered by Axion processors.
 
 learning_objectives: 
-    - Provision an Azure Arm64 virtual machine using the Azure console, with Ubuntu Pro 24.04 LTS as the base image
-    - Provision an Arm-based SUSE SLES virtual machine on Google Cloud (C4A with Axion processors)
-    - Install the latest stable Jenkins LTS with OpenJDK 17 on an Arm64 VM
+    - Provision an Azure Arm64 virtual machine using the Azure console with Ubuntu Pro 24.04 LTS
+    - Provision an Arm-based SUSE Linux virtual machine on Google Cloud (C4A with Axion processors)
+    - Install Jenkins LTS with OpenJDK 17 on an Arm64 virtual machine
     - Validate Jenkins installation through service checks, UI access, and Arm-native pipeline execution
     - Execute Arm-native Jenkins pipelines to verify correct runtime behavior
-    - Implement real-world CI use cases on Arm64, including Docker-based pipelines
+    - Implement CI use cases on Arm64, including Docker-based pipelines
 
 prerequisites:
-    - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100 based instances (Dpsv6).
-    - A [Google Cloud Platform](https://cloud.google.com/) account with access to Arm-based VM instances.
-    - Basic understanding of Linux command line.
-    - Familiarity with CI/CD concepts and [Jenkins fundamentals](https://www.jenkins.io/doc/book/pipeline/).
+    - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100-based instances (Dpsv6)
+    - A [Google Cloud Platform](https://cloud.google.com/) account with access to Arm-based virtual machine instances
+    - Basic understanding of Linux command line
+    - Familiarity with CI/CD concepts and [Jenkins fundamentals](https://www.jenkins.io/doc/book/pipeline/)
 
 author: Pareena Verma
 

content/learning-paths/servers-and-cloud-computing/jenkins/azure-installation.md

@@ -1,113 +1,106 @@
 ---
-title: Install Jenkins on Azure Ubuntu Arm64 VM
+title: Install Jenkins on Azure Ubuntu Arm64 virtual machine
 weight: 5
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
+To install Jenkins on an Azure Ubuntu 24.04 LTS Arm64 virtual machine, follow these steps.
 
-## Install Jenkins on Azure Cobalt 100
-This guide explains how to install **Jenkins** on an **Azure Ubuntu 24.04 LTS Arm64 VM**.
-
-At the end of this guide, Jenkins will be:
+At the end of the installation, Jenkins is:
 
 * Installed and running as a system service
-* Accessible on **port 8080**
-* Verified on **Arm64 (aarch64)** with **Java 17**
+* Accessible on port 8080
+* Verified on Arm64 (aarch64) with Java 17
+
+## Update the system and install basic tools
 
-### System Preparation
-Updates the OS and installs basic tools required to securely download and manage Jenkins packages.
+Update the OS and install basic tools to securely download and manage Jenkins packages.
 
 ```console
 sudo apt update && sudo apt upgrade -y
 sudo apt install -y curl wget gnupg ca-certificates
 ```
 
-These tools are required to securely download Jenkins packages.
+## Install Java 17
 
-### Install Java 17 (Required)
-Install the supported Java runtime required for running Jenkins LTS reliably.
-Jenkins LTS officially supports **Java 17**.
+Jenkins LTS officially supports Java 17. Install the Java runtime:
 
 ```console
 sudo apt install -y openjdk-17-jdk
 ```
 
-### Verify Java Installation
-Confirms that Java 17 is installed correctly and available in the system PATH.
+Verify Java installation:
 
 ```console
 java -version
 ```
 
-You should see an output similar to:
+The output is similar to:
 ```output
 openjdk version "17.0.17" 2025-10-21
 OpenJDK Runtime Environment (build 17.0.17+10-Ubuntu-124.04)
 OpenJDK 64-Bit Server VM (build 17.0.17+10-Ubuntu-124.04, mixed mode, sharing)
 ```
 
-### Add Jenkins Official Repository (Stable LTS)
-Add the official Jenkins signing key to ensure package authenticity and security.
+## Add the Jenkins repository
+
+Add the official Jenkins signing key to ensure package authenticity:
 
 ```console
 curl -fsSL https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key | \
 sudo tee /usr/share/keyrings/jenkins-keyring.asc > /dev/null
 ```
 
-This key ensures Jenkins packages are trusted.
-
-### Add Jenkins Stable Repository
-Configure the system to download Jenkins LTS packages from the official Jenkins repository.
+Add the Jenkins stable repository:
 
 ```console
 echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \
 https://pkg.jenkins.io/debian-stable binary/ | \
 sudo tee /etc/apt/sources.list.d/jenkins.list
 ```
 
-### Install Jenkins (Latest Stable LTS)
-Install the latest stable Jenkins Long-Term Support release on the Arm64 VM.
+## Install Jenkins
+
+Install the latest stable Jenkins LTS release:
 
 ```console
 sudo apt update
 sudo apt install -y jenkins
 ```
 
-This installs the **latest Jenkins LTS available** at install time.
+## Start and enable the Jenkins service
 
-### Start and Enable Jenkins Service
-Starts Jenkins immediately and enables it to launch automatically after system reboot.
+Start Jenkins immediately and enable it to launch automatically after system reboot:
 
 ```console
 sudo systemctl enable jenkins
 sudo systemctl start jenkins
 ```
 
-### Verify Service Status
-Confirms that the Jenkins service is running successfully without errors.
+Verify the service is running:
 
 ```console
 sudo systemctl status jenkins
 ```
 
-You should see an output similar to:
+The output is similar to:
 ```output
 Active: active (running)
 ```
 
-### Verify Jenkins Version
-Validates the installed Jenkins LTS version to ensure correct deployment on Arm64.
+## Verify the Jenkins version
+
+Check the installed Jenkins version:
 
 ```console
 jenkins --version
 ```
 
-You should see an output similar to:
+The output is similar to:
 ```output
 2.528.3
 ```
-This confirm the installed Jenkins LTS version.
 
-This installation confirm Jenkins LTS is successfully deployed on an Azure Ubuntu Arm64 VM.
+Jenkins LTS is now successfully deployed on your Azure Ubuntu Arm64 virtual machine.

content/learning-paths/servers-and-cloud-computing/jenkins/azure-instance.md

@@ -1,50 +1,49 @@
 ---
-title: Create an Arm based cloud virtual machine using Microsoft Cobalt 100 CPU 
+title: Create an Arm-based virtual machine using Microsoft Cobalt 100 
 weight: 3
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Introduction
+You can create an Arm-based Cobalt 100 virtual machine using the Microsoft Azure console, the Azure CLI tool, or Infrastructure as Code (IaC). For this Learning Path, you use the Azure console to create a virtual machine with an Arm-based Cobalt 100 processor. 
 
-There are several ways to create an Arm-based Cobalt 100 virtual machine: the Microsoft Azure console, the Azure CLI tool, or using your choice of IaC (Infrastructure as Code). This guide will use the Azure console to create a virtual machine with Arm-based Cobalt 100 Processor. 
+You'll focus on the general-purpose virtual machine of the D series. For more details, see [Dpsv6 size series](https://learn.microsoft.com/en-us/azure/virtual-machines/sizes/general-purpose/dpsv6-series) in the Microsoft Azure documentation.  
 
-This learning path focuses on the general-purpose virtual machine of the D series. Please read the guide on [Dpsv6 size series](https://learn.microsoft.com/en-us/azure/virtual-machines/sizes/general-purpose/dpsv6-series) offered by Microsoft Azure.  
+If you haven't used Microsoft Azure before, see [Create a Linux virtual machine in the Azure portal](https://learn.microsoft.com/en-us/azure/virtual-machines/linux/quick-create-portal?tabs=ubuntu). 
 
-If you have never used the Microsoft Cloud Platform before, please review the microsoft [guide to Create a Linux virtual machine in the Azure portal](https://learn.microsoft.com/en-us/azure/virtual-machines/linux/quick-create-portal?tabs=ubuntu). 
+## Create an Arm-based Azure virtual machine 
 
-#### Create an Arm-based Azure Virtual Machine 
+To create an Azure virtual machine based on Cobalt 100, launch the Azure portal and navigate to **Virtual Machines**.
 
-Creating a virtual machine based on Azure Cobalt 100 is no different from creating any other virtual machine in Azure. To create an Azure virtual machine, launch the Azure portal and navigate to "Virtual Machines".
-1. Select "Create", and click on "Virtual Machine" from the drop-down list.
-2. Inside the "Basic" tab, fill in the Instance details such as "Virtual machine name" and "Region".
-3. Choose the image for your virtual machine (for example, Ubuntu Pro 24.04 LTS) and select “Arm64” as the VM architecture.
-4. In the “Size” field, click on “See all sizes” and select the D-Series v6 family of virtual machines. Select “D4ps_v6” from the list.
+1. Select **Create**, and click on **Virtual Machine** from the drop-down list.
+2. In the **Basic** tab, fill in the instance details such as **Virtual machine name** and **Region**.
+3. Choose the image for your virtual machine (for example, **Ubuntu 24.04 LTS**) and select **Arm64** as the VM architecture.
+4. In the **Size** field, click on **See all sizes** and select the **D-Series v6** family of virtual machines. Select **D4ps_v6** from the list.
 
 ![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/instance.png "Figure 1: Select the D-Series v6 family of virtual machines")
 
-5. Select "SSH public key" as an Authentication type. Azure will automatically generate an SSH key pair for you and allow you to store it for future use. It is a fast, simple, and secure way to connect to your virtual machine.
-6. Fill in the Administrator username for your VM.
-7. Select "Generate new key pair", and select "RSA SSH Format" as the SSH Key Type. RSA could offer better security with keys longer than 3072 bits. Give a Key pair name to your SSH key.
-8. In the "Inbound port rules", select HTTP (80) and SSH (22) as the inbound ports.
+5. Select **SSH public key** as an authentication type. Azure automatically generates an SSH key pair for you and allows you to store it for future use.
+6. Fill in the administrator username for your virtual machine.
+7. Select **Generate new key pair**, and select **RSA SSH Format** as the SSH key type. RSA offers better security with keys longer than 3072 bits. Give a key pair name to your SSH key.
+8. In **Inbound port rules**, select **HTTP (80)** and **SSH (22)** as the inbound ports.
 
 ![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/instance1.png "Figure 2: Allow inbound port rules")
 
-9. Click on the "Review + Create" tab and review the configuration for your virtual machine. It should look like the following:
+9. Click on the **Review + Create** tab and review the configuration for your virtual machine.
 
 ![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/ubuntu-pro.png "Figure 3: Review and Create an Azure Cobalt 100 Arm64 VM")
 
-10. Finally, when you are confident about your selection, click on the "Create" button, and click on the "Download Private key and Create Resources" button.
+10. When you're confident about your selection, click on the **Create** button, and click on the **Download Private key and Create Resources** button.
 
 ![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/instance4.png "Figure 4: Download Private key and Create Resources")
 
-11. Your virtual machine should be ready and running in no time. You can SSH into the virtual machine using the private key, along with the Public IP details.
+11. Your virtual machine is ready and running in a few minutes. Press **Go to Resource** to view the new virtual machine details. You can SSH into the virtual machine using the private key and the public IP address.
 
 ![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/final-vm.png "Figure 5: VM deployment confirmation in Azure portal")
 
 {{% notice Note %}}
 
-To learn more about Arm-based virtual machine in Azure, refer to “Getting Started with Microsoft Azure” in [Get started with Arm-based cloud instances](/learning-paths/servers-and-cloud-computing/csp/azure).
+For more information about Arm-based virtual machines in Azure, see [Get started with Arm-based cloud instances](/learning-paths/servers-and-cloud-computing/csp/azure).
 
 {{% /notice %}}

content/learning-paths/servers-and-cloud-computing/jenkins/azure_firewall.md

@@ -1,40 +1,37 @@
 ---
-title: Create a Firewall Rule on Azure
+title: Create a firewall rule on Azure
 weight: 4
 
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Overview
-In this section, you will create a firewall rule in the Microsoft Azure Console to allow inbound TCP traffic on port 8080.
-
-To allow external traffic on port **8080** for your application running on an Azure Virtual Machine, you must open the port in the **Network Security Group (NSG)** attached to the VM's network interface or subnet.
+To allow external traffic on port 8080 for your application running on an Azure virtual machine, open the port in the Network Security Group (NSG) attached to the virtual machine's network interface or subnet.
 
 {{% notice Note %}}
-For support on Azure setup, see the Learning Path [Getting started with Microsoft Azure Platform](/learning-paths/servers-and-cloud-computing/csp/azure/).
+For more information about Azure setup, see [Getting started with Microsoft Azure Platform](/learning-paths/servers-and-cloud-computing/csp/azure/).
 {{% /notice %}}
 
 
-### Create a Firewall Rule in Azure
+## Create a firewall rule in Azure
 
 To expose the TCP port 8080, create a firewall rule.
 
-Navigate to the [Azure Portal]([https://console.cloud.google.com/](https://portal.azure.com)), go to ****Virtual Machines**, and select **your VM**.
+Navigate to the [Azure Portal](https://portal.azure.com), go to **Virtual Machines**, and select your virtual machine.
 
 ![Create a firewall rule alt-text#center](images/virtual_machine.png "Virtual Machines")
 
-Next, in the left menu, click **Networking** and in the **Networking** select **Network settings** that is associated with the VM's network interface.
+In the left menu, click **Networking** and in the **Networking** select **Network settings** that is associated with the virtual machine's network interface.
 
 ![Create a firewall rule alt-text#center](images/networking.png "Network settings")
 
-Now, navigate to **Create port rule**, select **Inbound port rule**.
+Navigate to **Create port rule**, and select **Inbound port rule**.
 
 ![Create a firewall rule alt-text#center](images/port_rule.png "Create rule")
 
-Next, configure it using the following details. After filling in the details, click **Add** to save the rule.
+Configure it using the following details. After filling in the details, click **Add** to save the rule.
 
 ![Create a firewall rule alt-text#center](images/inbound_rule.png "Network settings")
 
-The network firewall rule has now been created
+The network firewall rule is now created.

content/learning-paths/servers-and-cloud-computing/jenkins/background.md

@@ -1,26 +1,27 @@
 ---
-title: Technology Stack Overview
+title: Technology stack overview
 
 weight: 2
 
 layout: "learningpathall"
 ---
 
-## Cobalt 100 Arm-based processor
+## Cobalt 100 processor
 
-Azure’s Cobalt 100 is built on Microsoft's first-generation, in-house Arm-based processor: the Cobalt 100. Designed entirely by Microsoft and based on Arm’s Neoverse N2 architecture, this 64-bit CPU delivers improved performance and energy efficiency across a broad spectrum of cloud-native, scale-out Linux workloads. These include web and application servers, data analytics, open-source databases, caching systems, and other related technologies. Running at 3.4 GHz, the Cobalt 100 processor allocates a dedicated physical core for each vCPU, ensuring consistent and predictable performance. 
+Azure's Cobalt 100 is built on Microsoft's first-generation, in-house Arm-based processor. Designed entirely by Microsoft and based on Arm's Neoverse N2 architecture, this 64-bit CPU delivers improved performance and energy efficiency across a broad spectrum of cloud-native, scale-out Linux workloads, including web and application servers, data analytics, open-source databases, caching systems, and related technologies. Running at 3.4 GHz, the Cobalt 100 processor allocates a dedicated physical core for each vCPU, ensuring consistent and predictable performance. 
 
-To learn more about Cobalt 100, refer to the blog [Announcing the preview of new Azure virtual machine based on the Azure Cobalt 100 processor](https://techcommunity.microsoft.com/blog/azurecompute/announcing-the-preview-of-new-azure-vms-based-on-the-azure-cobalt-100-processor/4146353).
+For more information about Cobalt 100, see [Announcing the preview of new Azure virtual machines based on the Azure Cobalt 100 processor](https://techcommunity.microsoft.com/blog/azurecompute/announcing-the-preview-of-new-azure-vms-based-on-the-azure-cobalt-100-processor/4146353).
 
 ## Google Axion C4A Arm instances in 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 offers a cost-effective alternative to x86 virtual machines, 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.
+For more information about Google Axion, see [Introducing Google Axion Processors, our new Arm-based CPUs](https://cloud.google.com/blog/products/compute/introducing-googles-new-arm-based-cpu).
 
 ## Jenkins
-Jenkins is an open-source automation server used to build, test, and deploy software through continuous integration and continuous delivery (CI/CD). It automates development workflows and integrates with a wide range of tools and platforms via its plugin ecosystem.
 
-Learn more from the [Jenkins official website](https://www.jenkins.io/) and the [official documentation](https://www.jenkins.io/doc/).
+Jenkins is an open-source automation server used to build, test, and deploy software through continuous integration and continuous delivery (CI/CD). It automates development workflows and integrates with a wide range of tools and platforms through its plugin ecosystem.
+
+For more information, see the [Jenkins official website](https://www.jenkins.io/) and the [official documentation](https://www.jenkins.io/doc/).