Merge pull request #2371 from madeline-underwood/golang

Golang_JA to sign off

Author: jasonrandrews

content/learning-paths/servers-and-cloud-computing/golang-on-azure/_index.md

@@ -1,22 +1,19 @@
 ---
-title: Deploy Golang on the Microsoft Azure Cobalt 100 processors 
+title: Deploy Golang on Azure Cobalt 100 on Arm
 
-draft: true
-cascade:
-    draft: true
-    
-minutes_to_complete: 30   
+minutes_to_complete: 30
 
-who_is_this_for: This is an introductory topic for software developers looking to migrate their Golang workloads from x86_64 to Arm-based platforms, specifically on the Microsoft Azure Cobalt 100 processors.
+who_is_this_for: This is an introductory topic for software developers, DevOps engineers, and cloud architects looking to migrate their Golang (Go) applications from x86_64 to high-performance Arm-based Azure Cobalt 100 virtual machines for improved cost efficiency and performance.
 
 learning_objectives: 
-    - Provision an Azure Arm64 virtual machine using Azure console, with Ubuntu Pro 24.04 LTS as the base image.
-    - Deploy Golang on an Arm64-based virtual machine running Ubuntu Pro 24.04 LTS.
-    - Perform Golang baseline testing and benchmarking on both x86_64 and Arm64 virtual machine.
+    - Provision an Azure Arm64 virtual machine using the Azure portal, with Ubuntu Pro 24.04 LTS as the base image
+    - Deploy Golang on an Arm64-based virtual machine running Ubuntu Pro 24.04 LTS
+    - Perform Golang baseline testing and benchmarking on both x86_64 and Arm64 virtual machines
 
 prerequisites:
