【 kubernets series】 a Literature Study on the Safe exposure Applications of kubernets Service

Auteur：Vent et neige à mi - corps
Section précédente：K8S MoyennePod Le cycle de vie de
Introduction：Dans la dernière section, nous avons étudié ensemble,Kubernetes ApplicationPod Trois états du cycle de vie Pending -> Running -> Succeeded/Failed.Contenu de cette section,Ensemble, nous apprendrons comment exposer nos applications.

---

---

Objectifs

• Apprendre Kubernetes Dans Service
• Compris. Étiquettes(Label) Et Sélecteur d'étiquettes(Label Selector) Comment l'objet est lié à Service Liens
• UtiliserService Connexion à l'application
• In Kubernetes Utilisation externe du cluster Service Applications d'exposition

---

Un.、Qu'est - ce queKubernetes Service

Dans la section précédente,Nous avons apprispod Le cycle de vie de,Quand on travaille Node Après avoir raccroché, In Node Running on Pod Et mourir.. ReplicaSet Crée automatiquement un nouveau Pod Ramener le cluster à l'état cible,Pour assurer le bon fonctionnement de l'application.

Kubernetes Services en(Service)Est un concept abstrait,Il définit Pod Ensemble logique et accès Pod Accord.Service Subordination Pod Une synthèse faiblement couplée entre eux est possible. Et autres Kubernetes Même objet, Service Avec YAML (Plus recommandé) Ou JSON Pour définir Service Groupe suivant Pod Habituellement par LabelSelector Pour marquer.

Bien que chaque Pod Il y en a un seul. IP Adresse,Mais si ce n'est pas le cas, Service ,Ces IP Ne pas exposer à l'extérieur du cluster.Service Permettre à votre application de recevoir du trafic .Service Peut également être utilisé ServiceSpec MarquagetypeLa façon dont ils sont exposés

• ClusterIP (Par défaut) - À l'intérieur du cluster IP Public Service .Ce type de Service Accessible uniquement à partir du cluster.
• NodePort - Utiliser NAT Sélectionnez chaque Node Exposé sur le même port de Service .Utiliser<NodeIP>:<NodePort> Accès depuis l'extérieur du cluster Service.- Oui. ClusterIP Un superensemble de.
• LoadBalancer - Créer un répartiteur de charge externe dans le nuage actuel(Si elle est prise en charge),Et pour Service Assigner un extérieur fixeIP.- Oui. NodePort Un superensemble de.
• ExternalName - En renvoyant CNAME Enregistrement,Utilisez n'importe quel nom(Par spec DansexternalNameDésignation)Public Service.N'utilisez pas de proxy.Ce type de demandekube-dnsDev1.7Ou plus.

2.、Utiliser Service Connexion à l'application

Kubernetes Hypothèses Pod Peut être combiné avec d'autres Pod Communications,Peu importe sur quel hôte ils sont. Kubernetes À chacun. Pod Assigner un Cluster privé IP Adresse,Il n'est donc pas nécessaire de Pod Avec Pod Créer une connexion entre ou cartographier les ports du conteneur aux ports hôtes . Ça veut dire la même chose. Pod Tous les récipients à l'intérieur peuvent passer localhost Les ports sont connectés les uns aux autres ,Tous dans le cluster Pod Pas besoin de passer NAT La transformation permet de se voir.

2.1、Exposition au cluster Pod

Commençons par un projet. , Mode de démarrage spécifique , Comme nous l'avons déjà dit , Il n'y a pas grand - chose à dire ici. .

1. Après l'exécution du projet,Ouvre.Kubernetes Tableau de bord（Dashboard）,Cliquez en haut à droite＋No.,UtiliserYAML De la façon dont,Créer unpod Noeud.

2. Comme le montre la figure ci - dessus,InYAML Ajouter le code suivant：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  selector:
    matchLabels:
      run: my-nginx
  replicas: 2
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - name: my-nginx
        image: nginx
        ports:
        - containerPort: 80

