Continuous Deployment for AI Applications with AWS App Runner

Question

Pulumi · Accepted Answer

Continuous deployment is a software engineering practice where code changes are automatically prepared, tested, and released to production. AWS App Runner is a service that makes it easy for developers to quickly deploy containerized web applications and APIs, at scale and with no prior infrastructure experience required.

For an AI application, continuous deployment entails setting up a CI/CD pipeline to automate the deployment of the application upon new commits to a source repository. AWS App Runner supports this by integrating with source code repositories like GitHub and allowing for automatic deployments whenever a new commit is pushed to the linked repository branch.

Below is a Pulumi Python program that sets up continuous deployment for an AI application with AWS App Runner. This program does the following:

1. It creates an AWS App Runner service which points to a repository containing the AI application's code.
2. It specifies an automatic deployment trigger tied to the main branch of the repository.
3. It defines the necessary configurations for building and running the application, such as the runtime and environment variables.

Here is the Pulumi program in Python:

```python
import pulumi
import pulumi_aws_native as aws_native

# Define the AWS App Runner Service.
app_runner_service = aws_native.apprunner.Service(
    "aiApplicationService",
    tags={
        "Environment": "production",
        "Project": "AIApp"
    },
    serviceName="AIApplicationService",
    sourceConfiguration={
        "codeRepository": {
            "repositoryUrl": "https://github.com/your-repository-url", # Replace with your repository URL
            "sourceCodeVersion": {
                "type": "BRANCH",
                "value": "main" # Replace with the branch you want to deploy from
            },
            "codeConfiguration": {
                "configurationSource": "API",
                "codeConfigurationValues": {
                    "runtime": "python3", # Specify the runtime for your AI application
                    "buildCommand": "pip install -r requirements.txt", # A command to build your application
                    "startCommand": "python app.py" # The command to start your AI application
                    # Add any environment variables or secrets required by your AI application here
                    # "runtimeEnvironmentVariables": [
                    #     {"name": "ENV_VARIABLE_NAME", "value": "value"}
                    # ],
                }
            },
            # If private repo, provide connection ARN and other details
            # "authenticationConfiguration": {
            #     "connectionArn": "Connection ARN here"
            # }
        },
        "autoDeploymentsEnabled": True # Enable automatic deployments
    },
    # Define your instance configuration, network, health checks, and observability if needed.
    # instanceConfiguration={
    #     "cpu": "1024", # CPU in units (1024 units = 1 vCPU)
    #     "memory": "2048" # Memory in MB
    # },
    # Add any other configuration as required
)

# Export the Service ID and URL of the App Runner Application
pulumi.export('service_id', app_runner_service.serviceId)
pulumi.export('service_url', app_runner_service.serviceUrl)
```

Explanation:

- `aws_native.apprunner.Service`: This resource creates a new App Runner service. We provide it with a set of configurations that describe how to build and run the application. Among other things, this includes the location of the source code, the runtime environment, and the commands to build and start the application.
- `sourceConfiguration`: This defines where to find the source code and how to build and deploy it. We're pointing it to a `codeRepository` which should be your AI application's repository.
- `autoDeploymentsEnabled`: By setting this to `True`, we enable continuous deployment. App Runner will watch the specified branch and automatically deploy new commits.
- `pulumi.export`: We're exporting the service ID and URL, so you can easily retrieve them from the Pulumi stack after deployment.

To run this program:

1. Install Pulumi and set up AWS access.
2. Create a new Pulumi project and configure it for the Python language.
3. Replace the placeholders for the repository URL and branch with your actual details.
4. Add additional environment variables or configuration as required for your AI application.
5. Run `pulumi up` to launch the infrastructure.

Make sure your AWS credentials are configured correctly and you have the permissions to create App Runner services. Additionally, ensure that the build and start commands are accurate for your AI application.