Configure um balanceador de carga de aplicações externo com a entrada

Implementar uma app Web

O manifesto seguinte descreve uma Implementação que executa a imagem do contentor da aplicação Web de exemplo num servidor HTTP na porta 8080:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
  namespace: default
spec:
  selector:
    matchLabels:
      run: web
  template:
    metadata:
      labels:
        run: web
    spec:
      containers:
      - image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
        imagePullPolicy: IfNotPresent
        name: web
        ports:
        - containerPort: 8080
          protocol: TCP

Aplique o recurso ao cluster:

kubectl apply -f web-deployment.yaml

Expor a sua implementação no cluster

O manifesto seguinte descreve um Service que torna a implementação web acessível no cluster de contentores:

apiVersion: v1
kind: Service
metadata:
  name: web
  namespace: default
spec:
  ports:
  - port: 8080
    protocol: TCP
    targetPort: 8080
  selector:
    run: web
  type: NodePort

1. Aplique o recurso ao cluster:

   kubectl apply -f web-service.yaml
   

   Quando cria um serviço do tipo NodePort com este comando, o GKE disponibiliza o seu serviço num número de porta elevado selecionado aleatoriamente (por exemplo, 32640) em todos os nós no seu cluster.

2. Verifique se o serviço foi criado e se foi atribuída uma porta de nó:

   kubectl get service web
   

   Saída:

   NAME      TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
   web       NodePort   10.35.245.219   <none>        8080:32640/TCP   5m
   

   No exemplo de saída, a porta do nó para o serviço web é 32640. Tenha também em atenção que não existe nenhum IP externo atribuído a este serviço. Uma vez que os nós do GKE não são acessíveis externamente por predefinição, a criação deste serviço não torna a sua aplicação acessível a partir da Internet.

Para tornar a sua aplicação de servidor Web HTTP(S) acessível publicamente, tem de criar um recurso Ingress.

Criar um recurso Ingress

O Ingress é um recurso do Kubernetes que encapsula uma coleção de regras e configuração para encaminhar tráfego HTTP(S) externo para serviços internos.

No GKE, o Ingress é implementado através do Cloud Load Balancing. Quando cria um Ingress no seu cluster, o GKE cria um balanceador de carga HTTP(S) e configura-o para encaminhar o tráfego para a sua aplicação.

O manifesto seguinte descreve um recurso Ingress que direciona o tráfego para o seu serviço web:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: basic-ingress
spec:
  defaultBackend:
    service:
      name: web
      port:
        number: 8080

Aplique o recurso ao cluster:

kubectl apply -f basic-ingress.yaml

Depois de implementar este manifesto, o Kubernetes cria um recurso Ingress no seu cluster. O controlador Ingress do GKE cria e configura um balanceador de carga HTTP(S) de acordo com as informações no Ingress, encaminhando todo o tráfego HTTP externo (na porta 80) para o serviço web NodePort que expôs.

Visitar a sua aplicação

Descubra o endereço IP externo do balanceador de carga que serve a sua aplicação executando o seguinte comando:

kubectl get ingress basic-ingress

NAME            HOSTS     ADDRESS         PORTS     AGE
basic-ingress   *         203.0.113.12    80        2m

Abra o endereço IP externo da sua aplicação num navegador e veja uma resposta HTTP de texto simples, como a seguinte:

Hello, world!
Version: 1.0.0
Hostname: web-6498765b79-fq5q5

Pode visitar o Equilíbrio de carga na Google Cloud consola e inspecionar os recursos de rede criados pelo controlador GKE Ingress.

(Opcional) Configurar um endereço IP estático

Quando expõe um servidor Web num nome de domínio, precisa que o endereço IP externo de uma aplicação seja um IP estático que não se altere.

Por predefinição, o GKE atribui endereços IP externos temporários para aplicações HTTP expostas através de um Ingress. Os endereços efémeros estão sujeitos a alterações. Se planeia executar a sua aplicação durante muito tempo, tem de usar um endereço IP externo estático.

