Streamlining Dev/Staging/Production Deployment Variables

Question

Pulumi · Accepted Answer

When managing deployments across different environments such as development, staging, and production, it's crucial to have a system that allows you to separate and manage the configurations for each environment efficiently. In Pulumi, you can achieve this by defining separate stacks for each environment and using environment-specific variables to configure resources accordingly.

Here’s how you can approach this with Pulumi:

1. **Define Separate Stacks for Each Environment**: Create different Pulumi stacks for your development, staging, and production environments. This allows you to maintain separate state files for each environment and avoids interference between them.

2. **Use Configuration Values**: Pulumi's configuration system lets you define environment-specific variables that can be used in your code. These values are defined in the `Pulumi.<stack-name>.yaml` file for each stack.

3. **Abstract Common Resources**: Write your Pulumi program to use these configuration values to determine the environment-specific settings like domain names, instance sizes, etc.

Now, let’s go through the actual Pulumi program in TypeScript.

```typescript
import * as pulumi from "@pulumi/pulumi";

// Set up a Pulumi configuration to read environment-specific variables.
const config = new pulumi.Config();

// For example, you might retrieve a domain name that should only be used in this environment.
const domainName = config.require("domainName");

// ... Additional variables for resources like database connection strings, API keys, etc.

// Rest of your infrastructure code goes here. For instance, creating a static website:

import * as aws from "@pulumi/aws";

const siteBucket = new aws.s3.Bucket("siteBucket", {
    website: {
        indexDocument: "index.html",
    },
});

// Output the bucket name and endpoint
export const bucketName = siteBucket.bucket;
export const websiteUrl = siteBucket.websiteEndpoint;

// Now, based on the domainName variable we fetched from the configuration,
// you can set up additional resources that may differ between environments, such as DNS records.

// Remember that for each environment (dev/staging/production),
// you will run `pulumi up` within that respective stack which has its own configuration file.

```

To manage different environment configurations, you'll create Pulumi configuration files named `Pulumi.dev.yaml`, `Pulumi.staging.yaml`, and `Pulumi.production.yaml`. Each of these will hold the respective variables needed for the environment.

For example, inside `Pulumi.dev.yaml` you might have:

```yaml
config:
  aws:region: us-west-2
  myproject:domainName: dev.example.com
```

While in `Pulumi.production.yaml`, you might have:

```yaml
config:
  aws:region: us-west-2
  myproject:domainName: www.example.com
```

When you run `pulumi up`, Pulumi automatically uses the correct set of configurations based on the currently selected stack.

Make sure to select the correct stack before deploying your infrastructure:

```
pulumi stack select dev
pulumi up
```

Replace `dev` with `staging` or `production` accordingly.

This way, you can effortlessly switch between different configurations and deploy to many environments without changing your actual infrastructure code. This streamlines the management of your infrastructure and keeps environment configurations isolated and secure.