Building Modern Cloud Applications using Pulumi and .NET Core

We are excited to announce .NET Core support for Pulumi! This announcement means you can declare cloud infrastructure — including all of Azure, such as Kubernetes, Functions, AppService, Virtual Machines, CosmosDB, and more — using your favorite .NET language, including C#, VB.NET, and F#. This brings the entire cloud to your fingertips without ever having to leave your code editor, while using production-ready «infrastructure as code» techniques.



Infrastructure has become more relevant these days as modern cloud capabilities such as microservices, containers, serverless, and data stores permeate your application’s architecture. The term «infrastructure» covers all of the cloud resources your application needs to run. Modern architectures require thinking deeply about infrastructure while building your application, instead of waiting until afterwards. Pulumi’s approach helps developers and infrastructure teams work together to deliver innovative new functionality that leverages everything the modern cloud has to offer.

Pulumi launched a little over a year ago and recently reached a stable 1.0 milestone. After working with hundreds of companies to get cloud applications into production, .NET has quickly risen to one of Pulumi’s most frequently community requested features. Especially since many of us on the Pulumi team are early .NET ex-pats, we are thrilled today to make Pulumi available on .NET Core for your cloud engineering needs.

What is Pulumi?

Pulumi lets you use real languages to express your application’s infrastructure needs, using a powerful technique called «infrastructure as code.» Using infrastructure as code, you declare desired infrastructure, and an engine provisions it for you, so that it’s automated, easy to replicate, and robust enough for demanding production requirements. Pulumi takes this approach a step further by leveraging real languages and making modern cloud infrastructure patterns, such as containers and serverless programs, first class and easy.

With Pulumi for .NET you can:

• Declare infrastructure using C#, VB.NET, or F#.
  
• Automatically create, update, or delete cloud resources using Pulumi’s infrastructure as code engine, removing manual point-and-clicking in the Azure UI and ad-hoc scripts.
  
• Use your favorite IDEs and tools, including Visual Studio and Visual Studio Code, taking advantage of features like auto-completion, refactoring, and interactive documentation.
  
• Catch mistakes early on with standard compiler errors, Roslyn analyzers, and an infrastructure-specific policy engine for enforcing security, compliance, and best practices.
  
• Reuse any existing NuGet library, or distribute your own, whether that’s for infrastructure best practices, productivity, or just general programming patterns.
  
• Deploy continuously, predictably, and reliably using Azure DevOps Pipelines, GitHub Actions, or one of over a dozen integrations.
  
• Build scalable cloud applications using classic infrastructure cloud native technologies like Kubernetes, Docker containers, serverless functions, and highly scalable databases such as CosmosDB into your core development experience, bringing them closer to your application code.
  

Pulumi’s free open source SDK, which includes a CLI and assortment of libraries, enables these capabilities. Pulumi also offers premium features for teams wanting to use Pulumi in production, such as Azure ActiveDirectory integration for identity and advanced policies.

An example: global database with serverless app

Let’s say we want to build a new application that uses Azure CosmosDB for global distribution of data so that performance is great for customers no matter where in the world they are, with a C# serverless application that automatically scales alongside our database. Normally we’d use some other tools to create the infrastructure, such as JSON, YAML, a DSL, or manually point-and-click in the Azure console. This approach is par for the course, but also daunting — it’s complex, unrepeatable, and means we need an infrastructure expert just to even get started.

The Pulumi approach is to just write code in our favorite .NET language and the Pulumi tool will handle the rest. For example, this C# code creates an Azure CosmosDB databases with a serverless Azure AppService FunctionApp that automatically scales alongside the database:

using System;
using System.Collections.Generic;

using Pulumi;
using Pulumi.Azure.AppService;
using Pulumi.Azure.Core;
using Pulumi.Azure.CosmosDB;

