Kubernetes: entrada vs Balancer de carga

Estou bastante confuso sobre o papel de ingerir e carregar Balancer em Kubernetes.

Tanto quanto sei, a entrada é usada para mapear o tráfego de entrada da internet para os serviços que funcionam no cluster.

O papel do balancer de carga é encaminhar o tráfego para um hospedeiro. A este respeito, como é que a entrada difere do balancer de carga? Também Qual é o conceito de balancer de carga dentro de kubernetes em comparação com o ELB Amazon e o ALB?

Author: arunkjn, 2017-07-13
Source

3 answers

Carregar Balancer: um serviço de LoadBalancer kubernetes é um serviço que aponta para balancers de carga externos que não estão no seu conjunto de kubernetes, mas existem em outro lugar. Eles podem trabalhar com as suas cápsulas, assumindo que as suas cápsulas são roteáveis externamente. O Google e a AWS fornecem essa capacidade de forma nativa. Em termos de Amazon, isto mapeia diretamente com o ELB e o kubernetes ao correr no AWS pode automaticamente fornecer e configurar uma instância ELB para cada serviço de LoadBalancer implantado.

Entrada: uma entrada é realmente apenas um conjunto de regras para passar para um controlador que está a ouvi-las. Você pode implantar um monte de regras de entrada, mas nada vai acontecer a menos que você tenha um controlador que pode processá-los. Um serviço LoadBalancer poderia ouvir as regras de entrada, se estiver configurado para fazê-lo.

Você também pode criar um serviço NodePort , que tem um IP externamente Rotacionável fora do grupo, mas aponta para uma cápsula que existe dentro do seu conjunto. Isto pode ser um controlador de entrada.

Um Controlador de entrada é simplesmente um pod que está configurado para interpretar as regras de entrada. Um dos controladores de entrada mais populares suportados pelo kubernetes é o nginx. Em termos de Amazon, ALB pode ser usado como um controlador de entrada.

Por exemplo, Este controlador nginx é capaz de ingerir regras que você definiu e traduzi-las para um nginx.conf ficheiro que carrega e começa na sua cápsula.

Vamos. por exemplo, diga que definiu uma entrada da seguinte forma: 
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  annotations:
   ingress.kubernetes.io/rewrite-target: /
 name: web-ingress
spec:
  rules:
  - host: kubernetes.foo.bar
    http:
      paths:
      - backend:
          serviceName: appsvc
          servicePort: 80
        path: /app

Se inspeccionar a sua cápsula de controlo nginx verá a seguinte regra definida em /etc/nginx.conf:

