diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md b/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md index 7c9f295138..1a10514dbb 100644 --- a/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md +++ b/content/learning-paths/servers-and-cloud-computing/cobalt/1-create-cobalt-vm.md @@ -8,25 +8,29 @@ layout: learningpathall ## Use the Azure Portal to deploy a Cobalt 100 VM -Cobalt 100 is Microsoft’s first Arm-based server processor, built using the Armv9 Neoverse-N2 CPU. The Cobalt 100 processor is optimized for the performance of scale-out cloud-based applications. +Cobalt 100 is Microsoft’s first Arm-based server processor, built on the Armv9 Neoverse-N2 CPU architecture. It is optimized for the performance and efficiency of scale-out, cloud-based applications. -The Azure Cobalt 100 VM instances include two series: +Azure offers Cobalt 100–powered virtual machines in two series: + +- **Dpsv6** and **Dplsv6** (general-purpose) +- **Epsv6** (memory-optimized) -The general-purpose Dpsv6 and Dplsv6 virtual machine series. -The memory-optimized Epsv6 virtual machine series. To create a Cobalt 100 VM, follow these steps: 1. Sign in to the [Azure Portal](https://portal.azure.com/). 2. Select **Create a resource → Compute → Virtual machine**. -3. Complete the *Basics* tab: - ![Azure Portal – Basics tab for the VM wizard#center](images/create-cobalt-vm.png) - The Dpsv6-series are powered by Cobalt 100. Selecting Standard_D4ps_v6 will give you a Cobalt VM with 4 physical cores. you can change the 4 to another value if you want a different number of cores. +3. Complete the fields in the **Basics** tab using the values shown in the figure below: + + ![Azure Portal – Basics tab for the VM wizard#center](images/create-cobalt-vm.png "Configuring the Basics tab") + + Cobalt 100 powers the Dpsv6 and Dplsv6 series. Selecting **Standard_D4ps_v6** creates a Cobalt VM with four physical cores. + You can choose a different size if you need more or fewer cores. 4. Upload your public SSH key or generate a new one in the wizard. -5. Disallow public inbound ports for now. -5. Accept the defaults on the *Disks* tab. -6. On the *Networking* tab ensure that a **Public IP** is selected. You will need it to connect later. Leave the NSG settings as *Basic* for now. +5. For the **Public inbound ports** field, select **None**. +6. On the **Disks** tab, accept the default options. +7. On the **Networking** tab, ensure that a **Public IP** is selected. You will need it to connect to the VM later. Leave the NSG settings as **Basic**. -Click **Review + create** followed by **Create**. Azure now deploys the VM and the automatically-generated Network Security Group (NSG). Provisioning takes ~2 minutes. +8. Select **Review + create**, then **Create**. Azure deploys the VM and the automatically-generated Network Security Group (NSG). Provisioning takes ~2 minutes. -Navigate to the **Deployment in progress** pane or open the **Notifications** panel to track progress. When the deployment succeeds proceed to the next step to expose an inbound port. +9. Navigate to the **Deployment in progress** pane or open the **Notifications** panel to track progress. When the deployment completes, proceed to the next step to expose an inbound port. diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md b/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md index e5ba4c890f..7f9b44d24a 100644 --- a/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md +++ b/content/learning-paths/servers-and-cloud-computing/cobalt/2-open-port.md @@ -1,5 +1,5 @@ --- -title: Open an inbound port in the Network Security Group +title: Open inbound ports in the Network Security Group weight: 3 ### FIXED, DO NOT MODIFY @@ -8,16 +8,20 @@ layout: learningpathall ## Allow external traffic to TCP ports 22 (SSH) and 8080 -Every new virtual machine created through the Azure wizard is associated with a **Network Security Group (NSG)**. An NSG acts like a stateful firewall – if no rule explicitly allows traffic, Azure blocks it. +Every new virtual machine created through the Azure wizard is associated with a **Network Security Group (NSG)**. An NSG acts as a stateful firewall – if no rule explicitly allows traffic, Azure blocks it by default. -In this step you will open port 22 for SSH, as well as port 8080 so that a web application running on the VM is reachable from your IP for testing. Substitute a different port if required by your workload, or a different IP range if you'd like broader accessibility. +In this step, you'll open port 22 for SSH and port 8080 so that a web application running on the VM is reachable from your IP for testing. Substitute a different port if required by your workload, or a different IP range if you'd like broader accessibility. -1. In the Azure Portal open the newly created VM resource and click **Networking → Network settings** in the left nav. +1. In the Azure Portal, open the newly-created VM resource and select **Networking → Network settings** from the left-hand menu. 2. Select the **Network security group**. -3. Click on **Create Port Rule** and from the drop-down men select **Inbound port rule** -4. Fill in the form, specifying **My IP address** as the source and 22 as the destination port: - ![Add inbound security rule with source of my IP and destination port 22#center](images/create-nsg-rule.png) -5. Click **Add**. -To open port 8080, follow steps 3 through 5 again, but instead choose port 8080 for the destination port. +3. Select **Create Port Rule**, then choose **Inbound port rule** from the drop-down menu. -You have now opened ports 22 and 8080 to your IP. In the next step you will verify connectivity. +4. Fill in the form with **My IP address** as the source and 22 as the destination port: + + ![Add inbound security rule with source of my IP and destination port 22#center](images/create-nsg-rule.png "Create Port Rule form") + +5. Select **Add**. + +6. To open port 8080, repeat steps 3-5 and enter 8080 as the destination port. + +You have now opened ports 22 and 8080 to your IP. In the next step, you'll verify connectivity from your local machine. diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/3-verify-connectivity.md b/content/learning-paths/servers-and-cloud-computing/cobalt/3-verify-connectivity.md index b16db0151c..35de9b698e 100644 --- a/content/learning-paths/servers-and-cloud-computing/cobalt/3-verify-connectivity.md +++ b/content/learning-paths/servers-and-cloud-computing/cobalt/3-verify-connectivity.md @@ -8,20 +8,19 @@ layout: learningpathall ## Connect over SSH and test the open port -1. On the **Overview** page for the VM copy the **Public IP address**. -2. Open a terminal on your local machine and SSH to the VM (replace *azureuser* if you chose a different admin username): +On the **Overview** page of the VM, copy the **Public IP address**. Open a terminal on your local machine, and SSH to the VM (replace *azureuser* if you chose a different admin username): ```bash ssh -i [path to your pem file] azureuser@[public IP] ``` -Where `[public IP]` is your public IP and `[path to your pem file]` is the path to your SSH key file. +Replace `[public IP]` with your VM's public IP address, and `[path to your pem file]` with the path to your SSH private key file. -Accept the prompt to add the host to *known_hosts* the first time you connect. +When prompted, confirm the connection to add the VM to your *known_hosts* file. -### Start a simple HTTP server +### Start a temporary HTTP server -If you do not already have an application listening on TCP 8080 you can start one temporarily: +If you don't already have an application listening on TCP 8080, you can start one temporarily: ```bash sudo apt update -y && sudo apt install -y python3 @@ -32,16 +31,18 @@ Leave this terminal open – the server runs in the foreground. ### Test from your local machine -In a second local terminal run `curl` to confirm you can reach the server through the NSG rule you created: +In a second local terminal run `curl` to confirm that you can reach the server through the NSG rule you created: ```bash curl http://[public IP]:8080 ``` -Where `[public IP]` is your public IP. +Replace `[public IP]` with your VM's public IP address. -You should see an HTML directory listing (or your application response). Receiving a response verifies that TCP 8080 is open and the VM is reachable from the public internet. +You should see an HTML directory listing (or your application response). A successful response confirms that TCP port 8080 is open and the VM is reachable from the public internet. -Terminate the Python server when you are finished testing (press `Ctrl + C`). +To stop the server, press `Ctrl + C`. -You now have an Arm-based Cobalt 100 VM with an exposed port 8080 that you can use to run any test server. To learn about optimizing .NET workloads on Cobalt, check out [Migrating a .NET application to Azure Cobalt](../../dotnet-migration/). \ No newline at end of file +You now have an Arm-based Cobalt 100 VM with port 8080 open and ready to receive external traffic. You can use it to run any test server or deploy your own application. + +To learn about optimizing .NET workloads on Cobalt, check out [Migrating a .NET application to Azure Cobalt](../../dotnet-migration/). \ No newline at end of file diff --git a/content/learning-paths/servers-and-cloud-computing/cobalt/_index.md b/content/learning-paths/servers-and-cloud-computing/cobalt/_index.md index 8ea17b5fbc..4cb83a8d31 100644 --- a/content/learning-paths/servers-and-cloud-computing/cobalt/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/cobalt/_index.md @@ -1,18 +1,18 @@ --- -title: Create an Azure Cobalt 100 VM +title: Deploy a Cobalt 100 Virtual Machine on Azure minutes_to_complete: 10 -who_is_this_for: This is an introductory topic for developers and DevOps engineers who need an Arm-based virtual machine on Azure and want to expose an application port to the internet. +who_is_this_for: This is an introductory topic for developers and DevOps engineers who want to deploy an Arm-based virtual machine on Azure and expose an application port to the internet. learning_objectives: - - Deploy an Arm-based Cobalt 100 virtual machine (VM) on Microsoft Azure. - - Connect to the Cobalt 100 VM using SSH. - - Open an inbound TCP port in the associated Network Security Group (NSG). - - Verify external connectivity to the newly opened port. + - Deploy an Arm-based Cobalt 100 virtual machine (VM) on Microsoft Azure + - Connect to the Cobalt 100 VM using SSH + - Configure an inbound TCP port in the associated Network Security Group (NSG) + - Verify external connectivity to the newly-opened port prerequisites: - - A Microsoft Azure subscription with permission to create resources + - A Microsoft Azure subscription with permissions to create virtual machines and networking resources - Basic familiarity with SSH author: Joe Stech diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md index 49b0b64571..a25f47775f 100644 --- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md +++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/1-create-orchardcore-app.md @@ -1,20 +1,22 @@ --- -title: Create a basic OrchardCore application +title: Build and run an OrchardCore CMS app on Azure Cobalt (Arm64) weight: 2 ### FIXED, DO NOT MODIFY layout: learningpathall --- -# Create a basic OrchardCore application +## Getting started with the OrchardCore app -In this section, you will learn how to create and compile a basic [OrchardCore](https://github.com/OrchardCMS/OrchardCore) CMS application, as an example of a popular Linux-based .NET workload. OrchardCore is a modular and multi-tenant application framework built with ASP.NET Core, which can be used to create content-driven websites. +In this section, you'll build and run a basic [OrchardCore](https://github.com/OrchardCMS/OrchardCore) CMS application, which is a popular Linux-based .NET workload. OrchardCore is a modular and multi-tenant application framework built with ASP.NET Core, that's commonly used to create content-driven websites. -## Step 1: Set up your development environment +### Set up your development environment -1. Launch an Azure Cobalt instance running Ubuntu 24.04, and open port 8080 to the internet. For instructions on how to do this, see the [Create an Azure Cobalt 100 VM](../../cobalt) Learning Path. +First, launch an Azure Cobalt 100 instance (Arm-based VM) running Ubuntu 24.04, and open port 8080 to the internet. -2. **Install .NET SDK**: +For setup instructions, see the [Create an Azure Cobalt 100 VM](../../cobalt) Learning Path. + +Next, install .NET SDK: ```bash wget https://packages.microsoft.com/config/ubuntu/24.04/packages-microsoft-prod.deb @@ -23,35 +25,35 @@ sudo apt-get update sudo apt-get install -y dotnet-sdk-8.0 ``` -3. **Verify installations**: +Verify the installation: ```bash dotnet --version ``` -The output should look like: +You should then see output similar to: ```output 8.0.117 ``` -4. Install gcc for compiling your application: +Install gcc for compiling your application: ```bash sudo apt install gcc g++ build-essential -y ``` -## Step 2: Install the OrchardCore Templates +### Install the OrchardCore templates -To start building an OrchardCore application, you need to install the OrchardCore templates. Open your terminal and run the following command: +Install the OrchardCore templates: ```bash dotnet new install OrchardCore.ProjectTemplates::2.1.7 ``` -This command installs the OrchardCore project templates, which you will use to create a new application. +This command installs the OrchardCore project templates you'll use to create a new OrchardCore application. -The output will look like: +Expected output: ```output Success: OrchardCore.ProjectTemplates::2.1.7 installed the following templates: @@ -64,31 +66,31 @@ Orchard Core Mvc Web App ocmvc [C#] Web/Orchard Core/Mvc Orchard Core Theme octheme [C#] Web/Orchard Core/CMS ``` -## Step 3: Create a new OrchardCore application +### Create a new OrchardCore application -1. **Create a new project**: Use the `dotnet` CLI to create a new OrchardCore application. +First, create a new project using the `dotnet` CLI to create a new OrchardCore application: ```bash dotnet new occms -n MyOrchardCoreApp ``` - This command creates a new OrchardCore CMS application in a directory named `MyOrchardCoreApp`. +This command creates a new OrchardCore CMS application in a directory named `MyOrchardCoreApp`. -2. **Navigate to the project directory**: +Now navigate to the project directory: ```bash cd MyOrchardCoreApp ``` -## Step 4: Run the OrchardCore application +### Run the OrchardCore application -1. **Build the application**: Compile the application using the following command: +Build the application: ```bash dotnet build ``` -The output will look like: +The output should look like: ```output MSBuild version 17.8.27+3ab07f0cf for .NET @@ -103,14 +105,22 @@ Build succeeded. Time Elapsed 00:00:38.05 ``` -2. **Run the application**: Start the application with: +Run the application: ```bash dotnet run --urls http://0.0.0.0:8080 ``` -3. **Access the application**: Open a web browser and navigate to `http://[instance IP]:8080` to see your OrchardCore application in action, where `[instance IP]` is the public IP of your Azure Cobalt instance. +Access the application: + +* In your browser, navigate to `http://[instance IP]:8080` to see your OrchardCore application in action. + +* Replace `[instance IP]` with your VM’s public IP address. You can find it in the Azure portal under the **Networking** tab of your virtual machine. + +Configure the application: + +* On the setup screen, choose the Blog recipe and complete the admin credentials and database configuration to finish setup. -4. **Configure the application as a blog** In the resulting configuration page, +### Summary and next steps You have successfully created and run a basic OrchardCore CMS application. In the next sections, you will learn how to integrate a C shared library into your .NET application and explore performance optimizations for Arm architecture. diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md index 5a837d155d..1cfd82b524 100644 --- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md +++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/2-add-shared-c-library.md @@ -1,21 +1,21 @@ --- -title: Add a simple C shared library to your .NET OrchardCore application +title: Integrate a C shared library into your .NET OrchardCore app weight: 3 ### FIXED, DO NOT MODIFY layout: learningpathall --- +## Create a C shared library -## Introduction +In this section, you’ll integrate a simple C shared library into your .NET OrchardCore application, by doing the following: -In this section, you will learn how to integrate a simple C shared library into your .NET OrchardCore application. This process involves creating a C library, compiling it, and then using it within your .NET application. This integration can help you leverage existing C code and libraries, enhancing the functionality and performance of your application. +- Write a C function +- Compile it into a shared object (`.so`) +- Call it from C# using `DllImport` +This allows you to reuse existing C code and improve performance by accessing native functionality. -## Step 1: Create a C shared library - -First, you need to create a simple C shared library. This library will contain a function that you will call from your .NET application. - -1. Create a new file named `mylib.c` with the following content: +Create a file named `mylib.c` with the following: ```c #include @@ -25,19 +25,19 @@ void greet() { } ``` -2. Compile the C file into a shared library: +Compile the C file into a shared library: ```bash gcc -shared -o libmylib.so -fPIC mylib.c ``` - This will generate a shared library file (`libmylib.so`). +This creates a shared object file named `libmylib.so` which your .NET application can call at runtime. -## Step 2: Use the C library in your .NET application +## Use the C library in your .NET application Now that you have a shared library, you can use it in your .NET application. -1. In your OrchardCore application, create a new class file named `NativeMethods.cs`: +In your OrchardCore application, create a new class file named `NativeMethods.cs`: ```csharp using System; @@ -49,8 +49,11 @@ public static class NativeMethods public static extern void Greet(); } ``` +{{% notice Note %}} +On Linux, the `DllImport("mylib")` attribute resolves to `libmylib.so`. On Windows, the runtime would look for `mylib.dll`, and on macOS, `libmylib.dylib`. +{{% /notice %}} -2. Call the `Greet` method from your application. For example, you can add the following code to your main program `Program.cs` as shown: +Call the `Greet` method from your application. For example, you can add the following code to your main program `Program.cs` as shown: ```csharp using OrchardCore.Logging; @@ -88,31 +91,29 @@ app.UseOrchardCore(); app.Run(); ``` -3. Ensure that dotnet can find your shared library: +Ensure that dotnet can find your shared library: ```bash export LD_LIBRARY_PATH=$(pwd):$LD_LIBRARY_PATH ``` -## Step 3: Run your application +## Run your application -Now when you run `dotnet run`, you will see +When you run `dotnet run`, you’ll see the following output: ```bash Calling native greet... Hello from the C library! ``` -in the logging output. - ## Compiling for Arm -If you are compiling for Arm directly on Azure Cobalt, the compiler understands what default processor optimizations it should use, and you can compile as done in Step 1 above. However, if you are cross-compiling in your build pipeline, you should specify `-mcpu=neoverse-n2 -O3` when running the cross-compiler: +If you are compiling for Arm directly on Azure Cobalt, the compiler understands what default processor optimizations it should use, and you can compile as done above. However, if you are cross-compiling in your build pipeline, you should specify `-mcpu=neoverse-n2 -O3` when running the cross-compiler: ```bash aarch64-linux-gnu-gcc -mcpu=neoverse-n2 -O3 -shared -o libmylib.so -fPIC mylib.c ``` -The `-mcpu=neoverse-n2` flag specifies the Cobalt architecture, and `-O3` ensures that maximum optimizations are completed (including SIMD opimizations). +The `-mcpu=neoverse-n2` flag specifies the Cobalt architecture, and `-O3` ensures that maximum optimizations are completed (including SIMD optimizations). -In the next section, you will explore how to make your build architecture agnostic with the anyCPU feature. +In the next section, you’ll make your native interop cross-platform by using the AnyCPU feature and runtime dispatch strategies. diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/3-any-cpu.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/3-any-cpu.md index e109a8a51a..48cba9c9fa 100644 --- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/3-any-cpu.md +++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/3-any-cpu.md @@ -1,23 +1,28 @@ --- -title: Run a .NET OrchardCore application on Arm and x86 +title: Configure and run an architecture-agnostic OrchardCore app on Arm and x86 using .NET AnyCPU weight: 4 ### FIXED, DO NOT MODIFY layout: learningpathall --- -# Run a .NET OrchardCore application on Arm and x86 +## Run a .NET OrchardCore application on Arm and x86 -In this section, you will learn how to configure and run your OrchardCore application on both Arm and x86 architectures using the .NET AnyCPU configuration. This approach allows your application to be architecture agnostic, providing flexibility and ease of deployment across different hardware platforms. +In this section, you will configure and run your OrchardCore application on both Arm and x86 architectures using .NET's AnyCPU configuration. This architecture-agnostic approach simplifies deployment and ensures that your application runs smoothly on diverse hardware, including cloud VMs, local development boxes, and edge devices. -The AnyCPU feature has been around since .NET 2, but it's current incarnation was released in .NET Framework 4.5. +The AnyCPU feature has existed since .NET Framework 2.0, but its current behavior (particularly how it handles 32-bit vs. 64-bit execution) was defined in .NET Framework 4.5. + +{{% notice Note %}} +In .NET Core and .NET 5+, AnyCPU still lets the runtime decide which architecture to use, but keep in mind that your build must match the runtime environment's bitness (32-bit vs. 64-bit). Since .NET 8 targets 64-bit by default, this Learning Path assumes 64-bit runtime environments on both Arm64 and x86_64. +{{% /notice %}} ## Configure the project for AnyCPU -To make your OrchardCore application architecture agnostic, you need to configure it to use the AnyCPU platform target. This allows the .NET runtime to choose the appropriate architecture at runtime. +To make your OrchardCore application architecture-agnostic, configure the project to use the AnyCPU platform target. This allows the .NET runtime to select the appropriate architecture at runtime. + +1. Open your OrchardCore project `MyOrchardCoreApp.csproj` in your IDE. -1. Open your OrchardCore project `MyOrchardCoreApp.csproj` in your preferred IDE. -2. Find the `` and add the `` element to `AnyCPU`: +2. Add the `` element to your existing ``: ```xml @@ -25,34 +30,36 @@ To make your OrchardCore application architecture agnostic, you need to configur ``` -4. Save the changes to the `.csproj` file. +3. Save the `.csproj` file. + +## Build and run on any platform -## Build once, run anywhere +You can now build your application once and run it on either an x86_64 or Arm64 system. -You can now build your application on either an x86 or Arm host machine and deploy it on any architecture. +Build the application: ```bash dotnet build -c Release ``` -4. Run the application: +Run the application: ```bash dotnet run --urls http://0.0.0.0:8080 ``` -Your application should now be runnable on any architecture. All you have to do is copy the `MyOrchardCoreApp` directory to any computer with the .NET 8 Framework installed and run the command shown from within the `MyOrchardCoreApp` directory: +Your application should now be runnable on any architecture. All you have to do is copy the `MyOrchardCoreApp` directory to any computer with the .NET 8 runtime installed and run the command shown from within the `MyOrchardCoreApp` directory: ```bash dotnet ./bin/Release/net8.0/MyOrchardCoreApp.dll --urls http://0.0.0.0:8080 ``` -## Benefits of architecture agnostic applications +## Benefits of architecture-agnostic applications -By configuring your application to be architecture agnostic, you gain several benefits: +Using the AnyCPU configuration offers several advantages: -- **Flexibility**: Deploy your application on a wide range of devices without modification. -- **Efficiency**: Reduce the need for maintaining separate builds for different architectures. +- **Flexibility**: Deploy your application on a wide range of devices without modifying your code. +- **Efficiency**: Eliminate the need to maintain separate builds for different architectures. - **Scalability**: Easily scale your application across different hardware platforms. -This approach ensures that your OrchardCore application can run seamlessly on both Arm and x86 architectures. +This approach ensures that your OrchardCore application runs consistently on both Arm and x86 architectures. diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/4-dotnet-versions.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/4-dotnet-versions.md index 3e0d49d6eb..7dcd881edb 100644 --- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/4-dotnet-versions.md +++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/4-dotnet-versions.md @@ -1,20 +1,31 @@ --- -title: Evaluate .NET versions for performance on Arm +title: Evaluate .NET performance across versions on Arm weight: 5 ### FIXED, DO NOT MODIFY layout: learningpathall --- -# Evaluate .NET versions for performance on Arm +## Version-by-version feature and throughput improvements Understanding which versions perform best and the features they offer can help you make informed decisions when developing applications for Arm-based systems. .NET has evolved significantly over the years, with each version introducing new features and performance improvements. Here, you will learn about key versions that have notable performance implications for Arm architecture. +{{% notice Support status summary %}} + +- .NET 8 – Current LTS (support until Nov 2026) +- .NET 9 – STS (preview; GA Q4 2025) +- .NET 10 – Next LTS (preview; expected 2025 Q4–Q1 2026) +- .NET 3.1, 5, 6, 7 – End of life +{{% /notice %}} + + ## .NET Core 3.1 (end-of-life 2022) -.NET Core 3.1 was the first LTS with meaningful Arm64 support. Highlights were: +.NET Core 3.1 was the first LTS with meaningful Arm64 support. + +Highlights were: - Initial JIT (Just-In-Time) optimizations for Arm64 (but the bulk of Arm throughput work arrived in .NET 5). - Faster garbage collection thanks to refinements to the background GC mode. @@ -39,7 +50,9 @@ With .NET 5 Microsoft started the “one .NET” unification. Even though it had ## .NET 7 (end-of-life 2024) -.NET 7 was an STS (Standard-Term Support) release which is now out of support, but it pushed the performance envelope and is therefore interesting from a historical perspective. Key highlights were: +.NET 7 was an STS (Standard-Term Support) release which is now out of support, but it pushed the performance envelope and is therefore interesting from a historical perspective. + +Key highlights were: - General-availability of Native AOT publishing for console applications, producing self-contained, very small binaries with fast start-up on Arm64. - Dynamic PGO (Profile-Guided Optimisation) and On-Stack Replacement became the default, letting the JIT optimise the hottest code paths based on real run-time data. @@ -47,10 +60,12 @@ With .NET 5 Microsoft started the “one .NET” unification. Even though it had ## .NET 8 (current LTS – support until November 2026) -.NET 8 is the current Long-Term Support release and should be your baseline for new production workloads. Important Arm-related improvements include: +.NET 8 is the current Long-Term Support release and should be your baseline for new production workloads. + +Important Arm-related improvements include: - Native AOT support for ASP.NET Core, trimming enhancements and even smaller self-contained binaries, translating into faster cold-start for containerised Arm services. -- Further JIT tuning for Arm64 delivering single- to low-double-digit percentage throughput wins in real-world benchmarks. +- Further JIT tuning for Arm64 delivering single-digit to low double-digit throughput gains in real-world benchmarks. - Smaller base container images (`mcr.microsoft.com/dotnet/aspnet:8.0` and `…/runtime:8.0`) thanks to a redesigned layering strategy, particularly beneficial on Arm where network bandwidth is often at a premium. - Garbage-collector refinements that reduce pause times on highly-threaded, many-core servers. @@ -66,10 +81,10 @@ Although .NET 9 will receive only 18 months of support, it is an excellent choic ## .NET 10 (preview – next LTS) -.NET 10 is still in preview and will likely change prior to it's GA release, but it will be the next LTS version of .NET. +.NET 10 is still in preview and will likely evolve prior to its GA release, but it will be the next LTS version of .NET, with the following benefits: - [Extended SVE2 intrinsics](https://github.com/dotnet/runtime/issues/109652) to unlock efficient implementation of large-scale numerical algorithms and on-device AI inference on Arm v9. - C# 14 is expected to ship alongside .NET 10, bringing additional compile-time metaprogramming features that can reduce boilerplate on resource-constrained Arm edge devices. -Because .NET 10 is still in preview, you should validate any assumptions about feature availability against the latest preview builds and roadmap updates. +Developers targeting Arm-based systems should track preview builds and roadmap updates closely to validate feature availability and compatibility with their target platforms. diff --git a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md index fe8904538b..f7c657054b 100644 --- a/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md +++ b/content/learning-paths/servers-and-cloud-computing/dotnet-migration/_index.md @@ -1,22 +1,23 @@ --- -title: Migrate a .NET application to Microsoft Azure Cobalt 100 +title: Migrate a .NET application to Azure Cobalt 100 -draft: true -cascade: - draft: true - + minutes_to_complete: 25 -who_is_this_for: This is an advanced learning path for .NET developers who want to take advantage of the cost and performance benefits of Azure Cobalt processors. +who_is_this_for: This is an advanced topic path for .NET developers who want to take advantage of the performance and cost benefits of Azure Cobalt processors. learning_objectives: - - Create and compile a basic OrchardCore CMS application - - Add a simple C shared library to your .NET application - - Learn about anyCPU hardware agnostic builds - - Learn about performance of different .NET versions + - Build and run a basic OrchardCore CMS application + - Integrate a simple C shared library into a .NET application + - Configure architecture-agnostic builds using AnyCPU + - Evaluate the performance of different .NET versions prerequisites: - - A Microsoft Azure account + - A Microsoft Azure account with permissions to deploy virtual machines + - .NET SDK 8.0 or later + - Basic knowledge of C and C# + - GCC installed (Linux) or access to a cross-compiler + - OrchardCore application created using the .NET CLI or Visual Studio author: Joe Stech @@ -37,10 +38,14 @@ further_reading: - resource: title: OrchardCore documentation link: https://docs.orchardcore.net/ + type: documentation + - resource: + title: OrchardCore GitHub Repository + link: https://github.com/OrchardCMS/OrchardCore type: documentation - resource: title: .NET documentation - link: https://docs.microsoft.com/en-us/dotnet/ + link: https://learn.microsoft.com/en-us/dotnet/ type: documentation