Como configurar um serviço de back-end por meio do BackendConfig

beta

Nesta página, você verá como usar um objeto Ingress do Kubernetes para configurar determinadas propriedades de um serviço de back-end do Google Cloud (ou BackendConfig). O BackendConfig é um recurso personalizado que contém informações de configuração dos recursos do Google Cloud.

Visão geral

Em um cluster do GKE, quando você cria um objeto Ingress do Kubernetes, o controlador de entrada do GKE é reativado e cria um balanceador de carga HTTP(S) do Google Cloud. O controlador de entrada configura o balanceador de carga e também um ou mais serviços de back-end associados a esse balanceador.

As informações de configuração de um serviço de back-end são mantidas em um recurso personalizado denominado BackendConfig.

Para configurar as propriedades de um serviço de back-end:

  1. Crie um BackendConfig.
  2. Crie um serviço e associe uma das respectivas portas ao BackendConfig.
  3. Crie um objeto Ingress e associe-o ao par (Service, porta).

As propriedades exatas que podem ser configuradas dependerão de você estar usando um objeto Ingress com balanceamento de carga interno ou externo.

Propriedades configuráveis para o balanceador de carga HTTP(S) externo

A partir da versão 1.11.3-gke.18 do GKE, é possível usar um objeto Ingress para configurar estas propriedades de um serviço de back-end:

A partir da versão 1.15.3-gke.1 do GKE, é possível usar um objeto Ingress para configurar estas propriedades de um serviço de back-end:

Propriedades configuráveis para o balanceador de carga HTTP(S) interno

É possível usar um BackendConfig para configurar um balanceador de carga HTTP(S) interno para usar dois recursos extras:

Antes de começar

Antes de começar, veja se você realizou as seguintes tarefas:

Defina configurações gcloud padrão usando um dos métodos a seguir:

  • Use gcloud init se você quiser ser orientado sobre como definir padrões.
  • Use gcloud config para definir individualmente a região, a zona e o ID do projeto.

Como usar o gcloud init

  1. Execute gcloud init e siga as instruções:

    gcloud init

    Se você estiver usando SSH em um servidor remoto, utilize a sinalização --console-only para impedir que o comando inicie um navegador:

    gcloud init --console-only
  2. Siga as instruções para autorizar gcloud a usar sua conta do Google Cloud.
  3. Crie uma nova configuração ou selecione uma atual.
  4. Escolha um projeto do Google Cloud.
  5. Escolha uma zona padrão do Compute Engine.

Como usar o gcloud config

  • Defina o ID do projeto padrão:
    gcloud config set project project-id
  • Se você estiver trabalhando com clusters zonais, defina a zona do Compute padrão:
    gcloud config set compute/zone compute-zone
  • Se você estiver trabalhando com clusters regionais, defina a região do Compute padrão:
    gcloud config set compute/region compute-region
  • Atualize gcloud para a versão mais recente:
    gcloud components update

Como criar um Deployment

Antes de criar um BackendConfig e um Service, você precisa criar um Deployment. Veja o manifesto de um Deployment:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: my-bsc-deployment
    spec:
      selector:
        matchLabels:
          purpose: bsc-config-demo
      replicas: 2
      template:
        metadata:
          labels:
            purpose: bsc-config-demo
        spec:
          containers:
          - name: hello-app-container
            image: gcr.io/google-samples/hello-app:1.0
    

Copie o manifesto em um arquivo chamado my-bsc-deployment.yaml e crie o Deployment:

    kubectl apply -f my-bsc-deployment.yaml
    

Como criar um BackendConfig

Veja aqui um manifesto de um BackendConfig. O manifesto especifica:

  • um tempo limite de 40 segundos;
  • um tempo limite de diminuição da conexão de 60 segundos.
    apiVersion: cloud.google.com/v1beta1
    kind: BackendConfig
    metadata:
      name: my-bsc-backendconfig
    spec:
      timeoutSec: 40
      connectionDraining:
        drainingTimeoutSec: 60
    

Copie o manifesto em um arquivo chamado my-bsc-backendconfig.yaml e crie o BackendConfig:

    kubectl apply -f my-bsc-backendconfig.yaml
    

Como criar um Service

Veja o manifesto de um Service:

    apiVersion: v1
    kind: Service
    metadata:
      name: my-bsc-service
      labels:
        purpose: bsc-config-demo
      annotations:
        beta.cloud.google.com/backend-config: '{"ports": {"80":"my-bsc-backendconfig"}}'
    spec:
      type: NodePort
      selector:
        purpose: bsc-config-demo
      ports:
      - port: 80
        protocol: TCP
        targetPort: 8080
    

Para os fins deste exercício, estes são os pontos mais importantes a serem observados sobre seu Service:

  • Qualquer pod que tenha o rótulo purpose: bsc-config-demo é um membro do Service.

  • A porta TCP 80 do Service está associada a um BackendConfig chamado my-bsc-backendconfig. A anotação beta.cloud.google.com/backend-config especifica isso.

  • Uma solicitação enviada para a porta 80 do Service é encaminhada para um dos pods de membro na porta 8080.

Salve o manifesto em um arquivo chamado my-bsc-service.yaml e crie o Service:

    kubectl apply -f my-bsc-service.yaml
    

Como criar um Ingress

