Como configurar nomes de domínio com endereços IP estáticos

Autopilot Standard

Neste tutorial, demonstramos como usar o Google Kubernetes Engine (GKE) para publicar seu aplicativo da Web na Internet em um endereço IP externo estático e configurar um nome de domínio para apontar para o aplicativo.

Neste tutorial, presumimos que você tenha um nome de domínio registrado, como example.com.

Observação: este tutorial usa o Controlador de entrada do GKE integrado e não se aplica ao Controlador de entrada NGINX.

Objetivos

O tutorial demonstra as seguintes etapas:

• Reservar um endereço IP externo e estático para o aplicativo.
• Configurar um dos recursos Serviço ou Ingress para usar o endereço IP estático
• Atualizar registros DNS do seu nome de domínio para que apontem para seu aplicativo.

Custos

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

• GKE

Para gerar uma estimativa de custo baseada na sua projeção de uso, utilize a calculadora de preços.

Novos usuários do Google Cloud 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

Siga estas etapas para ativar a API do Kubernetes Engine:

1. Acesse a página do Kubernetes Engine no console do Google Cloud .
2. Crie ou selecione um projeto.
3. Aguarde a ativação da API e dos serviços relacionados. Isso pode levar alguns minutos.

4. Verify that billing is enabled for your Google Cloud project.

Instale as ferramentas de linha de comando a seguir usadas neste tutorial:

• gcloud é usado para criar e excluir clusters do Kubernetes Engine. O gcloud está incluído na gcloud CLI.
• O kubectl é usado para gerenciar o Kubernetes, o sistema de orquestração de cluster usado pelo Kubernetes Engine. É possível instalar kubectl usando gcloud:

  gcloud components install kubectl

Clone o código de amostra do GitHub:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
cd kubernetes-engine-samples/quickstarts/hello-app/manifests

Definir padrões para a ferramenta de linha de comando gcloud

Para poupar tempo, em vez de digitar o ID do projeto e as opções de zona do Compute Engine na ferramenta de linha de comando gcloud, defina os padrões:

gcloud config set project project-id
gcloud config set compute/zone compute-zone

Crie um cluster

Crie um cluster:

gcloud container clusters create-auto domain-test

Implantar seu web app

No manifesto a seguir, veja uma implantação que executa uma imagem de amostra do contêiner de aplicativo da Web:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloweb
  labels:
    app: hello
spec:
  selector:
    matchLabels:
      app: hello
      tier: web
  template:
    metadata:
      labels:
        app: hello
        tier: web
    spec:
      containers:
      - name: hello-app
        image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: 200m

Crie a implantação:

kubectl apply -f helloweb-deployment.yaml

Expor seu aplicativo

Você pode expor seu aplicativo no GKE usando um dos seguintes métodos:

• Usar um Serviço, que cria um balanceador de carga de rede de passagem externa que funciona com endereços IP regionais.

• Usar um Ingress, que cria um balanceador de carga de aplicativo e aceita endereços IP globais.

Para saber mais sobre as vantagens e desvantagens de cada método, consulte Como configurar um balanceador de carga de aplicativo externo com Ingress.

Usar um serviço

Para garantir que o aplicativo tenha um endereço IP externo estático, é preciso reservar um endereço IP estático.

Observação: os endereços IP estáticos não têm custo quando usados por um balanceador de carga. Se você reservar um endereço IP estático e não usá-lo, a cobrança será feita conforme os preços de endereços IP não utilizados.

Se você decidir expor o aplicativo usando um Serviço, precisará criar um endereço IP regional. Endereços IP globais só funcionam com o tipo de recurso de entrada, conforme explicado na próxima seção.

Para usar um serviço, crie um endereço IP estático chamado helloweb-ip na região us-central1:

gcloud

gcloud compute addresses create helloweb-ip --region us-central1

Encontre o endereço IP estático que você criou:

gcloud compute addresses describe helloweb-ip --region us-central1

O resultado será assim:

...
address: 203.0.113.32
...

Config Connector

Observação: esta etapa requer o Config Connector. Siga estas instruções para instalar o Config Connector no cluster.

apiVersion: compute.cnrm.cloud.google.com/v1beta1
kind: ComputeAddress
metadata:
  name: helloweb-ip
spec:
  location: us-central1

Salve o manifesto como compute-address-regional.yaml.

Aplique o manifesto ao cluster:

  kubectl apply -f compute-address-regional.yaml

Encontre o endereço IP estático que você criou:

  kubectl get computeaddress helloweb-ip -o jsonpath='{.spec.address}'

O manifesto a seguir descreve um Serviço do tipo LoadBalancer, que cria um balanceador de carga de rede de passagem externa para expor pods com um endereço IP externo.

apiVersion: v1
kind: Service
metadata:
  name: helloweb
  labels:
    app: hello
  annotations:
    networking.gke.io/load-balancer-ip-addresses: "helloweb-ip"
spec:
  selector:
    app: hello
    tier: web
  ports:
  - port: 80
    targetPort: 8080
  type: LoadBalancer

Criar o serviço:

kubectl apply -f helloweb-service-static-ip.yaml

Veja o endereço IP reservado associado ao balanceador de carga:

kubectl get service

O resultado será assim:

NAME               CLUSTER-IP      EXTERNAL-IP      PORT(S)          AGE
helloweb           10.31.254.176   203.0.113.32     80:30690/TCP     54s

Observação: o provisionamento e a configuração do balanceador de carga podem levar alguns minutos.

Usar uma entrada

