Sign in Dashboard Get started
  1. Packages
  2. Packages
  3. Hcloud Provider
  4. API Docs
  5. Rdns
Viewing docs for Hetzner Cloud v1.38.0
published on Friday, May 29, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-hcloud

hcloud.Rdns

hcloud logo
Viewing docs for Hetzner Cloud v1.38.0
published on Friday, May 29, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-hcloud

    Provides Hetzner Cloud reverse DNS (rDNS) entries for Servers, Primary IPs, Floating IPs or Load Balancers.

    Example Usage

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

// For Servers
const server1 = new hcloud.Server("server1", {name: "server1"});
const server1Rdns = new hcloud.Rdns("server1", {
    serverId: server1.id.apply(x =>Number(x)),
    ipAddress: server1.ipv4Address,
    dnsPtr: "example.com",
});
// For Primary IPs
const primaryIp1 = new hcloud.PrimaryIp("primary_ip1", {
    name: "primary_ip1",
    type: "ipv4",
});
const primaryIp1Rdns = new hcloud.Rdns("primary_ip1", {
    primaryIpId: primaryIp1.id.apply(x =>Number(x)),
    ipAddress: primaryIp1.ipAddress,
    dnsPtr: "example.com",
});
// For Floating IPs
const floatingIp1 = new hcloud.FloatingIp("floating_ip1", {
    name: "floating_ip1",
    type: "ipv4",
});
const floatingIp1Rdns = new hcloud.Rdns("floating_ip1", {
    floatingIpId: floatingIp1.id.apply(x =>Number(x)),
    ipAddress: floatingIp1.ipAddress,
    dnsPtr: "example.com",
});
// For Load Balancers
const loadBalancer1 = new hcloud.LoadBalancer("load_balancer1", {name: "load_balancer1"});
const loadBalancer1Rdns = new hcloud.Rdns("load_balancer1", {
    loadBalancerId: loadBalancer1.id.apply(x =>Number(x)),
    ipAddress: loadBalancer1.ipv4,
    dnsPtr: "example.com",
});

    import pulumi
import pulumi_hcloud as hcloud

# For Servers
server1 = hcloud.Server("server1", name="server1")
server1_rdns = hcloud.Rdns("server1",
    server_id=server1.id.apply(lambda x: int(x)),
    ip_address=server1.ipv4_address,
    dns_ptr="example.com")
# For Primary IPs
primary_ip1 = hcloud.PrimaryIp("primary_ip1",
    name="primary_ip1",
    type="ipv4")
primary_ip1_rdns = hcloud.Rdns("primary_ip1",
    primary_ip_id=primary_ip1.id.apply(lambda x: int(x)),
    ip_address=primary_ip1.ip_address,
    dns_ptr="example.com")
# For Floating IPs
floating_ip1 = hcloud.FloatingIp("floating_ip1",
    name="floating_ip1",
    type="ipv4")
floating_ip1_rdns = hcloud.Rdns("floating_ip1",
    floating_ip_id=floating_ip1.id.apply(lambda x: int(x)),
    ip_address=floating_ip1.ip_address,
    dns_ptr="example.com")
# For Load Balancers
load_balancer1 = hcloud.LoadBalancer("load_balancer1", name="load_balancer1")
load_balancer1_rdns = hcloud.Rdns("load_balancer1",
    load_balancer_id=load_balancer1.id.apply(lambda x: int(x)),
    ip_address=load_balancer1.ipv4,
    dns_ptr="example.com")

    package main

