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

Autopilot Padrão

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ê usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

Configurar o projeto

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

No console do Google Cloud, na página do seletor de projetos, clique em Criar projeto para começar a criar um novo projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs Google Kubernetes Engine, Cloud DNS.

Ative as APIs

No console do Google Cloud, na página do seletor de projetos, clique em Criar projeto para começar a criar um novo projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs Google Kubernetes Engine, Cloud DNS.

Ative as 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.

Configure seu 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, o kubectl e a CLI gcloud..

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

Clone o repositório do código:

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

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, ".")
}

Inicialize o Terraform:
```
terraform init
```
Veja as alterações na infraestrutura:
```
terraform plan
```
Quando solicitado, digite seu domínio, como my-domain.net.

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

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.

Aplique o manifesto ao cluster:

kubectl apply -f kubernetes-manifests.yaml

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

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
```

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

Limpeza

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.

Exclua o projeto

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código 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 passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

Exclua um projeto do Google Cloud:

gcloud projects delete PROJECT_ID

Excluir recursos individuais

Exclua os recursos do Kubernetes:

kubectl delete -f kubernetes-manifests.yaml

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.