Pulumi Blog: Arch templates

Using Kubernetes Arch Templates with Poetry and Python

Laura Santamaria — Wed, 07 Dec 2022 00:00:00 +0000

When building with Kubernetes for the first time, we often need to stand up a lot of infrastructure just to get to the point of having a base to build an application. Let’s explore how we can wire together two of our architecture templates to generate a base for a web application running on Kubernetes on Google Cloud with Python and Poetry.

A primer on microservices

To work with Kubernetes, you’re generally following a microservices architecture. In short, here’s how to think about a microservices architecture: Each logical component of your application is its own individual process acting as a closed box that defines what data must come in and what data is delivered on the other end—what’s known as a service. Services communicate with one another via APIs or similar small interfaces, and each service addresses one part of your business logic inside your application.

In a typical, very basic web application set up in a generic microservices architecture, you might have a data store, a backend, and a frontend (a user interface, or UI). In practice, you might have multiple backends and data stores to address multiple activities like logging in, running a shopping cart, delivering shipping updates, and more.

To ensure all of these services work together, an orchestrator like Kubernetes ensures each service is running and healthy, is connected to the others, and runs as expected.

A typical Kubernetes architecture

A Kubernetes cluster is a collection of one or more machines (either virtual or bare-metal) called nodes that host groups of containers, with each group containing multiple copies of a microservice. These groups of containers are called pods. And then, to connect and expose those pods to one another and the world, we add in services.

For our system that we’ll build today, we’re going to have a cluster running on Google Kubernetes Engine (GKE). We’ll create a namespace on that Kubernetes instance, which will hold all of our Kubernetes app resources. We’ll have a deployment that takes the configuration we need for NGINX (a ConfigMap) and spins up a pod holding the containers running that NGINX server. Then, we’ll have a service that exposes the ports so we can access our NGINX server from anywhere.

Start with templates

We’re going to build our entire architecture starting with two templates: Our GKE template and our Kubernetes web app template. Learn more about our new architecture templates.

This will be a bit different than our usual workflow. Generally, we here at Pulumi prefer to stand up different stacks for each type of infrastructure (so one project with one or more stacks for the Kubernetes cluster and then one project with one or more stacks for the web application). However, in this case, let’s explore together what happens if we’re want to have it all go up together as one project and stack while keeping the code in different files.

First, create a new directory to hold all of our project files, and add app and infra directories inside this root directory.

$ mkdir k8s-templates && cd k8s-templates
$ mkdir app
$ mkdir infra

In the infra directory, we’ll add the GKE template first. We’re using the --generate-only flag to avoid creating the default virtual environment and the various extra stack information since we’re using Poetry and will be running everything from the root directory later:

$ cd infra
$ pulumi new kubernetes-gcp-python --generate-only

Accept all of the standard default values, except give your Google Cloud project name here instead of the default.

In the app directory, we’ll add the web app template:

$ cd ../app
$ pulumi new webapp-kubernetes-python --generate-only

When it asks you for a project name in the app directory, give it the name app-mi-k8s. Otherwise, accept all of the default values (using your Google Cloud details).

And now, the real fun begins!

Putting it all together

We’re going to use Poetry instead of the default virtual environment as we’re going to be working in a number of different directories that all need the same virtual environment and dependencies. In the root of the project, let’s initialize a Poetry project. We’ll need to define all of the dependencies from the application and infrastructure requirements:

$ cd ../ # if you need to go back to your project root
$ poetry init
# In the dynamic generation of dependencies, add pulumi, pulumi-gcp, and pulumi-kubernetes.
# Otherwise, fill in the other pieces as you would normally.

Then install the dependencies:

$ poetry install

Now, we can pull the metadata file for Pulumi in:

$ touch Pulumi.yaml
$ cat infra/Pulumi.yaml > Pulumi.yaml
$ touch Pulumi.dev.yaml

And do a quick cleanup of the Pulumi.dev.yaml file:

