Maintaining State in Serverless AI Applications on Azure

Question

Pulumi · Accepted Answer

Maintaining state in serverless applications, including those that involve Artificial Intelligence (AI), is an essential task to ensure consistency, data durability, and reliability. Serverless functions often have a stateless nature, which means they don't natively preserve the data or session information from one execution to the next. To maintain state in such applications, you typically use external storage or databases that are accessible across function invocations.

Azure provides multiple services that can be used to maintain state in serverless AI applications. For example, you can use Azure Cosmos DB for data storage, Azure Blob Storage for large files, or Azure Redis Cache for fast, in-memory data access. Another solution is to integrate with Azure Durable Functions, which is an extension of Azure Functions that lets you write stateful functions in a serverless compute environment.

Below, I will provide a program using Pulumi to create resources for a serverless AI application that needs to maintain state. The program includes creation of:

- An Azure Functions App for hosting serverless functions.
- An Azure Cosmos DB instance for storing and retrieving state across function executions.

This combination allows your AI application to remain stateless in terms of compute while leveraging external services to maintain required state.

```python
import pulumi
import pulumi_azure_native as azure_native
from pulumi_azure_native import resources, storage, web, documentdb

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

# Create an Azure Storage Account for Azure Functions
storage_account = storage.StorageAccount('aistatefulstorage',
    resource_group_name=resource_group.name,
    kind=storage.Kind.STORAGE_V2,
    sku=storage.SkuArgs(
        name=storage.SkuName.STANDARD_LRS,
    )
)

# Create an Azure Function App on a consumption plan (serverless)
app_service_plan = web.AppServicePlan('aistatefulfunctionplan',
    resource_group_name=resource_group.name,
    kind='FunctionApp',
    reserved=True,  # Indicates that this is a Linux server
    sku=web.SkuDescriptionArgs(
        name='Y1',
        tier='Dynamic'
    )
)

function_app = web.WebApp('aistatefulfunctionapp',
    resource_group_name=resource_group.name,
    server_farm_id=app_service_plan.id,
    site_config=web.SiteConfigArgs(
        app_settings=[
            web.NameValuePairArgs(name='FUNCTIONS_WORKER_RUNTIME', value='python'),
            web.NameValuePairArgs(name='AzureWebJobsStorage', value=storage_account.primary_connection_string.apply(lambda c: c)),
            web.NameValuePairArgs(name='WEBSITE_RUN_FROM_PACKAGE', value='1')
        ],
    ),
    https_only=True
)

# Create an Azure Cosmos DB Account for maintaining state
cosmos_db_account = documentdb.DatabaseAccount('aistatefulcosmosdb',
    resource_group_name=resource_group.name,
    database_account_offer_type=documentdb.DatabaseAccountOfferType.STANDARD,
    locations=[
        documentdb.LocationArgs(
            location_name=resource_group.location,
            failover_priority=0,
        )
    ],
    consistency_policy=documentdb.ConsistencyPolicyArgs(
        default_consistency_level=documentdb.DefaultConsistencyLevel.SESSION,
    )
)

# Create a Cosmos DB Database
cosmos_db_database = documentdb.SqlResourceSqlDatabase('aistatefuldb',
    resource_group_name=resource_group.name,
    account_name=cosmos_db_account.name,
    resource=documentdb.SqlDatabaseResourceArgs(
        id='aistatefuldb',
    ),
    options=documentdb.CreateUpdateOptionsArgs(
        throughput=400,
    )
)

# Export the Azure Function App URL and the Cosmos DB endpoint
pulumi.export('function_app_url', function_app.default_host_name.apply(lambda h: f'https://{h}'))
pulumi.export('cosmos_db_endpoint', cosmos_db_account.document_endpoint)
```

In this program:

1. **Resource Group Creation**: An Azure Resource Group is a container that holds related resources for an Azure solution. We create a new resource group named `ai_stateful_rg`.

2. **Azure Storage Account**: Azure Functions require a storage account. Here, we create one that will be used to store the code for the functions and the operational state of the functions themselves.

3. **Azure Function App and App Service Plan**: We deploy an Azure Function App on a consumption plan which is the serverless offering in Azure for executing code without managing infrastructure. The app settings include the runtime (Python) and the connection strings.

4. **Azure Cosmos DB Account and Database**: Azure Cosmos DB is a globally distributed database service that enables you to manage data at scale. It's used here for its ability to manage state in a reliable and scalable way, providing session-level consistency to ensure coherence of data accessed by serverless functions.

5. **Exports**: We expose the Function App URL and Cosmos DB endpoint as stack outputs. These values can be used to interact with the deployed services.

With Pulumi, you can automate deployment of all these components with Python and manage them as part of your Infrastructure as Code practices. This approach is both effective and efficient for managing the state in serverless AI applications on Azure.