Configurar a rede para um cluster de produção básico

Este tutorial é destinado a arquitetos de nuvem e administradores de operações interessados em implantar um aplicativo da Web em um cluster do Google Kubernetes Engine (GKE) e expô-lo com um balanceador de carga HTTPS.

Objetivos

Neste tutorial, você aprenderá a:

• Criar um cluster do GKE.
• Crie um endereço IP global e uma zona do Cloud DNS com o Terraform.
• Configure o balanceamento de carga HTTPS.
• Implante um aplicativo da Web de amostra.

Custos

Neste documento, você vai usar os seguintes componentes faturáveis do Google Cloud:

• GKE
• Cloud Load Balancing
• External IP address

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Para mais informações, consulte Limpeza.

Antes de começar

Criar o projeto

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, click Create project to begin creating a new Google Cloud project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Google Kubernetes Engine, Cloud DNS APIs.

Enable the APIs

In the Google Cloud console, on the project selector page, click Create project to begin creating a new Google Cloud project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Google Kubernetes Engine, Cloud DNS APIs.

Enable the APIs

• Você precisa ser o proprietário de um nome de domínio. O nome do domínio não pode ter mais de 63 caracteres. É preciso usar o Google Domains ou outro registrador.

Configurar o ambiente

Neste tutorial, você vai usar o Cloud Shell para gerenciar recursos hospedados no Google Cloud. O Cloud Shell vem pré-instalado com o software necessário para este tutorial, incluindo o Terraform, o kubectl e a CLI gcloud..

1. Defina as variáveis de ambiente:

   PROJECT_ID=$(gcloud config get-value project)
   gcloud config set project $PROJECT_ID
   gcloud config set compute/region us-central1
   

2. Clone o repositório do código:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
   

3. Mude para o diretório de trabalho:

   cd kubernetes-engine-samples/autopilot/networking-tutorial
   

Criar um cluster do GKE

O seguinte arquivo do Terraform cria um cluster do GKE:

terraform {
  required_version = "~> 1.3"
}

provider "google" {}

variable "region" {
  type        = string
  description = "Region where the cluster will be created."
  default     = "us-central1"
}

variable "cluster_name" {
  type        = string
  description = "Name of the cluster"
  default     = "networking-cluster"
}

resource "google_container_cluster" "default" {
  name             = var.cluster_name
  description      = "Cluster for sample web application"
  location         = var.region
  enable_autopilot = true

  ip_allocation_policy {}
}

output "region" {
  value       = var.region
  description = "Compute region"
}

output "cluster_name" {
  value       = google_container_cluster.default.name
  description = "Cluster name"
}

O arquivo do Terraform a seguir cria um endereço IP global e uma zona do Cloud DNS:

terraform {
  required_version = "~> 1.3"
}

variable "base_domain" {
  type        = string
  description = "Your base domain"
}

variable "name" {
  type        = string
  description = "Name of resources"
  default     = "networking-tutorial"
}

data "google_client_config" "current" {}

resource "google_compute_global_address" "default" {
  name = var.name
}

resource "google_dns_managed_zone" "default" {
  name        = var.name
  dns_name    = "${var.name}.${var.base_domain}."
  description = "DNS Zone for web application"
}

resource "google_dns_record_set" "a" {
  name         = google_dns_managed_zone.default.dns_name
  type         = "A"
  ttl          = 300
  managed_zone = google_dns_managed_zone.default.name

  rrdatas = [google_compute_global_address.default.address]
}

resource "google_dns_record_set" "cname" {
  name         = join(".", compact(["www", google_dns_record_set.a.name]))
  type         = "CNAME"
  ttl          = 300
  managed_zone = google_dns_managed_zone.default.name

  rrdatas = [google_dns_record_set.a.name]
}

output "dns_zone_name_servers" {
  value       = google_dns_managed_zone.default.name_servers
  description = "Write these virtual name servers in your base domain."
}

output "domain" {
  value = trim(google_dns_record_set.a.name, ".")
}

1. Inicialize o Terraform:

   terraform init
   

2. Veja as alterações na infraestrutura:

   terraform plan
   

   Quando solicitado, digite seu domínio, como my-domain.net.