Veja aqui um manifesto de um Ingress:

    apiVersion: extensions/v1beta1
    kind: Ingress
    metadata:
      name: my-bsc-ingress
    spec:
      rules:
      - http:
          paths:
          - path: /*
            backend:
              serviceName: my-bsc-service
              servicePort: 80
    

No manifesto, é possível ver que as solicitações de entrada são roteadas para a porta 80 do Service chamado my-bsc-service.

Copie o manifesto para um arquivo chamado my-bsc-ingress.yaml e crie o Ingress:

    kubectl apply -f my-bsc-ingress.yaml
    

Aguarde alguns minutos para que o controlador de entrada configure um balanceador de carga HTTP(S) e um serviço de back-end associado.

Como visualizar o serviço de back-end

Veja seu serviço:

    kubectl get service my-bsc-service
    

Anote o valor da porta do nó que aparece na saída. Por exemplo, no resultado a seguir, o valor da porta do nó é 30936.

    NAME             TYPE       CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
    my-bsc-service   NodePort   10.83.15.111   none          80:30936/TCP   2m
    

Liste os serviços de back-end em seu projeto do Cloud.

    gcloud compute backend-services list
    

Na saída, encontre o nome do seu serviço de back-end. É o nome que contém a porta do nó do Service. Por exemplo, se a porta do seu nó for 30936, o nome do seu serviço de back-end será semelhante a este:

    NAME
    ...
    k8s-be-30936--078bc860bb6f7a2f
    ...
    

Descreva o serviço de back-end:

    gcloud compute backend-services describe [BACKEND_SERVICE_NAME] --global
    

[BACKEND_SERVICE_NAME] é o nome do seu serviço de back-end.

A saída mostra valores para as propriedades que você configurou:

    connectionDraining:
      drainingTimeoutSec: 60
    ...
    timeoutSec: 40
    

Como definir a afinidade de IP do cliente

É possível usar um "BackendConfig" para configurar a afinidade de IP do cliente.

Para fazer isso, você precisa de um cluster nativo de VPC. A afinidade de IP do cliente é útil apenas nos Serviços que são baseados em grupos de endpoint de rede. Esses grupos exigem um cluster nativo de VPC.

Para definir a afinidade de IP do cliente, configure affinityType como "CLIENT_IP" no seu manifesto de BackendConfig.

    apiVersion: cloud.google.com/v1beta1
    kind: BackendConfig
    metadata:
      name: my-bsc-backendconfig
    spec:
      timeoutSec: 40
      connectionDraining:
        drainingTimeoutSec: 60
      sessionAffinity:
        affinityType: "CLIENT_IP"
    

No manifesto do Service, inclua a anotação cloud.google.com/neg: '{"ingress": true}':

    kind: Service
    metadata:
      name: my-bsc-service
      labels:
        purpose: bsc-config-demo
      annotations:
        cloud.google.com/neg: '{"ingress": true}'
        beta.cloud.google.com/backend-config: '{"ports": {"80":"my-bsc-backendconfig"}}'
    ...
    

É possível usar um "BackendConfig" para configurar a afinidade de cookie gerado.

Para fazer isso, você precisa de um cluster nativo de VPC. A afinidade de cookie gerado é útil apenas nos recursos Service que são baseados em grupos de endpoint de rede. Esses grupos exigem um cluster nativo de VPC.

Para definir a afinidade de cookie gerado, configure affinityType como "GENERATED_COOKIE" no manifesto de BackendConfig. Também é possível usar affinityCookieTtlSec para definir o período para o cookie.

    sessionAffinity:
      affinityType: "GENERATED_COOKIE"
      affinityCookieTtlSec: 50
    

No manifesto do Service, inclua a anotação cloud.google.com/neg: '{"ingress": true}':

    kind: Service
    metadata:
      name: my-bsc-service
      labels:
        purpose: bsc-config-demo
      annotations:
        cloud.google.com/neg: '{"ingress": true}'
        beta.cloud.google.com/backend-config: '{"ports": {"80":"my-bsc-backendconfig"}}'
    ...
    

Como configurar cabeçalhos de solicitação definidos pelo usuário

Se você estiver usando Ingress para balanceamento de carga externo, será possível usar um BackendConfig para configurar cabeçalhos de solicitação definidos pelo usuário.

Para ativá-los, especifique uma lista de cabeçalhos na propriedade customRequestHeaders do recurso BackendConfig. O balanceador de carga adiciona os cabeçalhos às solicitações encaminhadas para os back-ends.

    customRequestHeaders:
      headers:
      - "X-Client-Region:{client_region}"
      - "X-Client-City:{client_city}"
      - "X-Client-CityLatLong:{client_city_lat_long}"
    

No manifesto do Service, inclua a anotação cloud.google.com/neg: '{"ingress": true}':

    kind: Service
    metadata:
      name: my-bsc-service
      labels:
        purpose: bsc-config-demo
      annotations:
        beta.cloud.google.com/backend-config: '{"ports": {"80":"my-bsc-backendconfig"}}'
    ...
    

Como fazer a limpeza

Depois de concluir os exercícios nesta página, siga estas etapas para remover os recursos e evitar cobranças indesejadas na conta:

Exclua os objetos do Kubernetes que você criou para este exercício:

    kubectl delete ingress my-bsc-ingress
    kubectl delete service my-bsc-service
    kubectl delete backendconfig my-bsc-backendconfig
    kubectl delete deployment my-bsc-deployment
    

A seguir