Merge pull request #2872 from madeline-underwood/cobalt_arm

Deploy Cobalt 100 VMs with Azure Resource Manager templates

Author: jasonrandrews

content/learning-paths/servers-and-cloud-computing/azure-arm-template/_index.md

@@ -1,22 +1,19 @@
 ---
-title: Deploy a Linux Cobalt 100 VM with Azure Resource Manager templates
+title: Deploy Arm-based Cobalt 100 VMs using Azure Resource Manager templates
 
-draft: true
-cascade:
-    draft: true
-    
 minutes_to_complete: 45
 
-who_is_this_for: This is an introductory topic for developers and DevOps engineers who want to automate the deployment of Arm-based Cobalt 100 virtual machines using Azure Resource Manager templates.
+who_is_this_for: This is an introductory topic for developers and DevOps engineers who want to automate the deployment of Arm-based Azure Cobalt 100 virtual machines using Azure Resource Manager templates.
 
 learning_objectives:
-    - Understand Azure Resource Manager template structure and syntax
-    - Create a Azure Resource Manager template for deploying Cobalt 100 virtual machines
-    - Deploy an Arm-based Linux VM using the template with Azure CLI
-    - Configure SSH authentication for secure access
+    - Structure an Azure Resource Manager template with parameters, variables, and resources
+    - Specify Arm64 architecture and Cobalt 100 Azure VM sizes
+    - Deploy the template using Azure CLI and verify the deployment
+    - Connect to your Cobalt 100 VM and validate the Arm64 architecture
 
 prerequisites:
-    - A Microsoft Azure account with permissions to create virtual machines and resource groups
+    - An Azure subscription with permissions to create resource groups, virtual machines, and networking resources
+    - Azure CLI installed on your local machine - see the [Azure CLI install guide](/install-guides/azure-cli/)
     - An SSH key pair for authentication
 
 author: Pareena Verma
@@ -42,8 +39,8 @@ further_reading:
         link: https://learn.microsoft.com/en-us/azure/virtual-machines/sizes/general-purpose/dpsv6-series
         type: documentation
     - resource:
-        title: Deploy a Cobalt 100 Virtual Machine on Azure
-        link: https://learn.arm.com/learning-paths/servers-and-cloud-computing/cobalt/
+        title: Deploy a Cobalt 100 virtual machine on Azure
+        link: /learning-paths/servers-and-cloud-computing/cobalt/
         type: documentation
 
 

content/learning-paths/servers-and-cloud-computing/azure-arm-template/create-template.md

@@ -1,21 +1,21 @@
 ---
-title: Create the Resource Manager template
+title: Create the Azure Resource Manager template
 weight: 3
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Azure Resource Manager template structure
+## Understand the Azure Resource Manager template structure
 
-An Azure Resource Manager template consists of several key sections:
+An Azure Resource Manager template is a JSON file organized into six sections:
+- `$schema`: defines the template language version
+- `contentVersion`: your template's version number
+- `parameters`: input values that customize the deployment
+- `variables`: computed values used throughout the template
+- `resources`: Azure resources to create
+- `outputs`: values returned after deployment
 
-- **$schema**: Defines the template language version
-- **contentVersion**: Your template's version number
-- **parameters**: Input values that customize the deployment
-- **variables**: Computed values used throughout the template
-- **resources**: Azure resources to create
-- **outputs**: Values returned after deployment
 
 ## Create the template file
 
@@ -253,19 +253,13 @@ Create a new file named `cobalt-vm-template.json` on your local machine. This te
 
 ## Key template elements for Cobalt 100
 
-The template includes several Arm-specific configurations:
+The template includes several Arm-specific configurations.
 
-**VM size**: The `vmSize` parameter defaults to `Standard_D4ps_v6`, which is part of the Dpsv6 series powered by Cobalt 100 processors. This series provides:
-- Four vCPUs
-- General-purpose compute capabilities
-- Arm64 architecture
+**VM size**: The `vmSize` parameter defaults to `Standard_D4ps_v6`, part of the Dpsv6 series powered by Cobalt 100 processors. The D4ps_v6 size provides four vCPUs with general-purpose compute capabilities on Arm64 architecture.
 
-Other Cobalt 100 VM sizes include:
-- `Standard_D2ps_v6` (2 vCPUs)
-- `Standard_D8ps_v6` (8 vCPUs)
-- `Standard_D16ps_v6` (16 vCPUs)
+Other available Cobalt 100 VM sizes include `Standard_D2ps_v6` (two vCPUs), `Standard_D8ps_v6` (8 vCPUs), and `Standard_D16ps_v6` (16 vCPUs).
 
