Primeros pasos con Pulumi en Azure usando C#

March 22, 2024

En el artículo vamos a hablar de Pulumi. Vamos a ver como podemos usarlo para desplegar nuestra infraestructura de Azure usando C#.

Tal y como dicen en la página oficial:

“Pulumi es una plataforma de infraestructura como código que le permite utilizar lenguajes y herramientas de programación familiares para construir, implementar y administrar infraestructura en la nube.”

Creo en mi opinión, que el mayor punto fuerte es que podemos usar un lenguaje que ya conocemos y usamos para programar, sin que tener que aprender otro lenguaje diferente.

Por ejemplo en el caso de Azure, usando otras herramientas como Terraform, plantillas ARM o Bicep para desplegar infraestructura como código, estamos “obligados” a aprender un nuevo lenguaje que usan cada una de estas herramientas.

Ahora ya, nos metemos en harina y vamos a ver como podemos desplegar nuestra infraestructura con Pulumi. En nuestro ejemplo vamos a usar C# como nuestro lenguaje de programación.

NOTA: Como editor de código vamos a usar Visual Studio Code. Podéis descargarlo de https://code.visualstudio.com/

Los pasos a seguir son:

Instalamos Pulumi, usando en nuestro caso winget. Abrimos Powershell y lanzamos lo siguiente:
```
winget install pulumi
```
Nota: En caso de no tener Windows 11, que por defecto tiene winget instalado. Podemos instalar Pulumi de otra manera. En la siguiente página, se dan instrucciones para poder instalarlo:

https://www.pulumi.com/docs/install/
Cerramos Powershell y lo abrimos de nuevo. Lanzamos el siguiente comando para comprobar que Pulumi se instaló correctamente:
```
pulumi version
```
Como hemos dicho, vamos a usar C#, y vamos a necesitar dotnet. En caso de no tenerlo instalado (cosa que dudo jajaja), podéis descargarlo de (version 6):

https://dotnet.microsoft.com/en-us/download

https://dotnet.microsoft.com/es-es/download/dotnet/thank-you/runtime-6.0.28-windows-x64-installer
Ahora vamos a hacer uso del CLI de Azure. En caso de no tenerlo instalado podemos descargarlo desde aquí:

https://learn.microsoft.com/es-es/cli/azure/install-azure-cli
Ahora ya vamos a hacer login con el CLI de Azure. Desde Powershell lanzamos el siguiente comando:
```
az login --tenant "[PUT-YOUR-TENANT-ID-HERE]"
```
Ahora seleccionamos la suscripción donde vamos a desplegar nuestra infra:
```
az account set --subscription "[PUT-YOUR-SUBSCRIPTION-ID-HERE]"
```
Ahora ya si empezamos con Pulumi. Creamos un nuevo directorio y usamos el comando de pulumi para crear un nuevo proyecto:
```
mkdir first-azure-iac 
cd first-azure-iac
pulumi login --local
pulumi new azure-csharp
```
Se nos pide una serie de datos:
Ahora lanzamos el comando para abrir Visual Studio Code:
```
code .
```

Abrimos el fichero Program.cs, y vemos que Pulumi nos ha creado un código de ejemplo:

using Pulumi;
using Pulumi.AzureNative.Resources;
using Pulumi.AzureNative.Storage;
using Pulumi.AzureNative.Storage.Inputs;
using System.Collections.Generic;

return await Pulumi.Deployment.RunAsync(() =>
{
    // Create an Azure Resource Group
    var resourceGroup = new ResourceGroup("resourceGroup");

    // Create an Azure resource (Storage Account)
    var storageAccount = new StorageAccount("sa", new StorageAccountArgs
    {
        ResourceGroupName = resourceGroup.Name,
        Sku = new SkuArgs
        {
            Name = SkuName.Standard_LRS
        },
        Kind = Kind.StorageV2
    });

    var storageAccountKeys = ListStorageAccountKeys.Invoke(new ListStorageAccountKeysInvokeArgs
    {
        ResourceGroupName = resourceGroup.Name,
        AccountName = storageAccount.Name
    });

    var primaryStorageKey = storageAccountKeys.Apply(accountKeys =>
    {
        var firstKey = accountKeys.Keys[0].Value;
        return Output.CreateSecret(firstKey);
    });

    // Export the primary key of the Storage Account
    return new Dictionary<string, object?>
    {
        ["primaryStorageKey"] = primaryStorageKey
    };
});

En este código podéis ver como se va a crear un resource group (línea 10 ) y un storage account (línea 13) .
Ahora vamos a desplegar esta infra, para ello lanzamos lo siguiente en la terminal de Visual Studio Code:
```
pulumi up
```
Nos pedirá confirmación. Ponemos lleves y pulsamos la tecla Enter.

Una vez finalizado, si vamos al portal de Azure veremos nuestra infraestructura desplegada:

Si os fijáis en el nombre de los recursos, podéis ver como al final de los nombres de los recursos se ha añadido unos valores random (por ejemplo el storage name se llama sarecetasdevops8bf02e54). Esta es una configuración por defecto de Pulimi llamada auto-names. En la documentación de Pulumi (mas info aquí: https://www.pulumi.com/docs/concepts/resources/names), se dice lo siguiente:

Pulumi auto-names most resources by default, using the logical name and a random suffix to construct a unique physical name for a resource. Users can provide explicit names to override this default.

Nosotros queremos poner unos nombres “fijos” a nuestros recursos, y no que Pulumi use auto-names. Es por ello que en nuestro código de C# lo ponemos de la siguiente manera:

Ya por último y para finalizar, para eliminar nuestra infraestructura lanzariamos el siguiente comando:

pulumi down

Espero que este pequeño artículo os anime a investigar sobre Pulumi ;)