Add Azure functions example in Typescript

azure-ts-functions/Pulumi.yaml

@@ -0,0 +1,2 @@
+name: azure-functions
+runtime: nodejs

azure-ts-functions/README.md

@@ -0,0 +1,53 @@
+# Azure Functions
+
+An example Pulumi component that deploys a Typescript function to Azure Functions.
+
+## Running the App
+
+1. Create a new stack:
+
+ ```
+ $ pulumi stack init azure-fn
+ ```
+
+1. Login to Azure CLI (you will be prompted to do this during deployment if you forget this step):
+
+ ```
+ $ az login
+ ```
+
+1. Restore NPM dependencies:
+
+ ```
+ $ npm install
+ ```
+
+1. Build the Typescript project:
+
+ ```
+ $ npm run build
+ ```
+
+1. Run `pulumi update` to preview and deploy changes:
+
+ ``` 
+ $ pulumi update
+ Previewing changes:
+ ...
+
+ Performing changes:
+ ...
+ info: 9 changes performed:
+ + 9 resources created
+ Update duration: 1m20.493392283s
+ ```
+
+1. Check the deployed function endpoint:
+
+ ```
+ $ pulumi stack output endpoint
+ https://fn-app051a4f8b.azurewebsites.net/api/fn
+ $ curl "$(pulumi stack output endpoint)"
+ Greetings from Azure Functions!
+ ...
+ ```

azure-ts-functions/azureFunction.ts

@@ -0,0 +1,124 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as azure from "@pulumi/azure";
+
+import * as azurefunctions from "azure-functions-ts-essentials";
+
+import { signedBlobReadUrl } from "./sas";
+
+export type Context = azurefunctions.Context;
+export type HttpRequest = azurefunctions.HttpRequest;
+export * from "azure-functions-ts-essentials";
+
+export type AzureFunctionHandler = (context: Context, request: HttpRequest) => void;
+
+
+async function blobContent(name: string, handler: AzureFunctionHandler): Promise<pulumi.asset.AssetMap> {
+ let serializedHandler = await pulumi.runtime.serializeFunction(handler);
+ let map: pulumi.asset.AssetMap = {};
+
+ map["host.json"] = new pulumi.asset.StringAsset(JSON.stringify({}));
+ map[`${name}/function.json`] = new pulumi.asset.StringAsset(JSON.stringify({
+ "disabled": false,
+ "bindings": [
+ {
+ "authLevel": "anonymous",
+ "type": "httpTrigger",
+ "direction": "in",
+ "name": "req"
+ },
+ {
+ "type": "http",
+ "direction": "out",
+ "name": "$return"
+ }
+ ]
+ }));
+ map[`${name}/index.js`] = new pulumi.asset.StringAsset(`module.exports = require("./handler").handler`),
+ map[`${name}/handler.js`] = new pulumi.asset.StringAsset(serializedHandler.text);
+
+ return map;
+}
+
+
+// An Azure function exposed via an HTTP endpoint.
+
+export class HttpFunction extends pulumi.ComponentResource {
+ readonly resourceGroup: azure.core.ResourceGroup;
+
+ readonly storageAccount: azure.storage.Account;
+ readonly storageContainer: azure.storage.Container;
+ readonly blob: azure.storage.ZipBlob;
+
+ readonly appServicePlan: azure.appservice.Plan;
+ readonly functionApp: azure.appservice.FunctionApp;
+
+ readonly codeBlobUrl: pulumi.Output<string>;
+ readonly endpoint: pulumi.Output<string>;
+
+ constructor(name: string, handler: AzureFunctionHandler, options?: pulumi.ResourceOptions) {
+ super("azure:HttpFunction", name, {}, options);
+
+ let parentArgs = { parent: this };
+
+ this.resourceGroup = new azure.core.ResourceGroup(`${name}-rg`, {
+ location: "West US 2",
+ }, parentArgs);
+
+ let resourceGroupArgs = {
+ resourceGroupName: this.resourceGroup.name,
+ location: this.resourceGroup.location,
+ };
+
+ this.storageAccount = new azure.storage.Account(`${name}sa`, {
+ ...resourceGroupArgs,
+
+ accountKind: "StorageV2",
+ accountTier: "Standard",
+ accountReplicationType: "LRS",
+ }, parentArgs);
+
+ this.storageContainer = new azure.storage.Container(`${name}-c`, {
+ resourceGroupName: this.resourceGroup.name,
+ storageAccountName: this.storageAccount.name,
+ containerAccessType: "private",
+ }, parentArgs);
+
+ this.blob = new azure.storage.ZipBlob(`${name}-b`, {
+ resourceGroupName: this.resourceGroup.name,
+ storageAccountName: this.storageAccount.name,
+ storageContainerName: this.storageContainer.name,
+ type: "block",
+
+ content: new pulumi.asset.AssetArchive(blobContent(name, handler)),
+ }, parentArgs);
+
+ this.codeBlobUrl = signedBlobReadUrl(this.blob, this.storageAccount, this.storageContainer);
+
+ this.appServicePlan = new azure.appservice.Plan(`${name}-p`, {
+ ...resourceGroupArgs,
+
+ kind: "FunctionApp",
+
+ // https://social.msdn.microsoft.com/Forums/azure/en-US/665c365d-2b86-4a77-8cea-72ccffef216c
+ sku: {
+ tier: "Dynamic",
+ size: "Y1",
+ },
+ }, parentArgs);
+
+ this.functionApp = new azure.appservice.FunctionApp(`${name}-app`, {
+ ...resourceGroupArgs,
+
+ appServicePlanId: this.appServicePlan.id,
+ storageConnectionString: this.storageAccount.primaryConnectionString,
+
+ appSettings: {
+ "WEBSITE_RUN_FROM_ZIP": this.codeBlobUrl,
+ },
+ }, parentArgs);
+
+ this.endpoint = this.functionApp.defaultHostname.apply(h => {
+ return `https://${h}/api/${name}`;
+ });
+ }
+};