-**Image reference**: The `storageProfile` section specifies the operating system image with Arm64 architecture. You can choose from various Arm64-compatible Linux distributions available in Azure. The template uses Ubuntu 24.04 LTS:
+**Image reference**: The `storageProfile` section specifies the operating system image with Arm64 architecture. The template uses Ubuntu 24.04 LTS:
 
 ```json
 "imageReference": {
@@ -276,8 +270,7 @@ Other Cobalt 100 VM sizes include:
 }
 ```
 
-You can change the Arm64 image used in the `imageReference` section, for example:
-for Ubuntu 22.04 LTS:
+You can change the Arm64 image used in the `imageReference` section. For Ubuntu 22.04 LTS:
 ```json
 "imageReference": {
   "publisher": "Canonical",
@@ -310,4 +303,6 @@ az vm image list --all --architecture Arm64 --output table
 
 ## What you've accomplished and what's next
 
-You've created a complete Resource Manager template that defines the network infrastructure (virtual network, subnet, and network security groups), a public IP address for external access, a network interface, a Cobalt 100 VM with Ubuntu 24.04 LTS, and SSH key authentication for secure access. The template uses parameters for flexibility, allowing you to customize the deployment without modifying the template structure. In the next section, you'll deploy this template to Azure and connect to your new Cobalt 100 VM.
+You've created a complete Resource Manager template that defines network infrastructure, a Cobalt 100 VM with Ubuntu 24.04 LTS, and SSH key authentication. The template uses parameters for flexibility, allowing you to customize deployments without modifying the template structure.
+
+Next, you'll deploy this template to Azure and connect to your new Cobalt 100 VM.

content/learning-paths/servers-and-cloud-computing/azure-arm-template/deploy-template.md

@@ -1,5 +1,5 @@
 ---
-title: Deploy the template
+title: Deploy the Azure Resource Manager template
 weight: 4
 
 ### FIXED, DO NOT MODIFY
@@ -14,12 +14,13 @@ Azure Resource Manager templates deploy resources into a resource group. Create
 az group create --name cobalt-rg --location eastus
 ```
 
-Replace `eastus` with your preferred Azure region. To see available regions that support Cobalt 100 VMs, run:
+Replace `eastus` with your preferred Azure region. To see available regions that support Cobalt 100 VMs, query Azure for VM SKUs and filter for the Dpsv6 series:
 
 ```bash
 az vm list-skus --location eastus --size Standard_D --all --output table | grep "ps_v6"
 ```
-The output will look like:
+
+The output is similar to:
 ```output
 virtualMachines  eastus       Standard_D16ps_v6       2,3      None
 virtualMachines  eastus       Standard_D2ps_v6        2,3      None
@@ -107,15 +108,15 @@ az deployment group show \
   --query properties.provisioningState
 ```
 
-The output displays `"Succeeded"` when the deployment completes successfully.
+The output displays `"Succeeded"` when the deployment completes.
 
 List the resources created in the resource group:
 
 ```bash
 az resource list --resource-group cobalt-rg --output table
 ```
 
