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

Autopilot Standard

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, use a calculadora de preços.

Novos Google Cloud usuários podem estar qualificados para um teste sem custo financeiro.

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

Faça login na sua Google Cloud conta do. Se você começou a usar o Google Cloud, crie uma conta para avaliar o desempenho dos nossos produtos em situações reais. Clientes novos também recebem US $300 em créditos para executar, testar e implantar cargas de trabalho.

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

Roles required to create a project

To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Google Kubernetes Engine, Cloud DNS APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

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

Roles required to create a project

To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Google Kubernetes Engine, Cloud DNS APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

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ê 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, 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 Entrada:

   ---
   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. Esse recurso provisiona um certificado SSL gerenciado pelo Google (clássico).
   • 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

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto atual para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos nele.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um ID do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja explorar várias arquiteturas, tutoriais e guias de início rápido, a reutilização de projetos pode evitar que você exceda limites da cota.

Excluir um Google Cloud projeto:

gcloud projects delete PROJECT_ID

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.