azure.keyvault.getEncryptedValue

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;

return await Deployment.RunAsync(() => 
{
    var exampleKeyVault = Azure.KeyVault.GetKeyVault.Invoke(new()
    {
        Name = "mykeyvault",
        ResourceGroupName = "some-resource-group",
    });

    var exampleKey = Azure.KeyVault.GetKey.Invoke(new()
    {
        Name = "some-key",
        KeyVaultId = exampleKeyVault.Apply(getKeyVaultResult => getKeyVaultResult.Id),
    });

    var encrypted = Azure.KeyVault.GetEncryptedValue.Invoke(new()
    {
        KeyVaultKeyId = azurerm_key_vault_key.Test.Id,
        Algorithm = "RSA1_5",
        PlainTextValue = "some-encrypted-value",
    });

    return new Dictionary<string, object?>
    {
        ["id"] = data.Azurerm_key_vault_encrypted_value.Example.Encrypted_data,
    };
});

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/keyvault"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleKeyVault, err := keyvault.LookupKeyVault(ctx, &keyvault.LookupKeyVaultArgs{
			Name:              "mykeyvault",
			ResourceGroupName: "some-resource-group",
		}, nil)
		if err != nil {
			return err
		}
		_, err = keyvault.LookupKey(ctx, &keyvault.LookupKeyArgs{
			Name:       "some-key",
			KeyVaultId: exampleKeyVault.Id,
		}, nil)
		if err != nil {
			return err
		}
		_, err = keyvault.GetEncryptedValue(ctx, &keyvault.GetEncryptedValueArgs{
			KeyVaultKeyId:  azurerm_key_vault_key.Test.Id,
			Algorithm:      "RSA1_5",
			PlainTextValue: pulumi.StringRef("some-encrypted-value"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("id", data.Azurerm_key_vault_encrypted_value.Example.Encrypted_data)
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.keyvault.KeyvaultFunctions;
import com.pulumi.azure.keyvault.inputs.GetKeyVaultArgs;
import com.pulumi.azure.keyvault.inputs.GetKeyArgs;
import com.pulumi.azure.keyvault.inputs.GetEncryptedValueArgs;
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 exampleKeyVault = KeyvaultFunctions.getKeyVault(GetKeyVaultArgs.builder()
            .name("mykeyvault")
            .resourceGroupName("some-resource-group")
            .build());

        final var exampleKey = KeyvaultFunctions.getKey(GetKeyArgs.builder()
            .name("some-key")
            .keyVaultId(exampleKeyVault.applyValue(getKeyVaultResult -> getKeyVaultResult.id()))
            .build());

        final var encrypted = KeyvaultFunctions.getEncryptedValue(GetEncryptedValueArgs.builder()
            .keyVaultKeyId(azurerm_key_vault_key.test().id())
            .algorithm("RSA1_5")
            .plainTextValue("some-encrypted-value")
            .build());

        ctx.export("id", data.azurerm_key_vault_encrypted_value().example().encrypted_data());
    }
}

import pulumi
import pulumi_azure as azure

example_key_vault = azure.keyvault.get_key_vault(name="mykeyvault",
    resource_group_name="some-resource-group")
example_key = azure.keyvault.get_key(name="some-key",
    key_vault_id=example_key_vault.id)
encrypted = azure.keyvault.get_encrypted_value(key_vault_key_id=azurerm_key_vault_key["test"]["id"],
    algorithm="RSA1_5",
    plain_text_value="some-encrypted-value")
pulumi.export("id", data["azurerm_key_vault_encrypted_value"]["example"]["encrypted_data"])

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";

const exampleKeyVault = azure.keyvault.getKeyVault({
    name: "mykeyvault",
    resourceGroupName: "some-resource-group",
});
const exampleKey = exampleKeyVault.then(exampleKeyVault => azure.keyvault.getKey({
    name: "some-key",
    keyVaultId: exampleKeyVault.id,
}));
const encrypted = azure.keyvault.getEncryptedValue({
    keyVaultKeyId: azurerm_key_vault_key.test.id,
    algorithm: "RSA1_5",
    plainTextValue: "some-encrypted-value",
});
export const id = data.azurerm_key_vault_encrypted_value.example.encrypted_data;

variables:
  exampleKeyVault:
    fn::invoke:
      Function: azure:keyvault:getKeyVault
      Arguments:
        name: mykeyvault
        resourceGroupName: some-resource-group
  exampleKey:
    fn::invoke:
      Function: azure:keyvault:getKey
      Arguments:
        name: some-key
        keyVaultId: ${exampleKeyVault.id}
  encrypted:
    fn::invoke:
      Function: azure:keyvault:getEncryptedValue
      Arguments:
        keyVaultKeyId: ${azurerm_key_vault_key.test.id}
        algorithm: RSA1_5
        plainTextValue: some-encrypted-value
outputs:
  id: ${data.azurerm_key_vault_encrypted_value.example.encrypted_data}