<root>/Pulumi.dev.yaml

config:
 namespace: fake-ns
 replicas: 1
 gcp:project: <your-project>
 gcp:region: <your-region>

Since we’re running on GKE, we need to define a different namespace than default. I used fake-ns.

We’ll need to modify the Pulumi.yaml file to remove the virtual environment:

<root>/Pulumi.yaml

name: k8s-combo-infra
description: A Python program to deploy a Kubernetes cluster and application on Google Cloud
runtime: python

And now we can set up our new __main__.py file! Create a new __main__.py file in the root of the repo, and add this code:

<root>/main.py

from pulumi import export as pulumi_export
from pulumi import Output
import app.__main__ as app
import infra.__main__ as infra_code

infra = infra_code

kubeconf = infra.cluster_kubeconfig
app_infra = kubeconf.apply(
 lambda val: app.create_app(kubeconfig_val=val)
)

pulumi_export("endpoint_url", Output.unsecret(app_infra))

We do need to make a couple small changes to the app/__main__.py file. We need to

wrap the code in a callable function so we can use that apply() call in the root file,
add a custom provider to use the right kubeconfig settings,
pass that provider context to all of the resources, and
get the endpoint from our app:

<root>/app/main.py

import pulumi
import pulumi_kubernetes as kubernetes


def create_app(kubeconfig_val):
 # Get some values from the Pulumi stack configuration, or use defaults
 config = pulumi.Config()
 k8s_namespace = config.get("namespace", "default")
 num_replicas = config.get_float("replicas", 1)
 app_labels = {
 "app": "nginx",
 }

 # NEW: Create a provider that consumes the upstream kubeconfig
 new_provider = kubernetes.Provider(
 "app_provider",
 kubeconfig=kubeconfig_val,
 namespace=k8s_namespace
 )

 # Create a namespace
 webserverns = kubernetes.core.v1.Namespace(
 "webserver",
 metadata=kubernetes.meta.v1.ObjectMetaArgs(
 name=k8s_namespace,
 ),
 opts=pulumi.ResourceOptions(provider=new_provider)
 )

 # Create a ConfigMap for the Nginx configuration
 webserverconfig = kubernetes.core.v1.ConfigMap(
 "webserverconfig",
 metadata=kubernetes.meta.v1.ObjectMetaArgs(
 namespace=webserverns.metadata.name,
 ),
 data={
 "nginx.conf": """events { }
 http {
 server {
 listen 80;
 root /usr/share/nginx/html;
 index index.html index.htm index.nginx-debian.html
 server_name _;
 location / {
 try_files $uri $uri/ =404;
 }
 }
 }
 """,
 },
 opts=pulumi.ResourceOptions(provider=new_provider)
 )

 # Create a Deployment with a user-defined number of replicas
 webserverdeployment = kubernetes.apps.v1.Deployment(
 "webserverdeployment",
 metadata=kubernetes.meta.v1.ObjectMetaArgs(
 namespace=webserverns.metadata.name,
 ),
 spec=kubernetes.apps.v1.DeploymentSpecArgs(
 selector=kubernetes.meta.v1.LabelSelectorArgs(
 match_labels=app_labels,
 ),
 replicas=num_replicas,
 template=kubernetes.core.v1.PodTemplateSpecArgs(
 metadata=kubernetes.meta.v1.ObjectMetaArgs(
 labels=app_labels,
 ),
 spec=kubernetes.core.v1.PodSpecArgs(
 containers=[kubernetes.core.v1.ContainerArgs(
 image="nginx",
 name="nginx",
 volume_mounts=[kubernetes.core.v1.VolumeMountArgs(
 mount_path="/etc/nginx/nginx.conf",
 name="nginx-conf-volume",
 read_only=True,
 sub_path="nginx.conf",
 )],
 )],
 volumes=[kubernetes.core.v1.VolumeArgs(
 config_map=kubernetes.core.v1.ConfigMapVolumeSourceArgs(
 items=[kubernetes.core.v1.KeyToPathArgs(
 key="nginx.conf",
 path="nginx.conf",
 )],
 name=webserverconfig.metadata.name,
 ),
 name="nginx-conf-volume",
 )],
 ),
 ),
 ),
 opts=pulumi.ResourceOptions(provider=new_provider)
 )

 # Expose the Deployment as a Kubernetes Service
 webserverservice = kubernetes.core.v1.Service(
 "webserverservice",
 metadata=kubernetes.meta.v1.ObjectMetaArgs(
 namespace=webserverns.metadata.name,
 ),
 spec=kubernetes.core.v1.ServiceSpecArgs(
 ports=[kubernetes.core.v1.ServicePortArgs(
 port=80,
 target_port=80,
 protocol="TCP",
 )],
 selector=app_labels,
 type="LoadBalancer"
 ),
 opts=pulumi.ResourceOptions(provider=new_provider)
 )

 # Export some values for use elsewhere
 pulumi.export("deploymentName", webserverdeployment.metadata.name)
 pulumi.export("serviceName", webserverservice.metadata.name)
 return webserverservice.status.apply(lambda val: val.load_balancer.ingress[0].ip)

