Connecting Azure Functions to Azure PostgreSQL for data-driven applications

Question

Pulumi · Accepted Answer

Connecting an Azure Function to an Azure PostgreSQL database involves several steps that ensure your function can communicate securely and effectively with the database to build data-driven applications. Below, I outline these steps and discuss key resources used in the Pulumi infrastructure as code framework to achieve this.

First, you'll need to create a PostgreSQL Server and a database within it. You'll use the `azure-native.dbforpostgresql.Server` and `azure-native.dbforpostgresql.Database` resources to accomplish this. These resources allow you to define the configurations for your PostgreSQL server, such as the version, SKU, and storage settings, as well as create a database within the server.

Second, you'll set up an Azure Function App using the `azure-native.web.WebAppFunction` resource. This resource allows you to define an Azure Function, which is a serverless compute service that enables you to run event-triggered code without having to explicitly provision or manage infrastructure.

The Function will require a connection string to access the PostgreSQL database. To maintain security, store this information in the Application Settings of the Function App as environment variables.

Finally, we'll tie them together by configuring the Azure Function to use the connection string of the PostgreSQL database, which will allow the function to read and write data to the database.

The following is a TypeScript program using Pulumi to provision these resources:

```typescript
import * as pulumi from '@pulumi/pulumi';
import * as azure_native from '@pulumi/azure-native';

// Create an Azure resource group
const resourceGroup = new azure_native.resources.ResourceGroup("resourceGroup");

// Create an Azure PostgreSQL Server
const postgreSqlServer = new azure_native.dbforpostgresql.Server("postgreSqlServer", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    sku: {
        name: "GP_Gen5_2",
    },
    version: "11",
    storageProfile: {
        storageMB: 5120,
    },
    administratorLogin: "postgresadmin",
    administratorLoginPassword: "yourpassword", // Replace with a strong password
});

// Create a PostgreSQL Database within the server
const postgresDatabase = new azure_native.dbforpostgresql.Database("postgresDatabase", {
    resourceGroupName: resourceGroup.name,
    databaseName: "mydatabase",
    serverName: postgreSqlServer.name,
});

// Create an Azure Function App
const functionApp = new azure_native.web.WebAppFunction("httpFunction", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    serverFarmId: "/subscriptions/YOUR_SUBSCRIPTION_ID/resourceGroups/YOUR_RESOURCE_GROUP_NAME/providers/Microsoft.Web/serverfarms/YOUR_APP_SERVICE_PLAN_NAME", // Replace with your App Service Plan ID
    siteConfig: {
        appSettings: [
            {
                name: "WEBSITE_RUN_FROM_PACKAGE", 
                value: "<URL to your function code package>"
            },
            {
                name: "POSTGRES_CONNECTION_STRING",
                value: pulumi.interpolate`Host=${postgreSqlServer.fullyQualifiedDomainName};Username=${postgreSqlServer.administratorLogin};Password=${postgreSqlServer.administratorLoginPassword};Database=${postgresDatabase.name};`
            }
        ]
    },
});

// Export the connection string and the Function App URL
export const connectionString = pulumi.interpolate`Host=${postgreSqlServer.fullyQualifiedDomainName};Username=${postgreSqlServer.administratorLogin};Password=${postgreSqlServer.administratorLoginPassword};Database=${postgresDatabase.name};`;
export const functionAppUrl = functionApp.defaultHostName;
```

In the above program:

- We import the necessary packages from Pulumi's Azure Native provider.
- We initialize a new Azure resource group which acts as a container that holds related resources for an Azure solution.
- We create a PostgreSQL server using `azure_native.dbforpostgresql.Server` where we specify the version, SKU, and the storage profile for the server.
- We follow up with creating a database in the PostgreSQL server using the `azure_native.dbforpostgresql.Database` resource.
- We create an Azure Function app using `azure_native.web.WebAppFunction`. The Function App is configured with the `WEBSITE_RUN_FROM_PACKAGE` setting pointing to a URL where the function code package is located. Replace this with the URL where your package resides.
- Critical part is setting the `POSTGRES_CONNECTION_STRING` in the app settings of the Function App, which will hold the connection string used by the function to communicate with the PostgreSQL database.
- Last but not least, we export the connection string and the Function App URL for easy access.

Replace placeholder values like `yourpassword` with actual secure values and `YOUR_SUBSCRIPTION_ID`, `YOUR_RESOURCE_GROUP_NAME`, and `YOUR_APP_SERVICE_PLAN_NAME` with your real Azure subscription ID, resource group name, and App Service Plan name respectively before running the Pulumi program.

For more detailed information, refer to the links in the code comments that point to the Pulumi Azure documentation for each resource.