gcore 0.22.0, Apr 30 25

gcore 0.22.0 published on Wednesday, Apr 30, 2025 by g-core

gcore.getFloatingip

Explore with Pulumi AI

gcore 0.22.0 published on Wednesday, Apr 30, 2025 by g-core

Example Usage

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

const pr = gcore.getProject({
    name: "test",
});
const rg = gcore.getRegion({
    name: "ED-10 Preprod",
});
const ip = Promise.all([rg, pr]).then(([rg, pr]) => gcore.getFloatingip({
    floatingIpAddress: "10.100.179.172",
    regionId: rg.id,
    projectId: pr.id,
}));
const ipByFixedIp = Promise.all([rg, pr]).then(([rg, pr]) => gcore.getFloatingip({
    fixedIpAddress: "192.168.42.12",
    regionId: rg.id,
    projectId: pr.id,
}));
export const view = ip;

import pulumi
import pulumi_gcore as gcore

pr = gcore.get_project(name="test")
rg = gcore.get_region(name="ED-10 Preprod")
ip = gcore.get_floatingip(floating_ip_address="10.100.179.172",
    region_id=rg.id,
    project_id=pr.id)
ip_by_fixed_ip = gcore.get_floatingip(fixed_ip_address="192.168.42.12",
    region_id=rg.id,
    project_id=pr.id)
