scaleway.instance.UserData

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

const config = new pulumi.Config();
const userData = config.getObject<Record<string, any>>("userData") || {
    "cloud-init": `#cloud-config
apt-update: true
apt-upgrade: true
`,
    foo: "bar",
};
const mainServer = new scaleway.instance.Server("main", {
    image: "ubuntu_focal",
    type: "DEV1-S",
});
// User data with a single value
const main = new scaleway.instance.UserData("main", {
    serverId: mainServer.id,
    key: "foo",
    value: "bar",
});
// User Data with many keys.
const data: scaleway.instance.UserData[] = [];
for (const range of Object.entries(userData).map(([k, v]) => ({key: k, value: v}))) {
    data.push(new scaleway.instance.UserData(`data-${range.key}`, {
        serverId: mainServer.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_server = scaleway.instance.Server("main",
    image="ubuntu_focal",
    type="DEV1-S")
# User data with a single value
main = scaleway.instance.UserData("main",
    server_id=main_server.id,
    key="foo",
    value="bar")
# User Data with many keys.
data = []
for range in [{"key": k, "value": v} for [k, v] in enumerate(user_data)]:
    data.append(scaleway.instance.UserData(f"data-{range['key']}",
        server_id=main_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/instance"
)

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
		}
		mainServer, err := instance.NewServer(ctx, "main", &instance.ServerArgs{
			Image: pulumi.String("ubuntu_focal"),
			Type:  pulumi.String("DEV1-S"),
		})
		if err != nil {
			return err
		}
		// User data with a single value
		_, err = instance.NewUserData(ctx, "main", &instance.UserDataArgs{
			ServerId: mainServer.ID(),
			Key:      pulumi.String("foo"),
			Value:    pulumi.String("bar"),
		})
		if err != nil {
			return err
		}
		// User Data with many keys.
		var data []*instance.UserData
		for key0, val0 := range userData {
			__res, err := instance.NewUserData(ctx, fmt.Sprintf("data-%v", key0), &instance.UserDataArgs{
				ServerId: mainServer.ID(),
				Key:      pulumi.String(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<Dictionary<string, dynamic>>("userData") ?? 
    {
        { "cloud-init", @"#cloud-config
apt-update: true
apt-upgrade: true
" },
        { "foo", "bar" },
    };
    var mainServer = new Scaleway.Instance.Server("main", new()
    {
        Image = "ubuntu_focal",
        Type = "DEV1-S",
    });

    // User data with a single value
    var main = new Scaleway.Instance.UserData("main", new()
    {
        ServerId = mainServer.Id,
        Key = "foo",
        Value = "bar",
    });

    // User Data with many keys.
    var data = new List<Scaleway.Instance.UserData>();
    foreach (var range in userData.Select(pair => new { pair.Key, pair.Value }))
    {
        data.Add(new Scaleway.Instance.UserData($"data-{range.Key}", new()
        {
            ServerId = mainServer.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.instance.Server;
import com.pulumi.scaleway.instance.ServerArgs;
import com.pulumi.scaleway.instance.UserData;
import com.pulumi.scaleway.instance.UserDataArgs;
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 mainServer = new Server("mainServer", ServerArgs.builder()
            .image("ubuntu_focal")
            .type("DEV1-S")
            .build());

        // User data with a single value
        var main = new UserData("main", UserDataArgs.builder()
            .serverId(mainServer.id())
            .key("foo")
            .value("bar")
            .build());

        // User Data with many keys.
        for (var range : KeyedValue.of(userData)) {
            new UserData("data-" + range.key(), UserDataArgs.builder()
                .serverId(mainServer.id())
                .key(range.key())
                .value(range.value())
                .build());
        }

    }
}

configuration:
  userData:
    type: map(dynamic)
    default:
      cloud-init: |
        #cloud-config
        apt-update: true
        apt-upgrade: true        
      foo: bar
resources:
  # User data with a single value
  main:
    type: scaleway:instance:UserData
    properties:
      serverId: ${mainServer.id}
      key: foo
      value: bar
  # User Data with many keys.
  data:
    type: scaleway:instance:UserData
    properties:
      serverId: ${mainServer.id}
      key: ${range.key}
      value: ${range.value}
    options: {}
  mainServer:
    type: scaleway:instance:Server
    name: main
    properties:
      image: ubuntu_focal
      type: DEV1-S

var userDataResource = new Scaleway.Instance.UserData("userDataResource", new()
{
    Key = "string",
    ServerId = "string",
    Value = "string",
    Zone = "string",
});

example, err := instance.NewUserData(ctx, "userDataResource", &instance.UserDataArgs{
	Key:      pulumi.String("string"),
	ServerId: pulumi.String("string"),
	Value:    pulumi.String("string"),
	Zone:     pulumi.String("string"),
})

var userDataResource = new UserData("userDataResource", UserDataArgs.builder()
    .key("string")
    .serverId("string")
    .value("string")
    .zone("string")
    .build());

user_data_resource = scaleway.instance.UserData("userDataResource",
    key="string",
    server_id="string",
    value="string",
    zone="string")

const userDataResource = new scaleway.instance.UserData("userDataResource", {
    key: "string",
    serverId: "string",
    value: "string",
    zone: "string",
});

type: scaleway:instance:UserData
properties:
    key: string
    serverId: string
    value: string
    zone: string