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.

Neste tutorial, presumimos que você tenha um nome de domínio registrado (como example.com). É possível registrar um nome de domínio por meio do Google Domains ou de outro registro de domínios que quiser, 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 os recursos de serviço ou entrada 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 do Kubernetes Engine:
  1. Acesse a página do Kubernetes Engine no console do Google Cloud Platform.
  2. Crie ou selecione um projeto.
  3. Aguarde a ativação da API e dos serviços relacionados. Isso pode demorar alguns minutos.
  4. Verifique se o faturamento foi ativado para o projeto.

    Saiba como ativar o faturamento

Instale as seguintes ferramentas de linha de comando usadas neste tutorial:

  • O gcloud é usado para criar e excluir clusters do Kubernetes Engine. O gcloud está incluído no Google Cloud SDK.
  • O kubectl é utilizado para gerenciar o Kubernetes, o sistema de orquestração de clusters do Kubernetes Engine. É possível instalar o kubectl usando o gcloud:
    gcloud components install kubectl

Definir padrões da ferramenta de linha de comando gcloud

Para não perder tempo digitando o código 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 us-central1-b

Criar um cluster do GKE

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

gcloud container clusters create domain-test

Etapa 1: implantar o aplicativo da Web

Para implantar o aplicativo da Web de amostra, salve o seguinte manifesto 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 comando a seguir para criar a Implantação:

kubectl apply -f helloweb-deployment.yaml

Etapa 2: expor o aplicativo

É possível expor seu 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 criar um endereço IP estático denominado helloweb-ip na região us-central1, execute o seguinte comando:

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

Use o manifesto a seguir para criar um arquivo de manifesto denominado 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 da reserva 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 uma entrada

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

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

Para criar um endereço IP estático global denominado helloweb-ip, execute o comando a seguir:

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

Para expor 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 anotação de IP estático

Use o manifesto a seguir para criar um arquivo de manifesto chamado helloweb-ingress.yaml que descreve esses 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, você pode acessar o endereço IP usando um navegador da Web 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 consultem seu nome de domínio (como example.com) ou para que o nome do subdomínio (como blog.example.com) aponte para o endereço IP estático que você reservou, é preciso atualizar os registros de servidor de nomes de domínio (DNS, na sigla em inglês) do seu nome de domínio.

É preciso criar um registro DNS do tipo A (Endereço) para o nome de domínio ou subdomínio e configurar 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 sobre o registro A do 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 é excluído, o endereço IP não utilizado, mas reservado, não é mais gratuito e é cobrado conforme os preços do 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

Próximas etapas

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Tutoriais do Kubernetes Engine