random.RandomId

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

return await Deployment.RunAsync(() => 
{
    // The following example shows how to generate a unique name for an AWS EC2
    // instance that changes each time a new AMI id is selected.
    var serverRandomId = new Random.RandomId("serverRandomId", new()
    {
        Keepers = 
        {
            { "ami_id", @var.Ami_id },
        },
        ByteLength = 8,
    });

    var serverInstance = new Aws.Ec2.Instance("serverInstance", new()
    {
        Tags = 
        {
            { "Name", serverRandomId.Hex.Apply(hex => $"web-server {hex}") },
        },
        Ami = serverRandomId.Keepers.Apply(keepers => keepers?.AmiId),
    });

    // ... (other aws_instance arguments) ...
});

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-aws/sdk/v5/go/aws/ec2"
	"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 AWS EC2
		// instance that changes each time a new AMI id is selected.
		serverRandomId, err := random.NewRandomId(ctx, "serverRandomId", &random.RandomIdArgs{
			Keepers: pulumi.StringMap{
				"ami_id": pulumi.Any(_var.Ami_id),
			},
			ByteLength: pulumi.Int(8),
		})
		if err != nil {
			return err
		}
		_, err = ec2.NewInstance(ctx, "serverInstance", &ec2.InstanceArgs{
			Tags: pulumi.StringMap{
				"Name": serverRandomId.Hex.ApplyT(func(hex string) (string, error) {
					return fmt.Sprintf("web-server %v", hex), nil
				}).(pulumi.StringOutput),
			},
			Ami: serverRandomId.Keepers.ApplyT(func(keepers interface{}) (*string, error) {
				return &keepers.AmiId, nil
			}).(pulumi.StringPtrOutput),
		})
		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.random.RandomId;
import com.pulumi.random.RandomIdArgs;
import com.pulumi.aws.ec2.Instance;
import com.pulumi.aws.ec2.InstanceArgs;
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) {
        var serverRandomId = new RandomId("serverRandomId", RandomIdArgs.builder()        
            .keepers(Map.of("ami_id", var_.ami_id()))
            .byteLength(8)
            .build());

        var serverInstance = new Instance("serverInstance", InstanceArgs.builder()        
            .tags(Map.of("Name", serverRandomId.hex().applyValue(hex -> String.format("web-server %s", hex))))
            .ami(serverRandomId.keepers().applyValue(keepers -> keepers.amiId()))
            .build());

    }
}

import pulumi
import pulumi_aws as aws
import pulumi_random as random

# The following example shows how to generate a unique name for an AWS EC2
# instance that changes each time a new AMI id is selected.
server_random_id = random.RandomId("serverRandomId",
    keepers={
        "ami_id": var["ami_id"],
    },
    byte_length=8)
server_instance = aws.ec2.Instance("serverInstance",
    tags={
        "Name": server_random_id.hex.apply(lambda hex: f"web-server {hex}"),
    },
    ami=server_random_id.keepers["amiId"])
# ... (other aws_instance arguments) ...

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

// The following example shows how to generate a unique name for an AWS EC2
// instance that changes each time a new AMI id is selected.
const serverRandomId = new random.RandomId("serverRandomId", {
    keepers: {
        ami_id: _var.ami_id,
    },
    byteLength: 8,
});
const serverInstance = new aws.ec2.Instance("serverInstance", {
    tags: {
        Name: pulumi.interpolate`web-server ${serverRandomId.hex}`,
    },
    ami: serverRandomId.keepers.apply(keepers => keepers?.amiId),
});
// ... (other aws_instance arguments) ...

resources:
  # The following example shows how to generate a unique name for an AWS EC2
  # instance that changes each time a new AMI id is selected.
  serverRandomId:
    type: random:RandomId
    properties:
      keepers:
        ami_id: ${var.ami_id}
      byteLength: 8
  serverInstance:
    type: aws:ec2:Instance
    properties:
      tags:
        Name: web-server ${serverRandomId.hex}
      # Read the AMI id "through" the random_id resource to ensure that
      #   # both will change together.
      ami: ${serverRandomId.keepers.amiId}