are there resources to get started contributing? I would like to get some more insight 🙂 love the project so far ❤️

Hi Team, I'm having issues while pulumi up with the auto generated requirements.txt file, can you please provide solution for this: pulumipulumiStack (Pulumi-latest-dev):     error: an unhandled error occurred: Program exited with non-zero exit code: 3221225781 error: installing dependencies via `pip install -r requirements.txt`: exit status 3221225781

I sent my first PR over the weekend, which allows using awsx load balancers across projects. https://github.com/pulumi/pulumi-awsx/pull/548. I'm totally blocked on adopting Pulumi by this issue, so would love if anyone's able to give it a look!

Hey everyone! Created a minor PR https://github.com/pulumi/pulumi/pull/5177 🙂 appreciate it if anyone could have a look at it

Is there a documentation of the http API? Anyone ever created a http backend besides api.pulumi.com?

Kia ora! could someone give https://github.com/pulumi/pulumi/pull/5191 a glance? Much appreciated! 🙏

Hi, I'm rather new to pulumi and want to learn more about pulumi. I noticed there is a

pulumi-language

process and wondering what it is for ?

i have a verbose log related to https://github.com/pulumi/pulumi/issues/2713 - where can i post it privately?

Hello, the Azure nextgen provider is based on a code generation build setup, starting from the Azure specs. Is anything of this code generation setup publicly accessible? The XenAPI specs are published too: https://github.com/xapi-project/xapi-project.github.io/tree/master/_data (xenapi.json) The reason I’m asking is that I’m interested in creating a XenAPI provider (to manage a home lab server).

Any specific reason that in

make prepare

of the tf-bridge, only in

provider/go.mod

the module name is replaced with

REPOSITORY

, but not in

scripts/go.mod

,

examples/go.mod

and

sdk/go.mod

? https://github.com/pulumi/pulumi-tf-provider-boilerplate/blob/master/Makefile#L37-L46

for development purpose how can I use the client with an http connection? Do you force https now? why?

How can I build pulumi-kubernetes? CONTRIBUTING.md says I should run

make ensure

, but I get the error

make: pulumictl: Command not found

make: pulumictl: Command not found

make: pulumictl: Command not found

make: * No rule to make target 'ensure'. Stop.

realized i asked this in the wrong channel. i think this would go along with the crossguard “product line” https://pulumi-community.slack.com/archives/CRH5ENVDX/p1603219176217400

The Python and C# implementations of Automation API are a great contribution opportunity. We are planning on picking this work up in the next few weeks, but if anyone is interested in taking a crack at it in the meantime, we're offering to provide a bunch of support throughout the process. See this message with links to the issues for more info: https://pulumi-community.slack.com/archives/C019YSXN04B/p1603520525076100

Any hint where I can extend the Amazon MQ type from

[ActiveMQ]

to

[ActiveMQ, RabbitMQ]

?

did not find the specification of this type

@bored-oyster-3147 👋 This is probably the best place for us to discuss Automation API C# related contribution questions

Hey folks 👋 I am interested in working on this issue https://github.com/pulumi/pulumi/issues/5506 Should the PR include implementation for all of the languages? I am using Typescript/Nodejs so thats what I am interested in most.

I'm trying to use the Vault provider and create a Policy object. It looks like it currently only supports an HCL formatted string, despite Vault being able to handle the equivalent JSON. I found this issue (https://github.com/pulumi/pulumi-vault/issues/10) asking about supporting an object (or even a JSON formatted string). Does anyone have pointers on steps to add that capability?

👋 @bored-oyster-3147 another community member is interested in contributing to the C# Automation API effort. Meet @tall-needle-56640 👋 Are there any areas where you feel like there are opportunities to collaborate or parallelize? Perhaps looking into inline programs and implementation of the gRPC language server as I know you said you might not get to that part of the implementation in your first pass.

Gonna make a new thread @lemon-agent-27707 - thoughts on this: The StackSettings object has a property

IDictionary<string, StackSettingsConfigValue> Config { get; }

. The

StackSettingsConfigValue

looks like:

{
    string? ValueString,
    IDictionary<string, object>? ValueObject,
    bool IsSecure,
    bool IsObject
}

This allows us to deserialize a structured object provided to stack settings config in a shape that isn't known at compile time. There is a catch though. Since both

System.Text.Json

and

YamlDotNet

deserialize to a dictionary differently, the compile-time type of

ValueObject

must remain

Dictionary<string, object>

in order to support both formats, since we don't want JSON or YAML to be exposed on

StackSettingsConfigValue

. But the runtime-type will be different depending on what format we are deserializing. Coming from JSON with

System.Text.Json

, the type of

TValue

at runtime will always be

JsonElement

. For good measure I tried

Newtonsoft.Json

, and this library tries to determine the type if it is a primitive, but only at the first level of depth. So if the property is a .NET primitive it will be that type - I tried and got

long

or

double

for numbers depending on if there is a decimal, as well as

bool

&

string

. But if the property is itself an object, than rather than getting another nested

Dictionary

you instead receive Newtonsoft's type

JObject

. Coming from YAML with

YamlDotNet

, the type of

TValue

at runtime is always a

string

, but it will break apart nested objects. So you receive either

string

or

Dictionary<string, string>

