getRecordSets function

Future<GetRecordSetsResult> getRecordSets(GetRecordSetsArgs args, { InvokeOptions? options, })

Get a list of DNS record sets within a Google Cloud DNS managed zone. This data source allows you to list all record sets or filter them by name and type.

To get more information about Cloud DNS Record Sets, see:

• API documentation
• How-to Guides

> Note: Filtering by type when name is not set is performed client-side.

Example Usage

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

const envDnsZone = gcp.dns.getManagedZone({
    name: "my-zone-name",
});
const example = envDnsZone.then(envDnsZone => gcp.dns.getRecordSets({
    managedZone: envDnsZone.name,
    type: "A",
}));

import pulumi
import pulumi_gcp as gcp

env_dns_zone = gcp.dns.get_managed_zone(name="my-zone-name")
example = gcp.dns.get_record_sets(managed_zone=env_dns_zone.name,
    type="A")

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

return await Deployment.RunAsync(() =>
{
    var envDnsZone = Gcp.Dns.GetManagedZone.Invoke(new()
    {
        Name = "my-zone-name",
    });

    var example = Gcp.Dns.GetRecordSets.Invoke(new()
    {
        ManagedZone = envDnsZone.Apply(getManagedZoneResult => getManagedZoneResult.Name),
        Type = "A",
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/dns"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		envDnsZone, err := dns.LookupManagedZone(ctx, &dns.LookupManagedZoneArgs{
			Name: "my-zone-name",
		}, nil)
		if err != nil {
			return err
		}
		_, err = dns.GetRecordSets(ctx, &dns.GetRecordSetsArgs{
			ManagedZone: envDnsZone.Name,
			Type:        pulumi.StringRef("A"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

data "gcp_dns_getmanagedzone" "envDnsZone" {
  name = "my-zone-name"
}
data "gcp_dns_getrecordsets" "example" {
  managed_zone = data.gcp_dns_getmanagedzone.envDnsZone.name
  type         = "A"
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.dns.DnsFunctions;
import com.pulumi.gcp.dns.inputs.GetManagedZoneArgs;
import com.pulumi.gcp.dns.inputs.GetRecordSetsArgs;
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) {
        final var envDnsZone = DnsFunctions.getManagedZone(GetManagedZoneArgs.builder()
            .name("my-zone-name")
            .build());

        final var example = DnsFunctions.getRecordSets(GetRecordSetsArgs.builder()
            .managedZone(envDnsZone.name())
            .type("A")
            .build());

    }
}

variables:
  envDnsZone:
    fn::invoke:
      function: gcp:dns:getManagedZone
      arguments:
        name: my-zone-name
  example:
    fn::invoke:
      function: gcp:dns:getRecordSets
      arguments:
        managedZone: ${envDnsZone.name}
        type: A

args Arguments passed to this invoke. Arguments for getRecordSets. options Invoke options controlling this call.

Implementation

Future<GetRecordSetsResult> getRecordSets(
  GetRecordSetsArgs args, {
  pulumi.InvokeOptions? options,
}) async {
  final deployment = pulumi.Deployment.instance;
  final result = await deployment.invoke<Map<String, dynamic>>(
    'gcp:dns/getRecordSets:getRecordSets',
    args.toMap(),
    options: pulumi.toDeploymentInvokeOptions(options),
  );
  return GetRecordSetsResult.fromMap(result);
}