-The output should look like:
+The output is similar to:
 
 ```output
 Name                                                     ResourceGroup    Location    Type                                     Status
@@ -131,7 +132,7 @@ cobaltdemo-vm_OsDisk_1_a3e13c940d07463cace48cfd1458a151  COBALT-RG        eastus
 
 The output shows the resources created: virtual machine, network interface, public IP address resource, virtual network, network security groups, and OS disk.
 
-## Retrieve the VM's public IP address
+## Retrieve the Cobalt 100 VM public IP address
 
 Get the public IP address to connect to your VM:
 
@@ -152,4 +153,6 @@ The public IP address is dynamically allocated and won't be available until the
 
 ## What you've accomplished and what's next
 
-You've successfully deployed an Arm-based Cobalt 100 VM using an Azure Resource Manager template. The deployment created a virtual network with a configured subnet, network security groups allowing SSH access, a public IP address for external connectivity, and a Cobalt 100 VM running Ubuntu 24.04 LTS. In the next section, you'll connect to your VM and verify the Arm64 architecture.
+You've deployed an Arm-based Cobalt 100 VM using an Azure Resource Manager template. The deployment includes network infrastructure with security groups, a public IP address, and a VM running Ubuntu 24.04 LTS.
+
+Next, you'll connect to your VM and verify the Arm64 architecture.

content/learning-paths/servers-and-cloud-computing/azure-arm-template/overview.md

@@ -1,52 +1,50 @@
 ---
-title: Overview
+title: Getting started with Azure Resource Manager
 weight: 2
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-In this Learning Path, you'll create an Azure Resource Manager template that deploys a Linux virtual machine powered by Azure Cobalt 100 processors. The template configures networking, security, and SSH authentication, providing a complete foundation for deploying Arm-based workloads on Azure.
+## Overview
 
-You'll learn how to:
+In this Learning Path, you’ll create an Azure Resource Manager template that deploys a Linux virtual machine powered by Azure Cobalt 100 processors. The template defines the virtual machine, networking, security settings, and SSH authentication required for deployment.
 
-- Structure an Azure Resource Manager template with parameters, variables, and resources
-- Specify Arm64 architecture and Cobalt 100 VM sizes
-- Configure SSH key authentication for secure access
-- Deploy the template using Azure CLI
-- Verify and connect to your deployed Arm-based VM
-
-By the end of this Learning Path, you'll have a reusable template for deploying Cobalt 100 VMs and the knowledge to customize it for your specific requirements.
-Azure Resource Manager templates provide a declarative way to define and deploy Azure infrastructure as code. By using Resource Manager templates, you can automate the deployment of Arm-based Cobalt 100 virtual machines with consistent, repeatable results across different environments.
+By using Azure Resource Manager templates, you can deploy infrastructure consistently across environments, reduce configuration errors, and integrate infrastructure provisioning into CI/CD workflows.
 
 ## What is an Azure Resource Manager template?
 
-Azure Resource Manager templates are JSON files that define the infrastructure and configuration you want to deploy in Azure. Templates enable Infrastructure as Code (IaC), allowing you to version control your infrastructure alongside your application code. When you submit a template to Azure Resource Manager, it orchestrates the creation of all specified resources in the correct order, managing dependencies automatically. By using templates, you can achieve consistent, repeatable deployments across different environments while reducing configuration errors and enabling CI/CD automation.
+An Azure Resource Manager template is a JSON file that defines the infrastructure and configuration you want to deploy in Azure. This approach is known as Infrastructure as Code (IaC).
+
+When you deploy a template, Azure Resource Manager:
+- Creates resources in the correct order
+- Manages dependencies automatically
+- Ensures deployments are consistent and repeatable
+
+Using templates allows you to version control infrastructure alongside application code and automate deployments across environments.
 
-## Before you begin
+## Set up your environment 
 
 To complete this Learning Path, you need:
 
-- An active Microsoft Azure subscription with permissions to:
-  - Create resource groups
-  - Deploy virtual machines
-  - Create networking resources (virtual networks, network security groups, public IP addresses)
-- Azure CLI installed on your local machine (see the [Azure CLI install guide](/install-guides/azure-cli/))
-- An SSH key pair for authentication
+- An Azure account with an active subscription
+- Azure CLI installed and configured
+- A local terminal on Linux, macOS, or Windows (with WSL)
+- An SSH key pair for secure access to the virtual machine
 
 ## Generate an SSH key pair
 
-If you don't already have an SSH key pair, create one now. On Linux or macOS, run:
+If you don't have an SSH key pair, create one now. On Linux or macOS, run:
 
 ```bash
 ssh-keygen -t rsa -b 4096 -f ~/.ssh/azure_cobalt_key
 ```
 
 When prompted, you can enter a passphrase for added security or press Enter to skip it.
 
-This command creates two files:
-- `~/.ssh/azure_cobalt_key` - Your private key (keep this secure)
-- `~/.ssh/azure_cobalt_key.pub` - Your public key (you'll use this in the Azure Resource Manager template)
+This creates two files:
+- `~/.ssh/azure_cobalt_key` (private key - keep this secure)
+- `~/.ssh/azure_cobalt_key.pub` (public key - you'll use this in the template)
 
 ## Sign in to Azure
 
@@ -72,7 +70,7 @@ You can list your subscriptions with:
 az account list --output table
 ```
 
-## Verify Azure CLI is working
+## Verify your Azure CLI configuration
 
 Confirm your Azure CLI is properly configured by checking your current subscription:
 
@@ -82,4 +80,8 @@ az account show --output table
 
 The output displays details about your active subscription, including the subscription ID and tenant ID.
 
-You're now ready to create the Azure Resource Manager template that will define your Arm-based Cobalt 100 VM infrastructure.
+## What you've accomplished and what's next
+
+You've authenticated with Azure, configured your active subscription, and generated SSH keys for secure VM access. Your development environment is ready for creating Azure Resource Manager templates.
+
+Next, you'll create the Resource Manager template that defines your Cobalt 100 VM infrastructure.

