harness.cloudprovider.Aws

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Harness = Lbrlabs.PulumiPackage.Harness;
using Harness = Pulumi.Harness;

return await Deployment.RunAsync(() => 
{
    var @default = Harness.GetSecretManager.Invoke(new()
    {
        Default = true,
    });

    var awsAccessKey = new Harness.EncryptedText("awsAccessKey", new()
    {
        Value = "<ACCESS_KEY_ID>",
        SecretManagerId = @default.Apply(@default => @default.Apply(getSecretManagerResult => getSecretManagerResult.Id)),
    });

    var awsSecretKey = new Harness.EncryptedText("awsSecretKey", new()
    {
        Value = "<SECRET_KEY_ID>",
        SecretManagerId = @default.Apply(@default => @default.Apply(getSecretManagerResult => getSecretManagerResult.Id)),
    });

    var aws = new Harness.Cloudprovider.Aws("aws", new()
    {
        AccessKeyIdSecretName = awsAccessKey.Name,
        SecretAccessKeySecretName = awsSecretKey.Name,
    });

});

package main

import (
	"github.com/lbrlabs/pulumi-harness/sdk/go/harness"
	"github.com/lbrlabs/pulumi-harness/sdk/go/harness/cloudprovider"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_default, err := harness.GetSecretManager(ctx, &harness.GetSecretManagerArgs{
			Default: pulumi.BoolRef(true),
		}, nil)
		if err != nil {
			return err
		}
		awsAccessKey, err := harness.NewEncryptedText(ctx, "awsAccessKey", &harness.EncryptedTextArgs{
			Value:           pulumi.String("<ACCESS_KEY_ID>"),
			SecretManagerId: *pulumi.String(_default.Id),
		})
		if err != nil {
			return err
		}
		awsSecretKey, err := harness.NewEncryptedText(ctx, "awsSecretKey", &harness.EncryptedTextArgs{
			Value:           pulumi.String("<SECRET_KEY_ID>"),
			SecretManagerId: *pulumi.String(_default.Id),
		})
		if err != nil {
			return err
		}
		_, err = cloudprovider.NewAws(ctx, "aws", &cloudprovider.AwsArgs{
			AccessKeyIdSecretName:     awsAccessKey.Name,
			SecretAccessKeySecretName: awsSecretKey.Name,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.harness.HarnessFunctions;
import com.pulumi.harness.inputs.GetSecretManagerArgs;
import com.pulumi.harness.EncryptedText;
import com.pulumi.harness.EncryptedTextArgs;
import com.pulumi.harness.cloudprovider.Aws;
import com.pulumi.harness.cloudprovider.AwsArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var default = HarnessFunctions.getSecretManager(GetSecretManagerArgs.builder()
            .default_(true)
            .build());

        var awsAccessKey = new EncryptedText("awsAccessKey", EncryptedTextArgs.builder()        
            .value("<ACCESS_KEY_ID>")
            .secretManagerId(default_.id())
            .build());

        var awsSecretKey = new EncryptedText("awsSecretKey", EncryptedTextArgs.builder()        
            .value("<SECRET_KEY_ID>")
            .secretManagerId(default_.id())
            .build());

        var aws = new Aws("aws", AwsArgs.builder()        
            .accessKeyIdSecretName(awsAccessKey.name())
            .secretAccessKeySecretName(awsSecretKey.name())
            .build());

    }
}

import pulumi
import lbrlabs_pulumi_harness as harness
import pulumi_harness as harness

default = harness.get_secret_manager(default=True)
aws_access_key = harness.EncryptedText("awsAccessKey",
    value="<ACCESS_KEY_ID>",
    secret_manager_id=default.id)
aws_secret_key = harness.EncryptedText("awsSecretKey",
    value="<SECRET_KEY_ID>",
    secret_manager_id=default.id)
aws = harness.cloudprovider.Aws("aws",
    access_key_id_secret_name=aws_access_key.name,
    secret_access_key_secret_name=aws_secret_key.name)

import * as pulumi from "@pulumi/pulumi";
import * as harness from "@lbrlabs/pulumi-harness";
import * as harness from "@pulumi/harness";

const default = harness.getSecretManager({
    "default": true,
});
const awsAccessKey = new harness.EncryptedText("awsAccessKey", {
    value: "<ACCESS_KEY_ID>",
    secretManagerId: _default.then(_default => _default.id),
});
const awsSecretKey = new harness.EncryptedText("awsSecretKey", {
    value: "<SECRET_KEY_ID>",
    secretManagerId: _default.then(_default => _default.id),
});
const aws = new harness.cloudprovider.Aws("aws", {
    accessKeyIdSecretName: awsAccessKey.name,
    secretAccessKeySecretName: awsSecretKey.name,
});

resources:
  awsAccessKey:
    type: harness:EncryptedText
    properties:
      value: <ACCESS_KEY_ID>
      secretManagerId: ${default.id}
  awsSecretKey:
    type: harness:EncryptedText
    properties:
      value: <SECRET_KEY_ID>
      secretManagerId: ${default.id}
  aws:
    type: harness:cloudprovider:Aws
    properties:
      accessKeyIdSecretName: ${awsAccessKey.name}
      secretAccessKeySecretName: ${awsSecretKey.name}
variables:
  default:
    fn::invoke:
      Function: harness:getSecretManager
      Arguments:
        default: true