Nesta página, você aprende a configurar um balanceador de carga HTTP(S) externo criando um objeto de entrada do Kubernetes. O objeto Entrada precisa estar associado a um ou mais objetos de serviço, e cada um deles associado a um conjunto de pods.
Um objeto de serviço tem uma ou mais estruturas servicePort
. Cada servicePort
segmentado por uma Entrada está associado a um recurso do serviço de back-end do Google Cloud.
Antes de começar
Antes de começar, verifique se você realizou as tarefas a seguir:
- Verifique se você ativou a API Google Kubernetes Engine. Ativar a API Google Kubernetes Engine
- Verifique se o SDK do Cloud está instalado.
Defina as configurações padrão da gcloud
usando um dos métodos a seguir:
- Use
gcloud init
se quiser orientações para definir os padrões. - Use
gcloud config
para definir individualmente a região, a zona e o ID do projeto.
Como usar o gcloud init
Se você receber o erro One of [--zone, --region] must be supplied: Please specify
location
, conclua esta seção.
-
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
-
Siga as instruções para autorizar a
gcloud
a usar sua conta do Google Cloud. - Crie uma nova configuração ou selecione uma atual.
- Escolha um projeto do Google Cloud.
- Escolha uma zona padrão do Compute Engine para clusters zonais ou uma região para clusters regionais ou de Autopilot.
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 de Autopilot ou 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
Você precisa ter um cluster do GKE no seu projeto com o complemento de balanceamento de carga HTTP(S) ativado:
Console
Acesse o menu do Google Kubernetes Engine no Console do Cloud.
Clique no nome do cluster que você quer modificar.
Em Rede, no campo Balanceamento de carga HTTP, clique em edit Editar balanceamento de carga HTTP.
Marque a caixa de seleção Ativar balanceamento de carga HTTP.
Clique em Salvar alterações.
gcloud
gcloud container clusters update cluster-name --update-addons=HttpLoadBalancing=ENABLED
em que cluster-name é o nome do cluster.
Vários serviços de back-end
Um balanceador de carga HTTP(S) externo fornece um endereço IP estável que pode ser usado para encaminhar solicitações a uma variedade de serviços de back-end.
Neste exercício, você configura um balanceador de carga HTTP(S) externo para fazer o encaminhamento de solicitações para diferentes
serviços de back-end, dependendo do caminho do URL. Solicitações que têm o caminho
/
são roteadas para um serviço de back-end, e as solicitações que têm o caminho
/kube
são encaminhadas para um serviço de back-end diferente.
Veja a ideia geral dos passos deste exercício:
- Crie uma implantação e a exponha a um serviço chamado
hello-world
. - Crie uma segunda implantação e a exponha a um serviço chamado
hello-kubernetes
. - Crie uma Entrada que especifique regras para encaminhar solicitações a um serviço ou outro, dependendo do caminho do URL na solicitação. Quando você cria a Entrada, o controlador de entrada do GKE cria e configura um balanceador de carga HTTP(S) externo.
- Teste o balanceador de carga HTTP(S) externo.
Como criar uma implantação
Veja aqui um manifesto de um Deployment:
apiVersion: apps/v1
kind: Deployment
metadata:
name: hello-world-deployment
spec:
selector:
matchLabels:
greeting: hello
department: world
replicas: 3
template:
metadata:
labels:
greeting: hello
department: world
spec:
containers:
- name: hello
image: "gcr.io/google-samples/hello-app:2.0"
env:
- name: "PORT"
value: "50000"
Copie o manifesto em um arquivo denominado hello-world-deployment.yaml
e crie a implantação:
kubectl apply -f hello-world-deployment.yaml
Crie um serviço
Veja aqui um manifesto para um Service que expõe seu primeiro Deployment:
apiVersion: v1
kind: Service
metadata:
name: hello-world
spec:
type: NodePort
selector:
greeting: hello
department: world
ports:
- protocol: TCP
port: 60000
targetPort: 50000
Para os fins deste exercício, estes são os pontos importantes que você precisa entender sobre este serviço:
Qualquer pod que tenha o rótulo
greeting: hello
e o rótulodepartment: world
é membro do serviço.Quando uma solicitação é enviada ao serviço na porta TCP 60000, ela é encaminhada para um dos pods membros na porta TCP 50000.
Copie o manifesto para um arquivo chamado hello-world-service.yaml
e crie o Service:
kubectl apply -f hello-world-service.yaml
Como criar uma segunda implantação
Veja aqui um manifesto para um segundo Deployment:
apiVersion: apps/v1
kind: Deployment
metadata:
name: hello-kubernetes-deployment
spec:
selector:
matchLabels:
greeting: hello
department: kubernetes
replicas: 3
template:
metadata:
labels:
greeting: hello
department: kubernetes
spec:
containers:
- name: hello-again
image: "gcr.io/google-samples/node-hello:1.0"
env:
- name: "PORT"
value: "8080"
Copie o manifesto em um arquivo denominado hello-kubernetes-deployment.yaml
e crie a implantação:
kubectl apply -f hello-kubernetes-deployment.yaml
Como criar um segundo serviço
Veja aqui um manifesto para um Service que expõe seu segundo Deployment:
apiVersion: v1
kind: Service
metadata:
name: hello-kubernetes
spec:
type: NodePort
selector:
greeting: hello
department: kubernetes
ports:
- protocol: TCP
port: 80
targetPort: 8080
Para os fins deste exercício, estes são os pontos importantes que você precisa entender sobre este serviço:
Qualquer pod que tenha o rótulo
greeting: hello
e o rótulodepartment: kubernetes
é membro do serviço.Quando uma solicitação é enviada ao serviço na porta TCP 80, ela é encaminhada para um dos pods membros na porta TCP 8080.
Copie o manifesto em um arquivo denominado hello-kubernetes-service.yaml
e crie o serviço:
kubectl apply -f hello-kubernetes-service.yaml
Como criar um Ingress
Veja aqui um manifesto de uma Entrada:
apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
name: my-ingress
annotations:
# If the class annotation is not specified it defaults to "gce".
kubernetes.io/ingress.class: "gce"
spec:
rules:
- http:
paths:
- path: /*
backend:
serviceName: hello-world
servicePort: 60000
- path: /kube
backend:
serviceName: hello-kubernetes
servicePort: 80
Para os fins deste exercício, estes são os pontos importantes que você precisa entender sobre esse manifesto de entrada:
Há duas classes de Entrada disponíveis para a Entrada do GKE. A classe
gce
implanta um balanceador de carga externo, e a classegce-internal
implanta um balanceador de carga interno. Recursos de entrada sem uma classe especificada por padrão comogce
.O único caractere curinga aceito no campo
path
de uma entrada é*
. O caractere*
precisa vir depois de uma barra (/
) e ser o último caractere no padrão. Por exemplo,/*
,/foo/*
e/foo/bar/*
são padrões válidos, ao contrário de*
,/foo/bar*
e/foo/*/bar
.Um padrão mais específico tem precedência sobre um menos específico. Se você tiver os padrões
/foo/*
e/foo/bar/*
,/foo/bar/bat
será usado na correspondência com/foo/bar/*
. Para mais informações sobre limitações de caminho e correspondência de padrões, consulte a documentação dos mapas de URL.O manifesto de entrada tem dois pares (
serviceName
,servicePort
). Cada um deles (serviceName
,servicePort
) está associado a um serviço de back-end do Google Cloud.
Copie o manifesto em um arquivo chamado my-ingress.yaml
e crie a Entrada:
kubectl apply -f my-ingress.yaml
Quando você faz isso, o controlador de entrada do GKE cria um balanceador de carga HTTP(S) externo e faz a configuração do balanceador desta forma:
Quando um cliente envia uma solicitação ao balanceador de carga com o caminho de URL
/
, a solicitação é encaminhada para o serviçohello-world
na porta 60000.Quando um cliente envia uma solicitação ao balanceador de carga usando o caminho de URL
/kube
, a solicitação é encaminhada para o serviçohello-kubernetes
na porta 80.
Aguarde cerca de cinco minutos até que o balanceador de carga seja configurado.
Como testar o balanceador de carga HTTP(S) externo
Para testar o balanceador de carga HTTP(S) externo:
Veja a Entrada:
kubectl get ingress my-ingress --output yaml
A saída mostra o endereço IP do balanceador de carga HTTP(S) externo:
status: loadBalancer: ingress: - ip: 203.0.113.1
Teste o caminho
/
:curl load-balancer-ip/
Substitua load-balancer-ip pelo endereço IP externo do balanceador de carga.
A saída mostra uma mensagem
Hello, world!
:Hello, world! Version: 2.0.0 Hostname: ...
Teste o caminho
/kube
:curl load-balancer-ip/kube
A saída mostra uma mensagem
Hello Kubernetes!
:Hello Kubernetes!
HTTPS entre o cliente e o balanceador de carga
Um balanceador de carga HTTP(S) externo atua como um proxy entre seus clientes e o aplicativo. Se você quiser aceitar solicitações HTTPS dos seus clientes, o balanceador de carga precisará ter um certificado para provar a identidade dele aos clientes. Além disso, ele precisa ter uma chave privada para concluir o handshake HTTPS. Veja mais informações em:
- Como configurar o HTTPS (TLS) entre o cliente e o balanceador de carga.
- Como usar vários certificados SSL no balanceamento de carga HTTP(S) com o Ingress
Como desativar o HTTP
Se você quiser que todo o tráfego entre o cliente e o balanceador de carga use HTTPS, desative o HTTP. Para mais informações, consulte Como desativar o HTTP.
HTTPS entre o balanceador de carga e o aplicativo
Se o aplicativo em execução em um pod do GKE for capaz de receber solicitações HTTPS, configure o balanceador de carga para usar HTTPS quando encaminhar solicitações para o aplicativo. Para mais informações, consulte HTTPS (TLS) entre o balanceador de carga e o aplicativo.
HTTP/2 entre o cliente e o balanceador de carga
Os clientes podem usar HTTP/2 para enviar solicitações ao balanceador de carga. Nenhuma configuração é necessária.
HTTP/2 entre o balanceador de carga e o aplicativo
Se seu aplicativo em execução em um pod do GKE for capaz de receber solicitações HTTP/2, é possível configurar o balanceador de carga para usar HTTP/2 ao encaminhar solicitações para o aplicativo. Para mais informações, consulte HTTP/2 para balanceamento de carga com Entrada.
Grupos de endpoint de rede
Se o cluster for compatível
com o balanceamento de carga nativo de contêiner,
recomendamos usar grupos de endpoints de rede (NEGs, na sigla em inglês). Para clusters do
GKE 1.17 e posteriores e
em determinadas condições,
o balanceamento de carga nativo de contêiner é padrão e não requer uma anotação de
serviço cloud.google.com/neg: '{"ingress": true}'
explícita.
Resumo das anotações de Entrada externa
Anotações do Ingress
Anotação | Descrição |
---|---|
kubernetes.io/ingress.allow-http | Especifica se o tráfego HTTP será permitido entre o cliente e o balanceador de carga HTTP(S). Os valores possíveis são "verdadeiro" e "falso". O padrão é "verdadeiro". Consulte Como desativar o HTTP. |
ingress.gcp.kubernetes.io/pre-shared-cert | É possível fazer upload de certificados e chaves para seu projeto do Google Cloud. Use essa anotação para fazer referência aos certificados e chaves. Consulte Como usar vários certificados SSL no balanceamento de carga HTTP(S). |
kubernetes.io/ingress.global-static-ip-name | Use essa anotação para especificar que o balanceador de carga usará um endereço IP externo e estático que você criou anteriormente. Consulte Endereços IP estáticos para balanceadores de carga HTTP(S). |
networking.gke.io/v1beta1.FrontendConfig | Use esta anotação para personalizar a configuração do balanceador de carga voltada para o cliente. Para mais informações, consulte Recursos de Entrada. |
Anotações de serviço relacionadas à Entrada
Anotação | Descrição |
---|---|
service.alpha.kubernetes.io/app-protocols | Use essa anotação para definir o protocolo de comunicação entre o balanceador de carga e o aplicativo. Os protocolos possíveis são HTTP, HTTPS e HTTP/2. Consulte HTTPS entre o balanceador de carga e o aplicativo e HTTP/2 para balanceamento de carga com Entrada. |
beta.cloud.google.com/backend-config | Use essa anotação para configurar o serviço de back-end associado a um servicePort. Para mais informações, consulte Recursos de Entrada. |
cloud.google.com/neg | Use essa anotação para especificar que o balanceador de carga usará grupos de endpoint de rede. Consulte Como usar o balanceamento de carga nativo de contêiner. |
A seguir
Leia a visão geral do Ingress para balanceamento de carga HTTP(S) no GKE.
Faça o tutorial sobre Como configurar o balanceamento de carga HTTP com a Entrada.
Leia uma visão geral conceitual dos serviços no GKE.