content/learning-paths/servers-and-cloud-computing/azure-arm-template/verify.md

@@ -1,12 +1,12 @@
 ---
-title: Connect and verify
+title: Connect to the Cobalt 100 VM and verify Arm64 architecture
 weight: 5
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Connect to the VM via SSH
+## Connect to the Cobalt 100 VM via SSH
 
 Use the public IP address from the previous step to connect to your Cobalt 100 VM:
 
@@ -34,19 +34,16 @@ Check the CPU information:
 lscpu
 ```
 
-The output shows details about the Cobalt 100 processor, including:
-- Architecture: aarch64
-- CPU(s): 4 (for Standard_D4ps_v6)
-- Vendor ID: ARM
+The output shows details about the Cobalt 100 processor, including Architecture (aarch64), CPU count (four for Standard_D4ps_v6), and Vendor ID (ARM).
 
-## Check system information
+## View Cobalt 100 system information
 
 View detailed system information:
 
 ```bash
 cat /proc/cpuinfo | head -10
 ```
-The output should look like:
+The output is similar to:
 ```output
 processor	: 0
 BogoMIPS	: 2000.00
@@ -65,7 +62,7 @@ This displays processor details, including key architectural features of the Cob
 - **sve** and **sve2**: Scalable Vector Extension instructions for enhanced SIMD (Single Instruction, Multiple Data) performance
 - **sha256**, **sha3**, **sha512**: Hardware-accelerated cryptographic operations for improved security workload performance
 
-These features make Cobalt 100 well-suited for AI/ML workloads, data analytics, and compute-intensive applications running on Arm64 architecture.
+These features make Cobalt 100 well-suited for AI/ML workloads, data analytics, and compute-intensive applications on Arm64 architecture.
 
 Verify the operating system:
 
@@ -75,7 +72,7 @@ lsb_release -a
 
 The output confirms Ubuntu 24.04 LTS (Noble Numbat).
 
-## Install and test software
+## Install and test software on Arm64
 
 Update the package lists and install a simple application to verify everything works:
 
@@ -90,7 +87,8 @@ Check that nginx is running:
 sudo systemctl status nginx
 ```
 
-The output shows nginx is active and running.
+The output shows nginx is active and running:
+
 ```output
 ● nginx.service - A high performance web server and a reverse proxy server
      Loaded: loaded (/lib/systemd/system/nginx.service; enabled; vendor preset:>
@@ -119,7 +117,7 @@ Test that nginx is working:
 curl http://localhost
 ```
 
-The output displays the nginx default welcome page HTML, confirming the web server is running correctly.
+The output displays the nginx default welcome page HTML, confirming the web server is running correctly:
 
 ```output
 <!DOCTYPE html>
@@ -146,18 +144,21 @@ Commercial support is available at
 </body>
 </html>
 ```
+
 ## Clean up resources (optional)
 
-When you're done exploring, you can delete all resources to avoid ongoing charges:
+When you're done exploring, delete all resources to avoid ongoing charges:
 
 ```bash
 az group delete --name cobalt-rg --yes --no-wait
 ```
 
 This command deletes the resource group and all resources within it. The `--no-wait` flag returns immediately without waiting for the deletion to complete.
 
-## Summary
+## What you've accomplished and what's next
+
+You've deployed a Cobalt 100 VM using an Azure Resource Manager template, connected via SSH, verified the Arm64 architecture, and tested nginx on the running system.
 
-You've successfully deployed a Cobalt 100 VM using a Azure Resource Manager template, connected to the VM via SSH, verified the Arm64 architecture, and installed and tested nginx. Your Azure Resource Manager template provides a reusable foundation for deploying Cobalt 100 VMs. You can customize it by changing the VM size to scale resources, modifying the OS image to use different Linux distributions, adding additional network security rules for your applications, including data disks for storage, or deploying multiple VMs in a single template. 
+Your template provides a reusable foundation for deploying Cobalt 100 VMs. You can customize it by changing the VM size, modifying the OS image, adding network security rules, including data disks, or deploying multiple VMs.
 
-For production deployments, consider using parameters files for environment-specific configurations, implementing Azure Key Vault for managing SSH keys, adding monitoring and diagnostics extensions, configuring backup policies, and using managed identities for Azure resource access.
+For production deployments, consider using parameters files for environment-specific configurations, Azure Key Vault for managing SSH keys, monitoring and diagnostics extensions, backup policies, and managed identities for Azure resource access.