[Cloud Native] [k8s] Jour 83 d'Apprentissage Opérations et Maintenance du Novice au Grand Maître ------- Gestion des applications Kubernetes basées sur Helm

Minikube est un outil qui peut exécuter rapidement un seul point de Kubernetes localement, pour les utilisateurs essayant Kubernetes ou développant quotidiennement. Ne pas utiliser dans des environnements de production.

Documentation officielle : Outils d'installation | Kubernetes

(2) Paquet binaire

Téléchargez le package binaire de distribution à partir de la version officielle et déployez manuellement chaque composant pour former un cluster Kubernetes. Cette méthode est actuellement principalement utilisée dans les environnements de production d’entreprise.

lien de téléchargement:

https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG-1.11.md#v1113

(3) Kubeadm

Kubeadm est un outil lancé par Google spécifiquement pour le déploiement rapide de clusters Kubernetes. Pendant le processus de déploiement du cluster, vous pouvez initialiser le nœud maître via kubeadm init, puis utiliser kubeadm join pour ajouter d'autres nœuds au cluster.

1. Kubeadm peut exécuter rapidement un cluster à disponibilité minimale grâce à une configuration simple. Sa conception initiale était axée sur l'installation et l'exécution rapides du cluster, plutôt que sur la préparation étape par étape de l'environnement de chaque nœud. De même, les différents plug-ins utilisés dans le cluster kubernetes ne sont pas au centre de kubeadm, comme le tableau de bord WEB du cluster kubernetes, l'activité du cluster de surveillance prometheus, etc. Le but de l'application kubeadm est de servir de base à tous les déploiements et de faciliter le déploiement de clusters Kubernetes via kubeadm.

2. Le déploiement simple et rapide de Kubeadm peut s’appliquer aux trois aspects suivants :

·Les nouveaux utilisateurs peuvent rapidement créer et comprendre Kubernete à partir de kubeadm.

·Les utilisateurs familiers avec Kubernetes peuvent utiliser kubeadm pour créer rapidement des clusters et tester leurs applications.

·Les projets à grande échelle peuvent utiliser kubeadm avec d'autres outils d'installation pour former un système plus complexe.

·Documents officiels:

Kubeadm | Kubernetes
Installation de kubeadm | Kubernetes

2. Déployer le cluster K8S basé sur kubeadm

(1) Préparation de l'environnement

adresse IP	Nom du processeur	Composants
192.168.100.131	k8s-maître	kubeadm、kubelet、kubectl、docker-ce
192.168.100.132	k8s-node01	kubeadm、kubelet、kubectl、docker-ce
192.168.100.133	k8s-noeud02	kubeadm、kubelet、kubectl、docker-ce

Remarque : CPU recommandé pour toutes les configurations d'hôte : 2C+ Mémoire : 2G+

1. Configuration d'initialisation de l'hôte

Désactivez le pare-feu et Selinux sur toutes les configurations d'hôte

[root@localhost ~]# setenforce 0

[root@localhost ~]# iptables -F

[root@localhost ~]# systemctl stop firewalld

[root@localhost ~]# systemctl disable firewalld

[root@localhost ~]# systemctl stop NetworkManager

[root@localhost ~]# systemctl disable NetworkManager

[root@localhost ~]# sed -i '/^SELINUX=/s/enforcing/disabled/' /etc/selinux/config

2. Configurez le nom d'hôte et liez les hôtes. Différents noms d'hôte sont différents.

[root@localhost ~]# nom d'hôte k8s-master

[root@localhost ~]# bash

[root@k8s-master ~]# cat << EOF >> /etc/hosts

192.168.100.131 k8s-master

192.168.100.132 k8s-node01

192.168.100.133 k8s-node02

EOF

[root@localhost ~]# nom d'hôte k8s-node01

[root@k8s-node01 ~]# cat /etc/hosts

[root@localhost ~]# nom d'hôte k8s-node02

[root@k8s-node02 ~]#cat /etc/hosts

