scaleway.InstanceUserData

import * as pulumi from "@pulumi/pulumi";
import * as scaleway from "@pulumiverse/scaleway";

const config = new pulumi.Config();
const userData = config.getObject("userData") || {
    "cloud-init": `#cloud-config
apt-update: true
apt-upgrade: true
`,
    foo: "bar",
};
const mainInstanceServer = new scaleway.InstanceServer("mainInstanceServer", {
    image: "ubuntu_focal",
    type: "DEV1-S",
});
// User data with a single value
const mainInstanceUserData = new scaleway.InstanceUserData("mainInstanceUserData", {
    serverId: mainInstanceServer.id,
    key: "foo",
    value: "bar",
});
// User Data with many keys.
const data: scaleway.InstanceUserData[] = [];
for (const range = {value: 0}; range.value < userData; range.value++) {
    data.push(new scaleway.InstanceUserData(`data-${range.value}`, {
        serverId: mainInstanceServer.id,
        key: range.key,
        value: range.value,
    }));
}

import pulumi
import pulumiverse_scaleway as scaleway

config = pulumi.Config()
user_data = config.get_object("userData")
if user_data is None:
    user_data = {
        "cloud-init": """#cloud-config
apt-update: true
apt-upgrade: true
""",
        "foo": "bar",
    }
main_instance_server = scaleway.InstanceServer("mainInstanceServer",
    image="ubuntu_focal",
    type="DEV1-S")
# User data with a single value
main_instance_user_data = scaleway.InstanceUserData("mainInstanceUserData",
    server_id=main_instance_server.id,
    key="foo",
    value="bar")
# User Data with many keys.
data = []
for range in [{"value": i} for i in range(0, user_data)]:
    data.append(scaleway.InstanceUserData(f"data-{range['value']}",
        server_id=main_instance_server.id,
        key=range["key"],
        value=range["value"]))

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
	"github.com/pulumiverse/pulumi-scaleway/sdk/go/scaleway"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		userData := map[string]interface{}{
			"cloud-init": "#cloud-config\napt-update: true\napt-upgrade: true\n",
			"foo":        "bar",
		}
		if param := cfg.GetObject("userData"); param != nil {
			userData = param
		}
		mainInstanceServer, err := scaleway.NewInstanceServer(ctx, "mainInstanceServer", &scaleway.InstanceServerArgs{
			Image: pulumi.String("ubuntu_focal"),
			Type:  pulumi.String("DEV1-S"),
		})
		if err != nil {
			return err
		}
		// User data with a single value
		_, err = scaleway.NewInstanceUserData(ctx, "mainInstanceUserData", &scaleway.InstanceUserDataArgs{
			ServerId: mainInstanceServer.ID(),
			Key:      pulumi.String("foo"),
			Value:    pulumi.String("bar"),
		})
		if err != nil {
			return err
		}
		// User Data with many keys.
		var data []*scaleway.InstanceUserData
		for index := 0; index < userData; index++ {
			key0 := index
			val0 := index
			__res, err := scaleway.NewInstanceUserData(ctx, fmt.Sprintf("data-%v", key0), &scaleway.InstanceUserDataArgs{
				ServerId: mainInstanceServer.ID(),
				Key:      pulumi.Any(key0),
				Value:    pulumi.Any(val0),
			})
			if err != nil {
				return err
			}
			data = append(data, __res)
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Scaleway = Pulumiverse.Scaleway;

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var userData = config.GetObject<dynamic>("userData") ?? 
    {
        { "cloud-init", @"#cloud-config
apt-update: true
apt-upgrade: true
" },
        { "foo", "bar" },
    };
    var mainInstanceServer = new Scaleway.InstanceServer("mainInstanceServer", new()
    {
        Image = "ubuntu_focal",
        Type = "DEV1-S",
    });

    // User data with a single value
    var mainInstanceUserData = new Scaleway.InstanceUserData("mainInstanceUserData", new()
    {
        ServerId = mainInstanceServer.Id,
        Key = "foo",
        Value = "bar",
    });

    // User Data with many keys.
    var data = new List<Scaleway.InstanceUserData>();
    for (var rangeIndex = 0; rangeIndex < userData; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        data.Add(new Scaleway.InstanceUserData($"data-{range.Value}", new()
        {
            ServerId = mainInstanceServer.Id,
            Key = range.Key,
            Value = range.Value,
        }));
    }
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scaleway.InstanceServer;
import com.pulumi.scaleway.InstanceServerArgs;
import com.pulumi.scaleway.InstanceUserData;
import com.pulumi.scaleway.InstanceUserDataArgs;
import com.pulumi.codegen.internal.KeyedValue;
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 config = ctx.config();
        final var userData = config.get("userData").orElse(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference));
        var mainInstanceServer = new InstanceServer("mainInstanceServer", InstanceServerArgs.builder()        
            .image("ubuntu_focal")
            .type("DEV1-S")
            .build());

        // User data with a single value
        var mainInstanceUserData = new InstanceUserData("mainInstanceUserData", InstanceUserDataArgs.builder()        
            .serverId(mainInstanceServer.id())
            .key("foo")
            .value("bar")
            .build());

        // User Data with many keys.
        for (var i = 0; i < userData; i++) {
            new InstanceUserData("data-" + i, InstanceUserDataArgs.builder()            
                .serverId(mainInstanceServer.id())
                .key(range.key())
                .value(range.value())
                .build());

        
}
    }
}

configuration:
  userData:
    type: dynamic
    default:
      cloud-init: |
        #cloud-config
        apt-update: true
        apt-upgrade: true        
      foo: bar
resources:
  # User data with a single value
  mainInstanceUserData:
    type: scaleway:InstanceUserData
    properties:
      serverId: ${mainInstanceServer.id}
      key: foo
      value: bar
  # User Data with many keys.
  data:
    type: scaleway:InstanceUserData
    properties:
      serverId: ${mainInstanceServer.id}
      key: ${range.key}
      value: ${range.value}
    options: {}
  mainInstanceServer:
    type: scaleway:InstanceServer
    properties:
      image: ubuntu_focal
      type: DEV1-S

var instanceUserDataResource = new Scaleway.InstanceUserData("instanceUserDataResource", new()
{
    Key = "string",
    ServerId = "string",
    Value = "string",
    Zone = "string",
});

example, err := scaleway.NewInstanceUserData(ctx, "instanceUserDataResource", &scaleway.InstanceUserDataArgs{
	Key:      pulumi.String("string"),
	ServerId: pulumi.String("string"),
	Value:    pulumi.String("string"),
	Zone:     pulumi.String("string"),
})

var instanceUserDataResource = new InstanceUserData("instanceUserDataResource", InstanceUserDataArgs.builder()        
    .key("string")
    .serverId("string")
    .value("string")
    .zone("string")
    .build());

instance_user_data_resource = scaleway.InstanceUserData("instanceUserDataResource",
    key="string",
    server_id="string",
    value="string",
    zone="string")

const instanceUserDataResource = new scaleway.InstanceUserData("instanceUserDataResource", {
    key: "string",
    serverId: "string",
    value: "string",
    zone: "string",
});

type: scaleway:InstanceUserData
properties:
    key: string
    serverId: string
    value: string
    zone: string