glesys.getIp

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

export = async () => {
    // glesys_dnsdomain datasource
    const www_pub = await glesys.getIp({
        id: "192.0.2.10",
    });
    return {
        "www-ptr": www_pub.ptr,
    };
}

import pulumi
import pulumi_glesys as glesys

# glesys_dnsdomain datasource
www_pub = glesys.get_ip(id="192.0.2.10")
pulumi.export("www-ptr", www_pub.ptr)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/glesys/glesys"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// glesys_dnsdomain datasource
		www_pub, err := glesys.LookupIp(ctx, &glesys.LookupIpArgs{
			Id: pulumi.StringRef("192.0.2.10"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("www-ptr", www_pub.Ptr)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // glesys_dnsdomain datasource
    var www_pub = Glesys.GetIp.Invoke(new()
    {
        Id = "192.0.2.10",
    });

    return new Dictionary<string, object?>
    {
        ["www-ptr"] = www_pub.Apply(www_pub => www_pub.Apply(getIpResult => getIpResult.Ptr)),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.glesys.GlesysFunctions;
import com.pulumi.glesys.inputs.GetIpArgs;
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) {
        // glesys_dnsdomain datasource
        final var www-pub = GlesysFunctions.getIp(GetIpArgs.builder()
            .id("192.0.2.10")
            .build());

        ctx.export("www-ptr", www_pub.ptr());
    }
}

variables:
  # glesys_dnsdomain datasource
  www-pub:
    fn::invoke:
      function: glesys:getIp
      arguments:
        id: 192.0.2.10
outputs:
  www-ptr: ${["www-pub"].ptr}

function getIp(args: GetIpArgs, opts?: InvokeOptions): Promise<GetIpResult>
function getIpOutput(args: GetIpOutputArgs, opts?: InvokeOptions): Output<GetIpResult>

def get_ip(address: Optional[str] = None,
           id: Optional[str] = None,
           opts: Optional[InvokeOptions] = None) -> GetIpResult
def get_ip_output(address: pulumi.Input[Optional[str]] = None,
           id: pulumi.Input[Optional[str]] = None,
           opts: Optional[InvokeOptions] = None) -> Output[GetIpResult]

func LookupIp(ctx *Context, args *LookupIpArgs, opts ...InvokeOption) (*LookupIpResult, error)
func LookupIpOutput(ctx *Context, args *LookupIpOutputArgs, opts ...InvokeOption) LookupIpResultOutput

public static class GetIp 
{
    public static Task<GetIpResult> InvokeAsync(GetIpArgs args, InvokeOptions? opts = null)
    public static Output<GetIpResult> Invoke(GetIpInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetIpResult> getIp(GetIpArgs args, InvokeOptions options)
public static Output<GetIpResult> getIp(GetIpArgs args, InvokeOptions options)

fn::invoke:
  function: glesys:index/getIp:getIp
  arguments:
    # arguments dictionary

data "glesys_get_ip" "name" {
    # arguments
}