No matter how you like to participate in developer communities, Pulumi wants to meet you there. If you want to meet other Pulumi users to share use-cases and best practices, contribute code or documentation, see us at an event, or just tell a story about something cool you did with Pulumi, you are part of our community.

Pulumi Community

That's because `map` is not an `pulumi.Input`
Also since you've got the keys of the map as strings why don't just use `string`?
Then to iterate over it after using `pulumi.Map` for the type and `string` for the key I get
```util.go:110:28: cannot use KeyPairExport{…} (value of type KeyPairExport) as pulumi.Input value in assignment: KeyPairExport does not implement pulumi.Input (missing method ElementType)```
As `KeyPairExport` again is not an `Input` , so maybe marshalling to json is acceptable? Not sure about a better way

```	type KeyPairExport struct {
		KeyName pulumi.StringOutput `pulumi:"key_name"`
		Id      pulumi.StringOutput `pulumi:"id"`
	}

	pairResources := pulumi.Map{}
	for _, kp := range keyPairs {
		nkp, _ := ec2.NewKeyPair(ctx, kp.Name, &amp;ec2.KeyPairArgs{
			KeyName:   pulumi.String(environment + "-key-pair-" + kp.Name),
			PublicKey: pulumi.String("ssh-rsa key"),
		})
		pairResources[kp.Name] = pulumi.JSONMarshal(KeyPairExport{
			KeyName: nkp.KeyName,
			Id:      nkp.KeyPairId,
		})

	}

	ctx.Export("key-pairs", pairResources)```
at least this compiles.

Unfortunately, it doesn't work:
```error: an unhandled error occurred: program failed:
waiting for RPCs: json: error calling MarshalJSON for type pulumi.StringOutput: Outputs can not be marshaled to JSON```

The error happens in this line:
```ctx.Export("key-pairs", pairResources)```
If I comment it - everything works.

Well, true that, it even says so in the doc
&gt; The Pulumi Go SDK does not currently support serializing or deserializing maps with unknown values.
How about
```pairResources[kp.Name] = pulumi.Sprintf("%s:%s", nkp.KeyName, nkp.KeyPairId)```
?

In this case I have string instead of map.
I'd like to keep map to properly process resources with StackReference.

I have this solution now:
```			pairResources[kp.Name] = pulumi.All(nkp.KeyName, nkp.KeyPairId).ApplyT(func(v []any) KeyPairExport {
				return KeyPairExport{
					KeyName: v[0].(string),
					Id:      v[1].(string),
				}
			})```
But not sure if it's a good solution..

But I see what you're trying to do,
sorry might not fit into your use case but why not use <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Connect-using-EC2-Instance-Connect.html>?  (and <https://github.com/springload/aws-ssh> to simplify connecting). So that ssh problem totally goes away :slightly_smiling_face:

It doesn't help a lot as key-pair is just an example - I have for example EKS cluster with many worker nodes divided by labels - they need specific configuration.
But thank you very much the links - it could be very useful anyway :slightly_smiling_face:

If someone will be interested in the solution - I fixed it with this code:
```		pairResources := pulumi.StringMapMap{}
		for _, kp := range keyPairs {
			nkp, _ := ec2.NewKeyPair(ctx, kp.Name, &amp;ec2.KeyPairArgs{
				KeyName:   pulumi.String(environment + "-key-pair-" + kp.Name),
				PublicKey: pulumi.String(kp.PublicKey),
				Tags:      tags,
			})

			pairResources[kp.Name] = pulumi.StringMap{
				"key_name":    nkp.KeyName,
				"key_pair_id": nkp.KeyPairId,
			}
		}
		ctx.Export("key-pairs", pairResources)```
The main idea - the correct datatype is `StringMapMap`