3. Initialisation de la configuration de l'hôte

[root@k8s-master ~]# yum -y install vim wget net-tools lrzsz

[root@k8s-master ~]# swapoff -a

[root@k8s-master ~]# sed -i '/swap/s/^/#/' /etc/fstab

[root@k8s-master ~]# cat << EOF >> /etc/sysctl.conf

net.bridge.bridge-nf-call-ip6tables = 1

net.bridge.bridge-nf-call-iptables = 1

EOF

[root@k8s-master ~]# modprobe br_netfilter

[root@k8s-master ~]# sysctl -p

4. Déployer l'environnement Docker

1) Déployez les environnements Docker sur trois hôtes respectivement, car l'orchestration des conteneurs par Kubernetes nécessite le support de Docker.

[root@k8s-master ~]# wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

[root@k8s-master ~]# yum install -y yum-utils device-mapper-persistent-data lvm2

2) Lorsque vous utilisez YUM pour installer Docker, il est recommandé d'utiliser la source YUM d'Alibaba.

[root@k8s-master ~]# yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

3) Vider le cache

[root@k8s-master ~]# miam nettoie tout && miam makecache rapidement

4) Démarrer le menu fixe

[root@k8s-master ~]# miam -y installer docker-ce

[root@k8s-master ~]# systemctl démarrer le docker

[root@k8s-master ~]# systemctl active docker

5) Accélérateur d'images (toutes les configurations d'hôte)

[root@k8s-master ~]# cat << FIN > /etc/docker/daemon.json

{ "registry-mirrors":[ "https://nyakyfun.mirror.aliyuncs.com" ]

}

FIN

6) Redémarrez le menu fixe

[root@k8s-master ~]# systemctl démon-reload

[root@k8s-master ~]# systemctl redémarrer le docker

(2) Déployer le cluster Kubernetes

1. Présentation des composants

Les trois nœuds doivent installer les trois composants suivants :

kubeadm : Installer les outils pour que tous les composants s'exécutent en tant que conteneurs

kubectl : outil API K8S de connexion client

kubelet : un outil qui s'exécute sur les nœuds node et sert à démarrer les conteneurs

2. Configurez la source Yum d'Alibaba Cloud

Lorsque vous utilisez YUM pour installer Kubernetes, il est recommandé d'utiliser la source YUM d'Alibaba.

[root@k8s-master ~]# ls /etc/yum.repos.d/

[root@k8s-master ~]# cat > /etc/yum.repos.d/kubernetes.repo

3. Installez Kubelet Kubeadm Kubectl

Toutes les configurations d'hôte

[root@k8s-master ~]# miam install -y kubelet-1.20.0 kubeadm-1.20.0 kubectl-1.20.0

[root@k8s-master ~]# systemctl active kubelet

[root@k8s-master ~]# version kubectl

Une fois que le kubelet vient d'être installé, il ne peut pas être démarré via systemctl start kubelet. Vous devez rejoindre le nœud ou l'initialiser en tant que maître avant de pouvoir le démarrer avec succès.

4. Configurez init-config.yaml

Kubeadm fournit de nombreux éléments de configuration. Les configurations Kubeadm sont stockées dans ConfigMap dans les clusters Kubernetes. Ces configurations peuvent également être écrites dans des fichiers de configuration pour faciliter la gestion d'éléments de configuration complexes. Le contenu de la configuration Kubeadm est écrit dans le fichier de configuration via la commande kubeadm config.

Installez sur le nœud maître. Le maître est défini sur 192.168.100.131. Créez le fichier init-config.yaml par défaut en suivant les instructions suivantes :

[root@k8s-master ~]# kubeadm config print init-defaults > init-config.yaml

configuration init-config.yaml

[root@k8s-master ~]# cat init-config.yaml

5. Installez le nœud maître

1) Tirez l'image requise

[root@k8s-master ~]# Liste des images de configuration kubeadm --config init-config.yaml

[root@k8s-master ~]# images de configuration kubeadm pull --config init-config.yaml