Now that all our changes have been made, let’s try running it! We’ll need to prepend poetry run to the commands, unless you choose to switch to the Poetry shell ahead of time:

$ poetry run pulumi stack init dev
$ poetry run pulumi stack select dev
$ poetry run pulumi up

And up they all go! Note that this takes a while, so don’t panic!

output

Previewing update (dev)

View Live: https://app.pulumi.com/nimbinatus/k8s-combo-infra/dev/previews/fe73460a-a846-475c-9a69-23626e56b4e4

 Type Name Plan
 + pulumi:pulumi:Stack k8s-combo-infra-dev create
 + ├─ gcp:compute:Network gke-network create
 + ├─ gcp:compute:Subnetwork gke-subnet create
 + ├─ gcp:container:Cluster gke-cluster create
 + ├─ gcp:serviceAccount:Account gke-nodepool-sa create
 + └─ gcp:container:NodePool gke-nodepool create


Outputs:
 clusterId : output<string>
 clusterName : "gke-cluster-dd00d9f"
 endpoint_url: output<string>
 kubeconfig : output<string>
 networkId : output<string>
 networkName : "gke-network-e0ce7fb"

Resources:
 + 6 to create

Do you want to perform this update? yes
Updating (dev)

View Live: https://app.pulumi.com/nimbinatus/k8s-combo-infra/dev/updates/109

 Type Name Status
 + pulumi:pulumi:Stack k8s-combo-infra-dev created (915s)
 + ├─ gcp:compute:Network gke-network created (21s)
 + ├─ gcp:compute:Subnetwork gke-subnet created (11s)
 + ├─ gcp:container:Cluster gke-cluster created (682s)
 + ├─ pulumi:providers:kubernetes app_provider created (0.17s)
 + ├─ gcp:serviceAccount:Account gke-nodepool-sa created (1s)
 + ├─ kubernetes:core/v1:Namespace webserver created (0.52s)
 + ├─ gcp:container:NodePool gke-nodepool created (125s)
 + ├─ kubernetes:core/v1:ConfigMap webserverconfig created (0.32s)
 + ├─ kubernetes:core/v1:Service webserverservice created (193s)
 + └─ kubernetes:apps/v1:Deployment webserverdeployment created (144s)


Outputs:
 clusterId : "projects/pulumi-development/locations/us-central1/clusters/gke-cluster-6cc9507"
 clusterName : "gke-cluster-6cc9507"
 endpoint_url: "35.224.177.197"
 kubeconfig : [secret]
 networkId : "projects/pulumi-development/global/networks/gke-network-68b9493"
 networkName : "gke-network-68b9493"

Resources:
 + 11 created

Duration: 15m17s

