fonctionnement automatique et le maintien
plate - forme (ansible, git, gitlab ce, docker , Jenkins, elk)
Automation (outils / scripts)
Récipient (docker / K8S)
virtualisation
docker différence et machines virtuelles une
utilisation plus efficace des ressources. Une machine virtuelle est un système complet, le récipient est juste un processus.
VM démarrage lent, le conteneur est un deuxième niveau
cohérent environnement d' exécution
CI / CD
concepts de base de conteneur
Image miroir
(1) est mise en miroir d' un système de fichier spécial. Il est nécessaire en plus de fournir conteneur pour exécuter des programmes, des bibliothèques, des ressources et d' autres fichiers de configuration, également contient un certain nombre de paramètres de configuration pour préparer le temps d'exécution (par exemple des variables d'environnement). L' image ne contient pas de données dynamiques, son contenu ne sera pas modifié après la construction.
(2) utilise un miroir AUFS, structure à plusieurs niveaux. Lors de la construction du miroir, construira une couche, la couche précédente est la base de cette dernière couche. Chaque couche que vous avez construit ne changera pas, tout changement du niveau ne se produit que dans son propre cette couche. Mirroring est en lecture seule. Lorsque vous créez une nouvelle image, le contenu sous - jacent inchangé, juste le miroir ajoute un nouveau niveau.
Container
(. 1) peut être considéré comme un conteneur en miroir accomplir un , la mise en miroir est accessible en écriture. Juste un processus de conteneur sur le système d'exploitation, le processus est terminé la sortie de volonté. Ne présumez pas que le conteneur existera toujours, devrait supposer qu'il va s'effondrer à tout moment. Une fois que le conteneur est un échec, ne pas hésiter à le supprimer, puis commencer un.
(2) selon la revendication meilleures pratiques Docker, le conteneur ne doit pas écrire de données sur laquelle la couche de stockage, la couche de stockage pour maintenir le récipient sans état. Toutes les opérations d'écriture de fichiers, les données de volume doivent être utilisés (volume) ou hôte de répertoire obligatoire, la lecture et l' écriture de ces emplacements sauteront couche de stockage de conteneurs à lire et à écrire à l'hôte (ou stockage en réseau) se produit directement, et ses performances une plus grande stabilité. volume de données à vie est indépendante du récipient, qui meurent, le volume de données ne mourra pas.
Dépôt entrepôt
entrepôt entrepôt est un miroir, le miroir est responsable de la gestion des Docker (gestionnaire d'entrepôt similaire), chaque entrepôt peut contenir plusieurs étiquettes (Tag), chaque étiquette correspond à un miroir. Vous pouvez également créer votre propre entrepôt privé.
K8S composent
ce groupe se compose de deux parties:
Un noeud maître (nœud maître): les récipients utilisés pour le contrôle, la planification, les serveurs physiques générales,
un groupe de noeud noeud (calcul de noeud): noeud de charge de travail, qui est un conteneur spécifique peut être un serveur physique, l'hôte peut également être un nuage
Il a ajouté:
Pod est l' unité de fonctionnement de base Kubernetes. Un Pod représente un processus en cours d' exécution dans le cluster en son sein encapsule un ou plusieurs conteneurs sont étroitement liés. En plus du Pod, K8S il y a le concept d'un service, un service peut être considéré comme un ensemble d'interface d'accès externe pour fournir les mêmes services Pod.
Graphique K8S
Diagramme de flux de travail DESCRIPTION K8S
configuration de simples K8S et d' application
1, un K8S d'installation maître (node11: 192.168.4.11), installé en tant que noeud de menu fixe noeud
2, docker modifier le fichier de configuration, de sorte qu'il peut être utilisé sur référentiel privé miroir machine physique
[K8s_pkgs la racine @ node11] # vim / etc / sysconfig / Docker
OPTIONS = « - = SELinux-Activé false // Fermer ... SELinux
[la racine @ node11 k8s_pkgs] # /etc/docker/daemon.json Vim
{
« dans l'insécurité -registries ": [" 192.168.4.254:5000 « ]
}
#################################### #############################################
[root @ room9pc01 ImagesRF Libres de droits ] # images docker // machine physique (192.168.4.254) construction du référentiel d'image privée suivante
cvs ID TAG iMAGE TAILLE CRÉÉ
192.168.8.254:5000/mysql Dernières 7bb2586065cd il y a 10 jours membre 476,9 MB
192.168.8.254:5000/pod-infrastructure Dernières 99965fb98423 19. 208,6 MB mois il y a membre
192.168.8.254:5000/guestbook-php-frontend Dernières 47ee16830e89 2 ans il y a 510 membres MB
192.168.8.254:5000/tomcat-app Dernières il y a a29e200a18e9 358,2 MB 2 ans membre
Dernières 405a0b586f7e 192.168.8.254:5000/redis-master 419,1 MB il y a 3 ans Membre
depuis 192.168.8.254:5000/guestbook-redis-slave Dernières e0c36a1fa372 3 années 109,5 MB Membre
1
3, démarrer les services connexes
K8S-Master:
ETCD: une base de données, sauvegarder l'ensemble de l' état du cluster
Kube-apiserver: l' exécution d' instructions, fournit les seules opérations des ressources d'entrée, et d'assurer l' authentification, l' autorisation, le contrôle d'accès, l' enregistrement des API et des mécanismes de découverte
Kube contrôleur-manager: MT5 pratique www.gendan5.com gestionnaire de contrôle /mt5.html, est responsable du maintien de l'état du cluster, telles que la détection de défaut, l' extension automatique, renversement, etc.
Kube-planificateur: responsable de la planification des ressources, conformément à une politique d'ordonnancement prédéterminé pour l' envoi à la machine Pod appropriée
K8S-noeud:
kubelet: réception de noeud noeud d'instruction (client de K8S), responsable du maintien du cycle de vie du conteneur, est également responsable du volume (CVI) et réseau (CNI) Gestion
Kube-proxy: noeud proxy, est responsable de fournir cluster pour le service découverte de services internes et l' équilibrage de charge
docker: réel service de conteneurs, responsable de la gestion de la gestion de l' image réelle et Pod et conteneurs
[root @ node11 k8s_pkgs] # rpm -q docker
docker-1.13.1-91.git07f3374.el7.centos.x86_64
#MASTER的组件
[root @ node11 Kubernetes] # systemctl commencer ETCD
[root @ node11 Kubernetes] # systemctl permettent ETCD
[root @ node11 k8s_pkgs] # systemctl début Kube-apiserver.service
[root @ node11 k8s_pkgs] # systemctl activer Kube-apiserver.service
[root @ node11 k8s_pkgs] # systemctl début Kube-contrôleur manager.service
[root @ node11 k8s_pkgs] # systemctl activer Kube-contrôleur manager.service
[root @ node11 k8s_pkgs] # systemctl début Kube-scheduler.service
[root @ node11 k8s_pkgs] # systemctl permettent Kube-scheduler.service
#node的组件
[root @ node11 k8s_pkgs] # systemctl début docker
[root @ node11 k8s_pkgs] # systemctl permettent docker
[root @ node11 k8s_pkgs] # systemctl début kubelet.service
[root @ node11 k8s_pkgs] # systemctl permettent kubelet.service
[root @ node11 k8s_pkgs] # systemctl début Kube-proxy.service
[racine @ node11 k8s_pkgs] # systemctl permettent Kube-proxy.service
4, les changements de configuration, redémarrez le service
[k8s_pkgs la racine @ node11] LS # / etc / Kubernetes /
apiserver Controller config-Proxy Gestionnaire kubelet Scheduler
[la racine @ node11 k8s_pkgs] # vim / etc / Kubernetes / apiserver
KUBE_API_ADDRESS = "- dans l'insécurité, l'bind-address = 0.0.0.0" // permettent tout hôte peut accéder à la machine
à supprimer de KUBE_ADMISSION_CONTROL ServiceAccount // supprimer le compte de service
[root @ node11 k8s_pkgs] # systemctl restart Kube-apiserver.service
[root @ node11 k8s_pkgs] # vim / etc / Kubernetes / config
KUBE_MASTER = "- maître = http://192.168.4.11:8080 " maître désigné // ip adresse
[root @ node11 k8s_pkgs] # vim / etc / Kubernetes / kubelet
KUBELET_ADDRESS = "- address = 0.0.0.0" // exécute client personnalisé sur toutes les adresses, facile à maîtriser la gestion à distance
KUBELET_API_SERVER = « - API serveurs = http://192.168.4.11:8080 » // spécifié par l'adresse du client et du serveur IP
KUBELET_POD_INFRA_CONTAINER = "- pod-infra- conteneur image = 192.168.4.254: 5000 / pod infrastructure" // Spécifier POD (groupe de conteneurs) du référentiel d'image propriétaire
[racine @ node11 k8s_pkgs] # systemctl restart kubelet
5, tests d'application tomcat + mysql
[Root @ node11 tomcat_mysql] # vim mysql-rc.yaml / mysql créer les déclarations de fichiers rc
apiVersion: v1
type: // déclaration de type ReplicationController
les métadonnées:
nom: mysql // rc Nom
spec: // fichier déclare
répliques: 1 // les étiquettes sont nécessaires app: le nombre de pod mysql est 1
sélecteur: // sélecteurs rechercher des étiquettes application: le pod mysql
app: mysql
modèle: // Si le nombre de gousses de non-conformité, créer satisfaisant les conditions suivantes pod
les métadonnées:
étiquettes:
App : MySQL
spec:
Conteneurs:
- Nom: MySQL
Image: // 192.168.4.254:5000/mysql entrepôt privé mise en miroir des
ports:- containerPort: 3306
env: - Nom: MYSQL_ROOT_PASSWORD
valeur: "123456"
- containerPort: 3306
# Créer des ressources selon le fichier YAML
[racine @ node11 tomcat_mysql] # kubectl créer -f mysql-rc.yaml // start conteneur rc un nom pour le mysql
[root @ node11 tomcat_mysql] # kubectl get rc // obtient des informations
NOM DÉSIRÉ PRÊT de AGE COURANT
mysql. 1. 1. 1 IH
[la racine @ node11 tomcat_mysql] GET # kubectl // le module comprenant un groupe pod de conteneurs et conteneurs d'infrastructure mysql conteneur
NOM redémarrages AGE STATUS READY
mysql marche 1/1 0 IH-v0pdr
Après pod # vue, un message de vue détaillée
[root @ node11 tomcat_mysql] # kubectl décrire pod mysql-v0pdr // pod informations Check
[root @ node11 tomcat_mysql] # docker ps
# Créer un service mysql
[root @ node11 tomcat_mysql] # vim mysql-svc.yaml // script de démarrage de service de conteneurs mysql
apiVersion: v1
genre: service
des métadonnées:
nom: mysql
spec:
les ports:
- Port: 3306
Selector:
App: mysql
[root @ node11 tomcat_mysql] -f # kubectl Créer mysql-svc.yaml // conteneur MySQL démarrer le service MySQL
[root @ node11 tomcat_mysql] # kubectl get services // voir le début du service
NOM CLUSTER le EXTERNE PORT-IP - IP (S) AGE
Kubernetes 10.254.0.1 <aucun> 443 / TCP 4H
MySQL 10.254.164.241 <aucun> 3306 / TCP 7Mservice MySQL ne EXTERNE-IP, parce que les utilisateurs ne ont pas accès directement mysql, mais l'accès aux services Web
# Création d' un service Web
[racine @ node11 tomcat_mysql] # vim MyWeb-rc.yaml // script de démarrage de conteneur Comcat
genre: ReplicationController
les métadonnées:
Nom: myweb
spec:
Répliques: 5 // nombre de copies de
sélection:
App: myweb
Modèle:
les métadonnées:
étiquettes:
Application: myweb
spec:
Conteneurs:
- Nom: myweb
Image: // 192.168.4.254:5000/tomcat-app privé mirroring entrepôt
ports:- containerPort: 8080
env: - Nom: // MYSQL_SERVICE_HOST connexion mysql navire
valeur: 'mysql' - Nom: MYSQL_SERVICE_PORT
valeur: '3306'
[root @ node11 tomcat_mysql] # kubectl créer -f MyWeb-rc.yaml
[root @] # node11 tomcat_mysql kubectl get rc
NOM COURANT READY DÉSIRÉ AGE
mysql 1 1 1 2h
MyWeb 5 5 5 35s
[ root @ node11 tomcat_mysql] # kubectl get PODS
NOM PRÊT AGE STATUT REDEMARRAGES
mysql-v0pdr 1/1 0 Exécution 2h
MyWeb-jsb1k 1/1 0 Exécution 47s
MyWeb-kl2gk 1/1 0 Exécution 47s
MyWeb-l1qvq 1/1 0 en cours 47s
MyWeb-p0n7g 1/1 0 Exécution 47s
MyWeb-sh6jl 1/1 Exécution 0 47s
[root @ node11 tomcat_mysql] # vim MyWeb-svc.yaml // MyWeb服务脚本
apiVersion: v1
type: service de
métadonnées:
nom: myweb
spécification:
Type : NodePort
ports:- Port: 8080 // suivant deux lignes représente un nœud d'accès 30001, sera mis en correspondance avec 8080 pod de
nodePort: 30001
Sélecteur:
App: myweb
[root @ node11 tomcat_mysql] # kubectl l' option Créer -f MyWeb-svc.yaml // MyWeb démarrer le service
[tomcat_mysql la racine @ node11] # kubectl GET-service
NOM CLUSTER EXTERNAL l'IP-IP-PORT (S) AGE
Kubernetes 10.254.0.1 <aucun> 443 / TCP 4 H
MySQL 10.254.164.241 <aucun> 3306 / 30m TCP
MyWeb 10.254.222.24 <nœuds > 8080: 30001 / TCP le 26S
[la racine @ node11 tomcat_mysql] # Docker PS | awk 'Imprimer $ {2}'
ID
192.168.4.254:5000/tomcat-app
192.168.4.254:5000/tomcat-app
192.168.4.254:5000/tomcat -app
192.168.4.254:5000/tomcat-app
192.168.4.254:5000/tomcat-app
192.168.4.254:5000/pod-infrastructure // MyWeb conteneur d'infrastructure
192.168.4.254:5000/pod-infrastructure
192.168.4.254:5000/pod-infrastructure
192.168.4.254:5000/pod-infrastructure
192.168.4.254:5000/pod-infrastructure
192.168.4.254:5000/mysql
192.168.4.254:5000/pod -Infrastructure // conteneur d'infrastructure mysql
#myweb lancera cinq pod et 10 conteneurs, parce que chacun a besoin de nacelle pour avoir un conteneur d'infrastructure, doivent également avoir un vaisseau de travail, l' empathie mysql va commencer une nacelle et un récipient
- Port: 8080 // suivant deux lignes représente un nœud d'accès 30001, sera mis en correspondance avec 8080 pod de
- containerPort: 8080
l' accès du navigateur http://192.168.4.11:30001/
après avoir supprimé un conteneur, K8S trouverez le nombre de conteneurs ont été moins déclaration rc, il crée automatiquement nouveau conteneur correspondant
[Tomcat_mysql la racine @ node11] -f RM # Docker c1bf3822f088
[la racine @ node11 tomcat_mysql] PS # Docker
. 1
2
si vous voulez régler dynamiquement le nombre de la nacelle, mais le nombre peut être modifié rc
[Root @ node11 tomcat_mysql] # kubectl échelle --replicas = 3 replicationcontroller MyWeb // MyWeb le nombre de conteneurs 3 est ajusté à
[la racine @ node11 tomcat_mysql] RC # kubectl GET
NOM DÉSIRÉ READY COURANT de AGE
MySQL. 1. 1. 1 IH
MyWeb. 3. 3 36M. 3
[la racine @ node11 tomcat_mysql] GET # kubectl POD
NOM AGE redémarrages l'état PRETE
MySQL-58m hg9z0 1/1 0 Exécution
MyWeb Rodage 3g6rz 1/1 0 32M
MyWeb cours-90jts 1/1 0 32M
MyWeb-rvrr1 1/1 0 32M Courir
[la racine @ node11 tomcat_mysql] PS # docker -a | awk '{2} Imprimer $' // ajuste automatiquement le nombre de docker
ID
192.168.4.254:5000/tomcat-app
192.168.4.254:5000/tomcat-app
192.168 .4.254: 5000 / Tomcat App-
192.168.4.254:5000/pod-infrastructure
192.168.4.254:5000/pod-infrastructure
192.168.4.254:5000/pod-infrastructure
192.168.4.254:5000/mysql
192.168.4.254:5000/pod-infrastructure
Supprimer un service (pod également connu sous le nom de micro-services), rc
[root @ node11 tomcat_mysql] # kubectl supprimer le service mysql le
service "mysql" supprimé
[root @ node11 tomcat_mysql] # kubectl Service MyWeb suppression de
service "MyWeb" supprimé
[root @ node11 tomcat_mysql] # kubectl suppression rc mysql
replicationcontroller "mysql" supprimé
racine [ @ node11 tomcat_mysql] # kubectl suppression rc MyWeb
replicationcontroller "MyWeb" supprimé
racine [@ node11 tomcat_mysql] # docker ps //无容器运行
php-REDIS maître de
# Redis-maître
[root @ node11 php_redis] # ls
frontend-controller.yaml Redis-maître-esclave controller.yaml Redis-controller.yaml
frontend-service.yaml Redis-maître-esclave service.yaml Redis-service.yaml
[root @ node11 php_redis] # vim Redis-master-controller.yaml
piVersion: v1
genre: ReplicationController
métadonnées:
nom: Redis-maître
étiquettes:
nom: Redis-maître
spécifications:
répliques: 1
sélecteur:
nom: Redis-maître
modèle:
métadonnées :
étiquettes:
nom: Redis-maître
spécifications:
conteneurs:
- Nom: maître d'
image: 192.168.4.254:5000/redis-master
ports:- containerPort: 6379
[root @ node11 php_redis] # kubectl créer -f Redis-master-controller.yaml
[root @] # node11 php_redis vim Redis-master-service.yaml
apiVersion: v1
genre: service
métadonnées:
nom: Redis-maître
étiquettes :
nom: Redis-maître
spec:
ports:- Port: 6379
targetPort: 6379
sélecteur:
nom: Redis-maître
[root @ node11 php_redis] # kubectl créer -f Redis-master-service.yaml
- Port: 6379
- containerPort: 6379
# Redis-esclave
[root @ node11 php_redis] # vim Redis-esclave controller.yaml
apiVersion: v1
genre: ReplicationController
métadonnées:
nom: Redis-esclave
étiquettes:
nom: Redis-esclave
spec:
répliques: 2
sélecteur:
nom: redis- esclave
template:
métadonnées:
étiquettes:
nom: Redis-esclave
spec:
conteneurs:
- Nom: esclave d'
image: 192.168.4.254:5000/guestbook-redis-slave
env:- Nom: GET_HOSTS_FORM
Valeur: env
ports: - containerPort: 6379
[root @ node11 php_redis] # vim Redis-esclave service.yaml
apiVersion: v1
genre: service
métadonnées:
nom: Redis-esclave
étiquettes:
nom: Redis-esclave
spec:
ports:- Port: 6379
sélecteur:
nom: Redis-esclave
[root @ node11 php_redis] # kubectl créer -f Redis-esclave service.yaml
[root @ node11 php_redis] # kubectl get rc
NOM DÉSIRÉ COURANT PRÊT AGE
Redis-master 1 1 1 9 m
Redis-esclave 2 2 2 1 m
[root @ node11 php_redis] # kubectl get pod
NOM READY STATUT redémarrages AGE
Redis-master-cn208 1/1 Exécution 0 9 m
Redis-esclave dctvw 1/1 0 Exécution 1m
Redis-esclaves gxtfs 1 / 1 Exécution 0 1m
[root @ node11 php_redis] # kubectl obtenir le service
NOM EXTERNE IP CLUSTER IP PORT (S) AGE
Kubernetes 10.254.0.1 <aucun> 443 / TCP 9h
Redis-maître 10.254.174.239 <none> 6379 / TCP 8 m
Redis-esclave 10.254.117.213 <aucun> 6379 / TCP 42s
- Port: 6379
- Nom: GET_HOSTS_FORM
#frontend (前端)
[root @ node11 php_redis] # vim frontend-controller.yaml
apiVersion: v1
genre: ReplicationController
métadonnées:
nom: frontend
étiquettes:
nom: frontend
spécifications:
répliques: 3
sélecteur:
nom: frontend
modèle:
métadonnées:
étiquettes:
nom: frontend
spécifications:
conteneurs:
- Nom: frontend
Image: 192.168.4.254:5000/guestbook-php-frontend
env:- Nom: GET_HOSTS_FROM
Valeur: env
ports:- containerPort: 80
-
[root @ node11 php_redis] # kubectl créer -f frontend-controller.yaml
[root @ node11 php_redis] # vim frontend-service.yaml
apiVersion: v1
genre: service
métadonnées:
Nom: frontend
étiquettes:
nom: frontend
spec:
Type: NodePort
ports:- Port: 80
nodePort: 30001
sélecteur:
nom: frontend
[root @ node11 php_redis] # kubectl créer frontend-service.yaml -f
[racine @ node11 php_redis] # kubectl get rc
NOM DÉSIRÉ COURANT READY AGE
frontend 3 3 3 2m
Redis-maître 1 1 1 14m
Redis-esclave 2 2 2 6 m
[root @ node11 php_redis] # kubectl get pod
ÉTAT NOM PRÊT redémarrages AGE
frontend-3dqhv 1/1 0 Exécution 2m
frontend-ct7qw 1/1 0 Exécution 2m
frontend-tz3p4 1/1 Exécution 0 2m
Redis-master-cn208 1/1 Exécution 0 14m
Redis-esclave dctvw 1/1 0 Exécution 6m
Redis-esclave-gxtfs 1/1 0 Exécution 6 m
[root @ node11 php_redis] # kubectl obtenir le service
NOM CLUSTER-IP PORT EXTERNE IP (S) AGE
frontend 10.254.210.184 <noeuds> 80: 30001 / TCP 42s
Kubernetes 10.254.0.1 <aucun> 443 / TCP 9h
Redis-maître 10.254.174.239 <aucun> 6379 / TCP 13m
REDIS-esclave 10.254.117.213 <aucun> 6379 / TCP 5m
- Port: 80
- Nom: GET_HOSTS_FROM
http://192.168.4.11:30001/ d'accès du navigateur, séparés de la lecture et de l'écriture principale Redis de test