Tenha em atenção que, depois de configurar um IP estático para o recurso Ingress, a eliminação do Ingress não elimina o endereço IP estático associado. Certifique-se de que limpa os endereços IP estáticos que configurou quando já não planeia usá-los novamente.

Para configurar um endereço IP estático, conclua os seguintes passos:

1. Reserve um endereço IP externo estático denominado web-static-ip:

   gcloud

   gcloud compute addresses create web-static-ip --global
   

   Config Connector

   Nota: este passo requer o Config Connector. Siga as instruções de instalação para instalar o Config Connector no seu cluster.

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

   Para implementar este manifesto, transfira-o para a sua máquina como compute-address.yaml e execute:

   kubectl apply -f compute-address.yaml

2. O manifesto basic-ingress-static.yaml adiciona uma anotação na entrada para usar o recurso de IP estático denominado web-static-ip:

   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: basic-ingress
     annotations:
       kubernetes.io/ingress.global-static-ip-name: "web-static-ip"
   spec:
     defaultBackend:
       service:
         name: web
         port:
           number: 8080

   Veja o manifesto:

   cat basic-ingress-static.yaml
   

3. Aplique o recurso ao cluster:

   kubectl apply -f basic-ingress-static.yaml
   

4. Verifique o endereço IP externo:

   kubectl get ingress basic-ingress
   

   Aguarde até que o endereço IP da sua aplicação mude para usar o endereço IP reservado do recurso web-static-ip.

   A atualização do recurso Ingress existente, a reconfiguração do equilibrador de carga e a propagação das regras de equilíbrio de carga em todo o mundo podem demorar alguns minutos. Após a conclusão desta operação, o GKE liberta o endereço IP efémero atribuído anteriormente à sua aplicação.

(Opcional) Publicar várias aplicações num balanceador de carga

Pode executar vários serviços num único equilibrador de carga e IP público configurando regras de encaminhamento no Ingress. Ao alojar vários serviços no mesmo Ingress, pode evitar a criação de equilibradores de carga adicionais (que são recursos faturáveis) para cada serviço que expõe à Internet.

O manifesto seguinte descreve uma implementação com a versão 2.0 da mesma aplicação Web:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web2
  namespace: default
spec:
  selector:
    matchLabels:
      run: web2
  template:
    metadata:
      labels:
        run: web2
    spec:
      containers:
      - image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
        imagePullPolicy: IfNotPresent
        name: web2
        ports:
        - containerPort: 8080
          protocol: TCP

Aplique o recurso ao cluster:

kubectl apply -f web-deployment-v2.yaml

O manifesto seguinte descreve um serviço que expõe web2 internamente ao cluster num serviço NodePort denominado web2:

apiVersion: v1
kind: Service
metadata:
  name: web2
  namespace: default
spec:
  ports:
  - port: 8080
    protocol: TCP
    targetPort: 8080
  selector:
    run: web2
  type: NodePort

Aplique o recurso ao cluster:

kubectl apply -f web-service-v2.yaml

O manifesto seguinte descreve um recurso Ingress que:

• Encaminha os pedidos com o caminho que começa com /v2/ para o serviço web2
• Encaminha todos os outros pedidos para o web serviço

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: fanout-ingress
spec:
  rules:
  - http:
      paths:
      - path: /*
        pathType: ImplementationSpecific
        backend:
          service:
            name: web
            port:
              number: 8080
      - path: /v2/*
        pathType: ImplementationSpecific
        backend:
          service:
            name: web2
            port:
              number: 8080

Aplique o recurso ao cluster:

kubectl create -f fanout-ingress.yaml

Após a implementação do Ingress, execute kubectl get ingress fanout-ingress para saber o endereço IP público do cluster.

Em seguida, aceda ao endereço IP para ver que ambas as aplicações estão acessíveis no mesmo balanceador de carga:

• Aceda a http://<IP_ADDRESS>/ e repare que a resposta contém Version: 1.0.0 (uma vez que o pedido é encaminhado para o serviço web)
• Aceda a http://<IP_ADDRESS>/v2/ e repare que a resposta contém Version: 2.0.0 (uma vez que o pedido é encaminhado para o serviço web2)

O único caráter universal suportado para o campo path de um Ingress é o caráter *. O caráter * tem de seguir uma barra (/) e tem de ser o último caráter no padrão. Por exemplo, /*, /foo/* e /foo/bar/* são padrões válidos, mas *, /foo/bar* e /foo/*/bar não são.

