Voting app using Redis and Flask

This example lives in the pulumi/examples repository. Check out just this directory to use it:

$ git clone --filter=blob:none --sparse https://github.com/pulumi/examples pulumi-examples
$ git -C pulumi-examples sparse-checkout set aws-ts-voting-app
$ cd pulumi-examples/aws-ts-voting-app

A simple voting app that uses Redis for a data store and a Python Flask app for the frontend. The example has been ported from https://github.com/Azure-Samples/azure-voting-app-redis.

The example shows how easy it is to deploy containers into production and to connect them to one another. Since the example defines a custom container, Pulumi does the following:

• Builds the Docker image
• Provisions AWS Container Registry (ECR) instance
• Pushes the image to the ECR instance
• Creates a new ECS task definition, pointing to the ECR image definition

Prerequisites#

1. Install Pulumi
2. Configure AWS credentials
3. Install Node.js
4. Install Docker

Deploying the example#

Note: some values in this example will be different from run to run. These values are indicated with ***.

1. Create a new stack:

   pulumi stack init voting-app-testing

2. Set AWS as the provider:

   pulumi config set cloud:provider aws

3. Configure Pulumi to use an AWS region that supports Fargate, which is currently only available in us-east-1, us-east-2, us-west-2, and eu-west-1:

   pulumi config set aws:region us-west-2

4. Set a value for the Redis password. The value can be an encrypted secret, specified with the --secret flag. If this flag is not provided, the value will be saved as plaintext in Pulumi.testing.yaml (since testing is the current stack name).

   pulumi config set --secret redisPassword S3cr37Password

5. Install dependencies:

   npm install

6. Ensure the Docker daemon is running on your machine, then preview and deploy the program with pulumi up. The program deploys 24 resources and takes about 10 minutes to complete.

   pulumi up

7. View the stack output properties. The stack output property frontendURL is the URL and port of the deployed app:

   pulumi stack output frontendURL

   ***.elb.us-west-2.amazonaws.com

8. In a browser, navigate to the URL for frontendURL. You should see the voting app webpage.

   

Cleaning up#

When you’re done, destroy your stack and remove it:

pulumi destroy
pulumi stack rm

About the code#

At the start of the program, the following lines retrieve the value for the Redis password by reading a configuration value. This is the same value that was set above with the command pulumi config set redisPassword <value>:

let config = new pulumi.Config();
let redisPassword = config.require("redisPassword");

In the program, the value can be used like any other variable.

Resources#

The program provisions two top-level resources with the following commands:

let redisCache = new awsx.ecs.FargateService("voting-app-cache", ... )
let frontend = new awsx.ecs.FargateService("voting-app-frontend", ... )

The definition of redisCache uses the image property of FargateService.taskDefinitionArgs to point to an existing Docker image. In this case, this is the image redis at tag alpine on Docker Hub. The redisPassword variable is passed to the startup command for this image.

The definition of frontend is more interesting, as it uses image property of FargateService.taskDefinitionArgs to point to a folder with a Dockerfile, which in this case is a Python Flask app. Pulumi automatically invokes docker build for you and pushes the container to ECR.

So that the frontend container can connect to redisCache, the environment variables REDIS, REDIS_PORT are defined. Using the redisListenre.endpoint property, it’s easy to declare the connection between the two containers.

The Flask app uses these environment variables to connect to the Redis cache container. See the following in frontend/app/main.py:

redis_server =   os.environ['REDIS']
redis_port =     os.environ['REDIS_PORT']
redis_password = os.environ['REDIS_PWD']