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

Neste tutorial, você verá como publicar seu aplicativo da Web na Internet em um endereço IP externo e estático, além de configurar registros DNS do nome de domínio para que indiquem o aplicativo.

Este tutorial pressupõe que você tem um nome de domínio registrado (como example.com). É possível registrar um nome de domínio no Google Domains ou em outro registro de domínios de sua preferência, caso não tenha um.

Objetivos

O tutorial demonstra as seguintes etapas:

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

Antes de começar

Siga estas etapas para ativar a API 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. Verifique se o faturamento foi ativado no projeto do Google Cloud Platform. Saiba como confirmar que o faturamento está ativado para seu projeto.

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

  • gcloud é usado para criar e excluir clusters do Kubernetes Engine. gcloud está incluído no SDK do Google Cloud.
  • 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

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_ENGINE_ZONE]

Criar um cluster do GKE

Crie um cluster de contêiner chamado domain-test para implantar seu aplicativo da Web:

gcloud container clusters create domain-test

Etapa 1: implantar o aplicativo da Web

Para implantar o aplicativo da Web de exemplo, salve o manifesto a seguir como helloweb-deployment.yaml:

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: gcr.io/google-samples/hello-app:1.0
        ports:
        - containerPort: 8080

Em seguida, execute o seguinte comando para criar a implantação:

kubectl apply -f helloweb-deployment.yaml

Etapa 2: publicar o aplicativo

É possível publicar o aplicativo no GKE usando um dos seguintes métodos:

Para saber mais sobre os prós e os contras de cada método, consulte o Tutorial de balanceamento de carga HTTP.

Etapa 2(a): como usar um serviço

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

Se você optar por publicar 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 Ingress, 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
  

Para encontrar o endereço IP estático que você criou, execute o seguinte comando:

  gcloud compute addresses describe helloweb-ip --region us-central1
  
Saída:
  address: 203.0.113.32
  ...
  

Configurar conector

Observação: esta etapa requer Configurar conector . Siga as instruções de instalação para instalar Configurar conector no cluster.

Ver no GitHub (em inglês)
apiVersion: compute.cnrm.cloud.google.com/v1alpha2
kind: ComputeAddress
metadata:
  name: helloweb-ip
spec:
  location: us-central1
Para implantar esse manifesto, faça o download dele para sua máquina como compute-address-regional.yaml e execute:
kubectl apply -f compute-address-regional.yaml

Use o seguinte manifesto para criar um arquivo de manifesto chamado helloweb-service.yaml que descreve um serviço. Substitua YOUR.IP.ADDRESS.HERE pelo endereço IP estático:

apiVersion: v1
kind: Service
metadata:
  name: helloweb
  labels:
    app: hello
spec:
  selector:
    app: hello
    tier: web
  ports:
  - port: 80
    targetPort: 8080
  type: LoadBalancer
  loadBalancerIP: "YOUR.IP.ADDRESS.HERE"

Em seguida, crie o serviço:

kubectl apply -f helloweb-service.yaml

Para ver o endereço IP reservado associado ao balanceador de carga:

kubectl get service
Saída:
NAME               CLUSTER-IP      EXTERNAL-IP      PORT(S)          AGE
helloweb           10.31.254.176   203.0.113.32     80:30690/TCP     54s

Etapa 2(b): como usar um Ingress

Se você escolher publicar o aplicativo usando um Ingress (em inglês), que cria um balanceador de carga HTTP(S), será preciso reservar um endereço IP estático global. Endereços IP regionais não funcionam com Ingress.

Para saber mais sobre como usar o Ingress para publicar seus aplicativos na internet, consulte o tutorial Balanceamento de carga HTTP com Ingress.

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

gcloud

  gcloud compute addresses create helloweb-ip --global
  

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

  gcloud compute addresses describe helloweb-ip --global
  
Saída:
  address: 203.0.113.32
  ...
  

Configurar conector

Observação: esta etapa requer Configurar conector . Siga as instruções de instalação para instalar Configurar conector no cluster.

Ver no GitHub (em inglês)
apiVersion: compute.cnrm.cloud.google.com/v1alpha2
kind: ComputeAddress
metadata:
  name: helloweb-ip
spec:
  location: global
Para implantar esse manifesto, faça o download dele para sua máquina como compute-address-global.yaml e execute:
kubectl apply -f compute-address-global.yaml

Para publicar um aplicativo da Web em um IP estático usando o Ingress, você precisa implantar dois recursos:

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

Use o seguinte manifesto para criar um arquivo de manifesto chamado helloweb-ingress.yaml descrevendo estes dois recursos:

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: helloweb
  annotations:
    kubernetes.io/ingress.global-static-ip-name: helloweb-ip
  labels:
    app: hello
spec:
  backend:
    serviceName: helloweb-backend
    servicePort: 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 HTTP(S).

Aplique o arquivo de manifesto helloweb-ingress.yaml ao cluster:

kubectl apply -f helloweb-ingress.yaml
Saída:
ingress "helloweb" created
service "helloweb-backend" created

Para ver o endereço IP da reserva associado ao balanceador de carga:

kubectl get ingress
Saída:
NAME       HOSTS     ADDRESS          PORTS     AGE
helloweb   *         203.0.113.32     80        4m

Etapa 3: visitar 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
Saída:
Hello, world!
Hostname: helloweb-3766687455-8lvqv

Etapa 4: configurar seus registros de nomes 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 onde você registrou o domínio (em outras palavras, seu "registrador") ou pode ser um serviço de DNS, como o Google Cloud DNS ou outro provedor.

  • Se o servidor de nomes for o Google 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 serviço DNS sobre como definir registros A de DNS para configurar o nome de domínio. Se você optar por usar o Google Cloud DNS em vez disso, consulte Como migrar para o Cloud DNS.

Etapa 5: visitar 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.

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

host example.com
Saída:
example.com has address 203.0.113.32

Neste ponto, você pode apontar o navegador da Web para o nome de domínio e visitar o site.

Como fazer a limpeza

Para evitar que os recursos usados neste tutorial sejam cobrados na conta do Google Cloud Platform:

  1. Exclua os recursos de balanceamento de carga:

    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, não será mais gratuito e será cobrado pelo preço de endereço IP não utilizado. Execute os comandos a seguir para liberar o recurso de IP estático:

    • Se você seguiu a Etapa 2(a):

      gcloud compute addresses delete helloweb-ip --region us-central1
    • Se você seguiu a Etapa 2(b):

      gcloud compute addresses delete helloweb-ip --global
  3. Exclua o aplicativo de amostra:

    kubectl delete -f helloweb-deployment.yaml

  4. Aguarde até que o balanceador de carga seja excluído por meio da observação da saída do comando a seguir (a saída não precisa mostrar uma regra de encaminhamento que contenha "helloweb" no nome):

    gcloud compute forwarding-rules list

  5. Exclua o cluster do contêiner:

    gcloud container clusters delete domain-test

A seguir