bitwarden.getItemSecureNote

import * as pulumi from "@pulumi/pulumi";
import * as bitwarden from "@pulumi/bitwarden";
import * as kubernetes from "@pulumi/kubernetes";

const vpnPresharedKey = bitwarden.getItemSecureNote({
    search: "VPN/Pre-sharedSecret",
});
// Example of usage of the data source:
const presharedKey = new kubernetes.index.Kubernetes_secret("presharedKey", {
    metadata: [{
        name: "vpn-preshared-key",
    }],
    data: {
        "private.key": vpnPresharedKey.notes,
    },
});

import pulumi
import pulumi_bitwarden as bitwarden
import pulumi_kubernetes as kubernetes

vpn_preshared_key = bitwarden.get_item_secure_note(search="VPN/Pre-sharedSecret")
# Example of usage of the data source:
preshared_key = kubernetes.index.Kubernetes_secret("presharedKey",
    metadata=[{
        name: vpn-preshared-key,
    }],
    data={
        private.key: vpn_preshared_key.notes,
    })

package main

import (
	"github.com/pulumi/pulumi-kubernetes/sdk/go/kubernetes"
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/bitwarden/bitwarden"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		vpnPresharedKey, err := bitwarden.LookupItemSecureNote(ctx, &bitwarden.LookupItemSecureNoteArgs{
			Search: pulumi.StringRef("VPN/Pre-sharedSecret"),
		}, nil)
		if err != nil {
			return err
		}
		// Example of usage of the data source:
		_, err = kubernetes.NewKubernetes_secret(ctx, "presharedKey", &kubernetes.Kubernetes_secretArgs{
			Metadata: []map[string]interface{}{
				map[string]interface{}{
					"name": "vpn-preshared-key",
				},
			},
			Data: map[string]interface{}{
				"private.key": vpnPresharedKey.Notes,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Bitwarden = Pulumi.Bitwarden;
using Kubernetes = Pulumi.Kubernetes;

return await Deployment.RunAsync(() => 
{
    var vpnPresharedKey = Bitwarden.GetItemSecureNote.Invoke(new()
    {
        Search = "VPN/Pre-sharedSecret",
    });

    // Example of usage of the data source:
    var presharedKey = new Kubernetes.Index.Kubernetes_secret("presharedKey", new()
    {
        Metadata = new[]
        {
            
            {
                { "name", "vpn-preshared-key" },
            },
        },
        Data = 
        {
            { "private.key", vpnPresharedKey.Apply(getItemSecureNoteResult => getItemSecureNoteResult.Notes) },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.bitwarden.BitwardenFunctions;
import com.pulumi.bitwarden.inputs.GetItemSecureNoteArgs;
import com.pulumi.kubernetes.kubernetes_secret;
import com.pulumi.kubernetes.Kubernetes_secretArgs;
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 vpnPresharedKey = BitwardenFunctions.getItemSecureNote(GetItemSecureNoteArgs.builder()
            .search("VPN/Pre-sharedSecret")
            .build());

        // Example of usage of the data source:
        var presharedKey = new Kubernetes_secret("presharedKey", Kubernetes_secretArgs.builder()
            .metadata(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .data(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
            .build());

    }
}

resources:
  # Example of usage of the data source:
  presharedKey:
    type: kubernetes:kubernetes_secret
    properties:
      metadata:
        - name: vpn-preshared-key
      data:
        private.key: ${vpnPresharedKey.notes}
variables:
  vpnPresharedKey:
    fn::invoke:
      function: bitwarden:getItemSecureNote
      arguments:
        search: VPN/Pre-sharedSecret

function getItemSecureNote(args: GetItemSecureNoteArgs, opts?: InvokeOptions): Promise<GetItemSecureNoteResult>
function getItemSecureNoteOutput(args: GetItemSecureNoteOutputArgs, opts?: InvokeOptions): Output<GetItemSecureNoteResult>

def get_item_secure_note(filter_collection_id: Optional[str] = None,
                         filter_folder_id: Optional[str] = None,
                         filter_organization_id: Optional[str] = None,
                         id: Optional[str] = None,
                         search: Optional[str] = None,
                         opts: Optional[InvokeOptions] = None) -> GetItemSecureNoteResult
def get_item_secure_note_output(filter_collection_id: Optional[pulumi.Input[str]] = None,
                         filter_folder_id: Optional[pulumi.Input[str]] = None,
                         filter_organization_id: Optional[pulumi.Input[str]] = None,
                         id: Optional[pulumi.Input[str]] = None,
                         search: Optional[pulumi.Input[str]] = None,
                         opts: Optional[InvokeOptions] = None) -> Output[GetItemSecureNoteResult]

func LookupItemSecureNote(ctx *Context, args *LookupItemSecureNoteArgs, opts ...InvokeOption) (*LookupItemSecureNoteResult, error)
func LookupItemSecureNoteOutput(ctx *Context, args *LookupItemSecureNoteOutputArgs, opts ...InvokeOption) LookupItemSecureNoteResultOutput

public static class GetItemSecureNote 
{
    public static Task<GetItemSecureNoteResult> InvokeAsync(GetItemSecureNoteArgs args, InvokeOptions? opts = null)
    public static Output<GetItemSecureNoteResult> Invoke(GetItemSecureNoteInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetItemSecureNoteResult> getItemSecureNote(GetItemSecureNoteArgs args, InvokeOptions options)
public static Output<GetItemSecureNoteResult> getItemSecureNote(GetItemSecureNoteArgs args, InvokeOptions options)

fn::invoke:
  function: bitwarden:index/getItemSecureNote:getItemSecureNote
  arguments:
    # arguments dictionary