2) Installer le nœud matser

[root@k8s-master ~]# kubeadm init --config=init-config.yaml //Initialiser l'installation de K8S

3) Suivez les instructions

Par défaut, kubectl recherchera le fichier de configuration dans le répertoire .kube sous le répertoire personnel de l'utilisateur où il est exécuté. Voici une copie du admin.conf généré lors de l'étape [kubeconfig] lors de l'initialisation vers .kube/config

[root@k8s-master ~]# mkdir -p $HOME/.kube

[root@k8s-master ~]# cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

[root@k8s-master ~]# chown $(id -u):$(id -g) $HOME/.kube/config

Kubeadm n'inclut pas de plug-ins réseau lors de l'installation initiale, ce qui signifie qu'il n'a pas de fonctions réseau associées après l'initialisation. Par exemple, les informations sur le nœud affichées sur le nœud k8s-master sont à l'état « Non prêt » et le pod CoreDNS ne peut pas fournir de services, etc.

6. Installer le nœud de nœud

1) Selon les informations demandées lors de l'installation principale

[root@k8s-node01 ~]# kubeadm join 192.168.100.131:6443 --token abcdef.0123456789abcdef --discovery-token-ca-cert-hash sha256:78bdd0f01660f4e84355b70aa8807cf1d0d6325b0b 28502b29c241563e93b4ae

[root@k8s-master ~]# kubectl récupère les nœuds

[root@k8s-node02 ~]# kubeadm join 192.168.100.131:6443 --token abcdef.0123456789abcdef --discovery-token-ca-cert-hash sha256:78bdd0f01660f4e84355b70aa8807cf1d0d6325b0b 28502b29c241563e93b4ae

Opération principale :

[root@k8s-master ~]# kubectl récupère les nœuds

Comme mentionné précédemment, il n'y a aucune configuration liée au réseau lors de l'initialisation de k8s-master, il ne peut donc pas communiquer avec le nœud nœud, donc l'état est « NotReady ». Mais le nœud ajouté via kubeadm join est déjà visible sur k8s-master.

7. Installez la flanelle

La raison pour laquelle le nœud maître est NotReady est qu'aucun plug-in réseau n'est utilisé et que la connexion entre le nœud et le maître n'est pas normale pour le moment. Actuellement, les plug-ins réseau Kubernetes les plus populaires incluent Flannel, Calico, Canal et Weave. Ici, nous choisissons d'utiliser Flannel.

Tous les hôtes :

Le maître télécharge kube-flannel.yml, tous les hôtes téléchargent flannel_v0.12.0-amd64.tar, cni-plugins-linux-amd64-v0.8.6.tgz

[root@k8s-master ~]# chargement du docker < flannel_v0.12.0-amd64.tar

Plugin de téléchargement :

[root@k8s-master ~]# tar xf cni-plugins-linux-amd64-v0.8.6.tgz

[root@k8s-master ~]# cp flanelle /opt/cni/bin/

Le maître télécharge kube-flannel.yml

configuration de l'hôte maître :

[root@k8s-master ~]# kubectl apply -f kube-flannel.yml

[root@k8s-master ~]# kubectl récupère les nœuds

[root@k8s-master ~]# kubectl get pods -n kube-system

Déjà prêt

(3) Installer l'interface utilisateur du tableau de bord

1. Déployer le tableau de bord

Adresse de l'entrepôt github du tableau de bord : https://github.com/kubernetes/dashboard

Dans l'entrepôt de code, il existe des fichiers de déploiement associés qui donnent des exemples d'installation. Nous pouvons les obtenir directement et les déployer directement.

[root@k8s-master ~]# wget https://raw.githubusercontent.com/kubernetes/dashboard/master/aio/deploy/recommended.yaml

Par défaut, dans ce fichier de déploiement, un espace de noms distinct nommé kubernetes-dashboard sera créé et kubernetes-dashboard sera déployé sous cet espace de noms. L'image du tableau de bord provient du hub Docker officiel, vous n'avez donc pas besoin de modifier l'adresse de l'image, il suffit de l'obtenir directement depuis l'adresse officielle.

