Diferença entre targetPort e port na definição de Serviço Kubernetes

Um Kubernetes Servicepode ter um targetPorte portna definição de serviço:

kind: Service
apiVersion: v1
metadata:
  name: my-service
spec:
  selector:
    app: MyApp
  ports:
  - protocol: TCP
    port: 80
    targetPort: 9376

Qual é a diferença entre the porte targetPort?

Serviço: direciona o tráfego para um pod.

TargetPort: Essa é a porta real na qual seu aplicativo está sendo executado dentro do contêiner.

Porta: algumas vezes seu aplicativo dentro do contêiner atende a diferentes serviços em uma porta diferente.

Exemplo: O aplicativo real pode ser executado 8080e as verificações de integridade desse aplicativo podem ser executadas na 8089porta do contêiner. Portanto, se você clicar no serviço sem porta, ele não saberá para qual porta do contêiner deve redirecionar a solicitação. O serviço precisa ter um mapeamento para poder atingir a porta específica do contêiner.

kind: Service
apiVersion: v1
metadata:
  name: my-service
spec:
  selector:
    app: MyApp
  ports:
    - name: http
      nodePort: 30475
      port: 8089
      protocol: TCP
      targetPort: 8080
    - name: metrics
      nodePort: 31261
      port: 5555
      protocol: TCP
      targetPort: 5555
    - name: health
      nodePort: 30013
      port: 8443
      protocol: TCP
      targetPort: 8085 

se você acertar o my-service:8089tráfego é roteado para 8080o contêiner (targetPort). Da mesma forma, se você pressionar my-service:8443, ele será redirecionado para 8085o contêiner (targetPort). Mas isso myservice:8089é interno ao cluster kubernetes e pode ser usado quando um aplicativo deseja se comunicar com outro aplicativo. Portanto, para atingir o serviço de fora do cluster, alguém precisa expor a porta na máquina host na qual o kubernetes está sendo executado, para que o tráfego seja redirecionado para uma porta do contêiner. Esta é node port(porta exposta na máquina host). No exemplo acima, você pode acessar o serviço de fora do cluster (Postman ou qualquer outro cliente restante)host_ip:nodePort

Digamos que seu ip máquina host é 10.10.20.20que você pode bater os http, métricas, serviços de saúde por 10.10.20.20:30475, 10.10.20.20:31261, 10.10.20.20:30013.

Edições: Editadas de acordo com o comentário de Raedwald .

Isso me ajuda a pensar nas coisas da perspectiva do serviço .

• nodePort: A porta no nó em que o tráfego externo entrará
• port: A porta deste serviço
• targetPort A porta de destino no (s) pod (s) para encaminhar o tráfego para

O tráfego é nodePortativado e encaminhado para porto serviço que é direcionado para targetPorto pod (s).

Vale enfatizar mais nodePorto tráfego externo. Outros pods no cluster que talvez precisem acessar o serviço serão usados ​​apenas port, não nodePortcomo acesso interno apenas ao serviço.

Também é importante notar que, se targetPortnão estiver definido, o padrão será o mesmo que port. Por exemplo, 80:80para porta de serviço 80direcionada à porta do contêiner 80.

A resposta dada acima por @Manikanta P está correta. No entanto, a explicação de "Port" pode ser um pouco incerta na primeira leitura. Vou explicar com um exemplo:

Considere um aplicativo da Web com seu conteúdo estático (primeira página, imagens etc.) hospedado pelo httpd e o conteúdo dinâmico (por exemplo, resposta a solicitações etc.) hospedado pelo tomcat. O servidor da Web (ou o conteúdo estático) é servido pelo httpd na porta 80enquanto o Appserver (ou o conteúdo dinâmico) é servido pelo tomcat na porta 8080.

O que um desenvolvedor deseja: O usuário deve poder acessar o servidor da Web de fora, mas não o Appserver de fora.

Solução: o tipo de serviço do servidor da Web em seu service.yml será NodePort, enquanto o tipo de serviço do Appserver em seu service.yml será o ClusterIP.

Código para service.yml do servidor da web:

spec:
  selector:
    app: Webserver
  type: NodePort        // written to make this service accessible from outside.
  ports:
    - nodePort: 30475   // To access from outside, type <host_IP>:30475 in browser.
      port: 5050        // (ignore for now, I will explain below).
      protocol: TCP
      targetPort: 80  // port where httpd runs inside the webserver pod.

Código para service.yml do Appserver

spec:
  selector:
    app: appserver
  type: ClusterIP        // written to make this service NOT accessible from outside.
  ports:
    - port: 5050         // port to access this container internally
      protocol: TCP
      targetPort: 8080   // port where tomcat runs inside the appserver pod.

Observe também que, no httpd.confarquivo do servidor da Web, escreveremos o IP que redireciona a solicitação de um usuário para o servidor de aplicativos. Este IP será: host_IP:5050.

O que exatamente está acontecendo aqui? Um usuário escreve hostIP:30475e vê a página do servidor da Web. Isso ocorre porque ele está sendo atendido pelo httpd na porta 80(targetport). Quando um usuário clica em um botão, é feita uma solicitação. Essa solicitação é redirecionada para o Appserver porque, no httpd.confarquivo, a porta 5050é mencionada e é a porta na qual o contêiner do Appserver e o servidor de conteúdo da Web se comunicam internamente. Quando o appserver recebe a solicitação, ele pode atendê-la devido ao tomcat sendo executado dentro dele na porta 8080.

Esta resposta é para referenciar a documentação do Kubernetes, além das outras respostas:

https://kubernetes.io/docs/concepts/services-networking/connect-applications-service/ :

targetPort: é a porta na qual o contêiner aceita tráfego,

port: é a porta de serviço abstraída, que pode ser qualquer porta usada por outros pods para acessar o serviço

https://kubernetes.io/docs/concepts/services-networking/connect-applications-service/ :

As definições de porta nos Pods têm nomes e você pode fazer referência a esses nomes no targetPortatributo de um Serviço. Isso funciona mesmo se houver uma mistura de pods no serviço usando um único nome configurado, com o mesmo protocolo de rede disponível por diferentes números de porta.

Em poucas palavras

nodeport: Escuta solicitação externa em todos os nós do trabalhador em nodeip: port e encaminha a solicitação para a porta.

port: Porta interna do serviço de cluster para contêiner e escuta a solicitação de entrada da nodeport e encaminhada para targetPort.

targetPort:Receba a solicitação do porto e encaminha para o pod de contêiner (porto) onde está escutando. mesmo se você não especificar, será atribuído por padrão os mesmos números de porta que a porta.

"Porta de destino" é a porta na qual seu contêiner está em execução.

Porta: a porta redireciona o tráfego para o contêiner do serviço.

Expondo a implantação

  master $ kubectl get deployments
NAME         READY   UP-TO-DATE   AVAILABLE   AGE

nginx        1/1     1            1           31s
master $ kubectl expose deployment nginx --name=nginx-svc --port=8080 --target-port=80
service/nginx-svc exposed

master $ kubectl get svc

NAME         TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE

nginx-svc    ClusterIP   10.107.209.151   <none>        8080/TCP   5s

NodePort: é a porta que permite que o serviço acesse externamente.

Espero que isso responda.

se o contêiner ouvir na porta 9376, targetPort : 9376

se um serviço escutar na porta 80, porta : 80

Em seguida, a configuração das portas de serviço é exibida abaixo

ports:
 - protocol: TCP
   port: 80
   targetPort: 9376

Por fim, a solicitação recebida na porta do serviço e encaminhada no targetPort do pod.