ionoscloud.compute.getGpus

import * as pulumi from "@pulumi/pulumi";
import * as ionoscloud from "@ionos-cloud/sdk-pulumi";

const example = ionoscloud.compute.getGpus({
    datacenterId: "datacenter_id",
    serverId: "server_id",
});

import pulumi
import pulumi_ionoscloud as ionoscloud

example = ionoscloud.compute.get_gpus(datacenter_id="datacenter_id",
    server_id="server_id")

package main

import (
	"github.com/ionos-cloud/pulumi-ionoscloud/sdk/go/ionoscloud/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.GetGpus(ctx, &compute.GetGpusArgs{
			DatacenterId: "datacenter_id",
			ServerId:     "server_id",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = Ionoscloud.Compute.GetGpus.Invoke(new()
    {
        DatacenterId = "datacenter_id",
        ServerId = "server_id",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.ionoscloud.compute.ComputeFunctions;
import com.pulumi.ionoscloud.compute.inputs.GetGpusArgs;
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 example = ComputeFunctions.getGpus(GetGpusArgs.builder()
            .datacenterId("datacenter_id")
            .serverId("server_id")
            .build());

    }
}

variables:
  example:
    fn::invoke:
      function: ionoscloud:compute:getGpus
      arguments:
        datacenterId: datacenter_id
        serverId: server_id

function getGpus(args: GetGpusArgs, opts?: InvokeOptions): Promise<GetGpusResult>
function getGpusOutput(args: GetGpusOutputArgs, opts?: InvokeOptions): Output<GetGpusResult>

def get_gpus(datacenter_id: Optional[str] = None,
             location: Optional[str] = None,
             server_id: Optional[str] = None,
             opts: Optional[InvokeOptions] = None) -> GetGpusResult
def get_gpus_output(datacenter_id: pulumi.Input[Optional[str]] = None,
             location: pulumi.Input[Optional[str]] = None,
             server_id: pulumi.Input[Optional[str]] = None,
             opts: Optional[InvokeOptions] = None) -> Output[GetGpusResult]

func GetGpus(ctx *Context, args *GetGpusArgs, opts ...InvokeOption) (*GetGpusResult, error)
func GetGpusOutput(ctx *Context, args *GetGpusOutputArgs, opts ...InvokeOption) GetGpusResultOutput

public static class GetGpus 
{
    public static Task<GetGpusResult> InvokeAsync(GetGpusArgs args, InvokeOptions? opts = null)
    public static Output<GetGpusResult> Invoke(GetGpusInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetGpusResult> getGpus(GetGpusArgs args, InvokeOptions options)
public static Output<GetGpusResult> getGpus(GetGpusArgs args, InvokeOptions options)

fn::invoke:
  function: ionoscloud:compute/getGpus:getGpus
  arguments:
    # arguments dictionary

data "ionoscloud_compute_getgpus" "name" {
    # arguments
}