pulumi.export("view", ip)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		pr, err := gcore.GetProject(ctx, &gcore.GetProjectArgs{
			Name: "test",
		}, nil)
		if err != nil {
			return err
		}
		rg, err := gcore.GetRegion(ctx, &gcore.GetRegionArgs{
			Name: "ED-10 Preprod",
		}, nil)
		if err != nil {
			return err
		}
		ip, err := gcore.LookupFloatingip(ctx, &gcore.LookupFloatingipArgs{
			FloatingIpAddress: pulumi.StringRef("10.100.179.172"),
			RegionId:          pulumi.Float64Ref(rg.Id),
			ProjectId:         pulumi.Float64Ref(pr.Id),
		}, nil)
		if err != nil {
			return err
		}
		_, err = gcore.LookupFloatingip(ctx, &gcore.LookupFloatingipArgs{
			FixedIpAddress: pulumi.StringRef("192.168.42.12"),
			RegionId:       pulumi.Float64Ref(rg.Id),
			ProjectId:      pulumi.Float64Ref(pr.Id),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("view", ip)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var pr = Gcore.GetProject.Invoke(new()
    {
        Name = "test",
    });

    var rg = Gcore.GetRegion.Invoke(new()
    {
        Name = "ED-10 Preprod",
    });

    var ip = Gcore.GetFloatingip.Invoke(new()
    {
        FloatingIpAddress = "10.100.179.172",
        RegionId = rg.Apply(getRegionResult => getRegionResult.Id),
        ProjectId = pr.Apply(getProjectResult => getProjectResult.Id),
    });

    var ipByFixedIp = Gcore.GetFloatingip.Invoke(new()
    {
        FixedIpAddress = "192.168.42.12",
        RegionId = rg.Apply(getRegionResult => getRegionResult.Id),
        ProjectId = pr.Apply(getProjectResult => getProjectResult.Id),
    });

    return new Dictionary<string, object?>
    {
        ["view"] = ip,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcore.GcoreFunctions;
import com.pulumi.gcore.inputs.GetProjectArgs;
import com.pulumi.gcore.inputs.GetRegionArgs;
import com.pulumi.gcore.inputs.GetFloatingipArgs;
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 pr = GcoreFunctions.getProject(GetProjectArgs.builder()
            .name("test")
            .build());

        final var rg = GcoreFunctions.getRegion(GetRegionArgs.builder()
            .name("ED-10 Preprod")
            .build());

        final var ip = GcoreFunctions.getFloatingip(GetFloatingipArgs.builder()
            .floatingIpAddress("10.100.179.172")
            .regionId(rg.applyValue(getRegionResult -> getRegionResult.id()))
            .projectId(pr.applyValue(getProjectResult -> getProjectResult.id()))
            .build());

        final var ipByFixedIp = GcoreFunctions.getFloatingip(GetFloatingipArgs.builder()
            .fixedIpAddress("192.168.42.12")
            .regionId(rg.applyValue(getRegionResult -> getRegionResult.id()))
            .projectId(pr.applyValue(getProjectResult -> getProjectResult.id()))
            .build());

        ctx.export("view", ip.applyValue(getFloatingipResult -> getFloatingipResult));
    }
}

variables:
  pr:
    fn::invoke:
      function: gcore:getProject
      arguments:
        name: test
  rg:
    fn::invoke:
      function: gcore:getRegion
      arguments:
        name: ED-10 Preprod
  ip:
    fn::invoke:
      function: gcore:getFloatingip
      arguments:
        floatingIpAddress: 10.100.179.172
        regionId: ${rg.id}
        projectId: ${pr.id}
  ipByFixedIp:
    fn::invoke:
      function: gcore:getFloatingip
      arguments:
        fixedIpAddress: 192.168.42.12
        regionId: ${rg.id}
        projectId: ${pr.id}
outputs:
  view: ${ip}

Using getFloatingip

Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

function getFloatingip(args: GetFloatingipArgs, opts?: InvokeOptions): Promise<GetFloatingipResult>
function getFloatingipOutput(args: GetFloatingipOutputArgs, opts?: InvokeOptions): Output<GetFloatingipResult>

def get_floatingip(fixed_ip_address: Optional[str] = None,
                   floating_ip_address: Optional[str] = None,
                   id: Optional[str] = None,
                   metadata_k: Optional[str] = None,
                   metadata_kv: Optional[Mapping[str, str]] = None,
                   port_id: Optional[str] = None,
                   project_id: Optional[float] = None,
                   project_name: Optional[str] = None,
                   region_id: Optional[float] = None,
                   region_name: Optional[str] = None,
                   opts: Optional[InvokeOptions] = None) -> GetFloatingipResult
def get_floatingip_output(fixed_ip_address: Optional[pulumi.Input[str]] = None,
                   floating_ip_address: Optional[pulumi.Input[str]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   metadata_k: Optional[pulumi.Input[str]] = None,
                   metadata_kv: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   port_id: Optional[pulumi.Input[str]] = None,
                   project_id: Optional[pulumi.Input[float]] = None,
                   project_name: Optional[pulumi.Input[str]] = None,
                   region_id: Optional[pulumi.Input[float]] = None,
                   region_name: Optional[pulumi.Input[str]] = None,
                   opts: Optional[InvokeOptions] = None) -> Output[GetFloatingipResult]

func LookupFloatingip(ctx *Context, args *LookupFloatingipArgs, opts ...InvokeOption) (*LookupFloatingipResult, error)
func LookupFloatingipOutput(ctx *Context, args *LookupFloatingipOutputArgs, opts ...InvokeOption) LookupFloatingipResultOutput

> Note: This function is named LookupFloatingip in the Go SDK.

public static class GetFloatingip 
{
    public static Task<GetFloatingipResult> InvokeAsync(GetFloatingipArgs args, InvokeOptions? opts = null)
    public static Output<GetFloatingipResult> Invoke(GetFloatingipInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetFloatingipResult> getFloatingip(GetFloatingipArgs args, InvokeOptions options)
public static Output<GetFloatingipResult> getFloatingip(GetFloatingipArgs args, InvokeOptions options)

fn::invoke:
  function: gcore:index/getFloatingip:getFloatingip
  arguments:
    # arguments dictionary

The following arguments are supported:

FixedIpAddress string
FloatingIpAddress string
Id string: The ID of this resource.
MetadataK string
MetadataKv Dictionary<string, string>
PortId string
ProjectId double
ProjectName string
RegionId double
RegionName string

FixedIpAddress string
FloatingIpAddress string
Id string: The ID of this resource.
MetadataK string
MetadataKv map[string]string
PortId string
ProjectId float64
ProjectName string
RegionId float64
RegionName string

fixedIpAddress String
floatingIpAddress String
id String: The ID of this resource.
metadataK String
metadataKv Map<String,String>
portId String
projectId Double
projectName String
regionId Double
regionName String

fixedIpAddress string
floatingIpAddress string
id string: The ID of this resource.
metadataK string
metadataKv {[key: string]: string}
portId string
projectId number
projectName string
regionId number
regionName string

fixed_ip_address str
floating_ip_address str
id str: The ID of this resource.
metadata_k str
metadata_kv Mapping[str, str]
port_id str
project_id float
project_name str
region_id float
region_name str

fixedIpAddress String
floatingIpAddress String
id String: The ID of this resource.
metadataK String
metadataKv Map<String>
portId String
projectId Number
projectName String
regionId Number
regionName String

getFloatingip Result

The following output properties are available:

FixedIpAddress string
FloatingIpAddress string
Id string: The ID of this resource.
MetadataReadOnlies List<GetFloatingipMetadataReadOnly>
RouterId string
Status string
MetadataK string
MetadataKv Dictionary<string, string>
PortId string
ProjectId double
ProjectName string
RegionId double
RegionName string

FixedIpAddress string
FloatingIpAddress string
Id string: The ID of this resource.
MetadataReadOnlies []GetFloatingipMetadataReadOnly
RouterId string
Status string
MetadataK string
MetadataKv map[string]string
PortId string
ProjectId float64
ProjectName string
RegionId float64
RegionName string

fixedIpAddress String
floatingIpAddress String
id String: The ID of this resource.
metadataReadOnlies List<GetFloatingipMetadataReadOnly>
routerId String
status String
metadataK String
metadataKv Map<String,String>
portId String
projectId Double
projectName String
regionId Double
regionName String

fixedIpAddress string
floatingIpAddress string
id string: The ID of this resource.
metadataReadOnlies GetFloatingipMetadataReadOnly[]
routerId string
status string
metadataK string
metadataKv {[key: string]: string}
portId string
projectId number
projectName string
regionId number
regionName string

fixed_ip_address str
floating_ip_address str
id str: The ID of this resource.
metadata_read_onlies Sequence[GetFloatingipMetadataReadOnly]
router_id str
status str
metadata_k str
metadata_kv Mapping[str, str]
port_id str
project_id float
project_name str
region_id float
region_name str

fixedIpAddress String
floatingIpAddress String
id String: The ID of this resource.
metadataReadOnlies List<Property Map>
routerId String
status String
metadataK String
metadataKv Map<String>
portId String
projectId Number
projectName String
regionId Number
regionName String

Supporting Types

GetFloatingipMetadataReadOnly

Key string
ReadOnly bool
Value string

Key string
ReadOnly bool
Value string

key String
readOnly Boolean
value String

key string
readOnly boolean
value string

key str
read_only bool
value str

key String
readOnly Boolean
value String

Package Details

Repository: gcore g-core/terraform-provider-gcore
License
Notes: This Pulumi package is based on the gcore Terraform Provider.

gcore 0.22.0 published on Wednesday, Apr 30, 2025 by g-core

g-core/terraform-provider-gcore

gcore.getFloatingip

On this page

On this page

Example Usage

Using getFloatingip

getFloatingip Result

Supporting Types

GetFloatingipMetadataReadOnly

Package Details

On this page

On this page