Comment exposer kubernetes service public sans codage en dur pour minion IP?
J'ai un kubernetes cluster en cours d'exécution avec 2 minions.
Actuellement je fais mon service accessible en 2 étapes:
- De démarrer la réplication du contrôleur de & gousse
- Obtenir minion IP (à l'aide de
kubectl get minions) et la définir comme publicIPs pour le Service.
Qu'est-ce que la pratique suggérée pour exposer un service au public? Mon approche semble faux, parce que je code en dur l'adresse IP de la personne minion IP-s. Il semble également de contourner les capacités d'équilibrage de charge de kubernetes services, parce que les clients ont accès à des services en cours d'exécution sur personne sbires directement.
Pour configurer la réplication du contrôleur de & pod-je utiliser:
id: frontend-controller
kind: ReplicationController
apiVersion: v1beta1
desiredState:
replicas: 2
replicaSelector:
name: frontend-pod
podTemplate:
desiredState:
manifest:
version: v1beta1
id: frontend-pod
containers:
- name: sinatra-docker-demo
image: madisn/sinatra_docker_demo
ports:
- name: http-server
containerPort: 4567
labels:
name: frontend-podPour configurer le service (après l'obtention de minion ip s):
kind: Service
id: frontend-service
apiVersion: v1beta1
port: 8000
containerPort: http-server
selector:
name: frontend-pod
labels:
name: frontend
publicIPs: [10.245.1.3, 10.245.1.4]- Où en êtes-vous de l'exécution de votre cluster? Certains fournisseurs de cloud, tels que la CME et GKE vous permettent de créer un service avec un équilibreur de charge.
- Je suis l'aide de vagrant fournisseur local (développement) et EC2 en production, donc je suis à la recherche d'une solution qui fonctionnerait de la même façon indépendante du fournisseur.
- CreateExternalLoadbalancer est l'abstraction que vous cherchez, mais malheureusement, il n'est pas mis en œuvre pour Vagrant.
Vous devez vous connecter pour publier un commentaire.
Comme je l'ai mentionné dans le commentaire ci-dessus, le createExternalLoadBalancer est la appropriée de l'abstraction que vous cherchez, mais malheureusement, il n'est pas encore mis en œuvre pour tous les fournisseurs de cloud, et en particulier pour le vagabond, qui vous aide localement.
Une option serait d'utiliser les adresses ip publiques pour tous les serviteurs de votre cluster pour tous les services que vous voulez être externalisées. Le trafic destiné au service prendra fin à l'un des serviteurs, où il sera intercepté par le kube-processus de vote par procuration et redirigé vers un pod, qui correspond à l'étiquette sélecteur pour le service. Ceci pourrait entraîner un tronçon supplémentaire sur le réseau (si vous tombez sur un nœud qui n'a pas le pod tourne en local) mais aussi pour des applications qui ne sont pas très sensibles à la latence du réseau, ce ne sera probablement pas perceptible.
Que Robert a dit dans sa réponse, c'est quelque chose qui est à venir, mais, malheureusement, n'est pas encore disponible.
Je suis en train d'exécuter un Kubernetes cluster sur notre réseau de datacenter. J'ai 1 master et 3 minions tous en cours d'exécution sur CentOS 7 virtuals (vcenter). La façon dont j'ai géré cette était de créer un "kube-proxy server". En gros, je suis juste en cours d'exécution le Kube-service de Proxy (avec de la Flanelle pour la mise en réseau) puis en attribuant des "public" des adresses IP à la carte réseau attaché à ce serveur. Quand je dis publique, je veux dire les adresses sur notre réseau de datacenter. Puis, quand je créer un service que je voudrais d'accès en dehors de la grappe, je viens de mettre la publicIPs de la valeur à l'une des adresses IP disponibles sur le kube-serveur proxy. Lorsque quelque chose ou quelqu'un tente de se connecter à ce service à partir de l'extérieur du cluster, il va frapper le kube-proxy et ensuite être redirigé vers le bon serviteur.
Même si cela peut sembler comme un travail autour de, ce est en fait similaire à ce que je m'attends à être qui se passe une fois qu'ils viennent avec construit dans la solution à ce problème.
Si vous utilisez un cluster localement, une solution que j'ai utilisée était de présenter le service sur votre kubernetes nœuds à l'aide de la nodeport directive dans la définition de votre service et ensuite round robin pour chaque nœud d'un cluster avec HAproxy.
Voici ce que d'exposer la nodeport ressemble:
Remarque: la valeur que vous spécifiez doit être à l'intérieur de la plage configurée pour le nœud ports. (par défaut: 30000-32767)
Cette expose le service sur le nodeport sur tous les nœuds de votre cluster. Puis-je créer une nouvelle machine sur le réseau interne de l'exécution de haproxy et un pare-feu qui est accessible de l'extérieur sur la nodeport(s) que vous souhaitez exposer.
Si vous regardez votre table de nat sur l'un de vos hôtes, vous pouvez voir ce qu'il fait.
Particulièrement cette ligne
Et enfin, si vous regardez netstat, vous pouvez voir kube-proxy est à l'écoute et en attente pour ce service sur ce port.
Kube-proxy écoute sur un port pour chaque service, et de faire de la traduction d'adresses réseau dans votre virtuel de sous-réseau que vos contenants résident. (Je crois?) J'ai utilisé de la flanelle.
Pour un cluster à deux nœuds, que HAproxy configuration peut paraître semblable à ceci:
Et le service est maintenant accessible sur le port 80 via HAproxy. Si l'un de vos nœuds aller vers le bas, les conteneurs seront déplacés vers un autre nœud grâce à la réplication et de contrôleurs de HAproxy ne itinéraire jusqu'à votre nœuds qui sont vivants.
Je suis curieux de savoir quelles sont les méthodes que d'autres ont utilisé, si, c'est juste que je suis venu avec. Je n'ai pas l'habitude de poster sur un débordement de pile, donc toutes mes excuses si je ne suis pas la suite de conventions ou de mise en forme appropriée.
C'est pour les Emr. Je n'ai pas assez d'espace dans la zone de commentaires pour poster cette réponse, j'ai donc dû créer une autre réponse. Espérons que cela aide:
Nous avons déménagé loin de Kubernetes puisque l'envoi de cette réponse. Si je me souviens bien, mais tout ce que je devais faire était de courir le kube-proxy exécutable sur une VM CentOS. Voici ce que j'ai fait:
D'abord j'ai enlevé Firewalld et mettre iptables en place. Kube-proxy s'appuie sur iptables pour s'occuper de sa NAT et les redirections.
Ensuite, vous devez installer flanneld de sorte que vous pouvez avoir un pont de l'adaptateur sur le même réseau que le Docker services en cours d'exécution sur vos larbins.
Alors ce que j'ai fait a été d'attribuer plusieurs adresses ip à la carte réseau local installé sur la machine. Ce seront les adresses ip, vous pouvez utiliser lors de la configuration d'un service. Ce seront les adresses disponibles à l'EXTÉRIEUR de votre cluster.
Une fois que l'on s'occupe de tout, vous pouvez démarrer le service de proxy. Il va se connecter au Maître, et de saisir une adresse IP pour la flanelle pont réseau. Ensuite, il sera synchronisé toutes les règles IPtables et vous devriez être en jeu. Chaque fois qu'un nouveau service est ajouté, il va créer les règles de proxy et de reproduire ces règles à tous les serviteurs (et votre proxy). Aussi longtemps que vous avez spécifié une adresse ip disponible sur votre serveur proxy pour proxy serveur de transférer tout le trafic pour cette adresse ip sur le bon serviteur.
Espère que c'est un peu plus clair. Rappelez-vous bien que je n'ai pas été une partie de la Kubernetes projet pendant environ 6 mois maintenant donc je ne suis pas sûr de ce qui a changé, ont été faites depuis que j'ai quitté. Ils pourraient même avoir une fonctionnalité en place qui gère ce genre de chose. Si non j'espère que cela vous aide à obtenir il pris soin de.
Vous pouvez utiliser La pénétration de ressources pour permettre des connexions externes de l'extérieur d'un Kubernetes cluster pour atteindre les services de cluster.
En supposant que vous avez déjà une nacelle déployée, maintenant, vous avez besoin d'un Service de ressources, par exemple:
apiVersion: v1
kind: Service
metadata:
name: frontend-service
labels:
tier: frontend
spec:
type: ClusterIP
selector:
name: frontend-pod
ports:
- name: http
protocol: TCP
# the port that will be exposed by this service
port: 8000
# port in a docker container; defaults to what "port" has set
targetPort: 8000
Et vous avez besoin d'un indice de ressources:
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
name: frontend-ingress
spec:
rules:
- host: foo.bar.com
http:
paths:
- path: /
backend:
serviceName: frontend-service
# the targetPort from service (the port inside a container)
servicePort: 8000
Afin d'être en mesure d'utiliser la Pénétration des ressources, vous avez besoin de quelques la pénétration du contrôleur déployé.
Maintenant, à condition que vous savez que votre Kubernetes maître IP, vous pouvez accéder à votre application à partir de l'extérieur d'un Kubernetes cluster avec:
curl http://<master_ip>:80/-H 'Host: foo.bar.com'
Si vous utilisez un serveur DNS, vous pouvez ajouter cet enregistrement:
foo.bar.com IN A <master_ip>ou ajoutez cette ligne à votre/etc/hostsfichier:<master_ip> foo.bar.comet maintenant, il vous suffit d'exécuter:curl foo.bar.com
Avis, que de cette façon, vous aurez toujours accès
foo.bar.comutilisant le port 80. Si vous souhaitez utiliser un autre port, je recommande d'utiliser un Service de type NodePort, que pour un non-port 80. Il va faire de ce port peut être résolu, n'importe qui Kubernetes VM IP que vous utilisez (tout capitaine ou à toute minion IP est très bien). Exemple:apiVersion: v1
kind: Service
metadata:
name: frontend-service-ssh
labels:
tier: frontend
spec:
type: NodePort
selector:
name: frontend-pod
ports:
- name: ssh
targetPort: 22
port: 22
nodePort: 2222
protocol: TCP
Et si vous avez
<master_ip> foo.bar.comdans votre fichier /etc/hosts, vous pouvez accéder à:foo.bar.com:2222--service-node-port-range="2000-32767". sur 1: je ne suis pas dans ce contexte là, maintenant, donc je ne vais pas ajouter quoi que ce soit pour l'instant. (Désolé pour la longueur de temps de réponse, j'étais en vacances).