2. Ouvrez les paramètres du port

Par défaut, le tableau de bord n'ouvre pas les ports d'accès au monde extérieur. Pour simplifier l'opération ici, utilisez directement nodePort pour exposer ses ports et modifier la définition de la partie service :

Téléchargez des images pour tous les hôtes

[root@k8s-master ~]# docker pull kubernetesui/dashboard:v2.0.0

[root@k8s-master ~]# docker pull kubernetesui/metrics-scraper:v1.0.4

[root@k8s-master ~]# vim recommandé.yaml

3. Configuration des autorisations

Configurer les privilèges d'un super administrateur

[root@k8s-master ~]# vim recommandé.yaml

[root@k8s-master ~]# kubectl apply -f recommandé.yaml

[root@k8s-master ~]# kubectl obtenir des pods -n kubernetes-dashboard

[root@k8s-master ~]# kubectl obtient les pods -A -o large

4. Configuration du jeton d'accès

Utilisez Google Chrome pour tester l'accès https://192.168.100.131:32443

Vous pouvez voir que l'écran ci-dessus apparaît et nous devons saisir un fichier kubeconfig ou un jeton. En fait, lors de l'installation du tableau de bord, un compte de service a été créé pour nous par défaut et un jeton a été généré pour kubernetes-dashboard.

Nous pouvons obtenir le jeton sa via la commande suivante :

[root@k8s-master ~]# kubectl décrire secret -n kubernetes-dashboard $(kubectl get secret -n kubernetes-dashboard |grep kubernetes-dashboard-token | awk '{print $1}') |grep token | awk '{print $2}'

Entrez le jeton obtenu

Afficher la présentation du cluster :

Afficher les rôles du cluster :

Afficher les espaces de noms de cluster :

Afficher les nœuds du cluster :

Afficher les pods de cluster :

(4) Déploiement du service de serveur de métriques

1. Téléchargez l'image sur le nœud Node

heapster a été remplacé par metrics-server, qui est un outil d'acquisition d'indicateurs de ressources dans K8S

Sur tous les nœuds

[root@k8s-node01 ~]# docker pull bluersw/metrics-server-amd64:v0.3.6

[root@k8s-node01 ~]# balise docker bluersw/metrics-server-amd64:v0.3.6 k8s.gcr.io/metrics-server-amd64:v0.3.6

2. Modifier les paramètres de démarrage du serveur API Kubernetes

Ajoutez les options de configuration suivantes à l'élément kube-apiserver. Après modification, l'apiserver redémarrera automatiquement.

[root@k8s-master ~]# vim /etc/kubernetes/manifests/kube-apiserver.yaml

3. Déployer sur Master

[root@k8s-master ~]# wget https://github.com/kubernetes-sigs/metrics-server/releases/download/v0.3.6/components.yaml

Modifiez le script d'installation :

[root@k8s-master ~]# vim composants.yaml

[root@k8s-master ~]# kubectl create -f composants.yaml

Attendez 1 à 2 minutes pour voir les résultats

[root@k8s-master ~]# nœuds supérieurs kubectl

Revenez à l’interface du tableau de bord et vous pourrez voir l’utilisation du processeur et de la mémoire.

(5) Introduction au gestionnaire de packages d'application Helm

1. Pourquoi avez-vous besoin de Helm ?

Les services d'application déployés sur Kubernetes sont composés de descriptions de ressources spécifiques, notamment le déploiement, le service, etc. Chaque objet ressource est enregistré dans son propre fichier ou écrit collectivement dans un fichier de configuration. Déployez-le ensuite via la commande kubectl apply –f demo.yaml.

Si le système métier ne comprend qu'un ou plusieurs de ces services, alors la méthode de gestion du déploiement ci-dessus est suffisante.

