Hello, I've written a vpc module that outputs a few pieces of information as Pulumi OutputString. I'm now hoping to pass this information to an instance of an eks module. I am also hoping to do this twice, once for a non-prod enivronment, once for a prod. Here's my current work in progress:

#!/usr/bin/node
import * as vpcModule from "./components/vpc"
import * as eksModule from "./components/eks"
import * as automation from "@pulumi/pulumi/automation";

/**
 * Non-prod configuration
 */
export const nonprodDemoVpcArgs: vpcModule.VpcArgs = {
    description: "Typescript pulumi vpc module non-prod",
    
    instanceTenancy: "default",

    availabilityZones: ["ca-central-1a", "ca-central-1b", "ca-central-1d"],

    vpcCidr: "10.0.0.0/16",
    publicSubnetsCidrs: ["10.0.1.0/24", "10.0.2.0/24"],
    privateSubnetsCidrs: ["10.0.3.0/24", "10.0.4.0/24"],   

    vpcSecurityGroupName: "sg-non-prod",
    
    enableDnsHostnames: true,
    enableDnsSupport: true,

    tags: { "Name": "non-prod-vpc" }
};

export const nonProdEksArgs: eksModule.AsgArgs = {
    // Ec2 Description
    description: "Helloworld non-prod eks cluster",

    vpcId: "",
    publicSubnets: ["subnet-12345678", "subnet-23456789"],
    privateSubnets: ["subnet-34567890", "subnet-45678901"]
}


/**
 * Prod configuration
 */

export const prodDemoVpcArgs: vpcModule.VpcArgs = {
    description: "Typescript pulumi vpc module prod",

    instanceTenancy: "default",

    availabilityZones: ["ca-central-1a", "ca-central-1b", "ca-central-1d"],

    vpcCidr: "192.168.0.0/16",
    publicSubnetsCidrs: ["192.168.1.0/24", "192.168.2.0/24"],
    privateSubnetsCidrs: ["192.168.3.0/24", "192.168.4.0/24"],

    vpcSecurityGroupName: "sg-prod",
    
    enableDnsHostnames: true,
    enableDnsSupport: true,
    
    tags: { "Name": "demo-vpc" }
};

export async function buildNonProd() {
    // Initialize a new workspace
    const projectName = "ts-modular-eks-iac"
    const stackName = "non-prod";
    
    // Create or select non-prod stack
    const nonProdVpc = await automation.LocalWorkspace.createOrSelectStack({
        stackName: stackName,
        projectName: projectName,
        program: async () => {
            // Component resource definition goes here
            new vpcModule.AwsWebVpc("non-prod", nonprodDemoVpcArgs);
        }
    });

    // Up the VPC stack
    await nonProdVpc.up({});

    // Get outputs from VPC stack
    const nonProdVpcOutputs = await nonProdVpc.outputs();

    const nonProdEks = await automation.LocalWorkspace.createOrSelectStack({
        stackName: stackName,
         projectName: projectName,

         program: async () => {
        // Component resource definition goes here
             new eksModule.AwsWebEc2("non-prod", nonProdEksArgs);
             config: vpcId: nonProdVpcOutputs.vpcId
         },
//        config: {
//             "vpcId": { value: nonProdVpcOutputs.vpcId }
//         }
    })

    await nonProdEks.up({});
    
    const nonProdEksOutputs = await nonProdEks.outputs();

//     const nonProdEks = await automation.LocalWorkspace.createOrSelectStack({
//         stackName: stackName,
//         projectName: projectName,

//         program: async () => {
//         // Component resource definition goes here
//             new eksModule.AwsWebEc2("non-prod", nonProdEksArgs);
//         },
//         config: {
//             "vpcId": { value: nonProdVpcOutputs.vpcId }
//         }
// });

    // // Create or select prod stack
    // const prodStack = await automation.LocalWorkspace.createOrSelectStack({
    //     stackName: stackNameProd,
    //     projectName: projectName,
    //     program: async () => {
    //         // Your component resource definition goes here
    //         // Example:
    //         new vpcModule.AwsWebVpc("prod", prodDemoVpcArgs);;
    //     }
    // });
    console.log("Stacks have been updated.");
}

buildNonProd().then(() => console.log("Done!"));
//main().catch(err => console.error(err));

I'm still in the early stages of looking at pulumi so any advice on how to achieve this pattern is most welcome.

The point (for me) of separate projects is to enable you to have different schedules for deploying different groups of resources. So you might want to deploy your VPC resources only once every few months or even years, as they're very stable; and you might want to deploy your EKS module every month or so, if it's under more regular development. Sticking the two projects together into a single automation-api program means that you're deploying them on the same schedule. This might be what you need, but it might also just be adding extra code and complexity for no benefit.

Thankyou 🙂 That's great advice... My requirements are: 1. Deploy a non-prod vpc stack 2. Deploy a non-prod eks stack 3. Deploy a prod vpc stack 4. Deploy a prod eks stack I want stack references between the non-prod-vpc stack and the non-prod-eks stack. The same goes for prod. I want to write the modules so that an application developer, in a different part of the business and unfamilliar to IaC can just consume them by passing infra Could you advise on how this could be best achieved with pulumi?

First, imagine it's a few months from now and the code is working perfectly. Are you likely to want to deploy the EKS stuff much more often than the VPC stuff? If you are, then develop two projects, each with two stacks. Otherwise, develop one project with two stacks.

yes, the vpc and eks configuration are component resources

Then you don't need multiple projects.

which i'm passing interfaces

And since this it Typescript, you don't need interfaces 🙂

so, one project with 4 stacks? 2 nonprod and 2 prod?

This is one of the reasons to leave automation-api until after you understand Pulumi well. So you know about projects and stacks.

That's cool

Good luck. Looking forward to your next question 🙂

haha yes no doubt i'll have some 🙂