depending on if the property itself is an object. So questions, are we OK with this implementation? Are we OK with the runtime type being different depending on which format we're deserializing from? Do we prefer Newtonsoft's method over System.Text.Json? Honestly I prefer System.Text.Json's just because it is consistent across all depths, but it does mean that the json-specific Type is exposed right away (at runtime).

@lemon-agent-27707 I'm still a little confused about the need for gRPC. Why are we creating a stack, spinning up a server, running the Pulumi CLI, which then calls the server, which executes code in the same codebase? What is the Pulumi CLI doing that we can't just skip gRPC altogether?

Hey! Thank you guys for the work you do with Pulumi, I’m really enjoying working with it. I’m trying to generate a provider for Rundeck, and I had a question. I’m following this (the pulumi-tf-provider-boilerplate). I’m especially confused about the plugin (perhaps because publishing an NPM library on a private registry is something we do all the time. Moving forward with the plugin isn’t super clear). The

make build_sdks

command generates an npm library and a binary plugin. I can see the plugin:

$ pulumi plugin ls | grep rundeck
rundeck     resource  0.2.0                            40 MB   2 weeks ago    2 weeks ago

But now — how do I actually get this deployed somewhere so that it’s usable in a production environment? Here’s my fork of the

pulumi-tf-provider-boilerplate

, after having followed all the steps. Any ideas?

Hey guys! Quick question - What’s the difference between a resource and a data source? I’m thinking specifically in the pulumi-tf-provider-boilerplate project, in

provider/resources.go

Resources:            map[string]*tfbridge.ResourceInfo{
			// Map each resource in the Terraform provider to a Pulumi type. Two examples
			// are below - the single line form is the common case. The multi-line form is
			// needed only if you wish to override types or other default options.
			//
			// "aws_iam_role": {Tok: makeResource(mainMod, "IamRole")}
			//
			// "aws_acm_certificate": {
			// 	Tok: makeResource(mainMod, "Certificate"),
			// 	Fields: map[string]*tfbridge.SchemaInfo{
			// 		"tags": {Type: makeType(mainPkg, "Tags")},
			// 	},
			// },
		},
		DataSources: map[string]*tfbridge.DataSourceInfo{
			// Map each resource in the Terraform provider to a Pulumi function. An example
			// is below.
			// "aws_ami": {Tok: makeDataSource(mainMod, "getAmi")},
		},

so @lemon-agent-27707 having issues with deserialization again. After a stack runs an UP command, it hits the CLI with

stack output --json

in order to get the latest outputs. Specifically this function:

async outputs(): Promise<OutputMap> {
    await this.workspace.selectStack(this.name);
    // TODO: do this in parallel after this is fixed <https://github.com/pulumi/pulumi/issues/6050>
    const maskedResult = await this.runPulumiCmd(["stack", "output", "--json"]);
    const plaintextResult = await this.runPulumiCmd(["stack", "output", "--json", "--show-secrets"]);
    const maskedOuts = JSON.parse(maskedResult.stdout);
    const plaintextOuts = JSON.parse(plaintextResult.stdout);
    const outputs: OutputMap = {};

    for (const [key, value] of Object.entries(plaintextOuts)) {
        const secret = maskedOuts[key] === secretSentinel;
        outputs[key] = { value, secret };
    }

    return outputs;
}

I'm willing to take any suggestions on how you'd like to accomplish this same result in .NET, since we can't simply assign arbitrary JSON to an anonymous object and have it typed such that we can iterate over the properties to build the resulting dictionary. I would consider just returning the JSON and letting the consumer deal with it and whatever they want to do with it. But that means you're losing the

IsSecret

boolean on your output map as well, because we would only be able to return either plaintext or masked.

Hey guys! Quick question about dynamic providers. In the docs, it says you should only consider implementing a dynamic provider in this case:

You need to manage a cloud resource that doesn’t have provider support, and you expect to only use it from within one program. If you expect to use it from many programs, and in many languages, implementing a full provider is preferable.

Why is that? From my point of view, if there’s a fairly simple set of resources we’ll be interacting with, even if we do it in many pulumi projects across our organization, using a dynamic provider that we distribute as an NPM library seems simpler than implementing a full provider. This is partly because we don’t feel too confident implementing a full provider. Like what would we do in that case? Create a Terraform provider and then use that to generate a Pulumi provider? Cuz that does not seem easier than implementing a dynamic provider. Note that we only care about having a nodejs sdk

@lemon-agent-27707 @tall-librarian-49374 @tall-needle-56640 alright the stack lifecycle operations are now implemented here . Would like to see some tests written but I'm not sure how you guys run tests for pulumi stacks? Anything else you'd like to see in this PR before publishing it for review? I believe it has everything except the: • workspace cancel/import/export • remote program support

Are there any tutorials on how to create a custom resource (not component)? Some small example I can look at?

ok btw @tall-librarian-49374 & @lemon-agent-27707 - The Automation API PR has been split into 2 PRs. The Automation API PR now contains only the automation API additions and does not touch deployment concurrency. The Automation API has also been split into a separate assembly and a separate test assembly. The changes necessary for deployment concurrency have been pulled out into a new PR so that it may be reviewed independently.

Can someone retry the tests on this? I don’t think the failure is related to the PR 🙂 https://github.com/pulumi/pulumi-kubernetes/pull/1429