Wie können zwei Kubernetes-Dienste miteinander kommunizieren?

Question

Momentan habe ich K8s API-Pods in einem K8s-Service, der mit einem K8s Redis-Service verbunden ist, mit eigenen K8s-Pods. Das Problem ist, ich benutze NodePort, BEIDE sind der Öffentlichkeit zugänglich. Ich möchte nur die API für die Öffentlichkeit zugänglich machen. Das Problem ist, dass das API es nicht sehen kann, wenn ich den Redis-Service nicht öffentlich mache. Gibt es eine Möglichkeit, zwei Dienste miteinander zu verbinden, ohne sie der Öffentlichkeit zugänglich zu machen?

Das ist mein API-Service yaml:

apiVersion: v1 
kind: Service 
metadata: 
    name: app-api-svc 
spec: 
    selector: 
    app: app-api 
    tier: api 
    ports: 
    - protocol: TCP 
     port: 5000 
     nodePort: 30400 
    type: NodePort 

Und das ist mein Redis Service yaml:

apiVersion: v1 
kind: Service 
metadata: 
    name: app-api-redis-svc 
spec: 
    selector: 
    app: app-api-redis 
    tier: celery_broker 
    ports: 
    - protocol: TCP 
     port: 6379 
     nodePort: 30537 
    type: NodePort 

Answer 1

Konfigurieren Sie zuerst den Redis-Dienst als ClusterIP-Dienst. Es wird privat und nur für andere Dienste sichtbar sein. Dies kann durch Entfernen der Zeile mit der Option type erfolgen.

apiVersion: v1 
kind: Service 
metadata: 
    name: app-api-redis-svc 
spec: 
    selector: 
    app: app-api-redis 
    tier: celery_broker 
    ports: 
    - protocol: TCP 
     port: 6379 
     targetPort: [the port exposed by the Redis pod] 

Schließlich, wenn Sie die API konfigurieren Redis zu erreichen, sollte die Adresse app-api-redis-svc:6379

sein Und das ist alles. Ich habe viele Dienste, die auf diese Weise miteinander kommunizieren. Wenn dies nicht für Sie funktioniert, lassen Sie es mich in den Kommentaren wissen.

Answer 2

Ich bin nicht sicher über redis, aber ich habe eine ähnliche Anwendung. Ich habe eine Java-Webanwendung, die als Pod ausgeführt wird und durch einen NodePort der Außenwelt ausgesetzt ist. Ich habe einen Mongodb-Container, der als Pod läuft.

In den Webapp-Deployment-Spezifikationen, ich es auf den Mongodb-Dienst über seinen Namen zuordnen, indem Sie den Dienstnamen als Parameter übergeben, habe ich die Spezifikation unten eingefügt. Sie können das entsprechend ändern. In Redis sollte es auch einen ähnlichen Zuordnungsparameter geben, wo Sie in meinem Fall den Dienstnamen "mongoservice" verwenden müssten.

apiVersion: extensions/v1beta1 
    kind: Deployment 
    metadata: 
     name: empappdepl 
     labels: 
     name: empapp 
    spec: 
     replicas: 1 
     template: 
     metadata: 
      labels: 
      name: empapp 
     spec: 
      containers: 
      - 
       resources: 
       limits: 
        cpu: 0.2 
       image: registryip:5000/employee:1 
       imagePullPolicy: IfNotPresent 
       name: wsemp 
       ports: 
       - containerPort: 8080 
        name: wsemp 
       command: ["java","-Dspring.data.mongodb.uri=mongodb://mongoservice/microservices", "-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"] 
      imagePullSecrets: 
      - name: myregistrykey 
--- 
apiVersion: v1 
kind: Service 
metadata: 
    labels: 
    name: empwhatever 
    name: empservice 
spec: 
    ports: 
    - port: 8080 
    targetPort: 8080 
    protocol: TCP 
    name: http 
    nodePort: 30062 
    type: NodePort 
    selector: 
    name: empapp 
    --- 
    apiVersion: extensions/v1beta1 
    kind: Deployment 
    metadata: 
     name: mongodbdepl 
     labels: 
     name: mongodb 
    spec: 
     replicas: 1 
     template: 
     metadata: 
      labels: 
      name: mongodb 
     spec: 
      containers: 
      - resources: 
       limits: 
       cpu: 0.3 
      image: mongo 
      imagePullPolicy: IfNotPresent 
      name: mongodb 
      ports: 
        - containerPort: 27017 
    --- 
    apiVersion: v1 
    kind: Service 
    metadata: 
     labels: 
     name: mongowhatever 
     name: mongoservice 
    spec: 
     ports: 
     - port: 27017 
     targetPort: 27017 
     protocol: TCP 
     selector: 
     name: mongodb 

Beachten Sie, dass der mongodb-Dienst nicht als NodePort verfügbar gemacht werden muss.

Answer 3

Kubernetes ermöglicht die Inter-Service-Kommunikation, indem Dienste mit ihrem Service-Namen mit anderen Services kommunizieren können.

In Ihrem Szenario sollte der Redis-Dienst von anderen Diensten unter http://app-api-redis-svc.default:6379 erreichbar sein. Hier ist Standard der Namespace, unter dem Ihr Dienst ausgeführt wird. Ich bin mit

Diese innenliegende Strecken Sie Ihre Anfragen an Ihren redis pod auf dem Zielcontainerhafen

Kasse diese link für verschiedene Modi der Service-Discovery-Optionen zur Verfügung gestellt von Kubernetes

Hoffe, es hilft

Answer 4

werde versuchen, das Beste aus allen Antworten und meinen eigenen Recherchen zu ziehen und einen kurzen Leitfaden zu erstellen, von dem ich hoffe, dass er hilfreich sein wird:

1.Testen Sie die Verbindung

Verbindung zu einem anderen pod, zB Rubin pod:

kubectl exec -it some-pod-name -- /bin/sh 

Stellen Sie sicher, kann es auf den Dienst in Frage ping:

ping redis 

Kann es an den Port anschließen? (Ich fand telnet nicht dafür funktionierte)

nc -zv redis 6379 

2. Überprüfen Sie Ihre Service-Selektoren korrekt sind

Wenn Ihr Dienstkonfiguration sieht wie folgt aus:

kind: Service 
apiVersion: v1 
metadata: 
    name: redis 
    labels: 
    app: redis 
    role: master 
    tier: backend 
spec: 
    ports: 
    - port: 6379 
    targetPort: 6379 
    selector: 
    app: redis 
    role: master 
    tier: backend 

jene Wähler überprüfen auch eingestellt werden auf deinen Schoten?

get pods --selector=app=redis,role=master,tier=backend 

Bestätigen Sie, dass Ihr Service für Ihre Schoten gebunden ist, indem Sie:

$> describe service redis 
Name:   redis 
Namespace:  default 
Labels:   app=redis 
      role=master 
      tier=backend 
Annotations:  <none> 
Selector:  app=redis,role=master,tier=backend 
Type:   ClusterIP 
IP:   10.47.250.121 
Port:   <unset> 6379/TCP 
Endpoints:  10.44.0.16:6379 
Session Affinity: None 
Events:   <none> 

Kontrolle der Endpoints: Feld und bestätigen Sie es nicht leer ist

Weitere Informationen finden Sie unter: https://kubernetes.io/docs/tasks/debug-application-cluster/debug-service/#my-service-is-missing-endpoints