3. Cliquez sur télécharger, Cliquez à nouveau sur le pod Options, Juste avant nous Familier pod Page.

Bien sûr., Nous pouvons également utiliser directement la ligne de commande , Pour vérifier nos noeuds ：

$ kubectl apply -f ./run-my-nginx.yaml

Si l'erreur suivante est signalée :

Exécution directe des commandes：

$ unset KUBECONFIG

Encore une fois：

$ kubectl apply -f ./run-my-nginx.yaml
$ kubectl get pods -l run=my-nginx -o wide

Les noeuds de sortie des résultats d'exécution sont les suivants: ：

Bien sûr., Nous pouvons également utiliser la ligne de commande ,Vérifiezpod DeIPAdresse：

$ kubectl get pods -l run=my-nginx -o yaml | grep podIP

Exporter le noeud actuelIP：

Nous pouvons passer par ssh Connectez - vous à n'importe quel noeud du cluster,Et utiliser curl Des outils comme celui - ci IP Adresse pour la demande de renseignements. Il est important de noter que,Le conteneur n'utilisera pas 80 Port,Et n'utilise pas non plus de NAT Règles pour acheminer le trafic vers Pod Allez.. Cela signifie qu'il est possible d'exécuter plusieurs Nginx Pod,Utiliser le même containerPort,Et peut provenir de n'importe quel autre Pod Ou utilisé sur le noeud IP Pour y accéder.

2.2、Création Service

Il crée un plat 、Exécuter dans l'espace d'adresse à l'échelle du cluster Nginx Services Pod , Pour l'exposer ,Nous devons aussi créer unService.

Kubernetes Service C'est un groupe dans un Cluster qui offre la même fonctionnalité Pod Expression abstraite de. Quand chaque Service Lors de la création,Sera attribué un seul IP Adresse（Aussi appelé clusterIP）. C'est IP Adresse et Service Le cycle de vie de,Tant que Service Existe, Ça ne changera pas . Configurable Pod Pour le rendre compatible avec Service Pour communiquer,Pod Savoir et Service La communication sera automatiquement équilibrée à cette Service Certains Pod Allez..

Utilisation directe Les ordres sont donnés à Au - dessus Nginx La copie crée un Service：

$ kubectl expose deployment/my-nginx
$ service/my-nginx exposed

Bien sûr.,Nous pouvons également utiliser directementYAML Comment créer , Création par et au - dessus pod C'est pareil., Le code suivant peut être utilisé directement ：

apiVersion: v1
kind: Service
metadata:
  name: my-nginx
  labels:
    run: my-nginx
spec:
  ports:
  - port: 80
    protocol: TCP
  selector:
    run: my-nginx

Cliquez sur Serverces, Vous verrez le courant Serverces Détails de：

Nous avons créé Service Toutes les étiquettes run: my-nginx De Pod De TCP 80 Le port est exposé à une abstraction Service Sur le port（targetPort：Port où le conteneur reçoit le trafic;port： Abstrait avec n'importe quelle valeur Service Port,Autres Pod Accès via ce port Service）.

Maintenant, Nous effectuons les commandes suivantes pour voir Service Ressources:

$ kubectl get svc my-nginx

Les extrants des ressources sont présentés dans la figure ci - dessous. ：

J'ai aussi mentionné ,Un Service Par un groupe Pod Fournir un soutien.Ces Pod Adoption endpoints Exposé. Service Selector Sera évalué en permanence,Les résultats ont été POST Vers un nom my-nginx De Endpoint Objet. Quand Pod Après résiliation,Il va automatiquement Endpoint Supprimer dans,Le nouveau peut correspondre à Service Selector De Pod Sera automatiquement ajouté à Endpoint Moyenne. Vérifiez ça. Endpoint,J'ai remarqué IP L'adresse correspond à celle créée à l'étape 1 Pod C'est pareil..

$ kubectl describe svc my-nginx

Exécuter la commande ci - dessus, On peut avoir le courant serverces Toutes les informations sur：

$ kubectl get ep my-nginx