Um padrão mais específico tem precedência sobre um padrão menos específico. Se tiver /foo/* e /foo/bar/*, considera-se que /foo/bar/bat corresponde a /foo/bar/*.

Para mais informações sobre as limitações de caminhos e a correspondência de padrões, consulte a documentação dos mapas de URLs.

(Opcional) Monitorizar a disponibilidade e a latência do seu serviço

AsGoogle Cloud verificações de tempo de atividade realizam a monitorização de caixa negra das aplicações do ponto de vista do utilizador, determinando a latência e a disponibilidade de vários IPs externos para o endereço IP do balanceador de carga. Em comparação,as Google Cloud verificações de funcionamento executam uma verificação interna em relação aos IPs dos pods, determinando a disponibilidade ao nível da instância. As verificações são complementares e oferecem uma imagem holística do estado de funcionamento da aplicação.

Pode criar uma verificação de tempo de atividade através da Google Cloud consola, da API Cloud Monitoring ou das bibliotecas cliente do Cloud Monitoring. Para mais informações, consulte o artigo Gerir verificações de tempo de atividade. Se quiser criar uma verificação de tempo de atividade através da Google Cloud consola, faça o seguinte:

1. Aceda à página Serviços e entrada na Google Cloud consola.

   Aceda a Serviços e entrada

2. Clique no nome do serviço para o qual quer criar uma verificação de tempo de atividade.

3. Clique em Criar verificação de tempo de atividade.

4. No painel Criar verificação de tempo de atividade, introduza um título para a verificação de tempo de atividade e, de seguida, clique em Seguinte para avançar para as definições de Destino.

   Os campos Destino da verificação de tempo de atividade são preenchidos automaticamente com as informações do equilibrador de carga do serviço.

   Para ver a documentação completa sobre todos os campos numa verificação de tempo de atividade, consulte o artigo Criar uma verificação de tempo de atividade.

5. Clique em Seguinte para avançar para as definições de Validação da resposta.

6. Clique em Seguinte para avançar para a secção Alerta e notificação.

   Para monitorizar uma verificação de tempo de atividade, pode criar uma política de alertas ou ver o painel de controlo da verificação de tempo de atividade. Uma política de alertas pode enviar-lhe uma notificação por email ou através de um canal diferente se a verificação de tempo de atividade falhar. Para obter informações gerais sobre as políticas de alertas, consulte o artigo Introdução aos alertas.

7. Clique em Criar.

Observações

Por predefinição, o Ingress realiza uma verificação de funcionamento periódica através de um pedido GET no caminho / para determinar o estado da aplicação e espera uma resposta HTTP 200. Se quiser verificar um caminho diferente ou esperar um código de resposta diferente, pode usar um caminho de verificação de estado personalizado.

A entrada suporta exemplos de utilização mais avançados, como:

• Alojamento virtual baseado em nomes: pode usar o Ingress para reutilizar o balanceador de carga para vários nomes de domínios, subdomínios e para expor vários serviços num único endereço IP e balanceador de carga. Consulte os exemplos de fanout simples e alojamento virtual baseado em nomes para saber como configurar o Ingress para estas tarefas.

• Rescisão de HTTPS: pode configurar o Ingress para rescindir o tráfego HTTPS através do Cloud Load Balancer.

Quando um Ingress é eliminado, o controlador de Ingress do GKE limpa automaticamente os recursos associados (exceto os endereços IP estáticos reservados).