Pour un système d'entreprise complexe, il y aura de nombreux fichiers de description de ressources similaires à ceux ci-dessus. Par exemple, une application d'architecture de microservices peut avoir jusqu'à dix ou dizaines de services qui composent l'application. S'il est nécessaire de mettre à jour ou de restaurer une application, il peut être nécessaire de modifier et de maintenir un grand nombre de fichiers d'objets de ressources impliqués, et cette façon d'organiser et de gérer les applications devient insuffisante.

De plus, en raison du manque de gestion et de contrôle des versions d’applications publiées, la maintenance et les mises à jour des applications sur Kubernetes sont confrontées à de nombreux défis, principalement confrontés aux problèmes suivants :

Comment gérer ces services dans leur ensemble

Comment réutiliser efficacement ces fichiers de ressources

La gestion des versions au niveau de l'application n'est pas prise en charge

2. Introduction à Helm

Helm est un outil de gestion de packages Kubernetes. Tout comme les gestionnaires de packages sous Linux, tels que yum/apt-get, etc., Helm peut facilement déployer des fichiers yaml précédemment packagés sur Kubernetes.

Helm a 3 concepts importants :

helm : Un outil client en ligne de commande principalement utilisé pour la création, le packaging, la publication et la gestion des graphiques d'application Kubernetes.

Graphique : Répertoire ou package compressé, utilisé pour la description de l'application, composé d'une série de fichiers utilisés pour décrire les objets ressources k8s.

Release : entité de déploiement basée sur un graphique. Une fois qu'un graphique est exécuté par Helm, une version correspondante sera générée ; un véritable objet de ressource en cours d'exécution sera créé dans k8s.

Caractéristiques de la barre

        Un gestionnaire de packages développé pour Kubernetes. Chaque package est appelé un graphique, et un graphique est un répertoire (généralement, le répertoire sera empaqueté et compressé pour former un seul fichier au format nom-version.tar.gz pour une transmission facile. et stockage)

        Pour les éditeurs d'applications, Helm peut être utilisé pour empaqueter des applications, gérer les dépendances des applications, gérer les versions d'applications et publier des applications dans des entrepôts de logiciels.

        Pour les utilisateurs, après avoir utilisé Helm, ils n'ont plus besoin de comprendre la syntaxe Yaml de Kubernetes et d'écrire des fichiers de déploiement d'applications. Ils peuvent télécharger et installer les applications requises sur Kubernetes via Helm.

        Helm fournit des fonctions puissantes pour le déploiement, la suppression, la mise à niveau et la restauration de logiciels sur Kubernetes

3. Modifications de Helm V3

Le 13 novembre 2019, l'équipe Helm a publié la première version stable de Helm v3. Les principaux changements de cette version sont les suivants :

1) Modifications architecturales

Le changement le plus évident est la suppression de Tiller

2) Les noms de versions peuvent être réutilisés dans différents espaces de noms

3) Prise en charge de la poussée du graphique vers le port de l'entrepôt miroir Docker

4) Utilisez JSONSchema pour vérifier les valeurs du graphique

5) Autres

Helm CLI individuel renomme pour mieux coordonner la formulation avec d'autres gestionnaires de packages

helm delete` a été renommé `helm uninstall

helm inspect a été renommé en helm show

helm fetch a été renommé en helm pull

Cependant, les anciennes commandes ci-dessus peuvent toujours être utilisées.

La commande helm serve utilisée pour créer temporairement le référentiel de graphiques localement a été supprimée.

Créer automatiquement des espaces de noms

Helm 2 a créé l'espace de noms lors de la création d'une distribution dans un espace de noms qui n'existait pas. Helm 3 suit le comportement des autres objets Kubernetes et renvoie une erreur si l'espace de noms n'existe pas.

Requirements.yaml n'est plus nécessaire, les dépendances sont définies directement dans chart.yaml.

(6) Déploiement du gestionnaire de packages d'application Helm

1. Déployer l'outil client Helm

Adresse de téléchargement du client Helm : versions · helm/helm · GitHub

