ws, err := auto.NewLocalWorkspace(ctx, auto.Project(workspace.Project{
		Name:    tokens.PackageName("..."),
		Runtime: workspace.NewProjectRuntimeInfo("go", nil),,
	}))

…

myorg/myproject

await (await LocalWorkspace.createOrSelectStack({ stackName: 'staging', workDir: infraDir })).getAllConfig()

stderr: error: could not decrypt configuration value: [400] Message authentication failed

error configuring Terraform AWS Provider: AWS account ID not previously found and failed retrieving via all available methods. See <https://www.terraform.io/docs/providers/aws/index.html#skip_requesting_account_id> for workaround

skipRequestingAccountId

stack_config: Dict[str, Any] = {
        "aws:region": ConfigValue(
            "us-east-1"
        )  
    }

    stack_config["aws:skipRequestingAccountId"] = ConfigValue(True)

project_settings = ProjectSettings(
        name=project_name, runtime=project_runtime_info, backend=project_backend
    )
    stack_settings = StackSettings(
        secrets_provider=secrets_provider,
        encrypted_key=encrypted_key,
        config=stack_config,
    )
    workspace_options = LocalWorkspaceOptions(
        secrets_provider=secrets_provider,  # Eli (2/11/22): since secrets_provider is already given in the ProjectSettings, I don't know if it's needed in both places or if just one spot would be better. Unclear at the moment
        project_settings=project_settings,
        stack_settings={stack_name: stack_settings},
    )
    print(f"Stack Config before initialization: {stack_config}")  # allow-print
    stack = create_or_select_stack(
        stack_name,
        project_name=project_name,
        program=pulumi_program,
        opts=workspace_options,
    )

preview

+ pulumi:pulumi:Stack: (create)
    [urn=urn:pulumi:eli-test::my_project::pulumi:pulumi:Stack::my_project-eli-test]
Resources:
    + 1 to create
 stderr: error: could not validate provider configuration: 1 error occurred:
        * Attribute must be a single value, not a map

def pulumi_program() -> None:
    s3.Bucket("bucket")

aws:region

config.require(...)

npm run start

Error: Program run without the Pulumi engine available; re-run using the pulumi CLI

const config = new pulumi.Config()

default_tags

const projectName = "pulumi_over_http";
const createPulumiProgram = (content: string) => async () => {
    // Create a bucket and expose a website index document
    console.log("Resource group creation starts...")
    const resourceGroup = new azure.core.ResourceGroup('rg');
    console.log("Resource group creation ends...")

    console.log("Storage account creation starts...")
    const storage = new azure.storage.Account("storageaccount", {
        accountKind: 'StorageV2',
        accountReplicationType: 'LRS',
        accountTier: 'Standard',
        allowBlobPublicAccess: false,
        location: 'WestEurope',
        name: "storageaccount",
        resourceGroupName: resourceGroup.name,
    });
    console.log("Storage account creation ends...")

    console.log("Storage container creation starts...");
    const container = new azure.storage.Container(
    "storagecontainer",
    {
        containerAccessType: 'blob',
        name: "storagecontainer",
        storageAccountName: storage.name,
    });
    console.log("Storage container creation ends...");

    // Upload the files
    ["index.html", "404.html"].map(name =>
        new azure.storage.Blob(name, {
            contentType: 'text/html',
            // source: `./static/${page.name}`,
            name,
            storageAccountName: storage.name,
            storageContainerName: container.name,
            type: 'Block',
        }),
    );
};

const buildBaseRequestCopy = (
    baseRequest: BaseRequest,
  ) => ({
      ...baseRequest,
      purpose: 'pul',
    });

const init = async (
    kvName: string,
    baseRequest: BaseRequest, 
    stackName: string
) => {
    // await initBasicLocalWorkspaceConfig(kvName, baseRequest.environment, stackName);
    // await initAtlasLocalWorkspaceConfig(kvName, baseRequest.environment, stackName);

    // case AzureEnvVar.AZURE_CLIENT_ID:
    process.env.AZURE_CLIENT_ID = 'XXXXXXXXXXXX';
    process.env.AZURE_CLIENT_SECRET = 'XXXXXXXXXXXX'
    process.env.AZURE_TENANT_ID = 'XXXXXXXXXXXX'
    process.env.AZURE_CLIENT_OBJECT_ID = 'XXXXXXXXXXXX'
}

const baseRequest: BaseRequest = {
    application: 'atl',
    countryCode: '3se',
    domain: 'cld',
    environment: 'dev',
    project: '',
    team: '',
}

const request: AtlasRequest  = {
    ...baseRequest,
};

const baseRequestCopy: BaseRequest = buildBaseRequestCopy(
    baseRequest,
);