import (
	"github.com/pulumi/pulumi-hcloud/sdk/go/hcloud"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// For Servers
		server1, err := hcloud.NewServer(ctx, "server1", &hcloud.ServerArgs{
			Name: pulumi.String("server1"),
		})
		if err != nil {
			return err
		}
		_, err = hcloud.NewRdns(ctx, "server1", &hcloud.RdnsArgs{
			ServerId:  server1.ID(),
			IpAddress: server1.Ipv4Address,
			DnsPtr:    pulumi.String("example.com"),
		})
		if err != nil {
			return err
		}
		// For Primary IPs
		primaryIp1, err := hcloud.NewPrimaryIp(ctx, "primary_ip1", &hcloud.PrimaryIpArgs{
			Name: pulumi.String("primary_ip1"),
			Type: pulumi.String("ipv4"),
		})
		if err != nil {
			return err
		}
		_, err = hcloud.NewRdns(ctx, "primary_ip1", &hcloud.RdnsArgs{
			PrimaryIpId: primaryIp1.ID(),
			IpAddress:   primaryIp1.IpAddress,
			DnsPtr:      pulumi.String("example.com"),
		})
		if err != nil {
			return err
		}
		// For Floating IPs
		floatingIp1, err := hcloud.NewFloatingIp(ctx, "floating_ip1", &hcloud.FloatingIpArgs{
			Name: pulumi.String("floating_ip1"),
			Type: pulumi.String("ipv4"),
		})
		if err != nil {
			return err
		}
		_, err = hcloud.NewRdns(ctx, "floating_ip1", &hcloud.RdnsArgs{
			FloatingIpId: floatingIp1.ID(),
			IpAddress:    floatingIp1.IpAddress,
			DnsPtr:       pulumi.String("example.com"),
		})
		if err != nil {
			return err
		}
		// For Load Balancers
		loadBalancer1, err := hcloud.NewLoadBalancer(ctx, "load_balancer1", &hcloud.LoadBalancerArgs{
			Name: pulumi.String("load_balancer1"),
		})
		if err != nil {
			return err
		}
		_, err = hcloud.NewRdns(ctx, "load_balancer1", &hcloud.RdnsArgs{
			LoadBalancerId: loadBalancer1.ID(),
			IpAddress:      loadBalancer1.Ipv4,
			DnsPtr:         pulumi.String("example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // For Servers
    var server1 = new HCloud.Server("server1", new()
    {
        Name = "server1",
    });

    var server1Rdns = new HCloud.Rdns("server1", new()
    {
        ServerId = server1.Id,
        IpAddress = server1.Ipv4Address,
        DnsPtr = "example.com",
    });

    // For Primary IPs
    var primaryIp1 = new HCloud.PrimaryIp("primary_ip1", new()
    {
        Name = "primary_ip1",
        Type = "ipv4",
    });

    var primaryIp1Rdns = new HCloud.Rdns("primary_ip1", new()
    {
        PrimaryIpId = primaryIp1.Id,
        IpAddress = primaryIp1.IpAddress,
        DnsPtr = "example.com",
    });

    // For Floating IPs
    var floatingIp1 = new HCloud.FloatingIp("floating_ip1", new()
    {
        Name = "floating_ip1",
        Type = "ipv4",
    });

    var floatingIp1Rdns = new HCloud.Rdns("floating_ip1", new()
    {
        FloatingIpId = floatingIp1.Id,
        IpAddress = floatingIp1.IpAddress,
        DnsPtr = "example.com",
    });

    // For Load Balancers
    var loadBalancer1 = new HCloud.LoadBalancer("load_balancer1", new()
    {
        Name = "load_balancer1",
    });

    var loadBalancer1Rdns = new HCloud.Rdns("load_balancer1", new()
    {
        LoadBalancerId = loadBalancer1.Id,
        IpAddress = loadBalancer1.Ipv4,
        DnsPtr = "example.com",
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.hcloud.Server;
import com.pulumi.hcloud.ServerArgs;
import com.pulumi.hcloud.Rdns;
import com.pulumi.hcloud.RdnsArgs;
import com.pulumi.hcloud.PrimaryIp;
import com.pulumi.hcloud.PrimaryIpArgs;
import com.pulumi.hcloud.FloatingIp;
import com.pulumi.hcloud.FloatingIpArgs;
import com.pulumi.hcloud.LoadBalancer;
import com.pulumi.hcloud.LoadBalancerArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // For Servers
        var server1 = new Server("server1", ServerArgs.builder()
            .name("server1")
            .build());

        var server1Rdns = new Rdns("server1Rdns", RdnsArgs.builder()
            .serverId(server1.id())
            .ipAddress(server1.ipv4Address())
            .dnsPtr("example.com")
            .build());

        // For Primary IPs
        var primaryIp1 = new PrimaryIp("primaryIp1", PrimaryIpArgs.builder()
            .name("primary_ip1")
            .type("ipv4")
            .build());

        var primaryIp1Rdns = new Rdns("primaryIp1Rdns", RdnsArgs.builder()
            .primaryIpId(primaryIp1.id())
            .ipAddress(primaryIp1.ipAddress())
            .dnsPtr("example.com")
            .build());

        // For Floating IPs
        var floatingIp1 = new FloatingIp("floatingIp1", FloatingIpArgs.builder()
            .name("floating_ip1")
            .type("ipv4")
            .build());

        var floatingIp1Rdns = new Rdns("floatingIp1Rdns", RdnsArgs.builder()
            .floatingIpId(floatingIp1.id())
            .ipAddress(floatingIp1.ipAddress())
            .dnsPtr("example.com")
            .build());

        // For Load Balancers
        var loadBalancer1 = new LoadBalancer("loadBalancer1", LoadBalancerArgs.builder()
            .name("load_balancer1")
            .build());

        var loadBalancer1Rdns = new Rdns("loadBalancer1Rdns", RdnsArgs.builder()
            .loadBalancerId(loadBalancer1.id())
            .ipAddress(loadBalancer1.ipv4())
            .dnsPtr("example.com")
            .build());

    }
}

    resources:
  # For Servers
  server1:
    type: hcloud:Server
    properties:
      name: server1
  server1Rdns:
    type: hcloud:Rdns
    name: server1
    properties:
      serverId: ${server1.id}
      ipAddress: ${server1.ipv4Address}
      dnsPtr: example.com
  # For Primary IPs
  primaryIp1:
    type: hcloud:PrimaryIp
    name: primary_ip1
    properties:
      name: primary_ip1
      type: ipv4
  primaryIp1Rdns:
    type: hcloud:Rdns
    name: primary_ip1
    properties:
      primaryIpId: ${primaryIp1.id}
      ipAddress: ${primaryIp1.ipAddress}
      dnsPtr: example.com
  # For Floating IPs
  floatingIp1:
    type: hcloud:FloatingIp
    name: floating_ip1
    properties:
      name: floating_ip1
      type: ipv4
  floatingIp1Rdns:
    type: hcloud:Rdns
    name: floating_ip1
    properties:
      floatingIpId: ${floatingIp1.id}
      ipAddress: ${floatingIp1.ipAddress}
      dnsPtr: example.com
  # For Load Balancers
  loadBalancer1:
    type: hcloud:LoadBalancer
    name: load_balancer1
    properties:
      name: load_balancer1
  loadBalancer1Rdns:
    type: hcloud:Rdns
    name: load_balancer1
    properties:
      loadBalancerId: ${loadBalancer1.id}
      ipAddress: ${loadBalancer1.ipv4}
      dnsPtr: example.com

    pulumi {
  required_providers {
    hcloud = {
      source = "pulumi/hcloud"
    }
  }
}

// For Servers
resource "hcloud_server" "server1" {
  name = "server1"
}
resource "hcloud_rdns" "server1" {
  server_id  = hcloud_server.server1.id
  ip_address = hcloud_server.server1.ipv4_address
  dns_ptr    = "example.com"
}
// For Primary IPs
resource "hcloud_primaryip" "primary_ip1" {
  name = "primary_ip1"
  type = "ipv4"
}
resource "hcloud_rdns" "primary_ip1" {
  primary_ip_id = hcloud_primaryip.primary_ip1.id
  ip_address    = hcloud_primaryip.primary_ip1.ip_address
  dns_ptr       = "example.com"
}
// For Floating IPs
resource "hcloud_floatingip" "floating_ip1" {
  name = "floating_ip1"
  type = "ipv4"
}
resource "hcloud_rdns" "floating_ip1" {
  floating_ip_id = hcloud_floatingip.floating_ip1.id
  ip_address     = hcloud_floatingip.floating_ip1.ip_address
  dns_ptr        = "example.com"
}
// For Load Balancers
resource "hcloud_loadbalancer" "load_balancer1" {
  name = "load_balancer1"
}
resource "hcloud_rdns" "load_balancer1" {
  load_balancer_id = hcloud_loadbalancer.load_balancer1.id
  ip_address       = hcloud_loadbalancer.load_balancer1.ipv4
  dns_ptr          = "example.com"
}

    Create Rdns Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new Rdns(name: string, args: RdnsArgs, opts?: CustomResourceOptions);
    @overload
def Rdns(resource_name: str,
         args: RdnsArgs,
         opts: Optional[ResourceOptions] = None)

@overload
def Rdns(resource_name: str,
         opts: Optional[ResourceOptions] = None,
         dns_ptr: Optional[str] = None,
         ip_address: Optional[str] = None,
         floating_ip_id: Optional[int] = None,
         load_balancer_id: Optional[int] = None,
         primary_ip_id: Optional[int] = None,
         server_id: Optional[int] = None)
    func NewRdns(ctx *Context, name string, args RdnsArgs, opts ...ResourceOption) (*Rdns, error)
    public Rdns(string name, RdnsArgs args, CustomResourceOptions? opts = null)
    public Rdns(String name, RdnsArgs args)
public Rdns(String name, RdnsArgs args, CustomResourceOptions options)

    type: hcloud:Rdns
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.


    resource "hcloud_rdns" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args RdnsArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args RdnsArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args RdnsArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args RdnsArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args RdnsArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var rdnsResource = new HCloud.Rdns("rdnsResource", new()
{
    DnsPtr = "string",
    IpAddress = "string",
    FloatingIpId = 0,
    LoadBalancerId = 0,
    PrimaryIpId = 0,
    ServerId = 0,
});

    example, err := hcloud.NewRdns(ctx, "rdnsResource", &hcloud.RdnsArgs{
	DnsPtr:         pulumi.String("string"),
	IpAddress:      pulumi.String("string"),
	FloatingIpId:   pulumi.Int(0),
	LoadBalancerId: pulumi.Int(0),
	PrimaryIpId:    pulumi.Int(0),
	ServerId:       pulumi.Int(0),
})

    resource "hcloud_rdns" "rdnsResource" {
  dns_ptr          = "string"
  ip_address       = "string"
  floating_ip_id   = 0
  load_balancer_id = 0
  primary_ip_id    = 0
  server_id        = 0
}

    var rdnsResource = new Rdns("rdnsResource", RdnsArgs.builder()
    .dnsPtr("string")
    .ipAddress("string")
    .floatingIpId(0)
    .loadBalancerId(0)
    .primaryIpId(0)
    .serverId(0)
    .build());

    rdns_resource = hcloud.Rdns("rdnsResource",
    dns_ptr="string",
    ip_address="string",
    floating_ip_id=0,
    load_balancer_id=0,
    primary_ip_id=0,
    server_id=0)

    const rdnsResource = new hcloud.Rdns("rdnsResource", {
    dnsPtr: "string",
    ipAddress: "string",
    floatingIpId: 0,
    loadBalancerId: 0,
    primaryIpId: 0,
    serverId: 0,
});

    type: hcloud:Rdns
properties:
    dnsPtr: string
    floatingIpId: 0
    ipAddress: string
    loadBalancerId: 0
    primaryIpId: 0
    serverId: 0

    Rdns Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The Rdns resource accepts the following input properties:

    DnsPtr string
    Domain name ipAddress should point to.
    IpAddress string
    IP address that should point to dnsPtr.
    FloatingIpId int
    ID of the Floating IP the ipAddress belongs to.
    LoadBalancerId int
    ID of the Load Balancer the ipAddress belongs to.
    PrimaryIpId int
    ID of the Primary IP the ipAddress belongs to.
    ServerId int
    ID of the Server the ipAddress belongs to.
    DnsPtr string
    Domain name ipAddress should point to.
    IpAddress string
    IP address that should point to dnsPtr.
    FloatingIpId int
    ID of the Floating IP the ipAddress belongs to.
    LoadBalancerId int
    ID of the Load Balancer the ipAddress belongs to.
    PrimaryIpId int
    ID of the Primary IP the ipAddress belongs to.
    ServerId int
    ID of the Server the ipAddress belongs to.
    dns_ptr string
    Domain name ipAddress should point to.
    ip_address string
    IP address that should point to dnsPtr.
    floating_ip_id number
    ID of the Floating IP the ipAddress belongs to.
    load_balancer_id number
    ID of the Load Balancer the ipAddress belongs to.
    primary_ip_id number
    ID of the Primary IP the ipAddress belongs to.
    server_id number
    ID of the Server the ipAddress belongs to.
    dnsPtr String
    Domain name ipAddress should point to.
    ipAddress String
    IP address that should point to dnsPtr.
    floatingIpId Integer
    ID of the Floating IP the ipAddress belongs to.
    loadBalancerId Integer
    ID of the Load Balancer the ipAddress belongs to.
    primaryIpId Integer
    ID of the Primary IP the ipAddress belongs to.
    serverId Integer
    ID of the Server the ipAddress belongs to.
    dnsPtr string
    Domain name ipAddress should point to.
    ipAddress string
    IP address that should point to dnsPtr.
    floatingIpId number
    ID of the Floating IP the ipAddress belongs to.
    loadBalancerId number
    ID of the Load Balancer the ipAddress belongs to.
    primaryIpId number
    ID of the Primary IP the ipAddress belongs to.
    serverId number
    ID of the Server the ipAddress belongs to.
    dns_ptr str
    Domain name ipAddress should point to.
    ip_address str
    IP address that should point to dnsPtr.
    floating_ip_id int
    ID of the Floating IP the ipAddress belongs to.
    load_balancer_id int
    ID of the Load Balancer the ipAddress belongs to.
    primary_ip_id int
    ID of the Primary IP the ipAddress belongs to.
    server_id int
    ID of the Server the ipAddress belongs to.
    dnsPtr String
    Domain name ipAddress should point to.
    ipAddress String
    IP address that should point to dnsPtr.
    floatingIpId Number
    ID of the Floating IP the ipAddress belongs to.
    loadBalancerId Number
    ID of the Load Balancer the ipAddress belongs to.
    primaryIpId Number
    ID of the Primary IP the ipAddress belongs to.
    serverId Number
    ID of the Server the ipAddress belongs to.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the Rdns resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing Rdns Resource

    Get an existing Rdns resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: RdnsState, opts?: CustomResourceOptions): Rdns
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        dns_ptr: Optional[str] = None,
        floating_ip_id: Optional[int] = None,
        ip_address: Optional[str] = None,
        load_balancer_id: Optional[int] = None,
        primary_ip_id: Optional[int] = None,
        server_id: Optional[int] = None) -> Rdns
    func GetRdns(ctx *Context, name string, id IDInput, state *RdnsState, opts ...ResourceOption) (*Rdns, error)
    public static Rdns Get(string name, Input<string> id, RdnsState? state, CustomResourceOptions? opts = null)
    public static Rdns get(String name, Output<String> id, RdnsState state, CustomResourceOptions options)
    resources:  _:    type: hcloud:Rdns    get:      id: ${id}
    import {
  to = hcloud_rdns.example
  id = "${id}"
}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    DnsPtr string
    Domain name ipAddress should point to.
    FloatingIpId int
    ID of the Floating IP the ipAddress belongs to.
    IpAddress string
    IP address that should point to dnsPtr.
    LoadBalancerId int
    ID of the Load Balancer the ipAddress belongs to.
    PrimaryIpId int
    ID of the Primary IP the ipAddress belongs to.
    ServerId int
    ID of the Server the ipAddress belongs to.
    DnsPtr string
    Domain name ipAddress should point to.
    FloatingIpId int
    ID of the Floating IP the ipAddress belongs to.
    IpAddress string
    IP address that should point to dnsPtr.
    LoadBalancerId int
    ID of the Load Balancer the ipAddress belongs to.
    PrimaryIpId int
    ID of the Primary IP the ipAddress belongs to.
    ServerId int
    ID of the Server the ipAddress belongs to.
    dns_ptr string
    Domain name ipAddress should point to.
    floating_ip_id number
    ID of the Floating IP the ipAddress belongs to.
    ip_address string
    IP address that should point to dnsPtr.
    load_balancer_id number
    ID of the Load Balancer the ipAddress belongs to.
    primary_ip_id number
    ID of the Primary IP the ipAddress belongs to.
    server_id number
    ID of the Server the ipAddress belongs to.
    dnsPtr String
    Domain name ipAddress should point to.
    floatingIpId Integer
    ID of the Floating IP the ipAddress belongs to.
    ipAddress String
    IP address that should point to dnsPtr.
    loadBalancerId Integer
    ID of the Load Balancer the ipAddress belongs to.
    primaryIpId Integer
    ID of the Primary IP the ipAddress belongs to.
    serverId Integer
    ID of the Server the ipAddress belongs to.
    dnsPtr string
    Domain name ipAddress should point to.
    floatingIpId number
    ID of the Floating IP the ipAddress belongs to.
    ipAddress string
    IP address that should point to dnsPtr.
    loadBalancerId number
    ID of the Load Balancer the ipAddress belongs to.
    primaryIpId number
    ID of the Primary IP the ipAddress belongs to.
    serverId number
    ID of the Server the ipAddress belongs to.
    dns_ptr str
    Domain name ipAddress should point to.
    floating_ip_id int
    ID of the Floating IP the ipAddress belongs to.
    ip_address str
    IP address that should point to dnsPtr.
    load_balancer_id int
    ID of the Load Balancer the ipAddress belongs to.
    primary_ip_id int
    ID of the Primary IP the ipAddress belongs to.
    server_id int
    ID of the Server the ipAddress belongs to.
    dnsPtr String
    Domain name ipAddress should point to.
    floatingIpId Number
    ID of the Floating IP the ipAddress belongs to.
    ipAddress String
    IP address that should point to dnsPtr.
    loadBalancerId Number
    ID of the Load Balancer the ipAddress belongs to.
    primaryIpId Number
    ID of the Primary IP the ipAddress belongs to.
    serverId Number
    ID of the Server the ipAddress belongs to.

    Import

    The pulumi import command can be used, for example:

    $ pulumi import hcloud:index/rdns:Rdns example "$RESOURCE_PREFIX-$ID-$IP"

    A Server with id 132022102 and ip 203.0.113.10

    $ pulumi import hcloud:index/rdns:Rdns server1 "s-132022102-203.0.113.10"

    A Primary IP with id 582026301 and ip 2001:db8::1

    $ pulumi import hcloud:index/rdns:Rdns primary_ip1 "p-582026301-2001:db8::1"

    A Floating IP with id 912300308 and ip 2001:db8::1

    $ pulumi import hcloud:index/rdns:Rdns floating_ip1 "f-912300308-2001:db8::1"

    A Load Balancer with id 747590326 and ip 203.0.113.25

    $ pulumi import hcloud:index/rdns:Rdns load_balancer1 "l-747590326-203.0.113.25"

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    Hetzner Cloud pulumi/pulumi-hcloud
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the hcloud Terraform Provider.
    hcloud logo
    Viewing docs for Hetzner Cloud v1.38.0
    published on Friday, May 29, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-hcloud

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial