diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/_index.md b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/_index.md new file mode 100644 index 0000000000..4605c69fb9 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/_index.md @@ -0,0 +1,58 @@ +--- +title: Run Golang on the Microsoft Azure Cobalt 100 processors + +minutes_to_complete: 40 + +who_is_this_for: This Learning Path is designed for software developers looking to migrate their Golang workloads from x86_64 to Arm-based platforms, specifically on the Microsoft Azure Cobalt 100 processors. + +learning_objectives: + - Start an Azure Arm64 virtual machine using Azure console, with Ubuntu as the base image. + - Learn how to create an Azure Linux 3.0 Docker container. + - Deploy the Golang on an Azure Linux 3.0 Arm64-based Docker container and an Azure Linux 3.0 custom-image-based Azure virtual machine. + - Test and Benchmark Golang in both containerized and virtual machine environments. + +prerequisites: + - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100 based instances (Dpsv6). + - A machine with [Docker](/install-guides/docker/) installed. + - Basic understanding of Linux command line. + - Familiarity with the [Golang](https://go.dev/) and deployment practices on Arm64 platforms. + +author: Jason Andrews + +### Tags +skilllevels: Advanced +subjects: Performance and Architecture +cloud_service_providers: Microsoft Azure + +armips: + - Neoverse + +tools_software_languages: + - Golang + - Docker + - go test -bench + +operatingsystems: + - Linux + +further_reading: + - resource: + title: Effective Go Benchmarking + link: https://go.dev/doc/effective_go#testing + type: Guide + - resource: + title: Testing and Benchmarking in Go + link: https://pkg.go.dev/testing + type: Official Documentation + - resource: + title: Using go test -bench for Benchmarking + link: https://pkg.go.dev/cmd/go#hdr-Testing_flags + type: Reference + + +### FIXED, DO NOT MODIFY +# ================================================================================ +weight: 1 # _index.md always has weight of 1 to order correctly +layout: "learningpathall" # All files under learning paths have this same wrapper +learning_path_main_page: "yes" # This should be surfaced when looking for related content. Only set for _index.md of learning path content. +--- diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/_next-steps.md b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/_next-steps.md new file mode 100644 index 0000000000..c3db0de5a2 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/_next-steps.md @@ -0,0 +1,8 @@ +--- +# ================================================================================ +# FIXED, DO NOT MODIFY THIS FILE +# ================================================================================ +weight: 21 # Set to always be larger than the content in this path to be at the end of the navigation. +title: "Next Steps" # Always the same, html page title. +layout: "learningpathall" # All files under learning paths have this same wrapper for Hugo processing. +--- diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/background.md b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/background.md new file mode 100644 index 0000000000..11077c1543 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/background.md @@ -0,0 +1,22 @@ +--- +title: "Cobalt 100 Arm-based processor and Golang" + +weight: 2 + +layout: "learningpathall" +--- + +## Cobalt 100 Arm-based 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 more. 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). + +## Azure Linux 3.0 + +Azure Linux 3.0 is Microsoft's in-house, lightweight Linux distribution optimized for running cloud-native workloads on Azure. Designed with performance, security, and reliability in mind, it is fully supported by Microsoft and tailored for containers, microservices, and Kubernetes. With native support for Arm64 (AArch64) architecture, Azure Linux 3.0 enables efficient execution of workloads on energy-efficient Arm-based infrastructure, making it a powerful choice for scalable and cost-effective cloud deployments. + +## 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. + +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/). diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/baseline-testing.md b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/baseline-testing.md new file mode 100644 index 0000000000..86d7b534b7 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/baseline-testing.md @@ -0,0 +1,135 @@ +--- +title: Golang Baseline Testing +weight: 6 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + + +### Baseline testing of Golang Web Page on Azure Arm64 +This guide demonstrates how to test your Go installation on Azure Arm64 by creating and running a simple Go web server that serves a styled HTML page. + +**1. Create Project Directory** + +First, create a new folder called goweb to hold your project and move inside it: + +```console +mkdir goweb && cd goweb +``` +This makes a directory named goweb and then changes into it. + +**2. Create HTML Page with Bootstrap Styling** + +Next, create a file named `index.html` using the nano editor: + +```console +nano index.html +``` + +Paste the following HTML code inside. This builds a simple, styled web page with a header, a welcome message, and a button using Bootstrap. + +```html + + + + + + Go Web on Azure ARM64 + + + + +
+
+

Go Web on Azure Arm64

+

This page is powered by Golang running on the Microsoft Azure Cobalt 100 processors.

+ Test API Endpoint +
+
+ + +``` +**3. Create Golang Web Server** + +Now create the Go program that will serve this web page: + +```console +nano main.go +``` +Paste the code below. 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. + +```go +package main +import ( + "encoding/json" + "log" + "net/http" + "time" + "gosort-bench" +) +func main() { + // Serve index.html for root + http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { + if r.URL.Path == "/" { + http.ServeFile(w, r, "index.html") + return + } + http.FileServer(http.Dir(".")).ServeHTTP(w, r) + }) + // REST API endpoint for JSON response + http.HandleFunc("/api/hello", func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + json.NewEncoder(w).Encode(map[string]string{ + "message": "Hello from Go on Azure ARM64!", + "time": time.Now().Format(time.RFC1123), + }) + }) + log.Println("Server running on http://0.0.0.0:80") + log.Fatal(http.ListenAndServe(":80", nil)) +} +``` + +**4. Run the Web Server** + +Run your Go program with: + +```console +go run main.go +``` + +This compiles and immediately starts the server. If successful, you’ll see the message: + +```output +2025/08/19 04:35:06 Server running on http://0.0.0.0:80 +``` +**5. Open in Browser** + +Finally, open your web browser and type in: + +```bash +http://:8080 +``` +Replace <**Public-IP**> with your Azure virtual machine’s actual public IP address. When you visit this link, you should see the styled HTML page being served directly by your Go application. + +You should see the Golang web page confirming a successful installation of Golang. + +![golang](./go-web.png) + +Now, your Golang instance is ready for further benchmarking and production use. diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/benchmarking.md b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/benchmarking.md new file mode 100644 index 0000000000..f8a7398860 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/benchmarking.md @@ -0,0 +1,201 @@ +--- +title: Benchmarking via go test -bench +weight: 7 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Run the performance tests using go test -bench + +`go test -bench` (the benchmarking mode of go test) is Golang’s built-in benchmarking framework that measures the performance of functions by running them repeatedly and reporting execution time (**ns/op**), memory usage, and allocations. With the `-benchmem flag`, it also shows memory usage and allocations. It’s simple, reliable, and requires only writing benchmark functions in the standard Golang testing package. + +This guide walks you through **benchmarking sorting algorithms** in Golang using the built-in **go test -bench framework**. You will learn how to set up a project, write sorting and benchmark functions, run performance tests, and compare results across **VMs and Docker containers on both x86_64 and Arm64 environments**. + +1. Create a Project Folder + +Open your terminal and create a new folder for this project: + +```console +mkdir gosort-bench +cd gosort-bench +``` + +2. Initialize a Go Module + +Inside the folder, run: + +```console +go mod init gosort-bench +``` +This creates a go.mod file which tells Go, “this is my project, and its name is gosort-bench”. +It helps Go manage dependencies (libraries) automatically. + +3. Add Sorting Functions + +Create a file called **sorting.go**: + +```console +nano sorting.go +``` +Paste this code in **sorting.go** file: + +```go +package sorting +func BubbleSort(arr []int) { + n := len(arr) + for i := 0; i < n-1; i++ { + for j := 0; j < n-i-1; j++ { + if arr[j] > arr[j+1] { + arr[j], arr[j+1] = arr[j+1], arr[j] + } + } + } +} + +func QuickSort(arr []int) { + quickSort(arr, 0, len(arr)-1) +} + +func quickSort(arr []int, low, high int) { + if low < high { + pivot := partition(arr, low, high) + quickSort(arr, low, pivot-1) + quickSort(arr, pivot+1, high) + } +} + +func partition(arr []int, low, high int) int { + pivot := arr[high] + i := low - 1 + for j := low; j < high; j++ { + if arr[j] < pivot { + i++ + arr[i], arr[j] = arr[j], arr[i] + } + } + arr[i+1], arr[high] = arr[high], arr[i+1] + return i + 1 +} +``` +- The code contains **two sorting methods**, Bubble Sort and Quick Sort, which arrange numbers in order from smallest to largest. +- **Bubble Sort** works by repeatedly comparing two numbers side by side and swapping them if they are in the wrong order. It keeps doing this until the whole list is sorted. +- **Quick Sor**t is faster. It picks a "pivot" number and splits the list into two groups — numbers smaller than the pivot and numbers bigger than it. Then it sorts each group separately. +- The **function** partition helps Quick Sort decide where to split the list based on the pivot number. +- In short, **Bubble Sort is simple but slow,** while **Quick Sort is smarter and usually much faster for big lists of numbers**. + +4. Add Benchmark Tests + +Create another file called s**orting_benchmark_test.go**: + +```console +nano sorting_benchmark_test.go +```` + +Paste the below code: + +```go +package sorting_test +import ( + "math/rand" + "testing" + "gosort-bench/sorting" +) +const LENGTH = 10000 +func makeRandomNumberSlice(n int) []int { + numbers := make([]int, n) + for i := range numbers { + numbers[i] = rand.Intn(n) + } + return numbers +} +func BenchmarkBubbleSort(b *testing.B) { + for i := 0; i < b.N; i++ { + b.StopTimer() + numbers := makeRandomNumberSlice(LENGTH) + b.StartTimer() + sorting.BubbleSort(numbers) + } +} + +func BenchmarkQuickSort(b *testing.B) { + for i := 0; i < b.N; i++ { + b.StopTimer() + numbers := makeRandomNumberSlice(LENGTH) + b.StartTimer() + sorting.QuickSort(numbers) + } +} +``` + +- The code is a **benchmark test** that checks how fast Bubble Sort and Quick Sort run in Go. +- It first creates a **list of 10,000 random numbers** each time before running a sort, so the test is fair and consistent. +- **BenchmarkBubbleSort** measures the speed of sorting using the slower Bubble Sort method. +- **BenchmarkQuickSort** measures the speed of sorting using the faster Quick Sort method. + +When you run **go test -bench=. -benchmem**, Go will show you how long each sort takes and how much memory it uses, so you can compare the two sorting techniques. + +### Run the Benchmark + +Execute the benchmark suite using the following command: +```console +go test -bench=. -benchmem +``` +- **-bench=.** - runs all functions starting with Benchmark. +- **-benchmem** - also shows memory usage (allocations per operation). + +You should see the output similar to this: + +```output +goos: linux +goarch: arm64 +pkg: gosort-bench +BenchmarkBubbleSort-4 26 44857916 ns/op 0 B/op 0 allocs/op +BenchmarkQuickSort-4 3526 338550 ns/op 0 B/op 0 allocs/op +PASS +ok gosort-bench 2.903s + +``` +### Matrics Explanation + +- **ns/op** - nanoseconds per operation (lower is better). +- **B/op** - bytes of memory used per operation. +- **allocs/op** - how many memory allocations happened per operation. + +### Benchmark summary on x86_64 + +The following benchmark results are collected on two different x86_64 environments: a **Docker container running Azure Linux 3.0 hosted on a D4s_v6 Ubuntu-based Azure virtual machine**, and a **D4s_v4 Azure virtual machine created from the Azure Linux 3.0 image published by Ntegral Inc**. + +| Benchmark | Value on Docker Container | Value on Virtual Machine | +|--------------------|----------------------------|---------------------------| +| BubbleSort (ns/op) | 44,242,116 | 107,821,267 | +| QuickSort (ns/op) | 530,817 | 587,150 | +| BubbleSort runs | 26 | 10 | +| QuickSort runs | 2,214 | 2,032 | +| Allocations/op | 0 | 0 | +| Bytes/op | 0 | 0 | +| Total time (s) | 2.692 | 2.886 | + +### Benchmark summary on Arm64 + +The following benchmark results are collected on two different Arm64 environments: a **Docker container running Azure Linux 3.0 hosted on a D4ps_v6 Ubuntu-based Azure virtual machine**, and a **D4ps_v6 Azure virtual machine created from the Azure Linux 3.0 custom image using the AArch64 ISO**. + +| Benchmark | Value on Docker Container | Value on Virtual Machine | +|--------------------|----------------------------|---------------------------| +| BubbleSort (ns/op) | 44,288,850 | 44,857,916 | +| QuickSort (ns/op) | 339,310 | 338,550 | +| BubbleSort runs | 26 | 26 | +| QuickSort runs | 3,496 | 3,526 | +| Allocations/op | 0 | 0 | +| Bytes/op | 0 | 0 | +| Total time (s) | 2.882 | 2.903 | + +### Benchmarking comparison summary + +When you compare the benchmarking results you will notice that on the Azure Cobalt 100: + +- **Arm64 maintains consistency** – both Docker container and virtual machine delivered nearly identical results, showing that Arm64 optimizations are working well across environments. +- **BubbleSort (CPU-heavy, O(n²))** – runs in **~44M ns/op** on both setups, proving that raw CPU compute on Arm64 is stable and unaffected by containerization. +- **QuickSort (efficient O(n log n))** – execution is very fast (**~339K ns/op**), showing Arm handles algorithmic workloads efficiently. +- **No memory overhead** – both container and virtual machine show **0 B/op and 0 allocs/op**, confirming Golang’s memory efficiency is preserved on Arm64. +- **Run counts align closely** – **BubbleSort (26 runs each) and QuickSort (~3.5K runs)** indicate Arm64 delivers repeatable and predictable performance. diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/container-setup.md b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/container-setup.md new file mode 100644 index 0000000000..2b23f6e6ba --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/container-setup.md @@ -0,0 +1,34 @@ +--- +title: Setup Azure Linux 3.0 Environment +weight: 4 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + + +You have an option to choose between working with the Azure Linux 3.0 Docker image or inside the virtual machine created with the OS image. + +### Working inside Azure Linux 3.0 Docker container +The Azure Linux Container Host is an operating system image that's optimized for running container workloads on Azure Kubernetes Service (AKS). Microsoft maintains the Azure Linux Container Host and based it on CBL-Mariner, an open-source Linux distribution created by Microsoft. To know more about Azure Linux 3.0, kindly refer [What is Azure Linux Container Host for AKS](https://learn.microsoft.com/en-us/azure/azure-linux/intro-azure-linux). + +Azure Linux 3.0 offers support for AArch64. However, the standalone virtual machine image for Azure Linux 3.0 or CBL Mariner 3.0 is not available for Arm. Hence, to use the default software stack provided by the Microsoft team, you can create a docker container with Azure Linux 3.0 as a base image, and run the Golang deployment inside the container. + +#### Create Azure Linux 3.0 Docker Container +The [Microsoft Artifact Registry](https://mcr.microsoft.com/en-us/artifact/mar/azurelinux/base/core/about) offers updated docker image for the Azure Linux 3.0. + +To create a docker container, install docker, and then follow the below instructions: + +```console +sudo docker run -it --rm mcr.microsoft.com/azurelinux/base/core:3.0 +``` +The default container startup command is bash. tdnf and dnf are the default package managers. + +### Working with Azure Linux 3.0 OS image +As of now, the Azure Marketplace offers official virtual machine images of Azure Linux 3.0 only for x64-based architectures, published by Ntegral Inc. However, native Arm64 (AArch64) images are not yet officially available. Hence, for this Learning Path, you can create your own custom Azure Linux 3.0 virtual machine image for AArch64 using the [AArch64 ISO for Azure Linux 3.0](https://github.com/microsoft/azurelinux#iso). + +Refer [Create an Azure Linux 3.0 virtual machine with Cobalt 100 processors](/learning-paths/servers-and-cloud-computing/azure-vm) for the details. + +Whether you're using an Azure Linux 3.0 Docker container, or a virtual machine created from a custom Azure Linux 3.0 image, the deployment and benchmarking steps remain the same. + +Once the setup has been established, you can proceed with the Golang Installation ahead. diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/create-instance.md b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/create-instance.md new file mode 100644 index 0000000000..44e9accdd0 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/create-instance.md @@ -0,0 +1,33 @@ +--- +title: Create an Arm based cloud virtual machine using Microsoft Cobalt 100 CPU +weight: 3 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Introduction + +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. + +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 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 + +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. + +Select “Create”, and fill in the details such as Name, and Region. Choose the image for your virtual machine (for example – Ubuntu 24.04) and select “Arm64” as the virtual machine architecture. + +In the “Size” field, click on “See all sizes” and select the D-Series v6 family of virtual machine. Select “D4ps_v6” from the list and create the virtual machine. + +![MongoDb Screenshot](./instance.png) + +The virtual machine should be ready and running; you can SSH into the virtual machine using the PEM key, along with the Public IP details. + +{{% 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](https://learn.arm.com/learning-paths/servers-and-cloud-computing/csp/azure) . + +{{% /notice %}} diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/deploy.md b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/deploy.md new file mode 100644 index 0000000000..5e36cc1adb --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/deploy.md @@ -0,0 +1,122 @@ +--- +title: Install Golang on Microsoft Azure Virtual Machine +weight: 5 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + + +## Install Golang on Azure Linux 3.0 +This guide covers installing the latest Go version on Azure Linux Arm64, configuring the environment, and verifying the setup. + +1. Download the Go archive + +This command downloads the official Go package for Linux Arm64 from the Go website. + +```console +wget https://go.dev/dl/go1.25.0.linux-arm64.tar.gz +``` +{{% notice Note %}} +There are many enhancements added to Golang version 1.18, that has resulted in up to a 20% increase in performance for Go workloads on Arm-based servers. Please see [this reference content](https://aws.amazon.com/blogs/compute/making-your-go-workloads-up-to-20-faster-with-go-1-18-and-aws-graviton/) for the details. + +The [Arm Ecosystem Dashboard](https://developer.arm.com/ecosystem-dashboard/) also recommends Golang version 1.18 as the minimum recommended on the Arm platforms. +{{% /notice %}} + +2. Extract the archive into `/usr/local` + +This unpacks the Go files into the system directory /usr/local, which is a standard place for system-wide software. + +```console +sudo tar -C /usr/local -xzf ./go1.25.0.linux-arm64.tar.gz +``` + +3. Add Go to your system PATH + +This updates your .bashrc file so your shell can recognize the go command from anywhere. + +```console +echo 'export PATH="$PATH:/usr/local/go/bin"' >> ~/.bashrc +``` + +4. Apply the PATH changes immediately + +This reloads your .bashrc so you don’t need to log out and log back in for the changes to take effect. + +```console +source ~/.bashrc +``` + +5. Verify Go installation + +This checks if Go is installed correctly and shows the installed version. + +```console +go version +``` + +You should see an output similar to: + +```output +go version go1.25.0 linux/arm64 +``` +6. Check Go environment settings + +This displays Go’s environment variables (like GOROOT and GOPATH) to ensure they point to the correct installation. + +```console +go env +``` + +You should see an output similar to: + +```output +AR='ar' +CC='gcc' +CGO_CFLAGS='-O2 -g' +CGO_CPPFLAGS='' +CGO_CXXFLAGS='-O2 -g' +CGO_ENABLED='0' +CGO_FFLAGS='-O2 -g' +CGO_LDFLAGS='-O2 -g' +CXX='g++' +GCCGO='gccgo' +GO111MODULE='' +GOARCH='arm64' +GOARM64='v8.0' +GOAUTH='netrc' +GOBIN='' +GOCACHE='/home/azureuser/.cache/go-build' +GOCACHEPROG='' +GODEBUG='' +GOENV='/home/azureuser/.config/go/env' +GOEXE='' +GOEXPERIMENT='' +GOFIPS140='off' +GOFLAGS='' +GOGCCFLAGS='-fPIC -fno-caret-diagnostics -Qunused-arguments -Wl,--no-gc-sections -fmessage-length=0 -ffile-prefix-map=/tmp/go-build3018594215=/tmp/go-build -gno-record-gcc-switches' +GOHOSTARCH='arm64' +GOHOSTOS='linux' +GOINSECURE='' +GOMOD='/dev/null' +GOMODCACHE='/home/azureuser/go/pkg/mod' +GONOPROXY='' +GONOSUMDB='' +GOOS='linux' +GOPATH='/home/azureuser/go' +GOPRIVATE='' +GOPROXY='https://proxy.golang.org,direct' +GOROOT='/usr/local/go' +GOSUMDB='sum.golang.org' +GOTELEMETRY='local' +GOTELEMETRYDIR='/home/azureuser/.config/go/telemetry' +GOTMPDIR='' +GOTOOLCHAIN='auto' +GOTOOLDIR='/usr/local/go/pkg/tool/linux_arm64' +GOVCS='' +GOVERSION='go1.25.0' +GOWORK='' +PKG_CONFIG='pkg-config' +``` + +Golang installation is complete. You can now proceed with the baseline testing. diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/go-web.png b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/go-web.png new file mode 100644 index 0000000000..66618480f2 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/go-web.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/golang-on-azure/instance.png b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/instance.png new file mode 100644 index 0000000000..285cd764a5 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/golang-on-azure/instance.png differ