const stackName = 'atl-cld-dev-3se';
const kvName = 'hi3gkvpulatlclddev3se';
const strName = 'hi3gstgpulatlclddev3se'
// creates new sites
const createHandler: express.RequestHandler = async (req, res) => {
    const content = req.body.content as string;
    await init(kvName, baseRequestCopy, stackName);
        
    try {
        // create a new stack
        const stack = await LocalWorkspace.createStack({
            // generate our pulumi program on the fly from the POST body
            program: createPulumiProgram(content),
            projectName,
            stackName,
          },
          setLocalWorkspaceOptions(
            projectName,
            stackName,
            kvName,
            strName,
          ),
        );
        await stack.setConfig("azure:region", { value: "west-europe" });
        // deploy the stack, tailing the logs to console
        const upRes = await stack.up({ onOutput: <http://console.info|console.info> });
        res.json({ id: stackName, url: upRes.outputs.websiteUrl.value });
    } catch (e) {
        if (e instanceof StackAlreadyExistsError) {
            res.status(409).send(`stack "${stackName}" already exists`);
        } else {
            res.status(500).send(e);
        }
    }
};

// updates the content for an existing site
const updateHandler: express.RequestHandler = async (req, res) => {
    const stackName = req.params.id;
    const content = req.body.content as string;
    try {
        await init(kvName, baseRequestCopy, stackName);
        // create a new stack
        const stack = await LocalWorkspace.selectStack({
            // generate our pulumi program on the fly from the POST body
            program: createPulumiProgram(content),
            projectName,
            stackName,
          },
          setLocalWorkspaceOptions(
            projectName,
            stackName,
            kvName,
            strName,
          ),
        );
        await stack.setConfig("azure:region", { value: "west-europe" });
        // deploy the stack, tailing the logs to console
        const upRes = await stack.up({ onOutput: <http://console.info|console.info> });
        res.json({ id: stackName, url: upRes.outputs.websiteUrl.value });
    } catch (e) {
        if (e instanceof StackNotFoundError) {
            res.status(404).send(`stack "${stackName}" does not exist`);
        } else if (e instanceof ConcurrentUpdateError) {
            res.status(409).send(`stack "${stackName}" already has update in progress`)
        } else {
            res.status(500).send(e);
        }
    }
};
const ensurePlugins = async () => {
    const ws = await LocalWorkspace.create({});
    await ws.installPlugin("azure", "v4.6.0");
};

// install necessary plugins once upon boot
ensurePlugins();

// configure express
const app = express();
app.use(express.json());

// setup our RESTful routes for our Site resource
<http://app.post|app.post>("/atlas", createHandler);
app.put("/atlas/:id", updateHandler);

// start our http server
// start our http server
app.listen(1337, () => <http://console.info|console.info>("server running on :1337"));

pending_operations

config

pulumi.get_stack()

get_config

get_stack

str

Stack

automation API

const opts = { ...options.Azure('azure'), region: stack.region, resourceGroupName }

export function Azure(
    name: string,
    opts?: CustomResourceOptions,
    providerOptions?: ProviderOptions,
): AzureOptions {
    const subscriptionId = cfg.require('subscriptionId')
    const provider = new azure.Provider(
        name,
        {
            tenantId,
            subscriptionId,
            clientId: cfg.require('clientId'),
            clientSecret: cfg.requireSecret('clientSecret'),
        },
        providerOptions,
    )
    return {
        subscriptionId,
        provider,
        ...opts,
    }
}

error: no resource plugin 'aws-v4.23.0' found in the workspace or on your $PATH, install the plugin using `pulumi plugin install resource aws v4.23.0`

try {
    const stack = await LocalWorkspace.createOrSelectStack({
      stackName: `${organization}/${stackName}`,
      projectName: project,
      program,
    })
    
    await stack.workspace.installPlugin('aws', 'v4.36.0')
    await stack.workspace.installPlugin('kubernetes', 'v3.15.0')
  
    await stack.setAllConfig({ ...configMap })

    const upRes = await stack.up({ onOutput: <http://console.info|console.info> })
    return upRes
  } catch (err) {
    console.log('err in createOrUpdateStack', err)
    throw new Error('err in createOrUpdateStack')
  }`

v4.23.0

'error: PULUMI_ACCESS_TOKEN must be set for login during non-interactive CLI sessions\n'

const stack = await LocalWorkspace.selectStack({
  stackName: `${organization}/${stackName}`,
  projectName: project,
  program: async () => { }, // don't need a program just to get outputs
})

await stack.setAllConfig({ 'PULUMI_ACCESS_TOKEN': 'xxx' })

const outputsRes = await stack.outputs()

Name:         DeveloperRole
Labels:       <http://app.kubernetes.io/managed-by=pulumi|app.kubernetes.io/managed-by=pulumi>
Annotations:  <none>
PolicyRule:
  Resources                    Non-Resource URLs  Resource Names  Verbs
  ---------                    -----------------  --------------  -----
  *                            []                 []              [*]
  *.apps                       []                 []              [*]
  *.autoscaling                []                 []              [*]
  *.batch                      []                 []              [*]
  *.extensions                 []                 []              [*]
  *.policy                     []                 []              [*]
  *.<http://rbac.authorization.k8s.io|rbac.authorization.k8s.io>  []                 []              [*]