Modern Infrastructure as Code for Azure

import * as azure from "@pulumi/azure";
import * as azureFunction from "./azureFunction";

// Create an Azure function that prints a message and the request headers.
function handler(context: azureFunction.Context, request: azureFunction.HttpRequest) {
    let body = "";
    let headers = context.req!.headers!;
    for (let h in headers) {
        body = body + h + "=" + headers[h] + "\n";
    }

    let res: azureFunction.HttpResponse = {
        status: azureFunction.HttpStatusCode.OK,
        headers: {
            "content-type": "text/plain",
        },
        body: "Greetings from Azure Functions!\n\n===\n\n" + body,
    };

    context.done(undefined, res);
}

let fn = new azureFunction.HttpFunction("fn", handler);
export let endpoint = fn.endpoint;

import * as azure from "@pulumi/azure";

const resourceGroup = new azure.core.ResourceGroup("resourcegroup", {
    location: "West US",
});

const containerGroup = new azure.containerservice.Group("containergroup", {
    location: resourceGroup.location,
    resourceGroupName: resourceGroup.name,
    ipAddressType: "public",
    osType: "linux",
    containers: [
        {
            name: "hw",
            image: "microsoft/aci-helloworld:latest",
            cpu: 0.5,
            memory: 1.5,
            port: 80
        },
        {
            name: "sidecar",
            image: "microsoft/aci-tutorial-sidecar",
            cpu: 0.5,
            memory: 1.5,
        },
    ],
    tags: {
        "environment": "testing",
    },
});

import * as helm from "@pulumi/kubernetes/helm";
import * as k8s from "@pulumi/kubernetes";
import { k8sCluster, k8sProvider } from "./cluster";

const apache = new helm.v2.Chart("apache", {
    repo: "bitnami",
    chart: "apache",
    version: "1.0.0",
}, { providers: { kubernetes: k8sProvider } });

export let cluster = k8sCluster.name;
export let kubeConfig = k8sCluster.kubeConfigRaw;
export let serviceIP =
    (apache.resources["v1/Service::default/apache-apache"]
            as k8s.core.v1.Service)
        .spec.apply(s => s.clusterIP);

const azure = require("@pulumi/azure");

let vm = new azure.compute.VirtualMachine("server-vm", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    networkInterfaceIds: [networkInterface.id],
    vmSize: "Standard_A0",
    deleteDataDisksOnTermination: true,
    deleteOsDiskOnTermination: true,
    osProfile: {
        computerName: "hostname",
        adminUsername: username,
        adminPassword: password,
        customData: userData,
    },
    osProfileLinuxConfig: {
        disablePasswordAuthentication: false,
    },
    storageOsDisk: {
        createOption: "FromImage",
        name: "myosdisk1",
    },
    storageImageReference: {
        publisher: "canonical",
        offer: "UbuntuServer",
        sku: "16.04-LTS",
        version: "latest",
    },
});

exports.publicIP = vm.id.apply(_ =>
    azure.network.getPublicIP({
        name: publicIP.name,
        resourceGroupName: publicIP.resourceGroupName,
    }).then(ip => ip.ipAddress)
);