Com o crescimento das aplicações na nuvem, garantir que elas estejam protegidas por SSL/TLS é uma prática essencial. O Google Cloud Platform (GCP) oferece diferentes formas de gerenciamento de certificados SSL, incluindo a possibilidade de emitir e vincular certificados a um Load Balancer. Uma abordagem moderna para isso é o uso de DNS Authorization para a validação dos certificados, e o uso de Certificate Maps para organizar e gerenciar vários certificados.

Neste post, vamos explorar como criar certificados com autorização via DNS, como configurar um Load Balancer e vinculá-lo ao certificado criado, usando a ferramenta de infraestrutura como código, Terraform. Além disso, vamos diferenciar entre certificados e Load Balancers clássicos e suas versões mais modernas no GCP.

Diferença entre Certificado e Certificado Clássico

No GCP, o certificado clássico refere-se à forma antiga, embora ainda válida, de gerenciar certificados SSL. Nesse processo, diferente da forma mais moderna, o certificado ficava ligado diretamente a um Load Balancer (LB), havendo uma limitação de 15 certs por LB.

Como não conseguimos gerar certificados wildcard nesse modelo, essa limitação pode se tornar um problema.

Outro ponto negativo dos certificados clássicos é a necessidade de apontar o domínio para o LB antes do certificado já estar gerado. Embora possa não parecer um problema muito grande para novos produtos, em cenários de migração pode acabar gerando um downtime da aplicação.

Já os certificados gerenciados mais moderno, diferentemente dos clássicos, não fica diretamente ligado a um LB. Seu vínculo se dá através da utilização de Certificate Maps e Certificate Map Entry.

Essa abordagem de “mapeamento” de certificado, facilita o processo de gestão, mudança e reutilização de um certificado entre vários LBs.

Além desse novo modelo suportar certificados wildcard, a limitação de certs por LB também é maior, chegando a 1 milhão.

Outro ponto importante é que a nova geração de certificados pode ser realizada via DNS Authorization, removendo assim a necessidade de apontamento do domínio antes de ter um certificado pronto para o uso.

Diferença entre Load Balancer e Load Balancer Clássico

O Load Balancer clássico no GCP é uma solução mais rígida, com menos flexibilidade para integrações avançadas como balanceamento multi-regional ou a adição de múltiplos certificados de forma dinâmica.

Já o Load Balancer moderno oferece maior flexibilidade e escalabilidade. Ele suporta balanceamento global e regional, permite a utilização de Certificate Maps, facilitando o processo de vinculação de certificados a múltiplos domínios e serviços.

Como criar certificado com DNS Authorization

Para criar um certificado com DNS Authorization no GCP utilizando Terraform, o primeiro passo é definir o recurso do certificado gerenciado, que automatizará a emissão e renovação do certificado após a autorização via DNS.

resource "google_certificate_manager_dns_authorization" "my_dns_auth" {
    name = "my-dns-auth"
    domain = "example.com"
}

resource "google_certificate_manager_certificate" "my_certificate" {
    name = "my-certificate"
    scope = "DEFAULT"
    managed {
       domains = ["*.example.com"]
       dns_authorizations = [google_certificate_manager_dns_authorization.my_dns_auth.id]
    }
}

Nesse código, estamos criando uma autorização DNS para o domínio “example.com”, em seguida, criando um certificado gerenciado atrelado à autorização DNS previamente configurada.

Note que o domínio utilizado no DNS Authorization não é wildcard.

Como criar Load Balancer

Agora que o certificado foi criado, vamos configurar o Load Balancer.

No GCP, o Load Balancer pode ser configurado para operar tanto em nível global quanto regional. Vamos focar no cenário global, usando Terraform para simplificar a configuração.

resource "google_compute_global_address" "lb_ip" {
    name = "lb-ip"
    address_type = "EXTERNAL"
}

resource "google_compute_global_forwarding_rule" "default" {
    name = "global-forwarding-rule"
    target = google_compute_target_https_proxy.default.id
    port_range = "443"
    ip_address = google_compute_global_address.lb_ip.address
    load_balancing_scheme = "EXTERNAL_MANAGED"
}

resource "google_compute_url_map" "default" {
    name = "http-lb"
    default_service = google_compute_backend_service.default.id
}

resource "google_compute_backend_service" "default" {
    name = "backend-service"
    port_name = "https"
    protocol = "HTTPS"
    load_balancing_scheme = "EXTERNAL_MANAGED"
    health_checks = [google_compute_health_check.default.id]
    
    backend {
        group = google_compute_instance_group.default.self_link
    }
}

resource "google_compute_instance_group" "default" {
    name = "instance-group"
    base_instance_name = "instance"
    zone = "us-central1-a"
}

resource "google_compute_health_check" "default" {
    name = "http-health-check"
    check_interval_sec = 5
    timeout_sec = 5
    healthy_threshold = 2
    unhealthy_threshold = 2
    http_health_check {
        port = "443"
        request_path = "/healthz/ingress"
    }
}

Nesse exemplo, criamos um Load Balancer global com um backend service associado a um grupo de instâncias, além de configurar um health check para monitoramento.

Como vincular o Certificado ao Load Balancer

Agora que o certificado e o Load Balancer estão configurados, vamos vincular o certificado ao Load Balancer utilizando um Certificate Map.

resource "google_certificate_manager_certificate_map" "my_cert_map" {
    name = "my-cert-map"
}

resource "google_certificate_manager_certificate_map_entry" "my_cert_map_entry" {
    name = "my-cert-map-entry"
    map = google_certificate_manager_certificate_map.my_cert_map.id
    certificates = [google_certificate_manager_certificate.my_certificate.id]
    hostname = "*.example.com"
}

resource "google_compute_target_https_proxy" "https_proxy" {
    name = "https-lb-proxy"
    certificate_map = "//certificatemanager.googleapis.com/${google_certificate_manager_certificate_map.my_certificate_map.id}"
    url_map = google_compute_url_map.default.id
}

Aqui, criamos um Certificate Map e adicionamos uma entrada que vincula o certificado gerenciado ao Load Balancer, usando um proxy HTTPS.

Conclusão

Criar e gerenciar certificados SSL no GCP ficou muito mais simples com a introdução da autorização via DNS Authorization e dos Certificate Maps.

Utilizando essa abordagem, é possível automatizar a emissão e renovação de certificados, além de vincular vários domínios ao mesmo Load Balancer de forma eficiente e sem a necessidade de apontar o domínio antes da emissão do certificado.

Com o uso de Terraform, é possível automatizar e versionar todo o processo, desde a criação do certificado até a configuração do Load Balancer e sua associação com o certificado. Essa abordagem aumenta a segurança, a escalabilidade e a eficiência operacional em ambientes na nuvem.

Faça parte da comunidade!

Receba os melhores conteúdos sobre Go, Kubernetes, arquitetura de software, Cloud e esteja sempre atualizado com as tendências e práticas do mercado.