If you CURL the endpoint, you get the default NGINX page that tells us the webserver is ready to go:

$ curl $(pulumi stack output endpoint_url)
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

Finally, if you’re done with the cluster, don’t forget to pull it down so you don’t get charged!

$ poetry run pulumi destroy -y

If you run into an issue where the cluster gets deleted before the various app resources (the namespace, the service, etc.) get removed, you may get an error that you can’t finish destroying the stack. Because the cluster is already gone, the Kubernetes provider can’t access it to update the status of the various app resources. So you’ll need to remove those resources from your state file as they were removed with the deletion of the cluster:

$ poetry run pulumi state delete urn:pulumi:dev::k8s-combo-infra::kubernetes:core/v1:Namespace::webserver --target-dependents

Then, refresh and destroy the rest of the resources, including the outputs:

$ poetry run pulumi refresh -y
$ poetry run pulumi destroy -y

If you want to try this out, head over to this example repo to explore the code and pull it down to run yourself. Don’t forget to create a Pulumi account first!

If you want to explore the other templates we have available for you, head to our templates page to explore.

Serverless Arch Templates

Kat Cosgrove — Mon, 07 Nov 2022 00:00:00 +0000

Whether you’re building a new application or moving an existing application over from another provider, the basic framework of your infrastructure probably isn’t something you want to worry about if you don’t have to. The cloud is complicated enough as it is. With Architecture Templates, Pulumi takes on some of the work involved in deploying your application to the cloud provider of your choice. Let’s take a tour of the new Serverless Templates for AWS, GCP, and Azure!

Serverless on any Cloud, in any Language

If you need a serverless application, whether that’s AWS Lambda, Google Cloud Functions, or Azure Functions, one of these templates can give you the starting point you need in any language Pulumi supports. Each template deploys a serverless function for you, with all necessary permissions to make it publicly available. While each of them does deploy a small sample function, these are designed to be extensible; we give you all the necessary tools to begin building your own application, without having to fuss around standing up the infrastructure yourself.

Generating the necessary starter code happens with a single CLI command, regardless of which cloud and language you choose:

AWS

$ mkdir my-serverless-app && cd my-serverless-app
$ pulumi new serverless-aws-typescript

$ mkdir my-serverless-app && cd my-serverless-app
$ pulumi new serverless-aws-python

$ mkdir my-serverless-app && cd my-serverless-app
$ pulumi new serverless-aws-go

$ mkdir my-serverless-app && cd my-serverless-app
$ pulumi new serverless-aws-csharp

$ mkdir my-serverless-app && cd my-serverless-app
$ pulumi new serverless-aws-yaml

GCP

$ mkdir my-serverless-app && cd my-serverless-app
$ pulumi new serverless-gcp-typescript

$ mkdir my-serverless-app && cd my-serverless-app
$ pulumi new serverless-gcp-python

$ mkdir my-serverless-app && cd my-serverless-app
$ pulumi new serverless-gcp-go

$ mkdir my-serverless-app && cd my-serverless-app
$ pulumi new serverless-gcp-csharp

$ mkdir my-serverless-app && cd my-serverless-app
$ pulumi new serverless-gcp-yaml

Azure

$ mkdir my-serverless-app && cd my-serverless-app
$ pulumi new serverless-azure-typescript

$ mkdir my-serverless-app && cd my-serverless-app
$ pulumi new serverless-azure-python

$ mkdir my-serverless-app && cd my-serverless-app
$ pulumi new serverless-azure-go

$ mkdir my-serverless-app && cd my-serverless-app
$ pulumi new serverless-azure-csharp

$ mkdir my-serverless-app && cd my-serverless-app
$ pulumi new serverless-azure-yaml

Pulumi to the Cloud