Décompressez le package de code source et déplacez-le vers le répertoire /usr/bin/.

[root@k8s-master ~]# wget https://get.helm.sh/helm-v3.5.2-linux-amd64.tar.gz

[root@k8s-master ~]# tar xf helm-v3.5.2-linux-amd64.tar.gz

[root@k8s-master ~]# cd linux-amd64/

[root@k8s-master linux-amd64]# ls

[root@k8s-master linux-amd64]# mv helm /usr/bin/

[root@k8s-master ~]# helm #Vérifiez si la commande helm est disponible

2. Commandes Helm couramment utilisées

Commande	décrire
créer	Créez un graphique et spécifiez un nom
dépendance	Gérer les dépendances des graphiques
obtenir	Téléchargez une version. Sous-commandes disponibles : tout, hooks, manifeste, notes, valeurs
histoire	Obtenir l'historique des versions
installer	Installer un graphique
liste	Liste des versions
emballer	Emballez le répertoire des graphiques dans un fichier d'archive de graphiques
tirer	Téléchargez le graphique depuis le référentiel distant et extrayez-le localement# helm pull stable/mysql --untar
dépôt	Ajoutez, répertoriez, supprimez, mettez à jour et indexez des référentiels de graphiques. Sous-commandes disponibles : ajouter, indexer, lister, supprimer, mettre à jour
retour en arriere	Restauration par rapport à la version précédente
recherche	Recherchez des graphiques en fonction de mots-clés. Sous-commandes disponibles : hub, repo
montrer	Afficher les détails du graphique. Sous-commandes disponibles : all, chart, readme, valeurs
statut	Afficher l'état d'une version nommée
modèle	Modèle de rendu local
désinstaller	Désinstaller une version
mise à niveau	Mettre à jour une version
version	Vérifier la version du client Helm

3. Configurer l'entrepôt de cartes national

L' entrepôt Microsoft ( Index of /kubernetes/charts/ ) est fortement recommandé. En gros, tous les graphiques du site officiel sont disponibles ici.

Entrepôt Alibaba Cloud ( https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts )

Entrepôt officiel ( Kubeapps | Accueil ) L'entrepôt de cartes officiel est un peu difficile à utiliser en Chine.

Ajouter un référentiel de graphiques

[root@k8s-master ~]# dépôt de barre ajouté stable http://mirror.azure.cn/kubernetes/charts

[root@k8s-master ~]# helm repo ajouter aliyun https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts

[root@k8s-master ~]# mise à jour du dépôt de barre

Afficher le référentiel de graphiques configuré

[root@k8s-master ~]# liste des dépôts de barre

Supprimez le dépôt :

[root@k8s-master ~]# helm repo supprimer aliyun

[root@k8s-master ~]# liste des dépôts de barre

4. Utilisez un graphique pour déployer une application Nginx

1) Créer un graphique

[root@k8s-master ~]# helm crée nginx

[root@k8s-master ~]# arbre nginx/

Explication détaillée:

nginx/

├── graphiques #dépend des fichiers de graphiques d'autres packages

├── Chart.yaml #Le fichier de description du graphique, comprenant l'adresse IP, les informations de version, etc.

├── modèles # Répertoire pour stocker les fichiers de modèles k8s

│ ├── déploiement.yaml #Créer un modèle yaml pour les ressources de déploiement k8s

│ ├── _helpers.tpl #Les fichiers commençant par un trait de soulignement peuvent être référencés par d'autres modèles

│ ├── hpa.yaml #Configurer les ressources de service, mémoire CPU

│ ├── ingress.yaml # Configuration d'entrée pour accéder au nom de domaine du service

│ ├── Fichier NOTES.txt #Description, le contenu affiché à l'utilisateur après l'installation de helm

│ ├── serviceaccount.yaml

│ ├── service.yaml #kubernetes Modèle yaml de service

│ └── épreuves

│ └── test-connection.yaml

└──values.yaml #Variables utilisées pour les fichiers modèles

2) Modifiez le type de service dans Values.yaml en NodePort