3. Aplique a configuração do Terraform:

   terraform apply --auto-approve
   

   Quando solicitado, digite seu domínio, como my-domain.net.

   O resultado será assim:

   Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
   
   Outputs:
   
   cluster_name = "networking-cluster"
   region = "us-central1"
   

Criar um balanceador de carga de aplicativo externo

1. O manifesto a seguir descreve ManagedCertificate, FrontendConfig, Deployment, Service e Ingress:

   ---
   apiVersion: networking.gke.io/v1
   kind: ManagedCertificate
   metadata:
     name: networking-managed-cert
   spec:
     domains:
       - DOMAIN_NAME
       - www.DOMAIN_NAME
   ---
   apiVersion: networking.gke.io/v1beta1
   kind: FrontendConfig
   metadata:
     name: networking-fc
   spec:
     redirectToHttps:
       enabled: true
       responseCodeName: MOVED_PERMANENTLY_DEFAULT
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: frontend
   spec:
     selector:
       matchLabels:
         app: frontend
     replicas: 2
     template:
       metadata:
         labels:
           app: frontend
       spec:
         containers:
         - name: echo-amd64
           image: us-docker.pkg.dev/google-samples/containers/gke/hello-app-cdn:1.0
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: frontend
   spec:
     type: LoadBalancer
     selector:
       app: frontend
     ports:
     - name: http
       port: 80
       targetPort: 8080
   ---
   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: frontend
     annotations:
       networking.gke.io/managed-certificates: networking-managed-cert
       networking.gke.io/v1beta1.FrontendConfig: networking-fc
       kubernetes.io/ingress.global-static-ip-name: networking-tutorial
       kubernetes.io/ingress.class: gce
     labels:
       app: frontend
   spec:
     defaultBackend:
       service:
         name: frontend
         port:
           number: 80

   Substitua DOMAIN_NAME pelo nome do seu domínio, como my-domain.net.

   Esse manifesto tem as seguintes propriedades:

   • networking.gke.io/managed-certificates: o nome do ManagedCertificate.
   • networking.gke.io/v1beta1.FrontendConfig: o nome do recurso FrontendConfig.
   • kubernetes.io/ingress.global-static-ip-name: o nome do endereço IP
   • kubernetes.io/ingress.class: instrui o controlador de entrada do GKE a criar um balanceador de carga de aplicativo externo.

2. Aplique o manifesto ao cluster:

   kubectl apply -f kubernetes-manifests.yaml
   

3. Verifique se o Ingress foi criado:

   kubectl describe ingress frontend
   

   O resultado será assim:

   ...
     Events:
       Type    Reason  Age   From                     Message
       ----    ------  ----  ----                     -------
       Normal  ADD     2m    loadbalancer-controller  default/frontend
       Normal  CREATE  1m    loadbalancer-controller  ip: 203.0.113.2
   ...
   

   O provisionamento do Ingress pode levar alguns minutos.

Testar aplicativo

1. Verifique o status do certificado SSL:

   kubectl get managedcertificates.networking.gke.io networking-managed-cert
   

   O certificado SSL pode levar até 30 minutos para ser provisionado. A saída a seguir indica que o certificado SSL está pronto:

   NAME                      AGE   STATUS
   networking-managed-cert   28m   Active
   

2. Execute um comando curl:

   curl -Lv https://DOMAIN_NAME
   

   O resultado será assim:

   *   Trying 34.160.115.33:443...
   * Connected to DOMAIN_NAME (34.160.115.33) port 443 (#0)
   ...
   * TLSv1.3 (IN), TLS handshake, Certificate (11):
   ...
   * Server certificate:
   *  subject: CN=DOMAIN_NAME
   ...
   > Host: DOMAIN_NAME
   

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Excluir o projeto

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Excluir recursos individuais

1. Exclua os recursos do Kubernetes:

   kubectl delete -f kubernetes-manifests.yaml
   

2. Exclua os recursos do Terraform:

   terraform destroy --auto-approve
   

   Quando solicitado, digite seu domínio, como my-domain.net.

A seguir

• Saiba mais sobre a rede do GKE.