Maintenant, On exécute les ordres ci - dessus. , Pour exposer notre serviceC'est,Les résultats sont les suivants：

NAME ENDPOINTS AGE
my-nginx 172.17.0.3:80,172.17.0.8:80 23m

Maintenant nous pouvons utiliser n'importe quel noeud du cluster curl Direction des commandes <CLUSTER-IP>:<PORT> Envoyer une demande d'accès à Nginx Service.

2.3、Accès à Service

KubernetesPrend en charge deux modèles principaux de services de recherche: Variables d'environnement et DNS. Je vais vous montrer comment trouver les variables d'environnement .

Quand Pod En cours d'exécution sur le noeud ,kubelet Pour chaque Service Pour Pod Ajouter un ensemble de variables d'environnement. Cela pose la question de l'ordre . Pour expliquer ce problème , Vérifions d'abord ce qui se passe. Nginx Pod Variables d'environnement pour.

Ma variable d'environnement personnelle est my-nginx-cf54cdbf7-vr96x La tienne pourrait être différente de la mienne ,Directementpod Voir les variables d'environnement directes dans .

Ensuite, exécutez la commande：

$ kubectl exec my-nginx-cf54cdbf7-vr96x – printenv | grep SERVICE

Les résultats sont les suivants：

KUBERNETES_SERVICE_HOST=10.96.0.1
KUBERNETES_SERVICE_PORT=443
KUBERNETES_SERVICE_PORT_HTTPS=443

Vous pouvez voir qu'il n'y a pas de variables d'environnement que vous avez créées Service Valeurs associées. C'est parce que la réplique a été créée avant Service. Un autre inconvénient est que, L'ordonnanceur peut mettre tout Pod Déployer sur la même machine, Si la machine s'arrête, la totalité Service Tout sera déconnecté . Pour corriger , On peut arrêter ça d'abord 2 - Oui. Pod,Et attendez. Deployment Pour les recréer . Cette fois Service Existe avant la copie.Cela permettra de Pod Appuyez. Service Répartition（ Supposons que tous les noeuds aient la même capacité ）, Et fournir les bonnes variables d'environnement .

Exécutez les deux lignes de commande suivantes: ：

$ kubectl scale deployment my-nginx --replicas=0; kubectl scale deployment my-nginx --replicas=2;
$ kubectl get pods -l run=my-nginx -o wide

Vous remarquerez peut - être,Pod A un nom différent, C'est parce qu'ils ont été recréés .

Maintenant, on recommence Nginx Pod Commandes variables d'environnement,Attention!： Maintenant, vos variables d'environnement ont encore changé. ,Veuillez vérifier：

$ kubectl exec my-nginx-cf54cdbf7-fhghk – printenv | grep SERVICE

Enfin, Nous sommes en cours d'exécution ,J'ai vuService Valeurs associées：

KUBERNETES_SERVICE_PORT_HTTPS=443
MY_NGINX_SERVICE_HOST=10.97.238.70
KUBERNETES_SERVICE_HOST=10.96.0.1
KUBERNETES_SERVICE_PORT=443
MY_NGINX_SERVICE_PORT=80

2.4、Protection Service

Jusqu'à présent,Nous n'avons accès qu'à l'intérieur du cluster Nginx Serveur.In Service Avant d'être exposé à Internet,Nous voulons nous assurer que les voies de communication sont sécurisées. Pour ce faire,Besoin：

• Pour HTTPS Certificat auto - signé pour（ Sauf si vous avez déjà un certificat d'identité ）
• Configuré avec un certificat Nginx Serveur
• Faire Pod Accès au certificat Secret

Nous pouvons exécuter les commandes suivantes directement en exécutant les étapes manuellement :

$ make keys KEY=/tmp/nginx.key CERT=/tmp/nginx.crt
$ kubectl create secret tls nginxsecret --key /tmp/nginx.key --cert /tmp/nginx.crt
$ secret/nginxsecret created
$ kubectl get secrets

Les résultats sont les suivants:：

NAME TYPE DATA AGE
default-token-t7mbb kubernetes.io/service-account-token 3 56m

