使用网域的静态托管

带有网域的静态托管是一个简单的静态网站创建工具，可让您使用 Storage 存储分区创建一个简单的网站：

存储 - 文件存储 - Cloud Storage
网络 - 负载均衡 - Cloud Load Balancer
网络 - DNS - Cloud DNS
域名管理 - 注册商 - Cloud Domains

开始使用

点击以下链接即可转到 Cloud Shell 中的源代码副本。之后，只需一个命令即可在项目中启动应用的工作副本。

使用网域组件的静态托管

使用网域的静态托管架构使用多种产品。下面列出了组件以及组件的详细信息，包括相关视频链接、产品文档和互动式演示。

			视频	文档	演示
	Cloud Storage	Cloud Storage 提供文件存储和通过 http(s) 公开提供图片的功能。
	Cloud DNS	Cloud DNS 提供 DNS 管理功能，可让您使用 Google 现有的 DNS 基础架构来运行自己的 DNS 基础架构。
	Cloud Load Balancing	Google Cloud 负载均衡器允许您在存储分区的前面放置一个负载均衡器，让您可以使用 SSL 证书、Logging 和 Monitoring。
	Cloud 网域	Cloud Domains 让您可以像域名注册商一样购买域名，但购买域名后，您可以通过自己的 Google Cloud 帐号管理域名并处理结算事宜。

脚本

安装脚本使用 go 和 Terraform CLI 工具编写的可执行文件接受一个空项目，并在其中安装应用。输出结果应该是正常运行的应用以及负载均衡 IP 地址的网址。

`./main.tf`

启用服务

默认情况下，Google Cloud 服务在项目中处于停用状态。要使用此处的任何解决方案，我们必须启用以下内容：

Cloud Domains - 域名注册
Cloud Storage - 托管静态文件
云计算 - 提供对负载平衡器的访问权限。
Cloud DNS - 提供 DNS 管理功能

variable "gcp_service_list" {
    description = "The list of apis necessary for the project"
    type        = list(string)
    default = [
        "domains.googleapis.com",
        "storage.googleapis.com",
        "compute.googleapis.com",
        "dns.googleapis.com",
        "appengine.googleapis.com",
    ]
}

resource "google_project_service" "all" {
    for_each                   = toset(var.gcp_service_list)
    project                    = var.project_number
    service                    = each.key
    disable_dependent_services = false
    disable_on_destroy         = false
}

创建 DNS 区域

创建用于管理记录的 DNS 区域，将记录指向负载平衡器，与网域注册商进行交互，并将 DNS 请求传送给其他 DNS 服务器。

resource "google_dns_managed_zone" "dnszone" {
    project     = var.project_id
    name        = local.clouddnszone
    dns_name    = "${var.domain}."
    description = "A DNS Zone for managing ${var.domain}"
}

创建 SSL 证书

https 协议请求需要 SSL 证书。这会生成一个将在稍后的命令中附加到负载均衡器的会话。

resource "google_compute_managed_ssl_certificate" "cert" {
    name        = "${local.basename}-cert"
    description = "Cert for ${local.basename}-microsite"
    project     = var.project_id

    managed {
        domains = [var.domain]
    }

    lifecycle {
        create_before_destroy = true
    }
}

创建外部 IP 地址

需要将主机绑定到域名，并在互联网上进行一般通信。

resource "google_compute_global_address" "ip" {
    project    = var.project_id
    name       = "${local.basename}-ip"
    ip_version = "IPV4"
}

创建存储分区

这会创建一个以该网域命名的存储桶，然后使用正确的配置将该存储桶用作 Web 服务器。最后，复制网站的简单模板

resource "google_storage_bucket" "http_bucket" {
    name     = local.bucket
    project  = var.project_id
    location = var.location

    website {
        main_page_suffix = "index.html"
        not_found_page   = "404.html"
    }
}

resource "google_storage_bucket_iam_binding" "policy" {
    bucket = google_storage_bucket.http_bucket.name
    role   = "roles/storage.objectViewer"
    members = [
      "allUsers",
    ]
    depends_on = [google_storage_bucket.http_bucket]
  }

resource "google_storage_bucket_object" "archive" {
    name   = "index.html"
    bucket = google_storage_bucket.http_bucket.name
    source = "code/${var.yesorno}/index.html"
    depends_on = [
        google_project_service.all,
        google_storage_bucket.http_bucket,
    ]
}

立式负载平衡器

这将创建负载均衡器，并将 Storage 存储分区设置为负载均衡器将为其提供访问权限的内容的来源。

resource "google_compute_backend_bucket" "be" {
    project     = var.project_id
    name        = "${local.basename}-be"
    bucket_name = google_storage_bucket.http_bucket.name
    depends_on = [google_storage_bucket.http_bucket]
}

resource "google_compute_url_map" "lb" {
    project         = var.project_id
    name            = "${local.basename}-lb"
    default_service = google_compute_backend_bucket.be.id
    depends_on = [google_compute_backend_bucket.be]
}

启用 HTTP

创建必要的网络规则，将负载均衡器上的端口 80 指向我们正在运行的服务。