-    - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100 based instances (Dpsv6)
-    - Familiarity with the [Golang](https://go.dev/) and deployment practices on Arm64 platforms.
+    - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Azure Cobalt 100 Arm-based instances (Dpsv6-series)
+    - Basic familiarity with the [Go programming language](https://go.dev/) and cloud deployment practices
+    - Understanding of Linux command line and virtual machine management
 
 author: Pareena Verma
 
@@ -26,13 +23,13 @@ subjects: Performance and Architecture
 cloud_service_providers: Microsoft Azure
 
 armips:
-    - Neoverse
+  - Neoverse
 
 tools_software_languages:
     - Golang
 
 operatingsystems:
-    - Linux
+  - Linux
 
 further_reading:
     - resource: 
@@ -42,7 +39,7 @@ further_reading:
     - resource:
         title: Testing and Benchmarking in Go
         link: https://pkg.go.dev/testing
-        type: Official Documentation
+        type: Documentation
     - resource:        
         title: Using go test -bench for Benchmarking
         link: https://pkg.go.dev/cmd/go#hdr-Testing_flags

content/learning-paths/servers-and-cloud-computing/golang-on-azure/background.md

@@ -1,18 +1,39 @@
 ---
 title: "Overview"
-
 weight: 2
 
-layout: "learningpathall"
+### FIXED, DO NOT MODIFY
+layout: learningpathall
 ---
+## Microsoft Azure Cobalt 100 Arm-based processor
+
+Azure Cobalt 100 is Microsoft's first-generation, custom-designed Arm-based processor built on the advanced Arm Neoverse N2 architecture. This high-performance 64-bit CPU is specifically optimized for cloud-native, scale-out Linux workloads including web servers, application servers, real-time data analytics, open-source databases, and in-memory caching solutions.
+
+Key performance features include:
+- Clock speed: 3.4 GHz for optimal processing power
+- Core allocation: dedicated physical core per vCPU for consistent performance
+- Architecture: Arm Neoverse N2 for superior energy efficiency
+- Target workloads: cloud-native applications and microservices 
+
+To learn more, see the Microsoft blog: [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).
+
+## Golang (Go programming language)
 
-## Cobalt 100 Arm-based processor
+Golang (Go) is a modern, open-source programming language developed by Google, specifically designed for building scalable, high-performance applications. Go excels in simplicity, compilation speed, and runtime efficiency, making it an ideal choice for cloud-native development and Arm64 architecture deployment.
 
-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 more. Running at 3.4 GHz, the Cobalt 100 processor allocates a dedicated physical core for each vCPU, ensuring consistent and predictable performance. 
+Key performance features include:
+- Built-in concurrency with goroutines and channels
+- Strong static typing for improved code reliability
+- Comprehensive standard library for rapid development
+- Fast compilation and efficient garbage collection
+- Cross-platform compatibility including native Arm64 support
 
-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).
+Go language primary use cases:
+- Cloud-native applications and containerized workloads
+- Microservices architecture and API development
+- Systems programming and infrastructure tools
+- DevOps automation and CI/CD pipelines
+- Distributed systems and high-throughput services 
 
-## Golang
-Golang (or Go) is an open-source programming language developed by Google, designed for simplicity, efficiency, and scalability. It provides built-in support for concurrency, strong typing, and a rich standard library, making it ideal for building reliable, high-performance applications.
+For more information, visit the [Go website](https://go.dev/) and see the [Go documentation](https://go.dev/doc/).
 
-Go is widely used for cloud-native development, microservices, system programming, DevOps tools, and distributed systems. Learn more from the [Go official website](https://go.dev/) and its [official documentation](https://go.dev/doc/).

content/learning-paths/servers-and-cloud-computing/golang-on-azure/baseline-testing.md

@@ -1,32 +1,31 @@
 ---
-title: Golang Baseline Testing 
+title: Perform Golang baseline testing and web server deployment on Azure Cobalt 100 
 weight: 5
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
+## Baseline testing: run a Go web server on Azure Arm64
 
-### Baseline Testing: Running a Go Web Server on Azure Arm64
-To validate your Go toolchain and runtime environment, you can build and run a lightweight web server. This ensures that compilation, networking, and runtime execution are working correctly on your Ubuntu Pro 24.04 LTS Arm64 virtual machine running on Azure Cobalt 100.
+Validate your Go development environment by building and deploying a complete web application. This baseline test confirms that compilation, networking, and runtime execution work correctly on your Ubuntu Pro 24.04 LTS Arm64 virtual machine powered by Azure Cobalt 100 processors.
 
-1. Create the project directory
-   
-Start by creating a new folder to hold your Go web project and navigate to it:
+## Initialize Go Web Project
+
+Create a dedicated project directory for your Go web application:
 
 ```console
 mkdir goweb && cd goweb
 ```
 
-2. Create an HTML Page with Bootstrap Styling
-
-Next, create a simple web page that your Go server will serve. Using the nano editor (or any editor of your choice), create a file named `index.html`:
+## Create an HTML page with Bootstrap styling
 
+Next, create a simple web page that your Go server will serve. Open an editor and create `index.html`:
 ```console
 nano index.html
 ```
 
-Paste the following HTML code into the `index.html` file. This page uses Bootstrap for styling and includes a header, a welcome message, and a button that links to a Go-powered API endpoint.
+Add the following HTML code with Bootstrap styling and Azure Cobalt 100 branding:
 
 ```html
 <!DOCTYPE html>
@@ -65,15 +64,16 @@ Paste the following HTML code into the `index.html` file. This page uses Bootstr
 </body>
 </html>
 ```
-3. Create Golang Web Server
 
 Now, let’s create the Go program that will serve your static HTML page and expose a simple API endpoint.
 
+Open an editor and create `main.go`:
 ```console
 nano main.go
 ```
-Paste the following code into the `main.go` file. This sets up a very basic web server that serves files from the current folder, including the `index.html` you just created. When it runs, it will print a message showing the server address.
+Paste the following code into the `main.go` file. This sets up a basic web server that serves files from the current folder, including the `index.html` you just created. When it runs, it will print a message showing the server address.
 
+Paste the following code into `main.go`:
 ```go
 package main
 import (
@@ -105,24 +105,22 @@ func main() {
 ```
 {{% notice Note %}}Running on port 80 requires root privileges. Use sudo with the full Go path if needed.{{% /notice %}}
 
-4. Run the Web Server
-   
-Compile and start your Go program with:
+## Deploy and Start the Web Server
+
+Compile and launch your Go web server on Azure Cobalt 100:
 
 ```console
 sudo /usr/local/go/bin/go run main.go
 ```
 
-This command compiles the Go source code into a binary and immediately starts the server on port 80. If the server starts successfully, you will see the following message in your terminal:
-
+Expected output confirming successful startup:
 ```output
 2025/08/19 04:35:06 Server running on http://0.0.0.0:80
 ```
-5. Allow HTTP Traffic in Firewall
 
-On Ubuntu Pro 24.04 LTS virtual machines, UFW (Uncomplicated Firewall) is used to manage firewall rules. By default, it allows only SSH (port 22), while other inbound connections are blocked. 
+### Configure Ubuntu Firewall for HTTP Access
 
-Even if you have already configured Azure Network Security Group (NSG) rules to allow inbound traffic on port 80, the VM level firewall may still block HTTP requests until explicitly opened.
+Ubuntu Pro 24.04 LTS uses UFW (Uncomplicated Firewall) to manage network access. Even with Azure Network Security Group (NSG) rules configured, the VM-level firewall requires explicit HTTP access configuration.
 
 Run the following commands to allow HTTP traffic on port 80:
 
@@ -145,14 +143,27 @@ To                         Action      From
 80/tcp (v6)                ALLOW       Anywhere (v6)
 ```
 
-6. Open in a Browser
-To quickly get your VM’s public IP address and form the URL, run:
+{{% notice Note %}}
+If UFW is already active, `sudo ufw enable` might warn you about disrupting SSH. Proceed only if you understand the impact, or use an Azure VM serial console as a recovery option.
+{{% /notice %}}
 
+## Open the site in a browser
+
+Print your VM’s public URL:
 ```console
 echo "http://$(curl -s ifconfig.me)/"
 ```
-Open this URL in your browser, and you should see the styled HTML landing page being served directly by your Go application.
 
-![golang](images/go-web.png)
+Open this URL in your browser. You should see the styled HTML landing page served by your Go application.
+
+![Go web server running on Azure Cobalt 100 Arm64 alt-text#center](images/go-web.png "Go web server running on Azure Cobalt 100 Arm64")
+
+## Baseline Testing Complete
+
+Successfully reaching this page confirms:
+- **Go toolchain** is properly installed and configured
+- **Development environment** is ready for Arm64 compilation
+- **Network connectivity** and firewall configuration are correct
+- **Runtime performance** is functioning on Azure Cobalt 100 processors
 
-Reaching this page in your browser confirms that Go is installed correctly, your environment is configured, and your Go web server is working end-to-end on Azure Cobalt 100 (Arm64). You can now proceed to perform further benchmarking tests.                                                      
+Your Azure Cobalt 100 virtual machine is now ready for advanced Go application development and performance benchmarking.