Serverless Multi-Model APIs with Azure Functions & Cosmos DB

Question

Pulumi · Accepted Answer

To create a serverless multi-model API using Azure Functions and Cosmos DB, we will follow these steps in our Pulumi code:

1. Set up an Azure Cosmos DB account which provides us with a multi-model database service that can support document, key-value, wide-column, and graph databases.
2. Create a database within the Cosmos DB account.
3. Deploy one or more containers (also known as collections), which are entities that hold data records and execute stored procedures, triggers, and user-defined functions.
4. Set up an Azure Functions App, which is a serverless compute service that allows you to run event-triggered code without having to explicitly provision or manage infrastructure.
5. Create an Azure Function within the App, which will act as an HTTP-triggered endpoint for our API.

Here's a Pulumi program written in Python to achieve this:

```python
import pulumi
from pulumi_azure_native import resources, documentdb, web

# Ensure the Azure provider is configured for our desired region
location = 'East US'

# Create an Azure Resource Group
resource_group = resources.ResourceGroup(
    'resource_group',
    location=location
)

# Create an Azure CosmosDB Account
cosmosdb_account = documentdb.DatabaseAccount(
    'cosmosdb_account',
    account_name='cosmosdbaccount',
    resource_group_name=resource_group.name,
    location=location,
    database_account_offer_type=documentdb.DatabaseAccountOfferType.STANDARD,
    locations=[{
        'location_name': location,
        'failover_priority': 0
    }]
)

# Create a SQL Database within the CosmosDB Account
database = documentdb.SqlResourceSqlDatabase(
    'sql_database',
    account_name=cosmosdb_account.name,
    database_name='apidatabase',
    resource_group_name=resource_group.name
)

# Create a SQL Container (Collection) within our Database
container = documentdb.SqlResourceSqlContainer(
    'sql_container',
    account_name=cosmosdb_account.name,
    database_name=database.name,
    resource_group_name=resource_group.name,
    container_name='datacontainer',
    resource=documentdb.SqlContainerResourceArgs(
        id='containerId1',
        partition_key=documentdb.ContainerPartitionKeyArgs(
            paths=['/partitionKey'],
            kind='Hash'
        )
    )
)

# Create an Azure Functions App Service Plan
app_service_plan = web.AppServicePlan(
    'function_app_service_plan',
    resource_group_name=resource_group.name,
    location=location,
    kind='FunctionApp',
    sku=web.SkuDescriptionArgs(
        tier='Dynamic',
        name='Y1'
    )
)

# Create an Azure Function App
function_app = web.WebApp(
    "function_app",
    resource_group_name=resource_group.name,
    location=location,
    server_farm_id=app_service_plan.id,
    kind='functionapp',
    site_config=web.SiteConfigArgs(
        app_settings=[
            web.NameValuePairArgs(name="AzureWebJobsStorage", value=cosmosdb_account.primary_master_key.apply(lambda key: f"DefaultEndpointsProtocol=https;AccountName={cosmosdb_account.name};AccountKey={key};EndpointSuffix=core.windows.net")),
            web.NameValuePairArgs(name="FUNCTIONS_EXTENSION_VERSION", value="~3"),
        ],
    )
)

# Export the connection string for Cosmos DB and the endpoint for the Azure Function
pulumi.export('cosmosdb_connection_string', cosmosdb_account.connection_strings)
pulumi.export('function_app_endpoint', function_app.default_host_name.apply(lambda endpoint: f"https://{endpoint}"))
```

In the given program:

- We start by creating a new Azure resource group in the East US region to hold all the resources we're provisioning. 
- We then provision a new Azure Cosmos DB account tailored for our APIs, capable of hosting SQL (Core), MongoDB, Cassandra, Gremlin, and Table APIs.
- Next, we create a new SQL database within the Cosmos DB account to keep our data.
- We also set up a container with a partition key that will be used for distributing our data across multiple partitions for scalability.
- An App Service Plan for Azure Functions is defined next; we use the `Y1` dynamic plan suitable for serverless workloads.
- We then deploy an Azure Functions app tied to the created plan. The `app_settings` for the function app are configured to connect to the Cosmos DB account.
- Finally, we export relevant outputs, such as the connection string for the Cosmos DB account and the HTTP endpoint for the Azure Function, which we would then use to interact with our serverless API.

This program lays out the infrastructure needed for a serverless API leveraging Azure Functions and Cosmos DB. It is ready to run in a Pulumi environment. After deployment, you can develop the API logic within Azure Functions to interact with Cosmos DB and provide the desired API responses.