Voici configmap：

$ kubectl create configmap nginxconfigmap --from-file=default.conf
$ configmap/nginxconfigmap created
$ ubectl get configmaps

Les résultats sont les suivants:：

NAME DATA AGE
kube-root-ca.crt 1 58m

Voici ce que vous faites. make Procédure manuelle à suivre en cas de problème（Par exemple,In Windows Allez.）：

#  Créer une clé publique et une clé privée correspondante 
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /d/tmp/nginx.key -out /d/tmp/nginx.crt -subj "/CN=my-nginx/O=my-nginx"
#  Mise en œuvre de la clé  base64 Codage
cat /d/tmp/nginx.crt | base64
cat /d/tmp/nginx.key | base64

Utilisez la sortie de la commande précédente pour créer yaml Documentation,Comme suit. base64 Les valeurs codées doivent toutes être placées sur une ligne.

apiVersion: "v1"
kind: "Secret"
metadata:
  name: "nginxsecret"
  namespace: "default"
type: kubernetes.io/tls  
data:
  tls.crt: " Mettez votre code ici "
  tls.key: " Mettez votre code ici "

Maintenant, utilisez le fichier pour créer Secret：

$ kubectl apply -f nginxsecrets.yaml
$ kubectl get secrets

Résultats de la mise en œuvre：

NAME TYPE DATA AGE
default-token-t7mbb kubernetes.io/service-account-token 3 62m

Modifier maintenant nginx Copie pour démarrer une utilisation Secret Pour le certificat dans HTTPS Le serveur et son port correspondant pour exposer （80 Et 443）De Service：

apiVersion: v1
kind: Service
metadata:
  name: my-nginx
  labels:
    run: my-nginx
spec:
  type: NodePort
  ports:
  - port: 8080
    targetPort: 80
    protocol: TCP
    name: http
  - port: 443
    protocol: TCP
    name: https
  selector:
    run: my-nginx
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  selector:
    matchLabels:
      run: my-nginx
  replicas: 1
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      volumes:
      - name: secret-volume
        secret:
          secretName: nginxsecret
      - name: configmap-volume
        configMap:
          name: nginxconfigmap
      containers:
      - name: nginxhttps
        image: bprashanth/nginxhttps:1.0
        ports:
        - containerPort: 443
        - containerPort: 80
        volumeMounts:
        - mountPath: /etc/nginx/ssl
          name: secret-volume
        - mountPath: /etc/nginx/conf.d
          name: configmap-volume

À propos de nginx-secure-app Liste de contrôle,Voici quelques points importants：

• Il va Deployment Et Service Le Protocole de .
• Nginx Serveur via 80 Traitement des ports HTTP Flux,Adoption 443 Traitement des ports HTTPS Flux,Et Nginx Service Les deux ports sont exposés .
• Chaque conteneur peut être monté /etc/nginx/ssl Clé d'accès au volume pour . Les volumes et les clés sont requis à Nginx Configuré avant le démarrage du serveur .

$ kubectl delete deployments,svc my-nginx; kubectl create -f ./nginx-secure-app.yaml

À ce moment - là,,Vous pouvez accéder à Nginx Serveur.

kubectl get pods -o yaml | grep -i podip
    podIP: 10.244.3.5
node $ curl -k https://10.244.3.5
...
<h1>Welcome to nginx!</h1>

Notez la dernière étape de notre offre -k Exécution des paramètres curl Ordre de,C'est parce qu'au moment de la production du certificat, On ne sait rien sur la course nginx De Pod Informations sur,Donc il a dû faire curl Ignorer la commande CName Cas d'inadéquation. En créant Service,Nous sommes connectés à CName Avec Service Interrogé par Pod Utilisation réelle DNS Nom. Passons d'un Pod Pour tester（Pour plus de commodité, Le même Secret,Pod Utiliser uniquement nginx.crt Pour visiter Service）：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: curl-deployment
spec:
  selector:
    matchLabels:
      app: curlpod
  replicas: 1
  template:
    metadata:
      labels:
        app: curlpod
    spec:
      volumes:
      - name: secret-volume
        secret:
          secretName: nginxsecret
      containers:
      - name: curlpod
        command:
        - sh
        - -c
        - while true; do sleep 1; done
        image: radial/busyboxplus:curl
        volumeMounts:
        - mountPath: /etc/nginx/ssl
          name: secret-volume