server {
    server_name kubernetes.foo.bar;
    listen 80;
    listen [::]:80;
    set $proxy_upstream_name "-";
    location ~* ^/web2\/?(?<baseuri>.*) {
        set $proxy_upstream_name "apps-web2svc-8080";
        port_in_redirect off;

        client_max_body_size                    "1m";

        proxy_set_header Host                   $best_http_host;

        # Pass the extracted client certificate to the backend

        # Allow websocket connections
        proxy_set_header                        Upgrade           $http_upgrade;
        proxy_set_header                        Connection        $connection_upgrade;

        proxy_set_header X-Real-IP              $the_real_ip;
        proxy_set_header X-Forwarded-For        $the_x_forwarded_for;
        proxy_set_header X-Forwarded-Host       $best_http_host;
        proxy_set_header X-Forwarded-Port       $pass_port;
        proxy_set_header X-Forwarded-Proto      $pass_access_scheme;
        proxy_set_header X-Original-URI         $request_uri;
        proxy_set_header X-Scheme               $pass_access_scheme;

        # mitigate HTTPoxy Vulnerability
        # https://www.nginx.com/blog/mitigating-the-httpoxy-vulnerability-with-nginx/
        proxy_set_header Proxy                  "";

        # Custom headers

        proxy_connect_timeout                   5s;
        proxy_send_timeout                      60s;
        proxy_read_timeout                      60s;

        proxy_redirect                          off;
        proxy_buffering                         off;
        proxy_buffer_size                       "4k";
        proxy_buffers                           4 "4k";

        proxy_http_version                      1.1;

        proxy_cookie_domain                     off;
        proxy_cookie_path                       off;

    rewrite /app/(.*) /$1 break;
    rewrite /app / break;
    proxy_pass http://apps-appsvc-8080;

    }

A Nginx acabou de criar uma regra para a rota http://kubernetes.foo.bar/app para apontar para o serviço appsvc no seu grupo.

Aqui está um exemplo de como implementar um conjunto de kubernetes com um controlador de entrada nginx. Espero que isto ajude!

 75
Author: Lindsay Landry, 2017-10-24 05:03:24
Encontrei este artigo muito interessante que explica as diferenças entre o NodePort, o LoadBalancer e a entrada.

Do conteúdo presente no artigo:

LoadBalancer:

Um serviço LoadBalancer é a forma padrão de expor um serviço ao quarto. Na GKE, isto vai rodar um Balancer de carga de rede que vai dar - lhe um único endereço IP que irá encaminhar todo o tráfego para o seu servico.

Se quiseres expor diretamente um serviço, este é o método padrão. Todo o tráfego no porto que você especificar será encaminhado para o serviço. Não há filtragem, não há roteamento, etc. Isso significa que você pode enviar quase qualquer tipo de tráfego para ele, como HTTP, TCP, UDP, Websockets, gRPC, ou como queiras.

A grande desvantagem é que cada serviço que expões com um carregador vai ter o seu próprio endereço IP, e você tem que pagar por um LoadBalancer por serviço exposto, que pode obter caro!

Entrada:

A entrada não é um tipo de serviço. Em vez disso, senta-se à frente de múltiplos serviços e actuar como" router inteligente " ou ponto de entrada para o teu grupo.

Você pode fazer muitas coisas diferentes com uma entrada, e há muitos tipos de controladores de entrada que têm capacidades diferentes.

O controlador de entrada por omissão do GKE irá rodar uma carga de HTTP Balancer para ti. Isto vai deixar-te fazer baseado no caminho e subdominado encaminhamento baseado para serviços de infra-estruturas. Por exemplo, você pode enviar tudo ligado foo.yourdomain.com ao serviço de foo, e tudo. sob a yourdomain.com/bar / localização do serviço de barras.

A entrada é provavelmente a forma mais poderosa de expor os seus serviços, mas... também pode ser o mais complicado. Há muitos tipos de entrada controladores, do Google Cloud Load Balancer, Nginx, Contour, Istio, e muito mais. Existem também plugins para a entrada controladores, como o cert-manager, que pode fornecer automaticamente certificados SSL pelos seus serviços.

A entrada é a mais útil se quiser expor vários serviços sob o mesmo endereço IP, e todos estes serviços usam o mesmo L7 protocolo (tipicamente HTTP). Você só paga por um balanceiro de carga se você estão a usar a integração GCP nativa, e porque a entrada é "inteligente" você pode obter um monte de recursos fora da caixa (como SSL, Auth, roteamento, etc)

 6
Author: Ankit Agrawal, 2018-05-11 09:58:39

TL: DR

    A entrada fica entre a rede pública (Internet) e os Serviços Kubernetes que expõem publicamente a implementação da nossa Api.
  1. A entrada é capaz de fornecer balanceamento de carga, terminação SSL e hospedagem virtual baseada em nome.
  2. as capacidades de entrada permitem expor de forma segura múltiplas API ou aplicações de um único nome de domínio.

Vamos começar com o caso de uso prático: você tem várias Apis apoiadas pelo serviço pacotes de implementação (ASIP para clariy e brevidade) para implantar sob um único nome de domínio. Como você é um desenvolvedor de ponta, você implementou uma arquitetura de micro-serviços que requer implementações separadas para cada ASIP para que eles possam ser atualizados ou dimensionados individualmente. É claro que estas ASIPs estão encapsuladas em container individual do docker e disponíveis para Kubernetes (K8s) do repositório de containers.

Vamos dizer agora que você quer implantar isso no Google GKE K8s. para implementar disponibilidade sustentada, cada instância ASIP (réplica) é implantada em diferentes nós (VM), onde cada VM tem seu próprio endereço IP interno na nuvem. Cada implementação ASIP é configurada em um nome apropriado "implantação.arquivo yaml " onde você declarativamente especificar, entre outras coisas, o número de réplicas do dado ASIP K8s deve implantar.

O próximo passo é expor a API ao mundo ousado e canalizar pedidos para uma das instâncias ASIP implantadas. Uma vez que temos muitas réplicas do mesmo ASIP executando em diferentes nós, precisamos de algo que distribua o pedido entre essas réplicas. Para resolver isso, podemos criar e aplicar um "serviço.ficheiro yaml " que irá configurar um serviço K8s (KServ) que será exposto externamente e acessível através de um endereço IP. Este KServ irá assumir o comando da distribuição de pedidos da API entre as suas Asiáticas configuradas. Note que um KServ será automaticamente reconfigurado pelo K8S master quando o nó de um ASIP falhar e for reiniciado. IP interno endereço nunca são reutilizados em tal caso e o KServ deve ser informado do local de implantação do novo ASIP.

Mas temos outros pacotes de Serviços Api que serão expostos no mesmo nome de domínio. Rodar um novo KServ irá criar um novo endereço IP externo e não seremos capazes de expô-lo no mesmo nome de domínio. É aqui que entra a entrada.

A entrada é entre a Internet e todos os KServices que expomos ao mundo exterior. A entrada é capaz de fornecer balanceamento de carga, rescisão SSL e hospedagem virtual baseada em nome. A última capacidade é capaz de encaminhar um pedido de entrada para o serviço certo, analisando a sua URL. Naturalmente, a entrada deve ser configurada e aplicada com um... "entrada.arquivo yaml" que irá especificar as reescritas e as rotas necessárias para enviar um pedido para o KServ direito.

Internet - > Entrada - > Serviços K8s - > Réplicas

Então, com a entrada certa, kservices e ASIPs configuração, podemos expor de forma segura muitas API estão usando o mesmo nome de domínio.
 3
Author: softjake, 2018-05-14 20:59:54