resource "google_compute_target_http_proxy" "lb-proxy" {
    project = var.project_id
    name    = "${local.basename}-lb-proxy"
    url_map = google_compute_url_map.lb.id
    depends_on = [google_compute_url_map.lb]
}

resource "google_compute_forwarding_rule" "http-lb-forwarding-rule" {
    project               = var.project_id
    name                  = "${local.basename}-http-lb-forwarding-rule"
    provider              = google-beta
    region                = "none"
    load_balancing_scheme = "EXTERNAL"
    port_range            = "80"
    target                = google_compute_target_http_proxy.lb-proxy.id
    ip_address            = google_compute_global_address.ip.id
    depends_on = [google_compute_target_http_proxy.lb-proxy]
}

启用 HTTPS

创建必要的网络规则，将负载均衡器上的端口 443 指向我们正在运行的服务。还会正确关联证书。

resource "google_compute_target_https_proxy" "ssl-lb-proxy" {
    project          = var.project_id
    name             = "${local.basename}-ssl-lb-proxy"
    url_map          = google_compute_url_map.lb.id
    ssl_certificates = [google_compute_managed_ssl_certificate.cert.id]
    depends_on = [google_compute_url_map.lb,google_compute_managed_ssl_certificate.cert ]
}

resource "google_compute_forwarding_rule" "https-lb-forwarding-rule" {
    project               = var.project_id
    name                  = "${local.basename}-https-lb-forwarding-rule"
    provider              = google-beta
    region                = "none"
    load_balancing_scheme = "EXTERNAL"
    port_range            = "443"
    target                = google_compute_target_https_proxy.ssl-lb-proxy.id
    ip_address            = google_compute_global_address.ip.id
    depends_on = [google_compute_target_https_proxy.ssl-lb-proxy]
}

设置记录

在 Cloud DNS 中创建适当的规则，将域名解析为我们创建的 IP 地址。

resource "google_dns_record_set" "a" {
    project      = var.project_id
    name         = "${var.domain}."
    managed_zone = google_dns_managed_zone.dnszone.name
    type         = "A"
    ttl          = 60

    rrdatas = [google_compute_global_address.ip.address]
    depends_on = [google_compute_global_address.ip]
}

`./deploystack.go`

查询网域可用性

获取有关所请求域名的可用性的信息

func domainsSearch(project, domain string) ([]*domainspb.RegisterParameters, error) {
    ctx := context.Background()

    c, err := domains.NewClient(ctx)
    if err != nil {
        return nil, err
    }
    defer c.Close()

    req := &domainspb.SearchDomainsRequest{
        Query:    domain,
        Location: fmt.Sprintf("projects/%s/locations/global", project),
    }
    resp, err := c.SearchDomains(ctx, req)
    if err != nil {
        return nil, err
    }

    return resp.RegisterParameters, nil
}

func domainIsAvailable(project, domain string) (*domainspb.RegisterParameters, error) {
    list, err := domainsSearch(project, domain)
    if err != nil {
        return nil, err
    }
    for _, v := range list {
        if v.DomainName == domain {
            return v, err
        }
    }

    return nil, err
}

查询网域所有权

获取相关信息，了解当前用户是否拥有所请求的网域。

func domainsIsVerified(project, domain string) (bool, error) {
    ctx := context.Background()

    c, err := domains.NewClient(ctx)
    if err != nil {
        return false, err
    }
    defer c.Close()

    req := &domainspb.ListRegistrationsRequest{
        Filter: fmt.Sprintf("domainName=\"%s\"", domain),
        Parent: fmt.Sprintf("projects/%s/locations/global", project),
    }
    it := c.ListRegistrations(ctx, req)
    for {
        resp, err := it.Next()
        if err == iterator.Done {
            break
        }
        if err != nil {
            return false, err
        }

        if resp.DomainName == domain {
            return true, nil
        }
    }

    return false, nil
}

使用 Cloud Domains 注册域名

实际执行向注册商购买域名的操作。

func domainRegister(project string, domaininfo *domainspb.RegisterParameters, contact ContactData) error {
    ctx := context.Background()

    parent := fmt.Sprintf("projects/%s/locations/global", project)

    c, err := domains.NewClient(ctx)
    if err != nil {
        return err
    }
    defer c.Close()

    dnscontact, err := contact.DomainContact()
    if err != nil {
        return err
    }

    req := &domainspb.RegisterDomainRequest{
        Registration: &domainspb.Registration{
            Name:       fmt.Sprintf("%s/registrations/%s", parent, domaininfo.DomainName),
            DomainName: domaininfo.DomainName,
            DnsSettings: &domainspb.DnsSettings{
                DnsProvider: &domainspb.DnsSettings_CustomDns_{
                    CustomDns: &domainspb.DnsSettings_CustomDns{
                        NameServers: []string{
                            "ns-cloud-e1.googledomains.com",
                            "ns-cloud-e2.googledomains.com",
                            "ns-cloud-e3.googledomains.com",
                            "ns-cloud-e4.googledomains.com",
                        },
                    },
                },
            },
            ContactSettings: &dnscontact,
        },
        Parent:      parent,
        YearlyPrice: domaininfo.YearlyPrice,
    }

    if _, err := c.RegisterDomain(ctx, req); err != nil {
        return err
    }

    return nil
}