Each of these commands will generate some boilerplate for you, and includes defaults you can accept or modify (such as the name of the project, or the application directory). Run pulumi up from this directory, ensuring that you’ve connected the Pulumi CLI to your preferred cloud provider, and your starting point is online, ready for you to sub in your own application code. For the purposes of this demonstration, I’ve accepted the defaults. I’ve also left the provided application and function code in place. Let’s examine what Pulumi creates for us here, using Python for AWS, Go for GCP, and Typescript for Azure.

import json
import pulumi
import pulumi_aws as aws
import pulumi_aws_apigateway as apigateway

# An execution role to use for the Lambda function
role = aws.iam.Role("role",
 assume_role_policy=json.dumps({
 "Version": "2012-10-17",
 "Statement": [{
 "Action": "sts:AssumeRole",
 "Effect": "Allow",
 "Principal": {
 "Service": "lambda.amazonaws.com",
 },
 }],
 }),
 managed_policy_arns=[aws.iam.ManagedPolicy.AWS_LAMBDA_BASIC_EXECUTION_ROLE])

# A Lambda function to invoke
fn = aws.lambda_.Function("fn",
 runtime="python3.9",
 handler="handler.handler",
 role=role.arn,
 code=pulumi.FileArchive("./function"))

# A REST API to route requests to HTML content and the Lambda function
api = apigateway.RestAPI("api",
 routes=[
 apigateway.RouteArgs(path="/", local_path="www"),
 apigateway.RouteArgs(path="/date", method=apigateway.Method.GET, event_handler=fn)
 ])

# The URL at which the REST API will be served.
pulumi.export("url", api.url)

Here Pulumi has provided an IAM execution role to use for the Lambda function, the Lambda function itself, and a REST API gateway to handle request routing. The Lambda function is pointed at an included ./function directory, which contains a Python function that returns the latest datetime. This can be replaced with your own code, or you can change the directory the Pulumi code is pointed at to your own. Similarly, the API gateway is pointed at a www directory containing a simple website to display the current datetime, ready to be replaced with your own content.

package main