azure-ts-functions/index.ts

@@ -0,0 +1,24 @@
+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;

azure-ts-functions/package.json

@@ -0,0 +1,19 @@
+{
+ "name": "azure-ts-functions",
+ "version": "1.0.0",
+ "main": "bin/index.js",
+ "typings": "bin/index.d.ts",
+ "scripts": {
+ "build": "tsc"
+ },
+ "devDependencies": {
+ "@types/node": "^10.3.3",
+ "azure-functions-ts-essentials": "^1.3.2",
+ "typescript": "^2.9.2"
+ },
+ "dependencies": {
+ "@pulumi/azure": "^0.14.0",
+ "@pulumi/pulumi": "^0.14.0",
+ "azure-storage": "^2.9.0-preview"
+ }
+}

azure-ts-functions/sas.ts

@@ -0,0 +1,37 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as azure from "@pulumi/azure";
+
+import * as azurestorage from "azure-storage";
+
+// Given an Azure blob, create a SAS URL that can read it.
+export function signedBlobReadUrl(
+ blob: azure.storage.Blob | azure.storage.ZipBlob,
+ account: azure.storage.Account,
+ container: azure.storage.Container,
+): pulumi.Output<string> {
+ // Choose a fixed, far-future expiration date for signed blob URLs.
+ // The shared access signature (SAS) we generate for the Azure storage blob must remain valid for as long as the
+ // Function App is deployed, since new instances will download the code on startup. By using a fixed date, rather
+ // than (e.g.) "today plus ten years", the signing operation is idempotent.
+ const signatureExpiration = new Date(2100, 1);
+
+ return pulumi.all([
+ account.primaryConnectionString,
+ container.name,
+ blob.name,
+ ]).apply(([connectionString, containerName, blobName]) => {
+ let blobService = new azurestorage.BlobService(connectionString);
+ let signature = blobService.generateSharedAccessSignature(
+ containerName,
+ blobName,
+ {
+ AccessPolicy: {
+ Expiry: signatureExpiration,
+ Permissions: azurestorage.BlobUtilities.SharedAccessPermissions.READ,
+ },
+ }
+ );
+
+ return blobService.getUrl(containerName, blobName, signature);
+ });
+}

azure-ts-functions/tsconfig.json

@@ -0,0 +1,26 @@
+{
+ "compilerOptions": {
+ "outDir": "bin",
+ "target": "es6",
+ "lib": [
+ "es6"
+ ],
+ "module": "commonjs",
+ "moduleResolution": "node",
+ "declaration": true,
+ "sourceMap": true,
+ "stripInternal": true,
+ "experimentalDecorators": true,
+ "pretty": true,
+ "noFallthroughCasesInSwitch": true,
+ "noImplicitAny": true,
+ "noImplicitReturns": true,
+ "forceConsistentCasingInFileNames": true,
+ "strictNullChecks": true
+ },
+ "files": [
+ "azureFunction.ts",
+ "index.ts",
+ "sas.ts",
+ ]
+}