[root@k8s-master ~]# cd nginx/

[root@k8s-master nginx]# vim valeurs.yaml

3) Installez la tâche graphique (notez le dernier point de la commande)

[root@k8s-master nginx]# helm install -f valeurs.yaml

4) Voir la version

[root@k8s-master nginx]# helm ls #ou liste de helm

5) Supprimer la version

[root@k8s-master nginx]# helm supprimer nginx

6) Vérifiez l'état du pod

[root@k8s-master nginx]# kubectl obtenir le pod

[root@k8s-master nginx]# kubectl obtient pod -o large

7) Vérifiez l'état du SVC

[root@k8s-master nginx]# kubectl obtient svc

Visitez 192.168.100.132:30281

5. Utilisez le graphique pour déployer une application Tomcat

[root@k8s-master ~]# helm crée Tomcat

Création de Tomcat

[root@k8s-master ~]# cd tomcat/

Modifier les fichiers déploiement.yaml et service.yaml

[root@k8s-master tomcat]# vim templates/deployment.yaml

[root@k8s-master tomcat]# vim templates/service.yaml

Créer une version

[root@k8s-master tomcat]# helm install tomcat .

Voir la version

[root@k8s-master tomcat]# helm ls

Afficher les pods et les svc

[root@k8s-master tomcat]# kubectl obtenir le pod

[root@k8s-master tomcat]# kubectl obtient pod -o large

[root@k8s-master tomcat]# kubectl obtenir svc

Préparer la page de test

[root@k8s-master tomcat]# kubectl exec -it tomcat-67df6cd4d6-s7qxl /bin/bash

root@tomcat-67df6cd4d6-s7qxl:/usr/local/tomcat# mkdir webapps/ROOT

root@tomcat-67df6cd4d6-s7qxl:/usr/local/tomcat# echo "helm test1" > webapps/ROOT/index.jsp

[root@k8s-master tomcat]# kubectl exec -it tomcat-67df6cd4d6-tkp95 /bin/bash

root@tomcat-67df6cd4d6-tkp95:/usr/local/tomcat# mkdir webapps/ROOT

root@tomcat-67df6cd4d6-tkp95:/usr/local/tomcat# echo "helm test2" > webapps/ROOT/index.jsp

Test d'accès :

Visitez 192.168.100.132:32092

Visitez 192.168.100.133:32092

supprimer

[root@k8s-master tomcat]# helm supprimer tomcat

[root@k8s-master tomcat]# helm ls

Mise à niveau (réappliquer après avoir modifié le fichier yaml)

[root@k8s-master tomcat]# helm install tomcat .

[root@k8s-master tomcat]# helm ls

[root@k8s-master tomcat]# kubectl obtenir le pod

[root@k8s-master tomcat]# vim templates/deployment.yaml

[root@k8s-master tomcat]# mise à niveau de la barre tomcat.

[root@k8s-master tomcat]# kubectl obtenir le pod

[root@k8s-master tomcat]# helm ls

retour en arriere

[root@k8s-master tomcat]# helm rollback tomcat 1

[root@k8s-master tomcat]# helm ls

[root@k8s-master tomcat]# kubectl obtenir le pod

6. Modèles de rendu avec des variables

Testez si le modèle est normal

[root@k8s-master tomcat]# helm install --dry-run tomcat .

Définir les variables dans le fichier Values.yaml

[root@k8s-master tomcat]# valeurs de chat.yaml

[root@k8s-master tomcat]# cat templates/deployment.yaml

[root@k8s-master tomcat]# cat templates/service.yaml

Les variables des fichiers déploiement.yaml et service.yaml sont des valeurs prédéfinies et référencées dans valeurs.yaml.

Release.Name représente le nom après l'installation de Helm

[root@k8s-master tomcat]# helm supprimer tomcat

Supprimez tous les fichiers redondants du répertoire des modèles, ne laissant que deux fichiers de test.

[root@k8s-master tomcat]# modèles ls/