pulumi-gcp-kotlin/com.pulumi.gcp.firebase.kotlin/HostingCustomDomain

HostingCustomDomain

class HostingCustomDomain : KotlinCustomResource

Example Usage

Firebasehosting Customdomain Basic

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.firebase.HostingCustomDomain;
import com.pulumi.gcp.firebase.HostingCustomDomainArgs;
import com.pulumi.resources.CustomResourceOptions;
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) {
        var default_ = new HostingCustomDomain("default", HostingCustomDomainArgs.builder()
            .project("my-project-name")
            .siteId("site-id")
            .customDomain("custom.domain.com")
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
    }
}

Firebasehosting Customdomain Full

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.firebase.HostingSite;
import com.pulumi.gcp.firebase.HostingSiteArgs;
import com.pulumi.gcp.firebase.HostingCustomDomain;
import com.pulumi.gcp.firebase.HostingCustomDomainArgs;
import com.pulumi.resources.CustomResourceOptions;
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) {
        var defaultHostingSite = new HostingSite("defaultHostingSite", HostingSiteArgs.builder()
            .project("my-project-name")
            .siteId("site-id-full")
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
        var defaultHostingCustomDomain = new HostingCustomDomain("defaultHostingCustomDomain", HostingCustomDomainArgs.builder()
            .project("my-project-name")
            .siteId(defaultHostingSite.siteId())
            .customDomain("source.domain.com")
            .certPreference("GROUPED")
            .redirectTarget("destination.domain.com")
            .waitDnsVerification(false)
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
    }
}

Firebasehosting Customdomain Cloud Run

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.firebase.HostingSite;
import com.pulumi.gcp.firebase.HostingSiteArgs;
import com.pulumi.gcp.cloudrunv2.Service;
import com.pulumi.gcp.cloudrunv2.ServiceArgs;
import com.pulumi.gcp.cloudrunv2.inputs.ServiceTemplateArgs;
import com.pulumi.gcp.firebase.HostingVersion;
import com.pulumi.gcp.firebase.HostingVersionArgs;
import com.pulumi.gcp.firebase.inputs.HostingVersionConfigArgs;
import com.pulumi.gcp.firebase.HostingRelease;
import com.pulumi.gcp.firebase.HostingReleaseArgs;
import com.pulumi.gcp.firebase.HostingCustomDomain;
import com.pulumi.gcp.firebase.HostingCustomDomainArgs;
import com.pulumi.resources.CustomResourceOptions;
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) {
        var defaultHostingSite = new HostingSite("defaultHostingSite", HostingSiteArgs.builder()
            .project("my-project-name")
            .siteId("site-id")
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
        var defaultService = new Service("defaultService", ServiceArgs.builder()
            .project("my-project-name")
            .location("us-central1")
            .ingress("INGRESS_TRAFFIC_ALL")
            .template(ServiceTemplateArgs.builder()
                .containers(ServiceTemplateContainerArgs.builder()
                    .image("us-docker.pkg.dev/cloudrun/container/hello")
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
        var defaultHostingVersion = new HostingVersion("defaultHostingVersion", HostingVersionArgs.builder()
            .siteId(defaultHostingSite.siteId())
            .config(HostingVersionConfigArgs.builder()
                .rewrites(HostingVersionConfigRewriteArgs.builder()
                    .glob("/hello/**")
                    .run(HostingVersionConfigRewriteRunArgs.builder()
                        .serviceId(defaultService.name())
                        .region(defaultService.location())
                        .build())
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
        var defaultHostingRelease = new HostingRelease("defaultHostingRelease", HostingReleaseArgs.builder()
            .siteId(defaultHostingSite.siteId())
            .versionName(defaultHostingVersion.name())
            .message("Cloud Run Integration")
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
        var defaultHostingCustomDomain = new HostingCustomDomain("defaultHostingCustomDomain", HostingCustomDomainArgs.builder()
            .project("my-project-name")
            .siteId(defaultHostingSite.siteId())
            .customDomain("run.custom.domain.com")
            .waitDnsVerification(false)
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
    }
}

Import

CustomDomain can be imported using any of these accepted formats* projects/{{project}}/sites/{{site_id}}/customDomains/{{custom_domain}} * sites/{{site_id}}/customDomains/{{custom_domain}} * {{project}}/{{site_id}}/{{custom_domain}} * {{site_id}}/{{custom_domain}} In Terraform v1.5.0 and later, use an import block to import CustomDomain using one of the formats above. For exampletf import { id = "projects/{{project}}/sites/{{site_id}}/customDomains/{{custom_domain}}" to = google_firebase_hosting_custom_domain.default }

$ pulumi import gcp:firebase/hostingCustomDomain:HostingCustomDomain When using the [`terraform import` command](https://developer.hashicorp.com/terraform/cli/commands/import), CustomDomain can be imported using one of the formats above. For example

$ pulumi import gcp:firebase/hostingCustomDomain:HostingCustomDomain default projects/{{project}}/sites/{{site_id}}/customDomains/{{custom_domain}}

$ pulumi import gcp:firebase/hostingCustomDomain:HostingCustomDomain default sites/{{site_id}}/customDomains/{{custom_domain}}

$ pulumi import gcp:firebase/hostingCustomDomain:HostingCustomDomain default {{project}}/{{site_id}}/{{custom_domain}}

$ pulumi import gcp:firebase/hostingCustomDomain:HostingCustomDomain default {{site_id}}/{{custom_domain}}

Properties

certPreference

val certPreference: Output<String>

A field that lets you specify which SSL certificate type Hosting creates for your domain name. Spark plan CustomDomains only have access to the GROUPED cert type, while Blaze plan can select any option. Possible values are: GROUPED, PROJECT_GROUPED, DEDICATED.

certs

val certs: Output<List<HostingCustomDomainCert>>

The SSL certificate Hosting has for this CustomDomain's domain name. For new CustomDomains, this often represents Hosting's intent to create a certificate, rather than an actual cert. Check the state field for more. Structure is documented below.

createTime

val createTime: Output<String>

The CustomDomain's create time.

customDomain

val customDomain: Output<String>

The ID of the CustomDomain, which is the domain name you'd like to use with Firebase Hosting.

deleteTime

val deleteTime: Output<String>

The time the CustomDomain was deleted; null for CustomDomains that haven't been deleted. Deleted CustomDomains persist for approximately 30 days, after which time Hosting removes them completely.

etag

val etag: Output<String>

A string that represents the current state of the CustomDomain and allows you to confirm its initial state in requests that would modify it.

expireTime

val expireTime: Output<String>

The minimum time before a soft-deleted CustomDomain is completely removed from Hosting; null for CustomDomains that haven't been deleted.

hostState

val hostState: Output<String>

The host state of your domain name. Host state is determined by checking each IP address associated with your domain name to see if it's serving Hosting content. HOST_UNHOSTED: Your CustomDomain's domain name isn't associated with any IP addresses. HOST_UNREACHABLE: Your CustomDomain's domain name can't be reached. Hosting services' DNS queries to find your domain name's IP addresses resulted in errors. See your CustomDomain's issues field for more details. HOST_MISMATCH: Your CustomDomain's domain name has IP addresses that don't ultimately resolve to Hosting. HOST_CONFLICT: Your CustomDomain's domain name has IP addresses that resolve to both Hosting and other services. To ensure consistent results, remove A and AAAA records related to non-Hosting services. HOST_ACTIVE: All requests against your CustomDomain's domain name are served by Hosting. If the CustomDomain's OwnershipState is also ACTIVE, Hosting serves your Hosting Site's content on the domain name.

val id: Output<String>

issues

val issues: Output<List<HostingCustomDomainIssue>>

A set of errors Hosting systems encountered when trying to establish Hosting's ability to serve secure content for your domain name. Resolve these issues to ensure your CustomDomain behaves properly. Structure is documented below.

name

val name: Output<String>

The fully-qualified name of the CustomDomain.

ownershipState

val ownershipState: Output<String>

The ownership state of your domain name. Ownership is determined at a Firebase project level, and established by adding TXT records to your domain name's DNS records. Ownership cascades to subdomains. Granting a project ownership of foo.com also grants that project ownership over bar.foo.com, unless you add specific TXT records to bar.foo.com that grant a different project ownership. If your CustomDomain is in an OwnershipState other than OWNERSHIP_ACTIVE for more than 30 days and it hasn't been updated in at least 30 days, Hosting's ownership systems delete the CustomDomain. OWNERSHIP_MISSING: Your CustomDomain's domain name has no Hosting-related ownership records; no Firebase project has permission to act on the domain name's behalf. OWNERSHIP_UNREACHABLE: Your CustomDomain's domain name can't be reached. Hosting services' DNS queries to find your domain name's ownership records resulted in errors. See your CustomDomain's issues field for more details. OWNERSHIP_MISMATCH: Your CustomDomain's domain name is owned by another Firebase project. Remove the conflicting TXT records and replace them with project-specific records for your current Firebase project. OWNERSHIP_CONFLICT: Your CustomDomain's domain name has conflicting TXT records that indicate ownership by both your current Firebase project and another project. Remove the other project's ownership records to grant the current project ownership. OWNERSHIP_PENDING: Your CustomDomain's DNS records are configured correctly. Hosting will transfer ownership of your domain to this CustomDomain within 24 hours. OWNERSHIP_ACTIVE: Your CustomDomain's domain name has TXT records that grant its project permission to act on its behalf.

project

val project: Output<String>

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

reconciling

val reconciling: Output<Boolean>

if true, indicates that Hosting's systems are attmepting to make the CustomDomain's state match your preferred state. This is most frequently true when initially provisioning a CustomDomain or when creating a new SSL certificate to match an updated cert_preference

redirectTarget

val redirectTarget: Output<String>?

A domain name that this CustomDomain should direct traffic towards. If specified, Hosting will respond to requests against this CustomDomain with an HTTP 301 code, and route traffic to the specified redirect_target instead.

requiredDnsUpdates

val requiredDnsUpdates: Output<List<HostingCustomDomainRequiredDnsUpdate>>

A set of updates you should make to the domain name's DNS records to let Hosting serve secure content on its behalf. Structure is documented below.

siteId

val siteId: Output<String>

The ID of the site in which to create this custom domain association.

updateTime

val updateTime: Output<String>

The last time the CustomDomain was updated.

urn

val urn: Output<String>

waitDnsVerification

val waitDnsVerification: Output<Boolean>?

If true, Terraform will wait for DNS records to be fully resolved on the 'CustomDomain'. If false, Terraform will not wait for DNS records on the 'CustomDomain'. Any issues in the 'CustomDomain' will be returned and stored in the Terraform state.