hcloud.getDatacenters

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

const all = hcloud.getDatacenters({});
const workers: hcloud.Server[] = [];
for (const range = {value: 0}; range.value < 5; range.value++) {
    workers.push(new hcloud.Server(`workers-${range.value}`, {
        name: `node${range.value}`,
        image: "debian-12",
        serverType: "cx23",
        datacenter: all.then(all => all.datacenters[range.value]).then(datacenters => datacenters.name),
    }));
}

import pulumi
import pulumi_hcloud as hcloud

all = hcloud.get_datacenters()
workers = []
for range in [{"value": i} for i in range(0, 5)]:
    workers.append(hcloud.Server(f"workers-{range['value']}",
        name=f"node{range['value']}",
        image="debian-12",
        server_type="cx23",
        datacenter=all.datacenters[range["value"]]["name"]))

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

return await Deployment.RunAsync(() => 
{
    var all = HCloud.GetDatacenters.Invoke();

    var workers = new List<HCloud.Server>();
    for (var rangeIndex = 0; rangeIndex < 5; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        workers.Add(new HCloud.Server($"workers-{range.Value}", new()
        {
            Name = $"node{range.Value}",
            Image = "debian-12",
            ServerType = "cx23",
            Datacenter = all.Apply(getDatacentersResult => getDatacentersResult.Datacenters)[range.Value].Apply(datacenters => datacenters.Name),
        }));
    }
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.hcloud.HcloudFunctions;
import com.pulumi.hcloud.Server;
import com.pulumi.hcloud.ServerArgs;
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 all = HcloudFunctions.getDatacenters(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);

        for (var i = 0; i < 5; i++) {
            new Server("workers-" + i, ServerArgs.builder()
                .name(String.format("node%s", range.value()))
                .image("debian-12")
                .serverType("cx23")
                .datacenter(all.datacenters()[range.value()].name())
                .build());

        
}
    }
}

function getDatacenters(opts?: InvokeOptions): Promise<GetDatacentersResult>
function getDatacentersOutput(opts?: InvokeOptions): Output<GetDatacentersResult>

def get_datacenters(opts: Optional[InvokeOptions] = None) -> GetDatacentersResult
def get_datacenters_output(opts: Optional[InvokeOptions] = None) -> Output[GetDatacentersResult]

func GetDatacenters(ctx *Context, opts ...InvokeOption) (*GetDatacentersResult, error)
func GetDatacentersOutput(ctx *Context, opts ...InvokeOption) GetDatacentersResultOutput

public static class GetDatacenters 
{
    public static Task<GetDatacentersResult> InvokeAsync(InvokeOptions? opts = null)
    public static Output<GetDatacentersResult> Invoke(InvokeOptions? opts = null)
}

public static CompletableFuture<GetDatacentersResult> getDatacenters(InvokeOptions options)
public static Output<GetDatacentersResult> getDatacenters(InvokeOptions options)

fn::invoke:
  function: hcloud:index/getDatacenters:getDatacenters
  arguments:
    # arguments dictionary