Puis exécutez la commande suivante：

$ kubectl apply -f ./curlpod.yaml
$ kubectl get pods -l app=curlpod

Les résultats sont les suivants：

NAME READY STATUS RESTARTS AGE
curl-deployment-1515033274-1410r 1/1 Running 0 1m

kubectl exec curl-deployment-1515033274-1410r -- curl https://my-nginx --cacert /etc/nginx/ssl/tls.crt
...
<title>Welcome to nginx!</title>
...

2.5、Exposition Service

Pour certaines parties de la demande ,Vous voudrez peut - être Service Exposition à un extérieur IP Adresse. Kubernetes Deux implémentations sont prises en charge：NodePort Et LoadBalancer. Créé dans le paragraphe précédent Service Utilisé NodePort,Donc,, Si votre noeud a un réseau public IP,Alors Nginx HTTPS La réplique est déjà capable de gérer le trafic sur Internet .

$ kubectl get svc my-nginx -o yaml | grep nodePort -C 5

$ kubectl get nodes -o yaml | grep ExternalIP -C 1

Recréer un Service Pour utiliser l'équilibreur de charge Cloud . Oui. my-nginx Service De Type Par NodePort Modifier comme suit: LoadBalancer：

$ kubectl edit svc my-nginx
$ kubectl get svc my-nginx

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
my-nginx LoadBalancer 10.0.162.149 xx.xxx.xxx.xxx 8080:30163/TCP

In EXTERNAL-IP Dans la colonne IP L'adresse peut être consultée sur le réseau public .CLUSTER-IP Seulement à partir du cluster / Accès au réseau privé Cloud .

Attention!,In AWS Allez.,Type LoadBalancer Le service pour créer un ELB,Et ELB Utiliser le nom d'hôte（C'est long.）,Au lieu de IP. ELB Le nom d'hôte de est trop long pour s'adapter à la norme kubectl get svc La sortie de, Il faut donc passer par l'exécution kubectl describe service my-nginx Commande pour le voir. Vous pouvez voir quelque chose comme：

Il est important de noter qu'il y a Service Le cas d'utilisation de spec Définition moyenneselector. L'un d'eux n'a passelectorCréé Service L'objet final correspondant n'est pas non plus créé.Cela permet à l'utilisateur de cartographier manuellement le service à un paramètre spécifique.Non. selector Une autre possibilité est que vous utilisez strictement type: ExternalNamePour marquer.

Trois、Service Et Label

Service Par un groupe de Pod Routage des communications.Service Est une abstraction,Il permet Pod La mort et Kubernetes Copie moyenne, Sans affecter l'application .Dans la dépendance Pod ( Comme les composants avant et arrière d'une application ) La découverte et le routage sont effectués par Kubernetes Service Traitement.

Service Correspond à un ensemble de Pod Est d'utiliser Étiquettes(Label)Et sélecteur(Selector), Ils sont autorisés à Kubernetes Un primitif de regroupement dans lequel les objets sont logiquement manipulés .Étiquettes(Label) Est une clé attachée à un objet /Paires de valeurs,Il peut être utilisé de plusieurs façons:

• Spécifié pour le développement , Objet testé et produit
• Étiquette de version intégrée
• Utiliser Label Classification des objets

Étiquettes(Label) Peut être attaché à un objet lors de sa création ou après . Ils peuvent être modifiés à tout moment .

Résumé

Contenu de cette section,Il explique principalement service Module, Et son étiquette associée ,Et service Comment exposer un cluster à l'extérieur ,Il y en a encore beaucoup.,La création n'est pas facile,J'espère que vous me soutiendrez.