class Program
{
    static Task<int> Main(string[] args)
    {
        return Deployment.RunAsync(() => {
            var locations = new[] { "WestUS", "WestEurope", "SouthEastAsia" };

            var rg = new ResourceGroup("myapp-rg", new ResourceGroupArgs {
                Location = locations[0],
            });

            var app = new CosmosApp("myapp", new CosmosAppArgs {
                 ResourceGroup = resourceGroup,
                 Locations = locations,
                 DatabaseName = "pricedb",
                 ContainerName = "prices",
                 Factory = (location, db) => {
                     var func = new ArchiveFunctionApp("myapp-func",
                          new ArchiveFunctionAppArgs {
                              Location = location,
                              Archive = new FileArchive("app"),
                              AppSettings = new Dictionary<string, string> {
                                  ["COSMOSDB_ENDPOINT"] = db.Endpoint,
                              },
                          },
                      );
                      return func.App.ID;
                 },
            });
        });
    }

    // Definitions of CosmosApp and ArchiveFunctionApp elided for brevity.
    // Actual runtime application code is stored in the "app" directory.
    // See link to the full example at the end of this article.
}

view rawProgram.cs hosted with by GitHub

After writing this code, you run the Pulumi CLI with the pulumi up command and it will first show you a preview of the infrastructure resources it plans on creating. After confirming, it will deploy your whole application and its required infrastructure in just a few minutes.



Later on, if you need to make any changes, you just edit your program, rerun the CLI, and it will make the necessary incremental changes to update your infrastructure accordingly. A full history of your deployments is recorded so you can easily see what changes have been made.

Why is .NET great for infrastructure too?

Many of us love using .NET to author our applications, so why not use it for infrastructure as code too? We’ve in fact already seen above some of the advantages above to doing so. Many of these are probably evident if you already know and love .NET, however, let’s briefly recap.

By using any .NET language, you get many helpful features for your infrastructure code:

• Familiarity: No need to learn DSLs or markup templating languages.
  
• Expressiveness: Use loops, conditionals, pattern matching, LINQ, async code, and more, to dynamically create infrastructure that meets the target environment’s needs.
  
• Abstraction: Encapsulate common patterns into classes and functions to hide complexity and avoid copy-and-pasting the same boilerplate repeatedly.
  
• Sharing and reuse: Tap into a community of cloud applications and infrastructure experts, by sharing and reusing NuGet libraries with your team or the global community.
  
• Productivity: Use your favorite IDE and get statement completion, go to definition, live error checking, refactoring, static analysis, and interactive documentation.
  
• Project organization: Use common code structuring techniques such as assemblies and namespaces to manage your infrastructure across one or more projects.
  
• Application lifecycle: Use existing ALM systems and techniques to manage and deploy your infrastructure projects, including source control, code review, testing, and continuous integration (CI) and delivery (CD).
  

Pulumi unlocks access to the entire .NET ecosystem — something that’s easy to take for granted but is missing from other solutions based on JSON, YAML, DSLs, or CLI scripts. Having access to a full language was essential to enabling the CosmosApp example above, which is a custom component that internally uses classes, loops, lambdas, and even LINQ. This approach also helps developers and operators work better together using a shared foundation. Add all of the above together, and you get things done faster and more reliably.

Join the community and get started

Today we’ve released the first preview of Pulumi for .NET, including support for the entire Azure breath of services. To give Pulumi a try, visit the Pulumi for .NET homepage.

There you will find several instructions on installing and getting started with Pulumi for .NET. The following resources provide additional useful information:

• Full CosmosApp example code
  
• Getting started with Pulumi for Azure
  
• Getting started with Pulumi for Kubernetes
  
• Integrating Pulumi with Azure DevOps Pipelines and GitHub Actions
  
• General Pulumi overview (concepts and architecture)
  
• Overview of premium Pulumi features for teams and Enterprises
  

Although Pulumi for .NET is listed in «preview» status, it supports all of the most essential Pulumi programming model features (and the rest is on its way). Our goal is to gather feedback and over the next few weeks, and we will be working hard to improve the .NET experience across the board, including more examples and better documentation.

Please join the community in Slack to discuss your scenarios, ideas, and to get any needed assistance from the team and other end users. Pulumi is also open source on GitHub.

This is an exciting day for the Pulumi team and our community. Pulumi was started by some of .NET’s earliest people and so it’s great to get back to our roots and connect with the .NET community, helping developers, infrastructure teams, and operators build better cloud software together.

We look forward to seeing the new and amazing cloud applications you build with Pulumi for .NET!