import (
 "fmt"

 "github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/cloudfunctions"
 "github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/storage"
 synced "github.com/pulumi/pulumi-synced-folder/sdk/go/synced-folder"
 "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 "github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
 pulumi.Run(func(ctx *pulumi.Context) error {

 // Import the program's configuration settings.
 cfg := config.New(ctx, "")
 sitePath := "./www"
 if param := cfg.Get("sitePath"); param != "" {
 sitePath = param
 }
 appPath := "./app"
 if param := cfg.Get("appPath"); param != "" {
 appPath = param
 }
 indexDocument := "index.html"
 if param := cfg.Get("indexDocument"); param != "" {
 indexDocument = param
 }
 errorDocument := "error.html"
 if param := cfg.Get("errorDocument"); param != "" {
 errorDocument = param
 }

 // Create a storage bucket and configure it as a website.
 siteBucket, err := storage.NewBucket(ctx, "site-bucket", &storage.BucketArgs{
 Location: pulumi.String("US"),
 Website: &storage.BucketWebsiteArgs{
 MainPageSuffix: pulumi.String(indexDocument),
 NotFoundPage: pulumi.String(errorDocument),
 },
 })
 if err != nil {
 return err
 }

 // Create an IAM binding to allow public read access to the bucket.
 _, err = storage.NewBucketIAMBinding(ctx, "site-bucket-iam-binding", &storage.BucketIAMBindingArgs{
 Bucket: siteBucket.Name,
 Role: pulumi.String("roles/storage.objectViewer"),
 Members: pulumi.StringArray{
 pulumi.String("allUsers"),
 },
 })
 if err != nil {
 return err
 }

 // Use a synced folder to manage the files of the website.
 _, err = synced.NewGoogleCloudFolder(ctx, "synced-folder", &synced.GoogleCloudFolderArgs{
 Path: pulumi.String(sitePath),
 BucketName: siteBucket.Name,
 })
 if err != nil {
 return err
 }

 // Create another storage bucket for the serverless app.
 appBucket, err := storage.NewBucket(ctx, "app-bucket", &storage.BucketArgs{
 Location: pulumi.String("US"),
 })
 if err != nil {
 return err
 }

 // Upload the serverless app to the storage bucket.
 appArchive, err := storage.NewBucketObject(ctx, "app-archive", &storage.BucketObjectArgs{
 Bucket: appBucket.Name,
 Source: pulumi.NewFileArchive(appPath),
 })
 if err != nil {
 return err
 }

 // Create a Cloud Function that returns some data.
 dataFunction, err := cloudfunctions.NewFunction(ctx, "data-function", &cloudfunctions.FunctionArgs{
 SourceArchiveBucket: appBucket.Name,
 SourceArchiveObject: appArchive.Name,
 Runtime: pulumi.String("go116"),
 EntryPoint: pulumi.String("Data"),
 TriggerHttp: pulumi.Bool(true),
 })
 if err != nil {
 return err
 }

 // Create an IAM member to invoke the function.
 _, err = cloudfunctions.NewFunctionIamMember(ctx, "data-function-invoker", &cloudfunctions.FunctionIamMemberArgs{
 Project: dataFunction.Project,
 Region: dataFunction.Region,
 CloudFunction: dataFunction.Name,
 Role: pulumi.String("roles/cloudfunctions.invoker"),
 Member: pulumi.String("allUsers"),
 })
 if err != nil {
 return err
 }

 // Create a JSON configuration file for the website.
 _, err = storage.NewBucketObject(ctx, "site-config", &storage.BucketObjectArgs{
 Name: pulumi.String("config.json"),
 Bucket: siteBucket.Name,
 ContentType: pulumi.String("application/json"),
 Source: dataFunction.HttpsTriggerUrl.ApplyT(func(url string) pulumi.AssetOrArchiveOutput {
 config := fmt.Sprintf(`{ "api": "%s" }`, url)
 return pulumi.NewStringAsset(config).ToAssetOrArchiveOutput()
 }).(pulumi.AssetOrArchiveOutput),
 })
 if err != nil {
 return err
 }

 // Export the URLs of the website and serverless endpoint.
 ctx.Export("siteURL", pulumi.Sprintf("https://storage.googleapis.com/%s/index.html", siteBucket.Name))
 ctx.Export("apiURL", dataFunction.HttpsTriggerUrl)

 return nil
 })
}

Here Pulumi is defining your application’s initial configuration values, including the directories it should be checking for your serverless application code and the index and error pages for the website it stands up. It then creates two storage buckets, each with appropriate IAM roles for access, one containing your serverless function and another configured to act like a website. We also have the Cloud Function declaration itself, and all configurations necessary for it, followed by exporting the URL for you.

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure-native";
import * as synced from "@pulumi/synced-folder";

// Import the program's configuration settings.
const config = new pulumi.Config();
const sitePath = config.get("sitePath") || "./www";
const appPath = config.get("appPath") || "./app";
const indexDocument = config.get("indexDocument") || "index.html";
const errorDocument = config.get("errorDocument") || "error.html";

// Create a resource group for the website.
const resourceGroup = new azure.resources.ResourceGroup("resource-group", {});

// Create a blob storage account.
const account = new azure.storage.StorageAccount("account", {
 resourceGroupName: resourceGroup.name,
 kind: azure.storage.Kind.StorageV2,
 sku: {
 name: azure.storage.SkuName.Standard_LRS,
 },
});

// Create a storage container for the pages of the website.
const website = new azure.storage.StorageAccountStaticWebsite("website", {
 accountName: account.name,
 resourceGroupName: resourceGroup.name,
 indexDocument: indexDocument,
 error404Document: errorDocument,
});

// Use a synced folder to manage the files of the website.
const syncedFolder = new synced.AzureBlobFolder("synced-folder", {
 path: sitePath,
 resourceGroupName: resourceGroup.name,
 storageAccountName: account.name,
 containerName: website.containerName,
});