Se você decidir expor o aplicativo usando um Ingress, precisará reservar um endereço IP estático global. Use a anotação kubernetes.io/ingress.global-static-ip-name para especificar um endereço IP global.

Para expor seu aplicativo a clientes e serviços em uma região, use um endereço IP interno estático regional ao implantar um recurso de entrada interno para o GKE com as anotações necessárias.

Para saber como usar o Ingress para expor seus aplicativos à Internet, consulte Como configurar um balanceador de carga de aplicativo externo com Ingress.

Observação: os endereços IP estáticos não têm custo quando usados por um balanceador de carga. Se você reservar um endereço IP estático e não usá-lo, a cobrança será feita conforme os preços de endereços IP não utilizados.

Para criar um endereço IP estático global chamado helloweb-ip:

gcloud

gcloud compute addresses create helloweb-ip --global

Encontre o endereço IP estático que você criou:

gcloud compute addresses describe helloweb-ip --global

O resultado será assim:

...
address: 203.0.113.32
...

Config Connector

Observação: esta etapa requer o Config Connector. Siga estas instruções para instalar o Config Connector no cluster.

apiVersion: compute.cnrm.cloud.google.com/v1beta1
kind: ComputeAddress
metadata:
  name: helloweb-ip
spec:
  location: global

Salve o manifesto como compute-address-global.yaml.

Aplique o manifesto ao cluster:

  kubectl apply -f compute-address-global.yaml

No manifesto a seguir, é descrita uma entrada que expõe um aplicativo da Web em um IP estático com dois recursos:

• Um Service com type:NodePort
• Um Ingress configurado com o nome do serviço e a anotação de IP estática

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: helloweb
  annotations:
    kubernetes.io/ingress.global-static-ip-name: helloweb-ip
  labels:
    app: hello
spec:
  defaultBackend:
    service:
      name: helloweb-backend
      port:
        number: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: helloweb-backend
  labels:
    app: hello
spec:
  type: NodePort
  selector:
    app: hello
    tier: web
  ports:
  - port: 8080
    targetPort: 8080

A anotação kubernetes.io/ingress.global-static-ip-name especifica o nome do recurso de endereço IP global a ser associado ao balanceador de carga.

Aplique o manifesto ao cluster:

kubectl apply -f helloweb-ingress-static-ip.yaml

Veja o endereço IP associado ao balanceador de carga:

kubectl get ingress

A saída será assim

NAME       HOSTS     ADDRESS          PORTS     AGE
helloweb   *         203.0.113.32     80        4m

Observação: o provisionamento e a configuração do balanceador de carga podem levar alguns minutos.

Ver seu endereço IP estático reservado

Para verificar se o balanceador de carga está configurado corretamente, é possível usar um navegador da Web para acessar o endereço IP ou usar curl:

curl http://203.0.113.32/

O resultado será assim:

Hello, world!
Hostname: helloweb-3766687455-8lvqv

Observação: se você tiver usado um Ingress para configurar um balanceador de carga, talvez encontre erros HTTP 404 e HTTP 500 por alguns minutos. Leva algum tempo para as mudanças de configuração se propagarem em regiões do mundo inteiro.

Configurar seus registros de nome de domínio

Para que os navegadores que consultam seu nome de domínio (como example.com) ou subdomínio (como blog.example.com) apontem para o endereço IP estático reservado, atualize os registros DNS de seu nome de domínio.

Crie um registro DNS do tipo A (Endereço) para o nome de domínio ou subdomínio e configure o valor dele com o endereço IP reservado.

Os registros DNS do domínio são gerenciados pelo servidor de nomes. O servidor de nomes pode ser o "registrador" em que você registrou o domínio, um serviço DNS como o Cloud DNS ou outro provedor de terceiros.

• Se o servidor de nomes for o Cloud DNS: siga o guia de início rápido do Cloud DNS para configurar o registro A de DNS do nome de domínio com o endereço IP reservado do aplicativo.

• Se o servidor de nomes for outro provedor: consulte a documentação do provedor de DNS sobre como definir registros A de DNS para configurar o nome de domínio. Se você optar por usar o Cloud DNS em vez disso, consulte Como migrar para o Cloud DNS.

Acessar seu nome de domínio

Para verificar se os registros A do DNS do domínio são resolvidos para o endereço IP reservado, visite o nome de domínio.

Observação: a propagação dos registros DNS pode levar algumas horas. Esse tempo pode depender dos servidores de nomes, do provedor de acesso à Internet (ISP, na sigla em inglês) local e de muitos outros fatores.

Para fazer uma consulta DNS para o registro A do seu nome de domínio, execute o comando host:

host example.com

O resultado será assim:

example.com has address 203.0.113.32

Agora, é possível direcionar o navegador da Web para seu nome de domínio e acessar o site.

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.

1. Exclua o Serviço e o Ingress:

   kubectl delete ingress,service -l app=hello
   

2. Libere o IP estático reservado. Depois que o balanceador de carga for excluído, o endereço IP não utilizado, mas reservado, será cobrado conforme os preços de endereços IP não utilizados.

   • Se você usou um serviço:

     gcloud compute addresses delete helloweb-ip --region us-central1
     

   • Se você usou uma entrada:

     gcloud compute addresses delete helloweb-ip --global
     

3. Exclua o aplicativo de amostra:

   kubectl delete -f helloweb-deployment.yaml
   

4. Exclua o cluster:

   gcloud container clusters delete domain-test
   

A seguir

• Explore outros tutoriais do Kubernetes Engine.
• Confira arquiteturas de referência, diagramas, tutoriais e práticas recomendadas do Google Cloud. Confira o Centro de arquitetura do Cloud.