random.RandomUuid

import * as pulumi from "@pulumi/pulumi";
import * as azurerm from "@pulumi/azurerm";
import * as random from "@pulumi/random";

// The following example shows how to generate a unique name for an Azure Resource Group.
const test = new random.RandomUuid("test", {});
const testResourceGroup = new azurerm.index.ResourceGroup("test", {
    name: `${test.result}-rg`,
    location: "Central US",
});

import pulumi
import pulumi_azurerm as azurerm
import pulumi_random as random

# The following example shows how to generate a unique name for an Azure Resource Group.
test = random.RandomUuid("test")
test_resource_group = azurerm.index.ResourceGroup("test",
    name=f{test.result}-rg,
    location=Central US)

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-azurerm/sdk/v1/go/azurerm"
	"github.com/pulumi/pulumi-random/sdk/v4/go/random"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// The following example shows how to generate a unique name for an Azure Resource Group.
		test, err := random.NewRandomUuid(ctx, "test", nil)
		if err != nil {
			return err
		}
		_, err = index.NewResourceGroup(ctx, "test", &index.ResourceGroupArgs{
			Name:     pulumi.String(fmt.Sprintf("%v-rg", test.Result)),
			Location: "Central US",
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azurerm = Pulumi.Azurerm;
using Random = Pulumi.Random;

return await Deployment.RunAsync(() => 
{
    // The following example shows how to generate a unique name for an Azure Resource Group.
    var test = new Random.RandomUuid("test");

    var testResourceGroup = new Azurerm.Index.ResourceGroup("test", new()
    {
        Name = $"{test.Result}-rg",
        Location = "Central US",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.random.RandomUuid;
import com.pulumi.azurerm.resourceGroup;
import com.pulumi.azurerm.ResourceGroupArgs;
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) {
        // The following example shows how to generate a unique name for an Azure Resource Group.
        var test = new RandomUuid("test");

        var testResourceGroup = new ResourceGroup("testResourceGroup", ResourceGroupArgs.builder()
            .name(String.format("%s-rg", test.result()))
            .location("Central US")
            .build());

    }
}

resources:
  # The following example shows how to generate a unique name for an Azure Resource Group.
  test:
    type: random:RandomUuid
  testResourceGroup:
    type: azurerm:resourceGroup
    name: test
    properties:
      name: ${test.result}-rg
      location: Central US

var randomUuidResource = new Random.RandomUuid("randomUuidResource", new()
{
    Keepers = 
    {
        { "string", "string" },
    },
});

example, err := random.NewRandomUuid(ctx, "randomUuidResource", &random.RandomUuidArgs{
	Keepers: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
})

var randomUuidResource = new RandomUuid("randomUuidResource", RandomUuidArgs.builder()
    .keepers(Map.of("string", "string"))
    .build());

random_uuid_resource = random.RandomUuid("randomUuidResource", keepers={
    "string": "string",
})

const randomUuidResource = new random.RandomUuid("randomUuidResource", {keepers: {
    string: "string",
}});

type: random:RandomUuid
properties:
    keepers:
        string: string