// Create a storage container for the serverless app.
const appContainer = new azure.storage.BlobContainer("app-container", {
 accountName: account.name,
 resourceGroupName: resourceGroup.name,
 publicAccess: azure.storage.PublicAccess.None,
});

// Upload the serverless app to the storage container.
const appBlob = new azure.storage.Blob("app-blob", {
 accountName: account.name,
 resourceGroupName: resourceGroup.name,
 containerName: appContainer.name,
 source: new pulumi.asset.FileArchive(appPath),
});

// Create a shared access signature to give the Function App access to the code.
const signature = azure.storage.listStorageAccountServiceSASOutput({
 resourceGroupName: resourceGroup.name,
 accountName: account.name,
 protocols: azure.storage.HttpProtocol.Https,
 sharedAccessStartTime: "2022-01-01",
 sharedAccessExpiryTime: "2030-01-01",
 resource: azure.storage.SignedResource.C,
 permissions: azure.storage.Permissions.R,
 contentType: "application/json",
 cacheControl: "max-age=5",
 contentDisposition: "inline",
 contentEncoding: "deflate",
 canonicalizedResource: pulumi.interpolate`/blob/${account.name}/${appContainer.name}`,
});

// Create an App Service plan for the Function App.
const plan = new azure.web.AppServicePlan("plan", {
 resourceGroupName: resourceGroup.name,
 sku: {
 name: "Y1",
 tier: "Dynamic",
 },
});

// Create the Function App.
const functionApp = new azure.web.WebApp("function-app", {
 resourceGroupName: resourceGroup.name,
 serverFarmId: plan.id,
 kind: "FunctionApp",
 siteConfig: {
 appSettings: [
 {
 name: "FUNCTIONS_WORKER_RUNTIME",
 value: "node",
 },
 {
 name: "WEBSITE_NODE_DEFAULT_VERSION",
 value: "~14",
 },
 {
 name: "FUNCTIONS_EXTENSION_VERSION",
 value: "~3",
 },
 {
 name: "WEBSITE_RUN_FROM_PACKAGE",
 value: pulumi.all([account.name, appContainer.name, appBlob.name, signature])
 .apply(([accountName, containerName, blobName, signature]) => `https://${accountName}.blob.core.windows.net/${containerName}/${blobName}?${signature.serviceSasToken}`),
 },
 ],
 cors: {
 allowedOrigins: [
 "*"
 ],
 },
 },
});

// Create a JSON configuration file for the website.
const configFile = new azure.storage.Blob("config.json", {
 source: functionApp.defaultHostName
 .apply(host => new pulumi.asset.StringAsset(JSON.stringify({ api: `https://${host}/api` }))),
 contentType: "application/json",
 accountName: account.name,
 resourceGroupName: resourceGroup.name,
 containerName: website.containerName,
});

// Export the URLs of the website and serverless endpoint.
export const siteURL = account.primaryEndpoints.apply(primaryEndpoints => primaryEndpoints.web);
export const apiURL = pulumi.interpolate`https://${functionApp.defaultHostName}/api`;

Here, Pulumi first defines the configuration options for your project, including the directories to look at for your application code and your website, as well as what the index and error documents should be. It then goes on to set up your blob storage account and containers for your website and serverless function, before uploading the serverless function itself with all permissions and configurations necessary to operate.

Extending Templates

In addition to the Pulumi code above, each template includes a simple website that utilizes a provided serverless function to display the current time and date, constantly updating. With only two CLI commands, you have deployed the core infrastructure necessary to get your serverless application online in the cloud, without writing a single line of code yourself.

From here, you’re ready to drop in your own application code. Pulumi has already handled the boring work for you, complying with best practices from the beginning so you only have to worry about building your own application, not how to get the infrastructure online!

Pulumi Architecture Templates exist for a variety of applications and common use-cases, including containerized applications and kubernetes, with more being added over time. Keep an eye out for new additions and ways to make engineering for the cloud less painful!